@eagleoutice/flowr 2.10.1 → 2.10.2

package/dataflow/environments/default-builtin-config.js

@@ -132,6 +132,7 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['Lapply', 'Sapply', 'Vapply'], processor: built_in_proc_name_1.BuiltInProcName.Apply, config: { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false }, /* functool wrappers */
     { type: 'function', names: ['apply', 'tapply', 'Tapply'], processor: built_in_proc_name_1.BuiltInProcName.Apply, config: { indexOfFunction: 2, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
     { type: 'function', names: ['print', 'message', 'warning', 'warn', 'info'], processor: built_in_proc_name_1.BuiltInProcName.Default, config: { returnsNthArgument: 0, forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
+    { type: 'function', names: ['invisible'], processor: built_in_proc_name_1.BuiltInProcName.Default, config: { returnsNthArgument: 0, forceArgs: 'all' }, assumePrimitive: true },
     // graphics base
     { type: 'function', names: exports.PlotCreate,
         processor: built_in_proc_name_1.BuiltInProcName.Default,
@@ -254,7 +255,7 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['ifelse', 'fifelse', 'IfElse'], processor: built_in_proc_name_1.BuiltInProcName.IfThenElse, config: { args: { cond: 'test', yes: 'yes', no: 'no' } }, assumePrimitive: true },
     { type: 'function', names: ['if_else'], processor: built_in_proc_name_1.BuiltInProcName.IfThenElse, config: { args: { cond: 'condition', yes: 'true', no: 'false' } }, assumePrimitive: true },
     { type: 'function', names: ['get'], processor: built_in_proc_name_1.BuiltInProcName.Get, config: {}, assumePrimitive: false },
-    { type: 'function', names: [identifier_1.Identifier.make('library', 'base'), identifier_1.Identifier.make('require', 'base')], processor: built_in_proc_name_1.BuiltInProcName.Library, config: {}, assumePrimitive: false },
+    { type: 'function', names: [identifier_1.Identifier.make('from', 'import'), identifier_1.Identifier.make('library', 'base'), identifier_1.Identifier.make('require', 'base')], processor: built_in_proc_name_1.BuiltInProcName.Library, config: {}, assumePrimitive: false },
     { type: 'function', names: ['<-', '='], processor: built_in_proc_name_1.BuiltInProcName.Assignment, config: { canBeReplacement: true }, assumePrimitive: true },
     { type: 'function', names: [':='], processor: built_in_proc_name_1.BuiltInProcName.Assignment, config: {}, assumePrimitive: true },
     { type: 'function', names: ['assign', 'setValidity'], processor: built_in_proc_name_1.BuiltInProcName.Assignment, config: { targetVariable: true, mayHaveMoreArgs: true }, assumePrimitive: true },
@@ -265,9 +266,160 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['->>'], processor: built_in_proc_name_1.BuiltInProcName.Assignment, config: { superAssignment: true, swapSourceAndTarget: true, canBeReplacement: true }, assumePrimitive: true },
     { type: 'function', names: ['&&', '&'], processor: built_in_proc_name_1.BuiltInProcName.SpecialBinOp, config: { lazy: true, evalRhsWhen: true }, assumePrimitive: true },
     { type: 'function', names: ['||', '|'], processor: built_in_proc_name_1.BuiltInProcName.SpecialBinOp, config: { lazy: true, evalRhsWhen: false }, assumePrimitive: true },
-    { type: 'function', names: ['|>', '%>%'], processor: built_in_proc_name_1.BuiltInProcName.Pipe, config: {}, assumePrimitive: true },
+    { type: 'function', names: ['|>'], processor: built_in_proc_name_1.BuiltInProcName.Pipe, config: { pipePlaceholderName: '_' }, assumePrimitive: true },
+    { type: 'function', names: ['%>%', '%!>%'], processor: built_in_proc_name_1.BuiltInProcName.Pipe, config: { pipePlaceholderName: '.', rhsMightBeSymbol: true }, assumePrimitive: true },
+    { type: 'function', names: ['%<>%'], processor: built_in_proc_name_1.BuiltInProcName.Pipe, config: { pipePlaceholderName: '.', assignLhs: true, rhsMightBeSymbol: true }, assumePrimitive: true },
+    { type: 'function', names: ['%T>%'], processor: built_in_proc_name_1.BuiltInProcName.Pipe, config: { pipePlaceholderName: '.', returnLhs: true, rhsMightBeSymbol: true }, assumePrimitive: true },
+    { type: 'function', names: [identifier_1.Identifier.make('map', 'purrr'), identifier_1.Identifier.make('map_lgl', 'purrr'), identifier_1.Identifier.make('map_int', 'purrr'), identifier_1.Identifier.make('map_dbl', 'purrr'), identifier_1.Identifier.make('map_chr', 'purrr')], processor: built_in_proc_name_1.BuiltInProcName.PurrrFormula, config: {
+            args: {
+                '.x': { index: 0, name: '.x' }
+            },
+            '.f': { index: 1, name: '.f' },
+            ignore: ['.progress']
+        } },
+    { type: 'function', names: [identifier_1.Identifier.make('pmap', 'purrr'), identifier_1.Identifier.make('pmap_lgl', 'purrr'), identifier_1.Identifier.make('pmap_int', 'purrr'), identifier_1.Identifier.make('pmap_dbl', 'purrr'), identifier_1.Identifier.make('pmap_chr', 'purrr')], processor: built_in_proc_name_1.BuiltInProcName.PurrrFormula, config: {
+            args: {
+                '.l': { index: 0, name: '.l' }
+            },
+            '.f': { index: 1, name: '.f' },
+            ignore: ['.progress']
+        } },
+    { type: 'function', names: [identifier_1.Identifier.make('map2', 'purrr'), identifier_1.Identifier.make('map2_lgl', 'purrr'), identifier_1.Identifier.make('map2_int', 'purrr'), identifier_1.Identifier.make('map2_dbl', 'purrr'), identifier_1.Identifier.make('map2_chr', 'purrr')], processor: built_in_proc_name_1.BuiltInProcName.PurrrFormula, config: {
+            args: {
+                '.x': { index: 0, name: '.x' },
+                '.y': { index: 1, name: '.y' },
+            },
+            '.f': { index: 2, name: '.f' },
+            ignore: ['.progress']
+        } },
+    { type: 'function', names: [identifier_1.Identifier.make('modify', 'purrr'), identifier_1.Identifier.make('imodify', 'purrr'), identifier_1.Identifier.make('imap', 'purrr'), identifier_1.Identifier.make('imap_lgl', 'purrr'), identifier_1.Identifier.make('imap_int', 'purrr'), identifier_1.Identifier.make('imap_dbl', 'purrr'), identifier_1.Identifier.make('imap_chr', 'purrr'), identifier_1.Identifier.make('imap_vec', 'purrr'), identifier_1.Identifier.make('lmap', 'purrr')], processor: built_in_proc_name_1.BuiltInProcName.PurrrFormula, config: {
+            args: {
+                '.x': { index: 0, name: '.x' }
+            },
+            '.f': { index: 1, name: '.f' },
+            ignore: []
+        } },
+    { type: 'function', names: [identifier_1.Identifier.make('modify2', 'purrr')], processor: built_in_proc_name_1.BuiltInProcName.PurrrFormula, config: {
+            args: {
+                '.x': { index: 0, name: '.x' },
+                '.y': { index: 1, name: '.y' }
+            },
+            '.f': { index: 2, name: '.f' },
+            ignore: []
+        } },
+    { type: 'function', names: [identifier_1.Identifier.make('map_at', 'purrr'), identifier_1.Identifier.make('modify_at', 'purrr')], processor: built_in_proc_name_1.BuiltInProcName.PurrrFormula, config: {
+            args: {
+                '.x': { index: 0, name: '.x' },
+                '.at': { index: 1, name: '.at' },
+            },
+            '.f': { index: 2, name: '.f' },
+            ignore: ['.progress']
+        } },
+    { type: 'function', names: [identifier_1.Identifier.make('lmap_at', 'purrr')], processor: built_in_proc_name_1.BuiltInProcName.PurrrFormula, config: {
+            args: {
+                '.x': { index: 0, name: '.x' },
+                '.at': { index: 1, name: '.at' },
+            },
+            '.f': { index: 2, name: '.f' },
+            ignore: []
+        } },
+    { type: 'function', names: [identifier_1.Identifier.make('map_if', 'purrr'), identifier_1.Identifier.make('modify_if', 'purrr'), identifier_1.Identifier.make('lmap_if', 'purrr')], processor: built_in_proc_name_1.BuiltInProcName.PurrrFormula, config: {
+            args: {
+                '.x': { index: 0, name: '.x' },
+                '.p': { index: 1, name: '.p' },
+            },
+            '.f': { index: 2, name: '.f' },
+            ignore: ['.else']
+        } },
+    { type: 'function', names: [identifier_1.Identifier.make('walk', 'purrr')], processor: built_in_proc_name_1.BuiltInProcName.PurrrFormula, config: {
+            args: {
+                '.x': { index: 0, name: '.x' }
+            },
+            '.f': { index: 1, name: '.f' },
+            ignore: ['.progress'],
+            returnArg: '.x'
+        } },
+    { type: 'function', names: [identifier_1.Identifier.make('iwalk', 'purrr')], processor: built_in_proc_name_1.BuiltInProcName.PurrrFormula, config: {
+            args: {
+                '.x': { index: 0, name: '.x' }
+            },
+            '.f': { index: 1, name: '.f' },
+            ignore: [],
+            returnArg: '.x'
+        } },
+    { type: 'function', names: [identifier_1.Identifier.make('pwalk', 'purrr')], processor: built_in_proc_name_1.BuiltInProcName.PurrrFormula, config: {
+            args: {
+                '.l': { index: 0, name: '.l' }
+            },
+            '.f': { index: 1, name: '.f' },
+            ignore: ['.progress'],
+            returnArg: '.l'
+        } },
+    { type: 'function', names: [identifier_1.Identifier.make('walk2', 'purrr')], processor: built_in_proc_name_1.BuiltInProcName.PurrrFormula, config: {
+            args: {
+                '.x': { index: 0, name: '.x' },
+                '.y': { index: 1, name: '.y' }
+            },
+            '.f': { index: 2, name: '.f' },
+            ignore: ['.progress'],
+            returnArg: '.x'
+        } },
+    { type: 'function', names: [identifier_1.Identifier.make('map_vec', 'purrr')], processor: built_in_proc_name_1.BuiltInProcName.PurrrFormula, config: {
+            args: {
+                '.x': { index: 0, name: '.x' }
+            },
+            '.f': { index: 1, name: '.f' },
+            ignore: ['.progress', '.ptype']
+        } },
+    { type: 'function', names: [identifier_1.Identifier.make('pmap_vec', 'purrr')], processor: built_in_proc_name_1.BuiltInProcName.PurrrFormula, config: {
+            args: {
+                '.l': { index: 0, name: '.l' }
+            },
+            '.f': { index: 1, name: '.f' },
+            ignore: ['.progress', '.ptype']
+        } },
+    { type: 'function', names: [identifier_1.Identifier.make('map_depth', 'purrr'), identifier_1.Identifier.make('modify_depth', 'purrr')], processor: built_in_proc_name_1.BuiltInProcName.PurrrFormula, config: {
+            args: {
+                '.x': { index: 0, name: '.x' },
+                '.depth': { index: 2, name: '.depth' }
+            },
+            '.f': { index: 2, name: '.f' },
+            ignore: ['.ragged', '.is_node']
+        } },
+    { type: 'function', names: [identifier_1.Identifier.make('map2_vec', 'purrr')], processor: built_in_proc_name_1.BuiltInProcName.PurrrFormula, config: {
+            args: {
+                '.x': { index: 0, name: '.x' },
+                '.y': { index: 1, name: '.y' }
+            },
+            '.f': { index: 2, name: '.f' },
+            ignore: ['.progress', '.ptype']
+        } },
+    { type: 'function', names: [identifier_1.Identifier.make('across', 'dplyr')], processor: built_in_proc_name_1.BuiltInProcName.PurrrFormula, config: {
+            args: {
+                '.x': { index: 0, name: '.cols' },
+            },
+            '.f': { index: 1, name: '.fns' },
+            ignore: ['.names', '.unpack']
+        } },
+    { type: 'function', names: [identifier_1.Identifier.make('filter', 'dplyr'), identifier_1.Identifier.make('filter_out', 'dplyr')], processor: built_in_proc_name_1.BuiltInProcName.PurrrFormula, config: {
+            args: {
+                '.x': { index: 0, name: '.data' },
+            },
+            '.f': { index: 1, name: '...' },
+            ignore: ['.by', '.preserve']
+        } },
+    { type: 'function', names: [identifier_1.Identifier.make('rename_with', 'dplyr')], processor: built_in_proc_name_1.BuiltInProcName.PurrrFormula, config: {
+            args: {
+                '.x': { index: 0, name: '.data' },
+            },
+            '.f': { index: 1, name: '.fn' },
+            ignore: ['.cols']
+        } },
     { type: 'function', names: ['function', '\\'], processor: built_in_proc_name_1.BuiltInProcName.FunctionDefinition, config: {}, assumePrimitive: true },
-    { type: 'function', names: ['quote', 'substitute', 'bquote'], processor: built_in_proc_name_1.BuiltInProcName.Quote, config: { quoteArgumentsWithIndex: 0 }, assumePrimitive: true },
+    { type: 'function', names: ['quote', 'bquote'], processor: built_in_proc_name_1.BuiltInProcName.Quote, config: { quoteArgumentsWithIndex: 0 }, assumePrimitive: true },
+    { type: 'function', names: ['substitute'], processor: built_in_proc_name_1.BuiltInProcName.Quote, config: { quoteArgumentsWithIndex: 0, envArgIndex: 1 }, assumePrimitive: true },
+    { type: 'function', names: [identifier_1.Identifier.make('enquo', 'rlang'), identifier_1.Identifier.make('enquos', 'rlang'), identifier_1.Identifier.make('quo', 'rlang'), identifier_1.Identifier.make('quos', 'rlang'), identifier_1.Identifier.make('sym', 'rlang'), identifier_1.Identifier.make('syms', 'rlang'), identifier_1.Identifier.make('ensym', 'rlang'), identifier_1.Identifier.make('ensyms', 'rlang'), identifier_1.Identifier.make('expr', 'rlang'), identifier_1.Identifier.make('exprs', 'rlang'), identifier_1.Identifier.make('quo_name', 'rlang'), identifier_1.Identifier.make('as_name', 'rlang'), identifier_1.Identifier.make('as_label', 'rlang'), identifier_1.Identifier.make('as_string', 'rlang')], processor: built_in_proc_name_1.BuiltInProcName.Quote, config: { quoteArgumentsWithIndex: 0, libFn: true }, assumePrimitive: true },
+    { type: 'function', names: [identifier_1.Identifier.make('call2', 'rlang'), identifier_1.Identifier.make('exec', 'rlang'), identifier_1.Identifier.make('invoke', 'purrr'), identifier_1.Identifier.make('invoke_map', 'purrr')], processor: built_in_proc_name_1.BuiltInProcName.Default, config: { libFn: true, hasUnknownSideEffects: true, unquoteFunction: true }, assumePrimitive: false },
     { type: 'function', names: ['local'], processor: built_in_proc_name_1.BuiltInProcName.Local, config: { args: { env: 'envir', expr: 'expr' } }, assumePrimitive: false },
     { type: 'function', names: ['for'], processor: built_in_proc_name_1.BuiltInProcName.ForLoop, config: {}, assumePrimitive: true },
     { type: 'function', names: ['repeat'], processor: built_in_proc_name_1.BuiltInProcName.RepeatLoop, config: {}, assumePrimitive: true },
@@ -283,6 +435,7 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['ddply'], processor: built_in_proc_name_1.BuiltInProcName.Apply, config: { unquoteFunction: true, indexOfFunction: 2, nameOfFunctionArgument: '.fun', libFn: true }, assumePrimitive: false },
     { type: 'function', names: ['list'], processor: built_in_proc_name_1.BuiltInProcName.List, config: {}, assumePrimitive: true },
     { type: 'function', names: ['Recall'], processor: built_in_proc_name_1.BuiltInProcName.Recall, config: { libFn: true }, assumePrimitive: false },
+    { type: 'function', names: ['sys.function'], processor: built_in_proc_name_1.BuiltInProcName.Recall, config: { libFn: true, unknownOnNonZeroArg: true }, assumePrimitive: false },
     { type: 'function', names: ['c'], processor: built_in_proc_name_1.BuiltInProcName.Vector, config: {}, assumePrimitive: true, evalHandler: 'built-in:c' },
     {
         type: 'function',
@@ -301,6 +454,7 @@ exports.DefaultBuiltinConfig = [
             'sys.on.exit', 'par', 'tpar', 'sink',
             /* library and require is handled above */
             'requireNamespace', 'loadNamespace', 'attachNamespace', 'asNamespace',
+            identifier_1.Identifier.make('use', 'base'),
             /* weird env attachments */
             'attach', 'unname', 'data',
             /* file creation/removal */
@@ -314,6 +468,7 @@ exports.DefaultBuiltinConfig = [
         type: 'function',
         names: [
             'tinytheme', 'theme_set',
+            identifier_1.Identifier.make('context', 'testthat'),
             /* downloader and installer functions (R, devtools, BiocManager) */
             'library.dynam', 'install.packages', 'install', 'install_github', 'install_gitlab', 'install_bitbucket', 'install_url', 'install_git', 'install_svn', 'install_local', 'install_version', 'update_packages',
         ],

package/dataflow/environments/overwrite.js

@@ -8,11 +8,8 @@ const scoping_1 = require("./scoping");
  * @see {@link Environment.overwrite} - for details on how definitions are handled.
  */
 function overwriteEnvironment(base, next, applyCds) {
-    if (base === undefined) {
-        return next;
-    }
-    else if (next === undefined) {
-        return base;
+    if (base === undefined || next === undefined) {
+        return next ?? base;
     }
     if (base.level !== next.level) {
         while (next.level < base.level) {

package/dataflow/graph/df-helper.d.ts

@@ -5,6 +5,7 @@ import { getOriginInDfg } from '../origin/dfg-get-origin';
 import { CallGraph } from './call-graph';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { REnvironmentInformation } from '../environments/environment';
+import type { DataflowGraphVertexInfo } from './vertex';
 /**
  * This is the root helper object to work with the {@link DataflowGraph}.
  *
@@ -92,12 +93,21 @@ export declare const Dataflow: {
      * Given the id of a vertex (usually a variable use),
      * this returns a reachable provenance set by calculating a non-interprocedural and non-context sensitive backward slice, but stopping at the given ids!
      * You can obtain the corresponding graph using {@link Dataflow.reduceGraph}.
-     * @param id       - The id to use as a seed for provenance calculation
-     * @param graph    - The graph to perform the provenance calculation on
-     * @param consider - The ids to restrict the calculation too (e.g., the ids contained within a function definition to restrict the analysis to)
+     * @param id          - The id to use as a seed for provenance calculation
+     * @param graph       - The graph to perform the provenance calculation on
+     * @param consider    - The ids to restrict the calculation too (e.g., the ids contained within a function definition to restrict the analysis to)
+     * @param followEdges - Which edges to consider in the provenance traversal, if you set this to undefined this will automatically track all edges
      * @see {@link Dataflow.provenanceGraph} - for a convenience wrapper to directly obtain the graph of the provenance.
      */
-    readonly provenance: (this: void, id: NodeId, graph: DataflowGraph, consider?: ReadonlySet<NodeId>) => Set<NodeId>;
+    readonly provenance: (this: void, id: NodeId, graph: DataflowGraph, consider?: ReadonlySet<NodeId>, followEdges?: number | undefined) => Set<NodeId>;
+    /**
+     * A simple visitor akin to {@link RNode.visitAst} to traverse the dataflow graph starting from the start id and only
+     * respecting edge direction.
+     * @param graph      - The dataflow graph to operate on.
+     * @param start      - The start id of the visitation.
+     * @param onVertex   - The function to execute for each vertex, if this returns `true` the visitation will stop from this vertex.
+     */
+    readonly visitDfg: (this: void, graph: DataflowGraph, start: NodeId, onVertex: (vtx: DataflowGraphVertexInfo) => (boolean | void)) => void;
     /**
      * A convenience wrapper for {@link Dataflow.reduceGraph|reducing} the {@link Dataflow.provenance|provenance} of a graph.
      * @param id       - The id to use as a seed for provenance calculation

package/dataflow/graph/df-helper.js

@@ -94,15 +94,15 @@ exports.Dataflow = {
      * Given the id of a vertex (usually a variable use),
      * this returns a reachable provenance set by calculating a non-interprocedural and non-context sensitive backward slice, but stopping at the given ids!
      * You can obtain the corresponding graph using {@link Dataflow.reduceGraph}.
-     * @param id       - The id to use as a seed for provenance calculation
-     * @param graph    - The graph to perform the provenance calculation on
-     * @param consider - The ids to restrict the calculation too (e.g., the ids contained within a function definition to restrict the analysis to)
+     * @param id          - The id to use as a seed for provenance calculation
+     * @param graph       - The graph to perform the provenance calculation on
+     * @param consider    - The ids to restrict the calculation too (e.g., the ids contained within a function definition to restrict the analysis to)
+     * @param followEdges - Which edges to consider in the provenance traversal, if you set this to undefined this will automatically track all edges
      * @see {@link Dataflow.provenanceGraph} - for a convenience wrapper to directly obtain the graph of the provenance.
      */
-    provenance(id, graph, consider) {
+    provenance(id, graph, consider, followEdges = edge_1.EdgeType.Calls | edge_1.EdgeType.Reads | edge_1.EdgeType.Returns | edge_1.EdgeType.Argument | edge_1.EdgeType.DefinedBy | edge_1.EdgeType.DefinedByOnCall) {
         const queue = [id];
         const visited = new Set();
-        const followEdges = edge_1.EdgeType.Calls | edge_1.EdgeType.Reads | edge_1.EdgeType.Returns | edge_1.EdgeType.Argument | edge_1.EdgeType.DefinedBy | edge_1.EdgeType.DefinedByOnCall;
         while (queue.length > 0) {
             const nodeId = queue.pop();
             if (nodeId === undefined || visited.has(nodeId) || (consider && !consider.has(nodeId))) {
@@ -114,7 +114,7 @@ exports.Dataflow = {
                 continue;
             }
             for (const [to, types] of vtx[1]) {
-                if (edge_1.DfEdge.includesType(types, followEdges)) {
+                if (followEdges === undefined || edge_1.DfEdge.includesType(types, followEdges)) {
                     queue.push(to);
                 }
             }
@@ -124,6 +124,36 @@ exports.Dataflow = {
         }
         return visited;
     },
+    /**
+     * A simple visitor akin to {@link RNode.visitAst} to traverse the dataflow graph starting from the start id and only
+     * respecting edge direction.
+     * @param graph      - The dataflow graph to operate on.
+     * @param start      - The start id of the visitation.
+     * @param onVertex   - The function to execute for each vertex, if this returns `true` the visitation will stop from this vertex.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+    visitDfg(graph, start, onVertex) {
+        const queue = [start];
+        const visited = new Set();
+        while (queue.length > 0) {
+            const nodeId = queue.pop();
+            if (nodeId === undefined || visited.has(nodeId)) {
+                continue;
+            }
+            visited.add(nodeId);
+            const vtx = graph.get(nodeId);
+            if (vtx === undefined) {
+                continue;
+            }
+            const shouldStop = onVertex(vtx[0]);
+            if (shouldStop) {
+                continue;
+            }
+            for (const [to] of vtx[1]) {
+                queue.push(to);
+            }
+        }
+    },
     /**
      * A convenience wrapper for {@link Dataflow.reduceGraph|reducing} the {@link Dataflow.provenance|provenance} of a graph.
      * @param id       - The id to use as a seed for provenance calculation

package/dataflow/graph/graph.d.ts

@@ -102,8 +102,18 @@ export declare const FunctionArgument: {
      * foo(a=3, 2) # returns the node id of either `a` or `2`
      * ```
      * @see {@link FunctionArgument.getReference}
+     * @see {@link FunctionArgument.getName}
      */
     readonly getId: (this: void, arg: FunctionArgument) => NodeId | undefined;
+    /**
+     * Returns the name of a named argument.
+     * @example
+     * ```r
+     * foo(a = 3, 2) # returns 'a' or undefined
+     * ```
+     * @see {@link FunctionArgument.getId}
+     */
+    readonly getName: (this: void, arg: FunctionArgument) => string | undefined;
     /**
      * Returns the reference of a non-empty argument.
      * @example

package/dataflow/graph/graph.js

@@ -74,6 +74,7 @@ exports.FunctionArgument = {
      * foo(a=3, 2) # returns the node id of either `a` or `2`
      * ```
      * @see {@link FunctionArgument.getReference}
+     * @see {@link FunctionArgument.getName}
      */
     getId(arg) {
         if (arg !== r_function_call_1.EmptyArgument) {
@@ -81,6 +82,17 @@ exports.FunctionArgument = {
         }
         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

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

@@ -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);