@eagleoutice/flowr 2.7.6 → 2.8.0

package/dataflow/info.d.ts

@@ -4,11 +4,13 @@ import type { IdentifierReference } from './environments/identifier';
 import type { REnvironmentInformation } from './environments/environment';
 import { DataflowGraph } from './graph/graph';
 import type { GenericDifferenceInformation, WriteableDifferenceReport } from '../util/diff';
+import type { HookInformation } from './hooks';
 /**
  * A control dependency links a vertex to the control flow element which
  * may have an influence on its execution.
  * Within `if(p) a else b`, `a` and `b` have a control dependency on the `if` (which in turn decides based on `p`).
  * @see {@link happensInEveryBranch} - to check whether a list of control dependencies is exhaustive
+ * @see {@link negateControlDependency} - to easily negate a control dependency
  */
 export interface ControlDependency {
     /** The id of the node that causes the control dependency to be active (e.g., the condition of an if) */
@@ -18,6 +20,11 @@ export interface ControlDependency {
     /** whether this control dependency was created due to iteration (e.g., a loop) */
     readonly byIteration?: boolean;
 }
+/**
+ * Negates the given control dependency (i.e., flips the `when` flag).
+ * This keeps undefined `when` values intact as undefined.
+ */
+export declare function negateControlDependency(cd: ControlDependency): ControlDependency;
 /**
  * Classifies the type of exit point encountered.
  * @see {@link ExitPoint}
@@ -30,8 +37,14 @@ export declare const enum ExitPointType {
     /** The exit point is an explicit `break` call (or an alias of it) */
     Break = 2,
     /** The exit point is an explicit `next` call (or an alias of it) */
-    Next = 3
+    Next = 3,
+    /** The exit point is caused by an error being thrown, e.g., by `stop` or `stopifnot` */
+    Error = 4
 }
+/**
+ * Checks whether the given exit point type propagates calls (i.e., whether it aborts the current function execution).
+ */
+export declare function doesExitPointPropagateCalls(type: ExitPointType): boolean;
 /**
  * An exit point describes the position which ends the current control flow structure.
  * This may be as innocent as the last expression or explicit with a `return`/`break`/`next`.
@@ -50,18 +63,28 @@ export interface ExitPoint {
      * (e.g., if the `return` is contained within an `if` statement).
      * @see {@link happensInEveryBranch} - to check whether control dependencies are exhaustive
      */
-    readonly controlDependencies: ControlDependency[] | undefined;
+    readonly controlDependencies?: ControlDependency[] | undefined;
 }
 /**
- * Adds all non-default exit points to the existing list.
+ * Adds all non-default exit points to the existing list and updates the `invertExitCds` accordingly.
  */
-export declare function addNonDefaultExitPoints(existing: ExitPoint[], add: readonly ExitPoint[]): void;
+export declare function addNonDefaultExitPoints(existing: ExitPoint[], invertExitCds: ControlDependency[], activeCds: ControlDependency[] | undefined, add: readonly ExitPoint[]): void;
+/**
+ * Overwrites the existing exit points with the given ones, taking care of cds.
+ */
+export declare function overwriteExitPoints(existing: readonly ExitPoint[], replace: ExitPoint[]): ExitPoint[];
 /** The control flow information for the current DataflowInformation. */
 export interface DataflowCfgInformation {
     /** The entry node into the subgraph */
     entryPoint: NodeId;
-    /** All already identified exit points (active 'return'/'break'/'next'-likes) of the respective structure. */
+    /**
+     * All already identified exit points (active 'return'/'break'/'next'-likes) of the respective structure.
+     * This also tracks (local knowledge of) exceptions thrown within the structure.
+     * See the {@link ExitPointType#Error|Error} type for more information.
+     */
     exitPoints: readonly ExitPoint[];
+    /** Registered hooks within the current subtree */
+    hooks: HookInformation[];
 }
 /**
  * The dataflow information is one of the fundamental structures we have in the dataflow analysis.

package/dataflow/info.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.negateControlDependency = negateControlDependency;
+exports.doesExitPointPropagateCalls = doesExitPointPropagateCalls;
 exports.addNonDefaultExitPoints = addNonDefaultExitPoints;
+exports.overwriteExitPoints = overwriteExitPoints;
 exports.initializeCleanDataflowInformation = initializeCleanDataflowInformation;
 exports.happensInEveryBranch = happensInEveryBranch;
 exports.happensInEveryBranchSet = happensInEveryBranchSet;
@@ -9,11 +12,48 @@ exports.filterOutLoopExitPoints = filterOutLoopExitPoints;
 exports.diffControlDependency = diffControlDependency;
 exports.diffControlDependencies = diffControlDependencies;
 const graph_1 = require("./graph/graph");
+const assert_1 = require("../util/assert");
 /**
- * Adds all non-default exit points to the existing list.
+ * Negates the given control dependency (i.e., flips the `when` flag).
+ * This keeps undefined `when` values intact as undefined.
  */
-function addNonDefaultExitPoints(existing, add) {
-    existing.push(...add.filter(({ type }) => type !== 0 /* ExitPointType.Default */));
+function negateControlDependency(cd) {
+    return {
+        ...cd,
+        when: cd.when === undefined ? undefined : !cd.when,
+    };
+}
+/**
+ * Checks whether the given exit point type propagates calls (i.e., whether it aborts the current function execution).
+ */
+function doesExitPointPropagateCalls(type) {
+    return type === 4 /* ExitPointType.Error */;
+}
+/**
+ * Adds all non-default exit points to the existing list and updates the `invertExitCds` accordingly.
+ */
+function addNonDefaultExitPoints(existing, invertExitCds, activeCds, add) {
+    const toAdd = add.filter(({ type }) => type !== 0 /* ExitPointType.Default */);
+    if (toAdd.length === 0) {
+        return;
+    }
+    const invertedCds = toAdd.flatMap(e => e.controlDependencies?.filter(icd => !activeCds?.some(e => e.id === icd.id && e.when === icd.when)).map(negateControlDependency)).filter(assert_1.isNotUndefined);
+    existing.push(...toAdd);
+    for (const icd of invertedCds) {
+        if (!invertExitCds.some(e => e.id === icd.id && e.when === icd.when)) {
+            invertExitCds.push(icd);
+        }
+    }
+}
+/**
+ * Overwrites the existing exit points with the given ones, taking care of cds.
+ */
+function overwriteExitPoints(existing, replace) {
+    const replaceCds = replace.flatMap(e => e.controlDependencies);
+    if (replaceCds.length === 0 || replaceCds.some(r => r === undefined) || happensInEveryBranch(replaceCds.filter(e => e !== undefined))) {
+        return replace;
+    }
+    return existing.concat(replace);
 }
 /**
  * Initializes an empty {@link DataflowInformation} object with the given entry point and data.
@@ -28,7 +68,8 @@ function initializeCleanDataflowInformation(entryPoint, data) {
         environment: data.environment,
         graph: new graph_1.DataflowGraph(data.completeAst.idMap),
         entryPoint,
-        exitPoints: [{ nodeId: entryPoint, type: 0 /* ExitPointType.Default */, controlDependencies: undefined }]
+        exitPoints: [{ nodeId: entryPoint, type: 0 /* ExitPointType.Default */ }],
+        hooks: []
     };
 }
 /**
@@ -37,28 +78,21 @@ function initializeCleanDataflowInformation(entryPoint, data) {
  * @see {@link happensInEveryBranchSet} - for the set-based version
  */
 function happensInEveryBranch(controlDependencies) {
-    if (controlDependencies === undefined) {
-        /* the cds are unconstrained */
-        return true;
-    }
-    else if (controlDependencies.length === 0) {
-        /* this happens only when we have no idea and require more analysis */
-        return false;
-    }
-    return coversSet(controlDependencies);
+    /* this happens only when we have no idea and require more analysis */
+    return controlDependencies === undefined || (controlDependencies.length !== 0 && coversSet(controlDependencies));
 }
 function coversSet(controlDependencies) {
-    const trues = [];
-    const falseSet = new Set();
+    const trues = new Set();
+    const falses = new Set();
     for (const { id, when } of controlDependencies) {
         if (when) {
-            trues.push(id);
+            trues.add(id);
         }
-        else {
-            falseSet.add(id);
+        else if (when === false) {
+            falses.add(id);
         }
     }
-    return trues.every(id => falseSet.has(id));
+    return trues.symmetricDifference(falses).size === 0;
 }
 /**
  * Checks whether the given control dependencies are exhaustive (i.e. if for every control dependency on a boolean,
@@ -66,28 +100,29 @@ function coversSet(controlDependencies) {
  * @see {@link happensInEveryBranch} - for the array-based version
  */
 function happensInEveryBranchSet(controlDependencies) {
-    if (controlDependencies === undefined) {
-        /* the cds are unconstrained */
-        return true;
-    }
-    else if (controlDependencies.size === 0) {
-        /* this happens only when we have no idea and require more analysis */
-        return false;
-    }
-    return coversSet(controlDependencies);
+    return controlDependencies === undefined || (controlDependencies.size !== 0 && coversSet(controlDependencies));
 }
 /**
  * Checks whether the given dataflow information always exits (i.e., if there is a non-default exit point in every branch).
  * @see {@link ExitPoint} - for the different types of exit points
  */
 function alwaysExits(data) {
-    return data.exitPoints?.some(e => e.type !== 0 /* ExitPointType.Default */ && happensInEveryBranch(e.controlDependencies)) ?? false;
+    let cds = [];
+    for (const e of data.exitPoints) {
+        if (e.type !== 0 /* ExitPointType.Default */) {
+            if (e.controlDependencies === undefined) {
+                return true;
+            }
+            cds = cds.concat(e.controlDependencies);
+        }
+    }
+    return happensInEveryBranch(cds);
 }
 /**
  * Filters out exit points which end their cascade within a loop.
  */
 function filterOutLoopExitPoints(exitPoints) {
-    return exitPoints.filter(({ type }) => type === 1 /* ExitPointType.Return */ || type === 0 /* ExitPointType.Default */);
+    return exitPoints.filter(({ type }) => type !== 2 /* ExitPointType.Break */ && type !== 3 /* ExitPointType.Next */);
 }
 /**
  * Calculates the difference between two control dependencies.
@@ -100,7 +135,7 @@ function diffControlDependency(a, b, info) {
         return;
     }
     if (a.id !== b.id) {
-        info.report.addComment(`${info.position}Different control dependency ids. ${info.leftname}: ${a.id} vs. ${info.rightname}: ${b.id}`);
+        info.report.addComment(`${info.position}Different control dependency ids. ${info.leftname}: ${JSON.stringify(a.id)} vs. ${info.rightname}: ${JSON.stringify(b.id)}`);
     }
     if (a.when !== b.when) {
         info.report.addComment(`${info.position}Different control dependency when. ${info.leftname}: ${a.when} vs. ${info.rightname}: ${b.when}`);

package/dataflow/internal/linker.d.ts

@@ -21,12 +21,21 @@ export declare function produceNameSharedIdMap(references: IdentifierReference[]
  * Links the given arguments to the given parameters within the given graph.
  * This follows the `pmatch` semantics of R
  * @see https://cran.r-project.org/doc/manuals/R-lang.html#Argument-matching
+ * This returns the resolved map from argument ids to parameter ids.
+ * If you just want to match by name, use {@link pMatch}.
  */
-export declare function linkArgumentsOnCall(args: FunctionArgument[], params: RParameter<ParentInformation>[], graph: DataflowGraph): void;
+export declare function linkArgumentsOnCall(args: readonly FunctionArgument[], params: readonly RParameter<ParentInformation>[], graph: DataflowGraph): Map<NodeId, NodeId>;
+/**
+ * Links the given arguments to the given parameters within the given graph by name only.
+ * @note
+ * To obtain the arguments from a {@link RFunctionCall}[], either use {@link processAllArguments} (also available via {@link processKnownFunctionCall})
+ * or convert them with {@link convertFnArguments}.
+ */
+export declare function pMatch<Targets extends NodeId>(args: readonly FunctionArgument[], params: Record<string, Targets>): Map<NodeId, Targets>;
 /**
  * Links a function call with a single target function definition.
  */
-export declare function linkFunctionCallWithSingleTarget(graph: DataflowGraph, def: DataflowGraphVertexFunctionDefinition, info: DataflowGraphVertexFunctionCall, idMap: AstIdMap): void;
+export declare function linkFunctionCallWithSingleTarget(graph: DataflowGraph, { subflow: fnSubflow, exitPoints, id: fnId, params }: DataflowGraphVertexFunctionDefinition, info: DataflowGraphVertexFunctionCall, idMap: AstIdMap): ExitPoint[];
 /**
  * Returns the called functions within the current graph, which can be used to merge the environments with the call.
  * Furthermore, it links the corresponding arguments.
@@ -37,6 +46,7 @@ export declare function linkFunctionCallWithSingleTarget(graph: DataflowGraph, d
 export declare function linkFunctionCalls(graph: DataflowGraph, idMap: AstIdMap, thisGraph: DataflowGraph): {
     functionCall: NodeId;
     called: readonly DataflowGraphVertexInfo[];
+    propagateExitPoints: readonly ExitPoint[];
 }[];
 /**
  * convenience function returning all known call targets, as well as the name source which defines them
@@ -45,7 +55,7 @@ export declare function getAllFunctionCallTargets(call: NodeId, graph: DataflowG
 /**
  * Finds all linked function definitions starting from the given set of read ids.
  */
-export declare function getAllLinkedFunctionDefinitions(functionDefinitionReadIds: ReadonlySet<NodeId>, dataflowGraph: DataflowGraph): [Set<DataflowGraphVertexInfo>, Set<BuiltIn>];
+export declare function getAllLinkedFunctionDefinitions(functionDefinitionReadIds: ReadonlySet<NodeId>, dataflowGraph: DataflowGraph): [Set<Required<DataflowGraphVertexFunctionDefinition>>, Set<BuiltIn>];
 /**
  * This method links a set of read variables to definitions in an environment.
  * @param referencesToLinkAgainstEnvironment - The set of references to link against the environment

package/dataflow/internal/linker.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findNonLocalReads = findNonLocalReads;
 exports.produceNameSharedIdMap = produceNameSharedIdMap;
 exports.linkArgumentsOnCall = linkArgumentsOnCall;
+exports.pMatch = pMatch;
 exports.linkFunctionCallWithSingleTarget = linkFunctionCallWithSingleTarget;
 exports.linkFunctionCalls = linkFunctionCalls;
 exports.getAllFunctionCallTargets = getAllFunctionCallTargets;
@@ -24,6 +25,7 @@ const vertex_1 = require("../graph/vertex");
 const resolve_by_name_1 = require("../environments/resolve-by-name");
 const built_in_1 = require("../environments/built-in");
 const prefix_1 = require("../../util/prefix");
+const info_1 = require("../info");
 /**
  * Find all reads within the graph that do not reference a local definition in the graph.
  */
@@ -81,26 +83,34 @@ function produceNameSharedIdMap(references) {
  * Links the given arguments to the given parameters within the given graph.
  * This follows the `pmatch` semantics of R
  * @see https://cran.r-project.org/doc/manuals/R-lang.html#Argument-matching
+ * This returns the resolved map from argument ids to parameter ids.
+ * If you just want to match by name, use {@link pMatch}.
  */
 function linkArgumentsOnCall(args, params, graph) {
     const nameArgMap = new Map(args.filter(graph_1.isNamedArgument).map(a => [a.name, a]));
     const nameParamMap = new Map(params.filter(p => p?.name?.content !== undefined)
         .map(p => [p.name.content, p]));
+    const maps = new Map();
     const specialDotParameter = params.find(p => p.special);
+    const sid = specialDotParameter?.name.info.id;
     // all parameters matched by name
     const matchedParameters = new Set();
+    const paramNames = nameParamMap.keys().toArray();
     // first map names
     for (const [name, { nodeId: argId }] of nameArgMap) {
-        const pmatchName = (0, prefix_1.findByPrefixIfUnique)(name, nameParamMap.keys()) ?? name;
+        const pmatchName = (0, prefix_1.findByPrefixIfUnique)(name, paramNames) ?? name;
         const param = nameParamMap.get(pmatchName);
         if (param?.name) {
-            graph.addEdge(argId, param.name.info.id, edge_1.EdgeType.DefinesOnCall);
-            graph.addEdge(param.name.info.id, argId, edge_1.EdgeType.DefinedByOnCall);
+            const pid = param.name.info.id;
+            graph.addEdge(argId, pid, edge_1.EdgeType.DefinesOnCall);
+            graph.addEdge(pid, argId, edge_1.EdgeType.DefinedByOnCall);
+            maps.set(argId, pid);
             matchedParameters.add(name);
         }
-        else if (specialDotParameter?.name) {
-            graph.addEdge(argId, specialDotParameter.name.info.id, edge_1.EdgeType.DefinesOnCall);
-            graph.addEdge(specialDotParameter.name.info.id, argId, edge_1.EdgeType.DefinedByOnCall);
+        else if (sid) {
+            graph.addEdge(argId, sid, edge_1.EdgeType.DefinesOnCall);
+            graph.addEdge(sid, argId, edge_1.EdgeType.DefinedByOnCall);
+            maps.set(argId, sid);
         }
     }
     const remainingParameter = params.filter(p => !p?.name || !matchedParameters.has(p.name.content));
@@ -110,10 +120,12 @@ function linkArgumentsOnCall(args, params, graph) {
         if (arg === r_function_call_1.EmptyArgument) {
             continue;
         }
+        const aid = arg.nodeId;
         if (remainingParameter.length <= i) {
-            if (specialDotParameter !== undefined) {
-                graph.addEdge(arg.nodeId, specialDotParameter.name.info.id, edge_1.EdgeType.DefinesOnCall);
-                graph.addEdge(specialDotParameter.name.info.id, arg.nodeId, edge_1.EdgeType.DefinedByOnCall);
+            if (sid) {
+                graph.addEdge(aid, sid, edge_1.EdgeType.DefinesOnCall);
+                graph.addEdge(sid, aid, edge_1.EdgeType.DefinedByOnCall);
+                maps.set(aid, sid);
             }
             else {
                 logger_1.dataflowLogger.warn(`skipping argument ${i} as there is no corresponding parameter - R should block that`);
@@ -121,13 +133,64 @@ function linkArgumentsOnCall(args, params, graph) {
             continue;
         }
         const param = remainingParameter[i];
-        logger_1.dataflowLogger.trace(`mapping unnamed argument ${i} (id: ${arg.nodeId}) to parameter "${param.name?.content ?? '??'}"`);
+        logger_1.dataflowLogger.trace(`mapping unnamed argument ${i} (id: ${aid}) to parameter "${param.name?.content ?? '??'}"`);
         if (param.name) {
-            graph.addEdge(arg.nodeId, param.name.info.id, edge_1.EdgeType.DefinesOnCall);
-            graph.addEdge(param.name.info.id, arg.nodeId, edge_1.EdgeType.DefinedByOnCall);
+            const pid = param.name.info.id;
+            graph.addEdge(aid, pid, edge_1.EdgeType.DefinesOnCall);
+            graph.addEdge(pid, aid, edge_1.EdgeType.DefinedByOnCall);
+            maps.set(aid, pid);
         }
     }
+    return maps;
 }
+/**
+ * Links the given arguments to the given parameters within the given graph by name only.
+ * @note
+ * To obtain the arguments from a {@link RFunctionCall}[], either use {@link processAllArguments} (also available via {@link processKnownFunctionCall})
+ * or convert them with {@link convertFnArguments}.
+ */
+function pMatch(args, params) {
+    const nameArgMap = new Map(args.filter(graph_1.isNamedArgument).map(a => [a.name, a]));
+    const maps = new Map();
+    const sid = params['...'];
+    const paramNames = Object.keys(params);
+    // all parameters matched by name
+    const matchedParameters = new Set();
+    // first map names
+    for (const [name, { nodeId: argId }] of nameArgMap) {
+        const pmatchName = (0, prefix_1.findByPrefixIfUnique)(name, paramNames) ?? name;
+        const param = params[pmatchName];
+        if (param) {
+            maps.set(argId, param);
+        }
+        else if (sid) {
+            maps.set(argId, sid);
+        }
+    }
+    const remainingParameter = paramNames.filter(p => !matchedParameters.has(p));
+    const remainingArguments = args.filter(a => !(0, graph_1.isNamedArgument)(a));
+    for (let i = 0; i < remainingArguments.length; i++) {
+        const arg = remainingArguments[i];
+        if (arg === r_function_call_1.EmptyArgument) {
+            continue;
+        }
+        const aid = arg.nodeId;
+        if (remainingParameter.length <= i) {
+            if (sid) {
+                maps.set(aid, sid);
+            }
+            continue;
+        }
+        const param = params[remainingParameter[i]];
+        if (param) {
+            maps.set(aid, param);
+        }
+    }
+    return maps;
+}
+/**
+ * Links the function call arguments to the target function definition and returns a map from argument ids to parameter ids.
+ */
 function linkFunctionCallArguments(targetId, idMap, functionCallName, functionRootId, callArgs, finalGraph) {
     // we get them by just choosing the rhs of the definition
     const linkedFunction = idMap.get(targetId);
@@ -139,16 +202,16 @@ function linkFunctionCallArguments(targetId, idMap, functionCallName, functionRo
         logger_1.dataflowLogger.trace(`function call definition base ${functionCallName} does not lead to a function definition (${functionRootId}) but got ${linkedFunction.type}`);
         return;
     }
-    linkArgumentsOnCall(callArgs, linkedFunction.parameters, finalGraph);
+    return linkArgumentsOnCall(callArgs, linkedFunction.parameters, finalGraph);
 }
 /**
  * Links a function call with a single target function definition.
  */
-function linkFunctionCallWithSingleTarget(graph, def, info, idMap) {
+function linkFunctionCallWithSingleTarget(graph, { subflow: fnSubflow, exitPoints, id: fnId, params }, info, idMap) {
     const id = info.id;
     if (info.environment !== undefined) {
         // for each open ingoing reference, try to resolve it here, and if so, add a read edge from the call to signal that it reads it
-        for (const ingoing of def.subflow.in) {
+        for (const ingoing of fnSubflow.in) {
             const defs = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, info.environment, ingoing.type) : undefined;
             if (defs === undefined) {
                 continue;
@@ -161,15 +224,32 @@ function linkFunctionCallWithSingleTarget(graph, def, info, idMap) {
             }
         }
     }
-    const exitPoints = def.exitPoints;
+    const propagateExitPoints = [];
     for (const exitPoint of exitPoints) {
-        graph.addEdge(id, exitPoint, edge_1.EdgeType.Returns);
+        graph.addEdge(id, exitPoint.nodeId, edge_1.EdgeType.Returns);
+        if ((0, info_1.doesExitPointPropagateCalls)(exitPoint.type)) {
+            // add the exit point to the call!
+            propagateExitPoints.push(exitPoint);
+        }
+    }
+    const defName = (0, node_id_1.recoverName)(fnId, idMap);
+    (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `recording expr-list-level call from ${(0, node_id_1.recoverName)(info.id, idMap)} to ${defName}`);
+    graph.addEdge(id, fnId, edge_1.EdgeType.Calls);
+    applyForForcedArgs(graph, info.id, params, linkFunctionCallArguments(fnId, idMap, defName, id, info.args, graph));
+    return propagateExitPoints;
+}
+/** for each parameter that we link that gets forced, add a reads edge from the call to argument to show that it reads it */
+function applyForForcedArgs(graph, callId, readParams, maps) {
+    if (maps === undefined) {
+        return;
+    }
+    for (const [arg, param] of maps.entries()) {
+        if (readParams[String(param)]) {
+            graph.addEdge(callId, arg, edge_1.EdgeType.Reads);
+        }
     }
-    const defName = (0, node_id_1.recoverName)(def.id, idMap);
-    (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `recording expression-list-level call from ${(0, node_id_1.recoverName)(info.id, idMap)} to ${defName}`);
-    graph.addEdge(id, def.id, edge_1.EdgeType.Calls);
-    linkFunctionCallArguments(def.id, idMap, defName, id, info.args, graph);
 }
+const FCallLinkReadBits = edge_1.EdgeType.Reads | edge_1.EdgeType.Calls | edge_1.EdgeType.DefinedByOnCall;
 /* there is _a lot_ potential for optimization here */
 function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefinitions) {
     const edges = graph.outgoingEdges(id);
@@ -177,16 +257,26 @@ function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefin
         /* no outgoing edges */
         return;
     }
-    const readBits = edge_1.EdgeType.Reads | edge_1.EdgeType.Calls;
-    const functionDefinitionReadIds = [...edges].filter(([_, e]) => (0, edge_1.edgeDoesNotIncludeType)(e.types, edge_1.EdgeType.Argument)
-        && (0, edge_1.edgeIncludesType)(e.types, readBits)).map(([target, _]) => target);
-    const functionDefs = getAllLinkedFunctionDefinitions(new Set(functionDefinitionReadIds), graph)[0];
+    const functionDefinitionReadIds = new Set();
+    for (const [t, { types }] of edges.entries()) {
+        if (!(0, built_in_1.isBuiltIn)(t) && (0, edge_1.edgeDoesNotIncludeType)(types, edge_1.EdgeType.Argument) && (0, edge_1.edgeIncludesType)(types, FCallLinkReadBits)) {
+            functionDefinitionReadIds.add(t);
+        }
+    }
+    const [functionDefs] = getAllLinkedFunctionDefinitions(new Set(functionDefinitionReadIds), graph);
+    const propagateExitPoints = [];
     for (const def of functionDefs.values()) {
-        (0, assert_1.guard)(def.tag === vertex_1.VertexType.FunctionDefinition, () => `expected function definition, but got ${def.tag}`);
-        linkFunctionCallWithSingleTarget(graph, def, info, idMap);
+        // we can skip this if we already linked it
+        const oEdge = graph.outgoingEdges(id)?.get(def.id);
+        if (oEdge && (0, edge_1.edgeIncludesType)(oEdge.types, edge_1.EdgeType.Calls)) {
+            continue;
+        }
+        for (const ep of linkFunctionCallWithSingleTarget(graph, def, info, idMap)) {
+            propagateExitPoints.push(ep);
+        }
     }
     if (thisGraph.isRoot(id) && functionDefs.size > 0) {
-        calledFunctionDefinitions.push({ functionCall: id, called: [...functionDefs.values()] });
+        calledFunctionDefinitions.push({ functionCall: id, called: functionDefs.values().toArray(), propagateExitPoints });
     }
 }
 /**
@@ -199,7 +289,9 @@ function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefin
 function linkFunctionCalls(graph, idMap, thisGraph) {
     const calledFunctionDefinitions = [];
     for (const [id, info] of thisGraph.verticesOfType(vertex_1.VertexType.FunctionCall)) {
-        linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefinitions);
+        if (!info.onlyBuiltin) {
+            linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefinitions);
+        }
     }
     return calledFunctionDefinitions;
 }
@@ -227,21 +319,25 @@ function getAllFunctionCallTargets(call, graph, environment) {
         for (const target of functionCallTargets) {
             found.push(target.id);
         }
-        found = found.concat(...builtInTargets, functionCallDefs);
+        found = found.concat(Array.from(builtInTargets), functionCallDefs);
     }
     return found;
 }
+const LinkedFnFollowBits = edge_1.EdgeType.Reads | edge_1.EdgeType.DefinedBy | edge_1.EdgeType.DefinedByOnCall;
 /**
  * Finds all linked function definitions starting from the given set of read ids.
  */
 function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGraph) {
-    let potential = functionDefinitionReadIds.values().toArray();
-    const visited = new Set();
     const result = new Set();
     const builtIns = new Set();
-    while (potential.length > 0) {
+    if (functionDefinitionReadIds.size === 0) {
+        return [result, builtIns];
+    }
+    const potential = Array.from(functionDefinitionReadIds);
+    const visited = new Set();
+    while (potential.length !== 0) {
         const currentId = potential.pop();
-        // do not traverse builtins further
+        visited.add(currentId);
         if ((0, built_in_1.isBuiltIn)(currentId)) {
             builtIns.add(currentId);
             continue;
@@ -250,24 +346,29 @@ function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGrap
         if (currentInfo === undefined) {
             continue;
         }
-        visited.add(currentId);
-        const outgoingEdges = currentInfo[1].entries().toArray();
-        const returnEdges = outgoingEdges
-            .filter(([_, e]) => (0, edge_1.edgeIncludesType)(e.types, edge_1.EdgeType.Returns));
-        if (returnEdges.length > 0) {
-            // only traverse return edges and do not follow `calls` etc. as this indicates that we have a function call which returns a result, and not the function calls itself
-            potential = potential.concat(returnEdges.map(([target]) => target).filter(id => !visited.has(id)));
+        const [vertex, edges] = currentInfo;
+        // Found a function definition
+        if (vertex.subflow !== undefined) {
+            result.add(vertex);
             continue;
         }
-        const followBits = edge_1.EdgeType.Reads | edge_1.EdgeType.DefinedBy | edge_1.EdgeType.DefinedByOnCall;
-        const followEdges = outgoingEdges.filter(([_, e]) => (0, edge_1.edgeIncludesType)(e.types, followBits));
-        if (currentInfo[0].subflow !== undefined) {
-            result.add(currentInfo[0]);
+        let hasReturnEdge = false;
+        for (const [target, { types }] of edges) {
+            if ((0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.Returns)) {
+                hasReturnEdge = true;
+                if (!visited.has(target)) {
+                    potential.push(target);
+                }
+            }
+        }
+        if (hasReturnEdge) {
+            continue;
+        }
+        for (const [target, { types }] of edges) {
+            if ((0, edge_1.edgeIncludesType)(types, LinkedFnFollowBits) && !visited.has(target)) {
+                potential.push(target);
+            }
         }
-        // trace all joined reads
-        potential = potential.concat(followEdges
-            .map(([target]) => target)
-            .filter(id => !visited.has(id)));
     }
     return [result, builtIns];
 }
@@ -327,10 +428,10 @@ function linkCircularRedefinitionsWithinALoop(graph, openIns, outgoing) {
         }
     }
     for (const [name, targets] of openIns.entries()) {
-        for (const out of lastOutgoing.values()) {
-            if (out.name === name) {
+        for (const { name: outName, nodeId } of lastOutgoing.values()) {
+            if (outName === name) {
                 for (const target of targets) {
-                    graph.addEdge(target.nodeId, out.nodeId, edge_1.EdgeType.Reads);
+                    graph.addEdge(target.nodeId, nodeId, edge_1.EdgeType.Reads);
                 }
             }
         }
@@ -344,8 +445,9 @@ function reapplyLoopExitPoints(exits, references) {
     const exitCds = new Set(exits.flatMap(e => e.controlDependencies).filter(assert_1.isNotUndefined));
     for (const ref of references) {
         for (const cd of exitCds) {
+            const { id: cId, when: cWhen } = cd;
             if (ref.controlDependencies) {
-                if (!ref.controlDependencies?.find(c => c.id === cd.id && c.when === cd.when)) {
+                if (!ref.controlDependencies?.find(c => c.id === cId && c.when === cWhen)) {
                     ref.controlDependencies.push({ ...cd, byIteration: true });
                 }
             }

package/dataflow/internal/process/functions/call/argument/unpack-argument.d.ts

@@ -10,3 +10,7 @@ export declare function unpackNonameArg<OtherInfo>(arg: RFunctionArgument<OtherI
  * @see {@link unpackNonameArg} - to specifically retrieve non-named arguments
  */
 export declare function unpackArg<OtherInfo>(arg: RFunctionArgument<OtherInfo> | undefined): RNode<OtherInfo> | undefined;
+/**
+ * Try to unpack the given argument, if it is not empty.
+ */
+export declare function tryUnpackNoNameArg<OtherInfo>(arg: RFunctionArgument<OtherInfo>): RNode<OtherInfo> | RFunctionArgument<OtherInfo>;

package/dataflow/internal/process/functions/call/argument/unpack-argument.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.unpackNonameArg = unpackNonameArg;
 exports.unpackArg = unpackArg;
+exports.tryUnpackNoNameArg = tryUnpackNoNameArg;
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 /**
  * Retrieve the value from an argument, if it is not empty.
@@ -17,4 +18,10 @@ function unpackNonameArg(arg) {
 function unpackArg(arg) {
     return arg === r_function_call_1.EmptyArgument ? undefined : arg?.value;
 }
+/**
+ * Try to unpack the given argument, if it is not empty.
+ */
+function tryUnpackNoNameArg(arg) {
+    return unpackNonameArg(arg) ?? arg;
+}
 //# sourceMappingURL=unpack-argument.js.map

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

@@ -13,7 +13,7 @@ export interface BuiltInApplyConfiguration extends MergeableRecord {
     /** Should we unquote the function if it is given as a string? */
     readonly unquoteFunction?: boolean;
     /** Should the function be resolved in the global environment? */
-    readonly resolveInEnvironment: 'global' | 'local';
+    readonly resolveInEnvironment?: 'global' | 'local';
     /** Should the value of the function be resolved? */
     readonly resolveValue?: boolean;
 }