@eagleoutice/flowr 1.5.1 → 2.0.0

package/statistics/features/supported/comments/comments.js

@@ -0,0 +1,133 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.comments = exports.initialCommentInfo = void 0;
+const xpath = __importStar(require("xpath-ts2"));
+const post_process_1 = require("./post-process");
+const assert_1 = require("../../../../util/assert");
+const statistics_file_1 = require("../../../output/statistics-file");
+exports.initialCommentInfo = {
+    totalAmount: 0,
+    roxygenComments: 0,
+    import: 0,
+    importFrom: 0,
+    importMethodsFrom: 0,
+    importClassesFrom: 0,
+    useDynLib: 0,
+    export: 0,
+    exportClass: 0,
+    exportMethod: 0,
+    exportS3Method: 0,
+    exportPattern: 0
+};
+const commentQuery = xpath.parse('//COMMENT');
+const importRegex = /^'\s*@import\s+(?<package>\S+)/;
+const importFromRegex = /^'\s*@importFrom\s+(?<package>\S+)(?<fn>( +\S+)+)$/;
+const useDynLibRegex = /^'\s*@useDynLib\s+(?<package>\S+)(?<fn>( +\S+)+)?$/;
+/** we still name the classes fn, so we can reuse processing code */
+const importClassesFromRegex = /^'\s*@importClassesFrom\s+(?<package>\S+)(?<fn>( +\S+)+)$/;
+const importMethodsFrom = /^'\s*@importMethodsFrom\s+(?<package>\S+)(?<fn>( +\S+)+)$/;
+/** deliberately includes the others to get a "total" overview */
+const exportRegex = /^'\s*@export/;
+const exportS3MethodRegex = /^'\s*@exportS3Method/;
+const exportClassRegex = /^'\s*@exportClass/;
+const exportMethodRegex = /^'\s*@exportMethod/;
+const exportPatternRegex = /^'\s*@exportPattern/;
+function processRoxygenImport(existing, commentsText, filepath) {
+    const packages = commentsText.map(text => importRegex.exec(text)?.groups?.package).filter(assert_1.isNotUndefined);
+    existing.import += packages.length;
+    (0, statistics_file_1.appendStatisticsFile)(exports.comments.name, 'import', packages, filepath, true);
+}
+function processWithRegex(commentsText, existing, regex) {
+    return commentsText.map(text => regex.exec(text)).filter(assert_1.isNotNull)
+        .flatMap(match => {
+        const packageName = match.groups?.package ?? '<unknown>';
+        return (match.groups?.fn.trim().split(/\s+/) ?? []).map(fn => `${JSON.stringify(packageName)},${fn}`);
+    });
+}
+function processRoxygenImportFrom(existing, commentsText, filepath) {
+    const result = processWithRegex(commentsText, existing, importFromRegex);
+    existing.importFrom += result.length;
+    (0, statistics_file_1.appendStatisticsFile)(exports.comments.name, 'importFrom', result, filepath, true);
+}
+function processRoxygenImportClassesFrom(existing, commentsText, filepath) {
+    const result = processWithRegex(commentsText, existing, importClassesFromRegex);
+    existing.importClassesFrom += result.length;
+    (0, statistics_file_1.appendStatisticsFile)(exports.comments.name, 'importClassesFrom', result, filepath, true);
+}
+function processRoxygenImportMethodsFrom(existing, commentsText, filepath) {
+    const result = processWithRegex(commentsText, existing, importMethodsFrom);
+    existing.importMethodsFrom += result.length;
+    (0, statistics_file_1.appendStatisticsFile)(exports.comments.name, 'importMethodsFrom', result, filepath, true);
+}
+function processExports(existing, comments) {
+    existing.export += comments.filter(text => exportRegex.test(text)).length;
+    existing.exportClass += comments.filter(text => exportClassRegex.test(text)).length;
+    existing.exportMethod += comments.filter(text => exportMethodRegex.test(text)).length;
+    existing.exportS3Method += comments.filter(text => exportS3MethodRegex.test(text)).length;
+    existing.exportPattern += comments.filter(text => exportPatternRegex.test(text)).length;
+}
+function processMatchForDynLib(match) {
+    const packageName = match.groups?.package ?? '<unknown>';
+    const functions = match.groups?.fn?.trim().split(/\s+/) ?? [];
+    if (functions.length === 0) {
+        return [packageName];
+    }
+    else {
+        return functions.map(fn => `${JSON.stringify(packageName)},${fn}`);
+    }
+}
+function processRoxygenUseDynLib(existing, commentsText, filepath) {
+    const result = commentsText.map(text => useDynLibRegex.exec(text))
+        .filter(assert_1.isNotNull)
+        .flatMap(processMatchForDynLib);
+    existing.useDynLib += result.length;
+    (0, statistics_file_1.appendStatisticsFile)(exports.comments.name, 'useDynLib', result, filepath, true);
+}
+exports.comments = {
+    name: 'Comments',
+    description: 'All comments that appear within the document',
+    process(existing, input) {
+        const comments = commentQuery.select({ node: input.parsedRAst }).map(node => node.textContent ?? '#')
+            .map(text => {
+            (0, assert_1.guard)(text.startsWith('#'), `unexpected comment ${text}`);
+            return text.slice(1);
+        })
+            .map(text => text.trim());
+        existing.totalAmount += comments.length;
+        const roxygenComments = comments.filter(text => text.startsWith("'"));
+        existing.roxygenComments += roxygenComments.length;
+        processRoxygenImport(existing, roxygenComments, input.filepath);
+        processRoxygenImportFrom(existing, roxygenComments, input.filepath);
+        processRoxygenUseDynLib(existing, roxygenComments, input.filepath);
+        processRoxygenImportClassesFrom(existing, roxygenComments, input.filepath);
+        processRoxygenImportMethodsFrom(existing, roxygenComments, input.filepath);
+        processExports(existing, roxygenComments);
+        return existing;
+    },
+    initialValue: exports.initialCommentInfo,
+    postProcess: post_process_1.postProcess
+};
+//# sourceMappingURL=comments.js.map

package/statistics/features/supported/comments/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/comments/post-process.js

@@ -0,0 +1,49 @@
+"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 comments_1 = require("./comments");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const summarizer_1 = require("../../../../util/summarizer");
+const assert_1 = require("../../../../util/assert");
+// monoids would be helpful :c
+function appendCommentsPostProcessing(a, b, numberOfLines, filepath, skipForProjects) {
+    for (const [key, val] of Object.entries(b)) {
+        const get = a[key];
+        (0, assert_1.guard)(get !== undefined, `key ${key} is not present in the comments post processing`);
+        get.count.push(val);
+        get.fracOfLines.push(val / numberOfLines);
+        if (val > 0) {
+            get.uniqueFiles.add(filepath);
+            get.uniqueProjects.add(filepath.split(path_1.default.sep)[skipForProjects] ?? '');
+        }
+    }
+}
+const initialCommentsMeta = () => ({ count: [], uniqueProjects: new Set(), uniqueFiles: new Set(), fracOfLines: [] });
+function mapComments(data, fn) {
+    const collected = {};
+    for (const [key, value] of Object.entries(data)) {
+        collected[key] = fn(value);
+    }
+    return collected;
+}
+function postProcess(featureRoot, info, outputPath, config) {
+    // for each we collect the count and the number of files that contain them
+    const collected = mapComments(comments_1.initialCommentInfo, initialCommentsMeta);
+    for (const [filepath, feature] of info.entries()) {
+        appendCommentsPostProcessing(collected, feature.comments, feature.stats.lines[0].length, filepath, config.projectSkip);
+    }
+    const fnOutStream = fs_1.default.createWriteStream(path_1.default.join(outputPath, 'comments.csv'));
+    fnOutStream.write(`kind,unique-projects,unique-files,${(0, summarizer_1.summarizedMeasurement2CsvHeader)('count')},${(0, summarizer_1.summarizedMeasurement2CsvHeader)('frac-of-lines')}\n`);
+    for (const [key, val] of Object.entries(collected)) {
+        const { count, uniqueProjects, uniqueFiles, fracOfLines } = val;
+        const counts = (0, summarizer_1.summarizeMeasurement)(count);
+        const lineFrac = (0, summarizer_1.summarizeMeasurement)(fracOfLines);
+        fnOutStream.write(`${JSON.stringify(key)},${uniqueProjects.size},${uniqueFiles.size},${(0, summarizer_1.summarizedMeasurement2Csv)(counts)},${(0, summarizer_1.summarizedMeasurement2Csv)(lineFrac)}\n`);
+    }
+}
+exports.postProcess = postProcess;
+//# sourceMappingURL=post-process.js.map

package/statistics/features/supported/control-flow/control-flow.d.ts

@@ -0,0 +1,17 @@
+import type { Feature } from '../../feature';
+import type { Writable } from 'ts-essentials';
+declare const initialControlflowInfo: {
+    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>;
+    /** can be nested with if-s or if-then-else's */
+    nestedIfThen: number;
+    nestedIfThenElse: number;
+    deepestNesting: number;
+    /** switch(...) */
+    switchCase: import("../../common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+};
+export type ControlflowInfo = Writable<typeof initialControlflowInfo>;
+export declare const controlflow: Feature<ControlflowInfo>;
+export {};

package/statistics/features/supported/control-flow/control-flow.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.controlflow = void 0;
+const common_syntax_probability_1 = require("../../common-syntax-probability");
+const post_process_1 = require("./post-process");
+const unpack_argument_1 = require("../../../../dataflow/internal/process/functions/call/argument/unpack-argument");
+const visitor_1 = require("../../../../r-bridge/lang-4.x/ast/model/processing/visitor");
+const initialControlflowInfo = {
+    ifThen: (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)(),
+    thenBody: (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)(),
+    ifThenElse: (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)(),
+    elseBody: (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)(),
+    /** can be nested with if-s or if-then-else's */
+    nestedIfThen: 0,
+    nestedIfThenElse: 0,
+    deepestNesting: 0,
+    /** switch(...) */
+    switchCase: (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)()
+};
+function visitIfThenElse(info, input) {
+    const ifThenElseStack = [];
+    (0, visitor_1.visitAst)(input.normalizedRAst.ast, node => {
+        if (node.type !== "RIfThenElse" /* RType.IfThenElse */) {
+            if (node.type === "RFunctionCall" /* RType.FunctionCall */ && node.flavor === 'named' && node.functionName.content === 'switch') {
+                const initialArg = (0, unpack_argument_1.unpackArgument)(node.arguments[0]);
+                if (initialArg) {
+                    info.switchCase = (0, common_syntax_probability_1.updateCommonSyntaxTypeCounts)(info.switchCase, initialArg);
+                }
+            }
+            return;
+        }
+        const ifThenElse = node.otherwise !== undefined;
+        if (ifThenElseStack.length > 0) {
+            if (ifThenElse) {
+                info.nestedIfThenElse++;
+            }
+            else {
+                info.nestedIfThen++;
+            }
+            info.deepestNesting = Math.max(info.deepestNesting, ifThenElseStack.length);
+        }
+        ifThenElseStack.push(node);
+        info.thenBody = (0, common_syntax_probability_1.updateCommonSyntaxTypeCounts)(info.thenBody, ...node.then.children);
+        if (ifThenElse) {
+            info.ifThenElse = (0, common_syntax_probability_1.updateCommonSyntaxTypeCounts)(info.ifThenElse, node.condition);
+            info.elseBody = (0, common_syntax_probability_1.updateCommonSyntaxTypeCounts)(info.elseBody, ...node.otherwise.children);
+        }
+        else {
+            info.ifThen = (0, common_syntax_probability_1.updateCommonSyntaxTypeCounts)(info.ifThen, node.condition);
+        }
+    }, node => {
+        // drop again :D
+        if (node.type === "RIfThenElse" /* RType.IfThenElse */) {
+            ifThenElseStack.pop();
+        }
+    });
+}
+exports.controlflow = {
+    name: 'Controlflow',
+    description: 'Deals with if-then-else and switch-case',
+    process(existing, input) {
+        visitIfThenElse(existing, input);
+        return existing;
+    },
+    initialValue: initialControlflowInfo,
+    postProcess: post_process_1.postProcess
+};
+//# sourceMappingURL=control-flow.js.map

package/statistics/features/supported/control-flow/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/control-flow/post-process.js

@@ -0,0 +1,64 @@
+"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 post_processing_1 = require("../../post-processing");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const summarizer_1 = require("../../../../util/summarizer");
+function postProcess(featureRoot, info, outputPath, config) {
+    const collected = {
+        ifThen: (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)(() => []),
+        thenBody: (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)(() => []),
+        ifThenElse: (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)(() => []),
+        elseBody: (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)(() => []),
+        nestedIfThen: (0, post_processing_1.emptySummarizedWithProject)(),
+        nestedIfThenElse: (0, post_processing_1.emptySummarizedWithProject)(),
+        deepestNesting: (0, post_processing_1.emptySummarizedWithProject)(),
+        switchCase: (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)(() => [])
+    };
+    for (const [filepath, data] of info.entries()) {
+        const value = data.controlflow;
+        for (const [key, val] of Object.entries(value)) {
+            if (typeof val === 'object') {
+                (0, common_syntax_probability_1.appendCommonSyntaxTypeCounter)(collected[key], val);
+            }
+            else {
+                const get = collected[key];
+                get.count.push(val);
+                if (val > 0) {
+                    (0, post_processing_1.recordFilePath)(get, filepath, config);
+                }
+            }
+        }
+    }
+    const metaOut = fs_1.default.createWriteStream(path_1.default.join(outputPath, 'control-flow-meta.csv'));
+    metaOut.write(`kind,unique-projects,unique-files,${(0, summarizer_1.summarizedMeasurement2CsvHeader)()}\n`);
+    for (const [key, val] of Object.entries(collected)) {
+        const data = val;
+        if ('uniqueProjects' in data) {
+            metaOut.write(`${JSON.stringify(key)},${data.uniqueProjects.size},${data.uniqueFiles.size},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(data.count))}\n`);
+        }
+        else {
+            const out = fs_1.default.createWriteStream(path_1.default.join(outputPath, `control-flow-type-${key}.csv`));
+            // name is for fields like number etc. to allow to group multiple entries
+            out.write(`kind,name,${(0, summarizer_1.summarizedMeasurement2CsvHeader)()}\n`);
+            for (const [name, vals] of Object.entries(data)) {
+                if (Array.isArray(vals)) {
+                    out.write(`${JSON.stringify(name)},"",${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(vals.flat()))}\n`);
+                }
+                else {
+                    for (const [keyName, keyValue] of Object.entries(vals)) {
+                        out.write(`${JSON.stringify(name)},${JSON.stringify(keyName)},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(keyValue.flat()))}\n`);
+                    }
+                }
+            }
+            out.close();
+        }
+    }
+}
+exports.postProcess = postProcess;
+//# sourceMappingURL=post-process.js.map

package/statistics/features/supported/data-access/data-access.d.ts

@@ -0,0 +1,15 @@
+import type { Feature } from '../../feature';
+import type { Writable } from 'ts-essentials';
+import type { CommonSyntaxTypeCounts } from '../../common-syntax-probability';
+declare const initialDataAccessInfo: {
+    singleBracket: Record<number, bigint | CommonSyntaxTypeCounts<bigint>>;
+    doubleBracket: Record<number, bigint | CommonSyntaxTypeCounts<bigint>>;
+    chainedOrNestedAccess: number;
+    longestChain: number;
+    deepestNesting: number;
+    byName: number;
+    bySlot: number;
+};
+export type DataAccessInfo = Writable<typeof initialDataAccessInfo>;
+export declare const dataAccess: Feature<DataAccessInfo>;
+export {};

package/statistics/features/supported/data-access/data-access.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataAccess = void 0;
+const common_syntax_probability_1 = require("../../common-syntax-probability");
+const post_process_1 = require("./post-process");
+const assert_1 = require("../../../../util/assert");
+const visitor_1 = require("../../../../r-bridge/lang-4.x/ast/model/processing/visitor");
+const role_1 = require("../../../../r-bridge/lang-4.x/ast/model/processing/role");
+const statistics_file_1 = require("../../../output/statistics-file");
+const r_function_call_1 = require("../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const initialDataAccessInfo = {
+    // for the nth argument, how many of them are constant, etc.
+    singleBracket: {
+        // only counts if empty
+        0: 0n,
+        1: (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)()
+    },
+    doubleBracket: {
+        // similar to single bracket
+        0: 0n,
+        1: (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)()
+    },
+    chainedOrNestedAccess: 0,
+    longestChain: 0,
+    deepestNesting: 0,
+    byName: 0,
+    bySlot: 0,
+};
+function classifyArguments(args, existing) {
+    if (args.length === 0) {
+        existing[0]++;
+        return;
+    }
+    let i = 1;
+    for (const arg of args) {
+        if (arg === null || arg === undefined || arg === r_function_call_1.EmptyArgument) {
+            existing[0]++;
+            continue;
+        }
+        existing[i] = (0, common_syntax_probability_1.updateCommonSyntaxTypeCounts)(existing[i] ?? (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)(), arg);
+        i++;
+    }
+}
+function visitAccess(info, input) {
+    const accessNest = [];
+    const accessChain = [];
+    const parentRoleCache = new Map();
+    (0, visitor_1.visitAst)(input.normalizedRAst.ast, node => {
+        if (node.type !== "RAccess" /* RType.Access */) {
+            return;
+        }
+        const roles = (0, role_1.rolesOfParents)(node, input.normalizedRAst.idMap);
+        let acc = false;
+        let idxAcc = false;
+        for (const role of roles) {
+            if (role === "accessed" /* RoleInParent.Accessed */) {
+                acc = true;
+                break; // we only account for the first one
+            }
+            else if (role === "index-access" /* RoleInParent.IndexAccess */) {
+                idxAcc = true;
+                break;
+            }
+        }
+        // here we have to check after the addition as we can only check the parental context
+        if (acc) {
+            accessChain.push(node);
+            info.chainedOrNestedAccess++;
+            info.longestChain = Math.max(info.longestChain, accessChain.length);
+        }
+        else if (idxAcc) {
+            accessNest.push(node);
+            info.chainedOrNestedAccess++;
+            info.deepestNesting = Math.max(info.deepestNesting, accessNest.length);
+        }
+        parentRoleCache.set(node.info.id, { acc, idxAcc });
+        if (accessNest.length === 0 && accessChain.length === 0) { // store topmost, after add as it must not be a child to do that
+            (0, statistics_file_1.appendStatisticsFile)(exports.dataAccess.name, 'dataAccess', [node.info.fullLexeme ?? node.lexeme], input.filepath);
+        }
+        const op = node.operator;
+        switch (op) {
+            case '@':
+                info.bySlot++;
+                return;
+            case '$':
+                info.byName++;
+                return;
+            case '[':
+                classifyArguments(node.access, info.singleBracket);
+                break;
+            case '[[':
+                classifyArguments(node.access, info.doubleBracket);
+                break;
+            default: (0, assert_1.assertUnreachable)(op);
+        }
+        (0, assert_1.guard)(Array.isArray(node.access), '[ and [[ must provide access as array');
+    }, node => {
+        // drop again :D
+        if (node.type === "RAccess" /* RType.Access */) {
+            const ctx = parentRoleCache.get(node.info.id);
+            if (ctx?.acc) {
+                accessChain.pop();
+            }
+            else if (ctx?.idxAcc) {
+                accessNest.pop();
+            }
+        }
+    });
+}
+exports.dataAccess = {
+    name: 'Data Access',
+    description: 'Ways of accessing data structures in R',
+    process(existing, input) {
+        visitAccess(existing, input);
+        return existing;
+    },
+    initialValue: initialDataAccessInfo,
+    postProcess: post_process_1.postProcess
+};
+//# sourceMappingURL=data-access.js.map

package/statistics/features/supported/data-access/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/data-access/post-process.js

@@ -0,0 +1,106 @@
+"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 post_processing_1 = require("../../post-processing");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const numbers_1 = require("../../../../util/numbers");
+const summarizer_1 = require("../../../../util/summarizer");
+function addToList(data, dataAccess, filepath, config) {
+    data.count.push(dataAccess);
+    if (dataAccess > 0) {
+        (0, post_processing_1.recordFilePath)(data, filepath, config);
+    }
+}
+function summarizeForBracket(dataAccess, data, filepath, config) {
+    for (const [key, val] of Object.entries(dataAccess)) {
+        const numericKey = Number(key);
+        const get = data.get(numericKey) ?? (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)(() => []);
+        if (typeof val === 'bigint' || typeof val === 'string') {
+            // it is for argument 0
+            const sumGet = get;
+            const numericVal = (0, numbers_1.bigint2number)(val);
+            sumGet.count.push(numericVal);
+            if (numericVal > 0) {
+                (0, post_processing_1.recordFilePath)(sumGet, filepath, config);
+            }
+        }
+        else {
+            (0, common_syntax_probability_1.appendCommonSyntaxTypeCounter)(get, val);
+        }
+        data.set(numericKey, get);
+    }
+}
+function writeSingleOrDoubleEmpty(outputPath, key, name, vals) {
+    const out = fs_1.default.createWriteStream(path_1.default.join(outputPath, `data-access-type-${key}-${name}.csv`));
+    // name is for fields like number etc. to allow to group multiple entries
+    out.write(`kind,unique-projects,unique-files,${(0, summarizer_1.summarizedMeasurement2CsvHeader)()}\n`);
+    out.write(`"0",${vals.uniqueProjects.size},${vals.uniqueFiles.size},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(vals.count))}\n`);
+    out.close();
+}
+function writeSingleOrDoubleBrackets(data, outputPath, key) {
+    for (const [name, vals] of data.entries()) {
+        // the 0 column
+        if ('uniqueProjects' in vals) {
+            writeSingleOrDoubleEmpty(outputPath, key, name, vals);
+        }
+        else {
+            // non-0-column
+            const out = fs_1.default.createWriteStream(path_1.default.join(outputPath, `data-access-type-${key}-${name}.csv`));
+            // name is for fields like number etc. to allow to group multiple entries
+            out.write(`kind,name,${(0, summarizer_1.summarizedMeasurement2CsvHeader)()}\n`);
+            for (const [entryName, values] of Object.entries(vals)) {
+                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 postProcess(featureRoot, info, outputPath, config) {
+    const summarize = {
+        singleBracket: new Map(),
+        doubleBracket: new Map(),
+        chainedOrNestedAccess: (0, post_processing_1.emptySummarizedWithProject)(),
+        longestChain: (0, post_processing_1.emptySummarizedWithProject)(),
+        deepestNesting: (0, post_processing_1.emptySummarizedWithProject)(),
+        byName: (0, post_processing_1.emptySummarizedWithProject)(),
+        bySlot: (0, post_processing_1.emptySummarizedWithProject)()
+    };
+    // initialize the special 0
+    summarize.singleBracket.set(0, (0, post_processing_1.emptySummarizedWithProject)());
+    summarize.doubleBracket.set(0, (0, post_processing_1.emptySummarizedWithProject)());
+    for (const [filepath, value] of info.entries()) {
+        const dataAccess = value.dataAccess;
+        addToList(summarize.chainedOrNestedAccess, dataAccess.chainedOrNestedAccess, filepath, config);
+        addToList(summarize.longestChain, dataAccess.longestChain, filepath, config);
+        addToList(summarize.deepestNesting, dataAccess.deepestNesting, filepath, config);
+        addToList(summarize.byName, dataAccess.byName, filepath, config);
+        addToList(summarize.bySlot, dataAccess.bySlot, filepath, config);
+        summarizeForBracket(dataAccess.singleBracket, summarize.singleBracket, filepath, config);
+        summarizeForBracket(dataAccess.doubleBracket, summarize.doubleBracket, filepath, config);
+    }
+    const metaOut = fs_1.default.createWriteStream(path_1.default.join(outputPath, 'data-access-meta.csv'));
+    metaOut.write(`kind,unique-projects,unique-files,${(0, summarizer_1.summarizedMeasurement2CsvHeader)()}\n`);
+    for (const [key, value] of Object.entries(summarize)) {
+        const data = value;
+        if ('uniqueProjects' in data) {
+            metaOut.write(`${JSON.stringify(key)},${data.uniqueProjects.size},${data.uniqueFiles.size},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(data.count))}\n`);
+            continue;
+        }
+        writeSingleOrDoubleBrackets(data, outputPath, key);
+    }
+    metaOut.close();
+}
+exports.postProcess = postProcess;
+//# sourceMappingURL=post-process.js.map

package/statistics/features/supported/defined-functions/defined-functions.d.ts

@@ -0,0 +1,34 @@
+import type { Feature } from '../../feature';
+import type { Writable } from 'ts-essentials';
+import type { MergeableRecord } from '../../../../util/objects';
+import type { SourcePosition } from '../../../../util/range';
+declare const initialFunctionDefinitionInfo: {
+    /** all, anonymous, assigned, non-assigned, ... */
+    total: number;
+    /** how many are really using OP-Lambda? */
+    lambdasOnly: number;
+    /** using `<<-`, `<-`, `=`, `->` `->>` */
+    assignedFunctions: number;
+    nestedFunctions: number;
+    /** functions that in some easily detectable way call themselves */
+    recursive: number;
+    deepestNesting: number;
+};
+export type FunctionDefinitionInfo = Writable<typeof initialFunctionDefinitionInfo>;
+export declare const AllDefinitionsFileBase = "all-definitions";
+export interface SingleFunctionDefinitionInformation extends MergeableRecord {
+    location: SourcePosition;
+    /** locations of all direct call sites */
+    callsites: SourcePosition[];
+    numberOfParameters: number;
+    returns: {
+        location: SourcePosition;
+    }[];
+    length: {
+        lines: number;
+        characters: number;
+        nonWhitespaceCharacters: number;
+    };
+}
+export declare const definedFunctions: Feature<FunctionDefinitionInfo>;
+export {};