@eagleoutice/flowr 2.1.8 → 2.1.10

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

@@ -11,10 +11,23 @@ const environment_1 = require("../../../../../environments/environment");
 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");
 function tableAssignmentProcessor(name, args, rootId, data, outInfo) {
     outInfo.definitionRootNodes.push(rootId);
     return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
 }
+/**
+ * Processes different types of access operations.
+ *
+ * Example:
+ * ```r
+ * a[i]
+ * a$foo
+ * a[[i]]
+ * a@foo
+ * ```
+ */
 function processAccess(name, args, rootId, data, config) {
     if (args.length < 2) {
         logger_1.dataflowLogger.warn(`Access ${name.content} has less than 2 arguments, skipping`);
@@ -26,47 +39,10 @@ function processAccess(name, args, rootId, data, config) {
     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 */
         // do we have a local definition that needs to be recovered?
-        const existing = data.environment.current.memory.get(':=');
-        const outInfo = { definitionRootNodes: [] };
-        data.environment.current.memory.set(':=', [{
-                type: identifier_1.ReferenceType.BuiltInFunction,
-                definedAt: built_in_1.BuiltIn,
-                controlDependencies: undefined,
-                processor: (name, args, rootId, data) => tableAssignmentProcessor(name, args, rootId, data, outInfo),
-                name: ':=',
-                nodeId: built_in_1.BuiltIn
-            }]);
-        fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs });
-        /* recover the environment */
-        if (existing !== undefined) {
-            data.environment.current.memory.set(':=', existing);
-        }
-        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);
-        }
+        fnCall = processNumberBasedAccess(data, name, args, rootId, config, head);
     }
     else {
-        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++) {
-            const arg = newArgs[i];
-            if (arg !== r_function_call_1.EmptyArgument && arg.value?.type === type_1.RType.Symbol) {
-                newArgs[i] = {
-                    ...arg,
-                    value: {
-                        type: type_1.RType.String,
-                        info: arg.value.info,
-                        lexeme: arg.value.lexeme,
-                        location: arg.value.location,
-                        content: {
-                            quotes: 'none',
-                            str: arg.value.lexeme
-                        }
-                    }
-                };
-            }
-        }
-        fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args: newArgs, rootId, data, forceArgs: config.forceArgs });
+        fnCall = processStringBasedAccess(args, data, name, rootId, config);
     }
     const info = fnCall.information;
     info.graph.addEdge(name.info.id, fnCall.processedArguments[0]?.entryPoint ?? head.info.id, edge_1.EdgeType.Returns);
@@ -80,16 +56,16 @@ function processAccess(name, args, rootId, data, config) {
     return {
         ...info,
         /*
-     * Keep active nodes in case of assignments etc.
-     * We make them maybe as a kind of hack.
-     * This way when using
-     * ```ts
-     * a[[1]] <- 3
-     * a[[2]] <- 4
-     * a
-     * ```
-     * the read for a will use both accesses as potential definitions and not just the last one!
-     */
+         * Keep active nodes in case of assignments etc.
+         * We make them maybe as a kind of hack.
+         * This way when using
+         * ```ts
+         * a[[1]] <- 3
+         * a[[2]] <- 4
+         * a
+         * ```
+         * the read for a will use both accesses as potential definitions and not just the last one!
+         */
         unknownReferences: (0, environment_1.makeAllMaybe)(info.unknownReferences, info.graph, info.environment, false),
         entryPoint: rootId,
         /** it is, to be precise, the accessed element we want to map to maybe */
@@ -103,4 +79,120 @@ function processAccess(name, args, rootId, data, config) {
         })
     };
 }
+/**
+ * Processes different types of number-based access operations.
+ *
+ * Example:
+ * ```r
+ * a[i]
+ * a[[i]]
+ * ```
+ */
+function processNumberBasedAccess(data, name, args, rootId, config, head) {
+    const existing = data.environment.current.memory.get(':=');
+    const outInfo = { definitionRootNodes: [] };
+    data.environment.current.memory.set(':=', [{
+            type: identifier_1.ReferenceType.BuiltInFunction,
+            definedAt: built_in_1.BuiltIn,
+            controlDependencies: undefined,
+            processor: (name, args, rootId, data) => tableAssignmentProcessor(name, args, rootId, data, outInfo),
+            name: ':=',
+            nodeId: built_in_1.BuiltIn,
+        }]);
+    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs });
+    /* recover the environment */
+    if (existing !== undefined) {
+        data.environment.current.memory.set(':=', existing);
+    }
+    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);
+    }
+    return fnCall;
+}
+/**
+ * Processes different types of string-based access operations.
+ *
+ * Example:
+ * ```r
+ * a$foo
+ * a@foo
+ * ```
+ */
+function processStringBasedAccess(args, data, name, rootId, config) {
+    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++) {
+        const arg = newArgs[i];
+        if (arg !== r_function_call_1.EmptyArgument && arg.value?.type === type_1.RType.Symbol) {
+            newArgs[i] = {
+                ...arg,
+                value: {
+                    type: type_1.RType.String,
+                    info: arg.value.info,
+                    lexeme: arg.value.lexeme,
+                    location: arg.value.location,
+                    content: {
+                        quotes: 'none',
+                        str: arg.value.lexeme
+                    }
+                }
+            };
+        }
+    }
+    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args: newArgs, rootId, data, forceArgs: config.forceArgs });
+    // 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 */);
+    if (accessedArg === undefined || accessArg === undefined) {
+        return fnCall;
+    }
+    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);
+    }
+    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;
+        }
+        // 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);
+        }
+    }
+    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
+ */
+function referenceIndices(accessedIndicesCollection, fnCall, parentNodeId) {
+    const accessedIndices = accessedIndicesCollection?.flatMap(indices => indices.indices);
+    for (const accessedIndex of accessedIndices ?? []) {
+        fnCall.information.graph.addEdge(parentNodeId, accessedIndex.nodeId, edge_1.EdgeType.Reads);
+        const accessedSubIndices = (0, vertex_1.isParentContainerIndex)(accessedIndex) ? accessedIndex.subIndices : undefined;
+        referenceIndices(accessedSubIndices, fnCall, accessedIndex.nodeId);
+    }
+}
 //# sourceMappingURL=built-in-access.js.map

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

@@ -4,17 +4,22 @@ import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/
 import type { RNode } from '../../../../../../r-bridge/lang-4.x/ast/model/model';
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
-import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { IdentifierDefinition } from '../../../../../environments/identifier';
+import { type NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { InGraphIdentifierDefinition } from '../../../../../environments/identifier';
+import type { ContainerIndicesCollection } from '../../../../../graph/vertex';
 import type { ForceArguments } from '../common';
 import type { REnvironmentInformation } from '../../../../../environments/environment';
 import type { DataflowGraph } from '../../../../../graph/graph';
 export interface AssignmentConfiguration extends ForceArguments {
     readonly superAssignment?: boolean;
     readonly swapSourceAndTarget?: boolean;
+    /** Make maybe if assigned to symbol */
     readonly makeMaybe?: boolean;
     readonly quoteSource?: boolean;
     readonly canBeReplacement?: boolean;
+    /** is the target a variable pointing at the actual name? */
+    readonly targetVariable?: boolean;
+    readonly indicesCollection?: ContainerIndicesCollection;
 }
 /**
  * Processes an assignment, i.e., `<target> <- <source>`.
@@ -43,4 +48,4 @@ export interface AssignmentToSymbolParameters<OtherInfo> extends AssignmentConfi
 export declare function markAsAssignment(information: {
     environment: REnvironmentInformation;
     graph: DataflowGraph;
-}, nodeToDefine: IdentifierDefinition, sourceIds: readonly NodeId[], rootIdOfAssignment: NodeId, quoteSource?: boolean, superAssignment?: boolean): void;
+}, nodeToDefine: InGraphIdentifierDefinition, sourceIds: readonly NodeId[], rootIdOfAssignment: NodeId, config?: AssignmentConfiguration | undefined): void;

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

@@ -16,6 +16,8 @@ const retriever_1 = require("../../../../../../r-bridge/retriever");
 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");
 function toReplacementSymbol(target, prefix, superAssignment) {
     return {
         type: type_1.RType.Symbol,
@@ -57,7 +59,7 @@ args, rootId, data, config) {
     const effectiveArgs = getEffectiveOrder(config, args);
     const { target, source } = extractSourceAndTarget(effectiveArgs, name);
     const { type, named } = target;
-    if (type === type_1.RType.Symbol) {
+    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 });
         return processAssignmentToSymbol({
             ...config,
@@ -107,8 +109,10 @@ args, rootId, data, config) {
     else if (type === type_1.RType.String) {
         return processAssignmentToString(target, args, name, rootId, data, config, source);
     }
-    logger_1.dataflowLogger.warn(`Assignment ${name.content} has an unknown target type ${target.type}, skipping`);
-    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args: effectiveArgs, rootId, data, forceArgs: config.forceArgs }).information;
+    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;
+    info.graph.markIdForUnknownSideEffects(rootId);
+    return info;
 }
 function extractSourceAndTarget(args, name) {
     const source = (0, unpack_argument_1.unpackArgument)(args[1], false);
@@ -117,12 +121,16 @@ function extractSourceAndTarget(args, name) {
     (0, assert_1.guard)(target !== undefined, () => `Assignment ${name.content} has no target, impossible!`);
     return { source, target };
 }
-function produceWrittenNodes(rootId, target, referenceType, data, makeMaybe) {
+/**
+ * Promotes the ingoing/unknown references of target (an assignment) to definitions
+ */
+function produceWrittenNodes(rootId, target, referenceType, data, makeMaybe, value) {
     return [...target.in, ...target.unknownReferences].map(ref => ({
         ...ref,
         type: referenceType,
         definedAt: rootId,
-        controlDependencies: data.controlDependencies ?? (makeMaybe ? [] : undefined)
+        controlDependencies: data.controlDependencies ?? (makeMaybe ? [] : undefined),
+        value: value
     }));
 }
 function processAssignmentToString(target, args, name, rootId, data, config, source) {
@@ -179,10 +187,29 @@ function checkTargetReferenceType(source, sourceInfo) {
  * @param quoteSource        - whether to quote the source (i.e., define `x` without a direct reference to `v`)
  * @param superAssignment    - whether this is a super assignment (i.e., `<<-`)
  */
-function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignment, quoteSource, superAssignment) {
-    information.environment = (0, define_1.define)(nodeToDefine, superAssignment, information.environment);
+function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignment, config) {
+    let indicesCollection = undefined;
+    if (sourceIds.length === 1) {
+        // 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;
+    }
+    // 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);
+        }
+        else {
+            // No indices were defined for the vertex e.g. a$b <- 2
+            indicesCollection = config.indicesCollection;
+        }
+    }
+    nodeToDefine.indicesCollection ??= indicesCollection;
+    information.environment = (0, define_1.define)(nodeToDefine, config?.superAssignment, information.environment);
     information.graph.setDefinitionOfVertex(nodeToDefine);
-    if (!quoteSource) {
+    if (!config?.quoteSource) {
         for (const sourceId of sourceIds) {
             information.graph.addEdge(nodeToDefine, sourceId, edge_1.EdgeType.DefinedBy);
         }
@@ -200,9 +227,11 @@ function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignme
 /**
  * Helper function whenever it is known that the _target_ of an assignment is a (single) symbol (i.e. `x <- ...`, but not `names(x) <- ...`).
  */
-function processAssignmentToSymbol({ nameOfAssignmentFunction, source, args: [targetArg, sourceArg], target, rootId, data, information, superAssignment, makeMaybe, quoteSource }) {
+function processAssignmentToSymbol(config) {
+    const { nameOfAssignmentFunction, source, args: [targetArg, sourceArg], target, rootId, data, information, makeMaybe, quoteSource } = config;
     const referenceType = checkTargetReferenceType(source, sourceArg);
-    const writeNodes = produceWrittenNodes(rootId, targetArg, referenceType, data, makeMaybe ?? false);
+    const aliases = (0, resolve_by_name_1.getAliases)([source.info.id], information.graph, information.environment);
+    const writeNodes = produceWrittenNodes(rootId, targetArg, referenceType, data, makeMaybe ?? false, aliases);
     if (writeNodes.length !== 1 && log_1.log.settings.minLevel <= 4 /* LogLevel.Warn */) {
         log_1.log.warn(`Unexpected write number in assignment: ${JSON.stringify(writeNodes)}`);
     }
@@ -215,7 +244,7 @@ function processAssignmentToSymbol({ nameOfAssignmentFunction, source, args: [ta
     information.environment = (0, overwrite_1.overwriteEnvironment)(targetArg.environment, sourceArg.environment);
     // install assigned variables in environment
     for (const write of writeNodes) {
-        markAsAssignment(information, write, [source.info.id], rootId, quoteSource, superAssignment);
+        markAsAssignment(information, write, [source.info.id], rootId, config);
     }
     information.graph.addEdge(rootId, targetArg.entryPoint, edge_1.EdgeType.Returns);
     if (quoteSource) {

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

@@ -4,4 +4,20 @@ import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { DataflowGraph } from '../../../../../graph/graph';
+import type { REnvironmentInformation } from '../../../../../environments/environment';
 export declare function processFunctionDefinition<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
+export declare function retrieveActiveEnvironment(callerEnvironment: REnvironmentInformation | undefined, baseEnvironment: REnvironmentInformation): REnvironmentInformation;
+/**
+ * Update the closure links of all nested function definitions
+ * @param graph          - dataflow graph to collect the function definitions from and to update the closure links for
+ * @param outEnvironment - active environment on resolving closures (i.e., exit of the function definition)
+ * @param fnId           - id of the function definition to update the closure links for
+ */
+export declare function updateNestedFunctionClosures(graph: DataflowGraph, outEnvironment: REnvironmentInformation, fnId: NodeId): void;
+/**
+ * Update the closure links of all nested function calls, this is probably to be done once at the end of the script
+ * @param graph          - dataflow graph to collect the function calls from and to update the closure links for
+ * @param outEnvironment - active environment on resolving closures (i.e., exit of the function definition)
+ */
+export declare function updateNestedFunctionCalls(graph: DataflowGraph, outEnvironment: REnvironmentInformation): void;

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

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processFunctionDefinition = processFunctionDefinition;
+exports.retrieveActiveEnvironment = retrieveActiveEnvironment;
+exports.updateNestedFunctionClosures = updateNestedFunctionClosures;
+exports.updateNestedFunctionCalls = updateNestedFunctionCalls;
 const processor_1 = require("../../../../../processor");
 const linker_1 = require("../../../../linker");
 const known_call_handling_1 = require("../known-call-handling");
@@ -77,7 +80,7 @@ function processFunctionDefinition(name, args, rootId, data) {
         graph: new Set(subgraph.rootIds()),
         environment: outEnvironment
     };
-    updateNestedFunctionClosures(subgraph, outEnvironment, name);
+    updateNestedFunctionClosures(subgraph, outEnvironment, name.info.id);
     const exitPoints = body.exitPoints;
     const graph = new graph_1.DataflowGraph(data.completeAst.idMap).mergeWith(subgraph, false);
     graph.addVertex({
@@ -99,10 +102,32 @@ function processFunctionDefinition(name, args, rootId, data) {
         environment: originalEnvironment
     };
 }
-function updateNestedFunctionClosures(subgraph, outEnvironment, name) {
+// this is no longer necessary when we update environments to be back to front (e.g., with a list of environments)
+// this favors the bigger environment
+function retrieveActiveEnvironment(callerEnvironment, baseEnvironment) {
+    callerEnvironment ??= (0, environment_1.initializeCleanEnvironments)(true);
+    let level = callerEnvironment.level ?? 0;
+    if (baseEnvironment.level !== level) {
+        while (baseEnvironment.level < level) {
+            baseEnvironment = (0, scoping_1.pushLocalEnvironment)(baseEnvironment);
+        }
+        while (baseEnvironment.level > level) {
+            callerEnvironment = (0, scoping_1.pushLocalEnvironment)(callerEnvironment);
+            level = callerEnvironment.level;
+        }
+    }
+    return (0, overwrite_1.overwriteEnvironment)(baseEnvironment, callerEnvironment);
+}
+/**
+ * Update the closure links of all nested function definitions
+ * @param graph          - dataflow graph to collect the function definitions from and to update the closure links for
+ * @param outEnvironment - active environment on resolving closures (i.e., exit of the function definition)
+ * @param fnId           - id of the function definition to update the closure links for
+ */
+function updateNestedFunctionClosures(graph, outEnvironment, fnId) {
     // track *all* function definitions - including those nested within the current graph,
     // try to resolve their 'in' by only using the lowest scope which will be popped after this definition
-    for (const [id, { subflow, tag }] of subgraph.vertices(true)) {
+    for (const [id, { subflow, tag }] of graph.vertices(true)) {
         if (tag !== vertex_1.VertexType.FunctionDefinition) {
             continue;
         }
@@ -114,15 +139,67 @@ function updateNestedFunctionClosures(subgraph, outEnvironment, name) {
                 remainingIn.push(ingoing);
                 continue;
             }
-            (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Found ${resolved.length} references to open ref ${id} in closure of function definition ${name.info.id}`);
+            (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Found ${resolved.length} references to open ref ${id} in closure of function definition ${fnId}`);
             for (const ref of resolved) {
-                subgraph.addEdge(ingoing, ref, edge_1.EdgeType.Reads);
+                graph.addEdge(ingoing, ref, edge_1.EdgeType.Reads);
             }
         }
-        (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Keeping ${remainingIn.length} references to open ref ${id} in closure of function definition ${name.info.id}`);
+        (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Keeping ${remainingIn.length} references to open ref ${id} in closure of function definition ${fnId}`);
         subflow.in = remainingIn;
     }
 }
+/**
+ * Update the closure links of all nested function calls, this is probably to be done once at the end of the script
+ * @param graph          - dataflow graph to collect the function calls from and to update the closure links for
+ * @param outEnvironment - active environment on resolving closures (i.e., exit of the function definition)
+ */
+function updateNestedFunctionCalls(graph, outEnvironment) {
+    // track *all* function definitions - including those nested within the current graph,
+    // try to resolve their 'in' by only using the lowest scope which will be popped after this definition
+    for (const [id, { onlyBuiltin, tag, environment, name }] of graph.vertices(true)) {
+        if (tag !== vertex_1.VertexType.FunctionCall || !name || onlyBuiltin) {
+            continue;
+        }
+        // only the call environment counts!
+        if (environment) {
+            while (outEnvironment.level > environment.level) {
+                outEnvironment = (0, scoping_1.popLocalEnvironment)(outEnvironment);
+            }
+            while (outEnvironment.level < environment.level) {
+                outEnvironment = (0, scoping_1.pushLocalEnvironment)(outEnvironment);
+            }
+        }
+        const effectiveEnvironment = environment ? (0, overwrite_1.overwriteEnvironment)(outEnvironment, environment) : outEnvironment;
+        const targets = (0, linker_1.getAllFunctionCallTargets)(id, graph, effectiveEnvironment);
+        for (const target of targets) {
+            const targetVertex = graph.getVertex(target);
+            if (targetVertex?.tag !== vertex_1.VertexType.FunctionDefinition) {
+                // support reads on symbols
+                if (targetVertex?.tag === vertex_1.VertexType.Use) {
+                    graph.addEdge(id, target, edge_1.EdgeType.Reads);
+                }
+                continue;
+            }
+            graph.addEdge(id, target, edge_1.EdgeType.Calls);
+            const ingoingRefs = targetVertex.subflow.in;
+            const remainingIn = [];
+            for (const ingoing of ingoingRefs) {
+                const resolved = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, effectiveEnvironment, ingoing.type) : undefined;
+                if (resolved === undefined) {
+                    remainingIn.push(ingoing);
+                    continue;
+                }
+                (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Found ${resolved.length} references to open ref ${id} in closure of function definition ${id}`);
+                for (const def of resolved) {
+                    graph.addEdge(ingoing, def, edge_1.EdgeType.DefinedByOnCall);
+                    graph.addEdge(id, def, edge_1.EdgeType.DefinesOnCall);
+                }
+            }
+            (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Keeping ${remainingIn.length} references to open ref ${id} in closure of function definition ${id}`);
+            targetVertex.subflow.in = remainingIn;
+        }
+    }
+}
 function prepareFunctionEnvironment(data) {
     let env = (0, environment_1.initializeCleanEnvironments)();
     for (let i = 0; i < data.environment.level + 1 /* add another env */; i++) {

package/dataflow/internal/process/functions/call/built-in/built-in-if-then-else.js

@@ -33,9 +33,9 @@ function processIfThenElse(name, args, rootId, data) {
     let then;
     let makeThenMaybe = false;
     // we should defer this to the abstract interpretation
-    const definitions = (0, resolve_by_name_1.resolveToConstants)(condArg?.lexeme, data.environment);
-    const conditionIsAlwaysFalse = definitions?.every(d => d.value === false) ?? false;
-    const conditionIsAlwaysTrue = definitions?.every(d => d.value === true) ?? false;
+    const values = (0, resolve_by_name_1.resolveValueOfVariable)(condArg?.lexeme, data.environment, cond.graph);
+    const conditionIsAlwaysFalse = values?.every(d => d === false) ?? false;
+    const conditionIsAlwaysTrue = values?.every(d => d === true) ?? false;
     if (!conditionIsAlwaysFalse) {
         then = (0, processor_1.processDataflowFor)(thenArg, data);
         if (then.entryPoint) {

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

@@ -0,0 +1,15 @@
+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 { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { DataflowInformation } from '../../../../../info';
+import type { DataflowProcessorInformation } from '../../../../../processor';
+/**
+ * Process a list call.
+ *
+ * Example:
+ * ```r
+ * list(a = 1, b = 2)
+ * ```
+ */
+export declare function processList<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processList = processList;
+const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
+const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
+const known_call_handling_1 = require("../known-call-handling");
+const config_1 = require("../../../../../../config");
+/**
+ * Process a list call.
+ *
+ * Example:
+ * ```r
+ * list(a = 1, b = 2)
+ * ```
+ */
+function processList(name, args, rootId, data) {
+    if (!(0, config_1.getConfig)().solver.pointerTracking) {
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    const namedArguments = [];
+    for (const arg of args) {
+        // Skip non named arguments
+        if (arg === r_function_call_1.EmptyArgument || arg.type !== type_1.RType.Argument || arg.name === undefined) {
+            continue;
+        }
+        let newIndex = {
+            lexeme: arg.name.content,
+            nodeId: arg.info.id,
+        };
+        // Check whether argument value is non-primitive
+        if (arg.value?.type === type_1.RType.Symbol) {
+            const defs = (0, resolve_by_name_1.resolveByName)(arg.value.lexeme, data.environment);
+            const indices = defs?.flatMap(index => index.indicesCollection ?? []);
+            if (indices) {
+                newIndex = {
+                    ...newIndex,
+                    subIndices: indices,
+                };
+            }
+        }
+        namedArguments.push(newIndex);
+    }
+    const indices = {
+        indices: namedArguments,
+        isContainer: true,
+    };
+    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }, [indices]).information;
+}
+//# sourceMappingURL=built-in-list.js.map

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

@@ -3,7 +3,7 @@ import type { DataflowInformation } from '../../../../../info';
 import type { ForceArguments } from '../common';
 import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
-import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 export declare function processReplacementFunction<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, 
 /** The last one has to be the value */

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

@@ -7,11 +7,14 @@ const log_1 = require("../../../../../../util/log");
 const built_in_assignment_1 = require("./built-in-assignment");
 const common_1 = require("../common");
 const assert_1 = require("../../../../../../util/assert");
+const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const logger_1 = require("../../../../../logger");
 const vertex_1 = require("../../../../../graph/vertex");
 const graph_1 = require("../../../../../graph/graph");
 const edge_1 = require("../../../../../graph/edge");
 const dfg_1 = require("../../../../../../util/mermaid/dfg");
+const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
+const list_access_1 = require("../../../../../../util/list-access");
 function processReplacementFunction(name, 
 /** The last one has to be the value */
 args, rootId, data, config) {
@@ -21,8 +24,33 @@ args, rootId, data, config) {
     }
     /* we only get here if <-, <<-, ... or whatever is part of the replacement is not overwritten */
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Replacement ${name.content} with ${JSON.stringify(args)}, processing`);
+    let indices = undefined;
+    if (name.content === '$<-') {
+        const nonEmptyArgs = args.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 */);
+        if (accessArg !== undefined && accessedArg != undefined) {
+            const leafIndex = { lexeme: accessArg.lexeme, nodeId: accessedArg.info.parent ?? '' };
+            const accessIndices = {
+                indices: [leafIndex],
+                isContainer: false
+            };
+            // Check for nested access
+            if (accessedArg.value?.type === type_1.RType.Access) {
+                indices = (0, list_access_1.constructNestedAccess)(accessedArg.value, accessIndices);
+            }
+            else {
+                // use access node as reference to get complete line in slice
+                indices = [accessIndices];
+            }
+        }
+    }
     /* we assign the first argument by the last for now and maybe mark as maybe!, we can keep the symbol as we now know we have an assignment */
-    const res = (0, built_in_assignment_1.processAssignment)(name, [args[0], args[args.length - 1]], rootId, data, { superAssignment: config.assignmentOperator === '<<-', makeMaybe: config.makeMaybe });
+    const res = (0, built_in_assignment_1.processAssignment)(name, [args[0], args[args.length - 1]], rootId, data, {
+        superAssignment: config.assignmentOperator === '<<-',
+        makeMaybe: indices !== undefined ? false : config.makeMaybe,
+        indicesCollection: indices
+    });
     /* now, we soft-inject other arguments, so that calls like `x[y] <- 3` are linked correctly */
     const { callArgs } = (0, common_1.processAllArguments)({
         functionName: (0, info_1.initializeCleanDataflowInformation)(rootId, data),