@eagleoutice/flowr 2.9.14 → 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/identifier.d.ts

@@ -39,6 +39,10 @@ export declare const Identifier: {
      * Please note that for `internal` to count, a namespace must be provided!
      */
     readonly make: (this: void, name: BrandedIdentifier, namespace?: BrandedNamespace, internal?: boolean) => Identifier;
+    /**
+     * Verify whether an unknown element has a valid identifier shape!
+     */
+    readonly is: (this: void, id: unknown) => id is Identifier;
     /**
      * Parse an identifier from its string representation,
      * Please note, that in R if one writes `"pkg::a"` this refers to a symbol named `pkg::a` and NOT to the namespaced identifier `a` in package `pkg`.

package/dataflow/environments/identifier.js

@@ -33,6 +33,23 @@ exports.Identifier = {
             return name;
         }
     },
+    /**
+     * Verify whether an unknown element has a valid identifier shape!
+     */
+    is(id) {
+        if (typeof id === 'string') {
+            return true;
+        }
+        if (Array.isArray(id)) {
+            if (id.length === 2) {
+                return typeof id[0] === 'string' && typeof id[1] === 'string';
+            }
+            else if (id.length === 3) {
+                return typeof id[0] === 'string' && typeof id[1] === 'string' && typeof id[2] === 'boolean';
+            }
+        }
+        return false;
+    },
     /**
      * Parse an identifier from its string representation,
      * Please note, that in R if one writes `"pkg::a"` this refers to a symbol named `pkg::a` and NOT to the namespaced identifier `a` in package `pkg`.

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/call-graph.d.ts

@@ -24,10 +24,6 @@ export declare const CallGraph: {
      * Extracts the sub call graph from the given call graph, starting from the given entry points.
      */
     readonly computeSubCallGraph: (this: void, graph: CallGraph, entryPoints: Set<NodeId>) => CallGraph;
-    /**
-     * Determines whether there is a path from `from` to `to` in the given graph (via any edge type, only respecting direction)
-     */
-    readonly reaches: (this: void, from: NodeId, to: NodeId, graph: DataflowGraph, knownReachability?: DefaultMap<NodeId, Set<NodeId>>) => boolean;
     /**
      * Reduces the call graph by dropping all transitive edges.
      */
@@ -53,8 +49,9 @@ export declare const CallGraph: {
             readonly convert: typeof import("./quads").df2quads;
         };
     };
-    readonly diffGraphs: (this: void, left: import("../../util/diff-graph").NamedGraph, right: import("../../util/diff-graph").NamedGraph, config?: Partial<import("../../util/diff").GenericDiffConfiguration>) => import("../../util/diff-graph").GraphDifferenceReport;
-    readonly invertGraph: (this: void, graph: DataflowGraph, cleanEnv: REnvironmentInformation) => DataflowGraph;
-    readonly resolveGraphCriteria: (graph: DataflowGraph, ctx: import("../../project/context/flowr-analyzer-context").ReadOnlyFlowrAnalyzerContext, idMap?: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").AstIdMap) => DataflowGraph;
+    readonly diffGraphs: <G extends DataflowGraph>(this: void, left: import("../../util/diff-graph").NamedGraph<G>, right: import("../../util/diff-graph").NamedGraph<G>, config?: Partial<import("../../util/diff").GenericDiffConfiguration>) => import("../../util/diff-graph").GraphDifferenceReport;
+    readonly invertGraph: <G extends DataflowGraph>(this: void, graph: G, cleanEnv: REnvironmentInformation) => G;
+    readonly resolveGraphCriteria: <G extends DataflowGraph>(graph: G, ctx: import("../../project/context/flowr-analyzer-context").ReadOnlyFlowrAnalyzerContext, idMap?: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").AstIdMap) => G;
+    readonly reaches: <G extends DataflowGraph>(this: void, from: NodeId, to: NodeId, graph: G, knownReachability?: DefaultMap<NodeId, Set<NodeId>>) => boolean;
     readonly name: "CallGraph";
 };

package/dataflow/graph/call-graph.js

@@ -189,28 +189,6 @@ exports.CallGraph = {
         }
         return result;
     },
-    /**
-     * Determines whether there is a path from `from` to `to` in the given graph (via any edge type, only respecting direction)
-     */
-    reaches(from, to, graph, knownReachability = new defaultmap_1.DefaultMap(() => new Set())) {
-        const visited = new Set();
-        const toVisit = [from];
-        while (toVisit.length > 0) {
-            const currentId = toVisit.pop();
-            if (visited.has(currentId)) {
-                continue;
-            }
-            if (currentId === to || knownReachability.get(currentId).has(to)) {
-                knownReachability.get(from).add(to);
-                return true;
-            }
-            visited.add(currentId);
-            for (const [tar] of graph.outgoingEdges(currentId) ?? []) {
-                toVisit.push(tar);
-            }
-        }
-        return false;
-    },
     /**
      * Reduces the call graph by dropping all transitive edges.
      */

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}.
  *
@@ -41,7 +42,6 @@ export declare const Dataflow: {
          */
         readonly callGraph: {
             readonly computeSubCallGraph: (this: void, graph: CallGraph, entryPoints: Set<NodeId>) => CallGraph;
-            readonly reaches: (this: void, from: NodeId, to: NodeId, graph: DataflowGraph, knownReachability?: import("../../util/collections/defaultmap").DefaultMap<NodeId, Set<NodeId>>) => boolean;
             readonly dropTransitiveEdges: (this: void, graph: CallGraph) => CallGraph;
             readonly compute: (this: void, graph: DataflowGraph) => CallGraph;
             readonly visualize: {
@@ -58,9 +58,10 @@ export declare const Dataflow: {
                     readonly convert: typeof import("./quads").df2quads;
                 };
             };
-            readonly diffGraphs: (this: void, left: import("../../util/diff-graph").NamedGraph, right: import("../../util/diff-graph").NamedGraph, config?: Partial<import("../../util/diff").GenericDiffConfiguration>) => import("../../util/diff-graph").GraphDifferenceReport;
-            readonly invertGraph: (this: void, graph: DataflowGraph, cleanEnv: REnvironmentInformation) => DataflowGraph;
-            readonly resolveGraphCriteria: (graph: DataflowGraph, ctx: import("../../project/context/flowr-analyzer-context").ReadOnlyFlowrAnalyzerContext, idMap?: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").AstIdMap) => DataflowGraph;
+            readonly diffGraphs: <G extends DataflowGraph>(this: void, left: import("../../util/diff-graph").NamedGraph<G>, right: import("../../util/diff-graph").NamedGraph<G>, config?: Partial<import("../../util/diff").GenericDiffConfiguration>) => import("../../util/diff-graph").GraphDifferenceReport;
+            readonly invertGraph: <G extends DataflowGraph>(this: void, graph: G, cleanEnv: REnvironmentInformation) => G;
+            readonly resolveGraphCriteria: <G extends DataflowGraph>(graph: G, ctx: import("../../project/context/flowr-analyzer-context").ReadOnlyFlowrAnalyzerContext, idMap?: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").AstIdMap) => G;
+            readonly reaches: <G extends DataflowGraph>(this: void, from: NodeId, to: NodeId, graph: G, knownReachability?: import("../../util/collections/defaultmap").DefaultMap<NodeId, Set<NodeId>>) => boolean;
             readonly name: "CallGraph";
         };
     };
@@ -87,17 +88,26 @@ export declare const Dataflow: {
      * @param select                - the ids to select in the reduced graph
      * @param includeMissingTargets - if set to true, this will include edges which target vertices that are not selected!
      */
-    readonly reduceGraph: (this: void, graph: DataflowGraph, select: ReadonlySet<NodeId>, includeMissingTargets?: boolean) => DataflowGraph;
+    readonly reduceGraph: <G extends DataflowGraph>(this: void, graph: G, select: ReadonlySet<NodeId>, includeMissingTargets?: boolean) => G;
     /**
      * 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
@@ -120,9 +130,10 @@ export declare const Dataflow: {
             readonly convert: typeof import("./quads").df2quads;
         };
     };
-    readonly diffGraphs: (this: void, left: import("../../util/diff-graph").NamedGraph, right: import("../../util/diff-graph").NamedGraph, config?: Partial<import("../../util/diff").GenericDiffConfiguration>) => import("../../util/diff-graph").GraphDifferenceReport;
-    readonly invertGraph: (this: void, graph: DataflowGraph, cleanEnv: REnvironmentInformation) => DataflowGraph;
-    readonly resolveGraphCriteria: (graph: DataflowGraph, ctx: import("../../project/context/flowr-analyzer-context").ReadOnlyFlowrAnalyzerContext, idMap?: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").AstIdMap) => DataflowGraph;
+    readonly diffGraphs: <G extends DataflowGraph>(this: void, left: import("../../util/diff-graph").NamedGraph<G>, right: import("../../util/diff-graph").NamedGraph<G>, config?: Partial<import("../../util/diff").GenericDiffConfiguration>) => import("../../util/diff-graph").GraphDifferenceReport;
+    readonly invertGraph: <G extends DataflowGraph>(this: void, graph: G, cleanEnv: REnvironmentInformation) => G;
+    readonly resolveGraphCriteria: <G extends DataflowGraph>(graph: G, ctx: import("../../project/context/flowr-analyzer-context").ReadOnlyFlowrAnalyzerContext, idMap?: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").AstIdMap) => G;
+    readonly reaches: <G extends DataflowGraph>(this: void, from: NodeId, to: NodeId, graph: G, knownReachability?: import("../../util/collections/defaultmap").DefaultMap<NodeId, Set<NodeId>>) => boolean;
     readonly name: "Dataflow";
     /**
      * Maps to flowR's main graph object to store and manipulate the dataflow graph

package/dataflow/graph/df-helper.js

@@ -94,29 +94,66 @@ 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.DefinedBy | edge_1.EdgeType.DefinedByOnCall;
         while (queue.length > 0) {
             const nodeId = queue.pop();
             if (nodeId === undefined || visited.has(nodeId) || (consider && !consider.has(nodeId))) {
                 continue;
             }
             visited.add(nodeId);
-            for (const [to, types] of graph.outgoingEdges(nodeId) ?? []) {
-                if (edge_1.DfEdge.includesType(types, followEdges)) {
+            const vtx = graph.get(nodeId);
+            if (vtx === undefined) {
+                continue;
+            }
+            for (const [to, types] of vtx[1]) {
+                if (followEdges === undefined || edge_1.DfEdge.includesType(types, followEdges)) {
                     queue.push(to);
                 }
             }
+            for (const cd of vtx[0].cds ?? []) {
+                queue.push(cd.id);
+            }
         }
         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-helper.d.ts

@@ -7,6 +7,7 @@ import type { REnvironmentInformation } from '../environments/environment';
 import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-analyzer-context';
 import type { AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { DefaultMap } from '../../util/collections/defaultmap';
 /**
  * The underlying functions which work for any graph* like view
  * **Please do not use this object directly but use the helpers**
@@ -19,7 +20,7 @@ export declare const GraphHelper: {
         /**
          * Mermaid rendering helper for dataflow graphs
          * - {@link DataflowMermaid.url}, {@link DataflowMermaid.raw} - to render the graph as a mermaid graph (e.g., in markdown or the mermaid live editor)
-         * - {@link DataflowMermaid.convert} - for the underyling transformation
+         * - {@link DataflowMermaid.convert} - for the underlying transformation
          * @see {@link DataflowMermaid}
          */
         readonly mermaid: {
@@ -40,16 +41,20 @@ export declare const GraphHelper: {
      * If you simply want to check whether they equal, use {@link GraphDifferenceReport#isEqual|`<result>.isEqual()`}.
      * @see {@link diffOfControlFlowGraphs} - for control flow graphs
      */
-    readonly diffGraphs: (this: void, left: NamedGraph, right: NamedGraph, config?: Partial<GenericDiffConfiguration>) => GraphDifferenceReport;
+    readonly diffGraphs: <G extends DataflowGraph>(this: void, left: NamedGraph<G>, right: NamedGraph<G>, config?: Partial<GenericDiffConfiguration>) => GraphDifferenceReport;
     /**
      * Inverts the given dataflow graph by reversing all edges.
      */
-    readonly invertGraph: (this: void, graph: DataflowGraph, cleanEnv: REnvironmentInformation) => DataflowGraph;
+    readonly invertGraph: <G extends DataflowGraph>(this: void, graph: G, cleanEnv: REnvironmentInformation) => G;
     /**
      * Resolves the dataflow graph ids from slicing criterion form to ids.
      * This returns a **new** graph with the resolved ids.
      * The main use-case for this is testing - if you do not know/want to fix the specific id,
      * you can use, e.g. `2@x` as a placeholder for the first x in the second line!
      */
-    readonly resolveGraphCriteria: (graph: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext, idMap?: AstIdMap) => DataflowGraph;
+    readonly resolveGraphCriteria: <G extends DataflowGraph>(graph: G, ctx: ReadOnlyFlowrAnalyzerContext, idMap?: AstIdMap) => G;
+    /**
+     * Determines whether there is a path from `from` to `to` in the given graph (via any edge type, only respecting direction)
+     */
+    readonly reaches: <G extends DataflowGraph>(this: void, from: NodeId, to: NodeId, graph: G, knownReachability?: DefaultMap<NodeId, Set<NodeId>>) => boolean;
 };

package/dataflow/graph/graph-helper.js

@@ -9,6 +9,7 @@ const graph_1 = require("./graph");
 const assert_1 = require("../../util/assert");
 const parse_1 = require("../../slicing/criterion/parse");
 const edge_1 = require("./edge");
+const defaultmap_1 = require("../../util/collections/defaultmap");
 /**
  * The underlying functions which work for any graph* like view
  * **Please do not use this object directly but use the helpers**
@@ -21,7 +22,7 @@ exports.GraphHelper = {
         /**
          * Mermaid rendering helper for dataflow graphs
          * - {@link DataflowMermaid.url}, {@link DataflowMermaid.raw} - to render the graph as a mermaid graph (e.g., in markdown or the mermaid live editor)
-         * - {@link DataflowMermaid.convert} - for the underyling transformation
+         * - {@link DataflowMermaid.convert} - for the underlying transformation
          * @see {@link DataflowMermaid}
          */
         mermaid: dfg_1.DataflowMermaid,
@@ -70,7 +71,7 @@ exports.GraphHelper = {
             if (cached !== undefined) {
                 return cached;
             }
-            const resolved = parse_1.SingleSlicingCriterion.tryParse(id, resolveMap) ?? id;
+            const resolved = parse_1.SlicingCriterion.tryParse(id, resolveMap) ?? id;
             cache.set(id, resolved);
             return resolved;
         };
@@ -100,6 +101,28 @@ exports.GraphHelper = {
             }
         }
         return resultGraph;
-    }
+    },
+    /**
+     * Determines whether there is a path from `from` to `to` in the given graph (via any edge type, only respecting direction)
+     */
+    reaches(from, to, graph, knownReachability = new defaultmap_1.DefaultMap(() => new Set())) {
+        const visited = new Set();
+        const toVisit = [from];
+        while (toVisit.length > 0) {
+            const currentId = toVisit.pop();
+            if (visited.has(currentId)) {
+                continue;
+            }
+            if (currentId === to || knownReachability.get(currentId).has(to)) {
+                knownReachability.get(from).add(to);
+                return true;
+            }
+            visited.add(currentId);
+            for (const [tar] of graph.outgoingEdges(currentId) ?? []) {
+                toVisit.push(tar);
+            }
+        }
+        return false;
+    },
 };
 //# sourceMappingURL=graph-helper.js.map

package/dataflow/graph/graph.d.ts

@@ -25,6 +25,7 @@ export type DataflowFunctionFlowInformation = Omit<DataflowInformation, 'graph'
  */
 export interface NamedFunctionArgument extends IdentifierReference {
     readonly name: string;
+    readonly valueId: NodeId | undefined;
 }
 /**
  * A reference which does not have a name, like the references to the arguments `3` and `2` in the following:
@@ -32,7 +33,6 @@ export interface NamedFunctionArgument extends IdentifierReference {
  * ```r
  * foo(3, 2)
  * ```
- * @see #isPositionalArgument
  * @see NamedFunctionArgument
  */
 export interface PositionalFunctionArgument extends Omit<IdentifierReference, 'name'> {
@@ -95,12 +95,32 @@ export declare const FunctionArgument: {
      * @see {@link FunctionArgument.isEmpty}
      */
     readonly isNotEmpty: <T>(this: void, arg: T) => arg is Exclude<T, typeof EmptyArgument>;
+    /**
+     * Returns the id of a non-empty argument.
+     * @example
+     * ```r
+     * 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
      * ```r
      * foo(a=3, 2) # returns the node id of either `3` or `2`, but skips a
      * ```
+     * @see {@link FunctionArgument.getId}
      */
     readonly getReference: (this: void, arg: FunctionArgument) => NodeId | undefined;
     /**
@@ -259,8 +279,9 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
     /**
      * 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: IdentifierReference): void;
+    setDefinitionOfVertex(reference: IdentifierReference, sourceIds: readonly NodeId[] | undefined): void;
     /**
      * Marks a vertex in the graph to be a function call with the new information
      * @param info - The information about the new function call node