@eagleoutice/flowr 1.5.2 → 2.0.1

package/statistics/features/common-syntax-probability.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeCommonSyntaxTypeCounter = exports.appendCommonSyntaxTypeCounter = exports.updateCommonSyntaxTypeCounts = exports.emptyCommonSyntaxTypeCounts = void 0;
+/**
+ * Defines the type of syntax constructs that we track (e.g., true, false, 0, 1, T, F, conditions...)
+ */
+const numbers_1 = require("../../util/numbers");
+const summarizer_1 = require("../../util/summarizer");
+const convert_values_1 = require("../../r-bridge/lang-4.x/convert-values");
+function emptyCommonSyntaxTypeCounts(init = () => 0n) {
+    return {
+        total: init(),
+        multiple: init(),
+        empty: init(),
+        withArgument: init(),
+        noValue: init(),
+        singleVar: {},
+        number: {},
+        integer: {},
+        complex: {},
+        string: {},
+        logical: {},
+        call: {},
+        unnamedCall: init(),
+        binOp: {},
+        unaryOp: {},
+        other: {}
+    };
+}
+exports.emptyCommonSyntaxTypeCounts = emptyCommonSyntaxTypeCounts;
+function incrementEntry(map, key) {
+    map[key] = (map[key] ?? 0n) + 1n;
+}
+/**
+ * Updates the given counts based on the type of the given node.
+ */
+function updateCommonSyntaxTypeCounts(current, ...nodes) {
+    current.total++;
+    if (nodes.length === 0) {
+        current.empty++;
+        return current;
+    }
+    else if (nodes.length > 1) {
+        current.multiple++;
+        return current;
+    }
+    let node = nodes[0];
+    if (node.type === "RArgument" /* RType.Argument */) {
+        if (node.name !== undefined) {
+            current.withArgument++;
+        }
+        if (node.value !== undefined) {
+            node = node.value;
+        }
+        else {
+            current.noValue++;
+            return current;
+        }
+    }
+    switch (node.type) {
+        case "RString" /* RType.String */:
+            incrementEntry(current.string, node.content.str);
+            break;
+        case "RSymbol" /* RType.Symbol */:
+            incrementEntry(current.singleVar, node.content);
+            break;
+        case "RLogical" /* RType.Logical */:
+            incrementEntry(current.logical, node.content ? convert_values_1.RTrue : convert_values_1.RFalse);
+            break;
+        case "RNumber" /* RType.Number */:
+            if (node.content.complexNumber) {
+                incrementEntry(current.complex, node.content.num);
+            }
+            else if (node.content.markedAsInt) {
+                incrementEntry(current.integer, node.content.num);
+            }
+            else {
+                incrementEntry(current.number, node.content.num);
+            }
+            break;
+        case "RFunctionCall" /* RType.FunctionCall */:
+            if (node.flavor === 'unnamed') {
+                current.unnamedCall++;
+            }
+            else {
+                incrementEntry(current.call, node.functionName.content);
+            }
+            break;
+        case "RBinaryOp" /* RType.BinaryOp */:
+            incrementEntry(current.binOp, node.operator);
+            break;
+        case "RUnaryOp" /* RType.UnaryOp */:
+            incrementEntry(current.unaryOp, node.operator);
+            break;
+        default:
+            // for space reasons, we do not record the full lexeme!
+            if (node.lexeme) {
+                incrementEntry(current.other, node.lexeme);
+            }
+            break;
+    }
+    return current;
+}
+exports.updateCommonSyntaxTypeCounts = updateCommonSyntaxTypeCounts;
+function appendRecord(a, b) {
+    for (const [key, val] of Object.entries(b)) {
+        const get = a[key];
+        // we guard with array, to guard against methods like `toString` which are given in js
+        if (!get || !Array.isArray(get)) {
+            a[key] = [[(0, numbers_1.bigint2number)(val)]];
+            continue;
+        }
+        get.push([(0, numbers_1.bigint2number)(val)]);
+    }
+}
+function appendCommonSyntaxTypeCounter(a, b) {
+    a.total.push([(0, numbers_1.bigint2number)(b.total)]);
+    a.empty.push([(0, numbers_1.bigint2number)(b.empty)]);
+    a.multiple.push([(0, numbers_1.bigint2number)(b.multiple)]);
+    a.withArgument.push([(0, numbers_1.bigint2number)(b.withArgument)]);
+    a.noValue.push([(0, numbers_1.bigint2number)(b.noValue)]);
+    a.unnamedCall.push([(0, numbers_1.bigint2number)(b.unnamedCall)]);
+    appendRecord(a.singleVar, b.singleVar);
+    appendRecord(a.number, b.number);
+    appendRecord(a.integer, b.integer);
+    appendRecord(a.complex, b.complex);
+    appendRecord(a.string, b.string);
+    appendRecord(a.logical, b.logical);
+    appendRecord(a.call, b.call);
+    appendRecord(a.binOp, b.binOp);
+    appendRecord(a.unaryOp, b.unaryOp);
+    appendRecord(a.other, b.other);
+}
+exports.appendCommonSyntaxTypeCounter = appendCommonSyntaxTypeCounter;
+function summarizeRecord(a) {
+    return Object.fromEntries(Object.entries(a).map(([key, val]) => [key, (0, summarizer_1.summarizeMeasurement)(val.flat(), val.length)]));
+}
+function summarizeCommonSyntaxTypeCounter(a) {
+    return {
+        total: (0, summarizer_1.summarizeMeasurement)(a.total.flat(), a.total.length),
+        empty: (0, summarizer_1.summarizeMeasurement)(a.empty.flat(), a.empty.length),
+        multiple: (0, summarizer_1.summarizeMeasurement)(a.multiple.flat(), a.multiple.length),
+        withArgument: (0, summarizer_1.summarizeMeasurement)(a.withArgument.flat(), a.withArgument.length),
+        noValue: (0, summarizer_1.summarizeMeasurement)(a.noValue.flat(), a.noValue.length),
+        unnamedCall: (0, summarizer_1.summarizeMeasurement)(a.unnamedCall.flat(), a.unnamedCall.length),
+        singleVar: summarizeRecord(a.singleVar),
+        number: summarizeRecord(a.number),
+        integer: summarizeRecord(a.integer),
+        complex: summarizeRecord(a.complex),
+        string: summarizeRecord(a.string),
+        logical: summarizeRecord(a.logical),
+        call: summarizeRecord(a.call),
+        binOp: summarizeRecord(a.binOp),
+        unaryOp: summarizeRecord(a.unaryOp),
+        other: summarizeRecord(a.other)
+    };
+}
+exports.summarizeCommonSyntaxTypeCounter = summarizeCommonSyntaxTypeCounter;
+//# sourceMappingURL=common-syntax-probability.js.map

package/statistics/features/feature.d.ts

@@ -0,0 +1,182 @@
+/**
+ * This module holds the definition of what a {@link Feature} that can be extracted from an R AST is.
+ *
+ * Furthermore, it contains the definition of all features that are known in {@link ALL_FEATURES}.
+ *
+ * @module
+ */
+import type { EvalOptions } from 'xpath-ts2/src/parse-api';
+import type { MetaStatistics } from '../meta-statistics';
+import type { StatisticsSummarizerConfiguration } from '../summarizer/summarizer';
+import type { MergeableRecord } from '../../util/objects';
+import type { DataflowInformation } from '../../dataflow/info';
+import type { NormalizedAst } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+/**
+ * Maps each sub-feature name to the number of occurrences of that sub-feature.
+ * Allows for one nesting level to denote hierarchical features.
+ * <p>
+ * Since we are writing to files {@link process}, we only count feature occurrences (some feature/parts are not written to file)
+ */
+export type FeatureInfo = Record<string, unknown> & MergeableRecord;
+/**
+ * The information and context that a {@link FeatureProcessor} may operate in.
+ */
+export interface FeatureProcessorInput extends MergeableRecord {
+    /** The XML Document representing the parsed (non-normalized) R AST */
+    readonly parsedRAst: Document;
+    /** The R AST, after the normalization step */
+    readonly normalizedRAst: NormalizedAst;
+    /** The dataflow information for the given input */
+    readonly dataflow: DataflowInformation;
+    /** The filepath that the document originated from (if present, may be undefined if the input was provided as text). This can be relative to the common root directory of requests. */
+    readonly filepath: string | undefined;
+}
+/**
+ * A function that processes the analysis results of a document and returns the feature information.
+ */
+export type FeatureProcessor<T extends FeatureInfo> = (existing: T, input: FeatureProcessorInput) => T;
+/**
+ * A feature is something to be retrieved by the statistics.
+ *
+ * @typeParam T - The type of what should be collected for the feature
+ *
+ * @see ALL_FEATURES
+ */
+export interface Feature<T extends FeatureInfo> {
+    /** A descriptive, yet unique name of the feature */
+    readonly name: string;
+    /** A description of the feature */
+    readonly description: string;
+    /** A function that retrieves the feature in the document appends it to the existing feature set (we could use a monoid :D), the filepath corresponds to the active file (if any) */
+    process: FeatureProcessor<T>;
+    /**
+     * If present, this feature allows to post-process the results of the feature extraction (for the summarizer).
+     * <p>
+     * The extraction can use the output path to write files to, and should return the final output.
+     *
+     * @param featureRoot - The root path to the feature directory which should contain all the files the feature can write to (already merged for every file processed)
+     * @param info        - The feature statistic maps each file name/context encountered to the feature information as well as the meta statistics for the file
+     * @param outputPath  - The path to write the output to (besides what is collected in the output and meta information)
+     * @param config      - The configuration for the summarizer (e.g., to obtain the number of folders to skip for the feature root)
+     */
+    postProcess?: (featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration) => void;
+    /** Values to start the existing track from */
+    initialValue: T;
+}
+/**
+ * The source of truth for all features that are supported by the statistics.
+ */
+export declare const ALL_FEATURES: {
+    readonly usedPackages: Feature<import("ts-essentials").Writable<{
+        library: number;
+        require: number;
+        loadNamespace: number;
+        requireNamespace: number;
+        attachNamespace: number;
+        withinApply: number;
+        '::': number;
+        ':::': number;
+        '<loadedByVariable>': number;
+    }>>;
+    readonly comments: Feature<import("ts-essentials").Writable<{
+        totalAmount: number;
+        roxygenComments: number;
+        import: number;
+        importFrom: number;
+        importMethodsFrom: number;
+        importClassesFrom: number;
+        useDynLib: number;
+        export: number;
+        exportClass: number;
+        exportMethod: number;
+        exportS3Method: number;
+        exportPattern: number;
+    }>>;
+    readonly definedFunctions: Feature<import("ts-essentials").Writable<{
+        total: number;
+        lambdasOnly: number;
+        assignedFunctions: number;
+        nestedFunctions: number;
+        recursive: number;
+        deepestNesting: number;
+    }>>;
+    readonly usedFunctions: Feature<import("ts-essentials").Writable<{
+        allFunctionCalls: number;
+        args: Record<number, bigint | import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>>;
+        nestedFunctionCalls: number;
+        deepestNesting: number;
+        unnamedCalls: number;
+    }>>;
+    readonly values: Feature<import("ts-essentials").Writable<{
+        allNumerics: number;
+        imaginaryNumbers: number;
+        integers: number;
+        floatHex: number;
+        logical: number;
+        specialConstants: number;
+        strings: number;
+    }>>;
+    readonly assignments: Feature<import("ts-essentials").Writable<{
+        assignmentOperator: Record<string, bigint>;
+        assigned: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        deepestNesting: number;
+        nestedOperatorAssignment: number;
+    }>>;
+    readonly loops: Feature<import("ts-essentials").Writable<{
+        forLoops: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        forLoopVar: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        forBody: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        whileLoops: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        whileBody: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        repeatLoops: bigint;
+        repeatBody: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        breakStatements: number;
+        nextStatements: number;
+        implicitLoops: number;
+        nestedExplicitLoops: number;
+        deepestExplicitNesting: number;
+    }>>;
+    readonly controlflow: Feature<import("ts-essentials").Writable<{
+        ifThen: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        thenBody: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        ifThenElse: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        elseBody: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        nestedIfThen: number;
+        nestedIfThenElse: number;
+        deepestNesting: number;
+        switchCase: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+    }>>;
+    readonly dataAccess: Feature<import("ts-essentials").Writable<{
+        singleBracket: Record<number, bigint | import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>>;
+        doubleBracket: Record<number, bigint | import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>>;
+        chainedOrNestedAccess: number;
+        longestChain: number;
+        deepestNesting: number;
+        byName: number;
+        bySlot: number;
+    }>>;
+    readonly expressionList: Feature<import("ts-essentials").Writable<{
+        allExpressionLists: number;
+        deepestNesting: number;
+    }>>;
+    readonly variables: Feature<import("ts-essentials").Writable<{
+        numberOfVariableUses: number;
+        numberOfDefinitions: number;
+        numberOfRedefinitions: number;
+        unknownVariables: number;
+    }>>;
+};
+export type FeatureKey = keyof typeof ALL_FEATURES;
+export type FeatureValue<K extends FeatureKey> = ReturnType<typeof ALL_FEATURES[K]['process']>;
+/** If the user passes `all`, this should be every feature present in {@link ALL_FEATURES} (see {@link allFeatureNames})*/
+export type FeatureSelection = Set<FeatureKey>;
+export declare const allFeatureNames: Set<FeatureKey>;
+export type FeatureStatistics = {
+    [K in FeatureKey]: FeatureInfo;
+};
+export type FeatureStatisticsWithMeta = FeatureStatistics & {
+    stats: MetaStatistics;
+};
+export interface Query {
+    select(options?: EvalOptions): Node[];
+}

package/statistics/features/feature.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * This module holds the definition of what a {@link Feature} that can be extracted from an R AST is.
+ *
+ * Furthermore, it contains the definition of all features that are known in {@link ALL_FEATURES}.
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allFeatureNames = exports.ALL_FEATURES = void 0;
+const used_packages_1 = require("./supported/used-packages/used-packages");
+const comments_1 = require("./supported/comments/comments");
+const defined_functions_1 = require("./supported/defined-functions/defined-functions");
+const used_functions_1 = require("./supported/used-functions/used-functions");
+const values_1 = require("./supported/values/values");
+const assignments_1 = require("./supported/assignments/assignments");
+const loops_1 = require("./supported/loops/loops");
+const control_flow_1 = require("./supported/control-flow/control-flow");
+const data_access_1 = require("./supported/data-access/data-access");
+const expression_list_1 = require("./supported/expression-list/expression-list");
+const variables_1 = require("./supported/variables/variables");
+/**
+ * The source of truth for all features that are supported by the statistics.
+ */
+exports.ALL_FEATURES = {
+    usedPackages: used_packages_1.usedPackages,
+    comments: comments_1.comments,
+    definedFunctions: defined_functions_1.definedFunctions,
+    usedFunctions: used_functions_1.usedFunctions,
+    values: values_1.values,
+    assignments: assignments_1.assignments,
+    loops: loops_1.loops,
+    controlflow: control_flow_1.controlflow,
+    dataAccess: data_access_1.dataAccess,
+    expressionList: expression_list_1.expressionList,
+    variables: variables_1.variables
+};
+exports.allFeatureNames = new Set(Object.keys(exports.ALL_FEATURES));
+//# sourceMappingURL=feature.js.map

package/statistics/features/post-processing.d.ts

@@ -0,0 +1,12 @@
+import type { StatisticsSummarizerConfiguration } from '../summarizer/summarizer';
+import type { MergeableRecord } from '../../util/objects';
+export interface SummarizedWithProject<Uniques = Set<string>, Count = number[]> {
+    uniqueProjects: Uniques;
+    uniqueFiles: Uniques;
+    count: Count;
+}
+export declare function emptySummarizedWithProject(): SummarizedWithProject;
+export type ReplaceKeysForSummary<Source, Target> = MergeableRecord & {
+    [K in keyof Source]: Target;
+};
+export declare function recordFilePath(summarize: SummarizedWithProject, filepath: string, config: StatisticsSummarizerConfiguration): void;

package/statistics/features/post-processing.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordFilePath = exports.emptySummarizedWithProject = void 0;
+const path_1 = __importDefault(require("path"));
+function emptySummarizedWithProject() {
+    return {
+        uniqueProjects: new Set(),
+        uniqueFiles: new Set(),
+        count: []
+    };
+}
+exports.emptySummarizedWithProject = emptySummarizedWithProject;
+function recordFilePath(summarize, filepath, config) {
+    summarize.uniqueFiles.add(filepath);
+    summarize.uniqueProjects.add(filepath.split(path_1.default.sep)[config.projectSkip] ?? '');
+}
+exports.recordFilePath = recordFilePath;
+//# sourceMappingURL=post-processing.js.map

package/statistics/features/supported/assignments/assignments.d.ts

@@ -0,0 +1,12 @@
+import type { Feature } from '../../feature';
+import type { Writable } from 'ts-essentials';
+declare const initialAssignmentInfo: {
+    assignmentOperator: Record<string, bigint>;
+    assigned: import("../../common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+    deepestNesting: number;
+    nestedOperatorAssignment: number;
+};
+export type AssignmentInfo = Writable<typeof initialAssignmentInfo>;
+export declare const AssignmentOperators: ReadonlySet<string>;
+export declare const assignments: Feature<AssignmentInfo>;
+export {};

package/statistics/features/supported/assignments/assignments.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignments = exports.AssignmentOperators = void 0;
+const common_syntax_probability_1 = require("../../common-syntax-probability");
+const post_process_1 = require("./post-process");
+const visitor_1 = require("../../../../r-bridge/lang-4.x/ast/model/processing/visitor");
+const operators_1 = require("../../../../r-bridge/lang-4.x/ast/model/operators");
+const initialAssignmentInfo = {
+    // operator to occurrence count
+    assignmentOperator: {},
+    assigned: (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)(),
+    // find combinations like `` is most often used for functions?
+    deepestNesting: 0,
+    nestedOperatorAssignment: 0
+};
+exports.AssignmentOperators = new Set(operators_1.Operators.filter(op => operators_1.OperatorDatabase[op].usedAs === 'assignment'));
+function visitAssignment(info, input) {
+    const assignmentStack = [];
+    (0, visitor_1.visitAst)(input.normalizedRAst.ast, node => {
+        if (node.type !== "RBinaryOp" /* RType.BinaryOp */ || !exports.AssignmentOperators.has(node.operator)) {
+            return;
+        }
+        if (assignmentStack.length > 0) {
+            info.nestedOperatorAssignment++;
+            info.deepestNesting = Math.max(info.deepestNesting, assignmentStack.length);
+        }
+        assignmentStack.push(node);
+        info.assignmentOperator[node.operator] = (info.assignmentOperator[node.operator] ?? 0n) + 1n;
+        switch (node.operator) {
+            case '->':
+            case '->>':
+                info.assigned = (0, common_syntax_probability_1.updateCommonSyntaxTypeCounts)(info.assigned, node.lhs);
+                break;
+            default:
+                info.assigned = (0, common_syntax_probability_1.updateCommonSyntaxTypeCounts)(info.assigned, node.rhs);
+                break;
+        }
+    }, node => {
+        // drop again :D
+        if (node.type === "RBinaryOp" /* RType.BinaryOp */ && node.flavor === 'assignment') {
+            assignmentStack.pop();
+        }
+    });
+}
+exports.assignments = {
+    name: 'Assignments',
+    description: 'all ways to assign something in R',
+    process(existing, input) {
+        visitAssignment(existing, input);
+        return existing;
+    },
+    initialValue: initialAssignmentInfo,
+    postProcess: post_process_1.postProcess
+};
+//# sourceMappingURL=assignments.js.map

package/statistics/features/supported/assignments/post-process.d.ts

@@ -0,0 +1,3 @@
+import type { FeatureStatisticsWithMeta } from '../../feature';
+import type { StatisticsSummarizerConfiguration } from '../../../summarizer/summarizer';
+export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;

package/statistics/features/supported/assignments/post-process.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postProcess = void 0;
+const common_syntax_probability_1 = require("../../common-syntax-probability");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const arrays_1 = require("../../../../util/arrays");
+const assert_1 = require("../../../../util/assert");
+const numbers_1 = require("../../../../util/numbers");
+const summarizer_1 = require("../../../../util/summarizer");
+function appendOperators(base, b, filepath, config) {
+    for (const [key, val] of Object.entries(b)) {
+        let get = base.assignmentOperator[key];
+        if (!get) {
+            get = { uniqueFiles: new Set(), uniqueProjects: new Set(), counts: [] };
+            base.assignmentOperator[key] = get;
+        }
+        const num = (0, numbers_1.bigint2number)(val);
+        get.counts.push([num]);
+        if (num > 0) {
+            get.uniqueFiles.add(filepath);
+            get.uniqueProjects.add(filepath.split(path_1.default.sep)[config.projectSkip] ?? '');
+        }
+    }
+}
+// returns a map that for each combination of operators found (like `<-,=`) returns the number of projects and files
+// that use both of them
+function retrieveUsageCombinationCounts(collected) {
+    const ops = Object.keys(collected.assignmentOperator);
+    if (ops.length < 1) {
+        return new Map();
+    }
+    const allCombinations = [...(0, arrays_1.getUniqueCombinationsOfSize)(ops, 1)];
+    const store = new Map();
+    for (const combs of allCombinations) {
+        if (combs.length === 1) {
+            // we can just copy the information
+            const { uniqueProjects, uniqueFiles } = collected.assignmentOperator[combs[0]];
+            store.set(combs[0], { uniqueProjects, uniqueFiles });
+            continue;
+        }
+        const existingKey = combs.slice(0, -1).join(',');
+        const existing = store.get(existingKey);
+        (0, assert_1.guard)(existing !== undefined, `Unable to retrieve cache for ${existingKey}`);
+        const newKey = combs.join(',');
+        const { uniqueProjects, uniqueFiles } = collected.assignmentOperator[combs[combs.length - 1]];
+        const newUniqueProjects = new Set([...existing.uniqueProjects].filter(x => uniqueProjects.has(x)));
+        const newUniqueFiles = new Set([...existing.uniqueFiles].filter(x => uniqueFiles.has(x)));
+        store.set(newKey, { uniqueProjects: newUniqueProjects, uniqueFiles: newUniqueFiles });
+    }
+    const result = new Map();
+    for (const [key, val] of store.entries()) {
+        result.set(key, { uniqueProjects: val.uniqueProjects.size, uniqueFiles: val.uniqueFiles.size });
+    }
+    return result;
+}
+function writeOperatorCombinationsUsageToCsv(collected, outputPath) {
+    // now to get all projects exhausted with _only_ a given subset (e.g., all projects only using '=')
+    const operators = retrieveUsageCombinationCounts(collected);
+    const out = fs_1.default.createWriteStream(path_1.default.join(outputPath, 'assignments-assigned-combinations.csv'));
+    out.write('assignment,unique-projects,unique-files\n');
+    for (const [key, val] of operators.entries()) {
+        out.write(`${JSON.stringify(key)},${val.uniqueProjects},${val.uniqueFiles}\n`);
+    }
+    out.close();
+}
+function writeAssignmentMetadataToCsv(outputPath, collected) {
+    const out = fs_1.default.createWriteStream(path_1.default.join(outputPath, 'assignments-meta.csv'));
+    out.write(`kind,${(0, summarizer_1.summarizedMeasurement2CsvHeader)()}\n`);
+    const summarizedDeepestNesting = (0, summarizer_1.summarizeMeasurement)(collected.deepestNesting.flat());
+    out.write(`deepest-nesting,${(0, summarizer_1.summarizedMeasurement2Csv)(summarizedDeepestNesting)}\n`);
+    const summarizedNestedOperatorAssignment = (0, summarizer_1.summarizeMeasurement)(collected.nestedOperatorAssignment.flat());
+    out.write(`nested-operator-assignment,${(0, summarizer_1.summarizedMeasurement2Csv)(summarizedNestedOperatorAssignment)}\n`);
+    out.close();
+}
+function writeAssignedTypesToCsv(outputPath, collected) {
+    const out = fs_1.default.createWriteStream(path_1.default.join(outputPath, 'assignments-assigned.csv'));
+    out.write(`kind,name,${(0, summarizer_1.summarizedMeasurement2CsvHeader)()}\n`);
+    for (const [entryName, values] of Object.entries(collected.assigned)) {
+        if (Array.isArray(values)) {
+            out.write(`${JSON.stringify(entryName)},"",${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(values.flat()))}\n`);
+        }
+        else {
+            for (const [keyName, keyValue] of Object.entries(values)) {
+                out.write(`${JSON.stringify(entryName)},${JSON.stringify(keyName)},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(keyValue.flat()))}\n`);
+            }
+        }
+    }
+    out.close();
+}
+function writeAssignmentOperatorsToCsv(outputPath, collected) {
+    const fnOutStream = fs_1.default.createWriteStream(path_1.default.join(outputPath, 'assignments-assignment-operators.csv'));
+    fnOutStream.write(`assignment,unique-projects,unique-files,${(0, summarizer_1.summarizedMeasurement2CsvHeader)()}\n`);
+    for (const [key, val] of Object.entries(collected.assignmentOperator)) {
+        const { uniqueProjects, uniqueFiles, counts } = val;
+        const summarized = (0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(counts.flat()));
+        fnOutStream.write(`${JSON.stringify(key)},${uniqueProjects.size},${uniqueFiles.size},${summarized}\n`);
+    }
+    fnOutStream.close();
+}
+function postProcess(featureRoot, info, outputPath, config) {
+    const collected = {
+        assignmentOperator: {},
+        assigned: (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)(() => []),
+        deepestNesting: [],
+        nestedOperatorAssignment: []
+    };
+    for (const [filepath, data] of info.entries()) {
+        const assignmentInfo = data.assignments;
+        collected.deepestNesting.push([assignmentInfo.deepestNesting]);
+        collected.nestedOperatorAssignment.push([assignmentInfo.nestedOperatorAssignment]);
+        (0, common_syntax_probability_1.appendCommonSyntaxTypeCounter)(collected.assigned, assignmentInfo.assigned);
+        appendOperators(collected, assignmentInfo.assignmentOperator, filepath, config);
+    }
+    writeAssignmentOperatorsToCsv(outputPath, collected);
+    writeOperatorCombinationsUsageToCsv(collected, outputPath);
+    writeAssignmentMetadataToCsv(outputPath, collected);
+    writeAssignedTypesToCsv(outputPath, collected);
+}
+exports.postProcess = postProcess;
+//# sourceMappingURL=post-process.js.map

package/statistics/features/supported/comments/comments.d.ts

@@ -0,0 +1,18 @@
+import type { Feature } from '../../feature';
+import type { Writable } from 'ts-essentials';
+export declare const initialCommentInfo: {
+    totalAmount: number;
+    roxygenComments: number;
+    import: number;
+    importFrom: number;
+    importMethodsFrom: number;
+    importClassesFrom: number;
+    useDynLib: number;
+    export: number;
+    exportClass: number;
+    exportMethod: number;
+    exportS3Method: number;
+    exportPattern: number;
+};
+export type CommentInfo = Writable<typeof initialCommentInfo>;
+export declare const comments: Feature<CommentInfo>;