@eagleoutice/flowr 2.9.1 → 2.9.3

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.2, R grammar v14 (tree-sitter engine)
     R> :query @linter "read.csv(\"/root/x.txt\")"
     ```
     
@@ -47,18 +47,18 @@ It offers a wide variety of features, for example:
                ╰ Path `/root/x.txt` at 1.1-23
            ╰ Metadata: totalConsidered: 1, totalUnknown: 0, searchTimeMs: 0, processTimeMs: 0
        ╰ Unused Definitions (unused-definitions):
-           ╰ Metadata: totalConsidered: 0, searchTimeMs: 0, processTimeMs: 0
+           ╰ Metadata: totalConsidered: 0, searchTimeMs: 0, processTimeMs: 1
        ╰ Naming Convention (naming-convention):
            ╰ Metadata: numMatches: 0, numBreak: 0, searchTimeMs: 0, processTimeMs: 0
        ╰ 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
        ╰ 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)
     ```
     
     
@@ -80,9 +80,9 @@ It offers a wide variety of features, for example:
     
     _Results (prettified and summarized):_
     
-    Query: **linter** (2 ms)\
+    Query: **linter** (3 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\
@@ -100,16 +100,16 @@ It offers a wide variety of features, for example:
     &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):\
-    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>numOperations: 0, numAccesses: 0, totalAccessed: 0, searchTimeMs: 0, processTimeMs: 0</code>\
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>numOperations: 0, numAccesses: 0, totalAccessed: 0, searchTimeMs: 0, processTimeMs: 1</code>\
     &nbsp;&nbsp;&nbsp;╰ **Dead Code** (dead-code):\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>consideredNodes: 5, searchTimeMs: 0, processTimeMs: 0</code>\
     &nbsp;&nbsp;&nbsp;╰ **Useless Loops** (useless-loop):\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>numOfUselessLoops: 0, searchTimeMs: 0, processTimeMs: 0</code>\
-    _All queries together required ≈2 ms (1ms accuracy, total 2 ms)_
+    _All queries together required ≈3 ms (1ms accuracy, total 3 ms)_
     
     <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.9 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,15 +126,15 @@ 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": {
             "results": [
               {
                 "involvedId": 3,
-                "range": [
+                "loc": [
                   1,
                   1,
                   1,
@@ -170,7 +170,7 @@ It offers a wide variety of features, for example:
               {
                 "certainty": "certain",
                 "filePath": "/root/x.txt",
-                "range": [
+                "loc": [
                   1,
                   1,
                   1,
@@ -218,7 +218,7 @@ It offers a wide variety of features, for example:
               "numAccesses": 0,
               "totalAccessed": 0,
               "searchTimeMs": 0,
-              "processTimeMs": 0
+              "processTimeMs": 1
             }
           },
           "dead-code": {
@@ -239,11 +239,11 @@ It offers a wide variety of features, for example:
           }
         },
         ".meta": {
-          "timing": 2
+          "timing": 3
         }
       },
       ".meta": {
-        "timing": 2
+        "timing": 3
       }
     }
     ```
@@ -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.2, 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 ≈3 ms (1ms accuracy, total 3 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!">117 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.2, 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 _2.0 ms_ (including parse and normalize, using the [tree-sitter](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment.)
     
     
     

package/core/print/slice-diff-ansi.js

@@ -9,11 +9,11 @@ function grayOut() {
 }
 function mergeJointRangesInSorted(loc) {
     return loc.reduce((acc, curr) => {
-        if ((0, range_1.rangesOverlap)(acc[acc.length - 1].location, curr.location)) {
+        if (range_1.SourceRange.overlap(acc[acc.length - 1].location, curr.location)) {
             return [
                 ...acc.slice(0, -1), {
                     selected: curr.selected || acc[acc.length - 1].selected,
-                    location: (0, range_1.mergeRanges)([acc[acc.length - 1].location, curr.location])
+                    location: range_1.SourceRange.merge([acc[acc.length - 1].location, curr.location])
                 }
             ];
         }
@@ -37,7 +37,7 @@ function sliceDiffAnsi(slice, normalized, criteriaIds, originalCode) {
         return `${grayOut()}${originalCode}${ansi_1.ansiFormatter.reset()}`;
     }
     // we sort all locations from back to front so that replacements do not screw up the indices
-    importantLocations.sort((a, b) => -(0, range_1.rangeCompare)(a.location, b.location));
+    importantLocations.sort((a, b) => -range_1.SourceRange.compare(a.location, b.location));
     // we need to merge all ranges that overlap, otherwise even reversed traversal can still crew us up
     importantLocations = mergeJointRangesInSorted(importantLocations);
     const lines = originalCode.split('\n');

package/dataflow/environments/built-in.d.ts

@@ -83,7 +83,16 @@ export interface DefaultBuiltInProcessorConfiguration extends ForceArguments {
      */
     readonly useAsProcessor?: BuiltInProcName;
 }
-export type BuiltInEvalHandler = (resolve: VariableResolve, a: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, env?: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap) => Value;
+export interface BuiltInEvalHandlerArgs {
+    resolve: VariableResolve;
+    node: RNodeWithParent;
+    ctx: ReadOnlyFlowrAnalyzerContext;
+    environment?: REnvironmentInformation;
+    graph?: DataflowGraph;
+    idMap?: AstIdMap;
+    blocked?: Set<NodeId>;
+}
+export type BuiltInEvalHandler = (args: BuiltInEvalHandlerArgs) => Value;
 declare function defaultBuiltInProcessor<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, { returnsNthArgument, useAsProcessor, forceArgs, readAllArguments, cfg, hasUnknownSideEffects, treatAsFnCall }: DefaultBuiltInProcessorConfiguration): DataflowInformation;
 /**
  * This contains all names of built-in function handlers and origins

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/alias-tracking.d.ts

@@ -2,7 +2,7 @@ import { VariableResolve } from '../../../config';
 import type { AstIdMap, RNodeWithParent } 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 { type REnvironmentInformation } from '../../environments/environment';
-import { type Identifier } from '../../environments/identifier';
+import { Identifier } from '../../environments/identifier';
 import type { DataflowGraph } from '../../graph/graph';
 import { type Lift, type Value, type ValueSet } from '../values/r-value';
 import type { ReadOnlyFlowrAnalyzerContext } from '../../../project/context/flowr-analyzer-context';
@@ -20,6 +20,8 @@ export interface ResolveInfo {
     resolve?: VariableResolve;
     /** Context used for resolving */
     ctx: ReadOnlyFlowrAnalyzerContext;
+    /** If set, the ids that should not be considered during resolution (=> top) */
+    blocked?: Set<NodeId>;
 }
 /**
  * Gets the definitions / aliases of a node
@@ -54,22 +56,20 @@ export declare function getAliases(sourceIds: readonly NodeId[], dataflow: Dataf
  * @param full               - Whether to track aliases on resolve
  * @param resolve            - Variable resolve mode
  * @param ctx                - Context used for clean environment
+ * @param blocked            - If set, the ids that should not be considered during resolution (=&gt;top)
  */
-export declare function resolveIdToValue(id: NodeId | RNodeWithParent | undefined, { environment, graph, idMap, full, resolve, ctx }: ResolveInfo): ResolveResult;
+export declare function resolveIdToValue(id: NodeId | RNodeWithParent | undefined, { environment, graph, idMap, full, resolve, ctx, blocked }: ResolveInfo): ResolveResult;
 /**
  * Please use {@link resolveIdToValue}
  *
  * Uses the aliases that were tracked in the environments (by the
  * {@link getAliases} function) to resolve a node to a value.
- * @param resolve    - Variable resolve mode
  * @param identifier - Identifier to resolve
- * @param use        - Environment to use
- * @param ctx        - analysis context
- * @param graph      - dataflow graph
- * @param idMap      - id map of Dataflow graph
+ * @param environment - Environment to use
+ * @param r          - Resolve information (env, ctx, ...)
  * @returns Value of Identifier or Top
  */
-export declare function trackAliasInEnvironments(resolve: VariableResolve, identifier: Identifier | undefined, use: REnvironmentInformation, ctx: ReadOnlyFlowrAnalyzerContext, graph?: DataflowGraph, idMap?: AstIdMap): ResolveResult;
+export declare function trackAliasInEnvironments(identifier: Identifier | undefined, environment: REnvironmentInformation, { blocked, idMap, resolve, ctx, graph }: Omit<ResolveInfo, 'environment'>): ResolveResult;
 /**
  * Please use {@link resolveIdToValue}
  *

package/dataflow/eval/resolve/alias-tracking.js

@@ -117,39 +117,44 @@ function getAliases(sourceIds, dataflow, environment) {
  * @param full               - Whether to track aliases on resolve
  * @param resolve            - Variable resolve mode
  * @param ctx                - Context used for clean environment
+ * @param blocked            - If set, the ids that should not be considered during resolution (=>top)
  */
-function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve, ctx }) {
+function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve, ctx, blocked }) {
     const variableResolve = resolve ?? ctx.config.solver.variables;
+    blocked ??= new Set();
     if (id === undefined) {
         return r_value_1.Top;
     }
     idMap ??= graph?.idMap;
     const node = typeof id === 'object' ? id : idMap?.get(id);
-    if (node === undefined) {
+    if (node === undefined || blocked.has(node.info.id)) {
         return r_value_1.Top;
     }
+    blocked.add(node.info.id);
     switch (node.type) {
         case type_1.RType.Argument:
             if (node.value) {
-                return resolveIdToValue(node.value.info.id, { environment, graph, idMap, full, resolve: variableResolve, ctx });
+                return resolveIdToValue(node.value.info.id, { environment, graph, idMap, full, resolve: variableResolve, ctx, blocked });
             }
         // eslint-disable-next-line no-fallthrough
         case type_1.RType.Symbol:
-            if (environment) {
-                return full ? trackAliasInEnvironments(variableResolve, node.lexeme, environment, ctx, graph, idMap) : r_value_1.Top;
-            }
-            else if (graph && resolve === config_1.VariableResolve.Alias) {
-                return full ? trackAliasesInGraph(node.info.id, graph, ctx, idMap) : r_value_1.Top;
-            }
-            else {
-                return r_value_1.Top;
+            if (full) {
+                if (environment) {
+                    return trackAliasInEnvironments(identifier_1.Identifier.toString(node.content), environment, { idMap, resolve: variableResolve, ctx, graph, blocked });
+                }
+                else if (graph && resolve === config_1.VariableResolve.Alias) {
+                    return trackAliasesInGraph(node.info.id, graph, ctx, idMap);
+                }
             }
+            return r_value_1.Top;
         case type_1.RType.FunctionDefinition:
             return (0, set_constants_1.setFrom)({ type: 'function-definition' });
         case type_1.RType.FunctionCall:
         case type_1.RType.BinaryOp:
         case type_1.RType.UnaryOp:
-            return (0, set_constants_1.setFrom)((0, resolve_1.resolveNode)(variableResolve, node, ctx, environment, graph, idMap));
+            return (0, set_constants_1.setFrom)((0, resolve_1.resolveNode)({
+                resolve: variableResolve, node, ctx, environment, graph, idMap, blocked
+            }));
         case type_1.RType.String:
         case type_1.RType.Number:
         case type_1.RType.Logical:
@@ -163,19 +168,16 @@ function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve,
  *
  * Uses the aliases that were tracked in the environments (by the
  * {@link getAliases} function) to resolve a node to a value.
- * @param resolve    - Variable resolve mode
  * @param identifier - Identifier to resolve
- * @param use        - Environment to use
- * @param ctx        - analysis context
- * @param graph      - dataflow graph
- * @param idMap      - id map of Dataflow graph
+ * @param environment - Environment to use
+ * @param r          - Resolve information (env, ctx, ...)
  * @returns Value of Identifier or Top
  */
-function trackAliasInEnvironments(resolve, identifier, use, ctx, graph, idMap) {
+function trackAliasInEnvironments(identifier, environment, { blocked, idMap, resolve = config_1.VariableResolve.Alias, ctx, graph }) {
     if (identifier === undefined) {
         return r_value_1.Top;
     }
-    const defs = (0, resolve_by_name_1.resolveByNameAnyType)(identifier, use);
+    const defs = (0, resolve_by_name_1.resolveByNameAnyType)(identifier, environment);
     if (defs === undefined) {
         return r_value_1.Top;
     }
@@ -195,7 +197,7 @@ function trackAliasInEnvironments(resolve, identifier, use, ctx, graph, idMap) {
             for (const alias of def.value) {
                 const definitionOfAlias = idMap?.get(alias);
                 if (definitionOfAlias !== undefined) {
-                    const value = (0, resolve_1.resolveNode)(resolve, definitionOfAlias, ctx, use, graph, idMap);
+                    const value = (0, resolve_1.resolveNode)({ resolve, node: definitionOfAlias, ctx, environment, graph, idMap, blocked });
                     if ((0, r_value_1.isTop)(value)) {
                         return r_value_1.Top;
                     }
@@ -252,7 +254,7 @@ function isNestedInLoop(node, ast) {
     if (parentNode === undefined) {
         return false;
     }
-    if (parentNode.type === type_1.RType.WhileLoop || parentNode.type === type_1.RType.RepeatLoop) {
+    if (parentNode.type === type_1.RType.WhileLoop || parentNode.type === type_1.RType.RepeatLoop || parentNode.type === type_1.RType.ForLoop) {
         return true;
     }
     return isNestedInLoop(parentNode, ast);
@@ -273,7 +275,7 @@ function trackAliasesInGraph(id, graph, ctx, idMap) {
     }
     idMap ??= graph.idMap;
     (0, assert_1.guard)(idMap !== undefined, 'The ID map is required to get the lineage of a node');
-    const queue = new visiting_queue_1.VisitingQueue(25);
+    const queue = new visiting_queue_1.VisitingQueue(10);
     const clean = ctx.env.makeCleanEnv();
     const cleanFingerprint = ctx.env.getCleanEnvFingerprint();
     queue.add(id, clean, cleanFingerprint, false);
@@ -281,11 +283,10 @@ function trackAliasesInGraph(id, graph, ctx, idMap) {
     const resultIds = [];
     while (queue.nonEmpty()) {
         const { id, baseEnvironment } = queue.next();
-        const res = graph.get(id);
-        if (!res) {
+        const vertex = graph.getVertex(id);
+        if (!vertex) {
             continue;
         }
-        const [vertex, outgoingEdges] = res;
         const cds = vertex.cds;
         for (const cd of cds ?? []) {
             const target = graph.idMap?.get(cd.id);
@@ -303,25 +304,23 @@ function trackAliasesInGraph(id, graph, ctx, idMap) {
         if (forceTop) {
             break;
         }
-        if (vertex.tag === vertex_1.VertexType.Value) {
-            resultIds.push(id);
-            continue;
-        }
-        else if (vertex.tag === vertex_1.VertexType.FunctionDefinition) {
+        const t = vertex.tag;
+        if (t === vertex_1.VertexType.Value || t === vertex_1.VertexType.FunctionDefinition) {
             resultIds.push(id);
             continue;
         }
-        const isFn = vertex.tag === vertex_1.VertexType.FunctionCall;
+        const isFn = t === vertex_1.VertexType.FunctionCall;
+        const outgoingEdges = graph.outgoingEdges(id) ?? [];
         // travel all read and defined-by edges
-        for (const [targetId, edge] of outgoingEdges) {
+        for (const [targetId, { types }] of outgoingEdges) {
             if (isFn) {
-                if (edge.types === edge_1.EdgeType.Returns || edge.types === edge_1.EdgeType.DefinedByOnCall || edge.types === edge_1.EdgeType.DefinedBy) {
+                if (types === edge_1.EdgeType.Returns || types === edge_1.EdgeType.DefinedByOnCall || types === edge_1.EdgeType.DefinedBy) {
                     queue.add(targetId, baseEnvironment, cleanFingerprint, false);
                 }
                 continue;
             }
             // currently, they have to be exact!
-            if (edge.types === edge_1.EdgeType.Reads || edge.types === edge_1.EdgeType.DefinedBy || edge.types === edge_1.EdgeType.DefinedByOnCall) {
+            if (types === edge_1.EdgeType.Reads || types === edge_1.EdgeType.DefinedBy || types === edge_1.EdgeType.DefinedByOnCall) {
                 queue.add(targetId, baseEnvironment, cleanFingerprint, false);
             }
         }

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/eval/resolve/resolve.d.ts

@@ -1,81 +1,47 @@
-import type { AstIdMap, RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { REnvironmentInformation } from '../../environments/environment';
-import type { DataflowGraph } from '../../graph/graph';
+import type { BuiltInEvalHandlerArgs } from '../../environments/built-in';
 import { type Lift, Top, type Value, type ValueNumber, type ValueVector } from '../values/r-value';
-import type { VariableResolve } from '../../../config';
-import type { ReadOnlyFlowrAnalyzerContext } from '../../../project/context/flowr-analyzer-context';
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
  *
  * This function converts an RNode to its Value, but also recursively resolves
- * aliases and vectors (in case of a vector).
- * @param a       - Ast node to resolve
- * @param resolve - Variable resolve mode
- * @param ctx     - Analyzer context
- * @param env     - Environment to use
- * @param graph   - Dataflow Graph to use
- * @param map     - Idmap of Dataflow Graph
+ * aliases and vectors (in case of node vector).
  * @returns resolved value or top/bottom
  */
-export declare function resolveNode(resolve: VariableResolve, a: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, env?: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap): Value;
+export declare function resolveNode({ resolve, node, ctx, blocked, environment, graph, idMap }: BuiltInEvalHandlerArgs): Value;
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
  *
  * This function resolves a vector function call `c` to a {@link ValueVector}
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- * @param resolve     - Variable resolve mode
- * @param node        - Node of the vector function to resolve
- * @param environment - Environment to use
- * @param ctx         - Analyzer context
- * @param graph       - Dataflow graph
- * @param idMap       - ID map of the dataflow graph
  * @returns ValueVector or Top
  */
-export declare function resolveAsVector(resolve: VariableResolve, node: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueVector<Lift<Value[]>> | typeof Top;
+export declare function resolveAsVector({ resolve, environment, node, graph, idMap, ctx, blocked }: BuiltInEvalHandlerArgs): ValueVector | typeof Top;
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
  *
  * This function resolves a binary sequence operator `:` to a {@link ValueVector} of {@link ValueNumber}s
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- * @param resolve  - Variable resolve mode
- * @param operator - Node of the sequence operator to resolve
- * @param graph    - Dataflow graph
- * @param ctx      - Analyzer context
- * @param idMap    - Id map of the dataflow graph
- * @param environment - Environment to use
  * @returns ValueVector of ValueNumbers or Top
  */
-export declare function resolveAsSeq(resolve: VariableResolve, operator: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueVector<Lift<ValueNumber[]>> | typeof Top;
+export declare function resolveAsSeq({ node: operator, environment, resolve, ctx, graph, idMap, blocked }: BuiltInEvalHandlerArgs): ValueVector<Lift<ValueNumber[]>> | typeof Top;
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
  *
  * This function resolves a unary plus operator `+` to a {@link ValueNumber} or {@link ValueVector} of ValueNumbers
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- * @param resolve  - Variable resolve mode
- * @param operator - Node of the plus operator to resolve
- * @param graph    - Dataflow graph
- * @param ctx      - Analyzer context
- * @param idMap    - Id map of the dataflow graph
- * @param environment - Environment to use
  * @returns ValueNumber, ValueVector of ValueNumbers, or Top
  */
-export declare function resolveAsPlus(resolve: VariableResolve, operator: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueNumber | ValueVector<Lift<ValueNumber[]>> | typeof Top;
+export declare function resolveAsPlus({ node: operator, environment, resolve, ctx, graph, idMap, blocked }: BuiltInEvalHandlerArgs): ValueNumber | ValueVector<Lift<ValueNumber[]>> | typeof Top;
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
  *
  * This function resolves a unary minus operator `-` to a {@link ValueNumber} or {@link ValueVector} of ValueNumbers
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- * @param resolve  - Variable resolve mode
- * @param operator - Node of the minus operator to resolve
- * @param graph    - Dataflow graph
- * @param ctx      - Analyzer context
- * @param idMap    - Id map of the dataflow graph
- * @param environment - Environment to use
  * @returns ValueNumber, ValueVector of ValueNumbers, or Top
  */
-export declare function resolveAsMinus(resolve: VariableResolve, operator: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueNumber | ValueVector<Lift<ValueNumber[]>> | typeof Top;
+export declare function resolveAsMinus({ node: operator, environment, resolve, ctx, graph, idMap, blocked }: BuiltInEvalHandlerArgs): ValueNumber | ValueVector<Lift<ValueNumber[]>> | typeof Top;