@eagleoutice/flowr 2.7.6 → 2.8.1

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;

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processStopIfNot = processStopIfNot;
+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 defaultmap_1 = require("../../../../../../util/collections/defaultmap");
+const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
+const general_1 = require("../../../../../eval/values/general");
+const assert_1 = require("../../../../../../util/assert");
+const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
+/**
+ * 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"
+ * })
+ * ```
+ */
+function processStopIfNot(name, args, rootId, data) {
+    const res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'builtin:stopifnot' }).information;
+    if (args.length === 0) {
+        logger_1.dataflowLogger.warn(`stopifnot (${name.content}) has no argument, assuming trivially true and skipping`);
+        return res;
+    }
+    // R only allows ... or exprs or exprObject, not all, but we over-approximate and collect all, given that they are after '...'
+    // we can safely extract named args by full name
+    const argMap = new defaultmap_1.DefaultMap(() => []);
+    for (const arg of args) {
+        const name = (arg === r_function_call_1.EmptyArgument ? undefined : arg.name)?.content;
+        if (name === 'exprObject' || name === 'exprs' || name === 'local') {
+            argMap.get(name).push(arg);
+        }
+        else {
+            argMap.get('...').push(arg);
+        }
+    }
+    const localArgs = argMap.get('local');
+    const localArg = localArgs.length > 0 ? localArgs[localArgs.length - 1] : undefined;
+    const resolveArgs = { environment: data.environment, idMap: data.completeAst.idMap, resolve: data.ctx.config.solver.variables, ctx: data.ctx };
+    // we collect all control dependencies from: all '...', all expressions in 'exprs', and 'exprObject'
+    const ids = collectIdsForControl(argMap, data);
+    if (localArg !== undefined && localArg !== r_function_call_1.EmptyArgument) {
+        const localVal = (0, alias_tracking_1.resolveIdToValue)(localArg?.value?.info.id, resolveArgs);
+        const alwaysTrue = (0, general_1.valueSetGuard)(localVal)?.elements.every(d => d.type === 'logical' && d.value === true) ?? false;
+        if (!alwaysTrue) {
+            logger_1.dataflowLogger.warn(`stopifnot (${name.content}) with non-true 'local' argument is not yet supported, over-approximate`);
+            const cds = (data.controlDependencies ?? []).concat(Array.from(ids).map(r => ({
+                id: r,
+                when: false
+            })));
+            res.exitPoints.push({
+                type: 4 /* ExitPointType.Error */,
+                nodeId: rootId,
+                controlDependencies: cds
+            });
+            return res;
+        }
+    }
+    const cds = [];
+    for (const id of ids) {
+        const val = (0, alias_tracking_1.resolveIdToValue)(id, resolveArgs);
+        const alwaysFalse = (0, general_1.valueSetGuard)(val)?.elements.every(d => d.type === 'logical' && d.value === false) ?? false;
+        if (alwaysFalse) {
+            // we know that this fails *always*
+            res.exitPoints.push(data.controlDependencies ? {
+                type: 4 /* ExitPointType.Error */,
+                nodeId: rootId,
+                controlDependencies: data.controlDependencies
+            } : {
+                type: 4 /* ExitPointType.Error */,
+                nodeId: rootId
+            });
+            return res;
+        }
+        const alwaysTrue = (0, general_1.valueSetGuard)(val)?.elements.every(d => d.type === 'logical' && d.value === true) ?? false;
+        if (!alwaysTrue) {
+            cds.push({
+                id: id,
+                when: false // only trigger if it is false
+            });
+        }
+    }
+    if (cds.length === 0) {
+        logger_1.dataflowLogger.warn(`stopifnot (${name.content}) has no unknown expressions to evaluate, assuming trivially true and skipping`);
+        return res;
+    }
+    res.exitPoints.push({
+        type: 4 /* ExitPointType.Error */,
+        nodeId: rootId,
+        controlDependencies: (data.controlDependencies ?? []).concat(cds)
+    });
+    return res;
+}
+/** Generator so we can early exit on first always-false */
+function* collectIdsForControl(argMap, data) {
+    yield* argMap.get('...')
+        .map(a => a !== r_function_call_1.EmptyArgument ? a.value?.info.id : undefined)
+        .filter(assert_1.isNotUndefined);
+    const exprs = argMap.get('exprs');
+    if (exprs.length > 0) {
+        const exprsArg = exprs[exprs.length - 1];
+        if (exprsArg !== r_function_call_1.EmptyArgument && exprsArg.value?.info.id) {
+            const elem = data.completeAst.idMap.get(exprsArg.value?.info.id);
+            if (elem?.type === type_1.RType.ExpressionList) {
+                for (const expr of elem.children) {
+                    yield expr.info.id;
+                }
+            }
+            else {
+                yield exprsArg.value?.info.id;
+            }
+        }
+    }
+    const exprObjectArgs = argMap.get('exprObject');
+    if (exprObjectArgs.length > 0) {
+        const exprObjectArg = exprObjectArgs[exprObjectArgs.length - 1];
+        if (exprObjectArg !== r_function_call_1.EmptyArgument && exprObjectArg.value?.info.id) {
+            yield exprObjectArg.value?.info.id;
+        }
+    }
+}
+//# sourceMappingURL=built-in-stop-if-not.js.map

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

@@ -0,0 +1,16 @@
+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';
+/**
+ * Process a built-in try-catch or similar handler.
+ */
+export declare function processTryCatch<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
+    block: string;
+    handlers: {
+        error?: string;
+        finally?: string;
+    };
+}): DataflowInformation;

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

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processTryCatch = processTryCatch;
+const info_1 = require("../../../../../info");
+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 linker_1 = require("../../../../linker");
+const vertex_1 = require("../../../../../graph/vertex");
+const unpack_argument_1 = require("../argument/unpack-argument");
+const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
+const assert_1 = require("../../../../../../util/assert");
+const edge_1 = require("../../../../../graph/edge");
+function getArgsOfName(argMaps, name) {
+    return new Set(argMaps.entries().filter(([, v]) => v === name).map(([k]) => k));
+}
+/**
+ * Process a built-in try-catch or similar handler.
+ */
+function processTryCatch(name, args, rootId, data, config) {
+    const res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args: args.map(unpack_argument_1.tryUnpackNoNameArg), rootId, data, origin: 'builtin:try', forceArgs: 'all' });
+    if (args.length < 1 || args[0] === r_function_call_1.EmptyArgument) {
+        logger_1.dataflowLogger.warn(`TryCatch Handler ${name.content} does not have 1 argument, skipping`);
+        return res.information;
+    }
+    // artificial ids :)
+    const params = {
+        [config.block]: 'block',
+        '...': '...'
+    };
+    if (config.handlers.error) {
+        params[config.handlers.error] = 'error';
+    }
+    if (config.handlers.finally) {
+        params[config.handlers.finally] = 'finally';
+    }
+    // only remove exit points from the block
+    const argMaps = (0, linker_1.pMatch)(res.callArgs, params);
+    const info = res.information;
+    const blockArg = getArgsOfName(argMaps, 'block');
+    const errorArg = getArgsOfName(argMaps, 'error');
+    const finallyArg = getArgsOfName(argMaps, 'finally');
+    // only take those exit points from the block
+    // check whether blockArg has *always* happening exceptions, if so we do not constrain the error handler
+    const blockErrorExitPoints = [];
+    const errorExitPoints = [];
+    info.exitPoints = res.processedArguments.flatMap(arg => {
+        if (!arg) {
+            return [];
+        }
+        // this calls error and finally args
+        if (finallyArg.has(arg.entryPoint)) {
+            return handleFdefAsCalled(arg.entryPoint, info.graph, arg.exitPoints, undefined);
+        }
+        else if (errorArg.has(arg.entryPoint)) {
+            errorExitPoints.push(...getExitPoints(info.graph.getVertex(arg.entryPoint), info.graph) ?? []);
+        }
+        if (!blockArg.has(arg.entryPoint)) {
+            // not killing other args
+            return arg.exitPoints;
+        }
+        blockErrorExitPoints.push(...arg.exitPoints.filter(ep => ep.type === 4 /* ExitPointType.Error */).flatMap(a => a.controlDependencies));
+        return arg.exitPoints.filter(ep => ep.type !== 4 /* ExitPointType.Error */);
+    });
+    if (errorExitPoints.length > 0) {
+        if ((0, info_1.happensInEveryBranch)(blockErrorExitPoints.some(assert_1.isUndefined) ? undefined : blockErrorExitPoints)) {
+            info.exitPoints.push(...errorExitPoints);
+        }
+        else {
+            info.exitPoints.push(...constrainExitPoints(errorExitPoints, blockArg));
+        }
+    }
+    for (const e of errorArg) {
+        info.graph.addEdge(rootId, e, edge_1.EdgeType.Calls);
+    }
+    for (const f of finallyArg) {
+        info.graph.addEdge(rootId, f, edge_1.EdgeType.Calls);
+    }
+    for (const e of info.exitPoints) {
+        if (e.type !== 4 /* ExitPointType.Error */) {
+            info.graph.addEdge(rootId, e.nodeId, edge_1.EdgeType.Returns);
+        }
+    }
+    return info;
+}
+function getExitPoints(vertex, graph) {
+    if (!vertex) {
+        return undefined;
+    }
+    if (vertex.tag === vertex_1.VertexType.FunctionDefinition) {
+        return vertex.exitPoints;
+    }
+    // we assumed named argument
+    const n = graph.idMap?.get(vertex.id);
+    if (!n) {
+        return undefined;
+    }
+    if (n.type === type_1.RType.Argument && n.value?.type === type_1.RType.FunctionDefinition) {
+        const fdefV = graph.getVertex(n.value.info.id);
+        if (fdefV?.tag === vertex_1.VertexType.FunctionDefinition) {
+            return fdefV.exitPoints;
+        }
+    }
+    return undefined;
+}
+function handleFdefAsCalled(nodeId, graph, def, constrain) {
+    const v = graph.getVertex(nodeId);
+    const e = getExitPoints(v, graph);
+    return e ? constrainExitPoints(e, constrain) : def;
+}
+function constrainExitPoints(exitPoints, constrain) {
+    if (!constrain || constrain.size === 0) {
+        return exitPoints;
+    }
+    // append constrains with true
+    const cds = Array.from(constrain, id => ({ id, when: true }));
+    return exitPoints.map(e => {
+        if (e.controlDependencies) {
+            e.controlDependencies.push(...cds);
+            return e;
+        }
+        else {
+            return { ...e, controlDependencies: cds };
+        }
+    });
+}
+//# sourceMappingURL=built-in-try-catch.js.map

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

@@ -58,7 +58,8 @@ function processWhileLoop(name, args, rootId, data) {
             entryPoint: name.info.id,
             exitPoints: [],
             graph: information.graph,
-            environment: information.environment
+            environment: information.environment,
+            hooks: condition.hooks
         };
     }
     (0, assert_1.guard)(condition !== undefined && body !== undefined, () => `While-Loop ${name.content} has no condition or body, impossible!`);
@@ -68,7 +69,7 @@ function processWhileLoop(name, args, rootId, data) {
         information.graph.addEdge(name.info.id, condition.entryPoint, edge_1.EdgeType.Reads);
         return condition;
     }
-    const cdTrue = { id: name.info.id, when: true };
+    const cdTrue = [{ id: name.info.id, when: true }];
     const remainingInputs = (0, linker_1.linkInputs)((0, reference_to_maybe_1.makeAllMaybe)(body.unknownReferences, information.graph, information.environment, false, cdTrue).concat((0, reference_to_maybe_1.makeAllMaybe)(body.in, information.graph, information.environment, false, cdTrue)), information.environment, condition.in.concat(condition.unknownReferences), information.graph, true);
     (0, linker_1.linkCircularRedefinitionsWithinALoop)(information.graph, (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(information.graph, condition.in)), body.out);
     (0, linker_1.reapplyLoopExitPoints)(body.exitPoints, body.in.concat(body.out, body.unknownReferences));
@@ -81,7 +82,8 @@ function processWhileLoop(name, args, rootId, data) {
         entryPoint: name.info.id,
         exitPoints: (0, info_1.filterOutLoopExitPoints)(body.exitPoints),
         graph: information.graph,
-        environment: information.environment
+        environment: information.environment,
+        hooks: condition.hooks.concat(body.hooks)
     };
 }
 //# sourceMappingURL=built-in-while-loop.js.map

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

@@ -2,7 +2,7 @@ import { type DataflowInformation } from '../../../../info';
 import { type DataflowProcessorInformation } from '../../../../processor';
 import type { RNode } from '../../../../../r-bridge/lang-4.x/ast/model/model';
 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 { EmptyArgument, type RFunctionArgument } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 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';
@@ -29,6 +29,18 @@ export interface ProcessAllArgumentResult {
     readonly remainingReadInArgs: IdentifierReference[];
     readonly processedArguments: (DataflowInformation | undefined)[];
 }
+/**
+ * Converts function arguments into function argument references for a function call vertex.
+ * Please be aware, that the ids here are those inferred from the AST, not from the dataflow graph!
+ * This function also works after the arguments were unpacked, e.g., by {@link tryUnpackNoNameArg}.
+ * @see convertFnArgument
+ */
+export declare function convertFnArguments<OtherInfo>(args: readonly (typeof EmptyArgument | RNode<OtherInfo & ParentInformation>)[]): FunctionArgument[];
+/**
+ * Transforms a function argument into a function argument reference for a function call vertex.
+ * Please be aware, that the ids here are those inferred from the AST, not from the dataflow graph!
+ */
+export declare function convertFnArgument<OtherInfo>(arg: typeof EmptyArgument | RNode<OtherInfo & ParentInformation>): FunctionArgument;
 /**
  * Processes all arguments for a function call, updating the given final graph and environment.
  */

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

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertFnArguments = convertFnArguments;
+exports.convertFnArgument = convertFnArgument;
 exports.processAllArguments = processAllArguments;
 exports.patchFunctionCall = patchFunctionCall;
 const info_1 = require("../../../../info");
@@ -20,7 +22,7 @@ function forceVertexArgumentValueReferences(rootId, value, graph, env) {
     if (valueVertex.tag !== vertex_1.VertexType.Value) {
         if (valueVertex.tag === vertex_1.VertexType.FunctionDefinition) {
             for (const exit of valueVertex.exitPoints) {
-                graph.addEdge(rootId, exit, edge_1.EdgeType.Reads);
+                graph.addEdge(rootId, exit.nodeId, edge_1.EdgeType.Reads);
             }
         }
         else {
@@ -42,6 +44,35 @@ function forceVertexArgumentValueReferences(rootId, value, graph, env) {
         }
     }
 }
+/**
+ * Converts function arguments into function argument references for a function call vertex.
+ * Please be aware, that the ids here are those inferred from the AST, not from the dataflow graph!
+ * This function also works after the arguments were unpacked, e.g., by {@link tryUnpackNoNameArg}.
+ * @see convertFnArgument
+ */
+function convertFnArguments(args) {
+    return args.map(arg => convertFnArgument(arg));
+}
+/**
+ * Transforms a function argument into a function argument reference for a function call vertex.
+ * Please be aware, that the ids here are those inferred from the AST, not from the dataflow graph!
+ */
+function convertFnArgument(arg) {
+    if (arg === r_function_call_1.EmptyArgument) {
+        return r_function_call_1.EmptyArgument;
+    }
+    else if (!arg.name || arg.type !== type_1.RType.Argument) {
+        return { nodeId: arg.info.id, controlDependencies: undefined, type: identifier_1.ReferenceType.Argument };
+    }
+    else {
+        return {
+            nodeId: arg.info.id,
+            name: arg.name.content,
+            controlDependencies: undefined,
+            type: identifier_1.ReferenceType.Argument
+        };
+    }
+}
 /**
  * Processes all arguments for a function call, updating the given final graph and environment.
  */
@@ -117,7 +148,7 @@ function patchFunctionCall({ nextGraph, rootId, name, data, argumentProcessResul
         environment: data.environment,
         /* will be overwritten accordingly */
         onlyBuiltin: false,
-        cds: data.controlDependencies,
+        controlDependencies: 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

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

@@ -1,5 +1,5 @@
 import { type DataflowProcessorInformation } from '../../../../processor';
-import { type DataflowInformation } from '../../../../info';
+import type { DataflowInformation } from '../../../../info';
 import { type ForceArguments } from './common';
 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';
@@ -7,6 +7,7 @@ import type { RFunctionArgument } from '../../../../../r-bridge/lang-4.x/ast/mod
 import type { NodeId } from '../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { RNode } from '../../../../../r-bridge/lang-4.x/ast/model/model';
 import { type IdentifierReference } from '../../../../environments/identifier';
+import type { FunctionArgument } from '../../../../graph/graph';
 import { DataflowGraph } from '../../../../graph/graph';
 import { type ContainerIndicesCollection, type FunctionOriginInformation } from '../../../../graph/vertex';
 export interface ProcessKnownFunctionCallInput<OtherInfo> extends ForceArguments {
@@ -22,12 +23,23 @@ 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;
+    /** The origin to use for the function being called. */
     readonly origin: FunctionOriginInformation | 'default';
 }
+/** The result of processing a known function call. */
 export interface ProcessKnownFunctionCallResult {
+    /** This is the overall information about the function call itself. */
     readonly information: DataflowInformation;
+    /** The processed arguments in order, they are included in the information but sometimes useful separately. */
     readonly processedArguments: readonly (DataflowInformation | undefined)[];
+    /** A reference to the function being called. */
     readonly fnRef: IdentifierReference;
+    /**
+     * The arguments as recorded on the function call vertex.
+     * They are also part of the information via the function call vertex adde, but sometimes useful separately.
+     * For example, together with {@link pMatch} to do custom parameter matching.
+     */
+    readonly callArgs: readonly FunctionArgument[];
 }
 /**
  * Marks the given arguments as being involved in R's non-standard evaluation.

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

@@ -48,8 +48,8 @@ function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = fal
         name: functionCallName,
         /* will be overwritten accordingly */
         onlyBuiltin: false,
-        cds: data.controlDependencies,
-        args: reverseOrder ? callArgs.reverse() : callArgs,
+        controlDependencies: data.controlDependencies,
+        args: reverseOrder ? callArgs.toReversed() : callArgs,
         indicesCollection: indicesCollection,
         origin: origin === 'default' ? ['function'] : [origin]
     }, data.ctx.env.makeCleanEnv());
@@ -59,6 +59,30 @@ function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = fal
     const inIds = remainingReadInArgs;
     const fnRef = { nodeId: rootId, name: functionCallName, controlDependencies: data.controlDependencies, type: identifier_1.ReferenceType.Function };
     inIds.push(fnRef);
+    // if force args is not none, we need to collect all non-default exit points from our arguments!
+    let exitPoints = undefined;
+    if (forceArgs === 'all') {
+        const nonDefaults = processedArguments.flatMap(p => p ? p.exitPoints.filter(ep => ep.type !== 0 /* ExitPointType.Default */) : []);
+        if (nonDefaults.length > 0) {
+            exitPoints = nonDefaults;
+        }
+    }
+    else if (forceArgs) {
+        for (let i = 0; i < forceArgs.length; i++) {
+            if (forceArgs[i]) {
+                const p = processedArguments[i];
+                if (p) {
+                    const nonDefaults = p.exitPoints.filter(ep => ep.type !== 0 /* ExitPointType.Default */);
+                    if (nonDefaults.length > 0) {
+                        if (exitPoints === undefined) {
+                            exitPoints = [];
+                        }
+                        exitPoints.push(...nonDefaults);
+                    }
+                }
+            }
+        }
+    }
     return {
         information: {
             unknownReferences: [],
@@ -68,8 +92,10 @@ function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = fal
             graph: finalGraph,
             environment: finalEnv,
             entryPoint: rootId,
-            exitPoints: [{ nodeId: rootId, type: 0 /* ExitPointType.Default */, controlDependencies: data.controlDependencies }]
+            exitPoints: exitPoints ?? [{ nodeId: rootId, type: 0 /* ExitPointType.Default */, controlDependencies: data.controlDependencies }],
+            hooks: functionName.hooks
         },
+        callArgs,
         processedArguments: reverseOrder ? processedArguments.reverse() : processedArguments,
         fnRef
     };

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

@@ -20,6 +20,7 @@ function mergeInformation(info, newInfo) {
         environment: (0, append_1.appendEnvironment)(info.environment, newInfo.environment),
         entryPoint: newInfo.entryPoint,
         exitPoints: info.exitPoints.concat(newInfo.exitPoints),
+        hooks: info.hooks.concat(newInfo.hooks)
     };
 }
 function processDefaultFunctionProcessor(information, name, args, rootId, data) {
@@ -48,7 +49,7 @@ function processNamedCall(name, args, rootId, data) {
     let builtIn = false;
     for (const resolvedFunction of resolved) {
         if (resolvedFunction.type === identifier_1.ReferenceType.BuiltInFunction && typeof resolvedFunction.processor === 'function') {
-            builtIn = true;
+            builtIn ||= resolvedFunction.config?.libFn !== true;
             information = mergeInformation(information, resolvedFunction.processor(name, args, rootId, data));
         }
         else {

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

@@ -23,8 +23,8 @@ function processUnnamedFunctionCall(functionCall, data) {
     const calledRootId = functionCall.calledFunction.info.id;
     const functionCallName = `${exports.UnnamedFunctionCallPrefix}${functionRootId}`;
     logger_1.dataflowLogger.debug(`Using ${functionRootId} as root for the unnamed function call`);
-    // we know that it calls the toplevel:
-    finalGraph.addEdge(functionRootId, calledRootId, edge_1.EdgeType.Calls | edge_1.EdgeType.Reads);
+    // we know that it reads the toplevel:
+    finalGraph.addEdge(functionRootId, calledRootId, edge_1.EdgeType.Reads);
     // keep the defined function
     finalGraph.mergeWith(calledFunction.graph);
     const { finalEnv, callArgs, remainingReadInArgs } = (0, common_1.processAllArguments)({
@@ -42,12 +42,13 @@ function processUnnamedFunctionCall(functionCall, data) {
         name: functionCallName,
         /* can never be a direct built-in-call */
         onlyBuiltin: false,
-        cds: data.controlDependencies,
+        controlDependencies: data.controlDependencies,
         args: callArgs, // same reference
         origin: [exports.UnnamedFunctionCallOrigin]
     }, data.ctx.env.makeCleanEnv());
     let inIds = remainingReadInArgs;
     inIds.push({ nodeId: functionRootId, name: functionCallName, controlDependencies: data.controlDependencies, type: identifier_1.ReferenceType.Function });
+    // if we just call a nested fdef
     if (functionCall.calledFunction.type === type_1.RType.FunctionDefinition) {
         (0, linker_1.linkArgumentsOnCall)(callArgs, functionCall.calledFunction.parameters, finalGraph);
     }
@@ -61,7 +62,8 @@ function processUnnamedFunctionCall(functionCall, data) {
         graph: finalGraph,
         environment: finalEnv,
         entryPoint: functionCall.info.id,
-        exitPoints: calledFunction.exitPoints
+        exitPoints: calledFunction.exitPoints,
+        hooks: calledFunction.hooks,
     };
 }
 //# sourceMappingURL=unnamed-call-handling.js.map

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

@@ -33,27 +33,28 @@ function processFunctionArgument(argument, data) {
         graph.addVertex({
             tag: vertex_1.VertexType.Use,
             id: argument.info.id,
-            cds: data.controlDependencies
+            controlDependencies: data.controlDependencies
         }, data.ctx.env.makeCleanEnv());
         entryPoint = argument.info.id;
     }
-    const ingoingRefs = [...value?.unknownReferences ?? [], ...value?.in ?? [], ...(name === undefined ? [] : [...name.in])];
+    const ingoingRefs = value ? value.unknownReferences.concat(value.in, name?.in ?? []) : name?.in;
     if (entryPoint && argument.value?.type === type_1.RType.FunctionDefinition) {
         graph.addEdge(entryPoint, argument.value.info.id, edge_1.EdgeType.Reads);
     }
-    else if (argumentName) {
+    else if (argumentName && ingoingRefs) {
         // we only need to link against those which are not already bound to another function call argument
-        linkReadsForArgument(argument, [...ingoingRefs, ...value?.out ?? [] /* value may perform definitions */], graph);
+        linkReadsForArgument(argument, value ? ingoingRefs.concat(value.out /* value may perform definitions */) : ingoingRefs, graph);
     }
     return {
         unknownReferences: [],
         // active nodes of the name will be lost as they are only used to reference the corresponding parameter
-        in: ingoingRefs.filter(r => r.name !== undefined),
+        in: ingoingRefs?.filter(r => r.name !== undefined) ?? [],
         out: [...value?.out ?? [], ...(name?.out ?? [])],
         graph: graph,
         environment: value?.environment ?? data.environment,
         entryPoint: entryPoint ?? argument.info.id,
-        exitPoints: value?.exitPoints ?? name?.exitPoints ?? [{ nodeId: argument.info.id, type: 0 /* ExitPointType.Default */, controlDependencies: data.controlDependencies }]
+        exitPoints: value?.exitPoints ?? name?.exitPoints ?? [{ nodeId: argument.info.id, type: 0 /* ExitPointType.Default */, controlDependencies: data.controlDependencies }],
+        hooks: []
     };
 }
 //# sourceMappingURL=process-argument.js.map

package/dataflow/internal/process/functions/process-parameter.js

@@ -43,7 +43,8 @@ function processFunctionParameter(parameter, data) {
         graph: graph,
         environment: environment,
         entryPoint: parameter.info.id,
-        exitPoints: [{ nodeId: parameter.info.id, type: 0 /* ExitPointType.Default */, controlDependencies: data.controlDependencies }]
+        exitPoints: [{ nodeId: parameter.info.id, type: 0 /* ExitPointType.Default */, controlDependencies: data.controlDependencies }],
+        hooks: []
     };
 }
 //# sourceMappingURL=process-parameter.js.map

package/dataflow/internal/process/process-named-call.d.ts

@@ -1,9 +1,9 @@
 import type { DataflowProcessorInformation } from '../../processor';
 import type { DataflowInformation } from '../../info';
-import type { Base, RNode, Location } from '../../../r-bridge/lang-4.x/ast/model/model';
+import type { RAstNodeBase, RNode, Location } from '../../../r-bridge/lang-4.x/ast/model/model';
 import type { ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { EmptyArgument } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 /**
  * Helper function for {@link processNamedCall} using the given `functionName` as the name of the function.
  */
-export declare function processAsNamedCall<OtherInfo>({ info, lexeme, location }: RNode<OtherInfo & ParentInformation> & Base<OtherInfo> & Location, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, name: string, args: readonly (RNode<OtherInfo & ParentInformation> | typeof EmptyArgument | undefined)[]): DataflowInformation;
+export declare function processAsNamedCall<OtherInfo>({ info, lexeme, location }: RNode<OtherInfo & ParentInformation> & RAstNodeBase<OtherInfo> & Location, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, name: string, args: readonly (RNode<OtherInfo & ParentInformation> | typeof EmptyArgument | undefined)[]): DataflowInformation;

package/dataflow/internal/process/process-symbol.js

@@ -21,10 +21,11 @@ function processSymbol(symbol, data) {
         graph: new graph_1.DataflowGraph(data.completeAst.idMap).addVertex({
             tag: vertex_1.VertexType.Use,
             id: symbol.info.id,
-            cds: data.controlDependencies
+            controlDependencies: data.controlDependencies
         }, data.ctx.env.makeCleanEnv()),
         entryPoint: symbol.info.id,
-        exitPoints: [{ nodeId: symbol.info.id, type: 0 /* ExitPointType.Default */, controlDependencies: data.controlDependencies }]
+        exitPoints: [{ nodeId: symbol.info.id, type: 0 /* ExitPointType.Default */, controlDependencies: data.controlDependencies }],
+        hooks: []
     };
 }
 //# sourceMappingURL=process-symbol.js.map

package/dataflow/internal/process/process-value.d.ts

@@ -2,6 +2,7 @@ import { type DataflowInformation } from '../../info';
 import type { DataflowProcessorInformation } from '../../processor';
 import type { RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 /**
- *
+ * Processes a value node in the AST for dataflow analysis.
+ * For example, literals like numbers.
  */
-export declare function processValue<OtherInfo>({ info: { id } }: RNodeWithParent, { controlDependencies, completeAst: { idMap }, ctx: { env }, environment }: DataflowProcessorInformation<OtherInfo>): DataflowInformation;
+export declare function processValue<OtherInfo>({ info: { id } }: RNodeWithParent, { controlDependencies, completeAst: { idMap }, environment }: DataflowProcessorInformation<OtherInfo>): DataflowInformation;