@eagleoutice/flowr 2.10.1 → 2.10.2

package/dataflow/internal/process/functions/call/built-in/built-in-get.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';
 /**
  * Processes a built-in 'get' function call.
  */
-export declare function processGet<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
+export declare function processGet<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-if-then-else.d.ts

@@ -2,7 +2,7 @@ import { type DataflowProcessorInformation } from '../../../../../processor';
 import { type DataflowInformation } from '../../../../../info';
 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 { 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';
 /** `if(<cond>) <then> else <else>` built-in function configuration, make sure to not reuse indices */
 export interface IfThenElseConfig {
@@ -20,4 +20,4 @@ export interface IfThenElseConfig {
  * 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>, config?: IfThenElseConfig): DataflowInformation;
+export declare function processIfThenElse<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config?: IfThenElseConfig): DataflowInformation;

package/dataflow/internal/process/functions/call/built-in/built-in-library.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 library call like `library` or `require`
  */
-export declare function processLibrary<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
+export declare function processLibrary<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-list.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';
  * list(a = 1, b = 2)
  * ```
  */
-export declare function processList<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
+export declare function processList<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-local.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';
 export interface LocalFunctionConfiguration {
@@ -15,4 +15,4 @@ export interface LocalFunctionConfiguration {
 /**
  * Processes a built-in 'local' function call.
  */
-export declare function processLocal<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: LocalFunctionConfiguration): DataflowInformation;
+export declare function processLocal<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: LocalFunctionConfiguration): DataflowInformation;

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

@@ -1,10 +1,30 @@
 import type { DataflowProcessorInformation } from '../../../../../processor';
 import type { DataflowInformation } from '../../../../../info';
-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 { 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';
+import type { BrandedIdentifier } from '../../../../../environments/identifier';
 /**
- * Suport for R's pipe functions like `|>`.
+ * Configuration options for the basic R pipe
  */
-export declare function processPipe<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
+interface PipeConfiguration {
+    pipePlaceholderName: BrandedIdentifier;
+    /**
+     * this is for a pipe like `%<>%` which assigns its lhs
+     */
+    assignLhs: boolean;
+    /**
+     * Whether to return the lhs (e.g., with the TPipe)
+     */
+    returnLhs: boolean;
+    /**
+     * If so, also allow a symbol instead of a function as rhs, if it is the case, this automatically converts the symbol on the rhs to a function call
+     */
+    rhsMightBeSymbol?: boolean;
+}
+/**
+ * Support for R's pipe functions like `|>` or magrittr's `%>%`
+ */
+export declare function processPipe<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, { pipePlaceholderName, assignLhs, returnLhs, rhsMightBeSymbol }: PipeConfiguration): DataflowInformation;
+export {};

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

@@ -4,41 +4,109 @@ exports.processPipe = processPipe;
 const known_call_handling_1 = require("../known-call-handling");
 const assert_1 = require("../../../../../../util/assert");
 const unpack_argument_1 = require("../argument/unpack-argument");
+const model_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/model");
 const logger_1 = require("../../../../../logger");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const vertex_1 = require("../../../../../graph/vertex");
 const edge_1 = require("../../../../../graph/edge");
 const identifier_1 = require("../../../../../environments/identifier");
+const make_argument_1 = require("../argument/make-argument");
+const built_in_assignment_1 = require("./built-in-assignment");
 const built_in_proc_name_1 = require("../../../../../environments/built-in-proc-name");
+const log_1 = require("../../../../../../util/log");
 /**
- * Suport for R's pipe functions like `|>`.
+ * Support for R's pipe functions like `|>` or magrittr's `%>%`
  */
-function processPipe(name, args, rootId, data) {
-    const { information, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: built_in_proc_name_1.BuiltInProcName.Pipe });
+function processPipe(name, args, rootId, data, { pipePlaceholderName, assignLhs, returnLhs, rhsMightBeSymbol = false }) {
+    const fCallInfo = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: built_in_proc_name_1.BuiltInProcName.Pipe });
+    const processedArguments = fCallInfo.processedArguments;
+    let information = fCallInfo.information;
     if (args.length !== 2) {
         logger_1.dataflowLogger.warn(`Pipe ${identifier_1.Identifier.toString(name.content)} has something else than 2 arguments, skipping`);
         return information;
     }
     const [lhs, rhs] = args.map(e => (0, unpack_argument_1.unpackNonameArg)(e));
     (0, assert_1.guard)(lhs !== undefined && rhs !== undefined, () => `lhs and rhs must be present, but ${JSON.stringify(lhs)} and ${JSON.stringify(rhs)} were found instead.`);
-    if (rhs.type === type_1.RType.FunctionCall) {
+    // If this is an assigning pipe (e.g., %<>%), perform the assignment writeback using the built-in
+    // assignment processor: target <- source where target is the original lhs and source is the rhs call
+    if (assignLhs) {
+        // create unnamed args for target and source
+        const targetArg = (0, make_argument_1.toUnnamedArgument)(lhs, data.completeAst.idMap);
+        const sourceArg = (0, make_argument_1.toUnnamedArgument)(rhs, data.completeAst.idMap);
+        // construct a synthetic symbol for the assignment operator '<-'
+        const assignSym = {
+            type: type_1.RType.Symbol,
+            info: name.info,
+            content: identifier_1.Identifier.make('<-', 'base'),
+            lexeme: '<-',
+            location: name.location
+        };
+        information = (0, built_in_assignment_1.processAssignment)(assignSym, [targetArg, sourceArg], rootId, data, { canBeReplacement: true, mayHaveMoreArgs: true });
+    }
+    let treatedAsFunctionCall = false;
+    if (rhs.type === type_1.RType.Symbol && rhsMightBeSymbol) {
+        // convert a plain symbol on the RHS into a function-call vertex so we can treat it like `df %>% head`
+        const maybeVertex = information.graph.getVertex(rhs.info.id);
+        if (maybeVertex && maybeVertex.tag === vertex_1.VertexType.Use) {
+            information.graph.updateToFunctionCall({
+                tag: vertex_1.VertexType.FunctionCall,
+                id: rhs.info.id,
+                name: rhs.content,
+                args: [],
+                environment: data.environment,
+                onlyBuiltin: false,
+                cds: data.cds,
+                origin: [built_in_proc_name_1.BuiltInProcName.Function]
+            });
+            treatedAsFunctionCall = true;
+        }
+    }
+    if (treatedAsFunctionCall || rhs.type === type_1.RType.FunctionCall) {
         const functionCallNode = information.graph.getVertex(rhs.info.id);
         (0, assert_1.guard)(functionCallNode?.tag === vertex_1.VertexType.FunctionCall, () => `Expected function call node with id ${rhs.info.id} to be a function call node, but got ${functionCallNode?.tag} instead.`);
-        // make the lhs an argument node:
+        // make the lhs an argument node (or link it to placeholders within the rhs call):
         const argId = lhs.info.id;
-        logger_1.dataflowLogger.trace(`Linking pipe arg ${argId} as first argument of ${rhs.info.id}`);
-        functionCallNode.args.unshift({
-            name: undefined,
-            nodeId: argId,
-            cds: data.cds,
-            type: identifier_1.ReferenceType.Function
+        // find all symbol occurrences inside the rhs function call AST that match the placeholder name
+        const occurrenceIds = [];
+        model_1.RNode.visitAst(rhs, (node) => {
+            if (node.type === type_1.RType.Symbol && node.content === pipePlaceholderName) {
+                occurrenceIds.push(node.info.id);
+            }
+            return false;
         });
-        information.graph.addEdge(functionCallNode.id, argId, edge_1.EdgeType.Argument | edge_1.EdgeType.Reads);
+        if (occurrenceIds.length > 0) {
+            if (occurrenceIds.length !== 1) {
+                log_1.log.warn(`Expected exactly one occurrence of the pipe placeholder '${identifier_1.Identifier.toString(pipePlaceholderName)}' in the rhs of the pipe, but found ${occurrenceIds.length}. Linking all occurrences to the lhs.`);
+            }
+            for (const occId of occurrenceIds) {
+                information.graph.addEdge(occId, argId, edge_1.EdgeType.Reads);
+            }
+        }
+        else {
+            logger_1.dataflowLogger.trace(`Linking pipe arg ${argId} as first argument of ${rhs.info.id}`);
+            functionCallNode.args.unshift({
+                name: undefined,
+                nodeId: argId,
+                cds: data.cds,
+                type: identifier_1.ReferenceType.Function
+            });
+            information.graph.addEdge(functionCallNode.id, argId, edge_1.EdgeType.Argument | edge_1.EdgeType.Reads);
+        }
     }
     else {
         logger_1.dataflowLogger.warn(`Expected rhs of pipe to be a function call, but got ${rhs.type} instead.`);
     }
     const firstArgument = processedArguments[0];
+    // If requested, return the lhs value (tee/TPipe semantics): add a Returns edge to the lhs entry
+    if (firstArgument && returnLhs) {
+        information.graph.addEdge(rootId, firstArgument.entryPoint, edge_1.EdgeType.Returns);
+    }
+    else {
+        const secondArgument = processedArguments[1];
+        if (secondArgument && !returnLhs) {
+            information.graph.addEdge(rootId, secondArgument.entryPoint, edge_1.EdgeType.Returns);
+        }
+    }
     const uniqueIn = information.in.slice();
     for (const ing of (firstArgument?.in ?? [])) {
         if (!uniqueIn.some(e => e.nodeId === ing.nodeId)) {

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) {