@eagleoutice/flowr 2.9.1 → 2.9.2

package/README.md

@@ -24,7 +24,7 @@ It offers a wide variety of features, for example:
     
     ```shell
     $ docker run -it --rm eagleoutice/flowr # or npm run flowr 
-    flowR repl using flowR v2.9.0, R grammar v14 (tree-sitter engine)
+    flowR repl using flowR v2.9.1, R grammar v14 (tree-sitter engine)
     R> :query @linter "read.csv(\"/root/x.txt\")"
     ```
     
@@ -39,7 +39,7 @@ It offers a wide variety of features, for example:
        ╰ File Path Validity (file-path-validity):
            ╰ certain:
                ╰ Path `/root/x.txt` at 1.1-23
-           ╰ Metadata: totalReads: 1, totalUnknown: 0, totalWritesBeforeAlways: 0, totalValid: 0, searchTimeMs: 1, processTimeMs: 0
+           ╰ Metadata: totalReads: 1, totalUnknown: 0, totalWritesBeforeAlways: 0, totalValid: 0, searchTimeMs: 0, processTimeMs: 1
        ╰ Seeded Randomness (seeded-randomness):
            ╰ Metadata: consumerCalls: 0, callsWithFunctionProducers: 0, callsWithAssignmentProducers: 0, callsWithNonConstantProducers: 0, callsWithOtherBranchProducers: 0, searchTimeMs: 0, processTimeMs: 0
        ╰ Absolute Paths (absolute-file-paths):
@@ -53,12 +53,12 @@ It offers a wide variety of features, for example:
        ╰ Network Functions (network-functions):
            ╰ Metadata: totalCalls: 0, totalFunctionDefinitions: 0, searchTimeMs: 0, processTimeMs: 0
        ╰ Dataframe Access Validation (dataframe-access-validation):
-           ╰ Metadata: numOperations: 0, numAccesses: 0, totalAccessed: 0, searchTimeMs: 0, processTimeMs: 1
+           ╰ Metadata: numOperations: 0, numAccesses: 0, totalAccessed: 0, searchTimeMs: 0, processTimeMs: 0
        ╰ Dead Code (dead-code):
-           ╰ Metadata: consideredNodes: 5, searchTimeMs: 0, processTimeMs: 0
+           ╰ Metadata: consideredNodes: 5, searchTimeMs: 1, processTimeMs: 0
        ╰ Useless Loops (useless-loop):
            ╰ Metadata: numOfUselessLoops: 0, searchTimeMs: 0, processTimeMs: 0
-    All queries together required ≈2 ms (1ms accuracy, total 2 ms)
+    All queries together required ≈2 ms (1ms accuracy, total 3 ms)
     ```
     
     
@@ -82,7 +82,7 @@ It offers a wide variety of features, for example:
     
     Query: **linter** (2 ms)\
        ╰ **Deprecated Functions** (deprecated-functions):\
-    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>totalCalls: 0, totalFunctionDefinitions: 0, searchTimeMs: 0, processTimeMs: 1</code>\
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>totalCalls: 0, totalFunctionDefinitions: 0, searchTimeMs: 1, processTimeMs: 0</code>\
     &nbsp;&nbsp;&nbsp;╰ **File Path Validity** (file-path-validity):\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ certain:\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ Path `/root/x.txt` at 1.1-23\
@@ -96,7 +96,7 @@ It offers a wide variety of features, for example:
     &nbsp;&nbsp;&nbsp;╰ **Unused Definitions** (unused-definitions):\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>totalConsidered: 0, searchTimeMs: 0, processTimeMs: 0</code>\
     &nbsp;&nbsp;&nbsp;╰ **Naming Convention** (naming-convention):\
-    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>numMatches: 0, numBreak: 0, searchTimeMs: 0, processTimeMs: 0</code>\
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>numMatches: 0, numBreak: 0, searchTimeMs: 1, processTimeMs: 0</code>\
     &nbsp;&nbsp;&nbsp;╰ **Network Functions** (network-functions):\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>totalCalls: 0, totalFunctionDefinitions: 0, searchTimeMs: 0, processTimeMs: 0</code>\
     &nbsp;&nbsp;&nbsp;╰ **Dataframe Access Validation** (dataframe-access-validation):\
@@ -109,7 +109,7 @@ It offers a wide variety of features, for example:
     
     <details> <summary style="color:gray">Show Detailed Results as Json</summary>
     
-    The analysis required _2.2 ms_ (including parsing and normalization and the query) within the generation environment.
+    The analysis required _2.3 ms_ (including parsing and normalization and the query) within the generation environment.
     
     In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
     Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -126,8 +126,8 @@ It offers a wide variety of features, for example:
             ".meta": {
               "totalCalls": 0,
               "totalFunctionDefinitions": 0,
-              "searchTimeMs": 0,
-              "processTimeMs": 1
+              "searchTimeMs": 1,
+              "processTimeMs": 0
             }
           },
           "file-path-validity": {
@@ -198,7 +198,7 @@ It offers a wide variety of features, for example:
             ".meta": {
               "numMatches": 0,
               "numBreak": 0,
-              "searchTimeMs": 0,
+              "searchTimeMs": 1,
               "processTimeMs": 0
             }
           },
@@ -308,7 +308,7 @@ It offers a wide variety of features, for example:
     
     ```shell
     $ docker run -it --rm eagleoutice/flowr # or npm run flowr 
-    flowR repl using flowR v2.9.0, R grammar v14 (tree-sitter engine)
+    flowR repl using flowR v2.9.1, R grammar v14 (tree-sitter engine)
     R> :query @static-slice (11@sum) file://test/testfiles/example.R
     ```
     
@@ -322,7 +322,7 @@ It offers a wide variety of features, for example:
     N <- 10
     for(i in 1:(N-1)) sum <- sum + i + w
     sum
-    All queries together required ≈3 ms (1ms accuracy, total 4 ms)
+    All queries together required ≈4 ms (1ms accuracy, total 4 ms)
     ```
     
     
@@ -356,7 +356,7 @@ It offers a wide variety of features, for example:
          
 
 * 🚀 **fast call-graph, data-, and control-flow graphs**\
-  Within just [<i><span title="This measurement is automatically fetched from the latest benchmark!">117.5 ms</span></i> (as of Feb 2, 2026)](https://flowr-analysis.github.io/flowr/wiki/stats/benchmark), 
+  Within just [<i><span title="This measurement is automatically fetched from the latest benchmark!">118 ms</span></i> (as of Feb 3, 2026)](https://flowr-analysis.github.io/flowr/wiki/stats/benchmark), 
   _flowR_ can analyze the data- and control-flow of the average real-world R script. See the [benchmarks](https://flowr-analysis.github.io/flowr/wiki/stats/benchmark) for more information,
   and consult the [wiki pages](https://github.com/flowr-analysis/flowr/wiki/wiki/dataflow-graph) for more details on the dataflow graphs as well as call graphs.
 
@@ -392,7 +392,7 @@ It offers a wide variety of features, for example:
     
     ```shell
     $ docker run -it --rm eagleoutice/flowr # or npm run flowr 
-    flowR repl using flowR v2.9.0, R grammar v14 (tree-sitter engine)
+    flowR repl using flowR v2.9.1, R grammar v14 (tree-sitter engine)
     R> :dataflow* test/testfiles/example.R
     ```
     
@@ -697,7 +697,7 @@ It offers a wide variety of features, for example:
     ```
     
     	
-    (The analysis required _1.7 ms_ (including parse and normalize, using the [tree-sitter](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment.)
+    (The analysis required _1.9 ms_ (including parse and normalize, using the [tree-sitter](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment.)
     
     
     

package/dataflow/environments/default-builtin-config.d.ts

@@ -426,6 +426,7 @@ export declare const DefaultBuiltinConfig: [{
             readonly idx: 2;
             readonly name: "definition";
         };
+        readonly modesForFn: ["s4"];
     };
     readonly assumePrimitive: true;
 }, {

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

@@ -258,7 +258,7 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['<-', '='], processor: built_in_1.BuiltInProcName.Assignment, config: { canBeReplacement: true }, assumePrimitive: true },
     { type: 'function', names: [':='], processor: built_in_1.BuiltInProcName.Assignment, config: {}, assumePrimitive: true },
     { type: 'function', names: ['assign', 'setValidity'], processor: built_in_1.BuiltInProcName.Assignment, config: { targetVariable: true, mayHaveMoreArgs: true }, assumePrimitive: true },
-    { type: 'function', names: ['setMethod'], processor: built_in_1.BuiltInProcName.AssignmentLike, config: { targetVariable: true, canBeReplacement: false, target: { idx: 0, name: 'f' }, source: { idx: 2, name: 'definition' } }, assumePrimitive: true },
+    { type: 'function', names: ['setMethod'], processor: built_in_1.BuiltInProcName.AssignmentLike, config: { targetVariable: true, canBeReplacement: false, target: { idx: 0, name: 'f' }, source: { idx: 2, name: 'definition' }, modesForFn: ['s4'] }, assumePrimitive: true },
     { type: 'function', names: ['delayedAssign'], processor: built_in_1.BuiltInProcName.Assignment, config: { quoteSource: true, targetVariable: true }, assumePrimitive: true },
     { type: 'function', names: ['<<-'], processor: built_in_1.BuiltInProcName.Assignment, config: { superAssignment: true, canBeReplacement: true }, assumePrimitive: true },
     { type: 'function', names: ['->'], processor: built_in_1.BuiltInProcName.Assignment, config: { swapSourceAndTarget: true, canBeReplacement: true }, assumePrimitive: true },

package/dataflow/eval/resolve/resolve-argument.js

@@ -26,7 +26,7 @@ function getArgumentStringValue(variableResolve, graph, vertex, argumentIndex, a
     }
     if (argumentIndex === 'unnamed') {
         // return all unnamed arguments
-        const references = vertex.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.getReferenceOfArgument).filter(assert_1.isNotUndefined);
+        const references = vertex.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.FunctionArgument.getReference).filter(assert_1.isNotUndefined);
         const map = new Map();
         for (const ref of references) {
             let valueNode = graph.idMap?.get(ref);
@@ -42,7 +42,7 @@ function getArgumentStringValue(variableResolve, graph, vertex, argumentIndex, a
         return map;
     }
     if (argumentIndex < vertex.args.length) {
-        const arg = (0, graph_1.getReferenceOfArgument)(vertex.args[argumentIndex]);
+        const arg = graph_1.FunctionArgument.getReference(vertex.args[argumentIndex]);
         if (!arg) {
             return undefined;
         }

package/dataflow/graph/dataflowgraph-builder.d.ts

@@ -1,8 +1,8 @@
 import { type NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import { type DataflowFunctionFlowInformation, DataflowGraph, type FunctionArgument } from './graph';
+import { type DataflowFunctionFlowInformation, DataflowGraph, FunctionArgument } from './graph';
 import { type IEnvironment, type REnvironmentInformation } from '../environments/environment';
-import { type DataflowGraphVertexArgument, type DataflowGraphVertexAstLink, type DataflowGraphVertexInfo, type DataflowGraphVertexUse, type FunctionOriginInformation } from './vertex';
+import { type DataflowGraphVertexFunctionDefinition, type DataflowGraphVertexArgument, type DataflowGraphVertexAstLink, type DataflowGraphVertexInfo, type DataflowGraphVertexUse, type FunctionOriginInformation } from './vertex';
 import type { ControlDependency, ExitPoint } from '../info';
 import type { LinkTo } from '../../queries/catalog/call-context-query/call-context-query-format';
 import type { FlowrSearchLike } from '../../search/flowr-search-builder';
@@ -39,6 +39,7 @@ export declare class DataflowGraphBuilder<Vertex extends DataflowGraphVertexInfo
         builtInEnvironment?: IEnvironment;
         cds?: ControlDependency[];
         readParams?: [NodeId, boolean][];
+        mode?: DataflowGraphVertexFunctionDefinition['mode'];
     }, asRoot?: boolean): this;
     /**
      * Adds a **vertex** for a **function call** (V2).

package/dataflow/graph/dataflowgraph-builder.js

@@ -57,8 +57,9 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
                 out: subflow.out.map(o => ({ ...o, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(o.nodeId), cds: o.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) })),
                 in: subflow.in.map(o => ({ ...o, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(o.nodeId), cds: o.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) })),
                 unknownReferences: subflow.unknownReferences.map(o => ({ ...o, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(o.nodeId), cds: o.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) })),
-                hooks: subflow.hooks ?? []
+                hooks: subflow.hooks ?? [],
             },
+            mode: info?.mode,
             exitPoints: exitPoints.map(e => typeof e === 'object' ? ({ ...e, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(e.nodeId), cds: e.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) }) :
                 ({ nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(e), type: 0 /* ExitPointType.Default */, cds: undefined })),
             cds: info?.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
@@ -105,10 +106,10 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
     /** automatically adds argument links if they do not already exist */
     addArgumentLinks(id, args) {
         for (const arg of args) {
-            if (arg === r_function_call_1.EmptyArgument) {
+            if (graph_1.FunctionArgument.isEmpty(arg)) {
                 continue;
             }
-            if ((0, graph_1.isPositionalArgument)(arg)) {
+            if (graph_1.FunctionArgument.isPositional(arg)) {
                 this.argument(id, arg.nodeId);
                 if (typeof arg.nodeId === 'string' && arg.nodeId.endsWith('-arg')) {
                     const withoutSuffix = arg.nodeId.slice(0, -4);

package/dataflow/graph/diff-dataflow-graph.d.ts

@@ -1,4 +1,4 @@
-import { type FunctionArgument, type OutgoingEdges } from './graph';
+import { FunctionArgument, type OutgoingEdges } from './graph';
 import { type GenericDiffConfiguration, type GenericDifferenceInformation } from '../../util/diff';
 import { type NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { type GraphDiffContext, type NamedGraph, GraphDifferenceReport } from '../../util/diff-graph';

package/dataflow/graph/diff-dataflow-graph.js

@@ -116,7 +116,7 @@ function diffFunctionArguments(fn, a, b, ctx) {
                 ctx.report.addComment(`${ctx.position}In argument #${i} (of ${ctx.leftname}, empty) the argument differs: ${JSON.stringify(aArg)} vs ${JSON.stringify(bArg)}.`);
             }
         }
-        else if ((0, graph_1.isNamedArgument)(aArg) && (0, graph_1.isNamedArgument)(bArg)) {
+        else if (graph_1.FunctionArgument.isNamed(aArg) && graph_1.FunctionArgument.isNamed(bArg)) {
             // must have the same name
             if (aArg.name !== bArg.name) {
                 ctx.report.addComment(`${ctx.position}In argument #${i} (of ${ctx.leftname}, named) the name differs: ${aArg.name} vs ${bArg.name}.`);
@@ -233,6 +233,10 @@ function diffVertices(ctx) {
                     ...ctx,
                     position: `${ctx.position}Vertex ${id} differs in subflow in-read-parameters. `
                 });
+                (0, diff_1.setDifference)(new Set(rInfo.mode ?? []), new Set(lInfo.mode ?? []), {
+                    ...ctx,
+                    position: `${ctx.position}Vertex ${id} differs in function definition mode. `
+                });
                 (0, diff_1.setDifference)(lInfo.subflow.graph, rInfo.subflow.graph, {
                     ...ctx,
                     position: `${ctx.position}Vertex ${id} differs in subflow graph. `

package/dataflow/graph/graph.d.ts

@@ -38,20 +38,76 @@ export interface NamedFunctionArgument extends IdentifierReference {
 export interface PositionalFunctionArgument extends Omit<IdentifierReference, 'name'> {
     readonly name?: undefined;
 }
-/** Summarizes either named (`foo(a = 3, b = 2)`), unnamed (`foo(3, 2)`), or empty (`foo(,)`) arguments within a function. */
-export type FunctionArgument = NamedFunctionArgument | PositionalFunctionArgument | typeof EmptyArgument;
-/**
- * Check if the given argument is a {@link PositionalFunctionArgument}.
- */
-export declare function isPositionalArgument(arg: FunctionArgument): arg is PositionalFunctionArgument;
 /**
- * Check if the given argument is a {@link NamedFunctionArgument}.
+ * Summarizes either named (`foo(a = 3, b = 2)`), unnamed (`foo(3, 2)`), or empty (`foo(,)`) arguments within a function.
+ * See the {@link FunctionArgument} helper functions to check for the specific types.
+ * @see {@link FunctionArgument.isNamed|`FunctionArgument.isNamed`} - to check for named arguments
+ * @see {@link FunctionArgument.isPositional|`FunctionArgument.isPositional`} - to check for positional arguments
+ * @see {@link FunctionArgument.isEmpty|`FunctionArgument.isEmpty`} - to check for empty arguments
  */
-export declare function isNamedArgument(arg: FunctionArgument): arg is NamedFunctionArgument;
+export type FunctionArgument = NamedFunctionArgument | PositionalFunctionArgument | typeof EmptyArgument;
 /**
- * Returns the reference of a non-empty argument.
+ * Helper functions to work with {@link FunctionArgument}s.
+ * @see {@link EmptyArgument} - the marker for empty arguments
  */
-export declare function getReferenceOfArgument(arg: FunctionArgument): NodeId | undefined;
+export declare const FunctionArgument: {
+    /**
+     * Checks whether the given argument is a positional argument.
+     * @example
+     * ```r
+     * foo(b=3, 2) # the second argument is positional
+     * ```
+     */
+    readonly isPositional: (this: void, arg: FunctionArgument) => arg is PositionalFunctionArgument;
+    /**
+     * Checks whether the given argument is a named argument.
+     * @example
+     * ```r
+     * foo(b=3, 2) # the first argument is named
+     * ```
+     * @see {@link isPositional}
+     * @see {@link isEmpty}
+     * @see {@link hasName}
+     */
+    readonly isNamed: (this: void, arg: FunctionArgument) => arg is NamedFunctionArgument;
+    /**
+     * Checks whether the given argument is an unnamed argument (either positional or empty).
+     * @example
+     * ```r
+     * foo(, 2)   # the first argument is unnamed (empty)
+     * foo(3, 2)  # both arguments are unnamed (positional)
+     * ```
+     * @see {@link isNamed}
+     */
+    readonly isUnnamed: (this: void, arg: FunctionArgument) => arg is PositionalFunctionArgument | typeof EmptyArgument;
+    /**
+     * Checks whether the given argument is an empty argument.
+     * @example
+     * ```r
+     * foo(, 2) # the first argument is empty
+     * ```
+     * @see {@link isNotEmpty}
+     */
+    readonly isEmpty: (this: void, arg: FunctionArgument) => arg is typeof EmptyArgument;
+    /**
+     * Checks whether the given argument is not an empty argument.
+     * @see {@link isEmpty}
+     */
+    readonly isNotEmpty: (this: void, arg: FunctionArgument) => arg is NamedFunctionArgument | PositionalFunctionArgument;
+    /**
+     * 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
+     * ```
+     */
+    readonly getReference: (this: void, arg: FunctionArgument) => NodeId | undefined;
+    /**
+     * Checks whether the given argument is a named argument with the specified name.
+     * @see {@link isNamed}
+     */
+    readonly hasName: (this: void, arg: FunctionArgument, name: string | undefined) => arg is NamedFunctionArgument;
+};
 /**
  * Maps the edges target to the edge information
  */

package/dataflow/graph/graph.js

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataflowGraph = void 0;
-exports.isPositionalArgument = isPositionalArgument;
-exports.isNamedArgument = isNamedArgument;
-exports.getReferenceOfArgument = getReferenceOfArgument;
+exports.DataflowGraph = exports.FunctionArgument = void 0;
 const assert_1 = require("../../util/assert");
 const vertex_1 = require("./vertex");
 const arrays_1 = require("../../util/collections/arrays");
@@ -14,26 +11,84 @@ const clone_1 = require("../environments/clone");
 const json_1 = require("../../util/json");
 const logger_1 = require("../logger");
 /**
- * Check if the given argument is a {@link PositionalFunctionArgument}.
+ * Helper functions to work with {@link FunctionArgument}s.
+ * @see {@link EmptyArgument} - the marker for empty arguments
  */
-function isPositionalArgument(arg) {
-    return arg !== r_function_call_1.EmptyArgument && arg.name === undefined;
-}
-/**
- * Check if the given argument is a {@link NamedFunctionArgument}.
- */
-function isNamedArgument(arg) {
-    return arg !== r_function_call_1.EmptyArgument && arg.name !== undefined;
-}
-/**
- * Returns the reference of a non-empty argument.
- */
-function getReferenceOfArgument(arg) {
-    if (arg !== r_function_call_1.EmptyArgument) {
-        return arg?.nodeId;
+exports.FunctionArgument = {
+    /**
+     * Checks whether the given argument is a positional argument.
+     * @example
+     * ```r
+     * foo(b=3, 2) # the second argument is positional
+     * ```
+     */
+    isPositional(arg) {
+        return arg !== r_function_call_1.EmptyArgument && arg.name === undefined;
+    },
+    /**
+     * Checks whether the given argument is a named argument.
+     * @example
+     * ```r
+     * foo(b=3, 2) # the first argument is named
+     * ```
+     * @see {@link isPositional}
+     * @see {@link isEmpty}
+     * @see {@link hasName}
+     */
+    isNamed(arg) {
+        return arg !== r_function_call_1.EmptyArgument && arg.name !== undefined;
+    },
+    /**
+     * Checks whether the given argument is an unnamed argument (either positional or empty).
+     * @example
+     * ```r
+     * foo(, 2)   # the first argument is unnamed (empty)
+     * foo(3, 2)  # both arguments are unnamed (positional)
+     * ```
+     * @see {@link isNamed}
+     */
+    isUnnamed(arg) {
+        return arg === r_function_call_1.EmptyArgument || arg.name === undefined;
+    },
+    /**
+     * Checks whether the given argument is an empty argument.
+     * @example
+     * ```r
+     * foo(, 2) # the first argument is empty
+     * ```
+     * @see {@link isNotEmpty}
+     */
+    isEmpty(arg) {
+        return arg === r_function_call_1.EmptyArgument;
+    },
+    /**
+     * Checks whether the given argument is not an empty argument.
+     * @see {@link isEmpty}
+     */
+    isNotEmpty(arg) {
+        return arg !== r_function_call_1.EmptyArgument;
+    },
+    /**
+     * 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
+     * ```
+     */
+    getReference(arg) {
+        if (arg !== r_function_call_1.EmptyArgument) {
+            return arg?.nodeId;
+        }
+        return undefined;
+    },
+    /**
+     * Checks whether the given argument is a named argument with the specified name.
+     * @see {@link isNamed}
+     */
+    hasName(arg, name) {
+        return exports.FunctionArgument.isNamed(arg) && arg.name === name;
     }
-    return undefined;
-}
+};
 /**
  * The dataflow graph holds the dataflow information found within the given AST.
  * We differentiate the directed edges in {@link EdgeType} and the vertices indicated by {@link DataflowGraphVertexArgument}
@@ -402,6 +457,14 @@ function mergeNodeInfos(current, next) {
     else if (current.tag === vertex_1.VertexType.FunctionDefinition) {
         (0, assert_1.guard)(current.scope === next.scope, 'nodes to be joined for the same id must have the same scope');
         current.exitPoints = (0, arrays_1.uniqueArrayMerge)(current.exitPoints, next.exitPoints);
+        if (next.tag === vertex_1.VertexType.FunctionDefinition && next.mode && next.mode.length > 0) {
+            current.mode ??= [];
+            for (const m of next.mode) {
+                if (!current.mode.includes(m)) {
+                    current.mode.push(m);
+                }
+            }
+        }
     }
     return current;
 }

package/dataflow/graph/vertex.d.ts

@@ -96,9 +96,13 @@ export interface DataflowGraphVertexFunctionCall extends DataflowGraphVertexBase
      * Please be aware that this name can differ from the lexeme.
      * For example, if the function is a replacement function, in this case, the actually called fn will
      * have the compound name (e.g., `[<-`).
+     * @see {@link Identifier} - for more information on identifiers
      */
     readonly name: Identifier;
-    /** The arguments of the function call, in order (as they are passed to the respective call if executed in R). */
+    /**
+     * The arguments of the function call, in order (as they are passed to the respective call if executed in R.
+     * @see {@link FunctionArgument} - for more information on function arguments
+     */
     args: FunctionArgument[];
     /** a performance flag to indicate that the respective call is _only_ calling a builtin function without any df graph attached */
     onlyBuiltin: boolean;
@@ -141,6 +145,12 @@ export interface DataflowGraphVertexFunctionDefinition extends DataflowGraphVert
     params: Record<NodeId, boolean>;
     /** The environment in which the function is defined (this is only attached if the DFG deems it necessary). */
     environment?: REnvironmentInformation;
+    /**
+     * If the function is a (potential) S3/S4/S7 dispatch
+     * Please note that flowR may create these flags *on use* (e.g. `s3` as otherwise any func with a `.` would be considered S3).
+     * This is more of a convenience flag for later processing.
+     */
+    mode?: ('s3' | 's4' | 's7')[];
 }
 /**
  * What is to be passed to construct a vertex in the {@link DataflowGraph|dataflow graph}

package/dataflow/internal/linker.d.ts

@@ -1,7 +1,7 @@
 import { DefaultMap } from '../../util/collections/defaultmap';
 import { type NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { Identifier, type IdentifierReference } from '../environments/identifier';
-import { type DataflowGraph, type FunctionArgument } from '../graph/graph';
+import { type DataflowGraph, FunctionArgument } from '../graph/graph';
 import type { RParameter } from '../../r-bridge/lang-4.x/ast/model/nodes/r-parameter';
 import type { AstIdMap, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { type DataflowGraphVertexFunctionCall, type DataflowGraphVertexFunctionDefinition, type DataflowGraphVertexInfo } from '../graph/vertex';

package/dataflow/internal/linker.js

@@ -78,7 +78,7 @@ function produceNameSharedIdMap(references) {
  * If you just want to match by name, use {@link pMatch}.
  */
 function linkArgumentsOnCall(args, params, graph) {
-    const nameArgMap = new Map(args.filter(graph_1.isNamedArgument).map(a => [a.name, a]));
+    const nameArgMap = new Map(args.filter(graph_1.FunctionArgument.isNamed).map(a => [a.name, a]));
     const nameParamMap = new Map(params.filter(p => p?.name?.content !== undefined)
         .map(p => [p.name.content, p]));
     const maps = new Map();
@@ -105,7 +105,7 @@ function linkArgumentsOnCall(args, params, graph) {
         }
     }
     const remainingParameter = params.filter(p => !p?.name || !matchedParameters.has(p.name.content));
-    const remainingArguments = args.filter(a => !(0, graph_1.isNamedArgument)(a));
+    const remainingArguments = args.filter(graph_1.FunctionArgument.isUnnamed);
     for (let i = 0; i < remainingArguments.length; i++) {
         const arg = remainingArguments[i];
         if (arg === r_function_call_1.EmptyArgument) {
@@ -164,7 +164,7 @@ function invertArgumentMap(maps) {
  * You can use {@link getAllIdsWithTarget} to get all argument ids that map to a given parameter.
  */
 function pMatch(args, params) {
-    const nameArgMap = new Map(args.filter(graph_1.isNamedArgument).map(a => [a.name, a]));
+    const nameArgMap = new Map(args.filter(graph_1.FunctionArgument.isNamed).map(a => [a.name, a]));
     const maps = new Map();
     const sid = params['...'];
     const paramNames = Object.keys(params);
@@ -183,7 +183,7 @@ function pMatch(args, params) {
         }
     }
     const remainingParameter = paramNames.filter(p => !matchedParameters.has(p));
-    const remainingArguments = args.filter(a => !(0, graph_1.isNamedArgument)(a));
+    const remainingArguments = args.filter(graph_1.FunctionArgument.isUnnamed);
     for (let i = 0; i < remainingArguments.length; i++) {
         const arg = remainingArguments[i];
         if (arg === r_function_call_1.EmptyArgument) {
@@ -239,6 +239,14 @@ function linkFunctionCallWithSingleTarget(graph, { subflow: fnSubflow, exitPoint
                         for (const v of value) {
                             graph.addEdge(id, v, edge_1.EdgeType.Calls);
                             graph.addEdge(ingoing.nodeId, v, edge_1.EdgeType.Calls);
+                            // add s7 to vertex
+                            const vInfo = graph.getVertex(v);
+                            if (vInfo && vInfo.tag === vertex_1.VertexType.FunctionDefinition) {
+                                vInfo.mode ??= [];
+                                if (!vInfo.mode.includes('s7')) {
+                                    vInfo.mode.push('s7');
+                                }
+                            }
                         }
                     }
                 }

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

@@ -6,6 +6,7 @@ import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/node
 import type { RFunctionArgument } 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';
 import type { ForceArguments } from '../common';
 import type { REnvironmentInformation } from '../../../../../environments/environment';
 import type { DataflowGraph } from '../../../../../graph/graph';
@@ -19,6 +20,7 @@ export interface AssignmentConfiguration extends ForceArguments {
     /** is the target a variable pointing at the actual name? */
     readonly targetVariable?: boolean;
     readonly mayHaveMoreArgs?: boolean;
+    readonly modesForFn?: DataflowGraphVertexFunctionDefinition['mode'];
 }
 export interface ExtendedAssignmentConfiguration extends AssignmentConfiguration {
     readonly source: {

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

@@ -265,10 +265,18 @@ function processAssignmentToString(target, args, name, rootId, data, config, sou
         information: res.information
     });
 }
-function checkTargetReferenceType(sourceInfo) {
+function checkTargetReferenceType(sourceInfo, fnModes) {
     const vert = sourceInfo.graph.getVertex(sourceInfo.entryPoint);
     switch (vert?.tag) {
         case vertex_1.VertexType.FunctionDefinition:
+            if (fnModes && fnModes.length > 0) {
+                vert.mode ??= [];
+                for (const m of fnModes) {
+                    if (!vert.mode.includes(m)) {
+                        vert.mode.push(m);
+                    }
+                }
+            }
             return identifier_1.ReferenceType.Function;
         case vertex_1.VertexType.Use:
         case vertex_1.VertexType.FunctionCall:
@@ -310,7 +318,7 @@ function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignme
  */
 function processAssignmentToSymbol(config) {
     const { nameOfAssignmentFunction, source, args: [targetArg, sourceArg], targetId, targetName, rootId, data, information, makeMaybe, quoteSource } = config;
-    const referenceType = checkTargetReferenceType(sourceArg);
+    const referenceType = checkTargetReferenceType(sourceArg, config.modesForFn);
     const useSourceIds = [sourceArg.graph.hasVertex(source.info.id) ? source.info.id : sourceArg.entryPoint];
     const aliases = (0, alias_tracking_1.getAliases)(useSourceIds, information.graph, information.environment);
     const writeNodes = targetName ? [{

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

@@ -266,6 +266,10 @@ function updateNestedFunctionCalls(graph, outEnvironment) {
                 graph.addEdge(id, exitPoint.nodeId, edge_1.EdgeType.Returns);
             }
             if (treatAsS3) {
+                targetVertex.mode ??= [];
+                if (!targetVertex.mode.includes('s3')) {
+                    targetVertex.mode.push('s3');
+                }
                 // collect all next method calls to link them to the same targets!
                 for (const s of targetVertex.subflow.graph) {
                     const v = graph.getVertex(s);

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

@@ -41,7 +41,7 @@ function processRegisterHook(name, args, rootId, data, config) {
             wrappedFunctions.add(wrapId);
             const wrapped = {
                 type: type_1.RType.FunctionDefinition,
-                location: val.location ?? (0, range_1.invalidRange)(),
+                location: val.location ?? name.location ?? (0, range_1.invalidRange)(),
                 parameters: [],
                 body: val,
                 lexeme: 'function',

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

@@ -8,7 +8,6 @@ const common_1 = require("../common");
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const logger_1 = require("../../../../../logger");
 const vertex_1 = require("../../../../../graph/vertex");
-const graph_1 = require("../../../../../graph/graph");
 const edge_1 = require("../../../../../graph/edge");
 const unpack_argument_1 = require("../argument/unpack-argument");
 const built_in_access_1 = require("./built-in-access");
@@ -19,6 +18,7 @@ const built_in_s_seven_dispatch_1 = require("./built-in-s-seven-dispatch");
 const make_argument_1 = require("../argument/make-argument");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const range_1 = require("../../../../../../util/range");
+const graph_1 = require("../../../../../graph/graph");
 /**
  * Process a replacement function call like `<-`, `[[<-`, `$<-`, etc.
  * These are automatically created when doing assignments like `x[y] <- value` or in general `fun(x) <- value` will call `fun<- (x, value)`.
@@ -44,7 +44,7 @@ args, rootId, data, config) {
             type: type_1.RType.Symbol,
             info: uArg.info,
             lexeme: tarName,
-            location: uArg.location ?? (0, range_1.invalidRange)()
+            location: uArg.location ?? targetArg.location ?? name.location ?? (0, range_1.invalidRange)()
         }, data.completeAst.idMap);
     }
     /* we assign the first argument by the last for now and maybe mark as maybe!, we can keep the symbol as we now know we have an assignment */
@@ -92,7 +92,7 @@ args, rootId, data, config) {
     }
     /* a replacement reads all of its call args as well, at least as far as I am aware of */
     for (const arg of callArgs) {
-        const ref = (0, graph_1.getReferenceOfArgument)(arg);
+        const ref = graph_1.FunctionArgument.getReference(arg);
         if (ref !== undefined) {
             res.graph.addEdge(rootId, ref, edge_1.EdgeType.Reads);
         }

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

@@ -15,6 +15,7 @@ const assert_1 = require("../../../../../../util/assert");
 const identifier_1 = require("../../../../../environments/identifier");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 const r_value_1 = require("../../../../../eval/values/r-value");
+const vertex_1 = require("../../../../../graph/vertex");
 /**
  * Process an S7 new generic dispatch call like `new_generic` or `setGeneric`.
  */
@@ -62,11 +63,16 @@ function processS7NewGeneric(name, args, rootId, data, config) {
     const info = (0, known_call_handling_1.processKnownFunctionCall)({ name, forceArgs: 'all', args: effectiveArgs, rootId, data, origin: built_in_1.BuiltInProcName.S7NewGeneric }).information;
     info.graph.addEdge(rootId, funArg, edge_1.EdgeType.Returns);
     info.entryPoint = funArg;
+    const fArg = info.graph.getVertex(funArg);
+    if (fArg?.tag === vertex_1.VertexType.FunctionDefinition) {
+        fArg.mode ??= ['s4', 's7'];
+    }
     return info;
 }
 // 'function([dispatch_args],...) S7_dispatch()'; returns the value id
 function makeS7DispatchFDef(name, names, rootId, args, idMap) {
     const argNameId = rootId + '-s7-new-generic-fun-arg-name';
+    const r = name.location ?? (0, range_1.invalidRange)();
     const argName = {
         type: type_1.RType.Symbol,
         lexeme: 'fun',
@@ -75,13 +81,13 @@ function makeS7DispatchFDef(name, names, rootId, args, idMap) {
             id: argNameId,
             nesting: name.info.nesting,
             role: "arg-name" /* RoleInParent.ArgumentName */,
-            fullRange: (0, range_1.invalidRange)(),
+            fullRange: r,
             adToks: undefined,
             file: name.info.file,
             parent: rootId,
             index: 0
         },
-        location: (0, range_1.invalidRange)(),
+        location: r,
     };
     idMap.set(argNameId, argName);
     const funcNameId = rootId + '-s7-new-generic-fun-name';
@@ -92,18 +98,18 @@ function makeS7DispatchFDef(name, names, rootId, args, idMap) {
             id: funcNameId,
             nesting: name.info.nesting,
             role: "call-name" /* RoleInParent.FunctionCallName */,
-            fullRange: (0, range_1.invalidRange)(),
+            fullRange: r,
             adToks: undefined,
             file: name.info.file,
             parent: rootId,
             index: 0
         },
-        location: (0, range_1.invalidRange)(),
+        location: r,
         content: identifier_1.Identifier.make('S7_dispatch', 's7'),
     };
     const funcBody = {
         type: type_1.RType.FunctionCall,
-        location: (0, range_1.invalidRange)(),
+        location: r,
         lexeme: 'S7_dispatch',
         named: true,
         functionName: funcName,
@@ -112,7 +118,7 @@ function makeS7DispatchFDef(name, names, rootId, args, idMap) {
             id: rootId + '-s7-new-generic-fun-body',
             nesting: name.info.nesting,
             role: "fun-body" /* RoleInParent.FunctionDefinitionBody */,
-            fullRange: (0, range_1.invalidRange)(),
+            fullRange: r,
             adToks: undefined,
             file: name.info.file,
             parent: rootId,
@@ -130,10 +136,10 @@ function makeS7DispatchFDef(name, names, rootId, args, idMap) {
             parent: rootId,
             index: args + 1,
             adToks: undefined,
-            fullRange: (0, range_1.invalidRange)(),
+            fullRange: r,
         },
         lexeme: 'function',
-        location: (0, range_1.invalidRange)(),
+        location: r,
         parameters: [...names.filter(assert_1.isNotUndefined), '...'].map((n, i) => {
             const paramId = fdefId + `-param-${i}`;
             const paramNameId = paramId + '-name';
@@ -145,17 +151,17 @@ function makeS7DispatchFDef(name, names, rootId, args, idMap) {
                     id: paramNameId,
                     nesting: name.info.nesting,
                     role: "param-name" /* RoleInParent.ParameterName */,
-                    fullRange: (0, range_1.invalidRange)(),
+                    fullRange: r,
                     adToks: undefined,
                     file: name.info.file,
                     index: i,
                     parent: paramId
                 },
-                location: (0, range_1.invalidRange)(),
+                location: r,
             };
             const param = {
                 type: type_1.RType.Parameter,
-                location: (0, range_1.invalidRange)(),
+                location: r,
                 lexeme: n,
                 name: paramName,
                 defaultValue: undefined,
@@ -168,7 +174,7 @@ function makeS7DispatchFDef(name, names, rootId, args, idMap) {
                     index: i,
                     adToks: undefined,
                     file: name.info.file,
-                    fullRange: (0, range_1.invalidRange)(),
+                    fullRange: r,
                 }
             };
             idMap.set(paramNameId, paramName);
@@ -184,12 +190,12 @@ function makeS7DispatchFDef(name, names, rootId, args, idMap) {
     const argument = {
         type: type_1.RType.Argument,
         lexeme: 'fun',
-        location: (0, range_1.invalidRange)(),
+        location: r,
         info: {
             id: argId,
             nesting: name.info.nesting,
             role: "call-arg" /* RoleInParent.FunctionCallArgument */,
-            fullRange: (0, range_1.invalidRange)(),
+            fullRange: r,
             adToks: undefined,
             file: name.info.file,
             parent: rootId,

package/documentation/wiki-dataflow-graph.js

@@ -1004,13 +1004,17 @@ Depending on what you are interested in, there exists a plethora of functions an
 * ${ctx.link(node_id_1.recoverName)} and ${ctx.link(node_id_1.recoverContent)} to get the name or content of a vertex in the dataflow graph
 * ${ctx.link(alias_tracking_1.resolveIdToValue)} to resolve the value of a variable or id (if possible, see [below](#dfg-resolving-values))
 * ${ctx.link(alias_tracking_1.getAliases)} to get all (potentially currently) aliases of a given definition
-* ${ctx.link('DfEdge', undefined, { type: 'variable' })} to get helpful functions wrt. edges (see [below](#dfg-resolving-values))
-* ${ctx.link('Identifier', undefined, { type: 'variable' })} to get helpful functions wrt. identifiers
 * ${ctx.link(identify_link_to_last_call_relation_1.getValueOfArgument)} to get the (syntactical) value of an argument in a function call 
 * ${ctx.link(dfg_get_origin_1.getOriginInDfg)} to get information about where a read, call, ... comes from (see [below](#dfg-resolving-values))
 
-Some of these functions have been explained in their respective wiki pages. However, some are part of the [Dataflow Graph API](${doc_files_1.FlowrWikiBaseRef}/Dataflow-Graph) and so we explain them here.
-If you are interested in which features we support and which features are still to be worked on, please refer to our [capabilities](${doc_files_1.FlowrWikiBaseRef}/Capabilities) page.
+FlowR also provides various helper objects (with the same name as the corresponding type) to help you work with the dataflow graph:
+
+* ${ctx.link('DfEdge', undefined, { type: 'variable' })} to get helpful functions wrt. edges (see [below](#dfg-resolving-values))
+* ${ctx.link('Identifier', undefined, { type: 'variable' })} to get helpful functions wrt. identifiers
+* ${ctx.link('FunctionArgument', undefined, { type: 'variable' })} to get helpful functions wrt. function arguments
+
+Some of these functions have been explained in their respective wiki pages. However, some are part of the ${ctx.linkPage('wiki/Dataflow Graph', 'Dataflow Graph API')} and so we explain them here.
+If you are interested in which features we support and which features are still to be worked on, please refer to our ${ctx.linkPage('wiki/Capabilities', 'capabilities')} page.
 
 ${(0, doc_structure_1.section)('Resolving Values', 3, 'dfg-resolving-values')}
 

package/linter/rules/seeded-randomness.js

@@ -86,7 +86,7 @@ exports.SEEDED_RANDOMNESS = {
                 // assignments have to be queried for their destination
                 for (const a of assignment ?? []) {
                     const argIdx = assignmentArgIndexes.get(identifier_1.Identifier.getName(a.name));
-                    const dest = (0, graph_1.getReferenceOfArgument)(a.args[argIdx]);
+                    const dest = graph_1.FunctionArgument.getReference(a.args[argIdx]);
                     if (dest !== undefined && assignmentProducers.has((0, node_id_1.recoverName)(dest, dataflow.graph.idMap))) {
                         // we either have arg index 0 or 1 for the assignmentProducers destination, so we select the assignment value as 1-argIdx here
                         if (isConstantArgument(dataflow.graph, a, 1 - argIdx, analyzer.inspectContext())) {
@@ -143,7 +143,7 @@ function getDefaultAssignments() {
     return default_builtin_config_1.DefaultBuiltinConfig.filter(b => b.type === 'function' && (b.processor === built_in_1.BuiltInProcName.Assignment || b.processor === built_in_1.BuiltInProcName.AssignmentLike));
 }
 function isConstantArgument(graph, call, argIndex, ctx) {
-    const args = call.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.getReferenceOfArgument);
+    const args = call.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.FunctionArgument.getReference);
     const values = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(args[argIndex], { graph: graph, resolve: config_1.VariableResolve.Alias, ctx }));
     return values?.elements.every(v => v.type === 'number' ||
         v.type === 'logical' ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.9.1",
+  "version": "2.9.2",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {

package/queries/catalog/call-context-query/identify-link-to-last-call-relation.js

@@ -91,15 +91,15 @@ function getValueOfArgument(graph, call, argument, additionalAllowedTypes) {
     if (!call) {
         return undefined;
     }
-    const totalIndex = argument.name ? call.args.findIndex(arg => arg !== r_function_call_1.EmptyArgument && arg.name === argument.name) : -1;
+    const totalIndex = argument.name ? call.args.findIndex(arg => graph_1.FunctionArgument.hasName(arg, argument.name)) : -1;
     let refAtIndex;
     if (totalIndex < 0) {
-        const references = call.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.getReferenceOfArgument);
+        const references = call.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.FunctionArgument.getReference);
         refAtIndex = references[argument.index];
     }
     else {
         const arg = call.args[totalIndex];
-        refAtIndex = (0, graph_1.getReferenceOfArgument)(arg);
+        refAtIndex = graph_1.FunctionArgument.getReference(arg);
     }
     if (refAtIndex === undefined) {
         return undefined;

package/r-bridge/lang-4.x/tree-sitter/tree-sitter-normalize.js

@@ -74,7 +74,7 @@ function convertTreeNode(node) {
             children: [],
             grouping: undefined,
             info: {
-                fullRange: (0, range_1.invalidRange)(),
+                fullRange: undefined,
                 adToks: [],
                 treeSitterId: -1,
             }
@@ -586,7 +586,7 @@ function convertTreeNode(node) {
         children: [],
         grouping: undefined,
         info: {
-            fullRange: (0, range_1.invalidRange)(),
+            fullRange: undefined,
             adToks: [],
             treeSitterId: -1,
         }

package/slicing/static/slice-call.js

@@ -34,7 +34,7 @@ function getAllFunctionCallTargetsForSlice(dataflowGraph, callerInfo, baseEnviro
     return [functionCallTargets, activeEnvironment];
 }
 function includeArgumentFunctionCallClosure(arg, activeEnvironment, queue, dataflowGraph) {
-    const valueRoot = (0, graph_1.getReferenceOfArgument)(arg);
+    const valueRoot = graph_1.FunctionArgument.getReference(arg);
     if (!valueRoot) {
         return;
     }

package/util/mermaid/dfg.js

@@ -84,11 +84,11 @@ function printArg(arg) {
     else if (arg === r_function_call_1.EmptyArgument) {
         return '[empty]';
     }
-    else if ((0, graph_1.isNamedArgument)(arg)) {
+    else if (graph_1.FunctionArgument.isNamed(arg)) {
         const deps = arg.cds ? ', :may:' + arg.cds.map(c => c.id + (c.when ? '+' : '-')).join(',') : '';
         return `${arg.name} (${arg.nodeId}${deps})`;
     }
-    else if ((0, graph_1.isPositionalArgument)(arg)) {
+    else if (graph_1.FunctionArgument.isPositional(arg)) {
         const deps = arg.cds ? ' (:may:' + arg.cds.map(c => c.id + (c.when ? '+' : '-')).join(',') + ')' : '';
         return `${arg.nodeId}${deps}`;
     }
@@ -99,12 +99,12 @@ function printArg(arg) {
 function displayFunctionArgMapping(argMapping) {
     const result = [];
     for (const arg of argMapping) {
-        result.push(printArg(arg));
+        result.push((0, mermaid_1.escapeMarkdown)(printArg(arg)));
     }
     return result.length === 0 ? '' : `\n    (${result.join(', ')})`;
 }
 function encodeEdge(from, to, types) {
-    return `${from}->${to}["${[...types].join(':')}"]`;
+    return `${from}->${to}["${Array.from(types).join(':')}"]`;
 }
 function mermaidNodeBrackets(tag) {
     let open;
@@ -169,7 +169,7 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark, includeOnlyIds) {
         const deps = info.cds ? ', :may:' + info.cds.map(c => c.id + (c.when ? '+' : '-')).join(',') : '';
         const lnks = info.link?.origin ? ', :links:' + info.link.origin.join(',') : '';
         const n = node?.info.fullRange ?? node?.location ?? (node?.type === type_1.RType.ExpressionList ? node?.grouping?.[0].location : undefined);
-        mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}${escapedName.length > 10 ? '\n      ' : ' '}(${id}${deps}${lnks})\n      *${formatRange(n)}*${fCall ? displayFunctionArgMapping(info.args) : ''}\`"${close}`);
+        mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}${escapedName.length > 10 ? '\n      ' : ' '}(${id}${deps}${lnks})\n      *${formatRange(n)}*${fCall ? displayFunctionArgMapping(info.args) : '' + (info.tag === vertex_1.VertexType.FunctionDefinition && info.mode && info.mode.length > 0 ? (0, mermaid_1.escapeMarkdown)(JSON.stringify(info.mode)) : '')}\`"${close}`);
     }
     if (mark?.has(id)) {
         mermaid.nodeLines.push(`    style ${idPrefix}${id} ${mermaid.markStyle.vertex} `);

package/util/version.js

@@ -6,7 +6,7 @@ exports.printVersionInformation = printVersionInformation;
 const semver_1 = require("semver");
 const assert_1 = require("./assert");
 // this is automatically replaced with the current version by release-it
-const version = '2.9.1';
+const version = '2.9.2';
 /**
  * Retrieves the current flowR version as a new {@link SemVer} object.
  */