@eagleoutice/flowr 2.2.11 → 2.2.13

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

@@ -4,66 +4,66 @@ 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 assert_1 = require("../../../../../../util/assert");
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const logger_1 = require("../../../../../logger");
 const vertex_1 = require("../../../../../graph/vertex");
 const graph_1 = require("../../../../../graph/graph");
 const edge_1 = require("../../../../../graph/edge");
-const dfg_1 = require("../../../../../../util/mermaid/dfg");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
-const list_access_1 = require("../../../../../../util/list-access");
+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`);
-    let indices = undefined;
-    if (name.content === '$<-' && (0, config_1.getConfig)().solver.pointerTracking) {
-        const nonEmptyArgs = args.filter(arg => arg !== r_function_call_1.EmptyArgument);
-        const accessedArg = nonEmptyArgs.find(arg => arg.info.role === "accessed" /* RoleInParent.Accessed */);
-        const accessArg = nonEmptyArgs.find(arg => arg.info.role === "index-access" /* RoleInParent.IndexAccess */);
-        if (accessArg !== undefined && accessedArg != undefined) {
-            const leafIndex = { lexeme: accessArg.lexeme, nodeId: accessedArg.info.parent ?? '' };
-            const accessIndices = {
-                indices: [leafIndex],
-                isContainer: false
-            };
-            // Check for nested access
-            if (accessedArg.value?.type === type_1.RType.Access) {
-                indices = (0, list_access_1.constructNestedAccess)(accessedArg.value, accessIndices);
-            }
-            else {
-                // use access node as reference to get complete line in slice
-                indices = [accessIndices];
-            }
-        }
+    let indices = config.activeIndices;
+    if ((0, config_1.getConfig)().solver.pointerTracking) {
+        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
+        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)({
         functionName: (0, info_1.initializeCleanDataflowInformation)(rootId, data),
-        args: args.slice(1, -1),
+        args: convertedArgs,
         data,
         functionRootId: rootId,
         finalGraph: res.graph,
         forceArgs: config.forceArgs,
     });
-    const fn = res.graph.getVertex(rootId, true);
-    (0, assert_1.guard)(fn?.tag === vertex_1.VertexType.FunctionCall && fn.args.length === 2, () => `Function ${rootId} not found in graph or not 2-arg fn-call (${JSON.stringify(fn)}) ${(0, dfg_1.graphToMermaidUrl)(res.graph)}`);
-    fn.args = [fn.args[0], ...callArgs, fn.args[1]];
+    (0, common_1.patchFunctionCall)({
+        nextGraph: res.graph,
+        data,
+        rootId,
+        name,
+        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) {
+        res.graph.addEdge(firstArg, rootId, edge_1.EdgeType.DefinedBy | edge_1.EdgeType.Reads);
+    }
     /* a replacement reads all of its call args as well, at least as far as I am aware of */
     for (const arg of callArgs) {
         const ref = (0, graph_1.getReferenceOfArgument)(arg);
@@ -71,6 +71,75 @@ 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;
 }
+/**
+ * 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];
+    }
+    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),
+        };
+    };
+}
 //# sourceMappingURL=built-in-replacement.js.map

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

@@ -0,0 +1,7 @@
+import type { DataflowProcessorInformation } from '../../../../../processor';
+import type { DataflowInformation } from '../../../../../info';
+import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+export declare function processRm<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-rm.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processRm = processRm;
+const known_call_handling_1 = require("../known-call-handling");
+const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const logger_1 = require("../../../../../logger");
+const remove_1 = require("../../../../../environments/remove");
+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, origin: 'default' }).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) {
+            logger_1.dataflowLogger.warn('empty argument in rm, skipping');
+            continue;
+        }
+        const unpacked = arg.value;
+        if (unpacked === undefined || (unpacked.type !== type_1.RType.Symbol && unpacked.type !== type_1.RType.String)) {
+            logger_1.dataflowLogger.warn(`argument is not a symbol or string, skipping ${JSON.stringify(unpacked)}`);
+        }
+        else if (unpacked.type === type_1.RType.Symbol) {
+            names.push(unpacked.content);
+        }
+        else if (unpacked.type === type_1.RType.String) {
+            names.push(unpacked.content.str);
+        }
+    }
+    let env = res.environment;
+    for (const name of names) {
+        env = (0, remove_1.remove)(name, env);
+    }
+    return {
+        ...res,
+        environment: env
+    };
+}
+//# sourceMappingURL=built-in-rm.js.map

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,12 +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, 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) {
@@ -135,12 +154,14 @@ function processSourceCall(name, args, rootId, data, config) {
         if (filepath !== undefined) {
             const request = sourceProvider.createRequest(filepath);
             // check if the sourced file has already been dataflow analyzed, and if so, skip it
-            if (data.referenceChain.find(e => e.request === request.request && e.content === request.content)) {
-                logger_1.dataflowLogger.warn(`Found loop in dataflow analysis for ${JSON.stringify(request)}: ${JSON.stringify(data.referenceChain)}, skipping further dataflow analysis`);
+            const limit = (0, config_1.getConfig)().solver.resolveSource?.repeatedSourceLimit ?? 0;
+            const findCount = data.referenceChain.filter(e => e.request === request.request && e.content === request.content).length;
+            if (findCount > limit) {
+                logger_1.dataflowLogger.warn(`Found cycle (>=${limit + 1}) in dataflow analysis for ${JSON.stringify(request)}: ${JSON.stringify(data.referenceChain)}, skipping further dataflow analysis`);
                 information.graph.markIdForUnknownSideEffects(rootId);
                 return information;
             }
-            return sourceRequest(rootId, request, data, information, (0, decorate_1.sourcedDeterministicCountingIdGenerator)(path, name.location));
+            return sourceRequest(rootId, request, data, information, (0, decorate_1.sourcedDeterministicCountingIdGenerator)((findCount > 0 ? findCount + '::' : '') + path, name.location));
         }
     }
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Non-constant argument ${JSON.stringify(sourceFile)} for source is currently not supported, skipping`);
@@ -193,7 +214,13 @@ function sourceRequest(rootId, request, data, information, getId) {
     for (const [k, v] of normalized.idMap) {
         data.completeAst.idMap.set(k, v);
     }
-    return newInformation;
+    return {
+        ...newInformation,
+        in: newInformation.in.concat(dataflow.in),
+        out: newInformation.out.concat(dataflow.out),
+        unknownReferences: newInformation.unknownReferences.concat(dataflow.unknownReferences),
+        exitPoints: dataflow.exitPoints
+    };
 }
 function standaloneSourceFile(inputRequest, data, uniqueSourceId, information) {
     const path = inputRequest.request === 'file' ? inputRequest.content : '-inline-';
@@ -210,6 +237,6 @@ function standaloneSourceFile(inputRequest, data, uniqueSourceId, information) {
         currentRequest: request,
         environment: information.environment,
         referenceChain: [...data.referenceChain, inputRequest]
-    }, information, (0, decorate_1.deterministicPrefixIdGenerator)(path + '@' + uniqueSourceId));
+    }, information, (0, decorate_1.deterministicPrefixIdGenerator)(path + '::' + uniqueSourceId));
 }
 //# sourceMappingURL=built-in-source.js.map

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.d.ts

@@ -0,0 +1,15 @@
+import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { DataflowInformation } from '../../../../../info';
+import type { DataflowProcessorInformation } from '../../../../../processor';
+/**
+ * Process a vector call.
+ *
+ * Example:
+ * ```r
+ * c(1, 2, 3, 4)
+ * ```
+ */
+export declare function processVector<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-vector.js

@@ -0,0 +1,75 @@
+"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");
+/**
+ * Process a vector call.
+ *
+ * Example:
+ * ```r
+ * c(1, 2, 3, 4)
+ * ```
+ */
+function processVector(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;
+    }
+    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)(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;
+}
+//# sourceMappingURL=built-in-vector.js.map

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 */
@@ -34,6 +35,8 @@ export interface PatchFunctionCallInput<OtherInfo> {
     readonly rootId: NodeId;
     readonly name: RSymbol<OtherInfo & ParentInformation>;
     readonly data: DataflowProcessorInformation<OtherInfo & ParentInformation>;
-    readonly argumentProcessResult: readonly (DataflowInformation | undefined)[];
+    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

@@ -64,9 +64,12 @@ function processAllArguments({ functionName, args, data, finalGraph, functionRoo
         }
         processedArguments.push(processed);
         finalEnv = (0, overwrite_1.overwriteEnvironment)(finalEnv, processed.environment);
+        finalGraph.mergeWith(processed.graph);
         // resolve reads within argument, we resolve before adding the `processed.environment` to avoid cyclic dependencies
         for (const ingoing of [...processed.in, ...processed.unknownReferences]) {
-            const tryToResolve = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, argEnv, identifier_1.ReferenceType.Unknown) : undefined;
+            // check if it is called directly
+            const vtx = finalGraph.getVertex(ingoing.nodeId);
+            const tryToResolve = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, argEnv, vtx?.tag === vertex_1.VertexType.FunctionCall ? identifier_1.ReferenceType.Function : identifier_1.ReferenceType.Unknown) : undefined;
             if (tryToResolve === undefined) {
                 remainingReadInArgs.push(ingoing);
             }
@@ -74,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
@@ -90,7 +93,6 @@ function processAllArguments({ functionName, args, data, finalGraph, functionRoo
             }
         }
         argEnv = (0, overwrite_1.overwriteEnvironment)(argEnv, processed.environment);
-        finalGraph.mergeWith(processed.graph);
         if (arg.type !== type_1.RType.Argument || !arg.name) {
             callArgs.push({ nodeId: processed.entryPoint, controlDependencies: undefined, type: identifier_1.ReferenceType.Argument });
         }
@@ -101,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,
@@ -111,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.d.ts

@@ -4,4 +4,6 @@ import type { ParentInformation } from '../../../../../r-bridge/lang-4.x/ast/mod
 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';
+import type { DataflowGraph } from '../../../../graph/graph';
+export declare function markAsOnlyBuiltIn(graph: DataflowGraph, rootId: NodeId): void;
 export declare function processNamedCall<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.markAsOnlyBuiltIn = markAsOnlyBuiltIn;
 exports.processNamedCall = processNamedCall;
 const info_1 = require("../../../../info");
 const known_call_handling_1 = require("./known-call-handling");
@@ -24,9 +25,16 @@ 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) {
+    const v = graph.getVertex(rootId);
+    if (v?.tag === vertex_1.VertexType.FunctionCall) {
+        v.onlyBuiltin = true;
+        v.environment = undefined;
+    }
+}
 function processNamedCall(name, args, rootId, data) {
     const resolved = (0, resolve_by_name_1.resolveByName)(name.content, data.environment, identifier_1.ReferenceType.Function) ?? [];
     let defaultProcessor = resolved.length === 0;
@@ -46,11 +54,7 @@ function processNamedCall(name, args, rootId, data) {
     }
     else if (information && builtIn) {
         // mark the function call as built in only
-        const v = information.graph.getVertex(rootId);
-        if (v?.tag === vertex_1.VertexType.FunctionCall) {
-            v.onlyBuiltin = true;
-            v.environment = undefined;
-        }
+        markAsOnlyBuiltIn(information.graph, rootId);
     }
     return information ?? (0, info_1.initializeCleanDataflowInformation)(rootId, data);
 }

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;