@eagleoutice/flowr 1.4.2 → 1.5.0

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

@@ -1,50 +0,0 @@
-"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 fs_1 = __importDefault(require("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 = 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

@@ -1,17 +0,0 @@
-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

@@ -1,67 +0,0 @@
-"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

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

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

@@ -1,6 +0,0 @@
-"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

@@ -1,3 +0,0 @@
-import type { FeatureStatisticsWithMeta } from '../../feature';
-import type { 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

@@ -1,65 +0,0 @@
-"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

@@ -1,15 +0,0 @@
-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

@@ -1,118 +0,0 @@
-"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

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

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

@@ -1,6 +0,0 @@
-"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

@@ -1,3 +0,0 @@
-import type { FeatureStatisticsWithMeta } from '../../feature';
-import type { 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

@@ -1,107 +0,0 @@
-"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 fs_1 = __importDefault(require("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 = 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 = 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 = 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

@@ -1,35 +0,0 @@
-import type { Feature } from '../../feature';
-import type { Writable } from 'ts-essentials';
-import type { SourcePosition } from '../../../../util/range';
-import type { 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

@@ -1,139 +0,0 @@
-"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

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