@eagleoutice/flowr 2.2.16 → 2.4.0

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.2.15, R v4.5.0 (r-shell engine)
+    flowR repl using flowR v2.3.0, R v4.5.0 (r-shell engine)
     R> :query @linter "read.csv(\"/root/x.txt\")"
     ```
     
@@ -33,24 +33,28 @@ It offers a wide variety of features, for example:
     
     
     ```text
-    Query: linter (2 ms)
+    Query: linter (3 ms)
        ╰ **Deprecated Functions** (deprecated-functions):
            ╰ _Metadata_: <code>{"totalDeprecatedCalls":0,"totalDeprecatedFunctionDefinitions":0,"searchTimeMs":0,"processTimeMs":0}</code>
        ╰ **File Path Validity** (file-path-validity):
-           ╰ definitely:
+           ╰ certain:
                ╰ Path `/root/x.txt` at 1.1-23
            ╰ _Metadata_: <code>{"totalReads":1,"totalUnknown":0,"totalWritesBeforeAlways":0,"totalValid":0,"searchTimeMs":1,"processTimeMs":0}</code>
        ╰ **Seeded Randomness** (seeded-randomness):
            ╰ _Metadata_: <code>{"consumerCalls":0,"callsWithFunctionProducers":0,"callsWithAssignmentProducers":0,"callsWithNonConstantProducers":0,"searchTimeMs":0,"processTimeMs":0}</code>
        ╰ **Absolute Paths** (absolute-file-paths):
-           ╰ definitely:
+           ╰ certain:
                ╰ Path `/root/x.txt` at 1.1-23
            ╰ _Metadata_: <code>{"totalConsidered":1,"totalUnknown":0,"searchTimeMs":1,"processTimeMs":0}</code>
        ╰ **Unused Definitions** (unused-definitions):
            ╰ _Metadata_: <code>{"totalConsidered":0,"searchTimeMs":0,"processTimeMs":0}</code>
        ╰ **Naming Convention** (naming-convention):
            ╰ _Metadata_: <code>{"numMatches":0,"numBreak":0,"searchTimeMs":0,"processTimeMs":0}</code>
-    All queries together required ≈2 ms (1ms accuracy, total 7 ms)
+       ╰ **Dataframe Access Validation** (dataframe-access-validation):
+           ╰ _Metadata_: <code>{"numOperations":0,"numAccesses":0,"totalAccessed":0,"searchTimeMs":0,"processTimeMs":0}</code>
+       ╰ **Dead Code** (dead-code):
+           ╰ _Metadata_: <code>{"consideredNodes":5,"searchTimeMs":1,"processTimeMs":0}</code>
+    All queries together required ≈3 ms (1ms accuracy, total 9 ms)
     ```
     
     
@@ -66,32 +70,38 @@ It offers a wide variety of features, for example:
     ```
     
     
+    (This query can be shortened to `@linter` when used within the REPL command <span title="Description (Repl Command): Query the given R code, start with 'file://' to indicate a file. The query is to be a valid query in json format (use 'help' to get more information).">`:query`</span>).
+    
     
     
     _Results (prettified and summarized):_
     
-    Query: **linter** (10 ms)\
+    Query: **linter** (14 ms)\
     &nbsp;&nbsp;&nbsp;╰ **Deprecated Functions** (deprecated-functions):\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"totalDeprecatedCalls":0,"totalDeprecatedFunctionDefinitions":0,"searchTimeMs":2,"processTimeMs":0}</code>\
     &nbsp;&nbsp;&nbsp;╰ **File Path Validity** (file-path-validity):\
-    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ definitely:\
+    &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>{"totalReads":1,"totalUnknown":0,"totalWritesBeforeAlways":0,"totalValid":0,"searchTimeMs":4,"processTimeMs":1}</code>\
     &nbsp;&nbsp;&nbsp;╰ **Seeded Randomness** (seeded-randomness):\
-    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"consumerCalls":0,"callsWithFunctionProducers":0,"callsWithAssignmentProducers":0,"callsWithNonConstantProducers":0,"searchTimeMs":0,"processTimeMs":0}</code>\
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"consumerCalls":0,"callsWithFunctionProducers":0,"callsWithAssignmentProducers":0,"callsWithNonConstantProducers":0,"searchTimeMs":0,"processTimeMs":1}</code>\
     &nbsp;&nbsp;&nbsp;╰ **Absolute Paths** (absolute-file-paths):\
-    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ definitely:\
+    &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":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):\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"numMatches":0,"numBreak":0,"searchTimeMs":0,"processTimeMs":0}</code>\
-    _All queries together required ≈10 ms (1ms accuracy, total 208 ms)_
+    &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":2}</code>\
+    &nbsp;&nbsp;&nbsp;╰ **Dead Code** (dead-code):\
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"consideredNodes":5,"searchTimeMs":0,"processTimeMs":0}</code>\
+    _All queries together required ≈14 ms (1ms accuracy, total 214 ms)_
     
     <details> <summary style="color:gray">Show Detailed Results as Json</summary>
     
-    The analysis required _207.6 ms_ (including parsing and normalization and the query) within the generation environment.	
+    The analysis required _213.8 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.
@@ -122,7 +132,7 @@ It offers a wide variety of features, for example:
                   23
                 ],
                 "filePath": "/root/x.txt",
-                "certainty": "definitely"
+                "certainty": "certain"
               }
             ],
             ".meta": {
@@ -142,13 +152,13 @@ It offers a wide variety of features, for example:
               "callsWithAssignmentProducers": 0,
               "callsWithNonConstantProducers": 0,
               "searchTimeMs": 0,
-              "processTimeMs": 0
+              "processTimeMs": 1
             }
           },
           "absolute-file-paths": {
             "results": [
               {
-                "certainty": "definitely",
+                "certainty": "certain",
                 "filePath": "/root/x.txt",
                 "range": [
                   1,
@@ -181,14 +191,32 @@ It offers a wide variety of features, for example:
               "searchTimeMs": 0,
               "processTimeMs": 0
             }
+          },
+          "dataframe-access-validation": {
+            "results": [],
+            ".meta": {
+              "numOperations": 0,
+              "numAccesses": 0,
+              "totalAccessed": 0,
+              "searchTimeMs": 0,
+              "processTimeMs": 2
+            }
+          },
+          "dead-code": {
+            "results": [],
+            ".meta": {
+              "consideredNodes": 5,
+              "searchTimeMs": 0,
+              "processTimeMs": 0
+            }
           }
         },
         ".meta": {
-          "timing": 10
+          "timing": 14
         }
       },
       ".meta": {
-        "timing": 10
+        "timing": 14
       }
     }
     ```
@@ -255,7 +283,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.2.15, R v4.5.0 (r-shell engine)
+    flowR repl using flowR v2.3.0, R v4.5.0 (r-shell engine)
     R> :slicer test/testfiles/example.R --criterion "11@sum"
     ```
     
@@ -302,7 +330,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!">136.2 ms</span></i> (as of Jun 2, 2025), 
+  Within just <i><span title="This measurement is automatically fetched from the latest benchmark!">136.8 ms</span></i> (as of Jul 21, 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.
 
@@ -338,7 +366,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.2.15, R v4.5.0 (r-shell engine)
+    flowR repl using flowR v2.3.0, R v4.5.0 (r-shell engine)
     R> :dataflow* test/testfiles/example.R
     ```
     
@@ -639,7 +667,7 @@ It offers a wide variety of features, for example:
     ```
     
     	
-    (The analysis required _13.9 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment.)
+    (The analysis required _13.8 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment.)
     
     
     

package/abstract-interpretation/data-frame/absint-info.d.ts

@@ -0,0 +1,109 @@
+import type { RNode } from '../../r-bridge/lang-4.x/ast/model/model';
+import type { 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 { DataFrameStateDomain } from './domain';
+import type { ConstraintType, DataFrameOperationArgs, DataFrameOperationName, DataFrameOperationOptions } from './semantics';
+/**
+ * An abstract data frame operation without additional options.
+ * - `operation` contains the type of the abstract operation (see {@link DataFrameOperationName})
+ * - `operand` contains the ID of the data frame operand of the operation (may be `undefined`)
+ * - `...args` contains the arguments of the abstract operation (see {@link DataFrameOperationArgs})
+ */
+export type DataFrameOperationType<OperationName extends DataFrameOperationName = DataFrameOperationName> = {
+    [Name in OperationName]: {
+        operation: Name;
+        operand: NodeId | undefined;
+    } & DataFrameOperationArgs<Name>;
+}[OperationName];
+/**
+ * An abstract data frame operation.
+ * - `operation` contains the type of the abstract operation (see {@link DataFrameOperationName})
+ * - `operand` contains the ID of the data frame operand of the operation (may be `undefined`)
+ * - `type` optionally contains the constraint type to overwrite the default type of the operation (see {@link ConstraintType})
+ * - `options` optionally contains additional options for the abstract operation (see {@link DataFrameOperationOptions})
+ * - `...args` contains the arguments of the abstract operation (see {@link DataFrameOperationArgs})
+ */
+export type DataFrameOperation<OperationName extends DataFrameOperationName = DataFrameOperationName> = {
+    [Name in OperationName]: {
+        operation: Name;
+        operand: NodeId | undefined;
+        type?: ConstraintType;
+        options?: DataFrameOperationOptions<Name>;
+    } & DataFrameOperationArgs<Name>;
+}[OperationName];
+/**
+ * Represents the base data frame information stored in the abstract interpretation info of an AST node.
+ * - `type` optionally defines the type of the extra information stored in the data frame info
+ * - `domain` contains the abstract data frame shape state of the node
+ *   This may not be present if the data frame shape inference has not been executed yet or the program contains no data frames
+ */
+interface DataFrameInfoBase {
+    type?: string;
+    domain?: DataFrameStateDomain;
+}
+/** Enum to mark nodes during the data frame shape inference */
+export declare enum DataFrameInfoMarker {
+    /** Marks the target symbol of assignments as "unassigned" until the assigned expression is evaluated */
+    Unassigned = "unassigned"
+}
+/**
+ * Represents the data frame information for a node without extra data frame information,
+ * i.e. for all nodes that do not represent a data frame assignment or data frame operation (this is the default).
+ *
+ * The `marker` can be used to mark nodes during the data frame shape inference.
+ */
+interface DataFrameEmptyInfo extends DataFrameInfoBase {
+    type?: never;
+    marker?: DataFrameInfoMarker;
+}
+/**
+ * Represents the data frame information for a data frame assignment with a target identifier (symbol/string) and an assigned expression.
+ * This is used during data frame shape inference to mark assignments of data frame expressions to an identifier.
+ *
+ * Use {@link hasDataFrameAssignmentInfo} to check whether an AST node has attached data frame assignment information.
+ */
+export interface DataFrameAssignmentInfo extends DataFrameInfoBase {
+    type: 'assignment';
+    identifier: NodeId;
+    expression: NodeId;
+}
+/**
+ * Represents the data frame information for a data frame function/operation with mapped abstract operations.
+ * This is used during data frame shape inference to store the abstract operations a data frame function/operation is mapped to.
+ *
+ * The order of the abstract operations is the order in which their semantics are applied (for example, access operations are typically before other operations in the list).
+ * Moreover, abstract operations that take the result of previous abstract operation as data frame operand must have the `operand` set to `undefined`.
+ *
+ * Use {@link hasDataFrameExpressionInfo} to check whether an AST node has attached data frame expression information.
+ */
+export interface DataFrameExpressionInfo extends DataFrameInfoBase {
+    type: 'expression';
+    operations: DataFrameOperation[];
+}
+/**
+ * Represents the data frame shape inference information stored in the abstract interpretation info of AST nodes.
+ */
+export type DataFrameInfo = DataFrameEmptyInfo | DataFrameAssignmentInfo | DataFrameExpressionInfo;
+/**
+ * Represents the abstract interpretation information attached to AST nodes.
+ */
+export interface AbstractInterpretationInfo {
+    dataFrame?: DataFrameInfo;
+}
+/**
+ * Checks whether an AST node has attached data frame assignment information.
+ */
+export declare function hasDataFrameAssignmentInfo<OtherInfo>(node: RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo>): node is RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo & {
+    dataFrame: DataFrameAssignmentInfo;
+}>;
+/**
+ * Checks whether an AST node has attached data frame expression information.
+ */
+export declare function hasDataFrameExpressionInfo<OtherInfo>(node: RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo>): node is RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo & {
+    dataFrame: DataFrameExpressionInfo;
+}>;
+/**
+ * Checks whether an AST node has an attached data frame info marker.
+ */
+export declare function hasDataFrameInfoMarker<OtherInfo>(node: RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo>, marker: DataFrameInfoMarker): boolean;
+export {};

package/abstract-interpretation/data-frame/absint-info.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataFrameInfoMarker = void 0;
+exports.hasDataFrameAssignmentInfo = hasDataFrameAssignmentInfo;
+exports.hasDataFrameExpressionInfo = hasDataFrameExpressionInfo;
+exports.hasDataFrameInfoMarker = hasDataFrameInfoMarker;
+/** Enum to mark nodes during the data frame shape inference */
+var DataFrameInfoMarker;
+(function (DataFrameInfoMarker) {
+    /** Marks the target symbol of assignments as "unassigned" until the assigned expression is evaluated */
+    DataFrameInfoMarker["Unassigned"] = "unassigned";
+})(DataFrameInfoMarker || (exports.DataFrameInfoMarker = DataFrameInfoMarker = {}));
+/**
+ * Checks whether an AST node has attached data frame assignment information.
+ */
+function hasDataFrameAssignmentInfo(node) {
+    return node.info.dataFrame?.type === 'assignment';
+}
+/**
+ * Checks whether an AST node has attached data frame expression information.
+ */
+function hasDataFrameExpressionInfo(node) {
+    return node.info.dataFrame?.type === 'expression';
+}
+/**
+ * Checks whether an AST node has an attached data frame info marker.
+ */
+function hasDataFrameInfoMarker(node, marker) {
+    return node.info.dataFrame?.type === undefined && node.info.dataFrame?.marker === marker;
+}
+//# sourceMappingURL=absint-info.js.map

package/abstract-interpretation/data-frame/absint-visitor.d.ts

@@ -0,0 +1,58 @@
+import type { CfgBasicBlockVertex, 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, DataflowGraphVertexVariableDefinition } from '../../dataflow/graph/vertex';
+import type { NoInfo } from '../../r-bridge/lang-4.x/ast/model/model';
+import type { NormalizedAst } 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 AbstractInterpretationInfo } from './absint-info';
+export type DataFrameShapeInferenceVisitorConfiguration<OtherInfo = NoInfo, ControlFlow extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo & AbstractInterpretationInfo> = NormalizedAst<OtherInfo & AbstractInterpretationInfo>, Dfg extends DataflowGraph = DataflowGraph> = Omit<SemanticCfgGuidedVisitorConfiguration<OtherInfo & AbstractInterpretationInfo, ControlFlow, Ast, Dfg>, 'defaultVisitingOrder' | 'defaultVisitingType'>;
+/**
+ * The control flow graph visitor to infer the shape of data frames using abstract interpretation
+ */
+export declare class DataFrameShapeInferenceVisitor<OtherInfo = NoInfo, ControlFlow extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo & AbstractInterpretationInfo> = NormalizedAst<OtherInfo & AbstractInterpretationInfo>, Dfg extends DataflowGraph = DataflowGraph, Config extends DataFrameShapeInferenceVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dfg> = DataFrameShapeInferenceVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dfg>> extends SemanticCfgGuidedVisitor<OtherInfo & AbstractInterpretationInfo, ControlFlow, Ast, Dfg, Config & {
+    defaultVisitingOrder: 'forward';
+    defaultVisitingType: 'exit';
+}> {
+    /**
+     * The old domain of an AST node before processing the node retrieved from the attached {@link AbstractInterpretationInfo}.
+     * This is used to check whether the state has changed and successors should be visited again, and is also required for widening.
+     */
+    private oldDomain;
+    /**
+     * The new domain of an AST node during and after processing the node.
+     * This information is stored in the {@link AbstractInterpretationInfo} afterwards.
+     */
+    private newDomain;
+    constructor(config: Config);
+    protected visitNode(nodeId: NodeId): boolean;
+    protected visitDataflowNode(vertex: Exclude<CfgSimpleVertex, CfgBasicBlockVertex>): void;
+    protected onVariableDefinition({ vertex }: {
+        vertex: DataflowGraphVertexVariableDefinition;
+    }): void;
+    protected onAssignmentCall({ call, target, source }: {
+        call: DataflowGraphVertexFunctionCall;
+        target?: NodeId;
+        source?: NodeId;
+    }): void;
+    protected onAccessCall({ call }: {
+        call: DataflowGraphVertexFunctionCall;
+    }): void;
+    protected onDefaultFunctionCall({ call }: {
+        call: DataflowGraphVertexFunctionCall;
+    }): void;
+    protected onReplacementCall({ call, source, target }: {
+        call: DataflowGraphVertexFunctionCall;
+        source: NodeId | undefined;
+        target: NodeId | undefined;
+    }): void;
+    private applyDataFrameAssignment;
+    private applyDataFrameExpression;
+    /** We only process vertices of leaf nodes and exit vertices (no entry nodes of complex nodes) */
+    private shouldSkipVertex;
+    /** Get all AST nodes for the predecessor vertices that are leaf nodes and exit vertices */
+    private getPredecessorNodes;
+    private shouldWiden;
+    private clearUnassignedInfo;
+}

package/abstract-interpretation/data-frame/absint-visitor.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataFrameShapeInferenceVisitor = 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 assert_1 = require("../../util/assert");
+const absint_info_1 = require("./absint-info");
+const domain_1 = require("./domain");
+const access_mapper_1 = require("./mappers/access-mapper");
+const assignment_mapper_1 = require("./mappers/assignment-mapper");
+const function_mapper_1 = require("./mappers/function-mapper");
+const replacement_mapper_1 = require("./mappers/replacement-mapper");
+const semantics_1 = require("./semantics");
+const shape_inference_1 = require("./shape-inference");
+/**
+ * The control flow graph visitor to infer the shape of data frames using abstract interpretation
+ */
+class DataFrameShapeInferenceVisitor extends semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor {
+    /**
+     * The old domain of an AST node before processing the node retrieved from the attached {@link AbstractInterpretationInfo}.
+     * This is used to check whether the state has changed and successors should be visited again, and is also required for widening.
+     */
+    oldDomain = new Map();
+    /**
+     * The new domain of an AST node during and after processing the node.
+     * This information is stored in the {@link AbstractInterpretationInfo} afterwards.
+     */
+    newDomain = new Map();
+    constructor(config) {
+        super({ ...config, defaultVisitingOrder: 'forward', defaultVisitingType: 'exit' });
+    }
+    visitNode(nodeId) {
+        const vertex = this.getCfgVertex(nodeId);
+        // skip vertices representing entries of complex nodes
+        if (vertex === undefined || this.shouldSkipVertex(vertex)) {
+            return true;
+        }
+        const predecessors = this.getPredecessorNodes(vertex.id);
+        this.newDomain = (0, domain_1.joinDataFrameStates)(...predecessors.map(node => node.info.dataFrame?.domain ?? new Map()));
+        this.onVisitNode(nodeId);
+        const visitedCount = this.visited.get(vertex.id) ?? 0;
+        this.visited.set(vertex.id, visitedCount + 1);
+        // only continue visiting if the node has not been visited before or the data frame value of the node changed
+        return visitedCount === 0 || !(0, domain_1.equalDataFrameState)(this.oldDomain, this.newDomain);
+    }
+    visitDataflowNode(vertex) {
+        const node = this.getNormalizedAst((0, control_flow_graph_1.getVertexRootId)(vertex));
+        if (node === undefined) {
+            return;
+        }
+        this.oldDomain = node.info.dataFrame?.domain ?? new Map();
+        super.visitDataflowNode(vertex);
+        if (this.shouldWiden(vertex)) {
+            this.newDomain = (0, domain_1.wideningDataFrameStates)(this.oldDomain, this.newDomain);
+        }
+        node.info.dataFrame ??= {};
+        node.info.dataFrame.domain = this.newDomain;
+    }
+    onVariableDefinition({ vertex }) {
+        const node = this.getNormalizedAst(vertex.id);
+        if (node !== undefined) {
+            // mark variable definitions as "unassigned", as the evaluation of the assigned expression is delayed until processing the assignment
+            node.info.dataFrame ??= { marker: absint_info_1.DataFrameInfoMarker.Unassigned };
+        }
+    }
+    onAssignmentCall({ call, target, source }) {
+        const node = this.getNormalizedAst(call.id);
+        const targetNode = this.getNormalizedAst(target);
+        const sourceNode = this.getNormalizedAst(source);
+        if (node !== undefined && (0, assignment_mapper_1.isAssignmentTarget)(targetNode) && sourceNode !== undefined) {
+            node.info.dataFrame = (0, assignment_mapper_1.mapDataFrameVariableAssignment)(targetNode, sourceNode, this.config.dfg);
+            this.applyDataFrameAssignment(node);
+            this.clearUnassignedInfo(targetNode);
+        }
+    }
+    onAccessCall({ call }) {
+        const node = this.getNormalizedAst(call.id);
+        if (node !== undefined) {
+            node.info.dataFrame = (0, access_mapper_1.mapDataFrameAccess)(node, this.config.dfg);
+            this.applyDataFrameExpression(node);
+        }
+    }
+    onDefaultFunctionCall({ call }) {
+        const node = this.getNormalizedAst(call.id);
+        if (node !== undefined) {
+            node.info.dataFrame = (0, function_mapper_1.mapDataFrameFunctionCall)(node, this.config.dfg, this.config.flowrConfig);
+            this.applyDataFrameExpression(node);
+        }
+    }
+    onReplacementCall({ call, source, target }) {
+        const node = this.getNormalizedAst(call.id);
+        const targetNode = this.getNormalizedAst(target);
+        const sourceNode = this.getNormalizedAst(source);
+        if (node !== undefined && targetNode !== undefined && sourceNode !== undefined) {
+            node.info.dataFrame = (0, replacement_mapper_1.mapDataFrameReplacementFunction)(node, sourceNode, this.config.dfg);
+            this.applyDataFrameExpression(node);
+            this.clearUnassignedInfo(targetNode);
+        }
+    }
+    applyDataFrameAssignment(node) {
+        if (!(0, absint_info_1.hasDataFrameAssignmentInfo)(node)) {
+            return;
+        }
+        const value = (0, shape_inference_1.resolveIdToDataFrameShape)(node.info.dataFrame.expression, this.config.dfg, this.newDomain);
+        if (value !== undefined) {
+            this.newDomain.set(node.info.dataFrame.identifier, value);
+            const identifier = this.getNormalizedAst(node.info.dataFrame.identifier);
+            if (identifier !== undefined) {
+                identifier.info.dataFrame ??= {};
+                identifier.info.dataFrame.domain = new Map(this.newDomain);
+            }
+        }
+    }
+    applyDataFrameExpression(node) {
+        if (!(0, absint_info_1.hasDataFrameExpressionInfo)(node)) {
+            return;
+        }
+        let value = domain_1.DataFrameTop;
+        for (const { operation, operand, type, options, ...args } of node.info.dataFrame.operations) {
+            const operandValue = operand !== undefined ? (0, shape_inference_1.resolveIdToDataFrameShape)(operand, this.config.dfg, this.newDomain) : value;
+            value = (0, semantics_1.applyDataFrameSemantics)(operation, operandValue ?? domain_1.DataFrameTop, args, options);
+            const constraintType = type ?? (0, semantics_1.getConstraintType)(operation);
+            if (operand !== undefined && constraintType === semantics_1.ConstraintType.OperandModification) {
+                this.newDomain.set(operand, value);
+                for (const origin of (0, shape_inference_1.getVariableOrigins)(operand, this.config.dfg)) {
+                    this.newDomain.set(origin.info.id, value);
+                }
+            }
+            else if (constraintType === semantics_1.ConstraintType.ResultPostcondition) {
+                this.newDomain.set(node.info.id, value);
+            }
+        }
+    }
+    /** We only process vertices of leaf nodes and exit vertices (no entry nodes of complex nodes) */
+    shouldSkipVertex(vertex) {
+        return (0, control_flow_graph_1.isMarkerVertex)(vertex) ? vertex.type !== control_flow_graph_1.CfgVertexType.EndMarker : vertex.end !== undefined;
+    }
+    /** Get 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 [this.getNormalizedAst((0, control_flow_graph_1.getVertexRootId)(vertex))];
+            }
+        })
+            .filter(assert_1.isNotUndefined)
+            .toArray() ?? [];
+    }
+    shouldWiden(vertex) {
+        return (this.visited.get(vertex.id) ?? 0) >= this.config.flowrConfig.abstractInterpretation.dataFrame.wideningThreshold;
+    }
+    clearUnassignedInfo(node) {
+        if ((0, absint_info_1.hasDataFrameInfoMarker)(node, absint_info_1.DataFrameInfoMarker.Unassigned)) {
+            if (node.info.dataFrame?.domain !== undefined) {
+                node.info.dataFrame = { domain: node.info.dataFrame.domain };
+            }
+            else {
+                delete node.info.dataFrame;
+            }
+        }
+    }
+}
+exports.DataFrameShapeInferenceVisitor = DataFrameShapeInferenceVisitor;
+//# sourceMappingURL=absint-visitor.js.map