@eagleoutice/flowr 2.2.12 → 2.2.13

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

@@ -15,7 +15,7 @@ const containers_1 = require("../../../../../../util/containers");
  * ```
  */
 function processList(name, args, rootId, data) {
-    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ 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 fnCall.information;
     }

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

@@ -13,4 +13,5 @@ args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeI
     assignmentOperator?: '<-' | '<<-';
     readIndices?: boolean;
     activeIndices?: ContainerIndicesCollection;
+    assignRootId?: NodeId;
 } & ForceArguments): DataflowInformation;

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

@@ -4,10 +4,10 @@ exports.processReplacementFunction = processReplacementFunction;
 const info_1 = require("../../../../../info");
 const known_call_handling_1 = require("../known-call-handling");
 const log_1 = require("../../../../../../util/log");
-const built_in_assignment_1 = require("./built-in-assignment");
 const common_1 = require("../common");
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const logger_1 = require("../../../../../logger");
+const vertex_1 = require("../../../../../graph/vertex");
 const graph_1 = require("../../../../../graph/graph");
 const edge_1 = require("../../../../../graph/edge");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
@@ -15,12 +15,14 @@ const containers_1 = require("../../../../../../util/containers");
 const config_1 = require("../../../../../../config");
 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");
+const identifier_1 = require("../../../../../environments/identifier");
 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`);
-        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 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`);
@@ -29,12 +31,16 @@ args, rootId, data, config) {
         indices ??= constructAccessedIndices(name.content, args);
     }
     /* we assign the first argument by the last for now and maybe mark as maybe!, we can keep the symbol as we now know we have an assignment */
-    const res = (0, built_in_assignment_1.processAssignment)(name, [args[0], args[args.length - 1]], rootId, data, {
+    let res = built_in_1.BuiltInProcessorMapper['builtin:assignment'](name, [args[0], args[args.length - 1]], rootId, data, {
         superAssignment: config.assignmentOperator === '<<-',
         makeMaybe: indices !== undefined ? false : config.makeMaybe,
         indicesCollection: indices,
         canBeReplacement: true
     });
+    const createdVert = res.graph.getVertex(rootId);
+    if (createdVert?.tag === vertex_1.VertexType.FunctionCall) {
+        createdVert.origin = ['builtin:replacement'];
+    }
     const convertedArgs = config.readIndices ? args.slice(1, -1) : (0, built_in_access_1.symbolArgumentsToStrings)(args.slice(1, -1), 0);
     /* now, we soft-inject other arguments, so that calls like `x[y] <- 3` are linked correctly */
     const { callArgs } = (0, common_1.processAllArguments)({
@@ -50,7 +56,9 @@ args, rootId, data, config) {
         data,
         rootId,
         name,
-        argumentProcessResult: args.map(a => a === r_function_call_1.EmptyArgument ? undefined : { entryPoint: (0, unpack_argument_1.unpackArgument)(a)?.info.id })
+        argumentProcessResult: args.map(a => a === r_function_call_1.EmptyArgument ? undefined : { entryPoint: (0, unpack_argument_1.unpackArgument)(a)?.info.id }),
+        origin: 'builtin:replacement',
+        link: config.assignRootId ? { origin: [config.assignRootId] } : undefined
     });
     const firstArg = (0, unpack_argument_1.unpackArgument)(args[0])?.info.id;
     if (firstArg) {
@@ -63,6 +71,13 @@ args, rootId, data, config) {
             res.graph.addEdge(rootId, ref, edge_1.EdgeType.Reads);
         }
     }
+    const fa = (0, unpack_argument_1.unpackArgument)(args[0]);
+    if (!(0, config_1.getConfig)().solver.pointerTracking && fa) {
+        res = {
+            ...res,
+            in: [...res.in, { name: fa.lexeme, type: identifier_1.ReferenceType.Variable, nodeId: fa.info.id, controlDependencies: data.controlDependencies }]
+        };
+    }
     return res;
 }
 /**

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

@@ -9,9 +9,9 @@ const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 function processRm(name, args, rootId, data) {
     if (args.length === 0) {
         logger_1.dataflowLogger.warn('empty rm, 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 res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    const res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'builtin:rm' }).information;
     const names = [];
     for (const arg of args) {
         if (arg === r_function_call_1.EmptyArgument) {

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

@@ -55,6 +55,14 @@ function platformDirname(p) {
 function returnPlatformPath(p) {
     return p.replaceAll(AnyPathSeparator, path_1.default.sep);
 }
+function applyReplacements(path, replacements) {
+    const results = [];
+    for (const replacement of replacements) {
+        const newPath = Object.entries(replacement).reduce((acc, [key, value]) => acc.replace(new RegExp(key, 'g'), value), path);
+        results.push(newPath);
+    }
+    return results;
+}
 /**
  * Tries to find sourced by a source request and returns the first path that exists
  * @param seed - the path originally requested in the `source` call
@@ -67,7 +75,7 @@ function findSource(seed, data) {
         ...(config?.searchPath ?? []),
         ...(inferWdFromScript(config?.inferWorkingDirectory ?? config_1.InferWorkingDirectory.No, data.referenceChain))
     ];
-    const tryPaths = [seed];
+    let tryPaths = [seed];
     switch (config?.dropPaths ?? config_1.DropPathsOption.No) {
         case config_1.DropPathsOption.Once: {
             const first = platformBasename(seed);
@@ -77,6 +85,7 @@ function findSource(seed, data) {
         case config_1.DropPathsOption.All: {
             const paths = platformDirname(seed).split(AnyPathSeparator);
             const basename = platformBasename(seed);
+            tryPaths.push(basename);
             if (paths.length === 1 && paths[0] === '.') {
                 break;
             }
@@ -89,6 +98,10 @@ function findSource(seed, data) {
         case config_1.DropPathsOption.No:
             break;
     }
+    if (config?.applyReplacements) {
+        const r = config.applyReplacements;
+        tryPaths = tryPaths.flatMap(t => applyReplacements(t, r));
+    }
     const found = [];
     for (const explore of [undefined, ...explorePaths]) {
         for (const tryPath of tryPaths) {
@@ -99,16 +112,18 @@ function findSource(seed, data) {
             }
         }
     }
-    log_1.log.info(`Found sourced file ${JSON.stringify(seed)} at ${JSON.stringify(found)}`);
+    if (log_1.log.settings.minLevel >= 3 /* LogLevel.Info */) {
+        log_1.log.info(`Found sourced file ${JSON.stringify(seed)} at ${JSON.stringify(found)}`);
+    }
     return found;
 }
 function processSourceCall(name, args, rootId, data, config) {
     if (args.length !== 1) {
         logger_1.dataflowLogger.warn(`Expected exactly one argument for source currently, but got ${args.length} instead, 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 information = config.includeFunctionCall ?
-        (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information
+        (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'builtin:source' }).information
         : (0, info_1.initializeCleanDataflowInformation)(rootId, data);
     const sourceFileArgument = args[0];
     if (!config.forceFollow && (0, config_1.getConfig)().ignoreSourceCalls) {

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

@@ -6,11 +6,11 @@ const logger_1 = require("../../../../../logger");
 const edge_1 = require("../../../../../graph/edge");
 function processSpecialBinOp(name, args, rootId, data, config) {
     if (!config.lazy) {
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'builtin:special-bin-op' }).information;
     }
     else if (args.length != 2) {
         logger_1.dataflowLogger.warn(`Logical bin-op ${name.content} has something else than 2 arguments, skipping`);
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs }).information;
+        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,
         patchData: (d, i) => {
@@ -18,7 +18,8 @@ function processSpecialBinOp(name, args, rootId, data, config) {
                 return { ...d, controlDependencies: [...d.controlDependencies ?? [], { id: name.info.id, when: config.evalRhsWhen }] };
             }
             return d;
-        }
+        },
+        origin: 'builtin:special-bin-op'
     });
     for (const arg of processedArguments) {
         if (arg) {

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

@@ -15,11 +15,11 @@ const containers_1 = require("../../../../../../util/containers");
  * ```
  */
 function processVector(name, args, rootId, data) {
-    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data });
+    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'builtin:vector' });
     if (!(0, config_1.getConfig)().solver.pointerTracking) {
         return fnCall.information;
     }
-    const vectorArgs = [];
+    let vectorArgs = [];
     let argIndex = 1;
     for (const arg of args) {
         // Skip invalid argument types
@@ -49,7 +49,7 @@ function processVector(name, args, rootId, data) {
                     nodeId: index.nodeId,
                 };
             }) ?? [];
-            vectorArgs.push(...flattenedIndices);
+            vectorArgs = vectorArgs.concat(flattenedIndices);
         }
     }
     if ((0, config_1.isOverPointerAnalysisThreshold)(vectorArgs.length)) {

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

@@ -14,12 +14,12 @@ const identifier_1 = require("../../../../../environments/identifier");
 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`);
-        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 unpackedArgs = args.map(e => (0, unpack_argument_1.unpackArgument)(e));
     if (unpackedArgs.some(assert_1.isUndefined)) {
         logger_1.dataflowLogger.warn(`While-Loop ${name.content} has empty arguments 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;
     }
     /* we inject the cf-dependency of the while-loop after the condition */
     const { information, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({
@@ -33,7 +33,7 @@ function processWhileLoop(name, args, rootId, data) {
                 return { ...d, controlDependencies: [...d.controlDependencies ?? [], { id: name.info.id, when: true }] };
             }
             return d;
-        }
+        }, origin: 'builtin:while-loop'
     });
     const [condition, body] = processedArguments;
     (0, assert_1.guard)(condition !== undefined && body !== undefined, () => `While-Loop ${name.content} has no condition or body, impossible!`);

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

@@ -7,6 +7,7 @@ import type { DataflowGraph, FunctionArgument } from '../../../../graph/graph';
 import type { NodeId } from '../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { REnvironmentInformation } from '../../../../environments/environment';
 import type { IdentifierReference } from '../../../../environments/identifier';
+import type { DataflowGraphVertexAstLink, FunctionOriginInformation } from '../../../../graph/vertex';
 import type { RSymbol } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 export interface ForceArguments {
     /** which of the arguments should be forced? this may be all, e.g., if the function itself is unknown on encounter */
@@ -35,5 +36,7 @@ export interface PatchFunctionCallInput<OtherInfo> {
     readonly name: RSymbol<OtherInfo & ParentInformation>;
     readonly data: DataflowProcessorInformation<OtherInfo & ParentInformation>;
     readonly argumentProcessResult: readonly (Pick<DataflowInformation, 'entryPoint'> | undefined)[];
+    readonly origin: FunctionOriginInformation;
+    readonly link?: DataflowGraphVertexAstLink;
 }
-export declare function patchFunctionCall<OtherInfo>({ nextGraph, rootId, name, data, argumentProcessResult }: PatchFunctionCallInput<OtherInfo>): void;
+export declare function patchFunctionCall<OtherInfo>({ nextGraph, rootId, name, data, argumentProcessResult, origin, link }: PatchFunctionCallInput<OtherInfo>): void;

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

@@ -77,7 +77,7 @@ function processAllArguments({ functionName, args, data, finalGraph, functionRoo
                 /* maybe all targets are not definitely of the current scope and should be still kept */
                 let assumeItMayHaveAHigherTarget = true;
                 for (const resolved of tryToResolve) {
-                    if ((0, info_1.happensInEveryBranch)(resolved.controlDependencies)) {
+                    if ((0, info_1.happensInEveryBranch)(resolved.controlDependencies) && !(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
@@ -103,7 +103,7 @@ function processAllArguments({ functionName, args, data, finalGraph, functionRoo
     }
     return { finalEnv, callArgs, remainingReadInArgs, processedArguments };
 }
-function patchFunctionCall({ nextGraph, rootId, name, data, argumentProcessResult }) {
+function patchFunctionCall({ nextGraph, rootId, name, data, argumentProcessResult, origin, link }) {
     nextGraph.addVertex({
         tag: vertex_1.VertexType.FunctionCall,
         id: rootId,
@@ -113,7 +113,9 @@ function patchFunctionCall({ nextGraph, rootId, name, data, argumentProcessResul
         onlyBuiltin: false,
         cds: data.controlDependencies,
         args: argumentProcessResult.map(arg => arg === undefined ? r_function_call_1.EmptyArgument : { nodeId: arg.entryPoint, controlDependencies: undefined, call: undefined, type: identifier_1.ReferenceType.Argument }),
-    });
+        origin: [origin],
+        link
+    }, !nextGraph.hasVertex(rootId) || nextGraph.isRoot(rootId), true);
     for (const arg of argumentProcessResult) {
         if (arg) {
             nextGraph.addEdge(rootId, arg.entryPoint, edge_1.EdgeType.Argument);

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

@@ -8,7 +8,7 @@ import type { NodeId } from '../../../../../r-bridge/lang-4.x/ast/model/processi
 import type { RNode } from '../../../../../r-bridge/lang-4.x/ast/model/model';
 import type { IdentifierReference } from '../../../../environments/identifier';
 import { DataflowGraph } from '../../../../graph/graph';
-import type { ContainerIndicesCollection } from '../../../../graph/vertex';
+import type { ContainerIndicesCollection, FunctionOriginInformation } from '../../../../graph/vertex';
 export interface ProcessKnownFunctionCallInput<OtherInfo> extends ForceArguments {
     readonly name: RSymbol<OtherInfo & ParentInformation>;
     readonly args: readonly (RNode<OtherInfo & ParentInformation> | RFunctionArgument<OtherInfo & ParentInformation>)[];
@@ -22,6 +22,7 @@ export interface ProcessKnownFunctionCallInput<OtherInfo> extends ForceArguments
     readonly patchData?: (data: DataflowProcessorInformation<OtherInfo & ParentInformation>, arg: number) => DataflowProcessorInformation<OtherInfo & ParentInformation>;
     /** Does the call have a side effect that we do not know a lot about which may have further consequences? */
     readonly hasUnknownSideEffect?: boolean;
+    readonly origin: FunctionOriginInformation | 'default';
 }
 export interface ProcessKnownFunctionCallResult {
     readonly information: DataflowInformation;
@@ -29,4 +30,4 @@ export interface ProcessKnownFunctionCallResult {
     readonly fnRef: IdentifierReference;
 }
 export declare function markNonStandardEvaluationEdges(markAsNSE: readonly number[], callArgs: readonly (DataflowInformation | undefined)[], finalGraph: DataflowGraph, rootId: NodeId): void;
-export declare function processKnownFunctionCall<OtherInfo>({ name, args, rootId, data, reverseOrder, markAsNSE, forceArgs, patchData, hasUnknownSideEffect }: ProcessKnownFunctionCallInput<OtherInfo>, indicesCollection?: ContainerIndicesCollection): ProcessKnownFunctionCallResult;
+export declare function processKnownFunctionCall<OtherInfo>({ name, args, rootId, data, reverseOrder, markAsNSE, forceArgs, patchData, hasUnknownSideEffect, origin }: ProcessKnownFunctionCallInput<OtherInfo>, indicesCollection?: ContainerIndicesCollection): ProcessKnownFunctionCallResult;

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

@@ -23,7 +23,7 @@ function markNonStandardEvaluationEdges(markAsNSE, callArgs, finalGraph, rootId)
         }
     }
 }
-function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = false, markAsNSE = undefined, forceArgs, patchData = d => d, hasUnknownSideEffect }, indicesCollection = undefined) {
+function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = false, markAsNSE = undefined, forceArgs, patchData = d => d, hasUnknownSideEffect, origin }, indicesCollection = undefined) {
     const functionName = (0, processor_1.processDataflowFor)(name, data);
     const finalGraph = new graph_1.DataflowGraph(data.completeAst.idMap);
     const functionCallName = name.content;
@@ -43,6 +43,7 @@ function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = fal
         cds: data.controlDependencies,
         args: reverseOrder ? [...callArgs].reverse() : callArgs,
         indicesCollection: indicesCollection,
+        origin: origin === 'default' ? ['function'] : [origin]
     });
     if (hasUnknownSideEffect) {
         finalGraph.markIdForUnknownSideEffects(rootId);

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

@@ -25,7 +25,7 @@ function mergeInformation(info, newInfo) {
 function processDefaultFunctionProcessor(information, name, args, rootId, data) {
     const resolve = (0, resolve_by_name_1.resolveByName)(name.content, data.environment, identifier_1.ReferenceType.Function);
     /* if we do not know where we land, we force! */
-    const call = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: (resolve?.length ?? 0) > 0 ? undefined : 'all' });
+    const call = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: (resolve?.length ?? 0) > 0 ? undefined : 'all', origin: 'default' });
     return mergeInformation(information, call.information);
 }
 function markAsOnlyBuiltIn(graph, rootId) {

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

@@ -3,4 +3,5 @@ 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 UnnamedFunctionCallOrigin = "unnamed";
 export declare function processUnnamedFunctionCall<OtherInfo>(functionCall: RUnnamedFunctionCall<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;