@eagleoutice/flowr 2.9.14 → 2.10.2

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

@@ -0,0 +1,41 @@
+import type { DataflowProcessorInformation } from '../../../../../processor';
+import type { DataflowInformation } from '../../../../../info';
+import type { PotentiallyEmptyRArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+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';
+interface BuiltInPurrrFormulaConfiguration {
+    /**
+     * Maps the created variable/variable to bind in the formula, to the argument that produces it.
+     * For example:
+     * ```ts
+     * {
+     *      '.x': { index: 0, name: '.x' },
+     *      '.y': { index: 1, name: '.y' }
+     * }
+     * ```
+     */
+    args: Record<string, {
+        index: number;
+        name: string;
+    }>;
+    /**
+     * This represents the special argument that represents the formula.
+     * We map all additional arguments that are not in `ignore` to this list.
+     */
+    '.f': {
+        index: number;
+        name: string;
+    };
+    /** arguments to additionally ignore when mapping the formulae */
+    ignore?: string[];
+    /**
+     * if given, this is a name that indexes into the 'args' map and indicates whatever this function is to return
+     */
+    returnArg?: string;
+}
+/**
+ * Support for R's purr formula: `map(df, ~ .x + 1)`.
+ */
+export declare function processPurrrFormula<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: BuiltInPurrrFormulaConfiguration): DataflowInformation;
+export {};

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

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processPurrrFormula = processPurrrFormula;
+const known_call_handling_1 = require("../known-call-handling");
+const linker_1 = require("../../../../linker");
+const df_helper_1 = require("../../../../../graph/df-helper");
+const vertex_1 = require("../../../../../graph/vertex");
+const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
+const identifier_1 = require("../../../../../environments/identifier");
+const common_1 = require("../common");
+const r_argument_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument");
+const built_in_proc_name_1 = require("../../../../../environments/built-in-proc-name");
+const model_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/model");
+const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
+const edge_1 = require("../../../../../graph/edge");
+const unpack_argument_1 = require("../argument/unpack-argument");
+const logger_1 = require("../../../../../logger");
+const graph_1 = require("../../../../../graph/graph");
+function linkOnSymbol(rootId, filteredArgs, node, graph, data) {
+    // If the formula is a symbol naming a function, try to resolve it in the call environment.
+    try {
+        const defs = (0, resolve_by_name_1.resolveByName)(node.content, data.environment, identifier_1.ReferenceType.Function) ?? [];
+        graph.addEdge(rootId, node.info.id, edge_1.EdgeType.Calls);
+        for (const def of defs) {
+            // Mark the call as calling this target
+            graph.addEdge(rootId, def.nodeId, edge_1.EdgeType.Calls);
+            // If the target directly maps to a function definition AST, try to link arguments to parameters
+            let linked = data.completeAst.idMap.get(def.nodeId);
+            if (linked?.type !== type_1.RType.FunctionDefinition) {
+                for (const vid of def.value) {
+                    const candidate = data.completeAst.idMap.get(vid);
+                    if (candidate && candidate.type === type_1.RType.FunctionDefinition) {
+                        linked = candidate;
+                        // also mark that we call the resolved function-definition node
+                        graph.addEdge(rootId, vid, edge_1.EdgeType.Calls);
+                        break;
+                    }
+                }
+            }
+            // we may find a candidate in the first check
+            if (linked?.type === type_1.RType.FunctionDefinition) {
+                try {
+                    return (0, linker_1.linkArgumentsOnCall)(filteredArgs, linked.parameters, graph);
+                }
+                catch (e) {
+                    logger_1.dataflowLogger.warn('Failed to link arguments to parameters for purr formula (symbol target), some bindings may be missing', { error: e });
+                }
+            }
+        }
+    }
+    catch (e) {
+        logger_1.dataflowLogger.warn('Failed to resolve symbol for purrr formula .f', { error: e });
+    }
+}
+/**
+ * Support for R's purr formula: `map(df, ~ .x + 1)`.
+ */
+function processPurrrFormula(name, args, rootId, data, config) {
+    const { information, callArgs } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: built_in_proc_name_1.BuiltInProcName.PurrrFormula });
+    const params = {};
+    for (const key of Object.keys(config.args)) {
+        params[config.args[key].name] = config.args[key].name;
+    }
+    // formula parameter
+    params[config['.f'].name] = config['.f'].name;
+    params['...'] = '...';
+    const argMaps = (0, linker_1.pMatch)((0, common_1.convertFnArguments)(args), params);
+    const formulaArgId = argMaps.get(config['.f'].name)?.[0];
+    if (!formulaArgId) {
+        // nothing to do if we couldn't find the formula argument
+        return information;
+    }
+    const formulaArg = r_argument_1.RArgument.getWithId(args, formulaArgId);
+    const formulaNode = formulaArg ? (0, unpack_argument_1.unpackNonameArg)(formulaArg) : undefined;
+    if (!formulaNode) {
+        return information;
+    }
+    let argToParamMap = new Map();
+    // Prepare the list of call arguments to consider for linking (exclude the formula argument and ignored args)
+    const filteredCallArgs = [];
+    for (const arg of callArgs) {
+        const aid = graph_1.FunctionArgument.getId(arg);
+        if (aid === formulaArgId || aid === formulaNode.info.id || config.ignore?.includes(graph_1.FunctionArgument.getName(arg) ?? '')) {
+            continue;
+        }
+        filteredCallArgs.push(arg);
+    }
+    if (formulaNode.type === type_1.RType.FunctionDefinition) {
+        const fdef = formulaNode;
+        information.graph.addEdge(rootId, fdef.info.id, edge_1.EdgeType.Calls);
+        try {
+            argToParamMap = (0, linker_1.linkArgumentsOnCall)(filteredCallArgs, fdef.parameters, information.graph);
+        }
+        catch (e) {
+            logger_1.dataflowLogger.warn('Failed to link arguments to parameters for purr formula, some bindings may be missing', { error: e });
+        }
+    }
+    else if (formulaNode.type === type_1.RType.Symbol) {
+        linkOnSymbol(rootId, filteredCallArgs, formulaNode, information.graph, data);
+    }
+    else {
+        try {
+            df_helper_1.Dataflow.visitDfg(information.graph, formulaNode.info.id, (vtx) => {
+                if (vtx.tag === vertex_1.VertexType.FunctionCall) {
+                    information.graph.addEdge(rootId, vtx.id, edge_1.EdgeType.Calls);
+                    const targets = (0, linker_1.getAllFunctionCallTargets)(vtx.id, information.graph, vtx.environment);
+                    for (const t of targets) {
+                        information.graph.addEdge(rootId, t, edge_1.EdgeType.Calls);
+                        const linked = data.completeAst.idMap.get(t);
+                        if (linked && linked.type === type_1.RType.FunctionDefinition) {
+                            try {
+                                const map = (0, linker_1.linkArgumentsOnCall)(filteredCallArgs, linked.parameters, information.graph);
+                                for (const [argId, paramId] of map.entries()) {
+                                    if (!argToParamMap.has(argId)) {
+                                        argToParamMap.set(argId, paramId);
+                                    }
+                                }
+                            }
+                            catch (e) {
+                                logger_1.dataflowLogger.warn('Failed to link arguments to parameters for purrr formula (list target)', { error: e });
+                            }
+                        }
+                    }
+                    return !vtx.origin.includes(built_in_proc_name_1.BuiltInProcName.List);
+                }
+                else if (vtx.tag === vertex_1.VertexType.Use) {
+                    const node = data.completeAst.idMap.get(vtx.id);
+                    if (node?.type === type_1.RType.Symbol) {
+                        linkOnSymbol(rootId, filteredCallArgs, node, information.graph, data);
+                    }
+                }
+                return false;
+            });
+        }
+        catch (e) {
+            logger_1.dataflowLogger.warn('Failed to traverse sub-dfg for purrr formula .f', { error: e });
+        }
+    }
+    const ignore = new Set(config.ignore ?? []);
+    model_1.RNode.visitAst(formulaNode, (node) => {
+        if (node.type === type_1.RType.Symbol) {
+            const sym = node;
+            const name = sym.content;
+            if (ignore.has(name)) {
+                return false;
+            }
+            const mappingKey = config.args[name]?.name;
+            if (mappingKey) {
+                const pid = (argMaps.get(mappingKey) ?? [])[0];
+                if (!pid) {
+                    return false;
+                }
+                const arg = r_argument_1.RArgument.getWithId(args, pid);
+                const producedNode = arg ? (0, unpack_argument_1.unpackNonameArg)(arg) : undefined;
+                if (!producedNode) {
+                    return false;
+                }
+                // If this argument was linked to a parameter on the call, skip adding edge
+                const resultId = producedNode.info.id;
+                if (!argToParamMap.has(resultId)) {
+                    information.graph.addEdge(node.info.id, resultId, edge_1.EdgeType.Reads);
+                }
+            }
+        }
+        return false;
+    });
+    if (config.returnArg) {
+        const returnArgId = argMaps.get(config.returnArg)?.[0];
+        if (returnArgId) {
+            const returnArg = r_argument_1.RArgument.getWithId(args, returnArgId);
+            const producedNode = returnArg ? (0, unpack_argument_1.unpackNonameArg)(returnArg) : undefined;
+            if (producedNode) {
+                information.graph.addEdge(rootId, producedNode.info.id, edge_1.EdgeType.Returns);
+            }
+        }
+    }
+    return information;
+}
+//# sourceMappingURL=built-in-purrr-formula.js.map

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

@@ -1,13 +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 { PotentiallyEmptyRArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { ForceArguments } from '../common';
+interface QuoteConfig extends ForceArguments {
+    quoteArgumentsWithIndex: number;
+    envArgIndex?: number;
+}
 /**
  * Process a call to `quote` or similar nse/substitution functions.
  */
-export declare function processQuote<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
-    quoteArgumentsWithIndex?: number;
-} & ForceArguments): DataflowInformation;
+export declare function processQuote<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: QuoteConfig): DataflowInformation;
+export {};

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

@@ -2,14 +2,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processQuote = processQuote;
 const known_call_handling_1 = require("../known-call-handling");
+const node_id_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id");
+const vertex_1 = require("../../../../../graph/vertex");
+const logger_1 = require("../../../../../logger");
+const df_helper_1 = require("../../../../../graph/df-helper");
 const edge_1 = require("../../../../../graph/edge");
 const built_in_proc_name_1 = require("../../../../../environments/built-in-proc-name");
+const graph_1 = require("../../../../../graph/graph");
 /**
  * Process a call to `quote` or similar nse/substitution functions.
  */
 function processQuote(name, args, rootId, data, config) {
     const startEnv = data.environment;
-    const { information, processedArguments, fnRef } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: built_in_proc_name_1.BuiltInProcName.Quote });
+    let lastEnv = startEnv;
+    const { information, processedArguments, fnRef } = (0, known_call_handling_1.processKnownFunctionCall)({
+        name, args, rootId, data, forceArgs: config.forceArgs, origin: built_in_proc_name_1.BuiltInProcName.Quote,
+        patchData(data, index) {
+            if (index === config.quoteArgumentsWithIndex) {
+                lastEnv = data.environment;
+                return { ...data, environment: data.ctx.env.makeCleanEnv() };
+            }
+            else {
+                return { ...data, environment: lastEnv };
+            }
+        }
+    });
     let inRefs = [fnRef];
     let outRefs = [];
     let unknownRefs = [];
@@ -28,6 +45,50 @@ function processQuote(name, args, rootId, data, config) {
             }
         }
     }
+    if (config?.envArgIndex !== undefined) {
+        const envProcessed = processedArguments[config.envArgIndex];
+        const exprProcessed = processedArguments[config.quoteArgumentsWithIndex];
+        if (envProcessed && exprProcessed) {
+            try {
+                // traverse the env processed DFG to find list calls (prefix-aware handling)
+                df_helper_1.Dataflow.visitDfg(envProcessed.graph, envProcessed.entryPoint, (vtx) => {
+                    if (vtx.tag !== vertex_1.VertexType.FunctionCall) {
+                        return;
+                    }
+                    if (!vtx.origin.includes(built_in_proc_name_1.BuiltInProcName.List)) {
+                        return true;
+                    }
+                    const useMap = new Map();
+                    for (const vType of [vertex_1.VertexType.Use, vertex_1.VertexType.FunctionCall]) {
+                        for (const [useId] of exprProcessed.graph.verticesOfType(vType)) {
+                            const rn = (0, node_id_1.recoverName)(useId, exprProcessed.graph.idMap);
+                            if (rn) {
+                                const arr = useMap.get(rn) ?? [];
+                                arr.push(useId);
+                                useMap.set(rn, arr);
+                            }
+                        }
+                    }
+                    if (useMap.size === 0) {
+                        return true;
+                    }
+                    const listFields = vtx.args.filter(graph_1.FunctionArgument.isNamed);
+                    for (const field of listFields) {
+                        const uses = useMap.get(field.name);
+                        if (uses) {
+                            for (const useId of uses) {
+                                information.graph.addEdge(useId, field.nodeId, edge_1.EdgeType.Reads);
+                            }
+                        }
+                    }
+                    return true;
+                });
+            }
+            catch (e) {
+                logger_1.dataflowLogger.warn('Failed to apply substitute-style env list replacement in quote-like call', { error: e });
+            }
+        }
+    }
     return {
         ...information,
         environment: startEnv,

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

@@ -1,11 +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 PotentiallyEmptyRArgument } 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';
+interface RecallConfig {
+    /** whether to not handle as a recall function but rather as an unknown side effect if the argument is non-constant non-zero */
+    unknownOnNonZeroArg?: boolean;
+}
 /**
  * Processes a built-in 'Recall' function call, linking
  * the recall to the enveloping function closure.
  */
-export declare function processRecall<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
+export declare function processRecall<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: RecallConfig): DataflowInformation;
+export {};

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

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processRecall = processRecall;
 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 type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
+const unknown_side_effect_1 = require("../../../../../graph/unknown-side-effect");
 const log_1 = require("../../../../../../util/log");
 const edge_1 = require("../../../../../graph/edge");
 const vertex_1 = require("../../../../../graph/vertex");
@@ -12,7 +15,7 @@ const built_in_proc_name_1 = require("../../../../../environments/built-in-proc-
  * Processes a built-in 'Recall' function call, linking
  * the recall to the enveloping function closure.
  */
-function processRecall(name, args, rootId, data) {
+function processRecall(name, args, rootId, data, config) {
     const { information } = (0, known_call_handling_1.processKnownFunctionCall)({
         name,
         args,
@@ -20,6 +23,17 @@ function processRecall(name, args, rootId, data) {
         data,
         origin: built_in_proc_name_1.BuiltInProcName.Recall
     });
+    // If requested, treat Recall as an unknown side effect when a single argument is provided and it is not the numeric literal 0.
+    if (config?.unknownOnNonZeroArg) {
+        if (args.length === 1 && args[0] !== r_function_call_1.EmptyArgument && args[0].value) {
+            const v = args[0].value;
+            // only allow the normal recall handling if the single arg is the literal 0
+            if (!(v.type === type_1.RType.Number && v.content.num === 0)) {
+                (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
+                return information;
+            }
+        }
+    }
     let cur = data.environment.current;
     let closure;
     while (cur) {

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

@@ -2,7 +2,7 @@ import { type DataflowProcessorInformation } from '../../../../../processor';
 import type { DataflowInformation } from '../../../../../info';
 import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { 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 PotentiallyEmptyRArgument } 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 {
@@ -31,4 +31,4 @@ export interface RegisterHookConfig {
 /**
  * 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;
+export declare function processRegisterHook<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: RegisterHookConfig): DataflowInformation;

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

@@ -1,7 +1,7 @@
 import type { DataflowProcessorInformation } from '../../../../../processor';
 import { type DataflowInformation } from '../../../../../info';
 import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type PotentiallyEmptyRArgument } 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';
 /**
@@ -12,4 +12,4 @@ import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/proce
  * @param data     - Additional dataflow processor information.
  * @returns        - The resulting dataflow information after processing the repeat loop.
  */
-export declare function processRepeatLoop<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
+export declare function processRepeatLoop<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

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

@@ -3,7 +3,7 @@ import { DataflowInformation } from '../../../../../info';
 import { type ForceArguments } from '../common';
 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 PotentiallyEmptyRArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 /**
  * Process a replacement function call like `<-`, `[[<-`, `$<-`, etc.
@@ -11,7 +11,7 @@ import { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing
  */
 export declare function processReplacementFunction<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, 
 /** The last one has to be the value */
-args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
+args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     makeMaybe?: boolean;
     constructName?: 's7';
     assignmentOperator?: '<-' | '<<-';

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

@@ -1,10 +1,10 @@
 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 PotentiallyEmptyRArgument } 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 an `rm` call.
  */
-export declare function processRm<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
+export declare function processRm<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/call/built-in/built-in-s-seven-dispatch.d.ts

@@ -1,7 +1,7 @@
 import type { DataflowProcessorInformation } from '../../../../../processor';
 import type { DataflowInformation } from '../../../../../info';
 import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type PotentiallyEmptyRArgument } 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';
 /** Used to separate S7 dispatch info in identifiers */
@@ -9,4 +9,4 @@ export declare const S7DispatchSeparator = "\uFE55s3\uFE55";
 /**
  * Process an S7 generic dispatch call like `S7_dispatch`.
  */
-export declare function processS7Dispatch<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
+export declare function processS7Dispatch<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/call/built-in/built-in-s-seven-new-generic.d.ts

@@ -1,7 +1,7 @@
 import type { DataflowProcessorInformation } from '../../../../../processor';
 import type { DataflowInformation } from '../../../../../info';
 import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type PotentiallyEmptyRArgument } 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';
 /** e.g. new_generic(name, dispatch_args, fun=NULL) */
@@ -15,5 +15,5 @@ interface S7GenericDispatchConfig {
 /**
  * Process an S7 new generic dispatch call like `new_generic` or `setGeneric`.
  */
-export declare function processS7NewGeneric<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: S7GenericDispatchConfig): DataflowInformation;
+export declare function processS7NewGeneric<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: S7GenericDispatchConfig): DataflowInformation;
 export {};

package/dataflow/internal/process/functions/call/built-in/built-in-s-three-dispatch.d.ts

@@ -1,7 +1,7 @@
 import type { DataflowProcessorInformation } from '../../../../../processor';
 import { 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 PotentiallyEmptyRArgument } 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';
 /** e.g. UseMethod(generic, object) */
@@ -16,5 +16,5 @@ interface S3DispatchConfig {
 /**
  * Process an S3 dispatch call like `UseMethod`.
  */
-export declare function processS3Dispatch<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: S3DispatchConfig): DataflowInformation;
+export declare function processS3Dispatch<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: S3DispatchConfig): DataflowInformation;
 export {};

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

@@ -3,7 +3,7 @@ import { DataflowInformation } from '../../../../../info';
 import { type FlowrLaxSourcingOptions, InferWorkingDirectory } from '../../../../../../config';
 import { type RParseRequest } from '../../../../../../r-bridge/retriever';
 import { type IdGenerator, 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 PotentiallyEmptyRArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { NoInfo } from '../../../../../../r-bridge/lang-4.x/ast/model/model';
@@ -35,7 +35,7 @@ export declare function findSource(resolveSource: FlowrLaxSourcingOptions | unde
 /**
  * Processes a named function call (i.e., not an anonymous function)
  */
-export declare function processSourceCall<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
+export declare function processSourceCall<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     /** should this produce an explicit source function call in the graph? */
     includeFunctionCall?: boolean;
     /** should this function call be followed, even when the configuration disables it? */

package/dataflow/internal/process/functions/call/built-in/built-in-special-bin-op.d.ts

@@ -1,7 +1,7 @@
 import type { DataflowProcessorInformation } from '../../../../../processor';
 import type { DataflowInformation } from '../../../../../info';
 import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { PotentiallyEmptyRArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { ForceArguments } from '../common';
@@ -10,7 +10,7 @@ import type { ForceArguments } from '../common';
  * For example, the logical AND `&&` and OR `||` operators only evaluate their right-hand side if necessary.
  * Please note that this is not (directly) related to R's special binary operators like `%in%`.
  */
-export declare function processSpecialBinOp<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
+export declare function processSpecialBinOp<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     lazy: boolean;
     evalRhsWhen: boolean;
 } & ForceArguments): DataflowInformation;

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

@@ -1,7 +1,7 @@
 import type { DataflowProcessorInformation } from '../../../../../processor';
 import type { DataflowInformation } from '../../../../../info';
 import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { PotentiallyEmptyRArgument } 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';
 /**
@@ -18,4 +18,4 @@ import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/proce
  * })
  * ```
  */
-export declare function processStopIfNot<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
+export declare function processStopIfNot<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

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

@@ -1,13 +1,13 @@
 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 PotentiallyEmptyRArgument } 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: {
+export declare function processTryCatch<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     block: string;
     handlers: {
         error?: string;

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

@@ -1,4 +1,4 @@
-import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type PotentiallyEmptyRArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
@@ -12,4 +12,4 @@ import type { DataflowProcessorInformation } from '../../../../../processor';
  * c(1, 2, 3, 4)
  * ```
  */
-export declare function processVector<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
+export declare function processVector<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

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

@@ -1,10 +1,10 @@
 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 PotentiallyEmptyRArgument } 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 while loop like `while(cond) { ... }`.
  */
-export declare function processWhileLoop<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
+export declare function processWhileLoop<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;