@eagleoutice/flowr 2.2.11 → 2.2.12

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

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

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

@@ -10,9 +10,11 @@ export interface BuiltInApplyConfiguration extends MergeableRecord {
     readonly indexOfFunction?: number;
     /** does the argument have a name that it can be given by as well? */
     readonly nameOfFunctionArgument?: string;
-    /**
-     * Should we unquote the function if it is given as a string?
-     */
+    /** Should we unquote the function if it is given as a string? */
     readonly unquoteFunction?: boolean;
+    /** Should the function be resolved in the global environment? */
+    readonly resolveInEnvironment: 'global' | 'local';
+    /** Should the value of the function be resolved? */
+    readonly resolveValue?: boolean;
 }
-export declare function processApply<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, { indexOfFunction, nameOfFunctionArgument, unquoteFunction }: BuiltInApplyConfiguration): DataflowInformation;
+export declare function processApply<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, { indexOfFunction, nameOfFunctionArgument, unquoteFunction, resolveInEnvironment, resolveValue }: BuiltInApplyConfiguration): DataflowInformation;

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

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

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

@@ -17,8 +17,10 @@ const vertex_1 = require("../../../../../graph/vertex");
 const define_1 = require("../../../../../environments/define");
 const edge_1 = require("../../../../../graph/edge");
 const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
-const list_access_1 = require("../../../../../../util/list-access");
+const containers_1 = require("../../../../../../util/containers");
 const config_1 = require("../../../../../../config");
+const built_in_replacement_1 = require("./built-in-replacement");
+const named_call_handling_1 = require("../named-call-handling");
 function toReplacementSymbol(target, prefix, superAssignment) {
     return {
         type: type_1.RType.Symbol,
@@ -45,6 +47,26 @@ function findRootAccess(node) {
         return undefined;
     }
 }
+function tryReplacementPassingIndices(functionName, data, name, args, indices) {
+    const resolved = (0, resolve_by_name_1.resolveByName)(functionName.content, data.environment, identifier_1.ReferenceType.Function) ?? [];
+    // yield for unsupported pass along!
+    if (resolved.length !== 1 || resolved[0].type !== identifier_1.ReferenceType.BuiltInFunction) {
+        return (0, process_named_call_1.processAsNamedCall)(functionName, data, name, args);
+    }
+    const info = (0, built_in_replacement_1.processReplacementFunction)({
+        type: type_1.RType.Symbol,
+        info: functionName.info,
+        content: name,
+        lexeme: functionName.lexeme,
+        location: functionName.location,
+        namespace: undefined
+    }, (0, make_argument_1.wrapArgumentsUnnamed)(args, data.completeAst.idMap), functionName.info.id, data, {
+        ...(resolved[0].config ?? {}),
+        activeIndices: indices
+    });
+    (0, named_call_handling_1.markAsOnlyBuiltIn)(info.graph, functionName.info.id);
+    return info;
+}
 /**
  * Processes an assignment, i.e., `<target> <- <source>`.
  * Handling it as a function call \`&lt;-\` `(<target>, <source>)`.
@@ -75,14 +97,14 @@ args, rootId, data, config) {
     }
     else if (config.canBeReplacement && type === type_1.RType.FunctionCall && named) {
         /* as replacement functions take precedence over the lhs fn-call (i.e., `names(x) <- ...` is independent from the definition of `names`), we do not have to process the call */
-        logger_1.dataflowLogger.debug(`Assignment ${name.content} has a function call as target => replacement function ${target.lexeme}`);
+        logger_1.dataflowLogger.debug(`Assignment ${name.content} has a function call as target ==> replacement function ${target.lexeme}`);
         const replacement = toReplacementSymbol(target, target.functionName.content, config.superAssignment ?? false);
-        return (0, process_named_call_1.processAsNamedCall)(replacement, data, replacement.content, [...target.arguments, source]);
+        return tryReplacementPassingIndices(replacement, data, replacement.content, [...target.arguments, source], config.indicesCollection);
     }
     else if (config.canBeReplacement && type === type_1.RType.Access) {
-        logger_1.dataflowLogger.debug(`Assignment ${name.content} has an access as target => replacement function ${target.lexeme}`);
+        logger_1.dataflowLogger.debug(`Assignment ${name.content} has an access-type node as target ==> replacement function ${target.lexeme}`);
         const replacement = toReplacementSymbol(target, target.operator, config.superAssignment ?? false);
-        return (0, process_named_call_1.processAsNamedCall)(replacement, data, replacement.content, [(0, make_argument_1.toUnnamedArgument)(target.accessed, data.completeAst.idMap), ...target.access, source]);
+        return tryReplacementPassingIndices(replacement, data, replacement.content, [(0, make_argument_1.toUnnamedArgument)(target.accessed, data.completeAst.idMap), ...target.access, source], config.indicesCollection);
     }
     else if (type === type_1.RType.Access) {
         const rootArg = findRootAccess(target);
@@ -191,16 +213,24 @@ function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignme
     if ((0, config_1.getConfig)().solver.pointerTracking) {
         let indicesCollection = undefined;
         if (sourceIds.length === 1) {
-            // support for tracking indices
+            // support for tracking indices.
             // Indices were defined for the vertex e.g. a <- list(c = 1) or a$b <- list(c = 1)
             indicesCollection = information.graph.getVertex(sourceIds[0])?.indicesCollection;
+            // support assignment of container e.g. container1 <- container2
+            // defined indices are passed
+            if (!indicesCollection) {
+                const node = information.graph.idMap?.get(sourceIds[0]);
+                if (node && node.type === type_1.RType.Symbol) {
+                    indicesCollection = (0, containers_1.resolveIndicesByName)(node.lexeme, information.environment);
+                }
+            }
         }
         // Indices defined by replacement operation e.g. $<-
         if (config?.indicesCollection !== undefined) {
             // If there were indices stored in the vertex, then a container was defined
             // and assigned to the index of another container e.g. a$b <- list(c = 1)
             if (indicesCollection) {
-                indicesCollection = (0, list_access_1.addSubIndicesToLeafIndices)(config.indicesCollection, indicesCollection);
+                indicesCollection = (0, containers_1.addSubIndicesToLeafIndices)(config.indicesCollection, indicesCollection);
             }
             else {
                 // No indices were defined for the vertex e.g. a$b <- 2

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

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

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

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processEvalCall = processEvalCall;
+const info_1 = require("../../../../../info");
+const config_1 = require("../../../../../../config");
+const known_call_handling_1 = require("../known-call-handling");
+const retriever_1 = require("../../../../../../r-bridge/retriever");
+const decorate_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate");
+const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const logger_1 = require("../../../../../logger");
+const log_1 = require("../../../../../../util/log");
+const built_in_source_1 = require("./built-in-source");
+const edge_1 = require("../../../../../graph/edge");
+const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
+const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
+const append_1 = require("../../../../../environments/append");
+const assert_1 = require("../../../../../../util/assert");
+const arrays_1 = require("../../../../../../util/arrays");
+function processEvalCall(name, args, rootId, data, config) {
+    if (args.length !== 1 || args[0] === r_function_call_1.EmptyArgument || !args[0].value) {
+        logger_1.dataflowLogger.warn(`Expected exactly one argument for eval currently, but got ${args.length} instead, skipping`);
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    const information = config.includeFunctionCall ?
+        (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: [true] }).information
+        : (0, info_1.initializeCleanDataflowInformation)(rootId, data);
+    const evalArgument = args[0];
+    if (config.includeFunctionCall) {
+        information.graph.addEdge(rootId, args[0].value.info.id, edge_1.EdgeType.Returns);
+    }
+    if (!(0, config_1.getConfig)().solver.evalStrings) {
+        (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Skipping eval call ${JSON.stringify(evalArgument)} (disabled in config file)`);
+        information.graph.markIdForUnknownSideEffects(rootId);
+        return information;
+    }
+    const code = resolveEvalToCode(evalArgument.value, data.environment, data.completeAst.idMap);
+    if (code) {
+        const idGenerator = (0, decorate_1.sourcedDeterministicCountingIdGenerator)(name.lexeme + '::' + rootId, name.location);
+        data = {
+            ...data,
+            controlDependencies: [...(data.controlDependencies ?? []), { id: rootId, when: true }]
+        };
+        const originalInfo = { ...information };
+        const result = [];
+        for (const c of code) {
+            const codeRequest = (0, retriever_1.requestFromInput)(c);
+            const r = (0, built_in_source_1.sourceRequest)(rootId, codeRequest, data, originalInfo, idGenerator);
+            result.push(r);
+            // add a returns edge from the eval to the result
+            for (const e of r.exitPoints) {
+                information.graph.addEdge(rootId, e, edge_1.EdgeType.Returns);
+            }
+        }
+        return {
+            graph: result.reduce((acc, r) => acc.mergeWith(r.graph), information.graph),
+            environment: result.reduce((acc, r) => (0, append_1.appendEnvironment)(acc, r.environment), information.environment),
+            entryPoint: rootId,
+            out: [...information.out, ...result.flatMap(r => r.out)],
+            in: [...information.in, ...result.flatMap(r => r.in)],
+            unknownReferences: [...information.unknownReferences, ...result.flatMap(r => r.unknownReferences)],
+            exitPoints: [...information.exitPoints, ...result.flatMap(r => r.exitPoints)],
+        };
+    }
+    (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Non-constant argument ${JSON.stringify(args)} for eval is currently not supported, skipping`);
+    information.graph.markIdForUnknownSideEffects(rootId);
+    return information;
+}
+function resolveEvalToCode(evalArgument, env, idMap) {
+    const val = evalArgument;
+    if (val.type === type_1.RType.FunctionCall && val.named && val.functionName.content === 'parse') {
+        const arg = val.arguments.find(v => v !== r_function_call_1.EmptyArgument && v.name?.content === 'text');
+        const nArg = val.arguments.find(v => v !== r_function_call_1.EmptyArgument && v.name?.content === 'n');
+        if (nArg !== undefined || arg === undefined || arg === r_function_call_1.EmptyArgument) {
+            return undefined;
+        }
+        if (arg.value?.type === type_1.RType.String) {
+            return [arg.value.content.str];
+        }
+        else if (arg.value?.type === type_1.RType.Symbol) {
+            const resolve = (0, resolve_by_name_1.resolveValueOfVariable)(arg.value.content, env, idMap);
+            if (resolve && resolve.every(r => typeof r === 'object' && r !== null && 'str' in r)) {
+                return resolve.map(r => r.str);
+            }
+        }
+        else if (arg.value?.type === type_1.RType.FunctionCall && arg.value.named && ['paste', 'paste0'].includes(arg.value.functionName.content)) {
+            return handlePaste(arg.value.arguments, env, idMap, arg.value.functionName.content === 'paste' ? [' '] : ['']);
+        }
+        return undefined;
+    }
+    else if (val.type === type_1.RType.Symbol) {
+        // const resolved = resolveValueOfVariable(val.content, env);
+        // see https://github.com/flowr-analysis/flowr/pull/1467
+        return undefined;
+    }
+    else {
+        return undefined;
+    }
+}
+function getAsString(val, env, idMap) {
+    if (!val) {
+        return undefined;
+    }
+    if (val.type === type_1.RType.String) {
+        return [val.content.str];
+    }
+    else if (val.type === type_1.RType.Symbol) {
+        const resolved = (0, resolve_by_name_1.resolveValueOfVariable)(val.content, env, idMap);
+        if (resolved && resolved.every(r => typeof r === 'object' && r !== null && 'str' in r)) {
+            return resolved.map(r => r.str);
+        }
+    }
+    return undefined;
+}
+function handlePaste(args, env, idMap, sepDefault) {
+    const sepArg = args.find(v => v !== r_function_call_1.EmptyArgument && v.name?.content === 'sep');
+    if (sepArg) {
+        const res = sepArg !== r_function_call_1.EmptyArgument && sepArg.value ? getAsString(sepArg.value, env, idMap) : undefined;
+        if (!res) {
+            // sep not resolvable clearly / unknown
+            return undefined;
+        }
+        sepDefault = res;
+    }
+    const allArgs = args
+        .filter(v => v !== r_function_call_1.EmptyArgument && v.name?.content !== 'sep' && v.value)
+        .map(v => getAsString(v.value, env, idMap));
+    if (allArgs.some(assert_1.isUndefined)) {
+        return undefined;
+    }
+    // return all cartesian products using the separator
+    const result = [];
+    const cartesianProducts = (0, arrays_1.cartesianProduct)(...allArgs);
+    for (const sep of sepDefault) {
+        for (const c of cartesianProducts) {
+            result.push(c.join(sep));
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=built-in-eval.js.map

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

@@ -3,9 +3,9 @@ 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");
+const containers_1 = require("../../../../../../util/containers");
 /**
  * Process a list call.
  *
@@ -15,36 +15,70 @@ const config_1 = require("../../../../../../config");
  * ```
  */
 function processList(name, args, rootId, data) {
+    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data });
     if (!(0, config_1.getConfig)().solver.pointerTracking) {
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+        return fnCall.information;
     }
-    const namedArguments = [];
+    const listArgs = [];
     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) {
+        if (arg === r_function_call_1.EmptyArgument || arg.type !== type_1.RType.Argument || arg.value === 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) {
+        let newIndex;
+        if (arg.name) {
+            // Named argument
+            newIndex = {
+                identifier: {
+                    index: arg.info.index,
+                    lexeme: arg.name.content
+                },
+                nodeId: arg.info.id,
+            };
+        }
+        else {
+            // Unnamed argument
+            newIndex = {
+                identifier: {
+                    index: arg.info.index,
+                },
+                nodeId: arg.value.info.id,
+            };
+        }
+        // Check whether argument value can be resolved
+        if (arg.value.type === type_1.RType.Symbol) {
+            const indicesCollection = (0, containers_1.resolveIndicesByName)(arg.value.lexeme, data.environment);
+            if (indicesCollection) {
                 newIndex = {
                     ...newIndex,
-                    subIndices: indices,
+                    subIndices: indicesCollection,
                 };
             }
         }
-        namedArguments.push(newIndex);
+        else {
+            // Check whether argument is nested container
+            const indicesCollection = fnCall.information.graph.getVertex(arg.value.info.id)?.indicesCollection;
+            if (indicesCollection) {
+                newIndex = {
+                    ...newIndex,
+                    subIndices: indicesCollection,
+                };
+            }
+        }
+        listArgs.push(newIndex);
+    }
+    if ((0, config_1.isOverPointerAnalysisThreshold)(listArgs.length)) {
+        return fnCall.information;
     }
     const indices = {
-        indices: namedArguments,
+        indices: listArgs,
         isContainer: true,
     };
-    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }, [indices]).information;
+    // Add resolved indices to vertex
+    const vertex = fnCall.information.graph.getVertex(rootId);
+    if (vertex) {
+        vertex.indicesCollection = [indices];
+    }
+    return fnCall.information;
 }
 //# sourceMappingURL=built-in-list.js.map

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

@@ -5,9 +5,12 @@ 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 type { ContainerIndicesCollection } from '../../../../../graph/vertex';
 export declare function processReplacementFunction<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, 
 /** The last one has to be the value */
 args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     makeMaybe?: boolean;
     assignmentOperator?: '<-' | '<<-';
+    readIndices?: boolean;
+    activeIndices?: ContainerIndicesCollection;
 } & ForceArguments): DataflowInformation;