@eagleoutice/flowr 2.9.14 → 2.10.2

package/dataflow/graph/graph.js

@@ -68,18 +68,48 @@ exports.FunctionArgument = {
         return arg !== r_function_call_1.EmptyArgument;
     },
     /**
-     * Returns the reference of a non-empty argument.
+     * Returns the id of a non-empty argument.
      * @example
      * ```r
-     * foo(a=3, 2) # returns the node id of either `3` or `2`, but skips a
+     * foo(a=3, 2) # returns the node id of either `a` or `2`
      * ```
+     * @see {@link FunctionArgument.getReference}
+     * @see {@link FunctionArgument.getName}
      */
-    getReference(arg) {
+    getId(arg) {
         if (arg !== r_function_call_1.EmptyArgument) {
             return arg?.nodeId;
         }
         return undefined;
     },
+    /**
+     * Returns the name of a named argument.
+     * @example
+     * ```r
+     * foo(a = 3, 2) # returns 'a' or undefined
+     * ```
+     * @see {@link FunctionArgument.getId}
+     */
+    getName(arg) {
+        return exports.FunctionArgument.isNamed(arg) ? arg.name : undefined;
+    },
+    /**
+     * Returns the reference of a non-empty argument.
+     * @example
+     * ```r
+     * foo(a=3, 2) # returns the node id of either `3` or `2`, but skips a
+     * ```
+     * @see {@link FunctionArgument.getId}
+     */
+    getReference(arg) {
+        if (arg === r_function_call_1.EmptyArgument) {
+            return undefined;
+        }
+        else if (arg.name === undefined) {
+            return arg.nodeId;
+        }
+        return arg.valueId;
+    },
     /**
      * Checks whether the given argument is a named argument with the specified name.
      * Please note that this only checks whether the name is exactly identical and not whether
@@ -369,8 +399,9 @@ class DataflowGraph {
     /**
      * Marks a vertex in the graph to be a definition
      * @param reference - The reference to the vertex to mark as definition
+     * @param sourceIds - The id of the source vertex of the def, if available
      */
-    setDefinitionOfVertex(reference) {
+    setDefinitionOfVertex(reference, sourceIds) {
         const vertex = this.getVertex(reference.nodeId);
         (0, assert_1.guard)(vertex !== undefined, () => `node must be defined for ${JSON.stringify(reference)} to set reference`);
         if (vertex.tag === vertex_1.VertexType.FunctionDefinition || vertex.tag === vertex_1.VertexType.VariableDefinition) {
@@ -379,6 +410,9 @@ class DataflowGraph {
         else {
             const oldTag = vertex.tag;
             vertex.tag = vertex_1.VertexType.VariableDefinition;
+            if (sourceIds) {
+                vertex.source = sourceIds;
+            }
             this.types.set(oldTag, (this.types.get(oldTag) ?? []).filter(id => id !== reference.nodeId));
             this.types.set(vertex_1.VertexType.VariableDefinition, (this.types.get(vertex_1.VertexType.VariableDefinition) ?? []).concat([reference.nodeId]));
         }

package/dataflow/graph/vertex.d.ts

@@ -123,6 +123,8 @@ export interface DataflowGraphVertexVariableDefinition extends DataflowGraphVert
     readonly environment?: undefined;
     /** Indicates whether the variable definition is a *partial* definition (e.g,. in `x[a] <- b`) */
     readonly par?: true;
+    /** Points to the source ids of the "value" if there is one, this is more of a best-effort flag and not guaranteed to be there */
+    readonly source?: readonly NodeId[];
 }
 /**
  * Arguments required to construct a vertex which represents the definition of a function in the {@link DataflowGraph|dataflow graph}.

package/dataflow/instrument/instrument-dataflow-count.d.ts

@@ -5,5 +5,15 @@ import type { RType } from '../../r-bridge/lang-4.x/ast/model/type';
 /**
  * This takes the out parameter `countMap` and fills it with the count of how many times each RType was processed.
  * The accompanying `reset` function can be used to reset the map to an empty state.
+ * @example
+ * ```ts
+ * const map = new Map<RType, number>();
+ * const analyzer = await new FlowrAnalyzerBuilder()
+ *     .configure('solver.instrument.dataflowExtractors', instrumentDataflowCount(map, () => map.clear()))
+ *     .build();
+ * analyzer.addRequest(requestFromInput(code));
+ * await analyzer.dataflow();
+ * ```
+ * Now, you can inspect the counts in the `map` objects, these will be reset for each new analysis request using the `() => map.clear()` function.
  */
 export declare function instrumentDataflowCount(countMap: Map<RType, number>, reset: (map: Map<RType, number>) => void): (extractor: DataflowProcessors<ParentInformation>, ctx: FlowrAnalyzerContext) => DataflowProcessors<ParentInformation>;

package/dataflow/instrument/instrument-dataflow-count.js

@@ -4,6 +4,16 @@ exports.instrumentDataflowCount = instrumentDataflowCount;
 /**
  * This takes the out parameter `countMap` and fills it with the count of how many times each RType was processed.
  * The accompanying `reset` function can be used to reset the map to an empty state.
+ * @example
+ * ```ts
+ * const map = new Map<RType, number>();
+ * const analyzer = await new FlowrAnalyzerBuilder()
+ *     .configure('solver.instrument.dataflowExtractors', instrumentDataflowCount(map, () => map.clear()))
+ *     .build();
+ * analyzer.addRequest(requestFromInput(code));
+ * await analyzer.dataflow();
+ * ```
+ * Now, you can inspect the counts in the `map` objects, these will be reset for each new analysis request using the `() => map.clear()` function.
  */
 function instrumentDataflowCount(countMap, reset) {
     return (extractor, _ctx) => {

package/dataflow/internal/process/functions/call/argument/unpack-argument.d.ts

@@ -1,16 +1,16 @@
-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 { RNode } from '../../../../../../r-bridge/lang-4.x/ast/model/model';
 /**
  * Retrieve the value from an argument, if it is not empty.
  * @see {@link unpackArg} - to specifically retrieve non-named arguments
  */
-export declare function unpackNonameArg<OtherInfo>(arg: RFunctionArgument<OtherInfo> | undefined): RNode<OtherInfo> | undefined;
+export declare function unpackNonameArg<OtherInfo>(arg: PotentiallyEmptyRArgument<OtherInfo> | undefined): RNode<OtherInfo> | undefined;
 /**
  * Retrieve the value from a non-named argument, if it is not empty.
  * @see {@link unpackNonameArg} - to specifically retrieve non-named arguments
  */
-export declare function unpackArg<OtherInfo>(arg: RFunctionArgument<OtherInfo> | undefined): RNode<OtherInfo> | undefined;
+export declare function unpackArg<OtherInfo>(arg: PotentiallyEmptyRArgument<OtherInfo> | undefined): RNode<OtherInfo> | undefined;
 /**
  * Try to unpack the given argument, if it is not empty.
  */
-export declare function tryUnpackNoNameArg<OtherInfo>(arg: RFunctionArgument<OtherInfo>): RNode<OtherInfo> | RFunctionArgument<OtherInfo>;
+export declare function tryUnpackNoNameArg<OtherInfo>(arg: PotentiallyEmptyRArgument<OtherInfo>): RNode<OtherInfo> | PotentiallyEmptyRArgument<OtherInfo>;

package/dataflow/internal/process/functions/call/built-in/built-in-access.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 { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { ForceArguments } from '../common';
@@ -16,10 +16,10 @@ import type { ForceArguments } from '../common';
  * a@foo
  * ```
  */
-export declare function processAccess<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
+export declare function processAccess<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     treatIndicesAsString: boolean;
 } & ForceArguments): DataflowInformation;
 /**
  * Converts symbol arguments to string arguments within the specified range.
  */
-export declare function symbolArgumentsToStrings<OtherInfo>(args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], firstIndexInclusive?: number, lastIndexInclusive?: number): RFunctionArgument<OtherInfo & ParentInformation>[];
+export declare function symbolArgumentsToStrings<OtherInfo>(args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], firstIndexInclusive?: number, lastIndexInclusive?: number): PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[];

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

@@ -1,6 +1,6 @@
 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';
@@ -20,4 +20,4 @@ export interface BuiltInApplyConfiguration extends MergeableRecord {
 /**
  * Process an apply call like `vapply` or `mapply`.
  */
-export declare function processApply<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: BuiltInApplyConfiguration): DataflowInformation;
+export declare function processApply<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: BuiltInApplyConfiguration): DataflowInformation;

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

@@ -98,6 +98,7 @@ function processApply(name, args, rootId, data, config) {
         if (arg && counterpart !== r_function_call_1.EmptyArgument) {
             return {
                 name: counterpart.name?.content,
+                valueId: counterpart.value?.info.id,
                 cds: data.cds,
                 type: identifier_1.ReferenceType.Argument,
                 nodeId: arg.entryPoint

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

@@ -3,7 +3,7 @@ import type { DataflowInformation } from '../../../../../info';
 import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RNode } from '../../../../../../r-bridge/lang-4.x/ast/model/model';
 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 { Identifier, type InGraphIdentifierDefinition } from '../../../../../environments/identifier';
 import type { DataflowGraphVertexFunctionDefinition } from '../../../../../graph/vertex';
@@ -35,13 +35,13 @@ export interface ExtendedAssignmentConfiguration extends AssignmentConfiguration
 /**
  * In contrast to `processAssignment`, this function allows more flexible handling of assignment-like functions.
  */
-export declare function processAssignmentLike<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: ExtendedAssignmentConfiguration): DataflowInformation;
+export declare function processAssignmentLike<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: ExtendedAssignmentConfiguration): DataflowInformation;
 /**
  * Processes an assignment, i.e., `<target> <- <source>`.
  * Handling it as a function call \`&lt;-\` `(<target>, <source>)`.
  * This includes handling of replacement functions (e.g., `names(x) <- ...` as \`names&lt;-\` `(x, ...)`).
  */
-export declare function processAssignment<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: AssignmentConfiguration): DataflowInformation;
+export declare function processAssignment<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: AssignmentConfiguration): DataflowInformation;
 export interface AssignmentToSymbolParameters<OtherInfo> extends AssignmentConfiguration {
     readonly nameOfAssignmentFunction: Identifier;
     readonly source: RNode<OtherInfo & ParentInformation>;

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

@@ -297,7 +297,7 @@ function checkTargetReferenceType(sourceInfo, fnModes) {
  */
 function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignment, data, assignmentConfig) {
     information.environment = (0, define_1.define)(nodeToDefine, assignmentConfig?.superAssignment, information.environment);
-    information.graph.setDefinitionOfVertex(nodeToDefine);
+    information.graph.setDefinitionOfVertex(nodeToDefine, sourceIds);
     const nid = nodeToDefine.nodeId;
     if (!assignmentConfig?.quoteSource) {
         for (const sourceId of sourceIds) {

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

@@ -1,13 +1,13 @@
 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';
 /**
  * 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: {
+export declare function processEvalCall<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;
 }): DataflowInformation;

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

@@ -6,9 +6,9 @@ import type { DataflowInformation } from '../../../../../info';
 import { type DataflowProcessorInformation } from '../../../../../processor';
 import { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 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';
 /**
  * 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;
+export declare function processExpressionList<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-for-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 { 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';
 /**
@@ -11,4 +11,4 @@ import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/node
  * `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;
+export declare function processForLoop<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-for-loop.js

@@ -60,7 +60,7 @@ function processForLoop(name, args, rootId, data) {
     const nameIdShares = (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(nextGraph, writtenIds));
     for (const write of writtenVariable) {
         nextGraph.addEdge(write.nodeId, vector.entryPoint, edge_1.EdgeType.DefinedBy);
-        nextGraph.setDefinitionOfVertex(write);
+        nextGraph.setDefinitionOfVertex(write, [vector.entryPoint]);
     }
     (0, reference_to_maybe_1.applyCdToReferences)(body.out, cd);
     const outgoing = variable.out.concat(writtenVariable, body.out);

package/dataflow/internal/process/functions/call/built-in/built-in-function-definition.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 { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { DataflowGraph } from '../../../../../graph/graph';
 import { type REnvironmentInformation } from '../../../../../environments/environment';
@@ -10,7 +10,7 @@ import type { ReadOnlyFlowrAnalyzerContext } from '../../../../../../project/con
 /**
  * Process a function definition, i.e., `function(a, b) { ... }`
  */
-export declare function processFunctionDefinition<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
+export declare function processFunctionDefinition<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
 /**
  * Retrieve the active environment when entering a function definition or call
  * @param callerEnvironment - environment at the call site / function definition site

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

@@ -99,10 +99,10 @@ function processFunctionDefinition(name, args, rootId, data) {
             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 };
+            return { type: identifier_1.ReferenceType.Argument, cds: data.cds, nodeId: p.value.name.info.id, name: p.value.name.content, valueId: p.value.defaultValue?.info.id };
         }
         else if (p.name) {
-            return { type: identifier_1.ReferenceType.Argument, cds: data.cds, nodeId: p.name.info.id, name: p.name.content };
+            return { type: identifier_1.ReferenceType.Argument, valueId: p.value?.info.id, cds: data.cds, nodeId: p.name.info.id, name: p.name.content };
         }
         else {
             return r_function_call_1.EmptyArgument;
@@ -231,20 +231,10 @@ function updateNestedFunctionCalls(graph, outEnvironment) {
     // track *all* function definitions - including those nested within the current graph,
     // try to resolve their 'in' by only using the lowest scope which will be popped after this definition
     for (const [id, { onlyBuiltin, environment, name, args, origin }] of graph.verticesOfType(vertex_1.VertexType.FunctionCall)) {
-        if (onlyBuiltin || !name) {
+        if (onlyBuiltin || name === undefined) {
             continue;
         }
-        let effectiveEnvironment = outEnvironment;
-        // only the call environment counts!
-        if (environment) {
-            while (outEnvironment.level > environment.level) {
-                outEnvironment = (0, scoping_1.popLocalEnvironment)(outEnvironment);
-            }
-            while (outEnvironment.level < environment.level) {
-                outEnvironment = (0, scoping_1.pushLocalEnvironment)(outEnvironment);
-            }
-            effectiveEnvironment = (0, overwrite_1.overwriteEnvironment)(outEnvironment, environment);
-        }
+        const effectiveEnvironment = environment ? (0, overwrite_1.overwriteEnvironment)(outEnvironment, environment) : outEnvironment;
         const targets = new Set((0, linker_1.getAllFunctionCallTargets)(id, graph, effectiveEnvironment));
         const collectedNextMethods = new Set();
         const treatAsS3 = origin.includes(built_in_proc_name_1.BuiltInProcName.S3Dispatch);
@@ -255,11 +245,10 @@ function updateNestedFunctionCalls(graph, outEnvironment) {
             }
             const targetVertex = graph.getVertex(target);
             // support reads on symbols
-            if (targetVertex?.tag === vertex_1.VertexType.Use) {
-                graph.addEdge(id, target, edge_1.EdgeType.Reads);
-                continue;
-            }
-            else if (targetVertex?.tag !== vertex_1.VertexType.FunctionDefinition) {
+            if (targetVertex?.tag !== vertex_1.VertexType.FunctionDefinition) {
+                if (targetVertex?.tag === vertex_1.VertexType.Use) {
+                    graph.addEdge(id, target, edge_1.EdgeType.Reads);
+                }
                 continue;
             }
             graph.addEdge(id, target, edge_1.EdgeType.Calls);

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