@eagleoutice/flowr 2.8.5 → 2.8.7

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

@@ -14,8 +14,9 @@ const general_1 = require("../../../../../eval/values/general");
 const r_value_1 = require("../../../../../eval/values/r-value");
 const log_1 = require("../../../../../../util/log");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
+const built_in_1 = require("../../../../../environments/built-in");
 /**
- *
+ * Process an apply call like `vapply` or `mapply`.
  */
 function processApply(name, args, rootId, data, config) {
     const { indexOfFunction = 1, nameOfFunctionArgument, unquoteFunction, resolveInEnvironment, resolveValue } = config;
@@ -23,14 +24,14 @@ function processApply(name, args, rootId, data, config) {
     const forceArgsMask = new Array(indexOfFunction).fill(false);
     forceArgsMask.push(true);
     const resFn = (0, known_call_handling_1.processKnownFunctionCall)({
-        name, args, rootId, data, forceArgs: forceArgsMask, origin: 'builtin:apply'
+        name, args, rootId, data, forceArgs: forceArgsMask, origin: built_in_1.BuiltInProcName.Apply
     });
     let information = resFn.information;
     const processedArguments = resFn.processedArguments;
     let index = indexOfFunction;
     /* search, if one of the arguments actually contains the argument name if given in the config */
     if (nameOfFunctionArgument !== undefined) {
-        const mayFn = args.findIndex(arg => arg !== r_function_call_1.EmptyArgument && arg.name && arg.name.content === nameOfFunctionArgument);
+        const mayFn = args.findIndex(arg => arg !== r_function_call_1.EmptyArgument && arg.name?.content === nameOfFunctionArgument);
         if (mayFn >= 0) {
             index = mayFn;
         }
@@ -69,7 +70,7 @@ function processApply(name, args, rootId, data, config) {
         functionName = val.content.str;
         information = {
             ...information,
-            in: [...information.in, { type: identifier_1.ReferenceType.Function, name: functionName, controlDependencies: data.controlDependencies, nodeId: functionId }]
+            in: [...information.in, { type: identifier_1.ReferenceType.Function, name: functionName, cds: data.cds, nodeId: functionId }]
         };
     }
     else if (val.type === type_1.RType.Symbol) {
@@ -99,7 +100,7 @@ function processApply(name, args, rootId, data, config) {
         if (arg && counterpart !== r_function_call_1.EmptyArgument) {
             return {
                 name: counterpart.name?.content,
-                controlDependencies: data.controlDependencies,
+                cds: data.cds,
                 type: identifier_1.ReferenceType.Argument,
                 nodeId: arg.entryPoint
             };
@@ -118,9 +119,9 @@ function processApply(name, args, rootId, data, config) {
             name: functionName,
             /* can never be a direct built-in-call */
             onlyBuiltin: false,
-            controlDependencies: data.controlDependencies,
+            cds: data.cds,
             args: allOtherArguments, // same reference
-            origin: ['function']
+            origin: [built_in_1.BuiltInProcName.Function]
         }, data.ctx.env.makeCleanEnv());
         information.graph.addEdge(rootId, rootFnId, edge_1.EdgeType.Calls | edge_1.EdgeType.Reads);
         information.graph.addEdge(rootId, functionId, edge_1.EdgeType.Calls | edge_1.EdgeType.Argument);
@@ -128,7 +129,7 @@ function processApply(name, args, rootId, data, config) {
             ...information,
             in: [
                 ...information.in,
-                { type: identifier_1.ReferenceType.Function, name: functionName, controlDependencies: data.controlDependencies, nodeId: functionId }
+                { type: identifier_1.ReferenceType.Function, name: functionName, cds: data.cds, nodeId: functionId }
             ]
         };
         const dfVert = information.graph.getVertex(rootId);
@@ -167,8 +168,8 @@ function processApply(name, args, rootId, data, config) {
             args: allOtherArguments,
             environment: resolveInEnvironment === 'global' ? undefined : data.environment,
             onlyBuiltin: resolveInEnvironment === 'global',
-            controlDependencies: data.controlDependencies,
-            origin: ['function']
+            cds: data.cds,
+            origin: [built_in_1.BuiltInProcName.Function]
         });
     }
     for (const arg of processedArguments) {

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

@@ -64,7 +64,7 @@ function tryReplacementPassingIndices(rootId, functionName, data, name, args, in
         location: functionName.location,
         namespace: undefined
     }, (0, make_argument_1.wrapArgumentsUnnamed)(args, data.completeAst.idMap), functionName.info.id, data, {
-        ...(resolved[0].config ?? {}),
+        ...resolved[0].config,
         activeIndices: indices,
         assignRootId: rootId
     });
@@ -80,16 +80,16 @@ 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);
+        const name = arg === r_function_call_1.EmptyArgument ? undefined : arg.name?.content;
+        if (name === undefined) {
+            argsWithoutNames.push(arg);
         }
         else {
-            argsWithoutNames.push(arg);
+            argsWithNames.set(name, 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);
+    const source = argsWithNames.get(config.source.name) ?? (config.source.idx === undefined ? undefined : argsWithoutNames[config.source.idx]);
+    const target = argsWithNames.get(config.target.name) ?? (config.target.idx === undefined ? undefined : argsWithoutNames[config.target.idx]);
     if (source && target) {
         args = [target, source];
     }
@@ -123,7 +123,7 @@ args, rootId, data, config) {
                 data,
                 reverseOrder: !config.swapSourceAndTarget,
                 forceArgs: config.forceArgs,
-                origin: 'builtin:assignment'
+                origin: built_in_1.BuiltInProcName.Assignment
             });
             return processAssignmentToSymbol({
                 ...config,
@@ -149,7 +149,7 @@ args, rootId, data, config) {
                         data,
                         reverseOrder: !config.swapSourceAndTarget,
                         forceArgs: config.forceArgs,
-                        origin: 'builtin:assignment'
+                        origin: built_in_1.BuiltInProcName.Assignment
                     });
                     return processAssignmentToSymbol({
                         ...config,
@@ -187,7 +187,7 @@ args, rootId, data, config) {
                 data,
                 reverseOrder: !config.swapSourceAndTarget,
                 forceArgs: config.forceArgs,
-                origin: 'builtin:assignment'
+                origin: built_in_1.BuiltInProcName.Assignment
             });
             return processAssignmentToSymbol({
                 ...config,
@@ -207,7 +207,7 @@ args, rootId, data, config) {
     logger_1.dataflowLogger.warn(`Assignment ${name.content} has an unknown target type ${target.type} => unknown impact`);
     const info = (0, known_call_handling_1.processKnownFunctionCall)({
         name, args: effectiveArgs, rootId, data, forceArgs: config.forceArgs,
-        origin: 'builtin:assignment'
+        origin: built_in_1.BuiltInProcName.Assignment
     }).information;
     (0, unknown_side_effect_1.handleUnknownSideEffect)(info.graph, info.environment, rootId);
     return info;
@@ -229,7 +229,7 @@ function produceWrittenNodes(rootId, target, referenceType, data, makeMaybe, val
                 name: ref.name,
                 type: referenceType,
                 definedAt: rootId,
-                controlDependencies: data.controlDependencies ?? (makeMaybe ? [] : undefined),
+                cds: data.cds ?? (makeMaybe ? [] : undefined),
                 value
             });
         }
@@ -257,7 +257,7 @@ function processAssignmentToString(target, args, name, rootId, data, config, sou
         data,
         reverseOrder: !config.swapSourceAndTarget,
         forceArgs: config.forceArgs,
-        origin: 'builtin:assignment'
+        origin: built_in_1.BuiltInProcName.Assignment
     });
     return processAssignmentToSymbol({
         ...config,
@@ -350,17 +350,17 @@ function processAssignmentToSymbol(config) {
             name: targetName,
             type: referenceType,
             definedAt: rootId,
-            controlDependencies: data.controlDependencies ?? (makeMaybe ? [] : undefined),
+            cds: data.cds ?? (makeMaybe ? [] : undefined),
             value: aliases
         }]
         : produceWrittenNodes(rootId, targetArg, referenceType, data, makeMaybe ?? false, aliases);
-    if (writeNodes.length !== 1 && log_1.log.settings.minLevel <= 4 /* LogLevel.Warn */) {
+    if (writeNodes.length !== 1 && log_1.log.settings.minLevel >= 4 /* LogLevel.Warn */) {
         log_1.log.warn(`Unexpected write number in assignment: ${JSON.stringify(writeNodes)}`);
     }
     // we drop the first arg which we use to pass along arguments :D
     const readFromSourceWritten = sourceArg.out.slice(1);
     const readTargets = [
-        { nodeId: rootId, name: nameOfAssignmentFunction, controlDependencies: data.controlDependencies, type: identifier_1.ReferenceType.Function }
+        { nodeId: rootId, name: nameOfAssignmentFunction, cds: data.cds, type: identifier_1.ReferenceType.Function }
     ].concat(sourceArg.unknownReferences, sourceArg.in, targetName ? targetArg.in : targetArg.in.filter(i => i.nodeId !== targetId), readFromSourceWritten);
     information.environment = (0, overwrite_1.overwriteEnvironment)(sourceArg.environment, targetArg.environment);
     // install assigned variables in environment
@@ -376,7 +376,10 @@ function processAssignmentToSymbol(config) {
         information.graph.addEdge(rootId, source.info.id, edge_1.EdgeType.Reads);
     }
     return {
-        ...information,
+        environment: information.environment,
+        graph: information.graph,
+        exitPoints: information.exitPoints,
+        hooks: information.hooks,
         unknownReferences: [],
         entryPoint: rootId,
         in: readTargets,

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

@@ -5,7 +5,7 @@ import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/
 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 call to `eval()`, trying to resolve the code being evaluated if possible.
  */
 export declare function processEvalCall<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     /** should this produce an explicit source function call in the graph? */

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

@@ -18,8 +18,9 @@ const string_constants_1 = require("../../../../../eval/values/string/string-con
 const unknown_side_effect_1 = require("../../../../../graph/unknown-side-effect");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 const arrays_1 = require("../../../../../../util/collections/arrays");
+const built_in_1 = require("../../../../../environments/built-in");
 /**
- *
+ * Process a call to `eval()`, trying to resolve the code being evaluated if possible.
  */
 function processEvalCall(name, args, rootId, data, config) {
     if (args.length !== 1 || args[0] === r_function_call_1.EmptyArgument || !args[0].value) {
@@ -27,7 +28,7 @@ function processEvalCall(name, args, rootId, data, config) {
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
     const information = config.includeFunctionCall ?
-        (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: [true], origin: 'builtin:eval' }).information
+        (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: [true], origin: built_in_1.BuiltInProcName.Eval }).information
         : (0, info_1.initializeCleanDataflowInformation)(rootId, data);
     const evalArgument = args[0];
     if (config.includeFunctionCall) {
@@ -43,7 +44,7 @@ function processEvalCall(name, args, rootId, data, config) {
         const idGenerator = (0, decorate_1.sourcedDeterministicCountingIdGenerator)(name.lexeme + '::' + rootId, name.location);
         data = {
             ...data,
-            controlDependencies: [...(data.controlDependencies ?? []), { id: rootId, when: true }]
+            cds: [...(data.cds ?? []), { id: rootId, when: true }]
         };
         const originalInfo = { ...information };
         const result = [];

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

@@ -9,6 +9,6 @@ import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/
 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';
 /**
- *
+ * Processes a list of expressions joining their dataflow graphs accordingly.
  */
 export declare function processExpressionList<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-expression-list.js

@@ -23,10 +23,10 @@ function linkReadNameToWriteIfPossible(read, environments, listEnvironments, rem
     const readName = read.name && dotDotDotAccess.test(read.name) ? '...' : read.name;
     const probableTarget = readName ? (0, resolve_by_name_1.resolveByName)(readName, environments, read.type) : undefined;
     // record if at least one has not been defined
-    if (probableTarget === undefined || probableTarget.some(t => !listEnvironments.has(t.nodeId) || !(0, info_1.happensInEveryBranch)(t.controlDependencies))) {
+    if (probableTarget === undefined || probableTarget.some(t => !listEnvironments.has(t.nodeId) || !(0, info_1.happensInEveryBranch)(t.cds))) {
         const has = remainingRead.get(readName);
         if (has) {
-            if (!has?.some(h => h.nodeId === read.nodeId && h.name === read.name && h.controlDependencies === read.controlDependencies)) {
+            if (!has?.some(h => h.nodeId === read.nodeId && h.name === read.name && h.cds === read.cds)) {
                 has.push(read);
             }
         }
@@ -81,7 +81,7 @@ function updateSideEffectsForCalledFunctions(calledEnvs, inputEnvironment, nextG
                     };
                 }
                 if (callDependencies === null) {
-                    callDependencies = nextGraph.getVertex(functionCall, true)?.controlDependencies;
+                    callDependencies = nextGraph.getVertex(functionCall, true)?.cds;
                 }
                 inputEnvironment = (0, overwrite_1.overwriteEnvironment)(inputEnvironment, environment, callDependencies);
             }
@@ -90,7 +90,7 @@ function updateSideEffectsForCalledFunctions(calledEnvs, inputEnvironment, nextG
     return inputEnvironment;
 }
 /**
- *
+ * Processes a list of expressions joining their dataflow graphs accordingly.
  */
 function processExpressionList(name, args, rootId, data) {
     const expressions = args.map(unpack_argument_1.unpackNonameArg);
@@ -102,7 +102,7 @@ function processExpressionList(name, args, rootId, data) {
     const nextGraph = new graph_1.DataflowGraph(data.completeAst.idMap);
     let out = [];
     const exitPoints = [];
-    const activeCdsAtStart = data.controlDependencies;
+    const activeCdsAtStart = data.cds;
     const invertExitCds = [];
     const processedExpressions = [];
     let defaultReturnExpr = undefined;
@@ -154,10 +154,10 @@ function processExpressionList(name, args, rootId, data) {
         }
     }
     if (defaultReturnExpr) {
-        exitPoints.push(data.controlDependencies ? {
+        exitPoints.push(data.cds ? {
             type: 0 /* ExitPointType.Default */,
             nodeId: defaultReturnExpr.entryPoint,
-            controlDependencies: data.controlDependencies
+            cds: data.cds
         } : {
             type: 0 /* ExitPointType.Default */,
             nodeId: defaultReturnExpr.entryPoint
@@ -167,14 +167,14 @@ function processExpressionList(name, args, rootId, data) {
     const rootNode = data.completeAst.idMap.get(rootId);
     const withGroup = rootNode?.grouping;
     if (withGroup) {
-        ingoing.push({ nodeId: rootId, name: name.content, controlDependencies: data.controlDependencies, type: identifier_1.ReferenceType.Function });
+        ingoing.push({ nodeId: rootId, name: name.content, cds: data.cds, type: identifier_1.ReferenceType.Function });
         (0, common_1.patchFunctionCall)({
             nextGraph,
             rootId,
             name,
             data,
             argumentProcessResult: processedExpressions,
-            origin: 'builtin:expression-list'
+            origin: built_in_1.BuiltInProcName.ExpressionList
         });
         nextGraph.addEdge(rootId, (0, built_in_1.builtInId)('{'), edge_1.EdgeType.Reads | edge_1.EdgeType.Calls);
         // process all exit points as potential returns:

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

@@ -5,6 +5,10 @@ import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 /**
- *
+ * Processes a for-loop call: `for(<variable> in <vector>) <body>`
+ * desugared as:
+ * ```r
+ * `for`(<variable>, <vector>, <body>)
+ * ```
  */
 export declare function processForLoop<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-for-loop.js

@@ -15,8 +15,13 @@ const append_1 = require("../../../../../environments/append");
 const edge_1 = require("../../../../../graph/edge");
 const identifier_1 = require("../../../../../environments/identifier");
 const reference_to_maybe_1 = require("../../../../../environments/reference-to-maybe");
+const built_in_1 = require("../../../../../environments/built-in");
 /**
- *
+ * Processes a for-loop call: `for(<variable> in <vector>) <body>`
+ * desugared as:
+ * ```r
+ * `for`(<variable>, <vector>, <body>)
+ * ```
  */
 function processForLoop(name, args, rootId, data) {
     if (args.length !== 3) {
@@ -32,14 +37,14 @@ function processForLoop(name, args, rootId, data) {
     }
     const variable = (0, processor_1.processDataflowFor)(variableArg, data);
     // this should not be able to exit always!
-    const originalDependency = data.controlDependencies;
+    const originalDependency = data.cds;
     let headEnvironments = (0, overwrite_1.overwriteEnvironment)(vector.environment, variable.environment);
     const headGraph = variable.graph.mergeWith(vector.graph);
     const writtenVariable = variable.unknownReferences.concat(variable.in);
     for (const write of writtenVariable) {
         headEnvironments = (0, define_1.define)({ ...write, definedAt: name.info.id, type: identifier_1.ReferenceType.Variable }, false, headEnvironments, data.ctx.config);
     }
-    data = { ...data, controlDependencies: [...data.controlDependencies ?? [], { id: name.info.id, when: true }], environment: headEnvironments };
+    data = { ...data, cds: [...data.cds ?? [], { id: name.info.id, when: true }], environment: headEnvironments };
     const body = (0, processor_1.processDataflowFor)(bodyArg, data);
     const nextGraph = headGraph.mergeWith(body.graph);
     const outEnvironment = (0, append_1.appendEnvironment)(headEnvironments, body.environment);
@@ -57,9 +62,9 @@ function processForLoop(name, args, rootId, data) {
         nextGraph,
         rootId,
         name,
-        data: { ...data, controlDependencies: originalDependency },
+        data: { ...data, cds: originalDependency },
         argumentProcessResult: [variable, vector, body],
-        origin: 'builtin:for-loop'
+        origin: built_in_1.BuiltInProcName.ForLoop
     });
     /* mark the last argument as nse */
     nextGraph.addEdge(rootId, body.entryPoint, edge_1.EdgeType.NonStandardEvaluation);
@@ -68,7 +73,7 @@ function processForLoop(name, args, rootId, data) {
     return {
         unknownReferences: [],
         // we only want those not bound by a local variable
-        in: [{ nodeId: rootId, name: name.content, controlDependencies: originalDependency, type: identifier_1.ReferenceType.Function }, ...vector.unknownReferences, ...[...nameIdShares.values()].flat()],
+        in: [{ nodeId: rootId, name: name.content, cds: originalDependency, type: identifier_1.ReferenceType.Function }, ...vector.unknownReferences, ...[...nameIdShares.values()].flat()],
         out: outgoing,
         graph: nextGraph,
         entryPoint: name.info.id,

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

@@ -19,13 +19,6 @@ export declare function processFunctionDefinition<OtherInfo>(name: RSymbol<Other
  * @returns active environment within the function definition / call
  */
 export declare function retrieveActiveEnvironment(callerEnvironment: REnvironmentInformation | undefined, baseEnvironment: REnvironmentInformation, ctx: ReadOnlyFlowrAnalyzerContext): REnvironmentInformation;
-/**
- * Update the closure links of all nested function definitions
- * @param graph          - dataflow graph to collect the function definitions from and to update the closure links for
- * @param outEnvironment - active environment on resolving closures (i.e., exit of the function definition)
- * @param fnId           - id of the function definition to update the closure links for
- */
-export declare function updateNestedFunctionClosures(graph: DataflowGraph, outEnvironment: REnvironmentInformation, fnId: NodeId): void;
 /**
  * Update the closure links of all nested function calls, this is probably to be done once at the end of the script
  * @param graph          - dataflow graph to collect the function calls from and to update the closure links for

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processFunctionDefinition = processFunctionDefinition;
 exports.retrieveActiveEnvironment = retrieveActiveEnvironment;
-exports.updateNestedFunctionClosures = updateNestedFunctionClosures;
 exports.updateNestedFunctionCalls = updateNestedFunctionCalls;
 const processor_1 = require("../../../../../processor");
 const info_1 = require("../../../../../info");
@@ -33,7 +32,7 @@ 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]);
+    const bodyArg = (0, unpack_argument_1.unpackNonameArg)(args.at(-1));
     (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
@@ -79,7 +78,7 @@ function processFunctionDefinition(name, args, rootId, data) {
                 tag: vertex_1.VertexType.Use,
                 id: read.nodeId,
                 environment: undefined,
-                controlDependencies: undefined
+                cds: undefined
             }, data.ctx.env.makeCleanEnv());
         }
     }
@@ -94,6 +93,20 @@ function processFunctionDefinition(name, args, rootId, data) {
         environment: outEnvironment,
         hooks: compactedHooks
     };
+    updateS3Dispatches(subgraph, parameters.map(p => {
+        if (p === r_function_call_1.EmptyArgument) {
+            return r_function_call_1.EmptyArgument;
+        }
+        else if (!p.name && p.value && p.value.type === type_1.RType.Parameter) {
+            return { type: identifier_1.ReferenceType.Argument, cds: data.cds, nodeId: p.value.name.info.id, name: p.value.name.content };
+        }
+        else if (p.name) {
+            return { type: identifier_1.ReferenceType.Argument, cds: data.cds, nodeId: p.name.info.id, name: p.name.content };
+        }
+        else {
+            return r_function_call_1.EmptyArgument;
+        }
+    }));
     updateNestedFunctionClosures(subgraph, outEnvironment, name.info.id);
     const exitPoints = body.exitPoints;
     const readParams = {};
@@ -119,7 +132,7 @@ function processFunctionDefinition(name, args, rootId, data) {
         tag: vertex_1.VertexType.FunctionDefinition,
         id: name.info.id,
         environment: (0, scoping_1.popLocalEnvironment)(outEnvironment),
-        controlDependencies: data.controlDependencies,
+        cds: data.cds,
         params: readParams,
         subflow: flow,
         exitPoints: afterHookExitPoints
@@ -157,6 +170,22 @@ function retrieveActiveEnvironment(callerEnvironment, baseEnvironment, ctx) {
     }
     return (0, overwrite_1.overwriteEnvironment)(baseEnvironment, callerEnvironment);
 }
+function updateS3Dispatches(graph, myArgs) {
+    for (const [, info] of graph.vertices(false)) {
+        if (info.tag !== vertex_1.VertexType.FunctionCall || !info.origin.includes(built_in_1.BuiltInProcName.S3Dispatch)) {
+            continue;
+        }
+        if (info.args.length === 0) {
+            info.args = myArgs;
+            for (const arg of myArgs) {
+                // add argument edges
+                if (arg !== r_function_call_1.EmptyArgument) {
+                    graph.addEdge(info.id, arg.nodeId, edge_1.EdgeType.Argument);
+                }
+            }
+        }
+    }
+}
 /**
  * Update the closure links of all nested function definitions
  * @param graph          - dataflow graph to collect the function definitions from and to update the closure links for
@@ -199,7 +228,7 @@ function updateNestedFunctionClosures(graph, outEnvironment, fnId) {
 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)) {
+    for (const [id, { onlyBuiltin, environment, name, args }] of graph.verticesOfType(vertex_1.VertexType.FunctionCall)) {
         if (onlyBuiltin || !name) {
             continue;
         }
@@ -248,6 +277,10 @@ function updateNestedFunctionCalls(graph, outEnvironment) {
             }
             (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Keeping ${remainingIn.length} references to open ref ${id} in closure of function definition ${id}`);
             targetVertex.subflow.in = remainingIn;
+            const linkedParameters = graph.idMap?.get(target);
+            if (linkedParameters?.type === type_1.RType.FunctionDefinition) {
+                (0, linker_1.linkArgumentsOnCall)(args, linkedParameters.parameters, graph);
+            }
         }
     }
 }
@@ -286,7 +319,7 @@ function findPromiseLinkagesForParameters(parameters, readInParameters, paramete
             remainingRead.push(read);
             continue;
         }
-        if (writingOuts[0].controlDependencies === undefined) {
+        if (writingOuts[0].cds === undefined) {
             parameters.addEdge(read, writingOuts[0], edge_1.EdgeType.Reads);
             continue;
         }

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

@@ -8,6 +8,7 @@ const logger_1 = require("../../../../../logger");
 const retriever_1 = require("../../../../../../r-bridge/retriever");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const edge_1 = require("../../../../../graph/edge");
+const built_in_1 = require("../../../../../environments/built-in");
 /**
  * Processes a built-in 'get' function call.
  */
@@ -34,7 +35,7 @@ function processGet(name, args, rootId, data) {
         args: (0, make_argument_1.wrapArgumentsUnnamed)([treatTargetAsSymbol], data.completeAst.idMap),
         rootId,
         data,
-        origin: 'builtin:get'
+        origin: built_in_1.BuiltInProcName.Get
     });
     const firstArg = processedArguments[0];
     if (firstArg) {

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

@@ -4,9 +4,20 @@ import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/node
 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 { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+/** `if(<cond>) <then> else <else>` built-in function configuration, make sure to not reuse indices */
+export interface IfThenElseConfig {
+    args?: {
+        /** the expression to treat as condition, defaults to index 0 */
+        cond: string;
+        /** argument to treat as yes/'then' case, defaults to index 1 */
+        yes: string;
+        /** argument to treat as no/'else' case, defaults to index 2 */
+        no: string;
+    };
+}
 /**
  * Processes an if-then-else built-in function call.
  * For example, `if(cond) thenExpr else elseExpr` and `if(cond) thenExpr`.
  * The arguments will be either `[cond, thenExpr]` or `[cond, thenExpr, elseExpr]`.
  */
-export declare function processIfThenElse<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
+export declare function processIfThenElse<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config?: IfThenElseConfig): DataflowInformation;

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

@@ -13,17 +13,41 @@ const identifier_1 = require("../../../../../environments/identifier");
 const general_1 = require("../../../../../eval/values/general");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 const reference_to_maybe_1 = require("../../../../../environments/reference-to-maybe");
+const linker_1 = require("../../../../linker");
+const r_argument_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument");
+const built_in_1 = require("../../../../../environments/built-in");
+function getArguments(config, args) {
+    let condArg;
+    let thenArg;
+    let otherwiseArg;
+    if (config?.args) {
+        const params = {
+            [config.args.cond]: 'cond',
+            [config.args.yes]: 'yes',
+            [config.args.no]: 'no',
+            '...': '...'
+        };
+        const argMaps = (0, linker_1.invertArgumentMap)((0, linker_1.pMatch)((0, common_1.convertFnArguments)(args), params));
+        condArg = (0, unpack_argument_1.unpackArg)((0, r_argument_1.getArgumentWithId)(args, argMaps.get('cond')?.[0]));
+        thenArg = (0, unpack_argument_1.unpackArg)((0, r_argument_1.getArgumentWithId)(args, argMaps.get('yes')?.[0]));
+        otherwiseArg = (0, unpack_argument_1.unpackArg)((0, r_argument_1.getArgumentWithId)(args, argMaps.get('no')?.[0]));
+    }
+    else {
+        [condArg, thenArg, otherwiseArg] = args.map(e => (0, unpack_argument_1.unpackArg)(e));
+    }
+    return { condArg, thenArg, otherwiseArg };
+}
 /**
  * Processes an if-then-else built-in function call.
  * For example, `if(cond) thenExpr else elseExpr` and `if(cond) thenExpr`.
  * The arguments will be either `[cond, thenExpr]` or `[cond, thenExpr, elseExpr]`.
  */
-function processIfThenElse(name, args, rootId, data) {
+function processIfThenElse(name, args, rootId, data, config) {
     if (args.length !== 2 && args.length !== 3) {
         logger_1.dataflowLogger.warn(`If-then-else ${name.content} has something different from 2 or 3 arguments, skipping`);
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
-    const [condArg, thenArg, otherwiseArg] = args.map(e => (0, unpack_argument_1.unpackNonameArg)(e));
+    const { condArg, thenArg, otherwiseArg } = getArguments(config, args);
     if (condArg === undefined || thenArg === undefined) {
         logger_1.dataflowLogger.warn(`If-then-else ${name.content} has empty condition or then case in ${JSON.stringify(args)}, skipping`);
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
@@ -33,7 +57,7 @@ function processIfThenElse(name, args, rootId, data) {
         logger_1.dataflowLogger.warn(`If-then-else ${rootId} forces exit in condition, skipping rest`);
         return cond;
     }
-    const originalDependency = data.controlDependencies?.slice();
+    const originalDependency = data.cds?.slice();
     // currently we update the cd afterward :sweat:
     data = { ...data, environment: cond.environment };
     let then;
@@ -45,7 +69,7 @@ function processIfThenElse(name, args, rootId, data) {
     if (!conditionIsAlwaysFalse) {
         then = (0, processor_1.processDataflowFor)(thenArg, data);
         if (then.entryPoint) {
-            then.graph.addEdge(name.info.id, then.entryPoint, edge_1.EdgeType.Returns);
+            then.graph.addEdge(rootId, then.entryPoint, edge_1.EdgeType.Returns);
         }
         if (!conditionIsAlwaysTrue) {
             makeThenMaybe = true;
@@ -54,10 +78,10 @@ function processIfThenElse(name, args, rootId, data) {
     let otherwise;
     let makeOtherwiseMaybe = false;
     if (otherwiseArg !== undefined && !conditionIsAlwaysTrue) {
-        data = { ...data, controlDependencies: originalDependency?.slice() };
+        data = { ...data, cds: originalDependency?.slice() };
         otherwise = (0, processor_1.processDataflowFor)(otherwiseArg, data);
         if (otherwise.entryPoint) {
-            otherwise.graph.addEdge(name.info.id, otherwise.entryPoint, edge_1.EdgeType.Returns);
+            otherwise.graph.addEdge(rootId, otherwise.entryPoint, edge_1.EdgeType.Returns);
         }
         if (!conditionIsAlwaysFalse) {
             makeOtherwiseMaybe = true;
@@ -87,17 +111,17 @@ function processIfThenElse(name, args, rootId, data) {
         nextGraph,
         rootId,
         name,
-        data: { ...data, controlDependencies: originalDependency },
+        data: { ...data, cds: originalDependency },
         argumentProcessResult: [cond, then, otherwise],
-        origin: 'builtin:if-then-else'
+        origin: built_in_1.BuiltInProcName.IfThenElse
     });
     // as an if always evaluates its condition, we add a 'reads'-edge
-    nextGraph.addEdge(name.info.id, cond.entryPoint, edge_1.EdgeType.Reads);
-    const exitPoints = (then?.exitPoints ?? []).map(e => ({ ...e, controlDependencies: makeThenMaybe ? [...data.controlDependencies ?? [], { id: rootId, when: true }] : e.controlDependencies }))
-        .concat((otherwise?.exitPoints ?? []).map(e => ({ ...e, controlDependencies: makeOtherwiseMaybe ? [...data.controlDependencies ?? [], { id: rootId, when: false }] : e.controlDependencies })));
+    nextGraph.addEdge(rootId, cond.entryPoint, edge_1.EdgeType.Reads);
+    const exitPoints = (then?.exitPoints ?? []).map(e => ({ ...e, cds: makeThenMaybe ? [...data.cds ?? [], { id: rootId, when: true }] : e.cds }))
+        .concat((otherwise?.exitPoints ?? []).map(e => ({ ...e, cds: makeOtherwiseMaybe ? [...data.cds ?? [], { id: rootId, when: false }] : e.cds })));
     return {
         unknownReferences: [],
-        in: [{ nodeId: rootId, name: name.content, controlDependencies: originalDependency, type: identifier_1.ReferenceType.Function }, ...ingoing],
+        in: [{ nodeId: rootId, name: name.content, cds: originalDependency, type: identifier_1.ReferenceType.Function }, ...ingoing],
         out: outgoing,
         exitPoints,
         entryPoint: rootId,