@eagleoutice/flowr 2.2.11 → 2.2.13

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/collections/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, origin: 'default' }).information;
+    }
+    const information = config.includeFunctionCall ?
+        (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: [true], origin: 'builtin:eval' }).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?.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?.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-expression-list.js

@@ -42,6 +42,9 @@ function linkReadNameToWriteIfPossible(read, environments, listEnvironments, rem
     for (const target of probableTarget) {
         // we can stick with maybe even if readId.attribute is always
         nextGraph.addEdge(read, target, edge_1.EdgeType.Reads);
+        if ((read.type === identifier_1.ReferenceType.Function || read.type === identifier_1.ReferenceType.BuiltInFunction) && ((0, built_in_1.isBuiltIn)(target.definedAt))) {
+            nextGraph.addEdge(read, target, edge_1.EdgeType.Calls);
+        }
     }
 }
 function processNextExpression(currentElement, environment, listEnvironments, remainingRead, nextGraph) {
@@ -66,7 +69,7 @@ function updateSideEffectsForCalledFunctions(calledEnvs, inputEnvironment, nextG
             while (current !== undefined && current.id !== environment_1.BuiltInEnvironment.id) {
                 for (const definitions of current.memory.values()) {
                     for (const def of definitions) {
-                        if (def.definedAt !== built_in_1.BuiltIn) {
+                        if (!(0, built_in_1.isBuiltIn)(def.definedAt)) {
                             hasUpdate = true;
                             nextGraph.addEdge(def.nodeId, functionCall, edge_1.EdgeType.SideEffectOnCall);
                         }
@@ -90,7 +93,7 @@ function processExpressionList(name, args, rootId, data) {
     const listEnvironments = new Set();
     const remainingRead = new Map();
     const nextGraph = new graph_1.DataflowGraph(data.completeAst.idMap);
-    const out = [];
+    let out = [];
     const exitPoints = [];
     let expressionCounter = 0;
     const processedExpressions = [];
@@ -115,7 +118,7 @@ function processExpressionList(name, args, rootId, data) {
             processed.unknownReferences = (0, environment_1.makeAllMaybe)(processed.unknownReferences, nextGraph, processed.environment, false);
         }
         (0, info_1.addNonDefaultExitPoints)(exitPoints, processed.exitPoints);
-        out.push(...processed.out);
+        out = out.concat(processed.out);
         (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `expression ${expressionCounter} of ${expressions.length} has ${processed.unknownReferences.length} unknown nodes`);
         processNextExpression(processed, environment, listEnvironments, remainingRead, nextGraph);
         environment = exitPoints.length > 0 ? (0, overwrite_1.overwriteEnvironment)(environment, processed.environment) : processed.environment;
@@ -150,8 +153,10 @@ function processExpressionList(name, args, rootId, data) {
             rootId,
             name,
             data,
-            argumentProcessResult: processedExpressions
+            argumentProcessResult: processedExpressions,
+            origin: 'builtin:expression-list'
         });
+        nextGraph.addEdge(rootId, (0, built_in_1.builtInId)('{'), edge_1.EdgeType.Reads | edge_1.EdgeType.Calls);
         // process all exit points as potential returns:
         for (const exit of exitPoints) {
             if (exit.type === 1 /* ExitPointType.Return */ || exit.type === 0 /* ExitPointType.Default */) {

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

@@ -18,7 +18,7 @@ const identifier_1 = require("../../../../../environments/identifier");
 function processForLoop(name, args, rootId, data) {
     if (args.length !== 3) {
         logger_1.dataflowLogger.warn(`For-Loop ${name.content} does not have three arguments, skipping`);
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
     const [variableArg, vectorArg, bodyArg] = args.map(e => (0, unpack_argument_1.unpackArgument)(e));
     (0, assert_1.guard)(variableArg !== undefined && vectorArg !== undefined && bodyArg !== undefined, () => `For-Loop ${JSON.stringify(args)} has missing arguments! Bad!`);
@@ -55,7 +55,8 @@ function processForLoop(name, args, rootId, data) {
         rootId,
         name,
         data: { ...data, controlDependencies: originalDependency },
-        argumentProcessResult: [variable, vector, body]
+        argumentProcessResult: [variable, vector, body],
+        origin: 'builtin:for-loop'
     });
     /* mark the last argument as nse */
     nextGraph.addEdge(rootId, body.entryPoint, edge_1.EdgeType.NonStandardEvaluation);

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

@@ -12,6 +12,7 @@ const assert_1 = require("../../../../../../util/assert");
 const logger_1 = require("../../../../../logger");
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const graph_1 = require("../../../../../graph/graph");
+const identifier_1 = require("../../../../../environments/identifier");
 const overwrite_1 = require("../../../../../environments/overwrite");
 const vertex_1 = require("../../../../../graph/vertex");
 const scoping_1 = require("../../../../../environments/scoping");
@@ -19,10 +20,11 @@ const environment_1 = require("../../../../../environments/environment");
 const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
 const edge_1 = require("../../../../../graph/edge");
 const log_1 = require("../../../../../../util/log");
+const built_in_1 = require("../../../../../environments/built-in");
 function processFunctionDefinition(name, args, rootId, data) {
     if (args.length < 1) {
         logger_1.dataflowLogger.warn(`Function Definition ${name.content} does not have an argument, skipping`);
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
     /* we remove the last argument, as it is the body */
     const parameters = args.slice(0, -1);
@@ -140,8 +142,15 @@ function updateNestedFunctionClosures(graph, outEnvironment, fnId) {
                 continue;
             }
             (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Found ${resolved.length} references to open ref ${id} in closure of function definition ${fnId}`);
+            let allBuiltIn = true;
             for (const ref of resolved) {
                 graph.addEdge(ingoing, ref, edge_1.EdgeType.Reads);
+                if (!(0, identifier_1.isReferenceType)(ref.type, identifier_1.ReferenceType.BuiltInConstant | identifier_1.ReferenceType.BuiltInFunction)) {
+                    allBuiltIn = false;
+                }
+            }
+            if (allBuiltIn) {
+                remainingIn.push(ingoing);
             }
         }
         (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Keeping ${remainingIn.length} references to open ref ${id} in closure of function definition ${fnId}`);
@@ -191,8 +200,10 @@ function updateNestedFunctionCalls(graph, outEnvironment) {
                 }
                 (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Found ${resolved.length} references to open ref ${id} in closure of function definition ${id}`);
                 for (const def of resolved) {
-                    graph.addEdge(ingoing, def, edge_1.EdgeType.DefinedByOnCall);
-                    graph.addEdge(id, def, edge_1.EdgeType.DefinesOnCall);
+                    if (!(0, built_in_1.isBuiltIn)(def.nodeId)) {
+                        graph.addEdge(ingoing, def, edge_1.EdgeType.DefinedByOnCall);
+                        graph.addEdge(id, def, edge_1.EdgeType.DefinesOnCall);
+                    }
                 }
             }
             (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Keeping ${remainingIn.length} references to open ref ${id} in closure of function definition ${id}`);
@@ -209,7 +220,7 @@ function prepareFunctionEnvironment(data) {
 }
 /**
  * Within something like `f <- function(a=b, m=3) { b <- 1; a; b <- 5; a + 1 }`
- * `a` will be defined by `b` and `b`will be a promise object bound by the first definition of b it can find.
+ * `a` will be defined by `b` and `b` will be a promise object bound by the first definition of b it can find.
  * This means that this function returns `2` due to the first `b <- 1` definition.
  * If the code is `f <- function(a=b, m=3) { if(m > 3) { b <- 1; }; a; b <- 5; a + 1 }`, we need a link to `b <- 1` and `b <- 6`
  * as `b` can be defined by either one of them.

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

@@ -11,12 +11,12 @@ const edge_1 = require("../../../../../graph/edge");
 function processGet(name, args, rootId, data) {
     if (args.length !== 1) {
         logger_1.dataflowLogger.warn(`symbol access with ${name.content} has not 1 argument, skipping`);
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
     const retrieve = (0, unpack_argument_1.unpackArgument)(args[0]);
     if (retrieve === undefined || retrieve.type !== type_1.RType.String) {
         logger_1.dataflowLogger.warn(`symbol access with ${name.content} has not 1 argument, skipping`);
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
     const treatTargetAsSymbol = {
         type: type_1.RType.Symbol,
@@ -30,7 +30,8 @@ function processGet(name, args, rootId, data) {
         name,
         args: (0, make_argument_1.wrapArgumentsUnnamed)([treatTargetAsSymbol], data.completeAst.idMap),
         rootId,
-        data
+        data,
+        origin: 'builtin:get'
     });
     const firstArg = processedArguments[0];
     if (firstArg) {

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

@@ -15,12 +15,12 @@ const environment_1 = require("../../../../../environments/environment");
 function processIfThenElse(name, args, rootId, data) {
     if (args.length !== 2 && args.length !== 3) {
         logger_1.dataflowLogger.warn(`If-then-else ${name.content} has something different from 2 or 3 arguments, skipping`);
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
     const [condArg, thenArg, otherwiseArg] = args.map(e => (0, unpack_argument_1.unpackArgument)(e));
     if (condArg === undefined || thenArg === undefined) {
         logger_1.dataflowLogger.warn(`If-then-else ${name.content} has empty condition or then case in ${JSON.stringify(args)}, skipping`);
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
     const cond = (0, processor_1.processDataflowFor)(condArg, data);
     if ((0, info_1.alwaysExits)(cond)) {
@@ -92,7 +92,8 @@ function processIfThenElse(name, args, rootId, data) {
         rootId,
         name,
         data: { ...data, controlDependencies: originalDependency },
-        argumentProcessResult: [cond, then, otherwise]
+        argumentProcessResult: [cond, then, otherwise],
+        origin: 'builtin:if-then-else'
     });
     // as an if always evaluates its condition, we add a 'reads'-edge
     nextGraph.addEdge(name.info.id, cond.entryPoint, edge_1.EdgeType.Reads);

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

@@ -10,12 +10,12 @@ function processLibrary(name, args, rootId, data) {
     /* we do not really know what loading the library does and what side effects it causes, hence we mark it as an unknown side effect */
     if (args.length !== 1) {
         logger_1.dataflowLogger.warn(`Currently only one-arg library-likes are allows (for ${name.content}), skipping`);
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, hasUnknownSideEffect: true }).information;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, hasUnknownSideEffect: true, origin: 'default' }).information;
     }
     const nameToLoad = (0, unpack_argument_1.unpackArgument)(args[0]);
     if (nameToLoad === undefined || nameToLoad.type !== type_1.RType.Symbol) {
         logger_1.dataflowLogger.warn('No library name provided, skipping');
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, hasUnknownSideEffect: true }).information;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, hasUnknownSideEffect: true, origin: 'default' }).information;
     }
     // treat as a function call but convert the first argument to a string
     const newArg = {
@@ -30,7 +30,8 @@ function processLibrary(name, args, rootId, data) {
     };
     return (0, known_call_handling_1.processKnownFunctionCall)({
         name, args: (0, make_argument_1.wrapArgumentsUnnamed)([newArg], data.completeAst.idMap), rootId, data,
-        hasUnknownSideEffect: true
+        hasUnknownSideEffect: true,
+        origin: 'builtin:library'
     }).information;
 }
 //# sourceMappingURL=built-in-library.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, origin: 'builtin:list' });
     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-pipe.js

@@ -10,7 +10,7 @@ const vertex_1 = require("../../../../../graph/vertex");
 const edge_1 = require("../../../../../graph/edge");
 const identifier_1 = require("../../../../../environments/identifier");
 function processPipe(name, args, rootId, data) {
-    const { information, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data });
+    const { information, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'builtin:pipe' });
     if (args.length !== 2) {
         logger_1.dataflowLogger.warn(`Pipe ${name.content} has something else than 2 arguments, skipping`);
         return information;

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

@@ -4,16 +4,17 @@ exports.processQuote = processQuote;
 const known_call_handling_1 = require("../known-call-handling");
 const edge_1 = require("../../../../../graph/edge");
 function processQuote(name, args, rootId, data, config) {
-    const { information, processedArguments, fnRef } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs });
-    const inRefs = [fnRef];
-    const outRefs = [];
-    const unknownRefs = [];
+    const startEnv = data.environment;
+    const { information, processedArguments, fnRef } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: 'builtin:quote' });
+    let inRefs = [fnRef];
+    let outRefs = [];
+    let unknownRefs = [];
     for (let i = 0; i < args.length; i++) {
         const processedArg = processedArguments[i];
         if (processedArg && i !== config?.quoteArgumentsWithIndex) {
-            inRefs.push(...processedArg.in);
-            outRefs.push(...processedArg.out);
-            unknownRefs.push(...processedArg.unknownReferences);
+            inRefs = inRefs.concat(processedArg.in);
+            outRefs = outRefs.concat(processedArg.out);
+            unknownRefs = unknownRefs.concat(processedArg.unknownReferences);
         }
         else if (processedArg) {
             information.graph.addEdge(rootId, processedArg.entryPoint, edge_1.EdgeType.NonStandardEvaluation);
@@ -25,6 +26,7 @@ function processQuote(name, args, rootId, data, config) {
     }
     return {
         ...information,
+        environment: startEnv,
         in: inRefs,
         out: outRefs,
         unknownReferences: unknownRefs

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

@@ -11,7 +11,7 @@ const logger_1 = require("../../../../../logger");
 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`);
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
     const unpacked = (0, unpack_argument_1.unpackArgument)(args[0]);
     const { information, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({
@@ -25,7 +25,8 @@ function processRepeatLoop(name, args, rootId, data) {
             }
             return d;
         },
-        markAsNSE: [0]
+        markAsNSE: [0],
+        origin: 'builtin:repeat-loop'
     });
     const body = processedArguments[0];
     (0, assert_1.guard)(body !== undefined, () => `Repeat-Loop ${name.content} has no body, impossible!`);

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

@@ -5,9 +5,13 @@ 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;
+    assignRootId?: NodeId;
 } & ForceArguments): DataflowInformation;