@eagleoutice/flowr 2.2.11 → 2.2.13

package/dataflow/graph/graph.js

@@ -5,15 +5,14 @@ exports.isPositionalArgument = isPositionalArgument;
 exports.isNamedArgument = isNamedArgument;
 exports.getReferenceOfArgument = getReferenceOfArgument;
 const assert_1 = require("../../util/assert");
-const diff_1 = require("./diff");
+const diff_dataflow_graph_1 = require("./diff-dataflow-graph");
 const vertex_1 = require("./vertex");
-const arrays_1 = require("../../util/arrays");
+const arrays_1 = require("../../util/collections/arrays");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const environment_1 = require("../environments/environment");
 const clone_1 = require("../environments/clone");
 const json_1 = require("../../util/json");
-const built_in_1 = require("../environments/built-in");
 const logger_1 = require("../logger");
 /**
  * Check if the given argument is a {@link PositionalFunctionArgument}.
@@ -50,7 +49,7 @@ function getReferenceOfArgument(arg) {
  * @see {@link DataflowGraph#addEdge|`addEdge`} - to add an edge to the graph
  * @see {@link DataflowGraph#addVertex|`addVertex`} - to add a vertex to the graph
  * @see {@link DataflowGraph#fromJson|`fromJson`} - to construct a dataflow graph object from a deserialized JSON object.
- * @see {@link emptyGraph} - to create an empty graph (useful in tests)
+ * @see {@link emptyGraph|`emptyGraph`} - to create an empty graph (useful in tests)
  */
 class DataflowGraph {
     static DEFAULT_ENVIRONMENT = undefined;
@@ -111,6 +110,24 @@ class DataflowGraph {
         }
         return edges;
     }
+    /**
+     * Given a node in the normalized AST this either:
+     * * returns the id if the node directly exists in the DFG
+     * * returns the ids of all vertices in the DFG that are linked to this
+     * * returns undefined if the node is not part of the DFG and not linked to any node
+     */
+    getLinked(nodeId) {
+        if (this.vertexInformation.has(nodeId)) {
+            return [nodeId];
+        }
+        const linked = [];
+        for (const [id, vtx] of this.vertexInformation) {
+            if (vtx.link?.origin.includes(nodeId)) {
+                linked.push(id);
+            }
+        }
+        return linked.length > 0 ? linked : undefined;
+    }
     /** Retrieves the id-map to the normalized AST attached to the dataflow graph */
     get idMap() {
         return this._idMap;
@@ -180,13 +197,14 @@ class DataflowGraph {
      * @param vertex - The vertex to add
      * @param asRoot - If false, this will only add the vertex but do not add it to the {@link rootIds|root vertices} of the graph.
      *                 This is probably only of use, when you construct dataflow graphs for tests.
+     * @param overwrite - If true, this will overwrite the vertex if it already exists in the graph (based on the id).
      *
      * @see DataflowGraphVertexInfo
      * @see DataflowGraphVertexArgument
      */
-    addVertex(vertex, asRoot = true) {
+    addVertex(vertex, asRoot = true, overwrite = false) {
         const oldVertex = this.vertexInformation.get(vertex.id);
-        if (oldVertex !== undefined) {
+        if (oldVertex !== undefined && !overwrite) {
             return this;
         }
         const fallback = vertex.tag === vertex_1.VertexType.VariableDefinition || vertex.tag === vertex_1.VertexType.Use || vertex.tag === vertex_1.VertexType.Value || (vertex.tag === vertex_1.VertexType.FunctionCall && vertex.onlyBuiltin) ? undefined : DataflowGraph.DEFAULT_ENVIRONMENT;
@@ -201,12 +219,9 @@ class DataflowGraph {
         }
         return this;
     }
-    /**
-     * Please note that this will never make edges to {@link BuiltIn} as they are not part of the graph.
-     */
     addEdge(from, to, type) {
         const [fromId, toId] = extractEdgeIds(from, to);
-        if (fromId === toId || toId === built_in_1.BuiltIn) {
+        if (fromId === toId) {
             return this;
         }
         /* we now that we pass all required arguments */
@@ -244,7 +259,7 @@ class DataflowGraph {
                 this.rootVertices.add(root);
             }
         }
-        this.sourced.push(...otherGraph.sourced);
+        this._sourced = this._sourced.concat(otherGraph.sourced);
         for (const unknown of otherGraph.unknownSideEffects) {
             this._unknownSideEffects.add(unknown);
         }
@@ -335,6 +350,11 @@ class DataflowGraph {
         const graph = new DataflowGraph(undefined);
         graph.rootVertices = new Set(data.rootVertices);
         graph.vertexInformation = new Map(data.vertexInformation);
+        for (const [, vertex] of graph.vertexInformation) {
+            if (vertex.environment) {
+                vertex.environment = renvFromJson(vertex.environment);
+            }
+        }
         graph.edgeInformation = new Map(data.edgeInformation.map(([id, edges]) => [id, new Map(edges)]));
         if (data.sourced) {
             graph._sourced = data.sourced;
@@ -352,7 +372,7 @@ function mergeNodeInfos(current, next) {
         (0, assert_1.guard)(current.scope === next.scope, 'nodes to be joined for the same id must have the same scope');
     }
     else if (current.tag === vertex_1.VertexType.FunctionCall) {
-        (0, assert_1.guard)((0, diff_1.equalFunctionArguments)(current.id, current.args, next.args), 'nodes to be joined for the same id must have the same function call information');
+        (0, assert_1.guard)((0, diff_dataflow_graph_1.equalFunctionArguments)(current.id, current.args, next.args), 'nodes to be joined for the same id must have the same function call information');
     }
     else if (current.tag === vertex_1.VertexType.FunctionDefinition) {
         (0, assert_1.guard)(current.scope === next.scope, 'nodes to be joined for the same id must have the same scope');
@@ -368,4 +388,23 @@ function extractEdgeIds(from, to) {
     const toId = typeof to === 'object' ? to.nodeId : to;
     return [fromId, toId];
 }
+function envFromJson(json) {
+    const parent = json.parent ? envFromJson(json.parent) : undefined;
+    const memory = new Map();
+    for (const [key, value] of Object.entries(json.memory)) {
+        memory.set(key, value);
+    }
+    return {
+        id: json.id,
+        parent: parent,
+        memory
+    };
+}
+function renvFromJson(json) {
+    const current = envFromJson(json.current);
+    return {
+        current,
+        level: json.level
+    };
+}
 //# sourceMappingURL=graph.js.map

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",
@@ -14,6 +15,36 @@ export declare const ValidVertexTypes: Set<string>;
 export declare const ValidVertexTypeReverse: {
     [k: string]: string;
 };
+/**
+ * Identifier for arguments e.g. for `3` in `c(2, 3, 5)` the identifier would be
+ * ```ts
+ * {
+ *   index: 2
+ * }
+ * ```
+ */
+export interface UnnamedArgumentId {
+    readonly index: number;
+}
+/**
+ * Identifier for named arguments e.g. for `age` in `list(name = 'John', age = 8)`
+ * the indentifier would be
+ * ```ts
+ * {
+ *   index: 2,
+ *   lexeme: 'age'
+ * }
+ * ```
+ */
+export interface NamedArgumentId {
+    /**
+     * Index may be undefined, when no index information is available.
+     */
+    readonly index: number | undefined;
+    readonly lexeme: string;
+}
+export declare function isNamedArgumentId(identifier: IndexIdentifier): identifier is NamedArgumentId;
+export type IndexIdentifier = UnnamedArgumentId | NamedArgumentId;
 /**
  * A single index of a container, which is not a container itself.
  *
@@ -21,9 +52,9 @@ export declare const ValidVertexTypeReverse: {
  */
 export interface ContainerLeafIndex {
     /**
-     * Distinctive lexeme of index e.g. 'name' for `list(name = 'John')`
+     * Distinctive identifier of index, see {@link IndexIdentifier}.
      */
-    readonly lexeme: string;
+    readonly identifier: IndexIdentifier;
     /**
      * NodeId of index in graph.
      */
@@ -48,6 +79,16 @@ export declare function isParentContainerIndex(index: ContainerIndex): index is
  * A single index of a container.
  */
 export type ContainerIndex = ContainerLeafIndex | ContainerParentIndex;
+/**
+ * Checks whether {@link index} is accessed by {@link accessLexeme}.
+ *
+ * @param index - The {@link ContainerIndex}, which is accessed
+ * @param accessLexeme - The access lexeme
+ * @param isIndexBasedAccess - Whether the index of the {@link ContainerIndex} is accessed i.e. the position in the container and not e.g. the name of the index
+ * @returns true, when {@link accessLexeme} accesses the {@link index}, false otherwise
+ */
+export declare function isAccessed(index: ContainerIndex, accessLexeme: string, isIndexBasedAccess: boolean): boolean;
+export declare function isSameIndex(a: ContainerIndex, b: ContainerIndex): boolean;
 /**
  * List of indices of a single statement like `list(a=3, b=2)`
  */
@@ -95,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.
@@ -133,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
  */
@@ -146,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/graph/vertex.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValidVertexTypeReverse = exports.ValidVertexTypes = exports.VertexType = void 0;
+exports.isNamedArgumentId = isNamedArgumentId;
 exports.isParentContainerIndex = isParentContainerIndex;
+exports.isAccessed = isAccessed;
+exports.isSameIndex = isSameIndex;
 exports.isValueVertex = isValueVertex;
 exports.isUseVertex = isUseVertex;
 exports.isFunctionCallVertex = isFunctionCallVertex;
@@ -17,9 +20,38 @@ var VertexType;
 })(VertexType || (exports.VertexType = VertexType = {}));
 exports.ValidVertexTypes = new Set(Object.values(VertexType));
 exports.ValidVertexTypeReverse = Object.fromEntries(Object.entries(VertexType).map(([k, v]) => [v, k]));
+function isNamedArgumentId(identifier) {
+    return 'lexeme' in identifier;
+}
 function isParentContainerIndex(index) {
     return 'subIndices' in index;
 }
+/**
+ * Checks whether {@link index} is accessed by {@link accessLexeme}.
+ *
+ * @param index - The {@link ContainerIndex}, which is accessed
+ * @param accessLexeme - The access lexeme
+ * @param isIndexBasedAccess - Whether the index of the {@link ContainerIndex} is accessed i.e. the position in the container and not e.g. the name of the index
+ * @returns true, when {@link accessLexeme} accesses the {@link index}, false otherwise
+ */
+function isAccessed(index, accessLexeme, isIndexBasedAccess) {
+    if (isIndexBasedAccess) {
+        return index.identifier.index === Number(accessLexeme);
+    }
+    if (isNamedArgumentId(index.identifier)) {
+        return index.identifier.lexeme === accessLexeme;
+    }
+    return false;
+}
+function isSameIndex(a, b) {
+    if (isNamedArgumentId(a.identifier) && isNamedArgumentId(b.identifier)) {
+        return a.identifier.lexeme === b.identifier.lexeme;
+    }
+    if (a.identifier.index === undefined || b.identifier.index === undefined) {
+        return false;
+    }
+    return a.identifier.index === b.identifier.index;
+}
 /**
  * Check if the given vertex is a {@link DataflowGraphVertexValue|value vertex}.
  */

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,7 @@ 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));
     const ids = new Set([...graph.vertices(true)]
@@ -74,26 +74,27 @@ 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();
     // first map names
     for (const [name, arg] of nameArgMap) {
-        const param = nameParamMap.get(name);
-        if (param !== undefined) {
+        const pmatchName = (0, prefix_1.findByPrefixIfUnique)(name, [...nameParamMap.keys()]) ?? name;
+        const param = nameParamMap.get(pmatchName);
+        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];
@@ -113,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) {
@@ -142,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);
+                }
             }
         }
     }
@@ -166,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);
@@ -196,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 [];
@@ -212,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);
@@ -242,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;
@@ -251,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.
@@ -277,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.d.ts

@@ -19,3 +19,4 @@ import type { ForceArguments } from '../common';
 export declare function processAccess<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     treatIndicesAsString: boolean;
 } & ForceArguments): DataflowInformation;
+export declare function symbolArgumentsToStrings<OtherInfo>(args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], firstIndexInclusive?: number, lastIndexInclusive?: number): RFunctionArgument<OtherInfo & ParentInformation>[];