@eagleoutice/flowr 2.8.6 → 2.8.7

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.8.5, R grammar v14 (tree-sitter engine)
+    flowR repl using flowR v2.8.6, R grammar v14 (tree-sitter engine)
     R> :query @linter "read.csv(\"/root/x.txt\")"
     ```
     
@@ -33,9 +33,9 @@ It offers a wide variety of features, for example:
     
     
     ```text
-    Query: linter (2 ms)
+    Query: linter (1 ms)
        ╰ Deprecated Functions (deprecated-functions):
-           ╰ Metadata: totalCalls: 0, totalFunctionDefinitions: 0, searchTimeMs: 1, processTimeMs: 0
+           ╰ Metadata: totalCalls: 0, totalFunctionDefinitions: 0, searchTimeMs: 0, processTimeMs: 0
        ╰ File Path Validity (file-path-validity):
            ╰ certain:
                ╰ Path `/root/x.txt` at 1.1-23
@@ -58,7 +58,7 @@ It offers a wide variety of features, for example:
            ╰ 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 ≈1 ms (1ms accuracy, total 2 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\
@@ -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.6 ms_ (including parsing and normalization and the query) within the generation environment.
+    The analysis required _2.7 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": {
@@ -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.8.5, R grammar v14 (tree-sitter engine)
+    flowR repl using flowR v2.8.6, 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 3 ms)
+    All queries together required ≈3 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.7 ms</span></i> (as of Jan 5, 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.2 ms</span></i> (as of Jan 13, 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/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.8.5, R grammar v14 (tree-sitter engine)
+    flowR repl using flowR v2.8.6, 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 _4.1 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/abstract-interpretation/absint-visitor.d.ts

@@ -1,6 +1,7 @@
 import type { CfgSimpleVertex, ControlFlowInformation } from '../control-flow/control-flow-graph';
 import type { SemanticCfgGuidedVisitorConfiguration } from '../control-flow/semantic-cfg-guided-visitor';
 import { SemanticCfgGuidedVisitor } from '../control-flow/semantic-cfg-guided-visitor';
+import { BuiltInProcessorMapper } from '../dataflow/environments/built-in';
 import type { DataflowGraph } from '../dataflow/graph/graph';
 import { type DataflowGraphVertexFunctionCall, type DataflowGraphVertexVariableDefinition } from '../dataflow/graph/vertex';
 import type { NoInfo, RNode } from '../r-bridge/lang-4.x/ast/model/model';
@@ -8,7 +9,7 @@ import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { type AnyAbstractDomain } from './domains/abstract-domain';
 import type { StateAbstractDomain } from './domains/state-abstract-domain';
-export interface AbsintVisitorConfiguration<Domain extends AnyAbstractDomain, OtherInfo = NoInfo> extends Omit<SemanticCfgGuidedVisitorConfiguration<OtherInfo, ControlFlowInformation, NormalizedAst<OtherInfo>>, 'defaultVisitingOrder' | 'defaultVisitingType'> {
+export interface AbsintVisitorConfiguration<Domain extends AnyAbstractDomain> extends Omit<SemanticCfgGuidedVisitorConfiguration<NoInfo, ControlFlowInformation, NormalizedAst>, 'defaultVisitingOrder' | 'defaultVisitingType'> {
     readonly domain: StateAbstractDomain<Domain>;
 }
 /**
@@ -16,7 +17,7 @@ export interface AbsintVisitorConfiguration<Domain extends AnyAbstractDomain, Ot
  *
  * However, the visitor does not yet support inter-procedural abstract interpretation and abstract condition semantics.
  */
-export declare abstract class AbstractInterpretationVisitor<Domain extends AnyAbstractDomain, OtherInfo = NoInfo, Config extends AbsintVisitorConfiguration<Domain, OtherInfo> = AbsintVisitorConfiguration<Domain, OtherInfo>> extends SemanticCfgGuidedVisitor<OtherInfo, ControlFlowInformation, NormalizedAst<OtherInfo>, DataflowGraph, Config & {
+export declare abstract class AbstractInterpretationVisitor<Domain extends AnyAbstractDomain, Config extends AbsintVisitorConfiguration<Domain> = AbsintVisitorConfiguration<Domain>> extends SemanticCfgGuidedVisitor<NoInfo, ControlFlowInformation, NormalizedAst, DataflowGraph, Config & {
     defaultVisitingOrder: 'forward';
     defaultVisitingType: 'exit';
 }> {
@@ -25,13 +26,13 @@ export declare abstract class AbstractInterpretationVisitor<Domain extends AnyAb
      */
     protected readonly trace: Map<NodeId, StateAbstractDomain<Domain>>;
     /**
-     * A set of nodes representing variable definitions that have already been visited but whose assignment has not yet been processed.
+     * The current abstract state domain at the currently processed AST node.
      */
-    private readonly unassigned;
+    protected currentState: StateAbstractDomain<Domain>;
     /**
-     * The current abstract state domain at the currently processed AST node.
+     * A set of nodes representing variable definitions that have already been visited but whose assignment has not yet been processed.
      */
-    private currentState;
+    private readonly unassigned;
     constructor(config: Config);
     /**
      * Resolves the inferred abstract value of an AST node.
@@ -40,7 +41,7 @@ export declare abstract class AbstractInterpretationVisitor<Domain extends AnyAb
      * @param state - An optional state abstract domain used to resolve the inferred abstract value (defaults to the state at the requested node)
      * @returns The inferred abstract value of the node, or `undefined` if no value was inferred for the node
      */
-    getAbstractValue(id: RNode<ParentInformation & OtherInfo> | NodeId | undefined, state?: StateAbstractDomain<Domain>): Domain | undefined;
+    getAbstractValue(id: RNode<ParentInformation> | NodeId | undefined, state?: StateAbstractDomain<Domain>): Domain | undefined;
     /**
      * Gets the inferred abstract state at the location of a specific AST node.
      * This requires that the abstract interpretation visitor has been completed, or at least started.
@@ -61,6 +62,7 @@ export declare abstract class AbstractInterpretationVisitor<Domain extends AnyAb
     getAbstractTrace(): ReadonlyMap<NodeId, StateAbstractDomain<Domain>>;
     start(): void;
     protected visitNode(vertexId: NodeId): boolean;
+    protected onDispatchFunctionCallOrigin(call: DataflowGraphVertexFunctionCall, origin: keyof typeof BuiltInProcessorMapper | string): void;
     protected onVariableDefinition({ vertex }: {
         vertex: DataflowGraphVertexVariableDefinition;
     }): void;
@@ -69,73 +71,23 @@ export declare abstract class AbstractInterpretationVisitor<Domain extends AnyAb
         target?: NodeId;
         source?: NodeId;
     }): void;
-    protected onReplacementCall({ call, target, source }: {
+    protected onReplacementCall({ target }: {
         call: DataflowGraphVertexFunctionCall;
         target?: NodeId;
         source?: NodeId;
     }): void;
-    protected onAccessCall({ call }: {
-        call: DataflowGraphVertexFunctionCall;
-    }): void;
-    protected onUnnamedCall({ call }: {
-        call: DataflowGraphVertexFunctionCall;
-    }): void;
-    protected onEvalFunctionCall({ call }: {
-        call: DataflowGraphVertexFunctionCall;
-    }): void;
-    protected onApplyFunctionCall({ call }: {
-        call: DataflowGraphVertexFunctionCall;
-    }): void;
-    protected onSourceCall({ call }: {
-        call: DataflowGraphVertexFunctionCall;
-    }): void;
-    protected onGetCall({ call }: {
-        call: DataflowGraphVertexFunctionCall;
-    }): void;
-    protected onRmCall({ call }: {
-        call: DataflowGraphVertexFunctionCall;
-    }): void;
-    protected onListCall({ call }: {
-        call: DataflowGraphVertexFunctionCall;
-    }): void;
-    protected onVectorCall({ call }: {
-        call: DataflowGraphVertexFunctionCall;
-    }): void;
-    protected onSpecialBinaryOpCall({ call }: {
-        call: DataflowGraphVertexFunctionCall;
-    }): void;
-    protected onQuoteCall({ call }: {
-        call: DataflowGraphVertexFunctionCall;
-    }): void;
-    protected onLibraryCall({ call }: {
-        call: DataflowGraphVertexFunctionCall;
-    }): void;
-    protected onDefaultFunctionCall({ call }: {
-        call: DataflowGraphVertexFunctionCall;
-    }): void;
-    /**
-     * Evaluates any function call visited by the abstract interpretation visitor by applying the abstract semantics of the function call to the current abstract state.
-     * @param call  - The data flow vertex of the function call to evaluate
-     * @param state - The current abstract state before the evaluation of the function call
-     * @returns The abstract state after applying the abstract semantics of the function call
-     */
-    protected abstract evalFunctionCall(call: DataflowGraphVertexFunctionCall, state: StateAbstractDomain<Domain>): StateAbstractDomain<Domain>;
     /**
-     * Evaluates any replacement function call visited by the abstract interpretation visitor by applying the abstract semantics of the replacement call to the current abstract state (e.g. for `$<-`, `[<-`, `names<-`, ...).
-     * @param call   - The data flow vertex of the replacement call to evaluate
-     * @param source - The node ID of the assignment target of the replacement call
-     * @param target - The node ID of the assigned expression of the replacement call
-     * @param state  - The current abstract state before the evaluation of the replacement call
-     * @returns The abstract state after applying the abstract semantics of the replacement call
+     * This event triggers for every function call that is not a condition, loop, assignment, replacement call, or access operation.
+     *
+     *
+     * For example, this triggers for `data.frame` in `x <- data.frame(id = 1:5, name = letters[1:5])`.
+     *
+     * This bundles all function calls that are no conditions, loops, assignments, replacement calls, and access operations.
+     * @protected
      */
-    protected abstract evalReplacementCall(call: DataflowGraphVertexFunctionCall, target: NodeId, source: NodeId, state: StateAbstractDomain<Domain>): StateAbstractDomain<Domain>;
-    /**
-     * Evaluates any access operation call visited by the abstract interpretation visitor by applying the abstract semantics of the access operation to the current abstract stat (e.g. for `$`, `[`, `[[`, ...).
-     * @param call  - The data flow vertex of the access operation to evaluate
-     * @param state - The current abstract state before the evaluation of the access operation
-     * @returns The abstract state after applying the abstract semantics of the access operation
-     */
-    protected abstract evalAccessCall(call: DataflowGraphVertexFunctionCall, state: StateAbstractDomain<Domain>): StateAbstractDomain<Domain>;
+    protected onFunctionCall(_data: {
+        call: DataflowGraphVertexFunctionCall;
+    }): void;
     /** Gets all AST nodes for the predecessor vertices that are leaf nodes and exit vertices */
     protected getPredecessorNodes(vertexId: NodeId): NodeId[];
     /** Gets each variable origin that has already been visited and whose assignment has already been processed */

package/abstract-interpretation/absint-visitor.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractInterpretationVisitor = void 0;
 const control_flow_graph_1 = require("../control-flow/control-flow-graph");
 const semantic_cfg_guided_visitor_1 = require("../control-flow/semantic-cfg-guided-visitor");
+const built_in_1 = require("../dataflow/environments/built-in");
 const vertex_1 = require("../dataflow/graph/vertex");
 const dfg_get_origin_1 = require("../dataflow/origin/dfg-get-origin");
 const r_function_call_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
@@ -19,14 +20,14 @@ class AbstractInterpretationVisitor extends semantic_cfg_guided_visitor_1.Semant
      * The abstract trace of the abstract interpretation visitor mapping node IDs to the abstract state at the respective node.
      */
     trace = new Map();
-    /**
-     * A set of nodes representing variable definitions that have already been visited but whose assignment has not yet been processed.
-     */
-    unassigned = new Set();
     /**
      * The current abstract state domain at the currently processed AST node.
      */
     currentState;
+    /**
+     * A set of nodes representing variable definitions that have already been visited but whose assignment has not yet been processed.
+     */
+    unassigned = new Set();
     constructor(config) {
         super({ ...config, defaultVisitingOrder: 'forward', defaultVisitingType: 'exit' });
         this.currentState = config.domain.bottom();
@@ -60,9 +61,9 @@ class AbstractInterpretationVisitor extends semantic_cfg_guided_visitor_1.Semant
             return this.getAbstractValue(node.value, state);
         }
         else if (node.type === type_1.RType.ExpressionList && node.children.length > 0) {
-            return this.getAbstractValue(node.children[node.children.length - 1], state);
+            return this.getAbstractValue(node.children.at(-1), state);
         }
-        else if (origins.includes('builtin:pipe')) {
+        else if (origins.includes(built_in_1.BuiltInProcName.Pipe)) {
             if (node.type === type_1.RType.Pipe || node.type === type_1.RType.BinaryOp) {
                 return this.getAbstractValue(node.rhs, state);
             }
@@ -70,7 +71,7 @@ class AbstractInterpretationVisitor extends semantic_cfg_guided_visitor_1.Semant
                 return this.getAbstractValue(call.args[1].nodeId, state);
             }
         }
-        else if (origins.includes('builtin:if-then-else')) {
+        else if (origins.includes(built_in_1.BuiltInProcName.IfThenElse)) {
             let values = [];
             if (node.type === type_1.RType.IfThenElse && node.otherwise !== undefined) {
                 values = [node.then, node.otherwise].map(entry => this.getAbstractValue(entry, state));
@@ -90,7 +91,7 @@ class AbstractInterpretationVisitor extends semantic_cfg_guided_visitor_1.Semant
      * @returns The abstract state at the node, or `undefined` if the node has no abstract state (i.e. the node has not been visited or is unreachable).
      */
     getAbstractState(id) {
-        return id !== undefined ? this.trace.get(id) : undefined;
+        return id === undefined ? undefined : this.trace.get(id);
     }
     /**
      * Gets the inferred abstract state at the end of the program (exit nodes of the control flow graph).
@@ -148,8 +149,28 @@ class AbstractInterpretationVisitor extends semantic_cfg_guided_visitor_1.Semant
         this.trace.set(nodeId, this.currentState);
         return true;
     }
+    onDispatchFunctionCallOrigin(call, origin) {
+        super.onDispatchFunctionCallOrigin(call, origin);
+        if (!(origin in built_in_1.BuiltInProcessorMapper)) {
+            return this.onFunctionCall({ call });
+        }
+        switch (origin) {
+            case 'builtin:expression-list':
+            case 'builtin:if-then-else':
+            case 'builtin:for-loop':
+            case 'builtin:while-loop':
+            case 'builtin:repeat-loop':
+            case 'builtin:assignment':
+            case 'builtin:assignment-like':
+            case 'builtin:replacement':
+            case 'builtin:access':
+                return;
+            default:
+                return this.onFunctionCall({ call });
+        }
+    }
     onVariableDefinition({ vertex }) {
-        if (this.getAbstractState(vertex.id) === undefined) {
+        if (this.currentState.get(vertex.id) === undefined) {
             this.unassigned.add(vertex.id);
         }
     }
@@ -164,52 +185,21 @@ class AbstractInterpretationVisitor extends semantic_cfg_guided_visitor_1.Semant
             this.trace.set(target, this.currentState.create(this.currentState.value));
         }
     }
-    onReplacementCall({ call, target, source }) {
-        if (source === undefined || target === undefined) {
-            return;
+    onReplacementCall({ target }) {
+        if (target !== undefined) {
+            this.unassigned.delete(target);
         }
-        this.currentState = this.evalReplacementCall(call, target, source, this.currentState);
-        this.unassigned.delete(target);
-    }
-    onAccessCall({ call }) {
-        this.currentState = this.evalAccessCall(call, this.currentState);
-    }
-    onUnnamedCall({ call }) {
-        this.currentState = this.evalFunctionCall(call, this.currentState);
-    }
-    onEvalFunctionCall({ call }) {
-        this.currentState = this.evalFunctionCall(call, this.currentState);
-    }
-    onApplyFunctionCall({ call }) {
-        this.currentState = this.evalFunctionCall(call, this.currentState);
-    }
-    onSourceCall({ call }) {
-        this.currentState = this.evalFunctionCall(call, this.currentState);
-    }
-    onGetCall({ call }) {
-        this.currentState = this.evalFunctionCall(call, this.currentState);
-    }
-    onRmCall({ call }) {
-        this.currentState = this.evalFunctionCall(call, this.currentState);
-    }
-    onListCall({ call }) {
-        this.currentState = this.evalFunctionCall(call, this.currentState);
-    }
-    onVectorCall({ call }) {
-        this.currentState = this.evalFunctionCall(call, this.currentState);
-    }
-    onSpecialBinaryOpCall({ call }) {
-        this.currentState = this.evalFunctionCall(call, this.currentState);
-    }
-    onQuoteCall({ call }) {
-        this.currentState = this.evalFunctionCall(call, this.currentState);
-    }
-    onLibraryCall({ call }) {
-        this.currentState = this.evalFunctionCall(call, this.currentState);
-    }
-    onDefaultFunctionCall({ call }) {
-        this.currentState = this.evalFunctionCall(call, this.currentState);
     }
+    /**
+     * This event triggers for every function call that is not a condition, loop, assignment, replacement call, or access operation.
+     *
+     *
+     * For example, this triggers for `data.frame` in `x <- data.frame(id = 1:5, name = letters[1:5])`.
+     *
+     * This bundles all function calls that are no conditions, loops, assignments, replacement calls, and access operations.
+     * @protected
+     */
+    onFunctionCall(_data) { }
     /** Gets all AST nodes for the predecessor vertices that are leaf nodes and exit vertices */
     getPredecessorNodes(vertexId) {
         return this.config.controlFlow.graph.outgoingEdges(vertexId)?.keys() // outgoing dependency edges are incoming CFG edges
@@ -249,7 +239,7 @@ class AbstractInterpretationVisitor extends semantic_cfg_guided_visitor_1.Semant
             return false;
         }
         const origin = dataflowVertex.origin;
-        return origin.includes('builtin:for-loop') || origin.includes('builtin:while-loop') || origin.includes('builtin:repeat-loop');
+        return origin.includes(built_in_1.BuiltInProcName.ForLoop) || origin.includes(built_in_1.BuiltInProcName.WhileLoop) || origin.includes(built_in_1.BuiltInProcName.RepeatLoop);
     }
     /**
      * Checks whether to continue visiting the control flow graph after a widening point.

package/abstract-interpretation/data-frame/dataframe-domain.d.ts

@@ -1,9 +1,7 @@
-import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { AbstractDomainValue } from '../domains/abstract-domain';
 import { PosIntervalDomain } from '../domains/positive-interval-domain';
 import { ProductDomain } from '../domains/product-domain';
 import { SetRangeDomain } from '../domains/set-range-domain';
-import { StateAbstractDomain } from '../domains/state-abstract-domain';
 /** The type of the abstract product representing the shape of data frames */
 export type AbstractDataFrameShape = {
     colnames: SetRangeDomain<string>;
@@ -34,10 +32,3 @@ export declare class DataFrameDomain extends ProductDomain<AbstractDataFrameShap
     static top(maxColNames?: number): DataFrameDomain;
     private static refine;
 }
-/**
- * The data frame state abstract domain as state domain mapping AST node IDs to inferred abstract data frame shapes.
- */
-export declare class DataFrameStateDomain extends StateAbstractDomain<DataFrameDomain> {
-    create(value: ReadonlyMap<NodeId, DataFrameDomain>): this;
-    static bottom(): DataFrameStateDomain;
-}

package/abstract-interpretation/data-frame/dataframe-domain.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataFrameStateDomain = exports.DataFrameDomain = void 0;
+exports.DataFrameDomain = void 0;
 const lattice_1 = require("../domains/lattice");
 const positive_interval_domain_1 = require("../domains/positive-interval-domain");
 const product_domain_1 = require("../domains/product-domain");
 const set_range_domain_1 = require("../domains/set-range-domain");
-const state_abstract_domain_1 = require("../domains/state-abstract-domain");
 /**
  * The data frame abstract domain as product domain of a column names domain, column count domain, and row count domain.
  */
@@ -69,16 +68,4 @@ class DataFrameDomain extends product_domain_1.ProductDomain {
     }
 }
 exports.DataFrameDomain = DataFrameDomain;
-/**
- * The data frame state abstract domain as state domain mapping AST node IDs to inferred abstract data frame shapes.
- */
-class DataFrameStateDomain extends state_abstract_domain_1.StateAbstractDomain {
-    create(value) {
-        return new DataFrameStateDomain(value);
-    }
-    static bottom() {
-        return new DataFrameStateDomain(new Map());
-    }
-}
-exports.DataFrameStateDomain = DataFrameStateDomain;
 //# sourceMappingURL=dataframe-domain.js.map

package/abstract-interpretation/data-frame/mappers/function-mapper.js

@@ -558,7 +558,7 @@ function mapDataFrameFunctionCall(node, inference, dfg, ctx) {
 }
 function isDataFrameFunction(functionName) {
     // a check with `functionName in DataFrameFunctionMapper` would return true for "toString"
-    return Object.prototype.hasOwnProperty.call(DataFrameFunctionMapper, functionName);
+    return Object.hasOwn(DataFrameFunctionMapper, functionName);
 }
 function getOtherDataFrameFunction(functionName) {
     return OtherDataFrameFunctions.find(entry => entry.names.includes(functionName));

package/abstract-interpretation/data-frame/mappers/replacement-mapper.d.ts

@@ -6,6 +6,8 @@ import type { DataFrameOperations, DataFrameShapeInferenceVisitor } from '../sha
 /**
  * Maps a concrete data frame replacement function call to abstract data frame operations.
  * @param node - The R node of the replacement function call
+ * @param expression - The assigned expression node of the replacement function call
+ * @param inference - The data frame shape inference visitor for checking data frame arguments
  * @param dfg  - The data flow graph for resolving the arguments
  * @param ctx - The current flowR analysis context
  * @returns The mapped abstract data frame operations for the replacement function call, or `undefined` if the node does not represent a data frame replacement function call

package/abstract-interpretation/data-frame/mappers/replacement-mapper.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapDataFrameReplacementFunction = mapDataFrameReplacementFunction;
 const config_1 = require("../../../config");
+const built_in_1 = require("../../../dataflow/environments/built-in");
 const vertex_1 = require("../../../dataflow/graph/vertex");
 const make_argument_1 = require("../../../dataflow/internal/process/functions/call/argument/make-argument");
 const r_function_call_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
@@ -20,6 +21,8 @@ const DataFrameReplacementFunctionMapper = {
 /**
  * Maps a concrete data frame replacement function call to abstract data frame operations.
  * @param node - The R node of the replacement function call
+ * @param expression - The assigned expression node of the replacement function call
+ * @param inference - The data frame shape inference visitor for checking data frame arguments
  * @param dfg  - The data flow graph for resolving the arguments
  * @param ctx - The current flowR analysis context
  * @returns The mapped abstract data frame operations for the replacement function call, or `undefined` if the node does not represent a data frame replacement function call
@@ -51,11 +54,11 @@ function mapDataFrameReplacementFunction(node, expression, inference, dfg, ctx)
 }
 function isDataFrameReplacement(functionName) {
     // a check with `functionName in DataFrameReplacementFunctionMapper` would return true for "toString"
-    return Object.prototype.hasOwnProperty.call(DataFrameReplacementFunctionMapper, functionName);
+    return Object.hasOwn(DataFrameReplacementFunctionMapper, functionName);
 }
 function hasParentReplacement(node, dfg) {
     const parentVertex = node.info.parent ? dfg.getVertex(node.info.parent) : undefined;
-    return (0, vertex_1.isFunctionCallVertex)(parentVertex) && parentVertex.origin.includes('builtin:replacement');
+    return (0, vertex_1.isFunctionCallVertex)(parentVertex) && parentVertex.origin.includes(built_in_1.BuiltInProcName.Replacement);
 }
 function mapDataFrameContentAssignment(access, expression, inference) {
     const dataFrame = access.accessed;

package/abstract-interpretation/data-frame/shape-inference.d.ts

@@ -1,8 +1,8 @@
 import type { DataflowGraphVertexFunctionCall } from '../../dataflow/graph/vertex';
-import type { NoInfo } from '../../r-bridge/lang-4.x/ast/model/model';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { AbstractInterpretationVisitor, type AbsintVisitorConfiguration } from '../absint-visitor';
-import { DataFrameDomain, DataFrameStateDomain } from './dataframe-domain';
+import { StateAbstractDomain } from '../domains/state-abstract-domain';
+import { DataFrameDomain } from './dataframe-domain';
 import { ConstraintType, type DataFrameOperationArgs, type DataFrameOperationName, type DataFrameOperationOptions } from './semantics';
 interface Operation<Name extends DataFrameOperationName> {
     /** The type of the abstract data frame operation (see {@link DataFrameOperationName}) */
@@ -36,8 +36,8 @@ interface DataFrameShapeInferenceConfiguration extends Omit<AbsintVisitorConfigu
 /**
  * The control flow graph visitor to infer the shape of data frames using abstract interpretation
  */
-export declare class DataFrameShapeInferenceVisitor extends AbstractInterpretationVisitor<DataFrameDomain, NoInfo, DataFrameShapeInferenceConfiguration & {
-    domain: DataFrameStateDomain;
+export declare class DataFrameShapeInferenceVisitor extends AbstractInterpretationVisitor<DataFrameDomain, DataFrameShapeInferenceConfiguration & {
+    domain: StateAbstractDomain<DataFrameDomain>;
 }> {
     /**
      * The abstract data frame operations the function call nodes are mapped to.
@@ -51,9 +51,17 @@ export declare class DataFrameShapeInferenceVisitor extends AbstractInterpretati
      * @returns The mapped abstract data frame operations for the node, or `undefined` if no abstract operation was mapped for the node or storing mapped abstract operations is disabled via the visitor config.
      */
     getAbstractOperations(id: NodeId | undefined): Readonly<DataFrameOperations>;
-    protected evalFunctionCall(call: DataflowGraphVertexFunctionCall, state: DataFrameStateDomain): DataFrameStateDomain;
-    protected evalReplacementCall(call: DataflowGraphVertexFunctionCall, target: NodeId, source: NodeId, state: DataFrameStateDomain): DataFrameStateDomain;
-    protected evalAccessCall(call: DataflowGraphVertexFunctionCall, state: DataFrameStateDomain): DataFrameStateDomain;
+    protected onFunctionCall({ call }: {
+        call: DataflowGraphVertexFunctionCall;
+    }): void;
+    protected onReplacementCall({ call, target, source }: {
+        call: DataflowGraphVertexFunctionCall;
+        target?: NodeId;
+        source?: NodeId;
+    }): void;
+    protected onAccessCall({ call }: {
+        call: DataflowGraphVertexFunctionCall;
+    }): void;
     private applyDataFrameExpression;
 }
 export {};

package/abstract-interpretation/data-frame/shape-inference.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataFrameShapeInferenceVisitor = void 0;
 const absint_visitor_1 = require("../absint-visitor");
+const state_abstract_domain_1 = require("../domains/state-abstract-domain");
 const dataframe_domain_1 = require("./dataframe-domain");
 const access_mapper_1 = require("./mappers/access-mapper");
 const function_mapper_1 = require("./mappers/function-mapper");
@@ -16,7 +17,7 @@ class DataFrameShapeInferenceVisitor extends absint_visitor_1.AbstractInterpreta
      */
     operations;
     constructor({ trackOperations = true, ...config }) {
-        super({ ...config, domain: dataframe_domain_1.DataFrameStateDomain.bottom() });
+        super({ ...config, domain: state_abstract_domain_1.StateAbstractDomain.bottom() });
         if (trackOperations) {
             this.operations = new Map();
         }
@@ -30,35 +31,38 @@ class DataFrameShapeInferenceVisitor extends absint_visitor_1.AbstractInterpreta
     getAbstractOperations(id) {
         return id !== undefined ? this.operations?.get(id) : undefined;
     }
-    evalFunctionCall(call, state) {
+    onFunctionCall({ call }) {
+        super.onFunctionCall({ call });
         const node = this.getNormalizedAst(call.id);
         if (node === undefined) {
-            return state;
+            return;
         }
         const operations = (0, function_mapper_1.mapDataFrameFunctionCall)(node, this, this.config.dfg, this.config.ctx);
-        return this.applyDataFrameExpression(node, operations, state);
+        this.applyDataFrameExpression(node, operations);
     }
-    evalReplacementCall(call, target, source, state) {
+    onReplacementCall({ call, target, source }) {
+        super.onReplacementCall({ call, target, source });
         const node = this.getNormalizedAst(call.id);
         const targetNode = this.getNormalizedAst(target);
         const sourceNode = this.getNormalizedAst(source);
         if (node === undefined || targetNode === undefined || sourceNode === undefined) {
-            return state;
+            return;
         }
         const operations = (0, replacement_mapper_1.mapDataFrameReplacementFunction)(node, sourceNode, this, this.config.dfg, this.config.ctx);
-        return this.applyDataFrameExpression(node, operations, state);
+        this.applyDataFrameExpression(node, operations);
     }
-    evalAccessCall(call, state) {
+    onAccessCall({ call }) {
+        super.onAccessCall({ call });
         const node = this.getNormalizedAst(call.id);
         if (node === undefined) {
-            return state;
+            return;
         }
         const operations = (0, access_mapper_1.mapDataFrameAccess)(node, this, this.config.dfg, this.config.ctx);
-        return this.applyDataFrameExpression(node, operations, state);
+        this.applyDataFrameExpression(node, operations);
     }
-    applyDataFrameExpression(node, operations, state) {
+    applyDataFrameExpression(node, operations) {
         if (operations === undefined) {
-            return state;
+            return;
         }
         else if (this.operations !== undefined) {
             this.operations.set(node.info.id, operations);
@@ -66,20 +70,19 @@ class DataFrameShapeInferenceVisitor extends absint_visitor_1.AbstractInterpreta
         const maxColNames = this.config.ctx.config.abstractInterpretation.dataFrame.maxColNames;
         let value = dataframe_domain_1.DataFrameDomain.top(maxColNames);
         for (const { operation, operand, type, options, ...args } of operations) {
-            const operandValue = operand !== undefined ? this.getAbstractValue(operand, state) : value;
+            const operandValue = operand !== undefined ? this.getAbstractValue(operand, this.currentState) : value;
             value = (0, semantics_1.applyDataFrameSemantics)(operation, operandValue ?? dataframe_domain_1.DataFrameDomain.top(maxColNames), args, options);
             const constraintType = type ?? (0, semantics_1.getConstraintType)(operation);
             if (operand !== undefined && constraintType === semantics_1.ConstraintType.OperandModification) {
-                state.set(operand, value);
+                this.currentState.set(operand, value);
                 for (const origin of this.getVariableOrigins(operand)) {
-                    state.set(origin, value);
+                    this.currentState.set(origin, value);
                 }
             }
             else if (constraintType === semantics_1.ConstraintType.ResultPostcondition) {
-                state.set(node.info.id, value);
+                this.currentState.set(node.info.id, value);
             }
         }
-        return state;
     }
 }
 exports.DataFrameShapeInferenceVisitor = DataFrameShapeInferenceVisitor;