@eagleoutice/flowr 2.2.10 → 2.2.12

package/dataflow/graph/graph.js

@@ -55,6 +55,8 @@ function getReferenceOfArgument(arg) {
 class DataflowGraph {
     static DEFAULT_ENVIRONMENT = undefined;
     _idMap;
+    /** all file paths included in this dfg */
+    _sourced = [];
     /*
      * Set of vertices which have sideEffects that we do not know anything about.
      * As a (temporary) solution until we have FD edges, a side effect may also store known target links
@@ -113,6 +115,13 @@ class DataflowGraph {
     get idMap() {
         return this._idMap;
     }
+    get sourced() {
+        return this._sourced;
+    }
+    /** Mark this file as being part of the dfg */
+    addFile(source) {
+        this._sourced.push(source);
+    }
     /**
      * Retrieves the set of vertices which have side effects that we do not know anything about.
      */
@@ -235,6 +244,7 @@ class DataflowGraph {
                 this.rootVertices.add(root);
             }
         }
+        this.sourced.push(...otherGraph.sourced);
         for (const unknown of otherGraph.unknownSideEffects) {
             this._unknownSideEffects.add(unknown);
         }
@@ -325,7 +335,15 @@ 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;
+        }
         return graph;
     }
 }
@@ -355,4 +373,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

@@ -14,6 +14,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 +51,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 +78,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)`
  */

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.js

@@ -23,6 +23,7 @@ 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)]
@@ -80,7 +81,8 @@ function linkArgumentsOnCall(args, params, graph) {
     const matchedParameters = new Set();
     // first map names
     for (const [name, arg] of nameArgMap) {
-        const param = nameParamMap.get(name);
+        const pmatchName = (0, prefix_1.findByPrefixIfUnique)(name, [...nameParamMap.keys()]) ?? name;
+        const param = nameParamMap.get(pmatchName);
         if (param !== undefined) {
             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);

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

@@ -1,3 +1,6 @@
 import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 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;

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

@@ -1,17 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.unpackArgument = unpackArgument;
-const log_1 = require("../../../../../../util/log");
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+/**
+ * Retrieve the value from an argument, if it is not empty.
+ */
 function unpackArgument(arg, noNameOnly = true) {
-    if (arg === r_function_call_1.EmptyArgument) {
-        log_1.log.trace('Argument is empty, skipping');
-        return undefined;
-    }
-    else if (noNameOnly && arg.name !== undefined) {
-        log_1.log.trace(`Argument ${JSON.stringify(arg)} is not unnamed, skipping`);
-        return undefined;
-    }
-    return arg.value;
+    return 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>[];

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processAccess = processAccess;
+exports.symbolArgumentsToStrings = symbolArgumentsToStrings;
 const known_call_handling_1 = require("../known-call-handling");
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const logger_1 = require("../../../../../logger");
@@ -11,7 +12,7 @@ const built_in_1 = require("../../../../../environments/built-in");
 const built_in_assignment_1 = require("./built-in-assignment");
 const identifier_1 = require("../../../../../environments/identifier");
 const vertex_1 = require("../../../../../graph/vertex");
-const list_access_1 = require("../../../../../../util/list-access");
+const containers_1 = require("../../../../../../util/containers");
 const config_1 = require("../../../../../../config");
 function tableAssignmentProcessor(name, args, rootId, data, outInfo) {
     outInfo.definitionRootNodes.push(rootId);
@@ -101,6 +102,7 @@ function processNumberBasedAccess(data, name, args, rootId, config, head) {
             definedAt: built_in_1.BuiltIn,
             controlDependencies: undefined,
             processor: (name, args, rootId, data) => tableAssignmentProcessor(name, args, rootId, data, outInfo),
+            config: {},
             name: ':=',
             nodeId: built_in_1.BuiltIn,
         }]);
@@ -112,21 +114,15 @@ function processNumberBasedAccess(data, name, args, rootId, config, head) {
     if (head.value && outInfo.definitionRootNodes.length > 0) {
         (0, built_in_assignment_1.markAsAssignment)(fnCall.information, { type: identifier_1.ReferenceType.Variable, name: head.value.lexeme ?? '', nodeId: head.value.info.id, definedAt: rootId, controlDependencies: [] }, outInfo.definitionRootNodes, rootId);
     }
+    if ((0, config_1.getConfig)().solver.pointerTracking) {
+        referenceAccessedIndices(args, data, fnCall, rootId, true);
+    }
     return fnCall;
 }
-/**
- * Processes different types of string-based access operations.
- *
- * Example:
- * ```r
- * a$foo
- * a@foo
- * ```
- */
-function processStringBasedAccess(args, data, name, rootId, config) {
+function symbolArgumentsToStrings(args, firstIndexInclusive = 1, lastIndexInclusive = args.length - 1) {
     const newArgs = [...args];
     // if the argument is a symbol, we convert it to a string for this perspective
-    for (let i = 1; i < newArgs.length; i++) {
+    for (let i = firstIndexInclusive; i <= lastIndexInclusive; i++) {
         const arg = newArgs[i];
         if (arg !== r_function_call_1.EmptyArgument && arg.value?.type === type_1.RType.Symbol) {
             newArgs[i] = {
@@ -144,47 +140,61 @@ function processStringBasedAccess(args, data, name, rootId, config) {
             };
         }
     }
+    return newArgs;
+}
+/**
+ * Processes different types of string-based access operations.
+ *
+ * Example:
+ * ```r
+ * a$foo
+ * a@foo
+ * ```
+ */
+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 });
+    if ((0, config_1.getConfig)().solver.pointerTracking) {
+        referenceAccessedIndices(newArgs, data, fnCall, rootId, false);
+    }
+    return fnCall;
+}
+function referenceAccessedIndices(newArgs, data, fnCall, rootId, isIndexBasedAccess) {
     // Resolve access on the way up the fold
-    const nonEmptyArgs = newArgs.filter(arg => arg !== r_function_call_1.EmptyArgument);
-    const accessedArg = nonEmptyArgs.find(arg => arg.info.role === "accessed" /* RoleInParent.Accessed */);
-    const accessArg = nonEmptyArgs.find(arg => arg.info.role === "index-access" /* RoleInParent.IndexAccess */);
+    const { accessedArg, accessArg } = (0, containers_1.getAccessOperands)(newArgs);
     if (accessedArg === undefined || accessArg === undefined) {
-        return fnCall;
+        return;
     }
-    if ((0, config_1.getConfig)().solver.pointerTracking) {
-        let accessedIndicesCollection;
-        // If the accessedArg is a symbol, it's either a simple access or the base case of a nested access
-        if (accessedArg.value?.type === type_1.RType.Symbol) {
-            accessedIndicesCollection = (0, list_access_1.resolveSingleIndex)(accessedArg, accessArg, data.environment);
+    let accessedIndicesCollection;
+    // If the accessedArg is a symbol, it's either a simple access or the base case of a nested access
+    if (accessedArg.value?.type === type_1.RType.Symbol) {
+        accessedIndicesCollection = (0, containers_1.resolveSingleIndex)(accessedArg, accessArg, data.environment, isIndexBasedAccess);
+    }
+    else {
+        // Higher access call
+        const underlyingAccessId = accessedArg.value?.info.id ?? -1;
+        const vertex = fnCall.information.graph.getVertex(underlyingAccessId);
+        const subIndices = vertex?.indicesCollection
+            ?.flatMap(indices => indices.indices)
+            ?.flatMap(index => index?.subIndices ?? []);
+        if (subIndices) {
+            accessedIndicesCollection = (0, containers_1.filterIndices)(subIndices, accessArg, isIndexBasedAccess);
         }
-        else {
-            // Higher access call
-            const underlyingAccessId = accessedArg.value?.info.id ?? -1;
-            const vertex = fnCall.information.graph.getVertex(underlyingAccessId);
-            const subIndices = vertex?.indicesCollection
-                ?.flatMap(indices => indices.indices)
-                ?.flatMap(index => index?.subIndices ?? []);
-            if (subIndices) {
-                accessedIndicesCollection = (0, list_access_1.filterIndices)(subIndices, accessArg);
-            }
+    }
+    // Add indices to vertex afterward
+    if (accessedIndicesCollection) {
+        const vertex = fnCall.information.graph.getVertex(rootId);
+        if (vertex) {
+            vertex.indicesCollection = accessedIndicesCollection;
         }
-        // Add indices to vertex afterward
-        if (accessedIndicesCollection) {
-            const vertex = fnCall.information.graph.getVertex(rootId);
-            if (vertex) {
-                vertex.indicesCollection = accessedIndicesCollection;
-            }
-            // When access has no access as parent, it's the top most
-            const rootNode = data.completeAst.idMap.get(rootId);
-            const parentNode = data.completeAst.idMap.get(rootNode?.info.parent ?? -1);
-            if (parentNode?.type !== type_1.RType.Access) {
-                // Only reference indices in top most access
-                referenceIndices(accessedIndicesCollection, fnCall, name.info.id);
-            }
+        // When access has no access as parent, it's the top most
+        const rootNode = data.completeAst.idMap.get(rootId);
+        const parentNode = data.completeAst.idMap.get(rootNode?.info.parent ?? -1);
+        if (parentNode?.type !== type_1.RType.Access) {
+            // Only reference indices in top most access
+            referenceIndices(accessedIndicesCollection, fnCall, rootId);
         }
     }
-    return fnCall;
 }
 /**
  * Creates edges of type {@link EdgeType.Reads} to the accessed Indices and their sub-indices starting from

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

@@ -10,9 +10,11 @@ export interface BuiltInApplyConfiguration extends MergeableRecord {
     readonly indexOfFunction?: number;
     /** does the argument have a name that it can be given by as well? */
     readonly nameOfFunctionArgument?: string;
-    /**
-     * Should we unquote the function if it is given as a string?
-     */
+    /** Should we unquote the function if it is given as a string? */
     readonly unquoteFunction?: boolean;
+    /** Should the function be resolved in the global environment? */
+    readonly resolveInEnvironment: 'global' | 'local';
+    /** 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 }: BuiltInApplyConfiguration): DataflowInformation;
+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;

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

@@ -8,7 +8,8 @@ const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const vertex_1 = require("../../../../../graph/vertex");
 const edge_1 = require("../../../../../graph/edge");
 const identifier_1 = require("../../../../../environments/identifier");
-function processApply(name, args, rootId, data, { indexOfFunction = 1, nameOfFunctionArgument, unquoteFunction }) {
+const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
+function processApply(name, args, rootId, data, { indexOfFunction = 1, nameOfFunctionArgument, unquoteFunction, resolveInEnvironment, resolveValue }) {
     /* 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);
@@ -33,8 +34,8 @@ function processApply(name, args, rootId, data, { indexOfFunction = 1, nameOfFun
         logger_1.dataflowLogger.warn(`Expected symbol as argument at index ${index}, but got ${JSON.stringify(arg)} instead.`);
         return information;
     }
-    let functionId;
-    let functionName;
+    let functionId = undefined;
+    let functionName = undefined;
     const val = arg.value;
     if (unquoteFunction && val.type === type_1.RType.String) {
         functionId = val.info.id;
@@ -42,9 +43,17 @@ function processApply(name, args, rootId, data, { indexOfFunction = 1, nameOfFun
     }
     else if (val.type === type_1.RType.Symbol) {
         functionId = val.info.id;
-        functionName = val.content;
+        if (resolveValue) {
+            const resolved = (0, resolve_by_name_1.resolveValueOfVariable)(val.content, data.environment);
+            if (resolved?.length === 1 && typeof resolved[0] === 'string') {
+                functionName = resolved[0];
+            }
+        }
+        else {
+            functionName = val.content;
+        }
     }
-    else {
+    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;
     }
@@ -68,8 +77,8 @@ function processApply(name, args, rootId, data, { indexOfFunction = 1, nameOfFun
         id: functionId,
         name: functionName,
         args: allOtherArguments,
-        environment: data.environment,
-        onlyBuiltin: false,
+        environment: resolveInEnvironment === 'global' ? undefined : data.environment,
+        onlyBuiltin: resolveInEnvironment === 'global',
         cds: data.controlDependencies
     });
     for (const arg of processedArguments) {
@@ -77,6 +86,16 @@ function processApply(name, args, rootId, data, { indexOfFunction = 1, nameOfFun
             information.graph.addEdge(functionId, arg.entryPoint, edge_1.EdgeType.Argument);
         }
     }
-    return information;
+    if (resolveInEnvironment === 'global') {
+        // remove from open ingoing references
+        return {
+            ...information,
+            in: information.in.filter(ref => ref.nodeId !== functionId),
+            unknownReferences: information.unknownReferences.filter(ref => ref.nodeId !== functionId)
+        };
+    }
+    else {
+        return information;
+    }
 }
 //# sourceMappingURL=built-in-apply.js.map

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

@@ -17,8 +17,10 @@ const vertex_1 = require("../../../../../graph/vertex");
 const define_1 = require("../../../../../environments/define");
 const edge_1 = require("../../../../../graph/edge");
 const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
-const list_access_1 = require("../../../../../../util/list-access");
+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");
 function toReplacementSymbol(target, prefix, superAssignment) {
     return {
         type: type_1.RType.Symbol,
@@ -45,6 +47,26 @@ function findRootAccess(node) {
         return undefined;
     }
 }
+function tryReplacementPassingIndices(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)({
+        type: type_1.RType.Symbol,
+        info: functionName.info,
+        content: name,
+        lexeme: functionName.lexeme,
+        location: functionName.location,
+        namespace: undefined
+    }, (0, make_argument_1.wrapArgumentsUnnamed)(args, data.completeAst.idMap), functionName.info.id, data, {
+        ...(resolved[0].config ?? {}),
+        activeIndices: indices
+    });
+    (0, named_call_handling_1.markAsOnlyBuiltIn)(info.graph, functionName.info.id);
+    return info;
+}
 /**
  * Processes an assignment, i.e., `<target> <- <source>`.
  * Handling it as a function call \`&lt;-\` `(<target>, <source>)`.
@@ -75,14 +97,14 @@ args, rootId, data, config) {
     }
     else if (config.canBeReplacement && type === type_1.RType.FunctionCall && named) {
         /* 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}`);
+        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 (0, process_named_call_1.processAsNamedCall)(replacement, data, replacement.content, [...target.arguments, source]);
+        return tryReplacementPassingIndices(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 as target => replacement function ${target.lexeme}`);
+        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 (0, process_named_call_1.processAsNamedCall)(replacement, data, replacement.content, [(0, make_argument_1.toUnnamedArgument)(target.accessed, data.completeAst.idMap), ...target.access, source]);
+        return tryReplacementPassingIndices(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);
@@ -191,16 +213,24 @@ function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignme
     if ((0, config_1.getConfig)().solver.pointerTracking) {
         let indicesCollection = undefined;
         if (sourceIds.length === 1) {
-            // support for tracking indices
+            // support for tracking indices.
             // Indices were defined for the vertex e.g. a <- list(c = 1) or a$b <- list(c = 1)
             indicesCollection = information.graph.getVertex(sourceIds[0])?.indicesCollection;
+            // support assignment of container e.g. container1 <- container2
+            // defined indices are passed
+            if (!indicesCollection) {
+                const node = information.graph.idMap?.get(sourceIds[0]);
+                if (node && node.type === type_1.RType.Symbol) {
+                    indicesCollection = (0, containers_1.resolveIndicesByName)(node.lexeme, information.environment);
+                }
+            }
         }
         // Indices defined by replacement operation e.g. $<-
         if (config?.indicesCollection !== undefined) {
             // If there were indices stored in the vertex, then a container was defined
             // and assigned to the index of another container e.g. a$b <- list(c = 1)
             if (indicesCollection) {
-                indicesCollection = (0, list_access_1.addSubIndicesToLeafIndices)(config.indicesCollection, indicesCollection);
+                indicesCollection = (0, containers_1.addSubIndicesToLeafIndices)(config.indicesCollection, indicesCollection);
             }
             else {
                 // No indices were defined for the vertex e.g. a$b <- 2

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

@@ -0,0 +1,10 @@
+import { type DataflowProcessorInformation } from '../../../../../processor';
+import type { DataflowInformation } from '../../../../../info';
+import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+export declare function processEvalCall<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
+    /** should this produce an explicit source function call in the graph? */
+    includeFunctionCall?: boolean;
+}): DataflowInformation;