@eagleoutice/flowr 2.2.11 → 2.2.13

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,11 +12,11 @@ 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);
-    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.
@@ -31,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 */
@@ -96,15 +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);
@@ -112,21 +115,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,55 +141,71 @@ function processStringBasedAccess(args, data, name, rootId, config) {
             };
         }
     }
-    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args: newArgs, rootId, data, forceArgs: config.forceArgs });
+    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,
+        origin: 'builtin:access'
+    });
+    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
  * 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

@@ -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>, config: BuiltInApplyConfiguration): DataflowInformation;

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

@@ -8,13 +8,19 @@ 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");
+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) {
@@ -29,30 +35,48 @@ 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;
-    let functionName;
+    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;
-        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 {
+    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
@@ -62,21 +86,84 @@ 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: data.environment,
-        onlyBuiltin: false,
-        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);
         }
     }
-    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

@@ -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");
@@ -17,8 +16,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 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,
@@ -45,6 +46,27 @@ function findRootAccess(node) {
         return undefined;
     }
 }
+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 = built_in_1.BuiltInProcessorMapper['builtin:replacement']({
+        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,
+        assignRootId: rootId
+    });
+    (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>)`.
@@ -55,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,
@@ -75,14 +101,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(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 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(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);
@@ -93,7 +119,8 @@ args, rootId, data, config) {
                 rootId,
                 data,
                 reverseOrder: !config.swapSourceAndTarget,
-                forceArgs: config.forceArgs
+                forceArgs: config.forceArgs,
+                origin: 'builtin:assignment'
             });
             return processAssignmentToSymbol({
                 ...config,
@@ -111,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 };
 }
 /**
@@ -154,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,
@@ -191,16 +220,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;