@eagleoutice/flowr 1.5.2 → 2.0.1

package/slicing/criterion/parse.d.ts

@@ -1,4 +1,6 @@
-import type { NormalizedAst, NodeId, NoInfo, ParentInformation } from '../../r-bridge';
+import type { NoInfo } from '../../r-bridge/lang-4.x/ast/model/model';
+import { type NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 /** Either `line:column`, `line@variable-name`, or `$id` */
 export type SingleSlicingCriterion = `${number}:${number}` | `${number}@${string}` | `$${number}`;
 export type SlicingCriteria = SingleSlicingCriterion[];
@@ -16,5 +18,5 @@ export interface DecodedCriterion {
     criterion: SingleSlicingCriterion;
     id: NodeId;
 }
-export type DecodedCriteria = DecodedCriterion[];
+export type DecodedCriteria = ReadonlyArray<DecodedCriterion>;
 export declare function convertAllSlicingCriteriaToIds(criteria: SlicingCriteria, decorated: NormalizedAst): DecodedCriteria;

package/slicing/criterion/parse.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertAllSlicingCriteriaToIds = exports.slicingCriterionToId = exports.CriteriaParseError = void 0;
-const static_1 = require("../static");
+const log_1 = require("../../util/log");
+const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
+const static_slicer_1 = require("../static/static-slicer");
 /**
  * Thrown if the given slicing criteria can not be found
  */
@@ -19,14 +21,14 @@ function slicingCriterionToId(criterion, decorated) {
     let resolved;
     if (criterion.includes(':')) {
         const [line, column] = criterion.split(':').map(c => parseInt(c));
-        resolved = locationToId({ line, column }, decorated.idMap);
+        resolved = locationToId([line, column], decorated.idMap);
     }
     else if (criterion.includes('@')) {
         const [line, name] = criterion.split(/@(.*)/s); // only split at first occurrence
         resolved = conventionalCriteriaToId(parseInt(line), name, decorated.idMap);
     }
     else if (criterion.startsWith('$')) {
-        resolved = criterion.substring(1);
+        resolved = (0, node_id_1.normalizeIdToNumberIfPossible)(criterion.substring(1));
     }
     if (resolved === undefined) {
         throw new CriteriaParseError(`invalid slicing criterion ${criterion}`);
@@ -37,38 +39,38 @@ exports.slicingCriterionToId = slicingCriterionToId;
 function locationToId(location, dataflowIdMap) {
     let candidate;
     for (const [id, nodeInfo] of dataflowIdMap.entries()) {
-        if (nodeInfo.location === undefined || nodeInfo.location.start.line !== location.line || nodeInfo.location.start.column !== location.column) {
+        if (nodeInfo.location === undefined || nodeInfo.location[0] !== location[0] || nodeInfo.location[1] !== location[1]) {
             continue; // only consider those with position information
         }
-        static_1.slicerLogger.trace(`can resolve id ${id} (${JSON.stringify(nodeInfo.location)}) for location ${JSON.stringify(location)}`);
+        (0, log_1.expensiveTrace)(static_slicer_1.slicerLogger, () => `can resolve id ${id} (${JSON.stringify(nodeInfo.location)}) for location ${JSON.stringify(location)}`);
         // function calls have the same location as the symbol they refer to, so we need to prefer the function call
-        if (candidate !== undefined && nodeInfo.type !== "RFunctionCall" /* RType.FunctionCall */ && nodeInfo.type !== "RArgument" /* RType.Argument */ || nodeInfo.type === "RExpressionList" /* RType.ExpressionList */) {
+        if (candidate !== undefined && nodeInfo.type !== "RFunctionCall" /* RType.FunctionCall */ || nodeInfo.type === "RArgument" /* RType.Argument */ || nodeInfo.type === "RExpressionList" /* RType.ExpressionList */) {
             continue;
         }
         candidate = nodeInfo;
     }
     const id = candidate?.info.id;
     if (id) {
-        static_1.slicerLogger.trace(`resolve id ${id} (${JSON.stringify(candidate?.info)}) for location ${JSON.stringify(location)}`);
+        (0, log_1.expensiveTrace)(static_slicer_1.slicerLogger, () => `resolve id ${id} (${JSON.stringify(candidate?.info)}) for location ${JSON.stringify(location)}`);
     }
     return id;
 }
 function conventionalCriteriaToId(line, name, dataflowIdMap) {
     let candidate;
     for (const [id, nodeInfo] of dataflowIdMap.entries()) {
-        if (nodeInfo.location === undefined || nodeInfo.location.start.line !== line || nodeInfo.lexeme !== name) {
+        if (nodeInfo.location === undefined || nodeInfo.location[0] !== line || nodeInfo.lexeme !== name) {
             continue;
         }
-        static_1.slicerLogger.trace(`can resolve id ${id} (${JSON.stringify(nodeInfo)}) for line ${line} and name ${name}`);
+        static_slicer_1.slicerLogger.trace(`can resolve id ${id} (${JSON.stringify(nodeInfo)}) for line ${line} and name ${name}`);
         // function calls have the same location as the symbol they refer to, so we need to prefer the function call
-        if (candidate !== undefined && nodeInfo.type !== "RFunctionCall" /* RType.FunctionCall */ && nodeInfo.type !== "RArgument" /* RType.Argument */ || nodeInfo.type === "RExpressionList" /* RType.ExpressionList */) {
+        if (candidate !== undefined && nodeInfo.type !== "RFunctionCall" /* RType.FunctionCall */ || nodeInfo.type === "RArgument" /* RType.Argument */ || nodeInfo.type === "RExpressionList" /* RType.ExpressionList */) {
             continue;
         }
         candidate = nodeInfo;
     }
     const id = candidate?.info.id;
     if (id) {
-        static_1.slicerLogger.trace(`resolve id ${id} (${JSON.stringify(candidate?.info)}) for line ${line} and name ${name}`);
+        static_slicer_1.slicerLogger.trace(`resolve id ${id} (${JSON.stringify(candidate?.info)}) for line ${line} and name ${name}`);
     }
     return id;
 }

package/slicing/static/fingerprint.d.ts

@@ -0,0 +1,5 @@
+import type { REnvironmentInformation } from '../../dataflow/environments/environment';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+export type Fingerprint = string;
+export declare function envFingerprint(env: REnvironmentInformation): Fingerprint;
+export declare function fingerprint(id: NodeId, envFingerprint: Fingerprint, onlyForSideEffects: boolean): Fingerprint;

package/slicing/static/fingerprint.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fingerprint = exports.envFingerprint = void 0;
+const object_hash_1 = __importDefault(require("object-hash"));
+const environment_1 = require("../../dataflow/environments/environment");
+function envFingerprint(env) {
+    return (0, object_hash_1.default)(env, { excludeKeys: key => key === 'id', replacer: (v) => v === environment_1.BuiltInEnvironment ? undefined : v });
+}
+exports.envFingerprint = envFingerprint;
+function fingerprint(id, envFingerprint, onlyForSideEffects) {
+    return `${id}-${envFingerprint}-${onlyForSideEffects ? '0' : '1'}`;
+}
+exports.fingerprint = fingerprint;
+//# sourceMappingURL=fingerprint.js.map

package/slicing/static/slice-call.d.ts

@@ -0,0 +1,10 @@
+import type { NodeToSlice } from './slicer-types';
+import type { VisitingQueue } from './visiting-queue';
+import type { Fingerprint } from './fingerprint';
+import type { DataflowGraphVertexFunctionCall } from '../../dataflow/graph/vertex';
+import type { REnvironmentInformation } from '../../dataflow/environments/environment';
+import type { DataflowGraph, OutgoingEdges } from '../../dataflow/graph/graph';
+/** returns the new threshold hit count */
+export declare function sliceForCall(current: NodeToSlice, callerInfo: DataflowGraphVertexFunctionCall, dataflowGraph: DataflowGraph, queue: VisitingQueue): void;
+/** Returns true if we found at least one return edge */
+export declare function handleReturns(queue: VisitingQueue, currentEdges: OutgoingEdges, baseEnvFingerprint: Fingerprint, baseEnvironment: REnvironmentInformation): boolean;

package/slicing/static/slice-call.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleReturns = exports.sliceForCall = void 0;
+const assert_1 = require("../../util/assert");
+const fingerprint_1 = require("./fingerprint");
+const linker_1 = require("../../dataflow/internal/linker");
+const scoping_1 = require("../../dataflow/environments/scoping");
+const overwrite_1 = require("../../dataflow/environments/overwrite");
+const built_in_1 = require("../../dataflow/environments/built-in");
+const resolve_by_name_1 = require("../../dataflow/environments/resolve-by-name");
+const edge_1 = require("../../dataflow/graph/edge");
+function retrieveActiveEnvironment(callerInfo, baseEnvironment) {
+    let callerEnvironment = callerInfo.environment;
+    if (baseEnvironment.level !== callerEnvironment.level) {
+        while (baseEnvironment.level < callerEnvironment.level) {
+            baseEnvironment = (0, scoping_1.pushLocalEnvironment)(baseEnvironment);
+        }
+        while (baseEnvironment.level > callerEnvironment.level) {
+            callerEnvironment = (0, scoping_1.pushLocalEnvironment)(callerEnvironment);
+        }
+    }
+    return (0, overwrite_1.overwriteEnvironment)(baseEnvironment, callerEnvironment);
+}
+/** returns the new threshold hit count */
+function sliceForCall(current, callerInfo, dataflowGraph, queue) {
+    // bind with call-local environments during slicing
+    const outgoingEdges = dataflowGraph.get(callerInfo.id, true);
+    (0, assert_1.guard)(outgoingEdges !== undefined, () => `outgoing edges of id: ${callerInfo.id} must be in graph but can not be found, keep in slice to be sure`);
+    // lift baseEnv on the same level
+    const baseEnvironment = current.baseEnvironment;
+    const baseEnvPrint = (0, fingerprint_1.envFingerprint)(baseEnvironment);
+    const activeEnvironment = retrieveActiveEnvironment(callerInfo, baseEnvironment);
+    const activeEnvironmentFingerprint = (0, fingerprint_1.envFingerprint)(activeEnvironment);
+    const name = callerInfo.name;
+    (0, assert_1.guard)(name !== undefined, () => `name of id: ${callerInfo.id} can not be found in id map`);
+    const functionCallDefs = (0, resolve_by_name_1.resolveByName)(name, activeEnvironment)?.filter(d => d.definedAt !== built_in_1.BuiltIn)?.map(d => d.nodeId) ?? [];
+    for (const [target, outgoingEdge] of outgoingEdges[1].entries()) {
+        if ((0, edge_1.edgeIncludesType)(outgoingEdge.types, 4 /* EdgeType.Calls */)) {
+            functionCallDefs.push(target);
+        }
+    }
+    const functionCallTargets = (0, linker_1.getAllLinkedFunctionDefinitions)(new Set(functionCallDefs), dataflowGraph);
+    for (const [_, functionCallTarget] of functionCallTargets) {
+        // all those linked within the scopes of other functions are already linked when exiting a function definition
+        for (const openIn of functionCallTarget.subflow.in) {
+            const defs = openIn.name ? (0, resolve_by_name_1.resolveByName)(openIn.name, activeEnvironment) : undefined;
+            if (defs === undefined) {
+                continue;
+            }
+            for (const def of defs.filter(d => d.nodeId !== built_in_1.BuiltIn)) {
+                queue.add(def.nodeId, baseEnvironment, baseEnvPrint, current.onlyForSideEffects);
+            }
+        }
+        for (const exitPoint of functionCallTarget.exitPoints) {
+            queue.add(exitPoint, activeEnvironment, activeEnvironmentFingerprint, current.onlyForSideEffects);
+        }
+    }
+}
+exports.sliceForCall = sliceForCall;
+/** Returns true if we found at least one return edge */
+function handleReturns(queue, currentEdges, baseEnvFingerprint, baseEnvironment) {
+    let found = false;
+    for (const [, edge] of currentEdges) {
+        if ((0, edge_1.edgeIncludesType)(edge.types, 8 /* EdgeType.Returns */)) {
+            found = true;
+            break;
+        }
+    }
+    if (!found) {
+        return false;
+    }
+    for (const [target, edge] of currentEdges) {
+        if ((0, edge_1.edgeIncludesType)(edge.types, 8 /* EdgeType.Returns */)) {
+            queue.add(target, baseEnvironment, baseEnvFingerprint, false);
+        }
+        else if ((0, edge_1.edgeIncludesType)(edge.types, 1 /* EdgeType.Reads */)) {
+            queue.add(target, baseEnvironment, baseEnvFingerprint, false);
+        }
+        else if ((0, edge_1.edgeIncludesType)(edge.types, 64 /* EdgeType.Argument */)) {
+            queue.potentialArguments.add(target);
+        }
+    }
+    return true;
+}
+exports.handleReturns = handleReturns;
+//# sourceMappingURL=slice-call.js.map

package/slicing/static/slicer-types.d.ts

@@ -0,0 +1,33 @@
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { REnvironmentInformation } from '../../dataflow/environments/environment';
+import type { DecodedCriteria } from '../criterion/parse';
+/**
+ * Represents a node during the slicing process, together with the environment it is traversed in
+ * (modified by function calls) and whether it is only used for its side effects.
+ */
+export interface NodeToSlice {
+    readonly id: NodeId;
+    /** used for calling context, etc. */
+    readonly baseEnvironment: REnvironmentInformation;
+    /** if we add a function call, we may need it only for its side effects (e.g., a redefinition of a global variable), if so, 'returns' links will not be traced */
+    readonly onlyForSideEffects: boolean;
+}
+/**
+ * The result of the slice step
+ */
+export interface SliceResult {
+    /**
+     * Number of times the set threshold was hit (i.e., the same node was visited too often).
+     * While any number above 0 might indicate a wrong slice, it does not have to as usually even revisiting the same node
+     * seldom causes more ids to be included in the slice.
+     */
+    readonly timesHitThreshold: number;
+    /**
+     * The ids of the nodes in the normalized ast that are part of the slice.
+     */
+    readonly result: ReadonlySet<NodeId>;
+    /**
+     * The mapping produced to decode the entered criteria
+     */
+    readonly decodedCriteria: DecodedCriteria;
+}

package/slicing/static/slicer-types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=slicer-types.js.map

package/slicing/static/static-slicer.d.ts

@@ -1,29 +1,11 @@
-import type { DataflowGraph } from '../../dataflow';
-import type { NodeId, NormalizedAst } from '../../r-bridge';
-import type { DecodedCriteria, SlicingCriteria } from '../criterion';
+import type { SliceResult } from './slicer-types';
+import type { DataflowGraph } from '../../dataflow/graph/graph';
+import type { NormalizedAst } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { SlicingCriteria } from '../criterion/parse';
 export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogObj>;
-/**
- * The result of the slice step
- */
-export interface SliceResult {
-    /**
-     * Number of times the set threshold was hit (i.e., the same node was visited too often).
-     * While any number above 0 might indicate a wrong slice, it does not have to as usually even revisiting the same node does not
-     * often cause more ids to be included in the slice.
-     */
-    timesHitThreshold: number;
-    /**
-     * The ids of the nodes in the normalized ast that are part of the slice.
-     */
-    result: Set<NodeId>;
-    /**
-     * The mapping produced to decode the entered criteria
-     */
-    decodedCriteria: DecodedCriteria;
-}
 /**
  * This returns the ids to include in the slice, when slicing with the given seed id's (must be at least one).
  * <p>
- * The returned ids can be used to {@link reconstructToCode | reconstruct the slice to R code}.
+ * The returned ids can be used to {@link reconstructToCode|reconstruct the slice to R code}.
  */
-export declare function staticSlicing(dataflowGraph: DataflowGraph, ast: NormalizedAst, criteria: SlicingCriteria, threshold?: number): Readonly<SliceResult>;
+export declare function staticSlicing(graph: DataflowGraph, ast: NormalizedAst, criteria: SlicingCriteria, threshold?: number): Readonly<SliceResult>;

package/slicing/static/static-slicer.js

@@ -1,186 +1,85 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.staticSlicing = exports.slicerLogger = void 0;
-const dataflow_1 = require("../../dataflow");
 const assert_1 = require("../../util/assert");
-const r_bridge_1 = require("../../r-bridge");
 const log_1 = require("../../util/log");
-const linker_1 = require("../../dataflow/internal/linker");
-const environments_1 = require("../../dataflow/environments");
-const object_hash_1 = __importDefault(require("object-hash"));
-const defaultmap_1 = require("../../util/defaultmap");
-const scopes_1 = require("../../dataflow/environments/scopes");
-const criterion_1 = require("../criterion");
+const fingerprint_1 = require("./fingerprint");
+const visiting_queue_1 = require("./visiting-queue");
+const slice_call_1 = require("./slice-call");
+const parse_1 = require("../criterion/parse");
+const environment_1 = require("../../dataflow/environments/environment");
+const edge_1 = require("../../dataflow/graph/edge");
+const built_in_1 = require("../../dataflow/environments/built-in");
 exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
-function envFingerprint(env) {
-    return (0, object_hash_1.default)(env, { excludeKeys: key => key === 'id' });
-}
-function fingerprint(id, envFingerprint, onlyForSideEffects) {
-    return `${id}-${envFingerprint}-${onlyForSideEffects ? '0' : '1'}`;
-}
-class VisitingQueue {
-    threshold;
-    timesHitThreshold = 0;
-    seen = new Map();
-    idThreshold = new defaultmap_1.DefaultMap(() => 0);
-    queue = [];
-    constructor(threshold) {
-        this.threshold = threshold;
-    }
-    add(target, env, envFingerprint, onlyForSideEffects) {
-        const idCounter = this.idThreshold.get(target);
-        if (idCounter > this.threshold) {
-            exports.slicerLogger.warn(`id: ${target} has been visited ${idCounter} times, skipping`);
-            this.timesHitThreshold++;
-            return;
-        }
-        else {
-            this.idThreshold.set(target, idCounter + 1);
-        }
-        const print = fingerprint(target, envFingerprint, onlyForSideEffects);
-        if (!this.seen.has(print)) {
-            this.seen.set(print, target);
-            this.queue.push({ id: target, baseEnvironment: env, onlyForSideEffects: onlyForSideEffects });
-        }
-    }
-    next() {
-        return this.queue.pop();
-    }
-    has() {
-        return this.queue.length > 0;
-    }
-    status() {
-        return {
-            timesHitThreshold: this.timesHitThreshold,
-            result: new Set(this.seen.values())
-        };
-    }
-}
 /**
  * This returns the ids to include in the slice, when slicing with the given seed id's (must be at least one).
  * <p>
- * The returned ids can be used to {@link reconstructToCode | reconstruct the slice to R code}.
+ * The returned ids can be used to {@link reconstructToCode|reconstruct the slice to R code}.
  */
-function staticSlicing(dataflowGraph, ast, criteria, threshold = 75) {
+function staticSlicing(graph, ast, criteria, threshold = 75) {
     (0, assert_1.guard)(criteria.length > 0, 'must have at least one seed id to calculate slice');
-    const decodedCriteria = (0, criterion_1.convertAllSlicingCriteriaToIds)(criteria, ast);
-    const idMap = ast.idMap;
-    if (exports.slicerLogger.settings.minLevel <= 1 /* LogLevel.Trace */) {
-        exports.slicerLogger.trace(`calculating slice for ${decodedCriteria.length} seed criteria: ${decodedCriteria.map(s => JSON.stringify(s)).join(', ')}`);
-    }
-    const queue = new VisitingQueue(threshold);
+    const decodedCriteria = (0, parse_1.convertAllSlicingCriteriaToIds)(criteria, ast);
+    (0, log_1.expensiveTrace)(exports.slicerLogger, () => `calculating slice for ${decodedCriteria.length} seed criteria: ${decodedCriteria.map(s => JSON.stringify(s)).join(', ')}`);
+    const queue = new visiting_queue_1.VisitingQueue(threshold);
+    let minDepth = Number.MAX_SAFE_INTEGER;
+    const sliceSeedIds = new Set();
     // every node ships the call environment which registers the calling environment
     {
-        const basePrint = envFingerprint((0, dataflow_1.initializeCleanEnvironments)());
+        const emptyEnv = (0, environment_1.initializeCleanEnvironments)();
+        const basePrint = (0, fingerprint_1.envFingerprint)(emptyEnv);
         for (const startId of decodedCriteria) {
-            queue.add(startId.id, (0, dataflow_1.initializeCleanEnvironments)(), basePrint, false);
+            queue.add(startId.id, emptyEnv, basePrint, false);
+            // retrieve the minimum depth of all nodes to only add control dependencies if they are "part" of the current execution
+            minDepth = Math.min(minDepth, ast.idMap.get(startId.id)?.info.depth ?? minDepth);
+            sliceSeedIds.add(startId.id);
         }
     }
-    while (queue.has()) {
+    while (queue.nonEmpty()) {
         const current = queue.next();
-        if (current === undefined) {
-            continue;
-        }
-        const baseEnvFingerprint = envFingerprint(current.baseEnvironment);
-        const currentInfo = dataflowGraph.get(current.id, true);
-        // slicerLogger.trace(`visiting id: ${current.id} with name: ${currentInfo?.[0].name ?? '<unknown>'}`)
+        const { baseEnvironment, id, onlyForSideEffects } = current;
+        const baseEnvFingerprint = (0, fingerprint_1.envFingerprint)(baseEnvironment);
+        const currentInfo = graph.get(id, true);
         if (currentInfo === undefined) {
-            exports.slicerLogger.warn(`id: ${current.id} must be in graph but can not be found, keep in slice to be sure`);
+            exports.slicerLogger.warn(`id: ${id} must be in graph but can not be found, keep in slice to be sure`);
             continue;
         }
-        if (currentInfo[0].tag === 'function-call' && !current.onlyForSideEffects) {
-            exports.slicerLogger.trace(`${current.id} is a function call`);
-            sliceForCall(current, idMap, currentInfo[0], dataflowGraph, queue);
+        const [currentVertex, currentEdges] = currentInfo;
+        // we only add control dependencies iff 1) we are in different function call or 2) they have, at least, the same depth as the slicing seed
+        if (currentVertex.controlDependencies) {
+            const topLevel = graph.isRoot(id) || sliceSeedIds.has(id);
+            for (const cd of currentVertex.controlDependencies) {
+                if (!topLevel || (ast.idMap.get(cd)?.info.depth ?? 0) <= minDepth) {
+                    queue.add(cd, baseEnvironment, baseEnvFingerprint, false);
+                }
+            }
         }
-        const currentNode = idMap.get(current.id);
-        (0, assert_1.guard)(currentNode !== undefined, () => `id: ${current.id} must be in dataflowIdMap is not in ${(0, dataflow_1.graphToMermaidUrl)(dataflowGraph, idMap)}`);
-        for (const [target, edge] of currentInfo[1]) {
-            if (edge.types.has(dataflow_1.EdgeType.SideEffectOnCall)) {
-                queue.add(target, current.baseEnvironment, baseEnvFingerprint, true);
+        if (!onlyForSideEffects) {
+            if (currentVertex.tag === "function-call" /* VertexType.FunctionCall */ && !currentVertex.onlyBuiltin) {
+                (0, slice_call_1.sliceForCall)(current, currentVertex, graph, queue);
             }
-            if (edge.types.has(dataflow_1.EdgeType.Reads) || edge.types.has(dataflow_1.EdgeType.DefinedBy) || edge.types.has(dataflow_1.EdgeType.Argument) || edge.types.has(dataflow_1.EdgeType.Calls) || edge.types.has(dataflow_1.EdgeType.Relates) || edge.types.has(dataflow_1.EdgeType.DefinesOnCall)) {
-                queue.add(target, current.baseEnvironment, baseEnvFingerprint, false);
+            const ret = (0, slice_call_1.handleReturns)(queue, currentEdges, baseEnvFingerprint, baseEnvironment);
+            if (ret) {
+                continue;
             }
         }
-        for (const controlFlowDependency of addControlDependencies(currentInfo[0].id, idMap)) {
-            queue.add(controlFlowDependency, current.baseEnvironment, baseEnvFingerprint, false);
-        }
-    }
-    // slicerLogger.trace(`static slicing produced: ${JSON.stringify([...seen])}`)
-    return { ...queue.status(), decodedCriteria };
-}
-exports.staticSlicing = staticSlicing;
-function addAllFrom(current, collected) {
-    for (const id of (0, r_bridge_1.collectAllIds)(current)) {
-        collected.add(id);
-    }
-}
-function addControlDependencies(source, ast) {
-    const start = ast.get(source);
-    const collected = new Set();
-    let current = start;
-    while (current !== undefined) {
-        if (current.type === "RIfThenElse" /* RType.IfThenElse */) {
-            addAllFrom(current.condition, collected);
-        }
-        else if (current.type === "RWhileLoop" /* RType.WhileLoop */) {
-            addAllFrom(current.condition, collected);
-        }
-        else if (current.type === "RForLoop" /* RType.ForLoop */) {
-            addAllFrom(current.variable, collected);
-            // vector not needed, if required, it is  linked by defined-by
-        }
-        // nothing to do for repeat and rest!
-        current = current.info.parent ? ast.get(current.info.parent) : undefined;
-    }
-    return collected;
-}
-function retrieveActiveEnvironment(callerInfo, baseEnvironment) {
-    let callerEnvironment = callerInfo.environment;
-    if (baseEnvironment.level !== callerEnvironment.level) {
-        while (baseEnvironment.level < callerEnvironment.level) {
-            baseEnvironment = (0, environments_1.pushLocalEnvironment)(baseEnvironment);
-        }
-        while (baseEnvironment.level > callerEnvironment.level) {
-            callerEnvironment = (0, environments_1.pushLocalEnvironment)(callerEnvironment);
-        }
-    }
-    return (0, environments_1.overwriteEnvironments)(baseEnvironment, callerEnvironment);
-}
-//// returns the new threshold hit count
-function sliceForCall(current, idMap, callerInfo, dataflowGraph, queue) {
-    // bind with call-local environments during slicing
-    const outgoingEdges = dataflowGraph.get(callerInfo.id, true);
-    (0, assert_1.guard)(outgoingEdges !== undefined, () => `outgoing edges of id: ${callerInfo.id} must be in graph but can not be found, keep in slice to be sure`);
-    // lift baseEnv on the same level
-    const baseEnvironment = current.baseEnvironment;
-    const baseEnvPrint = envFingerprint(baseEnvironment);
-    const activeEnvironment = retrieveActiveEnvironment(callerInfo, baseEnvironment);
-    const activeEnvironmentFingerprint = envFingerprint(activeEnvironment);
-    const functionCallDefs = (0, environments_1.resolveByName)(callerInfo.name, scopes_1.LocalScope, activeEnvironment)?.map(d => d.nodeId) ?? [];
-    for (const [target, outgoingEdge] of outgoingEdges[1].entries()) {
-        if (outgoingEdge.types.has(dataflow_1.EdgeType.Calls)) {
-            functionCallDefs.push(target);
-        }
-    }
-    const functionCallTargets = (0, linker_1.getAllLinkedFunctionDefinitions)(new Set(functionCallDefs), dataflowGraph);
-    for (const [_, functionCallTarget] of functionCallTargets) {
-        // all those linked within the scopes of other functions are already linked when exiting a function definition
-        for (const openIn of functionCallTarget.subflow.in) {
-            const defs = (0, environments_1.resolveByName)(openIn.name, scopes_1.LocalScope, activeEnvironment);
-            if (defs === undefined) {
+        for (const [target, { types }] of currentEdges) {
+            if (target === built_in_1.BuiltIn || (0, edge_1.edgeIncludesType)(types, 256 /* EdgeType.NonStandardEvaluation */)) {
                 continue;
             }
-            for (const def of defs) {
-                queue.add(def.nodeId, baseEnvironment, baseEnvPrint, current.onlyForSideEffects);
+            const t = (0, edge_1.shouldTraverseEdge)(types);
+            if (t === 3 /* TraverseEdge.Always */) {
+                queue.add(target, baseEnvironment, baseEnvFingerprint, false);
+            }
+            else if (t === 2 /* TraverseEdge.DefinedByOnCall */ && queue.potentialArguments.has(target)) {
+                queue.add(target, baseEnvironment, baseEnvFingerprint, false);
+                queue.potentialArguments.delete(target);
+            }
+            else if (t === 1 /* TraverseEdge.SideEffect */) {
+                queue.add(target, baseEnvironment, baseEnvFingerprint, true);
             }
-        }
-        for (const exitPoint of functionCallTarget.exitPoints) {
-            queue.add(exitPoint, activeEnvironment, activeEnvironmentFingerprint, current.onlyForSideEffects);
         }
     }
+    return { ...queue.status(), decodedCriteria };
 }
+exports.staticSlicing = staticSlicing;
 //# sourceMappingURL=static-slicer.js.map

package/slicing/static/visiting-queue.d.ts

@@ -0,0 +1,23 @@
+import type { NodeToSlice, SliceResult } from './slicer-types';
+import type { REnvironmentInformation } from '../../dataflow/environments/environment';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+export declare class VisitingQueue {
+    private readonly threshold;
+    private timesHitThreshold;
+    private seen;
+    private idThreshold;
+    private queue;
+    potentialArguments: Set<NodeId>;
+    constructor(threshold: number);
+    /**
+     * Adds a node to the queue if it has not been seen before.
+     * @param target             - the node to add
+     * @param env                - the environment the node is traversed in
+     * @param envFingerprint     - the fingerprint of the environment
+     * @param onlyForSideEffects - whether the node is only used for its side effects
+     */
+    add(target: NodeId, env: REnvironmentInformation, envFingerprint: string, onlyForSideEffects: boolean): void;
+    next(): NodeToSlice;
+    nonEmpty(): boolean;
+    status(): Readonly<Pick<SliceResult, 'timesHitThreshold' | 'result'>>;
+}

package/slicing/static/visiting-queue.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisitingQueue = void 0;
+const fingerprint_1 = require("./fingerprint");
+const static_slicer_1 = require("./static-slicer");
+class VisitingQueue {
+    threshold;
+    timesHitThreshold = 0;
+    seen = new Map();
+    idThreshold = new Map();
+    queue = [];
+    // the set of potential arguments holds arguments which may be added if found with the `defined-by-on-call` edge
+    potentialArguments = new Set();
+    constructor(threshold) {
+        this.threshold = threshold;
+    }
+    /**
+     * Adds a node to the queue if it has not been seen before.
+     * @param target             - the node to add
+     * @param env                - the environment the node is traversed in
+     * @param envFingerprint     - the fingerprint of the environment
+     * @param onlyForSideEffects - whether the node is only used for its side effects
+     */
+    add(target, env, envFingerprint, onlyForSideEffects) {
+        const idCounter = this.idThreshold.get(target) ?? 0;
+        if (idCounter > this.threshold) {
+            static_slicer_1.slicerLogger.warn(`id: ${target} has been visited ${idCounter} times, skipping`);
+            this.timesHitThreshold++;
+            return;
+        }
+        /* we do not include the in call part in the fingerprint as it is 'deterministic' from the source position */
+        const print = (0, fingerprint_1.fingerprint)(target, envFingerprint, onlyForSideEffects);
+        if (!this.seen.has(print)) {
+            this.idThreshold.set(target, idCounter + 1);
+            this.seen.set(print, target);
+            this.queue.push({ id: target, baseEnvironment: env, onlyForSideEffects });
+        }
+    }
+    next() {
+        return this.queue.pop();
+    }
+    nonEmpty() {
+        return this.queue.length > 0;
+    }
+    status() {
+        return {
+            timesHitThreshold: this.timesHitThreshold,
+            result: new Set(this.seen.values())
+        };
+    }
+}
+exports.VisitingQueue = VisitingQueue;
+//# sourceMappingURL=visiting-queue.js.map

package/statistics/features/common-syntax-probability.d.ts

@@ -0,0 +1,29 @@
+import type { SummarizedMeasurement } from '../../util/summarizer';
+import { RFalse, RTrue } from '../../r-bridge/lang-4.x/convert-values';
+import type { RArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-argument';
+import type { RNode } from '../../r-bridge/lang-4.x/ast/model/model';
+export interface CommonSyntaxTypeCounts<Measurement = bigint> {
+    total: Measurement;
+    multiple: Measurement;
+    empty: Measurement;
+    withArgument: Measurement;
+    noValue: Measurement;
+    singleVar: Record<string, Measurement>;
+    number: Record<number, Measurement>;
+    integer: Record<number, Measurement>;
+    complex: Record<number, Measurement>;
+    string: Record<string, Measurement>;
+    logical: Record<typeof RTrue | typeof RFalse, Measurement>;
+    call: Record<string, Measurement>;
+    unnamedCall: Measurement;
+    binOp: Record<string, Measurement>;
+    unaryOp: Record<string, Measurement>;
+    other: Record<string, Measurement>;
+}
+export declare function emptyCommonSyntaxTypeCounts<T = bigint>(init?: () => T): CommonSyntaxTypeCounts<T>;
+/**
+ * Updates the given counts based on the type of the given node.
+ */
+export declare function updateCommonSyntaxTypeCounts(current: CommonSyntaxTypeCounts, ...nodes: (RNode | RArgument)[]): CommonSyntaxTypeCounts;
+export declare function appendCommonSyntaxTypeCounter(a: CommonSyntaxTypeCounts<number[][]>, b: CommonSyntaxTypeCounts): void;
+export declare function summarizeCommonSyntaxTypeCounter(a: CommonSyntaxTypeCounts<number[][]>): CommonSyntaxTypeCounts<SummarizedMeasurement>;