@eagleoutice/flowr 2.1.8 → 2.1.9

package/queries/catalog/call-context-query/call-context-query-format.d.ts

@@ -6,6 +6,9 @@ import Joi from 'joi';
 import type { PipelineOutput } from '../../../core/steps/pipeline/pipeline';
 import type { DEFAULT_DATAFLOW_PIPELINE } from '../../../core/steps/pipeline/default-pipelines';
 import { CallTargets } from './identify-link-to-last-call-relation';
+import type { DataflowGraph } from '../../../dataflow/graph/graph';
+import type { DataflowGraphVertexInfo } from '../../../dataflow/graph/vertex';
+import type { CascadeAction } from './cascade-action';
 export interface FileFilter<FilterType> {
     /**
      * Regex that a node's file attribute must match to be considered
@@ -52,6 +55,16 @@ interface LinkToLastCall<CallName extends RegExp | string = RegExp | string> ext
     readonly type: 'link-to-last-call';
     /** Regex regarding the function name of the last call. Similar to {@link DefaultCallContextQueryFormat#callName}, strings are interpreted as a `RegExp`. */
     readonly callName: CallName;
+    /**
+     * Should we ignore this (source) call?
+     * Currently, there is no well working serialization for this.
+     */
+    readonly ignoreIf?: (id: NodeId, graph: DataflowGraph) => boolean;
+    /**
+     * Should we continue searching after the link was created?
+     * Currently, there is no well working serialization for this.
+     */
+    readonly cascadeIf?: (target: DataflowGraphVertexInfo, from: NodeId, graph: DataflowGraph) => CascadeAction;
 }
 export type LinkTo<CallName extends RegExp | string> = LinkToLastCall<CallName>;
 export interface SubCallContextQueryFormat<CallName extends RegExp | string = RegExp | string> extends DefaultCallContextQueryFormat<CallName> {

package/queries/catalog/call-context-query/call-context-query-format.js

@@ -32,7 +32,9 @@ exports.CallContextQueryDefinition = {
         }).optional().description('Filter that, when set, a node\'s file attribute must match to be considered'),
         linkTo: joi_1.default.object({
             type: joi_1.default.string().valid('link-to-last-call').required().description('The type of the linkTo sub-query.'),
-            callName: joi_1.default.string().required().description('Regex regarding the function name of the last call. Similar to `callName`, strings are interpreted as a regular expression.')
+            callName: joi_1.default.string().required().description('Regex regarding the function name of the last call. Similar to `callName`, strings are interpreted as a regular expression.'),
+            ignoreIf: joi_1.default.function().optional().description('Should we ignore this (source) call? Currently, there is no well working serialization for this.'),
+            cascadeIf: joi_1.default.function().optional().description('Should we continue searching after the link was created? Currently, there is no well working serialization for this.')
         }).optional().description('Links the current call to the last call of the given kind. This way, you can link a call like `points` to the latest graphics plot etc.')
     }).description('Call context query used to find calls in the dataflow graph')
 };

package/queries/catalog/call-context-query/cascade-action.d.ts

@@ -0,0 +1,8 @@
+export declare enum CascadeAction {
+    /** The action is to start the cascade */
+    Stop = "stop",
+    /** The action is to continue the cascade */
+    Continue = "continue",
+    /** The action is to skip the current node */
+    Skip = "skip"
+}

package/queries/catalog/call-context-query/cascade-action.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CascadeAction = void 0;
+var CascadeAction;
+(function (CascadeAction) {
+    /** The action is to start the cascade */
+    CascadeAction["Stop"] = "stop";
+    /** The action is to continue the cascade */
+    CascadeAction["Continue"] = "continue";
+    /** The action is to skip the current node */
+    CascadeAction["Skip"] = "skip";
+})(CascadeAction || (exports.CascadeAction = CascadeAction = {}));
+//# sourceMappingURL=cascade-action.js.map

package/queries/catalog/call-context-query/identify-link-to-last-call-relation.d.ts

@@ -1,6 +1,10 @@
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { ControlFlowGraph } from '../../../util/cfg/cfg';
 import type { DataflowGraph } from '../../../dataflow/graph/graph';
+import type { DataflowGraphVertexFunctionCall } from '../../../dataflow/graph/vertex';
+import { RType } from '../../../r-bridge/lang-4.x/ast/model/type';
+import type { RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { LinkTo } from './call-context-query-format';
 export declare enum CallTargets {
     /** call targets a function that is not defined locally (e.g., the call targets a library function) */
     OnlyGlobal = "global",
@@ -14,4 +18,10 @@ export declare enum CallTargets {
     Any = "any"
 }
 export declare function satisfiesCallTargets(id: NodeId, graph: DataflowGraph, callTarget: CallTargets): NodeId[] | 'no';
-export declare function identifyLinkToLastCallRelation(from: NodeId, cfg: ControlFlowGraph, graph: DataflowGraph, linkTo: RegExp): NodeId[];
+export declare function getValueOfArgument<Types extends readonly RType[] = readonly RType[]>(graph: DataflowGraph, call: DataflowGraphVertexFunctionCall | undefined, argument: {
+    name?: string;
+    index: number;
+}, additionalAllowedTypes?: Types): (RNodeWithParent & {
+    type: Types[number];
+}) | undefined;
+export declare function identifyLinkToLastCallRelation(from: NodeId, cfg: ControlFlowGraph, graph: DataflowGraph, { callName, ignoreIf, cascadeIf }: LinkTo<RegExp>): NodeId[];

package/queries/catalog/call-context-query/identify-link-to-last-call-relation.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CallTargets = void 0;
 exports.satisfiesCallTargets = satisfiesCallTargets;
+exports.getValueOfArgument = getValueOfArgument;
 exports.identifyLinkToLastCallRelation = identifyLinkToLastCallRelation;
+const graph_1 = require("../../../dataflow/graph/graph");
 const visitor_1 = require("../../../util/cfg/visitor");
 const vertex_1 = require("../../../dataflow/graph/vertex");
 const edge_1 = require("../../../dataflow/graph/edge");
@@ -10,6 +12,9 @@ const resolve_by_name_1 = require("../../../dataflow/environments/resolve-by-nam
 const identifier_1 = require("../../../dataflow/environments/identifier");
 const built_in_1 = require("../../../dataflow/environments/built-in");
 const assert_1 = require("../../../util/assert");
+const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
+const r_function_call_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const cascade_action_1 = require("./cascade-action");
 var CallTargets;
 (function (CallTargets) {
     /** call targets a function that is not defined locally (e.g., the call targets a library function) */
@@ -74,8 +79,36 @@ function satisfiesCallTargets(id, graph, callTarget) {
             (0, assert_1.assertUnreachable)(callTarget);
     }
 }
-function identifyLinkToLastCallRelation(from, cfg, graph, linkTo) {
+function getValueOfArgument(graph, call, argument, additionalAllowedTypes) {
+    if (!call) {
+        return undefined;
+    }
+    const totalIndex = argument.name ? call.args.findIndex(arg => arg !== r_function_call_1.EmptyArgument && arg.name === argument.name) : -1;
+    let refAtIndex;
+    if (totalIndex < 0) {
+        const references = call.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.getReferenceOfArgument);
+        refAtIndex = references[argument.index];
+    }
+    else {
+        const arg = call.args[totalIndex];
+        refAtIndex = (0, graph_1.getReferenceOfArgument)(arg);
+    }
+    if (refAtIndex === undefined) {
+        return undefined;
+    }
+    let valueNode = graph.idMap?.get(refAtIndex);
+    if (valueNode?.type === type_1.RType.Argument) {
+        valueNode = valueNode.value;
+    }
+    if (valueNode) {
+        return !additionalAllowedTypes || additionalAllowedTypes.includes(valueNode.type) ? valueNode : undefined;
+    }
+}
+function identifyLinkToLastCallRelation(from, cfg, graph, { callName, ignoreIf, cascadeIf }) {
     const found = [];
+    if (ignoreIf && ignoreIf(from, graph)) {
+        return found;
+    }
     (0, visitor_1.visitInReverseOrder)(cfg, from, node => {
         /* we ignore the start id as it cannot be the last call */
         if (node === from) {
@@ -85,13 +118,17 @@ function identifyLinkToLastCallRelation(from, cfg, graph, linkTo) {
         if (vertex === undefined || vertex[0].tag !== vertex_1.VertexType.FunctionCall) {
             return;
         }
-        if (linkTo.test(vertex[0].name)) {
+        if (callName.test(vertex[0].name)) {
+            const act = cascadeIf ? cascadeIf(vertex[0], from, graph) : cascade_action_1.CascadeAction.Stop;
+            if (act === cascade_action_1.CascadeAction.Skip) {
+                return;
+            }
             const tar = satisfiesCallTargets(vertex[0].id, graph, CallTargets.MustIncludeGlobal);
             if (tar === 'no') {
-                return true;
+                return act === cascade_action_1.CascadeAction.Stop;
             }
             found.push(node);
-            return true;
+            return act === cascade_action_1.CascadeAction.Stop;
         }
     });
     return found;

package/queries/catalog/dependencies-query/dependencies-query-format.js

@@ -83,6 +83,8 @@ exports.ReadFunctions = [
     { name: 'read.ssd', argIdx: 0, argName: 'file' },
     { name: 'read.systat', argIdx: 0, argName: 'file' },
     { name: 'read.xport', argIdx: 0, argName: 'file' },
+    // car
+    { name: 'Import', argIdx: 0, argName: 'file' },
 ];
 exports.WriteFunctions = [
     { name: 'save', argIdx: 0, argName: '...' },
@@ -138,6 +140,8 @@ exports.WriteFunctions = [
     { name: 'tiff', argIdx: 0, argName: 'file' },
     { name: 'X11', argIdx: 0, argName: 'file' },
     { name: 'quartz', argIdx: 0, argName: 'file' },
+    // car
+    { name: 'Export', argIdx: 0, argName: 'file' },
 ];
 function printResultSection(title, infos, result, sectionSpecifics) {
     if (infos.length <= 0) {

package/queries/query.d.ts

@@ -450,9 +450,9 @@ type OmitFromValues<T, K extends string | number | symbol> = {
 export type QueryResultsWithoutMeta<Queries extends Query> = OmitFromValues<Omit<QueryResults<Queries['type']>, '.meta'>, '.meta'>;
 export type Queries<Base extends SupportedQueryTypes, VirtualArguments extends VirtualCompoundConstraint<Base> = VirtualCompoundConstraint<Base>> = readonly (QueryArgumentsWithType<Base> | VirtualQueryArgumentsWithType<Base, VirtualArguments>)[];
 export declare function executeQueries<Base extends SupportedQueryTypes, VirtualArguments extends VirtualCompoundConstraint<Base> = VirtualCompoundConstraint<Base>>(data: BasicQueryData, queries: Queries<Base, VirtualArguments>): QueryResults<Base>;
-export declare const SupportedQueriesSchema: Joi.AlternativesSchema<any>;
+export declare function SupportedQueriesSchema(): Joi.AlternativesSchema<any>;
 export declare const CompoundQuerySchema: Joi.ObjectSchema<any>;
-export declare const VirtualQuerySchema: Joi.AlternativesSchema<any>;
-export declare const AnyQuerySchema: Joi.AlternativesSchema<any>;
-export declare const QueriesSchema: Joi.ArraySchema<any[]>;
+export declare function VirtualQuerySchema(): Joi.AlternativesSchema<any>;
+export declare function AnyQuerySchema(): Joi.AlternativesSchema<any>;
+export declare function QueriesSchema(): Joi.ArraySchema<any[]>;
 export {};

package/queries/query.js

@@ -3,9 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueriesSchema = exports.AnyQuerySchema = exports.VirtualQuerySchema = exports.CompoundQuerySchema = exports.SupportedQueriesSchema = exports.SupportedQueries = void 0;
+exports.CompoundQuerySchema = exports.SupportedQueries = void 0;
 exports.executeQueriesOfSameType = executeQueriesOfSameType;
 exports.executeQueries = executeQueries;
+exports.SupportedQueriesSchema = SupportedQueriesSchema;
+exports.VirtualQuerySchema = VirtualQuerySchema;
+exports.AnyQuerySchema = AnyQuerySchema;
+exports.QueriesSchema = QueriesSchema;
 const call_context_query_format_1 = require("./catalog/call-context-query/call-context-query-format");
 const assert_1 = require("../util/assert");
 const virtual_queries_1 = require("./virtual-query/virtual-queries");
@@ -74,14 +78,22 @@ function executeQueries(data, queries) {
     };
     return results;
 }
-exports.SupportedQueriesSchema = joi_1.default.alternatives(Object.values(exports.SupportedQueries).map(q => q.schema)).description('Supported queries');
+function SupportedQueriesSchema() {
+    return joi_1.default.alternatives(Object.values(exports.SupportedQueries).map(q => q.schema)).description('Supported queries');
+}
 exports.CompoundQuerySchema = joi_1.default.object({
     type: joi_1.default.string().valid('compound').required().description('The type of the query.'),
     query: joi_1.default.string().required().description('The query to run on the file analysis information.'),
     commonArguments: joi_1.default.object().required().description('Common arguments for all queries.'),
     arguments: joi_1.default.array().items(joi_1.default.object()).required().description('Arguments for each query.')
 }).description('Compound query used to combine queries of the same type');
-exports.VirtualQuerySchema = joi_1.default.alternatives(exports.CompoundQuerySchema).description('Virtual queries (used for structure)');
-exports.AnyQuerySchema = joi_1.default.alternatives(exports.SupportedQueriesSchema, exports.VirtualQuerySchema).description('Any query');
-exports.QueriesSchema = joi_1.default.array().items(exports.AnyQuerySchema).description('Queries to run on the file analysis information (in the form of an array)');
+function VirtualQuerySchema() {
+    return joi_1.default.alternatives(exports.CompoundQuerySchema).description('Virtual queries (used for structure)');
+}
+function AnyQuerySchema() {
+    return joi_1.default.alternatives(SupportedQueriesSchema(), VirtualQuerySchema()).description('Any query');
+}
+function QueriesSchema() {
+    return joi_1.default.array().items(AnyQuerySchema()).description('Queries to run on the file analysis information (in the form of an array)');
+}
 //# sourceMappingURL=query.js.map

package/r-bridge/lang-4.x/ast/model/model.d.ts

@@ -145,6 +145,9 @@ export type ROther<Info> = RComment<Info> | RLineDirective<Info>;
  * All other subtypes (like {@link RLoopConstructs}) listed above
  * can be used to restrict the kind of node. They do not have to be
  * exclusive, some nodes can appear in multiple subtypes.
+ *
+ * @see {@link recoverName} - to receive the name/lexeme from such a node
+ * @see {@link recoverContent} - for a more rigorous approach to get the content of a node within a {@link DataflowGraph|dataflow graph}
  */
 export type RNode<Info = NoInfo> = RExpressionList<Info> | RFunctions<Info> | ROther<Info> | RConstructs<Info> | RNamedAccess<Info> | RIndexAccess<Info> | RUnaryOp<Info> | RBinaryOp<Info> | RSingleNode<Info> | RPipe<Info>;
 export type OtherInfoNode = RNode | RDelimiter;

package/r-bridge/lang-4.x/ast/model/nodes/r-number.d.ts

@@ -1,7 +1,11 @@
 import type { Leaf, Location, NoInfo } from '../model';
 import type { RType } from '../type';
 import type { RNumberValue } from '../../../convert-values';
-/** includes numeric, integer, and complex */
+/**
+ * A number like `3`, `-2.14`, `1L`, or `2i`.
+ * Includes numeric, integer, and complex.
+ * See {@link RNumberValue} for more information.
+ */
 export interface RNumber<Info = NoInfo> extends Leaf<Info>, Location {
     readonly type: RType.Number;
     content: RNumberValue;

package/r-bridge/lang-4.x/ast/model/processing/node-id.d.ts

@@ -7,7 +7,12 @@ export type NodeId<T extends string | number = string | number> = T & {
 /** used so that we do not have to store strings for the default numeric ids */
 export declare function normalizeIdToNumberIfPossible(id: NodeId): NodeId;
 /**
- * Recovers the lexeme of a node from its id in the idmap.
+ * Recovers the lexeme of a {@link RNode|node} from its id in the {@link AstIdMap|id map}.
+ *
+ * @see {@link recoverContent} - to recover the content of a node
  */
 export declare function recoverName(id: NodeId, idMap?: AstIdMap): string | undefined;
+/**
+ * Recovers the content of a {@link RNode|node} from its id in the {@link DataflowGraph|dataflow graph}.
+ */
 export declare function recoverContent(id: NodeId, graph: DataflowGraph): string | undefined;

package/r-bridge/lang-4.x/ast/model/processing/node-id.js

@@ -15,11 +15,16 @@ function normalizeIdToNumberIfPossible(id) {
     return id;
 }
 /**
- * Recovers the lexeme of a node from its id in the idmap.
+ * Recovers the lexeme of a {@link RNode|node} from its id in the {@link AstIdMap|id map}.
+ *
+ * @see {@link recoverContent} - to recover the content of a node
  */
 function recoverName(id, idMap) {
     return idMap?.get(id)?.lexeme;
 }
+/**
+ * Recovers the content of a {@link RNode|node} from its id in the {@link DataflowGraph|dataflow graph}.
+ */
 function recoverContent(id, graph) {
     const vertex = graph.getVertex(id);
     if (vertex === undefined) {

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

@@ -1,10 +1,15 @@
 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 { DataflowGraphVertexFunctionCall, DataflowGraphVertexInfo } from '../../dataflow/graph/vertex';
 import type { REnvironmentInformation } from '../../dataflow/environments/environment';
 import type { DataflowGraph, OutgoingEdges } from '../../dataflow/graph/graph';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+/**
+ * Returns the function call targets (definitions) by the given caller
+ */
+export declare function getAllFunctionCallTargets(dataflowGraph: DataflowGraph, callerInfo: DataflowGraphVertexFunctionCall, baseEnvironment: REnvironmentInformation): [Set<DataflowGraphVertexInfo>, REnvironmentInformation];
 /** 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;
+export declare function handleReturns(from: NodeId, queue: VisitingQueue, currentEdges: OutgoingEdges, baseEnvFingerprint: Fingerprint, baseEnvironment: REnvironmentInformation): boolean;

package/slicing/static/slice-call.js

@@ -1,31 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllFunctionCallTargets = getAllFunctionCallTargets;
 exports.sliceForCall = sliceForCall;
 exports.handleReturns = handleReturns;
 const assert_1 = require("../../util/assert");
 const fingerprint_1 = require("./fingerprint");
 const linker_1 = require("../../dataflow/internal/linker");
-const environment_1 = require("../../dataflow/environments/environment");
-const scoping_1 = require("../../dataflow/environments/scoping");
-const overwrite_1 = require("../../dataflow/environments/overwrite");
 const graph_1 = require("../../dataflow/graph/graph");
 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");
 const identifier_1 = require("../../dataflow/environments/identifier");
-function retrieveActiveEnvironment(callerInfo, baseEnvironment) {
-    let callerEnvironment = callerInfo.environment;
-    let level = callerEnvironment?.level ?? 0;
-    if (baseEnvironment.level !== level) {
-        while (baseEnvironment.level < level) {
-            baseEnvironment = (0, scoping_1.pushLocalEnvironment)(baseEnvironment);
-        }
-        while (baseEnvironment.level > level) {
-            callerEnvironment = (0, scoping_1.pushLocalEnvironment)(callerEnvironment ?? (0, environment_1.initializeCleanEnvironments)(true));
-            level = callerEnvironment.level;
+const built_in_function_definition_1 = require("../../dataflow/internal/process/functions/call/built-in/built-in-function-definition");
+const static_slicer_1 = require("./static-slicer");
+/**
+ * Returns the function call targets (definitions) by the given caller
+ */
+function getAllFunctionCallTargets(dataflowGraph, callerInfo, baseEnvironment) {
+    // 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 activeEnvironment = (0, built_in_function_definition_1.retrieveActiveEnvironment)(callerInfo.environment, baseEnvironment);
+    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, identifier_1.ReferenceType.Unknown)?.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, edge_1.EdgeType.Calls)) {
+            functionCallDefs.push(target);
         }
     }
-    return (0, overwrite_1.overwriteEnvironment)(baseEnvironment, callerEnvironment);
+    const functionCallTargets = (0, linker_1.getAllLinkedFunctionDefinitions)(new Set(functionCallDefs), dataflowGraph);
+    return [functionCallTargets, activeEnvironment];
 }
 function includeArgumentFunctionCallClosure(arg, baseEnvironment, activeEnvironment, queue, dataflowGraph) {
     const valueRoot = (0, graph_1.getReferenceOfArgument)(arg);
@@ -33,20 +39,21 @@ function includeArgumentFunctionCallClosure(arg, baseEnvironment, activeEnvironm
         return;
     }
     const callTargets = (0, linker_1.getAllLinkedFunctionDefinitions)(new Set([valueRoot]), dataflowGraph);
-    linkCallTargets(false, callTargets, baseEnvironment, (0, fingerprint_1.envFingerprint)(baseEnvironment), activeEnvironment, (0, fingerprint_1.envFingerprint)(activeEnvironment), queue);
+    linkCallTargets(false, callTargets, activeEnvironment, (0, fingerprint_1.envFingerprint)(activeEnvironment), queue);
 }
-function linkCallTargets(onlyForSideEffects, functionCallTargets, baseEnvironment, baseEnvPrint, activeEnvironment, activeEnvironmentFingerprint, queue) {
+function linkCallTargets(onlyForSideEffects, functionCallTargets, activeEnvironment, activeEnvironmentFingerprint, queue) {
     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, openIn.type) : undefined;
-            if (defs === undefined) {
+        /* for(const openIn of (functionCallTarget as DataflowGraphVertexFunctionDefinition).subflow.in) {
+            // only if the outgoing path does not already have a defined by linkage
+            const defs = openIn.name ? resolveByName(openIn.name, activeEnvironment, openIn.type) : undefined;
+            if(defs === undefined) {
                 continue;
             }
-            for (const def of defs.filter(d => d.nodeId !== built_in_1.BuiltIn)) {
+            for(const def of defs.filter(d => d.nodeId !== BuiltIn)) {
                 queue.add(def.nodeId, baseEnvironment, baseEnvPrint, onlyForSideEffects);
             }
-        }
+        }*/
         for (const exitPoint of functionCallTarget.exitPoints) {
             queue.add(exitPoint, activeEnvironment, activeEnvironmentFingerprint, onlyForSideEffects);
         }
@@ -54,23 +61,9 @@ function linkCallTargets(onlyForSideEffects, functionCallTargets, baseEnvironmen
 }
 /** 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 [functionCallTargets, activeEnvironment] = getAllFunctionCallTargets(dataflowGraph, callerInfo, current.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, identifier_1.ReferenceType.Unknown)?.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, edge_1.EdgeType.Calls)) {
-            functionCallDefs.push(target);
-        }
-    }
-    const functionCallTargets = (0, linker_1.getAllLinkedFunctionDefinitions)(new Set(functionCallDefs), dataflowGraph);
     if (functionCallTargets.size === 0) {
         /*
          * if we do not have any call to resolve this function, we have to assume that every function passed is actually called!
@@ -81,10 +74,10 @@ function sliceForCall(current, callerInfo, dataflowGraph, queue) {
         }
         return;
     }
-    linkCallTargets(current.onlyForSideEffects, functionCallTargets, baseEnvironment, baseEnvPrint, activeEnvironment, activeEnvironmentFingerprint, queue);
+    linkCallTargets(current.onlyForSideEffects, functionCallTargets, activeEnvironment, activeEnvironmentFingerprint, queue);
 }
 /** Returns true if we found at least one return edge */
-function handleReturns(queue, currentEdges, baseEnvFingerprint, baseEnvironment) {
+function handleReturns(from, queue, currentEdges, baseEnvFingerprint, baseEnvironment) {
     const e = [...currentEdges.entries()];
     const found = e.filter(([_, edge]) => (0, edge_1.edgeIncludesType)(edge.types, edge_1.EdgeType.Returns));
     if (found.length === 0) {
@@ -97,12 +90,8 @@ function handleReturns(queue, currentEdges, baseEnvFingerprint, baseEnvironment)
         if ((0, edge_1.edgeIncludesType)(edge.types, edge_1.EdgeType.Reads)) {
             queue.add(target, baseEnvironment, baseEnvFingerprint, false);
         }
-        else if ((0, edge_1.edgeIncludesType)(edge.types, edge_1.EdgeType.Argument)) {
-            queue.potentialArguments.set(target, {
-                id: target,
-                baseEnvironment,
-                onlyForSideEffects: false
-            });
+        else if ((0, edge_1.edgeIncludesType)(edge.types, edge_1.EdgeType.DefinesOnCall | edge_1.EdgeType.DefinedByOnCall | edge_1.EdgeType.Argument)) {
+            (0, static_slicer_1.updatePotentialAddition)(queue, from, target, baseEnvironment);
         }
     }
     return true;

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

@@ -1,7 +1,10 @@
 import type { SliceResult } from './slicer-types';
+import { VisitingQueue } from './visiting-queue';
 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';
+import type { REnvironmentInformation } from '../../dataflow/environments/environment';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogObj>;
 /**
  * This returns the ids to include in the static backward slice, when slicing with the given seed id's (must be at least one).
@@ -10,7 +13,8 @@ export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogOb
  *
  * @param graph     - The dataflow graph to conduct the slicing on.
  * @param ast       - The normalized AST of the code (used to get static nesting information of the lexemes in case of control flow dependencies that may have no effect on the slicing scope).
- * @param criteria  - The criteras to slice on.
+ * @param criteria  - The criterias to slice on.
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  */
 export declare function staticSlicing(graph: DataflowGraph, { idMap }: NormalizedAst, criteria: SlicingCriteria, threshold?: number): Readonly<SliceResult>;
+export declare function updatePotentialAddition(queue: VisitingQueue, id: NodeId, target: NodeId, baseEnvironment: REnvironmentInformation): void;

package/slicing/static/static-slicer.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.slicerLogger = void 0;
 exports.staticSlicing = staticSlicing;
+exports.updatePotentialAddition = updatePotentialAddition;
 const assert_1 = require("../../util/assert");
 const log_1 = require("../../util/log");
 const fingerprint_1 = require("./fingerprint");
@@ -19,7 +20,7 @@ exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
  *
  * @param graph     - The dataflow graph to conduct the slicing on.
  * @param ast       - The normalized AST of the code (used to get static nesting information of the lexemes in case of control flow dependencies that may have no effect on the slicing scope).
- * @param criteria  - The criteras to slice on.
+ * @param criteria  - The criterias to slice on.
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  */
 function staticSlicing(graph, { idMap }, criteria, threshold = 75) {
@@ -71,7 +72,7 @@ function staticSlicing(graph, { idMap }, criteria, threshold = 75) {
             if (currentVertex.tag === vertex_1.VertexType.FunctionCall && !currentVertex.onlyBuiltin) {
                 (0, slice_call_1.sliceForCall)(current, currentVertex, graph, queue);
             }
-            const ret = (0, slice_call_1.handleReturns)(queue, currentEdges, baseEnvFingerprint, baseEnvironment);
+            const ret = (0, slice_call_1.handleReturns)(id, queue, currentEdges, baseEnvFingerprint, baseEnvironment);
             if (ret) {
                 continue;
             }
@@ -84,12 +85,8 @@ function staticSlicing(graph, { idMap }, criteria, threshold = 75) {
             if (t === 3 /* TraverseEdge.Always */) {
                 queue.add(target, baseEnvironment, baseEnvFingerprint, false);
             }
-            else if (t === 2 /* TraverseEdge.DefinedByOnCall */) {
-                const n = queue.potentialArguments.get(target);
-                if (n) {
-                    queue.add(target, n.baseEnvironment, (0, fingerprint_1.envFingerprint)(n.baseEnvironment), n.onlyForSideEffects);
-                    queue.potentialArguments.delete(target);
-                }
+            else if (t === 2 /* TraverseEdge.OnlyIfBoth */) {
+                updatePotentialAddition(queue, id, target, baseEnvironment);
             }
             else if (t === 1 /* TraverseEdge.SideEffect */) {
                 queue.add(target, baseEnvironment, baseEnvFingerprint, true);
@@ -98,4 +95,21 @@ function staticSlicing(graph, { idMap }, criteria, threshold = 75) {
     }
     return { ...queue.status(), decodedCriteria };
 }
+function updatePotentialAddition(queue, id, target, baseEnvironment) {
+    const n = queue.potentialAdditions.get(target);
+    if (n) {
+        const [addedBy, { baseEnvironment, onlyForSideEffects }] = n;
+        if (addedBy !== id) {
+            queue.add(target, baseEnvironment, (0, fingerprint_1.envFingerprint)(baseEnvironment), onlyForSideEffects);
+            queue.potentialAdditions.delete(target);
+        }
+    }
+    else {
+        queue.potentialAdditions.set(target, [id, {
+                id: target,
+                baseEnvironment,
+                onlyForSideEffects: false
+            }]);
+    }
+}
 //# sourceMappingURL=static-slicer.js.map

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

@@ -4,10 +4,10 @@ import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-i
 export declare class VisitingQueue {
     private readonly threshold;
     private timesHitThreshold;
-    private seen;
-    private idThreshold;
-    private queue;
-    potentialArguments: Map<NodeId, NodeToSlice>;
+    private readonly seen;
+    private readonly idThreshold;
+    private readonly queue;
+    potentialAdditions: Map<NodeId, [NodeId, NodeToSlice]>;
     constructor(threshold: number);
     /**
      * Adds a node to the queue if it has not been seen before.

package/slicing/static/visiting-queue.js

@@ -3,14 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VisitingQueue = void 0;
 const fingerprint_1 = require("./fingerprint");
 const static_slicer_1 = require("./static-slicer");
+const assert_1 = require("../../util/assert");
 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 Map();
+    // the set of potential additions holds nodes which may be added if a second edge deems them relevant (e.g., found with the `defined-by-on-call` edge)
+    // additionally it holds which node id added the addition so we can separate their inclusion on the structure
+    potentialAdditions = new Map();
     constructor(threshold) {
         this.threshold = threshold;
     }
@@ -48,7 +50,7 @@ class VisitingQueue {
     status() {
         return {
             timesHitThreshold: this.timesHitThreshold,
-            result: new Set(this.seen.values())
+            result: new Set([...this.seen.values()].filter(assert_1.isNotUndefined))
         };
     }
 }

package/statistics/output/print-stats.js

@@ -7,9 +7,10 @@ exports.printFeatureStatisticsEntry = printFeatureStatisticsEntry;
 const ansi_1 = require("../../util/ansi");
 const json_1 = require("../../util/json");
 const feature_1 = require("../features/feature");
+const arrays_1 = require("../../util/arrays");
 function minMaxAvgAndMedian(data) {
     data = data.sort((a, b) => a - b);
-    const sum = data.reduce((a, b) => a + b, 0);
+    const sum = (0, arrays_1.arraySum)(data);
     return {
         sum,
         min: data[0],

package/statistics/summarizer/post-process/histogram.js

@@ -11,6 +11,7 @@ const bimap_1 = require("../../../util/bimap");
 const defaultmap_1 = require("../../../util/defaultmap");
 const assert_1 = require("../../../util/assert");
 const summarizer_1 = require("../../../util/summarizer");
+const arrays_1 = require("../../../util/arrays");
 /**
  * Produces column-wise histogram-information based on a {@link ClusterReport}.
  *
@@ -79,7 +80,7 @@ function histograms2table(histograms, countAsDensity = false) {
     (0, assert_1.guard)(histograms.length > 0, 'there must be at least one histogram to convert to a table');
     const mostBins = guardForLargestBinSize(histograms);
     const header = ['bin', 'from', 'to', ...histograms.map(h => JSON.stringify(h.name))];
-    const sums = histograms.map(h => h.bins.reduce((a, b) => a + b, 0));
+    const sums = histograms.map(h => (0, arrays_1.arraySum)(h.bins));
     const rows = [];
     for (let binIndex = 0; binIndex < mostBins; binIndex++) {
         const row = new Array(histograms.length + 3);