@eagleoutice/flowr 2.2.12 → 2.2.13

package/dataflow/graph/vertex.d.ts

@@ -3,6 +3,7 @@ import type { DataflowFunctionFlowInformation, FunctionArgument } from './graph'
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { REnvironmentInformation } from '../environments/environment';
 import type { ControlDependency } from '../info';
+import type { BuiltInMappingName } from '../environments/built-in';
 export declare enum VertexType {
     Value = "value",
     Use = "use",
@@ -135,6 +136,14 @@ interface DataflowGraphVertexBase extends MergeableRecord {
      * this attribute links a vertex to indices (pointer links) it may be affected by or related to
      */
     indicesCollection?: ContainerIndicesCollection;
+    /**
+     * Describes the collection of AST vertices that contributed to this vertex.
+     * For example, this is useful with replacement operators, telling you which assignment operator caused them
+     */
+    link?: DataflowGraphVertexAstLink;
+}
+export interface DataflowGraphVertexAstLink {
+    origin: NodeId[];
 }
 /**
  * Marker vertex for a value in the dataflow of the program.
@@ -173,7 +182,9 @@ export interface DataflowGraphVertexUse extends DataflowGraphVertexBase {
     readonly environment?: undefined;
 }
 /**
- * Arguments required to construct a vertex which represents the usage of a variable in the {@link DataflowGraph|dataflow graph}.
+ * Arguments required to construct a vertex which represents the call to a function in the {@link DataflowGraph|dataflow graph}.
+ * This describes all kinds of function calls, including calls to built-ins and control-flow structures such as `if` or `for` (they are
+ * treated as function calls in R).
  *
  * @see {@link isFunctionCallVertex} - to check if a vertex is a function call vertex
  */
@@ -186,13 +197,17 @@ export interface DataflowGraphVertexFunctionCall extends DataflowGraphVertexBase
      * have the compound name (e.g., `[<-`).
      */
     readonly name: string;
-    /** The arguments of the function call, in order (as they are passed to the respective call if executed in R. */
+    /** The arguments of the function call, in order (as they are passed to the respective call if executed in R). */
     args: FunctionArgument[];
     /** a performance flag to indicate that the respective call is _only_ calling a builtin function without any df graph attached */
     onlyBuiltin: boolean;
     /** The environment attached to the call (if such an attachment is necessary, e.g., because it represents the calling closure */
     environment: REnvironmentInformation | undefined;
+    /** More detailed Information on this function call */
+    origin: FunctionOriginInformation[] | 'unnamed';
 }
+/** Describes the processor responsible for a function call */
+export type FunctionOriginInformation = BuiltInMappingName | string;
 /**
  * Arguments required to construct a vertex which represents the definition of a variable in the {@link DataflowGraph|dataflow graph}.
  *

package/dataflow/internal/linker.d.ts

@@ -1,10 +1,11 @@
-import { DefaultMap } from '../../util/defaultmap';
+import { DefaultMap } from '../../util/collections/defaultmap';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { IdentifierReference } from '../environments/identifier';
 import type { DataflowGraph, FunctionArgument } from '../graph/graph';
 import type { RParameter } from '../../r-bridge/lang-4.x/ast/model/nodes/r-parameter';
 import type { AstIdMap, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefinition, DataflowGraphVertexInfo } from '../graph/vertex';
+import type { BuiltIn } from '../environments/built-in';
 import type { REnvironmentInformation } from '../environments/environment';
 export type NameIdMap = DefaultMap<string, IdentifierReference[]>;
 export declare function findNonLocalReads(graph: DataflowGraph, ignore: readonly IdentifierReference[]): IdentifierReference[];
@@ -27,7 +28,7 @@ export declare function linkFunctionCalls(graph: DataflowGraph, idMap: AstIdMap,
  * convenience function returning all known call targets, as well as the name source which defines them
  */
 export declare function getAllFunctionCallTargets(call: NodeId, graph: DataflowGraph, environment?: REnvironmentInformation): NodeId[];
-export declare function getAllLinkedFunctionDefinitions(functionDefinitionReadIds: ReadonlySet<NodeId>, dataflowGraph: DataflowGraph): Set<DataflowGraphVertexInfo>;
+export declare function getAllLinkedFunctionDefinitions(functionDefinitionReadIds: ReadonlySet<NodeId>, dataflowGraph: DataflowGraph): [Set<DataflowGraphVertexInfo>, Set<BuiltIn>];
 /**
  * This method links a set of read variables to definitions in an environment.
  *

package/dataflow/internal/linker.js

@@ -9,7 +9,7 @@ exports.getAllFunctionCallTargets = getAllFunctionCallTargets;
 exports.getAllLinkedFunctionDefinitions = getAllLinkedFunctionDefinitions;
 exports.linkInputs = linkInputs;
 exports.linkCircularRedefinitionsWithinALoop = linkCircularRedefinitionsWithinALoop;
-const defaultmap_1 = require("../../util/defaultmap");
+const defaultmap_1 = require("../../util/collections/defaultmap");
 const assert_1 = require("../../util/assert");
 const log_1 = require("../../util/log");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
@@ -22,7 +22,6 @@ const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
 const vertex_1 = require("../graph/vertex");
 const resolve_by_name_1 = require("../environments/resolve-by-name");
 const built_in_1 = require("../environments/built-in");
-const static_slicer_1 = require("../../slicing/static/static-slicer");
 const prefix_1 = require("../../util/prefix");
 function findNonLocalReads(graph, ignore) {
     const ignores = new Set(ignore.map(i => i.nodeId));
@@ -75,7 +74,7 @@ function produceNameSharedIdMap(references) {
 }
 function linkArgumentsOnCall(args, params, graph) {
     const nameArgMap = new Map(args.filter(graph_1.isNamedArgument).map(a => [a.name, a]));
-    const nameParamMap = new Map(params.map(p => [p.name.content, p]));
+    const nameParamMap = new Map(params.filter(p => p !== undefined && p.name !== undefined && p.name.content !== undefined).map(p => [p.name.content, p]));
     const specialDotParameter = params.find(p => p.special);
     // all parameters matched by name
     const matchedParameters = new Set();
@@ -83,19 +82,19 @@ function linkArgumentsOnCall(args, params, graph) {
     for (const [name, arg] of nameArgMap) {
         const pmatchName = (0, prefix_1.findByPrefixIfUnique)(name, [...nameParamMap.keys()]) ?? name;
         const param = nameParamMap.get(pmatchName);
-        if (param !== undefined) {
+        if (param !== undefined && param.name) {
             logger_1.dataflowLogger.trace(`mapping named argument "${name}" to parameter "${param.name.content}"`);
             graph.addEdge(arg.nodeId, param.name.info.id, edge_1.EdgeType.DefinesOnCall);
             graph.addEdge(param.name.info.id, arg.nodeId, edge_1.EdgeType.DefinedByOnCall);
             matchedParameters.add(name);
         }
-        else if (specialDotParameter !== undefined) {
+        else if (specialDotParameter !== undefined && specialDotParameter.name) {
             logger_1.dataflowLogger.trace(`mapping named argument "${name}" to dot-dot-dot parameter`);
             graph.addEdge(arg.nodeId, specialDotParameter.name.info.id, edge_1.EdgeType.DefinesOnCall);
             graph.addEdge(specialDotParameter.name.info.id, arg.nodeId, edge_1.EdgeType.DefinedByOnCall);
         }
     }
-    const remainingParameter = params.filter(p => !matchedParameters.has(p.name.content));
+    const remainingParameter = params.filter(p => !p || !p.name || !matchedParameters.has(p.name.content));
     const remainingArguments = args.filter(a => !(0, graph_1.isNamedArgument)(a));
     for (let i = 0; i < remainingArguments.length; i++) {
         const arg = remainingArguments[i];
@@ -115,9 +114,11 @@ function linkArgumentsOnCall(args, params, graph) {
             continue;
         }
         const param = remainingParameter[i];
-        logger_1.dataflowLogger.trace(`mapping unnamed argument ${i} (id: ${arg.nodeId}) to parameter "${param.name.content}"`);
-        graph.addEdge(arg.nodeId, param.name.info.id, edge_1.EdgeType.DefinesOnCall);
-        graph.addEdge(param.name.info.id, arg.nodeId, edge_1.EdgeType.DefinedByOnCall);
+        logger_1.dataflowLogger.trace(`mapping unnamed argument ${i} (id: ${arg.nodeId}) to parameter "${param.name?.content ?? '??'}"`);
+        if (param.name) {
+            graph.addEdge(arg.nodeId, param.name.info.id, edge_1.EdgeType.DefinesOnCall);
+            graph.addEdge(param.name.info.id, arg.nodeId, edge_1.EdgeType.DefinedByOnCall);
+        }
     }
 }
 function linkFunctionCallArguments(targetId, idMap, functionCallName, functionRootId, callArgs, finalGraph) {
@@ -144,8 +145,10 @@ function linkFunctionCallWithSingleTarget(graph, def, info, idMap) {
                 continue;
             }
             for (const def of defs) {
-                graph.addEdge(ingoing, def, edge_1.EdgeType.DefinedByOnCall);
-                graph.addEdge(id, def, edge_1.EdgeType.DefinesOnCall);
+                if (!(0, built_in_1.isBuiltIn)(def.nodeId)) {
+                    graph.addEdge(ingoing, def, edge_1.EdgeType.DefinedByOnCall);
+                    graph.addEdge(id, def, edge_1.EdgeType.DefinesOnCall);
+                }
             }
         }
     }
@@ -168,7 +171,7 @@ function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefin
     const readBits = edge_1.EdgeType.Reads | edge_1.EdgeType.Calls;
     const functionDefinitionReadIds = [...edges].filter(([_, e]) => (0, edge_1.edgeDoesNotIncludeType)(e.types, edge_1.EdgeType.Argument)
         && (0, edge_1.edgeIncludesType)(e.types, readBits)).map(([target, _]) => target);
-    const functionDefs = getAllLinkedFunctionDefinitions(new Set(functionDefinitionReadIds), graph);
+    const functionDefs = getAllLinkedFunctionDefinitions(new Set(functionDefinitionReadIds), graph)[0];
     for (const def of functionDefs.values()) {
         (0, assert_1.guard)(def.tag === vertex_1.VertexType.FunctionDefinition, () => `expected function definition, but got ${def.tag}`);
         linkFunctionCallWithSingleTarget(graph, def, info, idMap);
@@ -198,7 +201,7 @@ function linkFunctionCalls(graph, idMap, thisGraph) {
  * convenience function returning all known call targets, as well as the name source which defines them
  */
 function getAllFunctionCallTargets(call, graph, environment) {
-    const found = [];
+    let found = [];
     const callVertex = graph.get(call, true);
     if (callVertex === undefined) {
         return [];
@@ -214,29 +217,28 @@ function getAllFunctionCallTargets(call, graph, environment) {
                 functionCallDefs.push(target);
             }
         }
-        const functionCallTargets = getAllLinkedFunctionDefinitions(new Set(functionCallDefs), graph);
+        const [functionCallTargets, builtInTargets] = getAllLinkedFunctionDefinitions(new Set(functionCallDefs), graph);
         for (const target of functionCallTargets) {
             found.push(target.id);
         }
-        for (const def of functionCallDefs) {
-            found.push(def);
-        }
+        found = found.concat(...builtInTargets, functionCallDefs);
     }
     return found;
 }
 function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGraph) {
-    const potential = [...functionDefinitionReadIds];
+    let potential = [...functionDefinitionReadIds];
     const visited = new Set();
     const result = new Set();
+    const builtIns = new Set();
     while (potential.length > 0) {
         const currentId = potential.pop();
-        // do not traverse builtins
-        if (currentId === built_in_1.BuiltIn) {
+        // do not traverse builtins further
+        if ((0, built_in_1.isBuiltIn)(currentId)) {
+            builtIns.add(currentId);
             continue;
         }
         const currentInfo = dataflowGraph.get(currentId, true);
         if (currentInfo === undefined) {
-            static_slicer_1.slicerLogger.trace('skipping unknown link');
             continue;
         }
         visited.add(currentId);
@@ -244,7 +246,7 @@ function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGrap
         const returnEdges = outgoingEdges.filter(([_, e]) => (0, edge_1.edgeIncludesType)(e.types, edge_1.EdgeType.Returns));
         if (returnEdges.length > 0) {
             // only traverse return edges and do not follow `calls` etc. as this indicates that we have a function call which returns a result, and not the function calls itself
-            potential.push(...returnEdges.map(([target]) => target).filter(id => !visited.has(id)));
+            potential = potential.concat(...returnEdges.map(([target]) => target).filter(id => !visited.has(id)));
             continue;
         }
         const followBits = edge_1.EdgeType.Reads | edge_1.EdgeType.DefinedBy | edge_1.EdgeType.DefinedByOnCall;
@@ -253,9 +255,9 @@ function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGrap
             result.add(currentInfo[0]);
         }
         // trace all joined reads
-        potential.push(...followEdges.map(([target]) => target).filter(id => !visited.has(id)));
+        potential = potential.concat(followEdges.map(([target]) => target).filter(id => !visited.has(id)));
     }
-    return result;
+    return [result, builtIns];
 }
 /**
  * This method links a set of read variables to definitions in an environment.
@@ -279,9 +281,16 @@ function linkInputs(referencesToLinkAgainstEnvironment, environmentInformation,
             givenInputs.push(bodyInput);
         }
         else {
+            let allBuiltIn = true;
             for (const target of probableTarget) {
                 // we can stick with maybe even if readId.attribute is always
                 graph.addEdge(bodyInput, target, edge_1.EdgeType.Reads);
+                if (!(0, identifier_1.isReferenceType)(target.type, identifier_1.ReferenceType.BuiltInConstant | identifier_1.ReferenceType.BuiltInFunction)) {
+                    allBuiltIn = false;
+                }
+            }
+            if (allBuiltIn) {
+                givenInputs.push(bodyInput);
             }
         }
     }

package/dataflow/internal/process/functions/call/argument/unpack-argument.d.ts

@@ -3,4 +3,4 @@ import type { RNode } from '../../../../../../r-bridge/lang-4.x/ast/model/model'
 /**
  * Retrieve the value from an argument, if it is not empty.
  */
-export declare function unpackArgument<OtherInfo>(arg: RFunctionArgument<OtherInfo>, noNameOnly?: boolean): RNode<OtherInfo> | undefined;
+export declare function unpackArgument<OtherInfo>(arg: RFunctionArgument<OtherInfo> | undefined, noNameOnly?: boolean): RNode<OtherInfo> | undefined;

package/dataflow/internal/process/functions/call/argument/unpack-argument.js

@@ -6,6 +6,6 @@ const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model
  * Retrieve the value from an argument, if it is not empty.
  */
 function unpackArgument(arg, noNameOnly = true) {
-    return arg === r_function_call_1.EmptyArgument || (noNameOnly && arg.name) ? undefined : arg.value;
+    return arg === undefined || arg === r_function_call_1.EmptyArgument || (noNameOnly && arg.name) ? undefined : arg.value;
 }
 //# sourceMappingURL=unpack-argument.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-access.js

@@ -16,7 +16,7 @@ const containers_1 = require("../../../../../../util/containers");
 const config_1 = require("../../../../../../config");
 function tableAssignmentProcessor(name, args, rootId, data, outInfo) {
     outInfo.definitionRootNodes.push(rootId);
-    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'table:assign' }).information;
 }
 /**
  * Processes different types of access operations.
@@ -32,13 +32,13 @@ function tableAssignmentProcessor(name, args, rootId, data, outInfo) {
 function processAccess(name, args, rootId, data, config) {
     if (args.length < 2) {
         logger_1.dataflowLogger.warn(`Access ${name.content} has less than 2 arguments, skipping`);
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs }).information;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: 'default' }).information;
     }
     const head = args[0];
     let fnCall;
     if (head === r_function_call_1.EmptyArgument) {
         // in this case we may be within a pipe
-        fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs });
+        fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: 'builtin:access' });
     }
     else if (!config.treatIndicesAsString) {
         /* within an access operation which treats its fields, we redefine the table assignment ':=' as a trigger if this is to be treated as a definition */
@@ -97,16 +97,17 @@ function processAccess(name, args, rootId, data, config) {
 function processNumberBasedAccess(data, name, args, rootId, config, head) {
     const existing = data.environment.current.memory.get(':=');
     const outInfo = { definitionRootNodes: [] };
+    const tableAssignId = (0, built_in_1.builtInId)(':=-table');
     data.environment.current.memory.set(':=', [{
             type: identifier_1.ReferenceType.BuiltInFunction,
-            definedAt: built_in_1.BuiltIn,
+            definedAt: tableAssignId,
             controlDependencies: undefined,
             processor: (name, args, rootId, data) => tableAssignmentProcessor(name, args, rootId, data, outInfo),
             config: {},
             name: ':=',
-            nodeId: built_in_1.BuiltIn,
+            nodeId: tableAssignId
         }]);
-    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs });
+    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: 'builtin:access' });
     /* recover the environment */
     if (existing !== undefined) {
         data.environment.current.memory.set(':=', existing);
@@ -153,7 +154,9 @@ function symbolArgumentsToStrings(args, firstIndexInclusive = 1, lastIndexInclus
  */
 function processStringBasedAccess(args, data, name, rootId, config) {
     const newArgs = symbolArgumentsToStrings(args);
-    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args: newArgs, rootId, data, forceArgs: config.forceArgs });
+    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args: newArgs, rootId, data, forceArgs: config.forceArgs,
+        origin: 'builtin:access'
+    });
     if ((0, config_1.getConfig)().solver.pointerTracking) {
         referenceAccessedIndices(newArgs, data, fnCall, rootId, false);
     }
@@ -201,8 +204,8 @@ function referenceAccessedIndices(newArgs, data, fnCall, rootId, isIndexBasedAcc
  * the node with {@link parentNodeId}.
  *
  * @param accessedIndicesCollection - All indices that were accessed by the access operation
- * @param fnCall - The {@link ProcessKnownFunctionCallResult} of the access operation
- * @param parentNodeId - {@link NodeId} of the parent from which the edge starts
+ * @param fnCall                    - The {@link ProcessKnownFunctionCallResult} of the access operation
+ * @param parentNodeId              - {@link NodeId} of the parent from which the edge starts
  */
 function referenceIndices(accessedIndicesCollection, fnCall, parentNodeId) {
     const accessedIndices = accessedIndicesCollection?.flatMap(indices => indices.indices);

package/dataflow/internal/process/functions/call/built-in/built-in-apply.d.ts

@@ -17,4 +17,4 @@ export interface BuiltInApplyConfiguration extends MergeableRecord {
     /** Should the value of the function be resolved? */
     readonly resolveValue?: boolean;
 }
-export declare function processApply<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, { indexOfFunction, nameOfFunctionArgument, unquoteFunction, resolveInEnvironment, resolveValue }: BuiltInApplyConfiguration): DataflowInformation;
+export declare function processApply<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: BuiltInApplyConfiguration): DataflowInformation;

package/dataflow/internal/process/functions/call/built-in/built-in-apply.js

@@ -9,13 +9,18 @@ const vertex_1 = require("../../../../../graph/vertex");
 const edge_1 = require("../../../../../graph/edge");
 const identifier_1 = require("../../../../../environments/identifier");
 const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
-function processApply(name, args, rootId, data, { indexOfFunction = 1, nameOfFunctionArgument, unquoteFunction, resolveInEnvironment, resolveValue }) {
+const unnamed_call_handling_1 = require("../unnamed-call-handling");
+const log_1 = require("../../../../../../util/log");
+function processApply(name, args, rootId, data, config) {
+    const { indexOfFunction = 1, nameOfFunctionArgument, unquoteFunction, resolveInEnvironment, resolveValue } = config;
     /* as the length is one-based and the argument filter mapping is zero-based, we do not have to subtract 1 */
     const forceArgsMask = new Array(indexOfFunction).fill(false);
     forceArgsMask.push(true);
-    const { information, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({
-        name, args, rootId, data, forceArgs: forceArgsMask
+    const resFn = (0, known_call_handling_1.processKnownFunctionCall)({
+        name, args, rootId, data, forceArgs: forceArgsMask, origin: 'builtin:apply'
     });
+    let information = resFn.information;
+    const processedArguments = resFn.processedArguments;
     let index = indexOfFunction;
     /* search, if one of the arguments actually contains the argument name if given in the config */
     if (nameOfFunctionArgument !== undefined) {
@@ -30,16 +35,21 @@ function processApply(name, args, rootId, data, { indexOfFunction = 1, nameOfFun
         return information;
     }
     const arg = args[index];
-    if (arg === r_function_call_1.EmptyArgument || !arg.value || (!unquoteFunction && arg.value.type !== type_1.RType.Symbol)) {
+    if (arg === r_function_call_1.EmptyArgument || !arg.value || (!unquoteFunction && arg.value.type !== type_1.RType.Symbol && arg.value.type !== type_1.RType.FunctionDefinition)) {
         logger_1.dataflowLogger.warn(`Expected symbol as argument at index ${index}, but got ${JSON.stringify(arg)} instead.`);
         return information;
     }
     let functionId = undefined;
     let functionName = undefined;
+    let anonymous = false;
     const val = arg.value;
     if (unquoteFunction && val.type === type_1.RType.String) {
         functionId = val.info.id;
         functionName = val.content.str;
+        information = {
+            ...information,
+            in: [...information.in, { type: identifier_1.ReferenceType.Function, name: functionName, controlDependencies: data.controlDependencies, nodeId: functionId }]
+        };
     }
     else if (val.type === type_1.RType.Symbol) {
         functionId = val.info.id;
@@ -53,15 +63,20 @@ function processApply(name, args, rootId, data, { indexOfFunction = 1, nameOfFun
             functionName = val.content;
         }
     }
+    else if (val.type === type_1.RType.FunctionDefinition) {
+        anonymous = true;
+        functionId = val.info.id;
+        functionName = `${unnamed_call_handling_1.UnnamedFunctionCallPrefix}${functionId}`;
+    }
     if (functionName === undefined || functionId === undefined) {
         logger_1.dataflowLogger.warn(`Expected symbol or string as function argument at index ${index}, but got ${JSON.stringify(val)} instead.`);
         return information;
     }
     const allOtherArguments = processedArguments.filter((_, i) => i !== index).map((arg, i) => {
         const counterpart = args[i];
-        if (arg && counterpart !== r_function_call_1.EmptyArgument && counterpart.name) {
+        if (arg && counterpart !== r_function_call_1.EmptyArgument) {
             return {
-                name: counterpart.name.content,
+                name: counterpart.name?.content,
                 controlDependencies: data.controlDependencies,
                 type: identifier_1.ReferenceType.Argument,
                 nodeId: arg.entryPoint
@@ -71,16 +86,69 @@ function processApply(name, args, rootId, data, { indexOfFunction = 1, nameOfFun
             return r_function_call_1.EmptyArgument;
         }
     });
-    /* identify it as a full-blown function call :) */
-    information.graph.updateToFunctionCall({
-        tag: vertex_1.VertexType.FunctionCall,
-        id: functionId,
-        name: functionName,
-        args: allOtherArguments,
-        environment: resolveInEnvironment === 'global' ? undefined : data.environment,
-        onlyBuiltin: resolveInEnvironment === 'global',
-        cds: data.controlDependencies
-    });
+    if (anonymous) {
+        const rootFnId = functionId;
+        functionId = 'anon-' + rootFnId;
+        information.graph.addVertex({
+            tag: vertex_1.VertexType.FunctionCall,
+            id: functionId,
+            environment: data.environment,
+            name: functionName,
+            /* can never be a direct built-in-call */
+            onlyBuiltin: false,
+            cds: data.controlDependencies,
+            args: allOtherArguments, // same reference
+            origin: ['function']
+        });
+        information.graph.addEdge(rootId, rootFnId, edge_1.EdgeType.Calls | edge_1.EdgeType.Reads);
+        information.graph.addEdge(rootId, functionId, edge_1.EdgeType.Calls | edge_1.EdgeType.Argument);
+        information = {
+            ...information,
+            in: [
+                ...information.in,
+                { type: identifier_1.ReferenceType.Function, name: functionName, controlDependencies: data.controlDependencies, nodeId: functionId }
+            ]
+        };
+        const dfVert = information.graph.getVertex(rootId);
+        if (dfVert && dfVert.tag === vertex_1.VertexType.FunctionDefinition) {
+            // resolve all ingoings against the environment
+            const ingoingRefs = dfVert.subflow.in;
+            const remainingIn = [];
+            for (const ingoing of ingoingRefs) {
+                const resolved = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, data.environment, ingoing.type) : undefined;
+                if (resolved === undefined) {
+                    remainingIn.push(ingoing);
+                    continue;
+                }
+                (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Found ${resolved.length} references to open ref ${ingoing.nodeId} in closure of function definition ${rootId}`);
+                let allBuiltIn = true;
+                for (const ref of resolved) {
+                    information.graph.addEdge(ingoing, ref, edge_1.EdgeType.Reads);
+                    information.graph.addEdge(rootId, ref, edge_1.EdgeType.Reads); // because the def. is the anonymous call
+                    if (!(0, identifier_1.isReferenceType)(ref.type, identifier_1.ReferenceType.BuiltInConstant | identifier_1.ReferenceType.BuiltInFunction)) {
+                        allBuiltIn = false;
+                    }
+                }
+                if (allBuiltIn) {
+                    remainingIn.push(ingoing);
+                }
+            }
+            dfVert.subflow.in = remainingIn;
+        }
+    }
+    else {
+        /* identify it as a full-blown function call :) */
+        information.graph.updateToFunctionCall({
+            tag: vertex_1.VertexType.FunctionCall,
+            id: functionId,
+            name: functionName,
+            args: allOtherArguments,
+            environment: resolveInEnvironment === 'global' ? undefined : data.environment,
+            onlyBuiltin: resolveInEnvironment === 'global',
+            cds: data.controlDependencies,
+            origin: ['function']
+        });
+    }
     for (const arg of processedArguments) {
         if (arg) {
             information.graph.addEdge(functionId, arg.entryPoint, edge_1.EdgeType.Argument);

package/dataflow/internal/process/functions/call/built-in/built-in-assignment.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.processAssignment = processAssignment;
 exports.markAsAssignment = markAsAssignment;
 const known_call_handling_1 = require("../known-call-handling");
-const assert_1 = require("../../../../../../util/assert");
 const log_1 = require("../../../../../../util/log");
 const unpack_argument_1 = require("../argument/unpack-argument");
 const process_named_call_1 = require("../../../process-named-call");
@@ -19,8 +18,8 @@ const edge_1 = require("../../../../../graph/edge");
 const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
 const containers_1 = require("../../../../../../util/containers");
 const config_1 = require("../../../../../../config");
-const built_in_replacement_1 = require("./built-in-replacement");
 const named_call_handling_1 = require("../named-call-handling");
+const built_in_1 = require("../../../../../environments/built-in");
 function toReplacementSymbol(target, prefix, superAssignment) {
     return {
         type: type_1.RType.Symbol,
@@ -47,13 +46,13 @@ function findRootAccess(node) {
         return undefined;
     }
 }
-function tryReplacementPassingIndices(functionName, data, name, args, indices) {
+function tryReplacementPassingIndices(rootId, functionName, data, name, args, indices) {
     const resolved = (0, resolve_by_name_1.resolveByName)(functionName.content, data.environment, identifier_1.ReferenceType.Function) ?? [];
     // yield for unsupported pass along!
     if (resolved.length !== 1 || resolved[0].type !== identifier_1.ReferenceType.BuiltInFunction) {
         return (0, process_named_call_1.processAsNamedCall)(functionName, data, name, args);
     }
-    const info = (0, built_in_replacement_1.processReplacementFunction)({
+    const info = built_in_1.BuiltInProcessorMapper['builtin:replacement']({
         type: type_1.RType.Symbol,
         info: functionName.info,
         content: name,
@@ -62,7 +61,8 @@ function tryReplacementPassingIndices(functionName, data, name, args, indices) {
         namespace: undefined
     }, (0, make_argument_1.wrapArgumentsUnnamed)(args, data.completeAst.idMap), functionName.info.id, data, {
         ...(resolved[0].config ?? {}),
-        activeIndices: indices
+        activeIndices: indices,
+        assignRootId: rootId
     });
     (0, named_call_handling_1.markAsOnlyBuiltIn)(info.graph, functionName.info.id);
     return info;
@@ -77,13 +77,17 @@ function processAssignment(name,
 args, rootId, data, config) {
     if (!config.mayHaveMoreArgs && args.length !== 2) {
         logger_1.dataflowLogger.warn(`Assignment ${name.content} has something else than 2 arguments, skipping`);
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs }).information;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: 'default' }).information;
     }
     const effectiveArgs = getEffectiveOrder(config, args);
-    const { target, source } = extractSourceAndTarget(effectiveArgs, name);
+    const { target, source } = extractSourceAndTarget(effectiveArgs);
+    if (target === undefined || source === undefined) {
+        logger_1.dataflowLogger.warn(`Assignment ${name.content} has an undefined target or source, skipping`);
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: 'default' }).information;
+    }
     const { type, named } = target;
     if (!config.targetVariable && type === type_1.RType.Symbol) {
-        const res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, reverseOrder: !config.swapSourceAndTarget, forceArgs: config.forceArgs });
+        const res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, reverseOrder: !config.swapSourceAndTarget, forceArgs: config.forceArgs, origin: 'builtin:assignment' });
         return processAssignmentToSymbol({
             ...config,
             nameOfAssignmentFunction: name.content,
@@ -99,12 +103,12 @@ args, rootId, data, config) {
         /* as replacement functions take precedence over the lhs fn-call (i.e., `names(x) <- ...` is independent from the definition of `names`), we do not have to process the call */
         logger_1.dataflowLogger.debug(`Assignment ${name.content} has a function call as target ==> replacement function ${target.lexeme}`);
         const replacement = toReplacementSymbol(target, target.functionName.content, config.superAssignment ?? false);
-        return tryReplacementPassingIndices(replacement, data, replacement.content, [...target.arguments, source], config.indicesCollection);
+        return tryReplacementPassingIndices(rootId, replacement, data, replacement.content, [...target.arguments, source], config.indicesCollection);
     }
     else if (config.canBeReplacement && type === type_1.RType.Access) {
         logger_1.dataflowLogger.debug(`Assignment ${name.content} has an access-type node as target ==> replacement function ${target.lexeme}`);
         const replacement = toReplacementSymbol(target, target.operator, config.superAssignment ?? false);
-        return tryReplacementPassingIndices(replacement, data, replacement.content, [(0, make_argument_1.toUnnamedArgument)(target.accessed, data.completeAst.idMap), ...target.access, source], config.indicesCollection);
+        return tryReplacementPassingIndices(rootId, replacement, data, replacement.content, [(0, make_argument_1.toUnnamedArgument)(target.accessed, data.completeAst.idMap), ...target.access, source], config.indicesCollection);
     }
     else if (type === type_1.RType.Access) {
         const rootArg = findRootAccess(target);
@@ -115,7 +119,8 @@ args, rootId, data, config) {
                 rootId,
                 data,
                 reverseOrder: !config.swapSourceAndTarget,
-                forceArgs: config.forceArgs
+                forceArgs: config.forceArgs,
+                origin: 'builtin:assignment'
             });
             return processAssignmentToSymbol({
                 ...config,
@@ -133,15 +138,16 @@ args, rootId, data, config) {
         return processAssignmentToString(target, args, name, rootId, data, config, source);
     }
     logger_1.dataflowLogger.warn(`Assignment ${name.content} has an unknown target type ${target.type} => unknown impact`);
-    const info = (0, known_call_handling_1.processKnownFunctionCall)({ name, args: effectiveArgs, rootId, data, forceArgs: config.forceArgs }).information;
+    const info = (0, known_call_handling_1.processKnownFunctionCall)({
+        name, args: effectiveArgs, rootId, data, forceArgs: config.forceArgs,
+        origin: 'builtin:assignment'
+    }).information;
     info.graph.markIdForUnknownSideEffects(rootId);
     return info;
 }
-function extractSourceAndTarget(args, name) {
+function extractSourceAndTarget(args) {
     const source = (0, unpack_argument_1.unpackArgument)(args[1], false);
     const target = (0, unpack_argument_1.unpackArgument)(args[0], false);
-    (0, assert_1.guard)(source !== undefined, () => `Assignment ${name.content} has no source, impossible!`);
-    (0, assert_1.guard)(target !== undefined, () => `Assignment ${name.content} has no target, impossible!`);
     return { source, target };
 }
 /**
@@ -176,7 +182,8 @@ function processAssignmentToString(target, args, name, rootId, data, config, sou
         rootId,
         data,
         reverseOrder: !config.swapSourceAndTarget,
-        forceArgs: config.forceArgs
+        forceArgs: config.forceArgs,
+        origin: 'builtin:assignment'
     });
     return processAssignmentToSymbol({
         ...config,

package/dataflow/internal/process/functions/call/built-in/built-in-eval.js

@@ -15,14 +15,14 @@ const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
 const append_1 = require("../../../../../environments/append");
 const assert_1 = require("../../../../../../util/assert");
-const arrays_1 = require("../../../../../../util/arrays");
+const arrays_1 = require("../../../../../../util/collections/arrays");
 function processEvalCall(name, args, rootId, data, config) {
     if (args.length !== 1 || args[0] === r_function_call_1.EmptyArgument || !args[0].value) {
         logger_1.dataflowLogger.warn(`Expected exactly one argument for eval currently, but got ${args.length} instead, skipping`);
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
     const information = config.includeFunctionCall ?
-        (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: [true] }).information
+        (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: [true], origin: 'builtin:eval' }).information
         : (0, info_1.initializeCleanDataflowInformation)(rootId, data);
     const evalArgument = args[0];
     if (config.includeFunctionCall) {
@@ -78,7 +78,7 @@ function resolveEvalToCode(evalArgument, env, idMap) {
         }
         else if (arg.value?.type === type_1.RType.Symbol) {
             const resolve = (0, resolve_by_name_1.resolveValueOfVariable)(arg.value.content, env, idMap);
-            if (resolve && resolve.every(r => typeof r === 'object' && r !== null && 'str' in r)) {
+            if (resolve?.every(r => typeof r === 'object' && r !== null && 'str' in r)) {
                 return resolve.map(r => r.str);
             }
         }
@@ -105,7 +105,7 @@ function getAsString(val, env, idMap) {
     }
     else if (val.type === type_1.RType.Symbol) {
         const resolved = (0, resolve_by_name_1.resolveValueOfVariable)(val.content, env, idMap);
-        if (resolved && resolved.every(r => typeof r === 'object' && r !== null && 'str' in r)) {
+        if (resolved?.every(r => typeof r === 'object' && r !== null && 'str' in r)) {
             return resolved.map(r => r.str);
         }
     }