@eagleoutice/flowr 2.8.14 → 2.9.0

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

@@ -1,11 +1,7 @@
 "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 known_call_handling_1 = require("../known-call-handling");
-const config_1 = require("../../../../../../config");
-const containers_1 = require("../../../../../../util/containers");
 const built_in_1 = require("../../../../../environments/built-in");
 /**
  * Process a list call.
@@ -16,70 +12,6 @@ const built_in_1 = require("../../../../../environments/built-in");
  * ```
  */
 function processList(name, args, rootId, data) {
-    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: built_in_1.BuiltInProcName.List });
-    if (!data.ctx.config.solver.pointerTracking) {
-        return fnCall.information;
-    }
-    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.value === undefined) {
-            continue;
-        }
-        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: indicesCollection,
-                };
-            }
-        }
-        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)(data.ctx.config, listArgs.length)) {
-        return fnCall.information;
-    }
-    const indices = {
-        indices: listArgs,
-        isContainer: true,
-    };
-    // Add resolved indices to vertex
-    const vertex = fnCall.information.graph.getVertex(rootId);
-    if (vertex) {
-        vertex.indicesCollection = [indices];
-    }
-    return fnCall.information;
+    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: built_in_1.BuiltInProcName.List }).information;
 }
 //# sourceMappingURL=built-in-list.js.map

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

@@ -16,13 +16,13 @@ const built_in_1 = require("../../../../../environments/built-in");
 function processPipe(name, args, rootId, data) {
     const { information, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: built_in_1.BuiltInProcName.Pipe });
     if (args.length !== 2) {
-        logger_1.dataflowLogger.warn(`Pipe ${name.content} has something else than 2 arguments, skipping`);
+        logger_1.dataflowLogger.warn(`Pipe ${identifier_1.Identifier.toString(name.content)} has something else than 2 arguments, skipping`);
         return information;
     }
     const [lhs, rhs] = args.map(e => (0, unpack_argument_1.unpackNonameArg)(e));
     (0, assert_1.guard)(lhs !== undefined && rhs !== undefined, () => `lhs and rhs must be present, but ${JSON.stringify(lhs)} and ${JSON.stringify(rhs)} were found instead.`);
     if (rhs.type === type_1.RType.FunctionCall) {
-        const functionCallNode = information.graph.getVertex(rhs.info.id, true);
+        const functionCallNode = information.graph.getVertex(rhs.info.id);
         (0, assert_1.guard)(functionCallNode?.tag === vertex_1.VertexType.FunctionCall, () => `Expected function call node with id ${rhs.info.id} to be a function call node, but got ${functionCallNode?.tag} instead.`);
         // make the lhs an argument node:
         const argId = lhs.info.id;

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

@@ -23,7 +23,7 @@ function processQuote(name, args, rootId, data, config) {
         else if (processedArg) {
             information.graph.addEdge(rootId, processedArg.entryPoint, edge_1.EdgeType.NonStandardEvaluation);
             /* nse actually affects _everything_ within that argument! */
-            for (const [vtx,] of processedArg.graph.vertices(true)) {
+            for (const [vtx] of processedArg.graph.vertices(true)) {
                 information.graph.addEdge(rootId, vtx, edge_1.EdgeType.NonStandardEvaluation);
             }
         }

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

@@ -0,0 +1,11 @@
+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';
+/**
+ * Processes a built-in 'Recall' function call, linking
+ * the recall to the enveloping function closure.
+ */
+export declare function processRecall<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-recall.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processRecall = processRecall;
+const known_call_handling_1 = require("../known-call-handling");
+const built_in_1 = require("../../../../../environments/built-in");
+const log_1 = require("../../../../../../util/log");
+const edge_1 = require("../../../../../graph/edge");
+const vertex_1 = require("../../../../../graph/vertex");
+const unnamed_call_handling_1 = require("../unnamed-call-handling");
+const identifier_1 = require("../../../../../environments/identifier");
+/**
+ * Processes a built-in 'Recall' function call, linking
+ * the recall to the enveloping function closure.
+ */
+function processRecall(name, args, rootId, data) {
+    const { information } = (0, known_call_handling_1.processKnownFunctionCall)({
+        name,
+        args,
+        rootId,
+        data,
+        origin: built_in_1.BuiltInProcName.Recall
+    });
+    let cur = data.environment.current;
+    let closure;
+    while (cur) {
+        if (cur.closure) {
+            closure = cur.closure;
+            break;
+        }
+        cur = cur.parent;
+    }
+    if (closure) {
+        information.graph.addEdge(rootId, closure, edge_1.EdgeType.Calls);
+        // also kill the name of the recall function
+        const r = information.graph.getVertex(rootId);
+        if ((0, vertex_1.isFunctionCallVertex)(r)) {
+            r.name = unnamed_call_handling_1.UnnamedFunctionCallPrefix + rootId + '-' + identifier_1.Identifier.toString(r.name);
+            r.environment = information.environment;
+        }
+    }
+    else {
+        log_1.log.warn('No enclosing function closure found for recall at node', rootId);
+    }
+    return information;
+}
+//# sourceMappingURL=built-in-recall.js.map

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

@@ -9,6 +9,7 @@ const unpack_argument_1 = require("../argument/unpack-argument");
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const logger_1 = require("../../../../../logger");
 const built_in_1 = require("../../../../../environments/built-in");
+const identifier_1 = require("../../../../../environments/identifier");
 /**
  * Process a built-in repeat loop function call like `repeat { ... }`.
  * @param name     - The name of the function being called.
@@ -19,7 +20,7 @@ const built_in_1 = require("../../../../../environments/built-in");
  */
 function processRepeatLoop(name, args, rootId, data) {
     if (args.length !== 1 || args[0] === r_function_call_1.EmptyArgument) {
-        logger_1.dataflowLogger.warn(`Repeat-Loop ${name.content} does not have 1 argument, skipping`);
+        logger_1.dataflowLogger.warn(`Repeat-Loop ${identifier_1.Identifier.toString(name.content)} does not have 1 argument, skipping`);
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
     const unpacked = (0, unpack_argument_1.unpackNonameArg)(args[0]);
@@ -39,7 +40,7 @@ function processRepeatLoop(name, args, rootId, data) {
         origin: built_in_1.BuiltInProcName.RepeatLoop
     });
     const body = processedArguments[0];
-    (0, assert_1.guard)(body !== undefined, () => `Repeat-Loop ${name.content} has no body, impossible!`);
+    (0, assert_1.guard)(body !== undefined, () => `Repeat-Loop ${identifier_1.Identifier.toString(name.content)} has no body, impossible!`);
     (0, linker_1.linkCircularRedefinitionsWithinALoop)(information.graph, (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(information.graph, [])), body.out);
     (0, linker_1.reapplyLoopExitPoints)(body.exitPoints, body.in.concat(body.out, body.unknownReferences));
     information.exitPoints = (0, info_1.filterOutLoopExitPoints)(information.exitPoints);

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

@@ -5,7 +5,6 @@ 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';
 /**
  * Process a replacement function call like `<-`, `[[<-`, `$<-`, etc.
  * These are automatically created when doing assignments like `x[y] <- value` or in general `fun(x) <- value` will call `fun<- (x, value)`.
@@ -16,6 +15,5 @@ args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeI
     makeMaybe?: boolean;
     assignmentOperator?: '<-' | '<<-';
     readIndices?: boolean;
-    activeIndices?: ContainerIndicesCollection;
     assignRootId?: NodeId;
 } & ForceArguments): DataflowInformation;

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

@@ -10,8 +10,6 @@ const logger_1 = require("../../../../../logger");
 const vertex_1 = require("../../../../../graph/vertex");
 const graph_1 = require("../../../../../graph/graph");
 const edge_1 = require("../../../../../graph/edge");
-const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
-const containers_1 = require("../../../../../../util/containers");
 const unpack_argument_1 = require("../argument/unpack-argument");
 const built_in_access_1 = require("./built-in-access");
 const built_in_1 = require("../../../../../environments/built-in");
@@ -25,20 +23,15 @@ function processReplacementFunction(name,
 /** The last one has to be the value */
 args, rootId, data, config) {
     if (args.length < 2) {
-        logger_1.dataflowLogger.warn(`Replacement ${name.content} has less than 2 arguments, skipping`);
+        logger_1.dataflowLogger.warn(`Replacement ${identifier_1.Identifier.getName(name.content)} has less than 2 arguments, skipping`);
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
     /* 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 = config.activeIndices;
-    if (data.ctx.config.solver.pointerTracking) {
-        indices ??= constructAccessedIndices(name.content, args);
-    }
+    (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Replacement ${identifier_1.Identifier.getName(name.content)} with ${JSON.stringify(args)}, processing`);
     /* 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 */
     let res = built_in_1.BuiltInProcessorMapper[built_in_1.BuiltInProcName.Assignment](name, [args[0], args.at(-1)], rootId, data, {
         superAssignment: config.assignmentOperator === '<<-',
-        makeMaybe: indices === undefined ? config.makeMaybe : false,
-        indicesCollection: indices,
+        makeMaybe: config.makeMaybe,
         canBeReplacement: true
     });
     const createdVert = res.graph.getVertex(rootId);
@@ -86,73 +79,19 @@ args, rootId, data, config) {
         }
     }
     const fa = (0, unpack_argument_1.unpackNonameArg)(args[0]);
-    if (!data.ctx.config.solver.pointerTracking && fa) {
+    if (fa) {
         res = {
             ...res,
             in: [...res.in, { name: fa.lexeme, type: identifier_1.ReferenceType.Variable, nodeId: fa.info.id, cds: data.cds }]
         };
     }
-    return res;
-}
-/**
- * Constructs accessed indices of replacement function recursively.
- *
- * Example:
- * ```r
- * a$b <- 1
- * # results in index with lexeme b as identifier
- *
- * a[[1]]$b
- * # results in index with index 1 as identifier with a sub-index with lexeme b as identifier
- * ```
- * @param operation - Operation of replacement function e.g. '$\<-', '[\<-', '[[\<-'
- * @param args      - Arguments of the replacement function
- * @returns Accessed indices construct
- */
-function constructAccessedIndices(operation, args) {
-    const { accessedArg, accessArg } = (0, containers_1.getAccessOperands)(args);
-    if (accessedArg === undefined || accessArg?.value === undefined || !isSupportedOperation(operation, accessArg.value)) {
-        return undefined;
-    }
-    const constructIdentifier = getIdentifierBuilder(operation);
-    const leafIndex = {
-        identifier: constructIdentifier(accessArg),
-        nodeId: accessedArg.info.parent ?? ''
-    };
-    const accessIndices = {
-        indices: [leafIndex],
-        isContainer: false
-    };
-    // Check for nested access
-    let indicesCollection = undefined;
-    if (accessedArg.value?.type === type_1.RType.Access) {
-        indicesCollection = (0, containers_1.constructNestedAccess)(accessedArg.value, accessIndices, constructIdentifier);
-    }
-    else {
-        // use access node as reference to get complete line in slice
-        indicesCollection = [accessIndices];
+    // dispatches actually as S3:
+    const fns = res.in.filter(i => i.nodeId === rootId);
+    for (const fn of fns) {
+        fn.type = identifier_1.ReferenceType.S3MethodPrefix;
     }
-    return indicesCollection;
-}
-function isSupportedOperation(operation, value) {
-    const isNameBasedAccess = (operation === '$<-' || operation === '@<-') && value.type === type_1.RType.Symbol;
-    const isNumericalIndexBasedAccess = (operation === '[[<-' || operation === '[<-') && value.type === type_1.RType.Number;
-    return isNameBasedAccess || isNumericalIndexBasedAccess;
-}
-function getIdentifierBuilder(operation) {
-    if (operation === '$<-' || operation == '@<-') {
-        return (arg) => {
-            return {
-                index: undefined,
-                lexeme: arg.lexeme,
-            };
-        };
-    }
-    // [[<- and [<-
-    return (arg) => {
-        return {
-            index: Number(arg.lexeme),
-        };
-    };
+    // link the built-in replacement op
+    res.graph.addEdge(rootId, (0, built_in_1.builtInId)(identifier_1.Identifier.getName(name.content)), edge_1.EdgeType.Calls | edge_1.EdgeType.Reads);
+    return res;
 }
 //# sourceMappingURL=built-in-replacement.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-s-three-dispatch.js

@@ -65,8 +65,7 @@ function processS3Dispatch(name, args, rootId, data, config) {
         info: generic.info,
         content: accessedIdentifiers[0],
         lexeme: accessedIdentifiers[0],
-        location: generic.location ?? (0, range_1.invalidRange)(),
-        namespace: undefined
+        location: generic.location ?? (0, range_1.invalidRange)()
     };
     (0, common_1.patchFunctionCall)({
         nextGraph: dfGeneric.graph,

package/dataflow/internal/process/functions/call/built-in/built-in-special-bin-op.js

@@ -5,6 +5,7 @@ const known_call_handling_1 = require("../known-call-handling");
 const logger_1 = require("../../../../../logger");
 const edge_1 = require("../../../../../graph/edge");
 const built_in_1 = require("../../../../../environments/built-in");
+const identifier_1 = require("../../../../../environments/identifier");
 /**
  * Process a special built-in binary operator, possibly lazily.
  * For example, the logical AND `&&` and OR `||` operators only evaluate their right-hand side if necessary.
@@ -15,7 +16,7 @@ function processSpecialBinOp(name, args, rootId, data, config) {
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: built_in_1.BuiltInProcName.SpecialBinOp }).information;
     }
     else if (args.length != 2) {
-        logger_1.dataflowLogger.warn(`Logical bin-op ${name.content} has something else than 2 arguments, skipping`);
+        logger_1.dataflowLogger.warn(`Logical bin-op ${identifier_1.Identifier.toString(name.content)} has something else than 2 arguments, skipping`);
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: 'default' }).information;
     }
     const { information, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs,

package/dataflow/internal/process/functions/call/built-in/built-in-stop-if-not.js

@@ -10,6 +10,7 @@ const general_1 = require("../../../../../eval/values/general");
 const assert_1 = require("../../../../../../util/assert");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const built_in_1 = require("../../../../../environments/built-in");
+const identifier_1 = require("../../../../../environments/identifier");
 /**
  * Processes a built-in 'stopifnot' function call.
  * This is special in that it may take a number of boolean expressions either via `...` or
@@ -27,7 +28,7 @@ const built_in_1 = require("../../../../../environments/built-in");
 function processStopIfNot(name, args, rootId, data) {
     const res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: built_in_1.BuiltInProcName.StopIfNot }).information;
     if (args.length === 0) {
-        logger_1.dataflowLogger.warn(`stopifnot (${name.content}) has no argument, assuming trivially true and skipping`);
+        logger_1.dataflowLogger.warn(`stopifnot (${identifier_1.Identifier.toString(name.content)}) has no argument, assuming trivially true and skipping`);
         return res;
     }
     // R only allows ... or exprs or exprObject, not all, but we over-approximate and collect all, given that they are after '...'
@@ -51,7 +52,7 @@ function processStopIfNot(name, args, rootId, data) {
         const localVal = (0, alias_tracking_1.resolveIdToValue)(localArg?.value?.info.id, resolveArgs);
         const alwaysTrue = (0, general_1.valueSetGuard)(localVal)?.elements.every(d => d.type === 'logical' && d.value === true) ?? false;
         if (!alwaysTrue) {
-            logger_1.dataflowLogger.warn(`stopifnot (${name.content}) with non-true 'local' argument is not yet supported, over-approximate`);
+            logger_1.dataflowLogger.warn(`stopifnot (${identifier_1.Identifier.toString(name.content)}) with non-true 'local' argument is not yet supported, over-approximate`);
             const cds = (data.cds ?? []).concat(Array.from(ids).map(r => ({
                 id: r,
                 when: false
@@ -89,7 +90,7 @@ function processStopIfNot(name, args, rootId, data) {
         }
     }
     if (cds.length === 0) {
-        logger_1.dataflowLogger.warn(`stopifnot (${name.content}) has no unknown expressions to evaluate, assuming trivially true and skipping`);
+        logger_1.dataflowLogger.warn(`stopifnot (${identifier_1.Identifier.toString(name.content)}) has no unknown expressions to evaluate, assuming trivially true and skipping`);
         return res;
     }
     res.exitPoints.push({

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

@@ -14,6 +14,7 @@ const edge_1 = require("../../../../../graph/edge");
 const built_in_1 = require("../../../../../environments/built-in");
 const unnamed_call_handling_1 = require("../unnamed-call-handling");
 const identifier_1 = require("../../../../../environments/identifier");
+const identifier_2 = require("../../../../../environments/identifier");
 const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
 const log_1 = require("../../../../../../util/log");
 function getArgsOfName(argMaps, name) {
@@ -25,7 +26,7 @@ function getArgsOfName(argMaps, name) {
 function processTryCatch(name, args, rootId, data, config) {
     const res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args: args.map(unpack_argument_1.tryUnpackNoNameArg), rootId, data, origin: built_in_1.BuiltInProcName.Try, forceArgs: 'all' });
     if (args.length < 1 || args[0] === r_function_call_1.EmptyArgument) {
-        logger_1.dataflowLogger.warn(`TryCatch Handler ${name.content} does not have 1 argument, skipping`);
+        logger_1.dataflowLogger.warn(`TryCatch Handler ${identifier_1.Identifier.toString(name.content)} does not have 1 argument, skipping`);
         return res.information;
     }
     // artificial ids :)
@@ -135,7 +136,7 @@ function promoteCallToFunction(call, arg, info, data) {
                     const rid = ref.nodeId;
                     info.graph.addEdge(ingoing.nodeId, rid, edge_1.EdgeType.Reads);
                     info.graph.addEdge(call, rid, edge_1.EdgeType.Reads); // because the def. is the anonymous call
-                    if (!(0, identifier_1.isReferenceType)(ref.type, identifier_1.ReferenceType.BuiltInConstant | identifier_1.ReferenceType.BuiltInFunction)) {
+                    if (!(0, identifier_2.isReferenceType)(ref.type, identifier_2.ReferenceType.BuiltInConstant | identifier_2.ReferenceType.BuiltInFunction)) {
                         allBuiltIn = false;
                     }
                 }

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

@@ -1,11 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processVector = processVector;
-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 known_call_handling_1 = require("../known-call-handling");
-const config_1 = require("../../../../../../config");
-const containers_1 = require("../../../../../../util/containers");
 const built_in_1 = require("../../../../../environments/built-in");
 /**
  * Process a vector call.
@@ -16,61 +12,6 @@ const built_in_1 = require("../../../../../environments/built-in");
  * ```
  */
 function processVector(name, args, rootId, data) {
-    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: built_in_1.BuiltInProcName.Vector });
-    if (!data.ctx.config.solver.pointerTracking) {
-        return fnCall.information;
-    }
-    let vectorArgs = [];
-    let argIndex = 1;
-    for (const arg of args) {
-        // Skip invalid argument types
-        if (arg === r_function_call_1.EmptyArgument || arg.type !== type_1.RType.Argument || arg.value === undefined) {
-            continue;
-        }
-        if (isPrimitive(arg.value.type)) {
-            vectorArgs.push({
-                identifier: { index: argIndex++ },
-                nodeId: arg.value.info.id,
-            });
-        }
-        else {
-            // Check whether argument value can be resolved
-            let indicesCollection;
-            if (arg.value.type === type_1.RType.Symbol) {
-                indicesCollection = (0, containers_1.resolveIndicesByName)(arg.value.lexeme, data.environment);
-            }
-            else {
-                // Check whether argument is nested container
-                indicesCollection = fnCall.information.graph.getVertex(arg.value.info.id)?.indicesCollection;
-            }
-            const flattenedIndices = indicesCollection?.flatMap(indices => indices.indices)
-                .map(index => {
-                return {
-                    identifier: { index: argIndex++ },
-                    nodeId: index.nodeId,
-                };
-            }) ?? [];
-            vectorArgs = vectorArgs.concat(flattenedIndices);
-        }
-    }
-    if ((0, config_1.isOverPointerAnalysisThreshold)(data.ctx.config, vectorArgs.length)) {
-        return fnCall.information;
-    }
-    const indices = {
-        indices: vectorArgs,
-        isContainer: true,
-    };
-    // Add resolved indices to vertex
-    const vertex = fnCall.information.graph.getVertex(rootId);
-    if (vertex) {
-        vertex.indicesCollection = [indices];
-    }
-    return fnCall.information;
-}
-/**
- * Checks whether the passed type is primitive i.e. number, logical or string.
- */
-function isPrimitive(type) {
-    return type === type_1.RType.Number || type === type_1.RType.Logical || type === type_1.RType.String;
+    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: built_in_1.BuiltInProcName.Vector }).information;
 }
 //# sourceMappingURL=built-in-vector.js.map

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

@@ -19,12 +19,12 @@ const built_in_1 = require("../../../../../environments/built-in");
  */
 function processWhileLoop(name, args, rootId, data) {
     if (args.length !== 2 || args[1] === r_function_call_1.EmptyArgument) {
-        logger_1.dataflowLogger.warn(`While-Loop ${name.content} does not have 2 arguments, skipping`);
+        logger_1.dataflowLogger.warn(`While-Loop ${identifier_1.Identifier.toString(name.content)} does not have 2 arguments, skipping`);
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
     const unpackedArgs = args.map(e => (0, unpack_argument_1.unpackNonameArg)(e));
     if (unpackedArgs.some(assert_1.isUndefined)) {
-        logger_1.dataflowLogger.warn(`While-Loop ${name.content} has empty arguments in ${JSON.stringify(args)}, skipping`);
+        logger_1.dataflowLogger.warn(`While-Loop ${identifier_1.Identifier.toString(name.content)} has empty arguments in ${JSON.stringify(args)}, skipping`);
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
     // we should defer this to the abstract interpretation
@@ -63,7 +63,7 @@ function processWhileLoop(name, args, rootId, data) {
             hooks: condition.hooks
         };
     }
-    (0, assert_1.guard)(condition !== undefined && body !== undefined, () => `While-Loop ${name.content} has no condition or body, impossible!`);
+    (0, assert_1.guard)(condition !== undefined && body !== undefined, () => `While-Loop ${identifier_1.Identifier.toString(name.content)} has no condition or body, impossible!`);
     const originalDependency = data.cds;
     if ((0, info_1.alwaysExits)(condition)) {
         logger_1.dataflowLogger.warn(`While-Loop ${rootId} forces exit in condition, skipping rest`);

package/dataflow/internal/process/functions/call/common.d.ts

@@ -55,6 +55,8 @@ export interface PatchFunctionCallInput<OtherInfo> {
     readonly link?: DataflowGraphVertexAstLink;
 }
 /**
- *
+ * Patches a function call vertex into the given dataflow graph.
+ * This is mostly useful for built-in processors that have custom argument processing.
+ * Otherwise, rely on {@link processKnownFunctionCall} instead.
  */
 export declare function patchFunctionCall<OtherInfo>({ nextGraph, rootId, name, data, argumentProcessResult, origin, link }: PatchFunctionCallInput<OtherInfo>): void;

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

@@ -114,12 +114,7 @@ function processAllArguments({ functionName, args, data, finalGraph, functionRoo
                     if ((0, info_1.happensInEveryBranch)(resolved.cds) && !(0, identifier_1.isReferenceType)(resolved.type, identifier_1.ReferenceType.BuiltInFunction | identifier_1.ReferenceType.BuiltInConstant)) {
                         assumeItMayHaveAHigherTarget = false;
                     }
-                    // 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 !== false) {
-                        finalGraph.addEdge(ingoing.nodeId, resolved.nodeId, edge_1.EdgeType.Reads);
-                    }
+                    finalGraph.addEdge(ingoing.nodeId, resolved.nodeId, edge_1.EdgeType.Reads);
                 }
                 if (assumeItMayHaveAHigherTarget) {
                     remainingReadInArgs.push(ingoing);
@@ -138,7 +133,9 @@ function processAllArguments({ functionName, args, data, finalGraph, functionRoo
     return { finalEnv, callArgs, remainingReadInArgs, processedArguments };
 }
 /**
- *
+ * Patches a function call vertex into the given dataflow graph.
+ * This is mostly useful for built-in processors that have custom argument processing.
+ * Otherwise, rely on {@link processKnownFunctionCall} instead.
  */
 function patchFunctionCall({ nextGraph, rootId, name, data, argumentProcessResult, origin, link }) {
     nextGraph.addVertex({
@@ -159,13 +156,4 @@ 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

@@ -9,11 +9,15 @@ import type { RNode } from '../../../../../r-bridge/lang-4.x/ast/model/model';
 import { type IdentifierReference } from '../../../../environments/identifier';
 import type { FunctionArgument } from '../../../../graph/graph';
 import { DataflowGraph } from '../../../../graph/graph';
-import { type ContainerIndicesCollection, type FunctionOriginInformation } from '../../../../graph/vertex';
+import { type FunctionOriginInformation } from '../../../../graph/vertex';
 export interface ProcessKnownFunctionCallInput<OtherInfo> extends ForceArguments {
+    /** The name of the function being called. */
     readonly name: RSymbol<OtherInfo & ParentInformation>;
+    /** The arguments to the function call. */
     readonly args: readonly (RNode<OtherInfo & ParentInformation> | RFunctionArgument<OtherInfo & ParentInformation>)[];
+    /** The node ID to use for the function call vertex. */
     readonly rootId: NodeId;
+    /** The dataflow processor information at the point of the function call. */
     readonly data: DataflowProcessorInformation<OtherInfo & ParentInformation>;
     /** should arguments be processed from right to left? This does not affect the order recorded in the call but of the environments */
     readonly reverseOrder?: boolean;
@@ -49,4 +53,4 @@ export declare function markNonStandardEvaluationEdges(markAsNSE: readonly numbe
  * The main processor for function calls for which we know the target but need not
  * add any specific handling.
  */
-export declare function processKnownFunctionCall<OtherInfo>({ name, args, rootId, data, reverseOrder, markAsNSE, forceArgs, patchData, hasUnknownSideEffect, origin }: ProcessKnownFunctionCallInput<OtherInfo>, indicesCollection?: ContainerIndicesCollection): ProcessKnownFunctionCallResult;
+export declare function processKnownFunctionCall<OtherInfo>({ name, args, rootId, data, reverseOrder, markAsNSE, forceArgs, patchData, hasUnknownSideEffect, origin }: ProcessKnownFunctionCallInput<OtherInfo>): ProcessKnownFunctionCallResult;

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

@@ -32,11 +32,11 @@ function markNonStandardEvaluationEdges(markAsNSE, callArgs, finalGraph, rootId)
  * The main processor for function calls for which we know the target but need not
  * add any specific handling.
  */
-function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = false, markAsNSE = undefined, forceArgs, patchData = d => d, hasUnknownSideEffect, origin }, indicesCollection = undefined) {
+function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = false, markAsNSE = undefined, forceArgs, patchData = d => d, hasUnknownSideEffect, origin }) {
     const functionName = (0, processor_1.processDataflowFor)(name, data);
     const finalGraph = new graph_1.DataflowGraph(data.completeAst.idMap);
     const functionCallName = name.content;
-    (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Processing known function call ${functionCallName} with ${args.length} arguments`);
+    (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Processing known function call ${identifier_1.Identifier.toString(functionCallName)} with ${args.length} arguments`);
     const processArgs = reverseOrder ? args.toReversed() : args;
     const { finalEnv, callArgs, remainingReadInArgs, processedArguments } = (0, common_1.processAllArguments)({ functionName, args: processArgs, data, finalGraph, functionRootId: rootId, patchData, forceArgs });
     if (markAsNSE) {
@@ -51,7 +51,6 @@ function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = fal
         onlyBuiltin: false,
         cds: data.cds,
         args: reverseOrder ? callArgs.toReversed() : callArgs,
-        indicesCollection: indicesCollection,
         origin: origin === 'default' ? [built_in_1.BuiltInProcName.Function] : [origin]
     }, data.ctx.env.makeCleanEnv());
     if (hasUnknownSideEffect) {

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

@@ -2,7 +2,7 @@ import { type DataflowProcessorInformation } from '../../../../processor';
 import type { DataflowInformation } from '../../../../info';
 import type { RUnnamedFunctionCall } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { ParentInformation } from '../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-export declare const UnnamedFunctionCallPrefix = "unnamed-function-call-";
+export declare const UnnamedFunctionCallPrefix = "unnamed-fc-";
 /**
  * Processes an unnamed function call.
  */

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

@@ -12,7 +12,7 @@ const type_1 = require("../../../../../r-bridge/lang-4.x/ast/model/type");
 const logger_1 = require("../../../../logger");
 const identifier_1 = require("../../../../environments/identifier");
 const built_in_1 = require("../../../../environments/built-in");
-exports.UnnamedFunctionCallPrefix = 'unnamed-function-call-';
+exports.UnnamedFunctionCallPrefix = 'unnamed-fc-';
 /**
  * Processes an unnamed function call.
  */