@eagleoutice/flowr 2.7.6 → 2.8.0

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

@@ -35,6 +35,21 @@ function processApply(name, args, rootId, data, config) {
             index = mayFn;
         }
     }
+    // shift the index to point to the index'd unnamed argument
+    let posArgsFound = 0;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg !== r_function_call_1.EmptyArgument && arg.name) {
+            // do nothing
+        }
+        else if (posArgsFound === index) {
+            index = i;
+            break;
+        }
+        else {
+            posArgsFound++;
+        }
+    }
     /* validate, that we indeed have so many arguments to fill this one :D */
     if (index >= args.length) {
         logger_1.dataflowLogger.warn(`Function argument at index ${index} not found, skipping`);
@@ -62,7 +77,8 @@ function processApply(name, args, rootId, data, config) {
         if (resolveValue) {
             const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(val.info.id, { environment: data.environment, idMap: data.completeAst.idMap, resolve: data.ctx.config.solver.variables, ctx: data.ctx }));
             if (resolved?.elements.length === 1 && resolved.elements[0].type === 'string') {
-                functionName = (0, r_value_1.isValue)(resolved.elements[0].value) ? resolved.elements[0].value.str : undefined;
+                const r = resolved.elements[0];
+                functionName = (0, r_value_1.isValue)(r.value) ? r.value.str : undefined;
             }
         }
         else {
@@ -102,7 +118,7 @@ function processApply(name, args, rootId, data, config) {
             name: functionName,
             /* can never be a direct built-in-call */
             onlyBuiltin: false,
-            cds: data.controlDependencies,
+            controlDependencies: data.controlDependencies,
             args: allOtherArguments, // same reference
             origin: ['function']
         }, data.ctx.env.makeCleanEnv());
@@ -151,7 +167,7 @@ function processApply(name, args, rootId, data, config) {
             args: allOtherArguments,
             environment: resolveInEnvironment === 'global' ? undefined : data.environment,
             onlyBuiltin: resolveInEnvironment === 'global',
-            cds: data.controlDependencies,
+            controlDependencies: data.controlDependencies,
             origin: ['function']
         });
     }

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

@@ -22,6 +22,20 @@ export interface AssignmentConfiguration extends ForceArguments {
     readonly indicesCollection?: ContainerIndicesCollection;
     readonly mayHaveMoreArgs?: boolean;
 }
+export interface ExtendedAssignmentConfiguration extends AssignmentConfiguration {
+    readonly source: {
+        idx?: number;
+        name: string;
+    };
+    readonly target: {
+        idx?: number;
+        name: string;
+    };
+}
+/**
+ * In contrast to `processAssignment`, this function allows more flexible handling of assignment-like functions.
+ */
+export declare function processAssignmentLike<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: ExtendedAssignmentConfiguration): DataflowInformation;
 /**
  * Processes an assignment, i.e., `<target> <- <source>`.
  * Handling it as a function call \`&lt;-\` `(<target>, <source>)`.

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAssignmentLike = processAssignmentLike;
 exports.processAssignment = processAssignment;
 exports.markAsAssignment = markAsAssignment;
 const known_call_handling_1 = require("../known-call-handling");
@@ -8,6 +9,7 @@ const unpack_argument_1 = require("../argument/unpack-argument");
 const process_named_call_1 = require("../../../process-named-call");
 const make_argument_1 = require("../argument/make-argument");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
+const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const logger_1 = require("../../../../../logger");
 const identifier_1 = require("../../../../../environments/identifier");
 const overwrite_1 = require("../../../../../environments/overwrite");
@@ -69,6 +71,30 @@ function tryReplacementPassingIndices(rootId, functionName, data, name, args, in
     (0, named_call_handling_1.markAsOnlyBuiltIn)(info.graph, functionName.info.id);
     return info;
 }
+/**
+ * In contrast to `processAssignment`, this function allows more flexible handling of assignment-like functions.
+ */
+function processAssignmentLike(name, 
+/* we expect them to be ordered in the sense that we have (source, target): `<source> <- <target>` */
+args, rootId, data, config) {
+    const argsWithNames = new Map();
+    const argsWithoutNames = [];
+    for (const arg of args) {
+        const name = arg !== r_function_call_1.EmptyArgument ? arg.name?.content : undefined;
+        if (name !== undefined) {
+            argsWithNames.set(name, arg);
+        }
+        else {
+            argsWithoutNames.push(arg);
+        }
+    }
+    const source = argsWithNames.get(config.source.name) ?? (config.source.idx !== undefined ? argsWithoutNames[config.source.idx] : undefined);
+    const target = argsWithNames.get(config.target.name) ?? (config.target.idx !== undefined ? argsWithoutNames[config.target.idx] : undefined);
+    if (source && target) {
+        args = [target, source];
+    }
+    return processAssignment(name, args, rootId, data, { ...config, mayHaveMoreArgs: true });
+}
 /**
  * Processes an assignment, i.e., `<target> <- <source>`.
  * Handling it as a function call \`&lt;-\` `(<target>, <source>)`.
@@ -338,6 +364,10 @@ function processAssignmentToSymbol(config) {
     if (quoteSource) {
         information.graph.addEdge(rootId, source.info.id, edge_1.EdgeType.NonStandardEvaluation);
     }
+    else {
+        // we read the source
+        information.graph.addEdge(rootId, source.info.id, edge_1.EdgeType.Reads);
+    }
     return {
         ...information,
         unknownReferences: [],

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

@@ -53,7 +53,7 @@ function processEvalCall(name, args, rootId, data, config) {
             result.push(r);
             // add a returns edge from the eval to the result
             for (const e of r.exitPoints) {
-                information.graph.addEdge(rootId, e, edge_1.EdgeType.Returns);
+                information.graph.addEdge(rootId, e.nodeId, edge_1.EdgeType.Returns);
             }
         }
         return {
@@ -64,6 +64,7 @@ function processEvalCall(name, args, rootId, data, config) {
             in: information.in.concat(result.flatMap(r => r.in)),
             unknownReferences: information.unknownReferences.concat(result.flatMap(r => r.unknownReferences)),
             exitPoints: information.exitPoints.concat(result.flatMap(r => r.exitPoints)),
+            hooks: information.hooks.concat(result.flatMap(r => r.hooks)),
         };
     }
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Non-constant argument ${JSON.stringify(args)} for eval is currently not supported, skipping`);

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

@@ -47,12 +47,6 @@ function linkReadNameToWriteIfPossible(read, environments, listEnvironments, rem
         }
     }
 }
-function processNextExpression(currentElement, environment, listEnvironments, remainingRead, nextGraph) {
-    // all inputs that have not been written until now are read!
-    for (const read of currentElement.in.concat(currentElement.unknownReferences)) {
-        linkReadNameToWriteIfPossible(read, environment, listEnvironments, remainingRead, nextGraph);
-    }
-}
 function updateSideEffectsForCalledFunctions(calledEnvs, inputEnvironment, nextGraph, localDefs) {
     for (const { functionCall, called } of calledEnvs) {
         let callDependencies = null;
@@ -87,7 +81,7 @@ function updateSideEffectsForCalledFunctions(calledEnvs, inputEnvironment, nextG
                     };
                 }
                 if (callDependencies === null) {
-                    callDependencies = nextGraph.getVertex(functionCall, true)?.cds;
+                    callDependencies = nextGraph.getVertex(functionCall, true)?.controlDependencies;
                 }
                 inputEnvironment = (0, overwrite_1.overwriteEnvironment)(inputEnvironment, environment, callDependencies);
             }
@@ -108,11 +102,11 @@ function processExpressionList(name, args, rootId, data) {
     const nextGraph = new graph_1.DataflowGraph(data.completeAst.idMap);
     let out = [];
     const exitPoints = [];
-    let expressionCounter = 0;
+    const activeCdsAtStart = data.controlDependencies;
+    const invertExitCds = [];
     const processedExpressions = [];
     let defaultReturnExpr = undefined;
     for (const expression of expressions) {
-        (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `processing expression ${++expressionCounter} of ${expressions.length}`);
         if (expression === undefined) {
             processedExpressions.push(undefined);
             continue;
@@ -126,16 +120,25 @@ function processExpressionList(name, args, rootId, data) {
         // if the expression contained next or break anywhere before the next loop, the "overwrite" should be an "append", because we do not know if the rest is executed
         // update the environments for the next iteration with the previous writes
         if (exitPoints.length > 0) {
-            processed.out = (0, reference_to_maybe_1.makeAllMaybe)(processed.out, nextGraph, processed.environment, true);
-            processed.in = (0, reference_to_maybe_1.makeAllMaybe)(processed.in, nextGraph, processed.environment, false);
+            processed.out = (0, reference_to_maybe_1.makeAllMaybe)(processed.out, nextGraph, processed.environment, true, invertExitCds);
+            processed.in = (0, reference_to_maybe_1.makeAllMaybe)(processed.in, nextGraph, processed.environment, false, invertExitCds);
             processed.unknownReferences = (0, reference_to_maybe_1.makeAllMaybe)(processed.unknownReferences, nextGraph, processed.environment, false);
         }
-        (0, info_1.addNonDefaultExitPoints)(exitPoints, processed.exitPoints);
         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;
+        // all inputs that have not been written until now are read!
+        for (const read of processed.in.concat(processed.unknownReferences)) {
+            linkReadNameToWriteIfPossible(read, environment, listEnvironments, remainingRead, nextGraph);
+        }
         const calledEnvs = (0, linker_1.linkFunctionCalls)(nextGraph, data.completeAst.idMap, processed.graph);
+        for (const c of calledEnvs) {
+            if (c.propagateExitPoints.length > 0) {
+                for (const exit of c.propagateExitPoints) {
+                    processed.exitPoints.push(exit);
+                }
+            }
+        }
+        (0, info_1.addNonDefaultExitPoints)(exitPoints, invertExitCds, activeCdsAtStart, processed.exitPoints);
+        environment = exitPoints.length > 0 ? (0, overwrite_1.overwriteEnvironment)(environment, processed.environment) : processed.environment;
         // if the called function has global redefinitions, we have to keep them within our environment
         environment = updateSideEffectsForCalledFunctions(calledEnvs, environment, nextGraph, processed.out);
         for (const { nodeId } of processed.out) {
@@ -149,10 +152,13 @@ function processExpressionList(name, args, rootId, data) {
         }
     }
     if (defaultReturnExpr) {
-        exitPoints.push({
+        exitPoints.push(data.controlDependencies ? {
             type: 0 /* ExitPointType.Default */,
             nodeId: defaultReturnExpr.entryPoint,
             controlDependencies: data.controlDependencies
+        } : {
+            type: 0 /* ExitPointType.Default */,
+            nodeId: defaultReturnExpr.entryPoint
         });
     }
     const ingoing = remainingRead.values().toArray().flat();
@@ -186,7 +192,8 @@ function processExpressionList(name, args, rootId, data) {
         graph: nextGraph,
         /* if we have no group, we take the last evaluated expr */
         entryPoint: meId,
-        exitPoints: exitPoints
+        exitPoints: exitPoints,
+        hooks: processedExpressions.flatMap(p => p?.hooks ?? []),
     };
 }
 //# sourceMappingURL=built-in-expression-list.js.map

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

@@ -73,7 +73,8 @@ function processForLoop(name, args, rootId, data) {
         graph: nextGraph,
         entryPoint: name.info.id,
         exitPoints: (0, info_1.filterOutLoopExitPoints)(body.exitPoints),
-        environment: outEnvironment
+        environment: outEnvironment,
+        hooks: variable.hooks.concat(vector.hooks, body.hooks),
     };
 }
 //# sourceMappingURL=built-in-for-loop.js.map

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

@@ -12,7 +12,11 @@ import type { ReadOnlyFlowrAnalyzerContext } from '../../../../../../project/con
  */
 export declare function processFunctionDefinition<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
 /**
- *
+ * Retrieve the active environment when entering a function definition or call
+ * @param callerEnvironment - environment at the call site / function definition site
+ * @param baseEnvironment   - base environment within the function definition / call
+ * @param ctx               - analyzer context
+ * @returns active environment within the function definition / call
  */
 export declare function retrieveActiveEnvironment(callerEnvironment: REnvironmentInformation | undefined, baseEnvironment: REnvironmentInformation, ctx: ReadOnlyFlowrAnalyzerContext): REnvironmentInformation;
 /**

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

@@ -5,6 +5,7 @@ exports.retrieveActiveEnvironment = retrieveActiveEnvironment;
 exports.updateNestedFunctionClosures = updateNestedFunctionClosures;
 exports.updateNestedFunctionCalls = updateNestedFunctionCalls;
 const processor_1 = require("../../../../../processor");
+const info_1 = require("../../../../../info");
 const linker_1 = require("../../../../linker");
 const known_call_handling_1 = require("../known-call-handling");
 const unpack_argument_1 = require("../argument/unpack-argument");
@@ -20,6 +21,8 @@ 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");
+const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
+const hooks_1 = require("../../../../../hooks");
 /**
  * Process a function definition, i.e., `function(a, b) { ... }`
  */
@@ -31,19 +34,23 @@ function processFunctionDefinition(name, args, rootId, data) {
     /* we remove the last argument, as it is the body */
     const parameters = args.slice(0, -1);
     const bodyArg = (0, unpack_argument_1.unpackNonameArg)(args[args.length - 1]);
-    (0, assert_1.guard)(bodyArg !== undefined, () => `Function Definition ${JSON.stringify(args)} has missing body! This is bad!`);
+    (0, assert_1.guard)(bodyArg !== undefined, () => `Function Definition ${JSON.stringify(args)} has no body! This is bad!`);
     const originalEnvironment = data.environment;
     // within a function def we do not pass on the outer binds as they could be overwritten when called
     data = prepareFunctionEnvironment(data);
     const subgraph = new graph_1.DataflowGraph(data.completeAst.idMap);
     let readInParameters = [];
+    const paramIds = [];
     for (const param of parameters) {
-        (0, assert_1.guard)(param !== r_function_call_1.EmptyArgument, () => `Empty argument in function definition ${name.content}, ${JSON.stringify(args)}`);
+        (0, assert_1.guard)(param !== r_function_call_1.EmptyArgument, () => `Empty param arg in function definition ${name.content}, ${JSON.stringify(args)}`);
         const processed = (0, processor_1.processDataflowFor)(param, data);
+        if (param.value?.type === type_1.RType.Parameter) {
+            paramIds.push(param.value.name.info.id);
+        }
         subgraph.mergeWith(processed.graph);
         const read = processed.in.concat(processed.unknownReferences);
         (0, linker_1.linkInputs)(read, data.environment, readInParameters, subgraph, false);
-        data = { ...data, environment: (0, overwrite_1.overwriteEnvironment)(data.environment, processed.environment) };
+        data.environment = (0, overwrite_1.overwriteEnvironment)(data.environment, processed.environment);
     }
     const paramsEnvironments = data.environment;
     const body = (0, processor_1.processDataflowFor)(bodyArg, data);
@@ -51,7 +58,7 @@ function processFunctionDefinition(name, args, rootId, data) {
     // This is the correct behavior, even if someone uses non-`=` arguments in functions.
     const bodyEnvironment = body.environment;
     readInParameters = findPromiseLinkagesForParameters(subgraph, readInParameters, paramsEnvironments, body);
-    const readInBody = [...body.in, ...body.unknownReferences];
+    const readInBody = body.in.concat(body.unknownReferences);
     // there is no uncertainty regarding the arguments, as if a function header is executed, so is its body
     const remainingRead = (0, linker_1.linkInputs)(readInBody, paramsEnvironments, readInParameters.slice(), body.graph, true /* functions do not have to be called */);
     // functions can be called multiple times,
@@ -59,7 +66,7 @@ function processFunctionDefinition(name, args, rootId, data) {
     /* theoretically, we should just check if there is a global effect-write somewhere within */
     if (remainingRead.length > 0) {
         const nameIdShares = (0, linker_1.produceNameSharedIdMap)(remainingRead);
-        const definedInLocalEnvironment = new Set([...bodyEnvironment.current.memory.values()].flat().map(d => d.nodeId));
+        const definedInLocalEnvironment = new Set(Array.from(bodyEnvironment.current.memory.values()).flat().map(d => d.nodeId));
         // Everything that is in body.out but not within the local environment populated for the function scope is a potential escape ~> global definition
         const globalBodyOut = body.out.filter(d => !definedInLocalEnvironment.has(d.nodeId));
         (0, linker_1.linkCircularRedefinitionsWithinALoop)(body.graph, nameIdShares, globalBodyOut);
@@ -72,28 +79,50 @@ function processFunctionDefinition(name, args, rootId, data) {
                 tag: vertex_1.VertexType.Use,
                 id: read.nodeId,
                 environment: undefined,
-                cds: undefined
+                controlDependencies: undefined
             }, data.ctx.env.makeCleanEnv());
         }
     }
+    const compactedHooks = (0, hooks_1.compactHookStates)(body.hooks);
+    const exitHooks = (0, hooks_1.getHookInformation)(compactedHooks, hooks_1.KnownHooks.OnFnExit);
     const flow = {
         unknownReferences: [],
         in: remainingRead,
         out: [],
         entryPoint: body.entryPoint,
         graph: new Set(subgraph.rootIds()),
-        environment: outEnvironment
+        environment: outEnvironment,
+        hooks: compactedHooks
     };
     updateNestedFunctionClosures(subgraph, outEnvironment, name.info.id);
     const exitPoints = body.exitPoints;
+    const readParams = {};
+    for (const paramId of paramIds) {
+        const ingoing = subgraph.ingoingEdges(paramId);
+        readParams[paramId] = ingoing?.values().some(({ types }) => (0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.Reads)) ?? false;
+    }
+    let afterHookExitPoints = exitPoints?.filter(e => e.type === 1 /* ExitPointType.Return */ || e.type === 0 /* ExitPointType.Default */ || e.type === 4 /* ExitPointType.Error */) ?? [];
+    for (const hook of exitHooks) {
+        const vert = subgraph.getVertex(hook.id);
+        if (vert?.tag !== vertex_1.VertexType.FunctionDefinition) {
+            continue;
+        }
+        // call all hooks
+        subgraph.addEdge(rootId, hook.id, edge_1.EdgeType.Calls);
+        const hookExitPoints = vert.exitPoints.filter(e => e.type === 1 /* ExitPointType.Return */ || e.type === 4 /* ExitPointType.Error */);
+        if (hookExitPoints.length > 0) {
+            afterHookExitPoints = (0, info_1.overwriteExitPoints)(afterHookExitPoints, hookExitPoints);
+        }
+    }
     const graph = new graph_1.DataflowGraph(data.completeAst.idMap).mergeWith(subgraph, false);
     graph.addVertex({
         tag: vertex_1.VertexType.FunctionDefinition,
         id: name.info.id,
         environment: (0, scoping_1.popLocalEnvironment)(outEnvironment),
-        cds: data.controlDependencies,
+        controlDependencies: data.controlDependencies,
+        params: readParams,
         subflow: flow,
-        exitPoints: exitPoints?.filter(e => e.type === 1 /* ExitPointType.Return */ || e.type === 0 /* ExitPointType.Default */).map(e => e.nodeId) ?? []
+        exitPoints: afterHookExitPoints
     }, data.ctx.env.makeCleanEnv());
     return {
         /* nothing escapes a function definition, but the function itself, will be forced in assignment: { nodeId: functionDefinition.info.id, scope: data.activeScope, used: 'always', name: functionDefinition.info.id as string } */
@@ -103,13 +132,16 @@ function processFunctionDefinition(name, args, rootId, data) {
         exitPoints: [],
         entryPoint: name.info.id,
         graph,
-        environment: originalEnvironment
+        environment: originalEnvironment,
+        hooks: []
     };
 }
-// this is no longer necessary when we update environments to be back to front (e.g., with a list of environments)
-// this favors the bigger environment
 /**
- *
+ * Retrieve the active environment when entering a function definition or call
+ * @param callerEnvironment - environment at the call site / function definition site
+ * @param baseEnvironment   - base environment within the function definition / call
+ * @param ctx               - analyzer context
+ * @returns active environment within the function definition / call
  */
 function retrieveActiveEnvironment(callerEnvironment, baseEnvironment, ctx) {
     callerEnvironment ??= ctx.env.makeCleanEnv();
@@ -168,9 +200,10 @@ function updateNestedFunctionCalls(graph, outEnvironment) {
     // track *all* function definitions - including those nested within the current graph,
     // try to resolve their 'in' by only using the lowest scope which will be popped after this definition
     for (const [id, { onlyBuiltin, environment, name }] of graph.verticesOfType(vertex_1.VertexType.FunctionCall)) {
-        if (!name || onlyBuiltin) {
+        if (onlyBuiltin || !name) {
             continue;
         }
+        let effectiveEnvironment = outEnvironment;
         // only the call environment counts!
         if (environment) {
             while (outEnvironment.level > environment.level) {
@@ -179,16 +212,21 @@ function updateNestedFunctionCalls(graph, outEnvironment) {
             while (outEnvironment.level < environment.level) {
                 outEnvironment = (0, scoping_1.pushLocalEnvironment)(outEnvironment);
             }
+            effectiveEnvironment = (0, overwrite_1.overwriteEnvironment)(outEnvironment, environment);
         }
-        const effectiveEnvironment = environment ? (0, overwrite_1.overwriteEnvironment)(outEnvironment, environment) : outEnvironment;
-        const targets = (0, linker_1.getAllFunctionCallTargets)(id, graph, effectiveEnvironment);
+        const targets = new Set((0, linker_1.getAllFunctionCallTargets)(id, graph, effectiveEnvironment));
         for (const target of targets) {
+            if ((0, built_in_1.isBuiltIn)(target)) {
+                graph.addEdge(id, target, edge_1.EdgeType.Calls);
+                continue;
+            }
             const targetVertex = graph.getVertex(target);
-            if (targetVertex?.tag !== vertex_1.VertexType.FunctionDefinition) {
-                // support reads on symbols
-                if (targetVertex?.tag === vertex_1.VertexType.Use) {
-                    graph.addEdge(id, target, edge_1.EdgeType.Reads);
-                }
+            // support reads on symbols
+            if (targetVertex?.tag === vertex_1.VertexType.Use) {
+                graph.addEdge(id, target, edge_1.EdgeType.Reads);
+                continue;
+            }
+            else if (targetVertex?.tag !== vertex_1.VertexType.FunctionDefinition) {
                 continue;
             }
             graph.addEdge(id, target, edge_1.EdgeType.Calls);

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

@@ -76,8 +76,8 @@ function processIfThenElse(name, args, rootId, data) {
     else {
         finalEnvironment = (0, append_1.appendEnvironment)(thenEnvironment, otherwise ? otherwise.environment : cond.environment);
     }
-    const cdTrue = { id: rootId, when: true };
-    const cdFalse = { id: rootId, when: false };
+    const cdTrue = [{ id: rootId, when: true }];
+    const cdFalse = [{ id: rootId, when: false }];
     // again within an if-then-else we consider all actives to be read
     const ingoing = cond.in.concat(makeThenMaybe ? (0, reference_to_maybe_1.makeAllMaybe)(then?.in, nextGraph, finalEnvironment, false, cdTrue) : then?.in ?? [], makeOtherwiseMaybe ? (0, reference_to_maybe_1.makeAllMaybe)(otherwise?.in, nextGraph, finalEnvironment, false, cdFalse) : otherwise?.in ?? [], cond.unknownReferences, makeThenMaybe ? (0, reference_to_maybe_1.makeAllMaybe)(then?.unknownReferences, nextGraph, finalEnvironment, false, cdTrue) : then?.unknownReferences ?? [], makeOtherwiseMaybe ? (0, reference_to_maybe_1.makeAllMaybe)(otherwise?.unknownReferences, nextGraph, finalEnvironment, false, cdFalse) : otherwise?.unknownReferences ?? []);
     // we assign all with a maybe marker
@@ -102,7 +102,8 @@ function processIfThenElse(name, args, rootId, data) {
         exitPoints,
         entryPoint: rootId,
         environment: finalEnvironment,
-        graph: nextGraph
+        graph: nextGraph,
+        hooks: cond.hooks.concat(then?.hooks ?? [], otherwise?.hooks ?? []),
     };
 }
 //# sourceMappingURL=built-in-if-then-else.js.map

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

@@ -0,0 +1,34 @@
+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 { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { KnownHooks } from '../../../../../hooks';
+export interface RegisterHookConfig {
+    /** name of the hook to register, 'fn-exit' if it triggers on exit */
+    hook: KnownHooks;
+    args: {
+        /** the expression to register as hook */
+        expr: {
+            idx?: number;
+            name: string;
+        };
+        /** argument to control whether to add or replace the current hook */
+        add?: {
+            idx?: number;
+            name: string;
+            default: boolean;
+        };
+        /** argument to control whether to run the hook before or after other hooks */
+        after?: {
+            idx?: number;
+            name: string;
+            default: boolean;
+        };
+    };
+}
+/**
+ * Process a hook such as `on.exit`
+ */
+export declare function processRegisterHook<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: RegisterHookConfig): DataflowInformation;

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processRegisterHook = processRegisterHook;
+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 linker_1 = require("../../../../linker");
+const common_1 = require("../common");
+const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
+const range_1 = require("../../../../../../util/range");
+const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
+const general_1 = require("../../../../../eval/values/general");
+const unknown_side_effect_1 = require("../../../../../graph/unknown-side-effect");
+/**
+ * Process a hook such as `on.exit`
+ */
+function processRegisterHook(name, args, rootId, data, config) {
+    const params = {
+        [config.args.expr.name]: 'expr',
+    };
+    if (config.args.add) {
+        params[config.args.add.name] = 'add';
+    }
+    if (config.args.after) {
+        params[config.args.after.name] = 'after';
+    }
+    params['...'] = '...';
+    const argMaps = (0, linker_1.pMatch)((0, common_1.convertFnArguments)(args), params);
+    const exprIds = new Set(argMaps.entries().filter(([, v]) => v === 'expr').map(([k]) => k));
+    const addIds = config.args.add ? new Set(argMaps.entries().filter(([, v]) => v === 'add').map(([k]) => k)) : new Set();
+    const afterIds = config.args.after ? new Set(argMaps.entries().filter(([, v]) => v === 'after').map(([k]) => k)) : new Set();
+    const wrappedFunctions = new Set();
+    // we automatically transform the expr to a function definition that takes no arguments
+    const transformed = args.map(arg => {
+        if (arg === r_function_call_1.EmptyArgument) {
+            return r_function_call_1.EmptyArgument;
+        }
+        else if (exprIds.has(arg.info.id) && arg.value) {
+            const val = arg.value;
+            const wrapId = `${val.info.id}-hook-fn`;
+            wrappedFunctions.add(wrapId);
+            const wrapped = {
+                type: type_1.RType.FunctionDefinition,
+                location: val.location ?? (0, range_1.invalidRange)(),
+                parameters: [],
+                body: val,
+                lexeme: 'function',
+                info: {
+                    ...val.info,
+                    id: wrapId,
+                }
+            };
+            data.completeAst.idMap.set(wrapId, wrapped);
+            return {
+                ...arg,
+                value: wrapped
+            };
+        }
+        else {
+            return arg;
+        }
+    });
+    const res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args: transformed, rootId, data, origin: 'builtin:register-hook' });
+    const resolveArgs = {
+        graph: res.information.graph,
+        environment: res.information.environment,
+        resolve: data.ctx.config.solver.variables,
+        ctx: data.ctx,
+        idMap: data.completeAst.idMap,
+        full: true
+    };
+    const shouldAdd = addIds.size === 0 ? config.args.add?.default :
+        Array.from(addIds).flatMap(id => (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(id, resolveArgs))?.elements ?? [])
+            .some(v => v.type === 'logical' && v.value !== false);
+    const shouldBeAfter = afterIds.size === 0 ? config.args.after?.default :
+        Array.from(afterIds).flatMap(id => (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(id, resolveArgs))?.elements ?? [])
+            .some(v => v.type === 'logical' && v.value !== false);
+    const info = res.information;
+    const hooks = Array.from(wrappedFunctions, id => ({
+        type: config.hook,
+        id,
+        cds: data.controlDependencies,
+        add: shouldAdd,
+        after: shouldBeAfter
+    }));
+    info.hooks.push(...hooks);
+    if (data.environment.level <= 1) {
+        // if we are at the root level, we need to assume that the hook can cause unknown side-effects
+        (0, unknown_side_effect_1.handleUnknownSideEffect)(info.graph, info.environment, rootId);
+    }
+    return info;
+}
+//# sourceMappingURL=built-in-register-hook.js.map

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

@@ -27,6 +27,7 @@ function processRepeatLoop(name, args, rootId, data) {
         args: unpacked ? [unpacked] : args,
         rootId,
         data,
+        forceArgs: 'all',
         patchData: (d, i) => {
             if (i === 0) {
                 return { ...d, controlDependencies: [...d.controlDependencies ?? [], { id: name.info.id }] };

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

@@ -0,0 +1,21 @@
+import type { DataflowProcessorInformation } from '../../../../../processor';
+import type { DataflowInformation } from '../../../../../info';
+import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+/**
+ * Processes a built-in 'stopifnot' function call.
+ * This is special in that it may take a number of boolean expressions either via `...` or
+ * via `exprs` for which each expression is now evaluated individually:
+ * @example
+ * ```r
+ * stopifnot(exprs = {
+ *   all.equal(pi, 3.1415927)
+ *   2 < 2
+ *   all(1:10 < 12)
+ *   "a" < "b"
+ * })
+ * ```
+ */
+export declare function processStopIfNot<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;