@eagleoutice/flowr 1.3.11

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

@@ -0,0 +1,50 @@
+"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 data_1 = require("../../../../util/summarizer/benchmark/data");
+const comments_1 = require("./comments");
+const assert_1 = require("../../../../util/assert");
+const node_fs_1 = __importDefault(require("node:fs"));
+const path_1 = __importDefault(require("path"));
+const process_1 = require("../../../../util/summarizer/benchmark/first-phase/process");
+// 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 = node_fs_1.default.createWriteStream(path_1.default.join(outputPath, 'comments.csv'));
+    fnOutStream.write(`kind,unique-projects,unique-files,${(0, data_1.summarizedMeasurement2CsvHeader)('count')},${(0, data_1.summarizedMeasurement2CsvHeader)('frac-of-lines')}\n`);
+    for (const [key, val] of Object.entries(collected)) {
+        const { count, uniqueProjects, uniqueFiles, fracOfLines } = val;
+        const counts = (0, process_1.summarizeMeasurement)(count);
+        const lineFrac = (0, process_1.summarizeMeasurement)(fracOfLines);
+        fnOutStream.write(`${JSON.stringify(key)},${uniqueProjects.size},${uniqueFiles.size},${(0, data_1.summarizedMeasurement2Csv)(counts)},${(0, data_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 { Feature } from '../../feature';
+import { 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,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.controlflow = void 0;
+const common_syntax_probability_1 = require("../../common-syntax-probability");
+const r_bridge_1 = require("../../../../r-bridge");
+const post_process_1 = require("./post-process");
+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, r_bridge_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 = 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/index.d.ts

@@ -0,0 +1 @@
+export { controlflow } from './control-flow';

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.controlflow = void 0;
+var control_flow_1 = require("./control-flow");
+Object.defineProperty(exports, "controlflow", { enumerable: true, get: function () { return control_flow_1.controlflow; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,3 @@
+import { FeatureStatisticsWithMeta } from '../../feature';
+import { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/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,65 @@
+"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 data_1 = require("../../../../util/summarizer/benchmark/data");
+const process_1 = require("../../../../util/summarizer/benchmark/first-phase/process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+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, data_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, data_1.summarizedMeasurement2Csv)((0, process_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, data_1.summarizedMeasurement2CsvHeader)()}\n`);
+            for (const [name, vals] of Object.entries(data)) {
+                if (Array.isArray(vals)) {
+                    out.write(`${JSON.stringify(name)},"",${(0, data_1.summarizedMeasurement2Csv)((0, process_1.summarizeMeasurement)(vals.flat()))}\n`);
+                }
+                else {
+                    for (const [keyName, keyValue] of Object.entries(vals)) {
+                        out.write(`${JSON.stringify(name)},${JSON.stringify(keyName)},${(0, data_1.summarizedMeasurement2Csv)((0, process_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 { Feature } from '../../feature';
+import { Writable } from 'ts-essentials';
+import { 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,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataAccess = void 0;
+const r_bridge_1 = require("../../../../r-bridge");
+const assert_1 = require("../../../../util/assert");
+const output_1 = require("../../../output");
+const common_syntax_probability_1 = require("../../common-syntax-probability");
+const post_process_1 = require("./post-process");
+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) {
+            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, r_bridge_1.visitAst)(input.normalizedRAst.ast, node => {
+        if (node.type !== "RAccess" /* RType.Access */) {
+            return;
+        }
+        const roles = (0, r_bridge_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, output_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/index.d.ts

@@ -0,0 +1 @@
+export { dataAccess } from './data-access';

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataAccess = void 0;
+var data_access_1 = require("./data-access");
+Object.defineProperty(exports, "dataAccess", { enumerable: true, get: function () { return data_access_1.dataAccess; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,3 @@
+import { FeatureStatisticsWithMeta } from '../../feature';
+import { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/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,107 @@
+"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 data_1 = require("../../../../util/summarizer/benchmark/data");
+const common_syntax_probability_1 = require("../../common-syntax-probability");
+const post_processing_1 = require("../../post-processing");
+const numbers_1 = require("../../../../util/numbers");
+const node_fs_1 = __importDefault(require("node:fs"));
+const path_1 = __importDefault(require("path"));
+const process_1 = require("../../../../util/summarizer/benchmark/first-phase/process");
+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 = node_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, data_1.summarizedMeasurement2CsvHeader)()}\n`);
+    out.write(`"0",${vals.uniqueProjects.size},${vals.uniqueFiles.size},${(0, data_1.summarizedMeasurement2Csv)((0, process_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 = node_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, data_1.summarizedMeasurement2CsvHeader)()}\n`);
+            for (const [entryName, values] of Object.entries(vals)) {
+                if (Array.isArray(values)) {
+                    out.write(`${JSON.stringify(entryName)},"",${(0, data_1.summarizedMeasurement2Csv)((0, process_1.summarizeMeasurement)(values.flat()))}\n`);
+                }
+                else {
+                    for (const [keyName, keyValue] of Object.entries(values)) {
+                        out.write(`${JSON.stringify(entryName)},${JSON.stringify(keyName)},${(0, data_1.summarizedMeasurement2Csv)((0, process_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 = node_fs_1.default.createWriteStream(path_1.default.join(outputPath, 'data-access-meta.csv'));
+    metaOut.write(`kind,unique-projects,unique-files,${(0, data_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, data_1.summarizedMeasurement2Csv)((0, process_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,35 @@
+import { Feature } from '../../feature';
+import { Writable } from 'ts-essentials';
+import { SourcePosition } from '../../../../util/range';
+import { MergeableRecord } from '../../../../util/objects';
+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: {
+        explicit: boolean;
+        location: SourcePosition;
+    }[];
+    length: {
+        lines: number;
+        characters: number;
+        nonWhitespaceCharacters: number;
+    };
+}
+export declare const definedFunctions: Feature<FunctionDefinitionInfo>;
+export {};

package/statistics/features/supported/defined-functions/defined-functions.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.definedFunctions = exports.AllDefinitionsFileBase = void 0;
+const output_1 = require("../../../output");
+const r_bridge_1 = require("../../../../r-bridge");
+const dataflow_1 = require("../../../../dataflow");
+const assert_1 = require("../../../../util/assert");
+const post_process_1 = require("./post-process");
+const initialFunctionDefinitionInfo = {
+    /** all, anonymous, assigned, non-assigned, ... */
+    total: 0,
+    /** how many are really using OP-Lambda? */
+    lambdasOnly: 0,
+    /** using `<<-`, `<-`, `=`, `->` `->>` */
+    assignedFunctions: 0,
+    nestedFunctions: 0,
+    /** functions that in some easily detectable way call themselves */
+    recursive: 0,
+    deepestNesting: 0
+};
+exports.AllDefinitionsFileBase = 'all-definitions';
+function retrieveAllCallsites(input, node, recursiveCalls) {
+    const dfStart = input.dataflow.graph.outgoingEdges(node.info.id);
+    const callsites = [];
+    for (const [target, edge] of dfStart ?? []) {
+        if (!edge.types.has(dataflow_1.EdgeType.Calls)) {
+            continue;
+        }
+        const loc = input.normalizedRAst.idMap.get(target)?.location?.start;
+        if (loc) {
+            callsites.push(loc);
+        }
+    }
+    for (const call of recursiveCalls) {
+        const loc = call.location;
+        if (loc) {
+            callsites.push(loc.start);
+        }
+    }
+    return callsites;
+}
+function visitDefinitions(info, input) {
+    const definitionStack = [];
+    const allDefinitions = [];
+    (0, r_bridge_1.visitAst)(input.normalizedRAst.ast, node => {
+        if (node.type !== "RFunctionDefinition" /* RType.FunctionDefinition */) {
+            return;
+        }
+        const graph = input.dataflow.graph;
+        const dfNode = graph.get(node.info.id, true);
+        if (dfNode === undefined) {
+            (0, output_1.appendStatisticsFile)(exports.definedFunctions.name, 'no-dataflow-node-found', [node], input.filepath);
+            return;
+        }
+        const [fnDefinition] = dfNode;
+        (0, assert_1.guard)(fnDefinition.tag === 'function-definition', () => `Dataflow node is not a function definition (${JSON.stringify(fnDefinition)}))})`);
+        const returnTypes = fnDefinition.exitPoints.map(ep => graph.get(ep, true)).filter(assert_1.isNotUndefined)
+            .map(([vertex]) => ({
+            explicit: vertex.tag === 'function-call' && vertex.name === 'return',
+            location: input.normalizedRAst.idMap.get(vertex.id)?.location?.start ?? { line: -1, column: -1 }
+        }));
+        if (definitionStack.length > 0) {
+            info.nestedFunctions++;
+            info.deepestNesting = Math.max(info.deepestNesting, definitionStack.length);
+            (0, output_1.appendStatisticsFile)(exports.definedFunctions.name, 'nested-definitions', [node.info.fullLexeme ?? node.lexeme], input.filepath);
+        }
+        // parameter names:
+        const parameterNames = node.parameters.map(p => p.info.fullLexeme ?? p.lexeme);
+        (0, output_1.appendStatisticsFile)(exports.definedFunctions.name, 'usedParameterNames', parameterNames, input.filepath);
+        const isLambda = node.lexeme.startsWith('\\');
+        if (isLambda) {
+            info.lambdasOnly++;
+            (0, output_1.appendStatisticsFile)(exports.definedFunctions.name, 'allLambdas', [node.info.fullLexeme ?? node.lexeme], input.filepath);
+        }
+        definitionStack.push(node);
+        // we find definitions with silly defined-by edges
+        const assigned = new Set();
+        const edges = input.dataflow.graph.ingoingEdges(node.info.id);
+        if (edges !== undefined) {
+            for (const [targetId, edge] of edges) {
+                if (edge.types.has(dataflow_1.EdgeType.DefinedBy)) {
+                    const target = input.normalizedRAst.idMap.get(targetId);
+                    (0, assert_1.guard)(target !== undefined, 'Dataflow edge points to unknown node');
+                    const name = target.info.fullLexeme ?? target.lexeme;
+                    if (name) {
+                        assigned.add(name);
+                    }
+                    info.assignedFunctions++;
+                    (0, output_1.appendStatisticsFile)(exports.definedFunctions.name, 'assignedFunctions', [name ?? '<unknown>'], input.filepath);
+                }
+                if (edge.types.has(dataflow_1.EdgeType.Calls)) {
+                    const target = input.normalizedRAst.idMap.get(targetId);
+                    (0, assert_1.guard)(target !== undefined, 'Dataflow edge points to unknown node');
+                }
+            }
+        }
+        // track all calls with the same name that do not already have a bound calls edge, superfluous if recursive tracking is explicit
+        const recursiveCalls = [];
+        (0, r_bridge_1.visitAst)(node.body, n => {
+            if (n.type === "RFunctionCall" /* RType.FunctionCall */ && n.flavor === 'named' && assigned.has(n.functionName.lexeme)) {
+                recursiveCalls.push(n);
+            }
+        });
+        // one recursive definition, but we record all
+        info.recursive += recursiveCalls.length > 0 ? 1 : 0;
+        (0, output_1.appendStatisticsFile)(exports.definedFunctions.name, 'recursive', recursiveCalls.map(n => n.info.fullLexeme ?? n.lexeme ?? 'unknown'), input.filepath);
+        const lexeme = node.info.fullLexeme;
+        const lexemeSplit = lexeme?.split('\n');
+        allDefinitions.push({
+            location: node.location.start,
+            callsites: retrieveAllCallsites(input, node, recursiveCalls),
+            numberOfParameters: node.parameters.length,
+            returns: returnTypes,
+            length: {
+                lines: lexemeSplit?.length ?? -1,
+                characters: lexeme?.length ?? -1,
+                nonWhitespaceCharacters: lexeme?.replaceAll(/\s/g, '').length ?? 0
+            }
+        });
+    }, node => {
+        // drop again :D
+        if (node.type === "RFunctionDefinition" /* RType.FunctionDefinition */) {
+            definitionStack.pop();
+        }
+    });
+    info.total += allDefinitions.length;
+    (0, output_1.appendStatisticsFile)(exports.definedFunctions.name, exports.AllDefinitionsFileBase, allDefinitions, input.filepath);
+}
+exports.definedFunctions = {
+    name: 'Defined Functions',
+    description: 'All functions defined within the document',
+    process(existing, input) {
+        visitDefinitions(existing, input);
+        return existing;
+    },
+    initialValue: initialFunctionDefinitionInfo,
+    postProcess: post_process_1.postProcess
+};
+//# sourceMappingURL=defined-functions.js.map

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

@@ -0,0 +1 @@
+export { definedFunctions } from './defined-functions';