@eagleoutice/flowr 2.1.9 → 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,19 +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>`.
@@ -45,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,
@@ -119,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) {
@@ -181,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);
         }
@@ -202,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)}`);
     }
@@ -217,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-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),

package/dataflow/internal/process/functions/call/common.js

@@ -77,7 +77,12 @@ function processAllArguments({ functionName, args, data, finalGraph, functionRoo
                     if ((0, info_1.happensInEveryBranch)(resolved.controlDependencies)) {
                         assumeItMayHaveAHigherTarget = false;
                     }
-                    finalGraph.addEdge(ingoing.nodeId, resolved.nodeId, edge_1.EdgeType.Reads);
+                    // When only a single index is referenced, we don't need to reference the whole object
+                    const resolvedInGraphDef = resolved;
+                    const isContainer = checkForContainer(resolvedInGraphDef?.indicesCollection);
+                    if (isContainer || isContainer === undefined) {
+                        finalGraph.addEdge(ingoing.nodeId, resolved.nodeId, edge_1.EdgeType.Reads);
+                    }
                 }
                 if (assumeItMayHaveAHigherTarget) {
                     remainingReadInArgs.push(ingoing);
@@ -113,4 +118,13 @@ function patchFunctionCall({ nextGraph, rootId, name, data, argumentProcessResul
         }
     }
 }
+/**
+ * Check whether passed {@link indices} are containers or whether their sub-indices are containers.
+ */
+function checkForContainer(indices) {
+    return indices?.every((indices) => {
+        const areSubIndicesContainers = indices.indices.every(index => 'subIndices' in index && checkForContainer(index.subIndices));
+        return indices.isContainer || areSubIndicesContainers;
+    });
+}
 //# sourceMappingURL=common.js.map

package/dataflow/internal/process/functions/call/known-call-handling.d.ts

@@ -8,6 +8,7 @@ import type { NodeId } from '../../../../../r-bridge/lang-4.x/ast/model/processi
 import type { RNode } from '../../../../../r-bridge/lang-4.x/ast/model/model';
 import type { IdentifierReference } from '../../../../environments/identifier';
 import { DataflowGraph } from '../../../../graph/graph';
+import type { ContainerIndicesCollection } from '../../../../graph/vertex';
 export interface ProcessKnownFunctionCallInput<OtherInfo> extends ForceArguments {
     readonly name: RSymbol<OtherInfo & ParentInformation>;
     readonly args: readonly (RNode<OtherInfo & ParentInformation> | RFunctionArgument<OtherInfo & ParentInformation>)[];
@@ -28,4 +29,4 @@ export interface ProcessKnownFunctionCallResult {
     readonly fnRef: IdentifierReference;
 }
 export declare function markNonStandardEvaluationEdges(markAsNSE: readonly number[], callArgs: readonly (DataflowInformation | undefined)[], finalGraph: DataflowGraph, rootId: NodeId): void;
-export declare function processKnownFunctionCall<OtherInfo>({ name, args, rootId, data, reverseOrder, markAsNSE, forceArgs, patchData, hasUnknownSideEffect }: ProcessKnownFunctionCallInput<OtherInfo>): ProcessKnownFunctionCallResult;
+export declare function processKnownFunctionCall<OtherInfo>({ name, args, rootId, data, reverseOrder, markAsNSE, forceArgs, patchData, hasUnknownSideEffect }: ProcessKnownFunctionCallInput<OtherInfo>, indicesCollection?: ContainerIndicesCollection): ProcessKnownFunctionCallResult;

package/dataflow/internal/process/functions/call/known-call-handling.js

@@ -23,7 +23,7 @@ function markNonStandardEvaluationEdges(markAsNSE, callArgs, finalGraph, rootId)
         }
     }
 }
-function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = false, markAsNSE = undefined, forceArgs, patchData = d => d, hasUnknownSideEffect }) {
+function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = false, markAsNSE = undefined, forceArgs, patchData = d => d, hasUnknownSideEffect }, indicesCollection = undefined) {
     const functionName = (0, processor_1.processDataflowFor)(name, data);
     const finalGraph = new graph_1.DataflowGraph(data.completeAst.idMap);
     const functionCallName = name.content;
@@ -41,7 +41,8 @@ function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = fal
         /* will be overwritten accordingly */
         onlyBuiltin: false,
         controlDependencies: data.controlDependencies,
-        args: reverseOrder ? [...callArgs].reverse() : callArgs
+        args: reverseOrder ? [...callArgs].reverse() : callArgs,
+        indicesCollection: indicesCollection,
     });
     if (hasUnknownSideEffect) {
         finalGraph.markIdForUnknownSideEffects(rootId);

package/documentation/print-interface-wiki.js

@@ -171,6 +171,7 @@ The following summarizes the configuration options:
 - \`semantics\`: allows to configure the way _flowR_ handles R, although we currently only support \`semantics/environment/overwriteBuiltIns\`. 
   You may use this to overwrite _flowR_'s handling of built-in function and even completely clear the preset definitions shipped with flowR. 
   See [Configure BuiltIn Semantics](#configure-builtin-semantics) for more information.
+- \`solver\`: allows to configure how _flowR_ resolves variables and their values (currently we support: ${Object.values(config_1.VariableResolve).map(v => `\`${v}\``).join(', ')}), as well as if pointer analysis should be active.
 
 So you can configure _flowR_ by adding a file like the following:
 
@@ -189,6 +190,10 @@ ${(0, doc_code_1.codeBlock)('json', JSON.stringify({
                     ]
                 }
             }
+        },
+        solver: {
+            variables: config_1.VariableResolve.Alias,
+            pointerTracking: true
         }
     }, null, 2))}
 
@@ -233,7 +238,7 @@ _flowR_ can be used as a [module](${doc_files_1.FlowrNpmRef}) and offers several
 ### Using the \`${shell_1.RShell.name}\` to Interact with R
 
 The \`${shell_1.RShell.name}\` class allows to interface with the \`R\` ecosystem installed on the host system.
-For now there are no (real) alternatives, although we plan on providing more flexible drop-in replacements.
+For now, there are no (real) alternatives, although we plan on providing more flexible drop-in replacements.
 
 > [!IMPORTANT]
 > Each \`${shell_1.RShell.name}\` controls a new instance of the R interpreter, make sure to call \`${shell_1.RShell.name}::${shell.close.name}()\` when you’re done.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.1.9",
+  "version": "2.1.10",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {

package/util/list-access.d.ts

@@ -0,0 +1,48 @@
+import type { REnvironmentInformation } from '../dataflow/environments/environment';
+import type { ContainerIndices, ContainerIndicesCollection } from '../dataflow/graph/vertex';
+import type { RAccess } from '../r-bridge/lang-4.x/ast/model/nodes/r-access';
+import type { ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+/**
+ * Resolves {@link accessedArg} in the {@link environment} and filters its indices according to {@link accessArg}.
+ *
+ * @param accessedArg - The argument to resolve
+ * @param accessArg - The argument which is used to filter the indices
+ * @param environment - The environment in which {@link accessedArg} is resolved
+ * @returns The filtered {@link ContainerIndicesCollection} of the resolved {@link accessedArg}
+ */
+export declare function resolveSingleIndex(accessedArg: {
+    lexeme: string;
+}, accessArg: {
+    lexeme: string;
+}, environment: REnvironmentInformation): ContainerIndicesCollection;
+/**
+ * Filters the single indices of the {@link indicesCollection} according to the lexeme of the {@link accessArg}.
+ *
+ * @param indicesCollection - The {@link ContainerIndicesCollection} to filter
+ * @param accessArg - The argument which is used to filter {@link indicesCollection}
+ * @returns The filtered copy of {@link indicesCollection}
+ */
+export declare function filterIndices(indicesCollection: ContainerIndicesCollection, accessArg: {
+    lexeme: string;
+}): ContainerIndicesCollection;
+/**
+ * Constructs the definition of a nested access.
+ *
+ * Example:
+ * ```r
+ * person$credentials$username
+ * ```
+ * would result in a list with the index `credentials`, which has the subIndex `username`.
+ *
+ * @param accessedArg - The top level argument that is accessed
+ * @param leafIndices - The index at the end of the nested access i.e. `c` in `a$b$c`.
+ * @returns The constructed nested access
+ */
+export declare function constructNestedAccess<OtherInfo>(accessedArg: RAccess<OtherInfo & ParentInformation>, leafIndices: ContainerIndices): ContainerIndices[];
+/**
+ * Adds the passed list of {@link leafSubIndices} to the leaf (sub-)indices of {@link indicesCollection}.
+ *
+ * @param indicesCollection - Indices where to add the sub indices.
+ * @param leafSubIndices - Indices that are added to the leaf indices.
+ */
+export declare function addSubIndicesToLeafIndices(indicesCollection: ContainerIndices[], leafSubIndices: ContainerIndices[]): ContainerIndices[];