@eagleoutice/flowr 2.2.15 → 2.3.0

package/README.md

@@ -12,6 +12,226 @@ available for [VSCode](https://marketplace.visualstudio.com/items?itemName=code-
 and [Docker](https://hub.docker.com/r/eagleoutice/flowr).
 It offers a wide variety of features, for example:
 
+* 🐞 **code linting**\
+   Analyze your R scripts for common issues and potential bugs (see the [wiki page](https://github.com/flowr-analysis/flowr/wiki/Linter) for more information on the currently supported linters).
+
+	    
+    <details><summary style="">Example: Linting code with flowR</summary>
+    
+    To lint your code, you can use the [REPL](https://github.com/flowr-analysis/flowr/wiki/Interface#using-the-repl) or the [Visual Studio Code extension](https://marketplace.visualstudio.com/items?itemName=code-inspect.vscode-flowr) (see [vscode-flowr#283](https://github.com/flowr-analysis/vscode-flowr/pull/283)).
+    	
+    
+    
+    ```shell
+    $ docker run -it --rm eagleoutice/flowr # or npm run flowr 
+    flowR repl using flowR v2.2.16, R v4.5.0 (r-shell engine)
+    R> :query @linter "read.csv(\"/root/x.txt\")"
+    ```
+    
+    <details>
+    <summary style='color:gray'>Output</summary>
+    
+    
+    ```text
+    Query: linter (2 ms)
+       ╰ **Deprecated Functions** (deprecated-functions):
+           ╰ _Metadata_: <code>{"totalDeprecatedCalls":0,"totalDeprecatedFunctionDefinitions":0,"searchTimeMs":0,"processTimeMs":0}</code>
+       ╰ **File Path Validity** (file-path-validity):
+           ╰ definitely:
+               ╰ 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:
+               ╰ 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>
+       ╰ **Dataframe Access Validation** (dataframe-access-validation):
+           ╰ _Metadata_: <code>{"numOperations":0,"numAccesses":0,"totalAccessed":0,"searchTimeMs":0,"processTimeMs":0}</code>
+    All queries together required ≈2 ms (1ms accuracy, total 7 ms)
+    ```
+    
+    
+    
+    The linter will analyze the code and return any issues found.
+    Formatted more nicely, this returns:
+    
+    
+    
+    
+    ```json
+    [ { "type": "linter" } ]
+    ```
+    
+    
+    (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** (12 ms)\
+    &nbsp;&nbsp;&nbsp;╰ **Deprecated Functions** (deprecated-functions):\
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"totalDeprecatedCalls":0,"totalDeprecatedFunctionDefinitions":0,"searchTimeMs":1,"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;&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":3,"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":1,"processTimeMs":0}</code>\
+    &nbsp;&nbsp;&nbsp;╰ **Absolute Paths** (absolute-file-paths):\
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ definitely:\
+    &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":2,"processTimeMs":0}</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>\
+    &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":3}</code>\
+    _All queries together required ≈13 ms (1ms accuracy, total 207 ms)_
+    
+    <details> <summary style="color:gray">Show Detailed Results as Json</summary>
+    
+    The analysis required _207.2 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.
+    
+    
+    
+    
+    ```json
+    {
+      "linter": {
+        "results": {
+          "deprecated-functions": {
+            "results": [],
+            ".meta": {
+              "totalDeprecatedCalls": 0,
+              "totalDeprecatedFunctionDefinitions": 0,
+              "searchTimeMs": 1,
+              "processTimeMs": 0
+            }
+          },
+          "file-path-validity": {
+            "results": [
+              {
+                "range": [
+                  1,
+                  1,
+                  1,
+                  23
+                ],
+                "filePath": "/root/x.txt",
+                "certainty": "definitely"
+              }
+            ],
+            ".meta": {
+              "totalReads": 1,
+              "totalUnknown": 0,
+              "totalWritesBeforeAlways": 0,
+              "totalValid": 0,
+              "searchTimeMs": 3,
+              "processTimeMs": 1
+            }
+          },
+          "seeded-randomness": {
+            "results": [],
+            ".meta": {
+              "consumerCalls": 0,
+              "callsWithFunctionProducers": 0,
+              "callsWithAssignmentProducers": 0,
+              "callsWithNonConstantProducers": 0,
+              "searchTimeMs": 1,
+              "processTimeMs": 0
+            }
+          },
+          "absolute-file-paths": {
+            "results": [
+              {
+                "certainty": "definitely",
+                "filePath": "/root/x.txt",
+                "range": [
+                  1,
+                  1,
+                  1,
+                  23
+                ]
+              }
+            ],
+            ".meta": {
+              "totalConsidered": 1,
+              "totalUnknown": 0,
+              "searchTimeMs": 2,
+              "processTimeMs": 0
+            }
+          },
+          "unused-definitions": {
+            "results": [],
+            ".meta": {
+              "totalConsidered": 0,
+              "searchTimeMs": 0,
+              "processTimeMs": 0
+            }
+          },
+          "naming-convention": {
+            "results": [],
+            ".meta": {
+              "numMatches": 0,
+              "numBreak": 0,
+              "searchTimeMs": 0,
+              "processTimeMs": 0
+            }
+          },
+          "dataframe-access-validation": {
+            "results": [],
+            ".meta": {
+              "numOperations": 0,
+              "numAccesses": 0,
+              "totalAccessed": 0,
+              "searchTimeMs": 0,
+              "processTimeMs": 3
+            }
+          }
+        },
+        ".meta": {
+          "timing": 12
+        }
+      },
+      ".meta": {
+        "timing": 13
+      }
+    }
+    ```
+    
+    
+    
+    </details>
+    
+    
+    
+    
+    
+    
+    
+    	
+    		
+    
+    </details>
+    
+    
+    	   
+    	   
+    
+    </details>
+        
+
+
 * 🍕 **program slicing**\
    Given a point of interest like the visualization of a plot, _flowR_ reduces the program to just the parts which are relevant
    for the computation of the point of interest.
@@ -51,7 +271,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.14, R v4.4.3 (r-shell engine)
+    flowR repl using flowR v2.2.16, R v4.5.0 (r-shell engine)
     R> :slicer test/testfiles/example.R --criterion "11@sum"
     ```
     
@@ -98,7 +318,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!">133.8 ms</span></i> (as of May 31, 2025), 
+  Within just <i><span title="This measurement is automatically fetched from the latest benchmark!">136.1 ms</span></i> (as of Jul 12, 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.
 
@@ -134,7 +354,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.14, R v4.4.3 (r-shell engine)
+    flowR repl using flowR v2.2.16, R v4.5.0 (r-shell engine)
     R> :dataflow* test/testfiles/example.R
     ```
     
@@ -411,7 +631,7 @@ It offers a wide variety of features, for example:
         linkStyle 68 stroke:gray;
         35 -->|"CD-True"| 36
         linkStyle 69 stroke:gray,color:gray;
-        36 -->|"reads, argument"| 12
+        36 -->|"argument"| 12
         36 -->|"reads, argument"| 20
         36 -->|"argument, non-standard-evaluation"| 35
         36 -.->|"reads, calls"| built-in:for
@@ -435,7 +655,7 @@ It offers a wide variety of features, for example:
     ```
     
     	
-    (The analysis required _22.8 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.)
     
     
     
@@ -478,7 +698,7 @@ You can enter <span title="Description (Repl Command): Show help information (al
 
 <summary>Example REPL session</summary>
 
-![Example of a simple REPL session](wiki/gif/repl-demo.gif)
+![Example of a simple REPL session](wiki/gif/repl-demo-opt.gif)
 
 </details>
 

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,59 @@
+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 processOperation;
+    private processDataFrameAssignment;
+    private processDataFrameExpression;
+    /** 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,173 @@
+"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 mid markers or 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 visitor 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.processOperation(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.processOperation(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.processOperation(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.processOperation(node);
+            this.clearUnassignedInfo(targetNode);
+        }
+    }
+    processOperation(node) {
+        if ((0, absint_info_1.hasDataFrameAssignmentInfo)(node)) {
+            this.processDataFrameAssignment(node);
+        }
+        else if ((0, absint_info_1.hasDataFrameExpressionInfo)(node)) {
+            this.processDataFrameExpression(node);
+        }
+    }
+    processDataFrameAssignment(node) {
+        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);
+            }
+        }
+    }
+    processDataFrameExpression(node) {
+        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.applySemantics)(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