@eagleoutice/flowr 2.7.0 → 2.7.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.6.3, R grammar v14 (tree-sitter engine)
+    flowR repl using flowR v2.7.2, 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_: <code>{"totalCalls":0,"totalFunctionDefinitions":0,"searchTimeMs":1,"processTimeMs":0}</code>
+           ╰ _Metadata_: <code>{"totalCalls":0,"totalFunctionDefinitions":0,"searchTimeMs":0,"processTimeMs":0}</code>
        ╰ **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_: <code>{"consideredNodes":5,"searchTimeMs":0,"processTimeMs":0}</code>
        ╰ **Useless Loops** (useless-loop):
            ╰ _Metadata_: <code>{"numOfUselessLoops":0,"searchTimeMs":0,"processTimeMs":0}</code>
-    All queries together required ≈2 ms (1ms accuracy, total 2 ms)
+    All queries together required ≈1 ms (1ms accuracy, total 2 ms)
     ```
     
     
@@ -92,7 +92,7 @@ It offers a wide variety of features, for example:
     &nbsp;&nbsp;&nbsp;╰ **Absolute Paths** (absolute-file-paths):\
     &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\
-    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"totalConsidered":1,"totalUnknown":0,"searchTimeMs":1,"processTimeMs":0}</code>\
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"totalConsidered":1,"totalUnknown":0,"searchTimeMs":0,"processTimeMs":1}</code>\
     &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):\
@@ -105,11 +105,11 @@ It offers a wide variety of features, for example:
     &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 ≈3 ms (1ms accuracy, total 3 ms)_
+    _All queries together required ≈3 ms (1ms accuracy, total 4 ms)_
     
     <details> <summary style="color:gray">Show Detailed Results as Json</summary>
     
-    The analysis required _3.2 ms_ (including parsing and normalization and the query) within the generation environment.
+    The analysis required _3.5 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.
@@ -180,8 +180,8 @@ It offers a wide variety of features, for example:
             ".meta": {
               "totalConsidered": 1,
               "totalUnknown": 0,
-              "searchTimeMs": 1,
-              "processTimeMs": 0
+              "searchTimeMs": 0,
+              "processTimeMs": 1
             }
           },
           "unused-definitions": {
@@ -307,7 +307,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.6.3, R grammar v14 (tree-sitter engine)
+    flowR repl using flowR v2.7.2, R grammar v14 (tree-sitter engine)
     R> :query @static-slice (11@sum) file://test/testfiles/example.R
     ```
     
@@ -321,7 +321,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 ≈2 ms (1ms accuracy, total 2 ms)
+    All queries together required ≈3 ms (1ms accuracy, total 3 ms)
     ```
     
     
@@ -355,7 +355,7 @@ It offers a wide variety of features, for example:
         
 
 * 🚀 **fast data- and control-flow graphs**\
-  Within just <i><span title="This measurement is automatically fetched from the latest benchmark!">125 ms</span></i> (as of Nov 25, 2025), 
+  Within just <i><span title="This measurement is automatically fetched from the latest benchmark!">123.4 ms</span></i> (as of Dec 17, 2025), 
   _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 graph.
 
@@ -391,7 +391,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.6.3, R grammar v14 (tree-sitter engine)
+    flowR repl using flowR v2.7.2, R grammar v14 (tree-sitter engine)
     R> :dataflow* test/testfiles/example.R
     ```
     
@@ -696,7 +696,7 @@ It offers a wide variety of features, for example:
     ```
     
     	
-    (The analysis required _2.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 _5.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

@@ -0,0 +1,160 @@
+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 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';
+import type { NormalizedAst, ParentInformation } 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 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'> {
+    readonly domain: StateAbstractDomain<Domain>;
+}
+/**
+ * A control flow graph visitor to perform abstract interpretation.
+ *
+ * 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 & {
+    defaultVisitingOrder: 'forward';
+    defaultVisitingType: 'exit';
+}> {
+    /**
+     * The abstract trace of the abstract interpretation visitor mapping node IDs to the abstract state at the respective node.
+     */
+    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.
+     */
+    private readonly unassigned;
+    /**
+     * The current abstract state domain at the currently processed AST node.
+     */
+    private currentState;
+    constructor(config: Config);
+    /**
+     * Resolves the inferred abstract value of an AST node.
+     * This requires that the abstract interpretation visitor has been completed, or at least started.
+     * @param id    - The ID of the node to get the inferred value for
+     * @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;
+    /**
+     * 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.
+     * @param id - The ID of the node to get the abstract state at
+     * @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: NodeId | undefined): StateAbstractDomain<Domain> | undefined;
+    /**
+     * Gets the inferred abstract state at the end of the program (exit nodes of the control flow graph).
+     * This requires that the abstract interpretation visitor has been completed, or at least started.
+     * @returns The inferred abstract state at the end of the program
+     */
+    getEndState(): StateAbstractDomain<Domain>;
+    /**
+     * Gets the inferred abstract trace mapping AST nodes to the inferred abstract state at the respective node.
+     * @returns The inferred abstract trace of the program
+     */
+    getAbstractTrace(): ReadonlyMap<NodeId, StateAbstractDomain<Domain>>;
+    start(): void;
+    protected visitNode(vertexId: NodeId): boolean;
+    protected onVariableDefinition({ vertex }: {
+        vertex: DataflowGraphVertexVariableDefinition;
+    }): void;
+    protected onAssignmentCall({ target, source }: {
+        call: DataflowGraphVertexFunctionCall;
+        target?: NodeId;
+        source?: NodeId;
+    }): void;
+    protected onReplacementCall({ call, target, source }: {
+        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
+     */
+    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>;
+    /** 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 */
+    protected getVariableOrigins(nodeId: NodeId): NodeId[];
+    /** We only perform widening at `for`, `while`, or `repeat` loops with more than one incoming CFG edge */
+    protected isWideningPoint(nodeId: NodeId): boolean;
+    /**
+     * Checks whether to continue visiting the control flow graph after a widening point.
+     * By default, we only continue visiting if the widening point is visited for the first time or the abstract state at the widening point changed.
+     */
+    protected shouldContinueVisiting(wideningPoint: CfgSimpleVertex, oldState: StateAbstractDomain<Domain>): boolean;
+    /**
+     * Checks whether a control flow graph vertex should be skipped during visitation.
+     * By default, we only process vertices of leaf nodes and exit vertices (no entry nodes of complex nodes).
+     */
+    protected shouldSkipVertex(vertex: CfgSimpleVertex): boolean;
+    /**
+     * Whether widening should be performed at a widening point.
+     * By default, we perform widening when the number of visitation of the widening point reaches the widening threshold of the config.
+     */
+    protected shouldWiden(wideningPoint: CfgSimpleVertex): boolean;
+}

package/abstract-interpretation/absint-visitor.js

@@ -0,0 +1,279 @@
+"use strict";
+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 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");
+const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
+const assert_1 = require("../util/assert");
+const abstract_domain_1 = require("./domains/abstract-domain");
+/**
+ * A control flow graph visitor to perform abstract interpretation.
+ *
+ * However, the visitor does not yet support inter-procedural abstract interpretation and abstract condition semantics.
+ */
+class AbstractInterpretationVisitor extends semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor {
+    /**
+     * 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;
+    constructor(config) {
+        super({ ...config, defaultVisitingOrder: 'forward', defaultVisitingType: 'exit' });
+        this.currentState = config.domain.bottom();
+    }
+    /**
+     * Resolves the inferred abstract value of an AST node.
+     * This requires that the abstract interpretation visitor has been completed, or at least started.
+     * @param id    - The ID of the node to get the inferred value for
+     * @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, state) {
+        const node = (id === undefined || typeof id === 'object') ? id : this.getNormalizedAst(id);
+        state ??= node !== undefined ? this.getAbstractState(node.info.id) : undefined;
+        if (node === undefined) {
+            return;
+        }
+        else if (state?.has(node.info.id)) {
+            return state.get(node.info.id);
+        }
+        const vertex = this.getDataflowGraph(node.info.id);
+        const call = vertex?.tag === vertex_1.VertexType.FunctionCall ? vertex : undefined;
+        const origins = Array.isArray(call?.origin) ? call.origin : [];
+        if (node.type === type_1.RType.Symbol) {
+            const values = this.getVariableOrigins(node.info.id).map(origin => state?.get(origin));
+            if (values.length > 0 && values.every(assert_1.isNotUndefined)) {
+                return abstract_domain_1.AbstractDomain.joinAll(values);
+            }
+        }
+        else if (node.type === type_1.RType.Argument && node.value !== undefined) {
+            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);
+        }
+        else if (origins.includes('builtin:pipe')) {
+            if (node.type === type_1.RType.Pipe || node.type === type_1.RType.BinaryOp) {
+                return this.getAbstractValue(node.rhs, state);
+            }
+            else if (call?.args.length === 2 && call?.args[1] !== r_function_call_1.EmptyArgument) {
+                return this.getAbstractValue(call.args[1].nodeId, state);
+            }
+        }
+        else if (origins.includes('builtin:if-then-else')) {
+            let values = [];
+            if (node.type === type_1.RType.IfThenElse && node.otherwise !== undefined) {
+                values = [node.then, node.otherwise].map(entry => this.getAbstractValue(entry, state));
+            }
+            else if (call?.args.every(arg => arg !== r_function_call_1.EmptyArgument) && call.args.length === 3) {
+                values = call.args.slice(1, 3).map(entry => this.getAbstractValue(entry.nodeId, state));
+            }
+            if (values.length > 0 && values.every(assert_1.isNotUndefined)) {
+                return abstract_domain_1.AbstractDomain.joinAll(values);
+            }
+        }
+    }
+    /**
+     * 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.
+     * @param id - The ID of the node to get the abstract state at
+     * @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;
+    }
+    /**
+     * Gets the inferred abstract state at the end of the program (exit nodes of the control flow graph).
+     * This requires that the abstract interpretation visitor has been completed, or at least started.
+     * @returns The inferred abstract state at the end of the program
+     */
+    getEndState() {
+        const exitPoints = this.config.controlFlow.exitPoints.map(id => this.getCfgVertex(id)).filter(assert_1.isNotUndefined);
+        const exitNodes = exitPoints.map(vertex => (0, control_flow_graph_1.getVertexRootId)(vertex)).filter(assert_1.isNotUndefined);
+        const states = exitNodes.map(node => this.getAbstractState(node)).filter(assert_1.isNotUndefined);
+        return this.config.domain.bottom().joinAll(states);
+    }
+    /**
+     * Gets the inferred abstract trace mapping AST nodes to the inferred abstract state at the respective node.
+     * @returns The inferred abstract trace of the program
+     */
+    getAbstractTrace() {
+        return this.trace;
+    }
+    start() {
+        (0, assert_1.guard)(this.trace.size === 0, 'Abstract interpretation visitor has already been started');
+        super.start();
+        this.unassigned.clear();
+    }
+    visitNode(vertexId) {
+        const vertex = this.getCfgVertex(vertexId);
+        if (vertex === undefined) {
+            return true;
+        }
+        const nodeId = (0, control_flow_graph_1.getVertexRootId)(vertex);
+        if (this.isWideningPoint(nodeId)) {
+            // only check widening points at the entry vertex
+            if (vertex.type === control_flow_graph_1.CfgVertexType.EndMarker) {
+                return true;
+            }
+            const oldState = this.getAbstractState(nodeId) ?? this.config.domain.bottom();
+            const predecessorDomains = this.getPredecessorNodes(vertex.id).map(pred => this.getAbstractState(pred)).filter(assert_1.isNotUndefined);
+            this.currentState = this.config.domain.bottom().joinAll(predecessorDomains);
+            if (this.shouldWiden(vertex)) {
+                this.currentState = oldState.widen(this.currentState);
+            }
+            this.trace.set(nodeId, this.currentState);
+            return this.shouldContinueVisiting(vertex, oldState);
+        }
+        else if (this.shouldSkipVertex(vertex)) {
+            return true;
+        }
+        const predecessorDomains = this.getPredecessorNodes(vertex.id).map(pred => this.getAbstractState(pred)).filter(assert_1.isNotUndefined);
+        this.currentState = this.config.domain.bottom().joinAll(predecessorDomains);
+        this.onVisitNode(vertexId);
+        // discard the inferred abstract state when encountering functions with unknown side effects (e.g. `eval`)
+        if (this.config.dfg.unknownSideEffects.has(nodeId)) {
+            this.currentState = this.currentState.bottom();
+        }
+        this.trace.set(nodeId, this.currentState);
+        return true;
+    }
+    onVariableDefinition({ vertex }) {
+        if (this.getAbstractState(vertex.id) === undefined) {
+            this.unassigned.add(vertex.id);
+        }
+    }
+    onAssignmentCall({ target, source }) {
+        if (target === undefined || source === undefined) {
+            return;
+        }
+        const value = this.getAbstractValue(source);
+        this.unassigned.delete(target);
+        if (value !== undefined) {
+            this.currentState.set(target, value);
+            this.trace.set(target, this.currentState.create(this.currentState.value));
+        }
+    }
+    onReplacementCall({ call, target, source }) {
+        if (source === undefined || target === undefined) {
+            return;
+        }
+        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);
+    }
+    /** 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
+            .map(id => this.getCfgVertex(id))
+            .flatMap(vertex => {
+            if (vertex === undefined) {
+                return [];
+            }
+            else if (this.shouldSkipVertex(vertex)) {
+                return this.getPredecessorNodes(vertex.id);
+            }
+            else {
+                return [(0, control_flow_graph_1.getVertexRootId)(vertex)];
+            }
+        })
+            .toArray() ?? [];
+    }
+    /** Gets each variable origin that has already been visited and whose assignment has already been processed */
+    getVariableOrigins(nodeId) {
+        return (0, dfg_get_origin_1.getOriginInDfg)(this.config.dfg, nodeId)
+            ?.filter(origin => origin.type === 0 /* OriginType.ReadVariableOrigin */)
+            .map(origin => origin.id)
+            .filter(origin => this.trace.has(origin) && !this.unassigned.has(origin)) ?? [];
+    }
+    /** We only perform widening at `for`, `while`, or `repeat` loops with more than one incoming CFG edge */
+    isWideningPoint(nodeId) {
+        const incomingEdges = this.config.controlFlow.graph.outgoingEdges(nodeId)?.size; // outgoing dependency edges are incoming CFG edges
+        if (incomingEdges === undefined || incomingEdges <= 1) {
+            return false;
+        }
+        const node = this.getNormalizedAst(nodeId);
+        if (node?.type === type_1.RType.ForLoop || node?.type === type_1.RType.WhileLoop || node?.type === type_1.RType.RepeatLoop) {
+            return true;
+        }
+        const dataflowVertex = this.getDataflowGraph(nodeId);
+        if (dataflowVertex?.tag !== vertex_1.VertexType.FunctionCall || !Array.isArray(dataflowVertex.origin)) {
+            return false;
+        }
+        const origin = dataflowVertex.origin;
+        return origin.includes('builtin:for-loop') || origin.includes('builtin:while-loop') || origin.includes('builtin:repeat-loop');
+    }
+    /**
+     * Checks whether to continue visiting the control flow graph after a widening point.
+     * By default, we only continue visiting if the widening point is visited for the first time or the abstract state at the widening point changed.
+     */
+    shouldContinueVisiting(wideningPoint, oldState) {
+        const visitedCount = this.visited.get(wideningPoint.id) ?? 0;
+        this.visited.set(wideningPoint.id, visitedCount + 1);
+        return visitedCount === 0 || !oldState.equals(this.currentState);
+    }
+    /**
+     * Checks whether a control flow graph vertex should be skipped during visitation.
+     * By default, we only process vertices of leaf nodes and exit vertices (no entry nodes of complex nodes).
+     */
+    shouldSkipVertex(vertex) {
+        return vertex.type !== control_flow_graph_1.CfgVertexType.EndMarker && vertex.end !== undefined;
+    }
+    /**
+     * Whether widening should be performed at a widening point.
+     * By default, we perform widening when the number of visitation of the widening point reaches the widening threshold of the config.
+     */
+    shouldWiden(wideningPoint) {
+        return (this.visited.get(wideningPoint.id) ?? 0) >= this.config.ctx.config.abstractInterpretation.wideningThreshold;
+    }
+}
+exports.AbstractInterpretationVisitor = AbstractInterpretationVisitor;
+//# sourceMappingURL=absint-visitor.js.map

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

@@ -2,7 +2,6 @@ import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-i
 import type { AbstractDomainValue } from '../domains/abstract-domain';
 import { PosIntervalDomain } from '../domains/positive-interval-domain';
 import { ProductDomain } from '../domains/product-domain';
-import type { SetRangeLimit } from '../domains/set-range-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 */
@@ -17,7 +16,7 @@ export type DataFrameShapeProperty<Property extends keyof AbstractDataFrameShape
  * The data frame abstract domain as product domain of a column names domain, column count domain, and row count domain.
  */
 export declare class DataFrameDomain extends ProductDomain<AbstractDataFrameShape> {
-    constructor(value: AbstractDataFrameShape, maxColNames?: SetRangeLimit | number);
+    constructor(value: AbstractDataFrameShape);
     create(value: AbstractDataFrameShape): this;
     /**
      * The current abstract value of the column names domain.
@@ -33,6 +32,7 @@ export declare class DataFrameDomain extends ProductDomain<AbstractDataFrameShap
     get rows(): AbstractDataFrameShape['rows'];
     static bottom(maxColNames?: number): DataFrameDomain;
     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.

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataFrameStateDomain = 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");
@@ -9,15 +10,15 @@ 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.
  */
 class DataFrameDomain extends product_domain_1.ProductDomain {
-    constructor(value, maxColNames) {
-        super({
-            colnames: new set_range_domain_1.SetRangeDomain(value.colnames.value, maxColNames ?? value.colnames.limit),
-            cols: new positive_interval_domain_1.PosIntervalDomain(value.cols.value),
-            rows: new positive_interval_domain_1.PosIntervalDomain(value.rows.value)
-        });
+    constructor(value) {
+        super(DataFrameDomain.refine({
+            colnames: value.colnames.create(value.colnames.value),
+            cols: value.cols.create(value.cols.value),
+            rows: value.rows.create(value.rows.value)
+        }));
     }
     create(value) {
-        return new DataFrameDomain(value, this.colnames.limit);
+        return new DataFrameDomain(value);
     }
     /**
      * The current abstract value of the column names domain.
@@ -51,6 +52,21 @@ class DataFrameDomain extends product_domain_1.ProductDomain {
             rows: positive_interval_domain_1.PosIntervalDomain.top()
         });
     }
+    static refine(value) {
+        if (value.colnames.isValue() && value.cols.isValue()) {
+            if (value.colnames.value.range === lattice_1.Top && value.colnames.value.min.size >= value.cols.value[1]) {
+                value.colnames = value.colnames.meet({ min: new Set(), range: value.colnames.value.min });
+            }
+            if (value.colnames.isValue()) {
+                const minColNames = value.colnames.value.min.size;
+                const maxColNames = value.colnames.isFinite() ? value.colnames.value.min.size + value.colnames.value.range.size : Infinity;
+                if (minColNames > value.cols.value[0] || maxColNames < value.cols.value[1]) {
+                    value.cols = value.cols.meet([minColNames, maxColNames]);
+                }
+            }
+        }
+        return value;
+    }
 }
 exports.DataFrameDomain = DataFrameDomain;
 /**

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

@@ -1,17 +1,17 @@
 import type { DataflowGraph } from '../../../dataflow/graph/graph';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../../project/context/flowr-analyzer-context';
 import type { RNode } from '../../../r-bridge/lang-4.x/ast/model/model';
 import type { RAccess, RNamedAccess } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-access';
 import type { ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { DataFrameExpressionInfo } from '../absint-info';
-import type { ReadOnlyFlowrAnalyzerContext } from '../../../project/context/flowr-analyzer-context';
+import type { DataFrameOperations, DataFrameShapeInferenceVisitor } from '../shape-inference';
 /**
- * Maps a concrete data frame access to abstract data frame operations.
+ * Maps a concrete data frame access operation to abstract data frame operations.
  * @param node - The R node of the access
  * @param dfg  - The data flow graph for resolving the arguments
- * @param ctx  - The read-only Flowr analyzer context
- * @returns Data frame expression info containing the mapped abstract data frame operations, or `undefined` if the node does not represent a data frame access
+ * @param ctx  - The current flowR analyzer context
+ * @returns The mapped abstract data frame operations for the access operation, or `undefined` if the node does not represent a data frame access operation
  */
-export declare function mapDataFrameAccess(node: RNode<ParentInformation>, dfg: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext): DataFrameExpressionInfo | undefined;
+export declare function mapDataFrameAccess(node: RNode<ParentInformation>, inference: DataFrameShapeInferenceVisitor, dfg: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext): DataFrameOperations;
 /**
  * Checks whether an access node represents a string-based access (`$` or `@`), and no index-based access (`[` or `[[`).
  */