@eagleoutice/flowr 1.5.2 → 2.0.1

package/core/steps.js

@@ -1,100 +0,0 @@
-"use strict";
-/**
- * This file defines *all* steps of the slicing process and the data they require.
- *
- * Note, that the order of elements here also describes the *desired* order of their desired execution for readability.
- * However, it is the {@link SteppingSlicer} which controls the order of execution and the steps required to achieve a given result.
- *
- * If you add a new step, you have to (at least) update the {@link SteppingSlicer} as well as the corresponding type predicate {@link SteppingSlicerInput}.
- * Furthermore, if your step is the new *last* step, please update {@link LAST_STEP}.
- *
- * Please note that the combination of `satisfies` and `as` seems to be required.
- * With `satisfies` we make sure that the respective element has all the keys it requires, and the `as` force the type to be exactly the given one
- *
- * @module
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.printStepResult = exports.executeSingleSubStep = exports.LAST_STEP = exports.LAST_PER_FILE_STEP = exports.STEPS = exports.STEPS_PER_SLICE = exports.STEPS_PER_FILE = void 0;
-const r_bridge_1 = require("../r-bridge");
-const dataflow_1 = require("../dataflow");
-const slicing_1 = require("../slicing");
-const print_1 = require("./print/print");
-const normalize_printer_1 = require("./print/normalize-printer");
-const assert_1 = require("../util/assert");
-const parse_printer_1 = require("./print/parse-printer");
-const dataflow_printer_1 = require("./print/dataflow-printer");
-const parser_1 = require("../r-bridge/lang-4.x/ast/parser/json/parser");
-exports.STEPS_PER_FILE = {
-    'parse': {
-        description: 'Parse the given R code into an AST',
-        processor: (r, s) => (0, r_bridge_1.retrieveParseDataFromRCode)(r, s),
-        required: 'once-per-file',
-        printer: {
-            [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter,
-            [2 /* StepOutputFormat.Json */]: text => text,
-            [5 /* StepOutputFormat.RdfQuads */]: parse_printer_1.parseToQuads
-        }
-    },
-    'normalize': {
-        description: 'Normalize the AST to flowR\'s AST (first step of the normalization)',
-        processor: (j, h, g) => (0, parser_1.normalize)(j, h, g),
-        required: 'once-per-file',
-        printer: {
-            [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter,
-            [2 /* StepOutputFormat.Json */]: normalize_printer_1.normalizedAstToJson,
-            [5 /* StepOutputFormat.RdfQuads */]: normalize_printer_1.normalizedAstToQuads,
-            [3 /* StepOutputFormat.Mermaid */]: normalize_printer_1.printNormalizedAstToMermaid,
-            [4 /* StepOutputFormat.MermaidUrl */]: normalize_printer_1.printNormalizedAstToMermaidUrl
-        }
-    },
-    'dataflow': {
-        description: 'Construct the dataflow graph',
-        processor: (r, a) => (0, dataflow_1.produceDataFlowGraph)(r, a),
-        required: 'once-per-file',
-        printer: {
-            [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter,
-            [2 /* StepOutputFormat.Json */]: dataflow_printer_1.dataflowGraphToJson,
-            [5 /* StepOutputFormat.RdfQuads */]: dataflow_printer_1.dataflowGraphToQuads,
-            [3 /* StepOutputFormat.Mermaid */]: dataflow_printer_1.dataflowGraphToMermaid,
-            [4 /* StepOutputFormat.MermaidUrl */]: dataflow_printer_1.dataflowGraphToMermaidUrl
-        }
-    }
-};
-exports.STEPS_PER_SLICE = {
-    'slice': {
-        description: 'Calculate the actual static slice from the dataflow graph and the given slicing criteria',
-        processor: (d, a, c) => (0, slicing_1.staticSlicing)(d, a, c),
-        required: 'once-per-slice',
-        printer: {
-            [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter
-        }
-    },
-    'reconstruct': {
-        description: 'Reconstruct R code from the static slice',
-        processor: (a, s) => (0, slicing_1.reconstructToCode)(a, s),
-        required: 'once-per-slice',
-        printer: {
-            [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter
-        }
-    }
-};
-exports.STEPS = { ...exports.STEPS_PER_FILE, ...exports.STEPS_PER_SLICE };
-exports.LAST_PER_FILE_STEP = 'dataflow';
-exports.LAST_STEP = 'reconstruct';
-function executeSingleSubStep(subStep, ...input) {
-    // @ts-expect-error - this is safe, as we know that the function arguments are correct by 'satisfies', this saves an explicit cast with 'as'
-    return exports.STEPS[subStep].processor(...input);
-}
-exports.executeSingleSubStep = executeSingleSubStep;
-/**
- * For a `step` of the given name, which returned the given `data`. Convert that data into the given `format`.
- * Depending on your step and the format this may require `additional` inputs.
- */
-function printStepResult(step, data, format, ...additional) {
-    const base = exports.STEPS[step].printer;
-    const printer = base[format];
-    (0, assert_1.guard)(printer !== undefined, `printer for ${step} does not support ${String(format)}`);
-    return printer(data, ...additional);
-}
-exports.printStepResult = printStepResult;
-//# sourceMappingURL=steps.js.map

package/dataflow/environments/index.d.ts

@@ -1,7 +0,0 @@
-export * from './append';
-export * from './resolve-by-name';
-export * from './scoping';
-export * from './overwrite';
-export * from './environment';
-export * from './register';
-export { DataflowScopeName } from './scopes';

package/dataflow/environments/index.js

@@ -1,23 +0,0 @@
-"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./append"), exports);
-__exportStar(require("./resolve-by-name"), exports);
-__exportStar(require("./scoping"), exports);
-__exportStar(require("./overwrite"), exports);
-__exportStar(require("./environment"), exports);
-__exportStar(require("./register"), exports);
-//# sourceMappingURL=index.js.map

package/dataflow/environments/register.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.define = void 0;
-const environment_1 = require("./environment");
-const scopes_1 = require("./scopes");
-const assert_1 = require("../../util/assert");
-/**
- * Insert the given `definition` --- defined within the given scope --- into the passed along `environments` will take care of propagation.
- * Does not modify the passed along `environments` in-place! It returns the new reference.
- */
-function define(definition, withinScope, environments) {
-    let newEnvironments = environments;
-    (0, assert_1.guard)(withinScope === definition.scope, 'Mismatching scopes');
-    if (withinScope === scopes_1.LocalScope) {
-        newEnvironments = (0, environment_1.cloneEnvironments)(environments, false);
-        newEnvironments.current.memory.set(definition.name, [definition]);
-    }
-    else if (withinScope === scopes_1.GlobalScope) {
-        newEnvironments = (0, environment_1.cloneEnvironments)(environments, true);
-        let current = newEnvironments.current;
-        let last = undefined;
-        let found = false;
-        do {
-            if (current.memory.has(definition.name)) {
-                current.memory.set(definition.name, [definition]);
-                found = true;
-                break;
-            }
-            last = current;
-            current = current.parent;
-        } while (current !== undefined);
-        if (!found) {
-            (0, assert_1.guard)(last !== undefined, () => `Could not find global scope for ${definition.name}`);
-            last.memory.set(definition.name, [definition]);
-        }
-    }
-    return newEnvironments;
-}
-exports.define = define;
-//# sourceMappingURL=register.js.map

package/dataflow/environments/scopes.d.ts

@@ -1,6 +0,0 @@
-export declare const GlobalScope = ".GlobalEnv";
-export declare const LocalScope = "local";
-/**
- * Used to represent usual R scopes
- */
-export type DataflowScopeName = /** default R global environment */ typeof GlobalScope | /** unspecified automatic local environment */ typeof LocalScope | /** named environments */ string;

package/dataflow/environments/scopes.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LocalScope = exports.GlobalScope = void 0;
-exports.GlobalScope = '.GlobalEnv';
-exports.LocalScope = 'local';
-//# sourceMappingURL=scopes.js.map

package/dataflow/graph/index.d.ts

@@ -1,4 +0,0 @@
-export * from './graph';
-export * from './edge';
-export * from './vertex';
-export * from './diff';

package/dataflow/graph/index.js

@@ -1,21 +0,0 @@
-"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./graph"), exports);
-__exportStar(require("./edge"), exports);
-__exportStar(require("./vertex"), exports);
-__exportStar(require("./diff"), exports);
-//# sourceMappingURL=index.js.map

package/dataflow/index.d.ts

@@ -1,5 +0,0 @@
-export declare const dataflowLogger: import("tslog").Logger<import("tslog").ILogObj>;
-export * from './graph';
-export * from './extractor';
-export * from './environments/environment';
-export * from '../util/mermaid/dfg';

package/dataflow/index.js

@@ -1,24 +0,0 @@
-"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dataflowLogger = void 0;
-const log_1 = require("../util/log");
-exports.dataflowLogger = log_1.log.getSubLogger({ name: 'dataflow' });
-__exportStar(require("./graph"), exports);
-__exportStar(require("./extractor"), exports);
-__exportStar(require("./environments/environment"), exports);
-__exportStar(require("../util/mermaid/dfg"), exports);
-//# sourceMappingURL=index.js.map

package/dataflow/internal/info.d.ts

@@ -1,21 +0,0 @@
-import { DataflowGraph } from '../graph';
-import type { REnvironmentInformation, IdentifierReference, DataflowScopeName } from '../environments';
-import type { DataflowProcessorInformation } from '../processor';
-/**
- * Continuously updated during the dataflow analysis to hold the current state.
- */
-export interface DataflowInformation {
-    /** Nodes that have not been identified as read or write and will be so on higher */
-    unknownReferences: IdentifierReference[];
-    /** Nodes which are read */
-    in: IdentifierReference[];
-    /** Nodes which are written to */
-    out: IdentifierReference[];
-    /** The current scope during the fold */
-    scope: DataflowScopeName;
-    /** Current environments used for name resolution, probably updated on the next expression-list processing */
-    environments: REnvironmentInformation;
-    /** The current constructed dataflow graph */
-    graph: DataflowGraph;
-}
-export declare function initializeCleanInfo<T>(data: DataflowProcessorInformation<T>): DataflowInformation;

package/dataflow/internal/info.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeCleanInfo = void 0;
-const graph_1 = require("../graph");
-function initializeCleanInfo(data) {
-    return {
-        unknownReferences: [],
-        in: [],
-        out: [],
-        scope: data.activeScope,
-        environments: data.environments,
-        graph: new graph_1.DataflowGraph()
-    };
-}
-exports.initializeCleanInfo = initializeCleanInfo;
-//# sourceMappingURL=info.js.map

package/dataflow/internal/process/access.d.ts

@@ -1,4 +0,0 @@
-import type { ParentInformation, RAccess } from '../../../r-bridge';
-import type { DataflowInformation } from '../info';
-import type { DataflowProcessorInformation } from '../../processor';
-export declare function processAccess<OtherInfo>(node: RAccess<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/access.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processAccess = void 0;
-const processor_1 = require("../../processor");
-const environments_1 = require("../../environments");
-const graph_1 = require("../../graph");
-function processAccess(node, data) {
-    const processedAccessed = (0, processor_1.processDataflowFor)(node.accessed, data);
-    const nextGraph = processedAccessed.graph;
-    const outgoing = processedAccessed.out;
-    const ingoing = processedAccessed.in;
-    const environments = processedAccessed.environments;
-    const accessedNodes = processedAccessed.unknownReferences;
-    if (node.operator === '[' || node.operator === '[[') {
-        for (const access of node.access) {
-            if (access === null || access.value === undefined) {
-                continue;
-            }
-            const processedAccess = (0, processor_1.processDataflowFor)(access, data);
-            nextGraph.mergeWith(processedAccess.graph);
-            // outgoing.push()
-            // we link to *out* instead of *in*, as access uses arguments for parsing and the arguments are defined
-            for (const newIn of [...processedAccess.out, ...processedAccess.unknownReferences]) {
-                for (const accessedNode of accessedNodes) {
-                    nextGraph.addEdge(accessedNode, newIn, graph_1.EdgeType.Reads, 'always');
-                }
-            }
-            ingoing.push(...processedAccess.in, ...processedAccess.unknownReferences);
-            (0, environments_1.overwriteEnvironments)(environments, processedAccess.environments);
-        }
-    }
-    return {
-        /*
-     * keep active nodes in case of assignments etc.
-     * We make them maybe as a kind of hack.
-     * This way when using
-     * ```ts
-     * a[[1]] <- 3
-     * a[[2]] <- 4
-     * a
-     * ```
-     * the read for a will use both accesses as potential definitions and not just the last one!
-     */
-        unknownReferences: (0, environments_1.makeAllMaybe)(processedAccessed.unknownReferences, nextGraph, environments),
-        in: ingoing,
-        out: outgoing,
-        environments: environments,
-        scope: data.activeScope,
-        graph: nextGraph
-    };
-}
-exports.processAccess = processAccess;
-//# sourceMappingURL=access.js.map

package/dataflow/internal/process/expression-list.d.ts

@@ -1,8 +0,0 @@
-/**
- * Processes a list of expressions joining their dataflow graphs accordingly.
- * @module
- */
-import type { DataflowInformation } from '../info';
-import type { ParentInformation, RExpressionList } from '../../../r-bridge';
-import type { DataflowProcessorInformation } from '../../processor';
-export declare function processExpressionList<OtherInfo>(exprList: RExpressionList<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/expression-list.js

@@ -1,144 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processExpressionList = void 0;
-const info_1 = require("../info");
-const r_bridge_1 = require("../../../r-bridge");
-const processor_1 = require("../../processor");
-const environments_1 = require("../../environments");
-const linker_1 = require("../linker");
-const defaultmap_1 = require("../../../util/defaultmap");
-const graph_1 = require("../../graph");
-const index_1 = require("../../index");
-const assert_1 = require("../../../util/assert");
-const dotDotDotAccess = /\.\.\d+/;
-function linkReadNameToWriteIfPossible(read, data, environments, listEnvironments, remainingRead, nextGraph) {
-    const readName = dotDotDotAccess.test(read.name) ? '...' : read.name;
-    const probableTarget = (0, environments_1.resolveByName)(readName, data.activeScope, environments);
-    // record if at least one has not been defined
-    if (probableTarget === undefined || probableTarget.some(t => !listEnvironments.has(t.nodeId))) {
-        if (remainingRead.has(readName)) {
-            remainingRead.get(readName)?.push(read);
-        }
-        else {
-            remainingRead.set(readName, [read]);
-        }
-    }
-    // keep it, for we have no target, as read-ids are unique within same fold, this should work for same links
-    // we keep them if they are defined outside the current parent and maybe throw them away later
-    if (probableTarget === undefined) {
-        return;
-    }
-    for (const target of probableTarget) {
-        // we can stick with maybe even if readId.attribute is always
-        nextGraph.addEdge(read, target, index_1.EdgeType.Reads, undefined, true);
-    }
-}
-function processNextExpression(currentElement, data, environments, listEnvironments, remainingRead, nextGraph) {
-    // all inputs that have not been written until know, are read!
-    for (const read of [...currentElement.in, ...currentElement.unknownReferences]) {
-        linkReadNameToWriteIfPossible(read, data, environments, listEnvironments, remainingRead, nextGraph);
-    }
-    // add same variable reads for deferred if they are read previously but not dependent
-    for (const writeTarget of currentElement.out) {
-        const writeName = writeTarget.name;
-        const resolved = (0, environments_1.resolveByName)(writeName, data.activeScope, environments);
-        if (resolved !== undefined) {
-            // write-write
-            for (const target of resolved) {
-                nextGraph.addEdge(target, writeTarget, index_1.EdgeType.SameDefDef, undefined, true);
-            }
-        }
-    }
-}
-function updateSideEffectsForCalledFunctions(calledEnvs, environments, nextGraph) {
-    for (const { functionCall, called } of calledEnvs) {
-        for (const calledFn of called) {
-            (0, assert_1.guard)(calledFn.tag === 'function-definition', 'called function must call a function definition');
-            // only merge the environments they have in common
-            let environment = calledFn.environment;
-            while (environment.level > environments.level) {
-                environment = (0, environments_1.popLocalEnvironment)(environment);
-            }
-            // update alle definitions to be defined at this function call
-            let current = environment.current;
-            while (current !== undefined) {
-                for (const definitions of current.memory.values()) {
-                    for (const def of definitions) {
-                        if (def.kind !== 'built-in-function') {
-                            nextGraph.addEdge(def.nodeId, functionCall, index_1.EdgeType.SideEffectOnCall, def.used);
-                        }
-                    }
-                }
-                current = current.parent;
-            }
-            // we update all definitions to be linked with teh corresponding function call
-            environments = (0, environments_1.overwriteEnvironments)(environments, environment);
-        }
-    }
-    return environments;
-}
-function processExpressionList(exprList, data) {
-    const expressions = exprList.children;
-    index_1.dataflowLogger.trace(`processing expression list with ${expressions.length} expressions`);
-    if (expressions.length === 0) {
-        return (0, info_1.initializeCleanInfo)(data);
-    }
-    let environments = data.environments;
-    // used to detect if a "write" happens within the same expression list
-    const listEnvironments = new Set();
-    const remainingRead = new Map();
-    const nextGraph = new graph_1.DataflowGraph();
-    const out = [];
-    let expressionCounter = 0;
-    let foundNextOrBreak = false;
-    for (const expression of expressions) {
-        index_1.dataflowLogger.trace(`processing expression ${++expressionCounter} of ${expressions.length}`);
-        // use the current environments for processing
-        data = { ...data, environments };
-        const processed = (0, processor_1.processDataflowFor)(expression, data);
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- seems to be a bug in eslint
-        if (!foundNextOrBreak) {
-            (0, r_bridge_1.visitAst)(expression, n => {
-                if (n.type === "RNext" /* RType.Next */ || n.type === "RBreak" /* RType.Break */) {
-                    foundNextOrBreak = true;
-                }
-                return n.type === "RForLoop" /* RType.ForLoop */ || n.type === "RWhileLoop" /* RType.WhileLoop */ || n.type === "RRepeatLoop" /* RType.RepeatLoop */ || n.type === "RFunctionDefinition" /* RType.FunctionDefinition */;
-            });
-        }
-        // if the expression contained next or break anywhere before the next loop, the overwrite should be an append because we do not know if the rest is executed
-        // update the environments for the next iteration with the previous writes
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- seems to be a bug in eslint
-        if (foundNextOrBreak) {
-            processed.out = (0, environments_1.makeAllMaybe)(processed.out, nextGraph, processed.environments);
-            processed.in = (0, environments_1.makeAllMaybe)(processed.in, nextGraph, processed.environments);
-            processed.unknownReferences = (0, environments_1.makeAllMaybe)(processed.unknownReferences, nextGraph, processed.environments);
-        }
-        nextGraph.mergeWith(processed.graph);
-        out.push(...processed.out);
-        index_1.dataflowLogger.trace(`expression ${expressionCounter} of ${expressions.length} has ${processed.unknownReferences.length} unknown nodes`);
-        processNextExpression(processed, data, environments, listEnvironments, remainingRead, nextGraph);
-        const functionCallIds = [...processed.graph.vertices(true)]
-            .filter(([_, info]) => info.tag === 'function-call');
-        const calledEnvs = (0, linker_1.linkFunctionCalls)(nextGraph, data.completeAst.idMap, functionCallIds, processed.graph);
-        environments = (0, environments_1.overwriteEnvironments)(environments, processed.environments);
-        // if the called function has global redefinitions, we have to keep them within our environment
-        environments = updateSideEffectsForCalledFunctions(calledEnvs, environments, nextGraph);
-        for (const { nodeId } of processed.out) {
-            listEnvironments.add(nodeId);
-        }
-    }
-    // now, we have to link same reads
-    (0, linker_1.linkReadVariablesInSameScopeWithNames)(nextGraph, new defaultmap_1.DefaultMap(() => [], remainingRead));
-    index_1.dataflowLogger.trace(`expression list exits with ${remainingRead.size} remaining read names`);
-    return {
-        /* no active nodes remain, they are consumed within the remaining read collection */
-        unknownReferences: [],
-        in: [...remainingRead.values()].flat(),
-        out,
-        environments,
-        scope: data.activeScope,
-        graph: nextGraph
-    };
-}
-exports.processExpressionList = processExpressionList;
-//# sourceMappingURL=expression-list.js.map

package/dataflow/internal/process/functions/argument.d.ts

@@ -1,8 +0,0 @@
-import type { DataflowInformation } from '../../info';
-import type { DataflowProcessorInformation } from '../../../processor';
-import type { ParentInformation, RArgument, RNode } from '../../../../r-bridge';
-import { DataflowGraph } from '../../../graph';
-import type { IdentifierReference } from '../../../environments';
-export declare const UnnamedArgumentPrefix = "unnamed-argument-";
-export declare function linkReadsForArgument<OtherInfo>(root: RNode<OtherInfo & ParentInformation>, ingoingRefs: IdentifierReference[], graph: DataflowGraph): void;
-export declare function processFunctionArgument<OtherInfo>(argument: RArgument<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/exit-points.d.ts

@@ -1,2 +0,0 @@
-import type { NodeId, ParentInformation, RFunctionDefinition } from '../../../../r-bridge';
-export declare function retrieveExitPointsOfFunctionDefinition<OtherInfo>(functionDefinition: RFunctionDefinition<OtherInfo & ParentInformation>): NodeId[];

package/dataflow/internal/process/functions/exit-points.js

@@ -1,121 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.retrieveExitPointsOfFunctionDefinition = void 0;
-const assert_1 = require("../../../../util/assert");
-function retrieveExitPointsOfFunctionDefinition(functionDefinition) {
-    const exitPoints = visitExitPoints(functionDefinition.body);
-    return exitPoints.knownIds.concat(exitPoints.potentialIds);
-}
-exports.retrieveExitPointsOfFunctionDefinition = retrieveExitPointsOfFunctionDefinition;
-function visitExitPoints(node) {
-    const type = node.type;
-    switch (type) {
-        case "RExpressionList" /* RType.ExpressionList */:
-            return visitExpressionList(node);
-        case "RFunctionCall" /* RType.FunctionCall */:
-            if (node.flavor === 'named' && node.functionName.content === 'return') {
-                return {
-                    knownIds: [node.info.id],
-                    potentialIds: []
-                };
-            }
-            break;
-        case "RFunctionDefinition" /* RType.FunctionDefinition */:
-            // do not further investigate
-            break;
-        case "RForLoop" /* RType.ForLoop */:
-        case "RWhileLoop" /* RType.WhileLoop */:
-        case "RRepeatLoop" /* RType.RepeatLoop */:
-            // loops return invisible null, as we do not trace values, but they may contain return statements
-            return visitLoops(node);
-        case "RIfThenElse" /* RType.IfThenElse */:
-            return visitIf(node);
-        case "RPipe" /* RType.Pipe */:
-        case "RBinaryOp" /* RType.BinaryOp */:
-            // assignments return invisible rhs
-            return knownIdsOfChildren(node.info.id, node.lhs, node.rhs);
-        case "RUnaryOp" /* RType.UnaryOp */:
-            return knownIdsOfChildren(node.info.id, node.operand);
-        case "RParameter" /* RType.Parameter */:
-            return node.defaultValue ? knownIdsOfChildren(node.info.id, node.defaultValue) : { knownIds: [], potentialIds: [] };
-        case "RArgument" /* RType.Argument */:
-            return node.value ? knownIdsOfChildren(node.info.id, node.value) : { knownIds: [], potentialIds: [] };
-        case "RSymbol" /* RType.Symbol */:
-        case "RLogical" /* RType.Logical */:
-        case "RNumber" /* RType.Number */:
-        case "RString" /* RType.String */:
-        case "RAccess" /* RType.Access */:
-            // just use this node
-            break;
-        // contain noting to return/return `invisible(null)`
-        case "RComment" /* RType.Comment */:
-        case "RLineDirective" /* RType.LineDirective */:
-        case "RBreak" /* RType.Break */:
-        case "RNext" /* RType.Next */:
-            return { knownIds: [], potentialIds: [] };
-        default:
-            (0, assert_1.assertUnreachable)(type);
-    }
-    return {
-        knownIds: [],
-        potentialIds: [node.info.id]
-    };
-}
-// we use keepSelfAsPotential in order to track nodes like 2 + 3, which keep themselves as potential exit points if there are no knownIds
-function knownIdsOfChildren(keepSelfAsPotential, ...children) {
-    const knownIds = children.flatMap(child => visitExitPoints(child).knownIds);
-    return {
-        knownIds,
-        potentialIds: knownIds.length === 0 ? [keepSelfAsPotential] : []
-    };
-}
-function visitLoops(loop) {
-    const result = visitExitPoints(loop.body);
-    // conditions may contain return statements which we have to keep
-    let otherKnownIds = [];
-    if (loop.type === "RForLoop" /* RType.ForLoop */) {
-        otherKnownIds = visitExitPoints(loop.variable).knownIds;
-        otherKnownIds.push(...visitExitPoints(loop.vector).knownIds);
-    }
-    else if (loop.type === "RWhileLoop" /* RType.WhileLoop */) {
-        otherKnownIds = visitExitPoints(loop.condition).knownIds;
-    }
-    return {
-        knownIds: [...result.knownIds, ...otherKnownIds],
-        potentialIds: []
-    };
-}
-function visitExpressionList(node) {
-    const known = [];
-    let lastPotentialIds = [];
-    // we only keep the potential ids of the last expression, which is no comment
-    for (const child of node.children) {
-        const { knownIds, potentialIds } = visitExitPoints(child);
-        known.push(...knownIds);
-        if (child.type !== "RComment" /* RType.Comment */) {
-            lastPotentialIds = potentialIds;
-        }
-    }
-    return {
-        knownIds: known,
-        potentialIds: lastPotentialIds
-    };
-}
-function visitIf(node) {
-    // conditions can contain return statements
-    const known = visitExitPoints(node.condition).knownIds;
-    const potential = [];
-    const thenCase = visitExitPoints(node.then);
-    known.push(...thenCase.knownIds);
-    potential.push(...thenCase.potentialIds);
-    if (node.otherwise !== undefined) {
-        const otherwiseCase = visitExitPoints(node.otherwise);
-        known.push(...otherwiseCase.knownIds);
-        potential.push(...otherwiseCase.potentialIds);
-    }
-    return {
-        knownIds: known,
-        potentialIds: potential
-    };
-}
-//# sourceMappingURL=exit-points.js.map

package/dataflow/internal/process/functions/function-call.d.ts

@@ -1,5 +0,0 @@
-import type { DataflowInformation } from '../../info';
-import type { DataflowProcessorInformation } from '../../../processor';
-import type { ParentInformation, RFunctionCall } from '../../../../r-bridge';
-export declare const UnnamedFunctionCallPrefix = "unnamed-function-call-";
-export declare function processFunctionCall<OtherInfo>(functionCall: RFunctionCall<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;