@eagleoutice/flowr 2.2.16 → 2.3.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.2.16, R v4.5.0 (r-shell engine)
     R> :query @linter "read.csv(\"/root/x.txt\")"
     ```
     
@@ -50,6 +50,8 @@ It offers a wide variety of features, for example:
            ╰ _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)
     ```
     
@@ -66,32 +68,36 @@ 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** (12 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;&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":4,"processTimeMs":1}</code>\
+    &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":0,"processTimeMs":0}</code>\
+    &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":1,"processTimeMs":1}</code>\
+    &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>\
-    _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":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.6 ms_ (including parsing and normalization and the query) within the generation environment.	
+    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.
@@ -108,7 +114,7 @@ It offers a wide variety of features, for example:
             ".meta": {
               "totalDeprecatedCalls": 0,
               "totalDeprecatedFunctionDefinitions": 0,
-              "searchTimeMs": 2,
+              "searchTimeMs": 1,
               "processTimeMs": 0
             }
           },
@@ -130,7 +136,7 @@ It offers a wide variety of features, for example:
               "totalUnknown": 0,
               "totalWritesBeforeAlways": 0,
               "totalValid": 0,
-              "searchTimeMs": 4,
+              "searchTimeMs": 3,
               "processTimeMs": 1
             }
           },
@@ -141,7 +147,7 @@ It offers a wide variety of features, for example:
               "callsWithFunctionProducers": 0,
               "callsWithAssignmentProducers": 0,
               "callsWithNonConstantProducers": 0,
-              "searchTimeMs": 0,
+              "searchTimeMs": 1,
               "processTimeMs": 0
             }
           },
@@ -161,8 +167,8 @@ It offers a wide variety of features, for example:
             ".meta": {
               "totalConsidered": 1,
               "totalUnknown": 0,
-              "searchTimeMs": 1,
-              "processTimeMs": 1
+              "searchTimeMs": 2,
+              "processTimeMs": 0
             }
           },
           "unused-definitions": {
@@ -181,14 +187,24 @@ 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": 3
+            }
           }
         },
         ".meta": {
-          "timing": 10
+          "timing": 12
         }
       },
       ".meta": {
-        "timing": 10
+        "timing": 13
       }
     }
     ```
@@ -255,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.15, R v4.5.0 (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"
     ```
     
@@ -302,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!">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.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.
 
@@ -338,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.15, R v4.5.0 (r-shell engine)
+    flowR repl using flowR v2.2.16, R v4.5.0 (r-shell engine)
     R> :dataflow* test/testfiles/example.R
     ```
     
@@ -639,7 +655,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,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

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

@@ -0,0 +1,107 @@
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+type Interval = [number, number];
+/** The bottom element (least element) of the positive interval domain representing no possible values, explicitly given as "bottom". */
+export declare const IntervalBottom = "bottom";
+/** The top element (greatest element) of the positive interval domain representing all possible values, defined as the interval from 0 to infinity. */
+export declare const IntervalTop: [0, number];
+/** The positive interval domain representing possible integer values. */
+export type IntervalDomain = Interval | typeof IntervalBottom;
+/** The bottom element (least element) of the column names domain representing no possible column name, defined as the empty list []. */
+export declare const ColNamesBottom: [];
+/** The top element (greatest element) of the column names domain representing all possible values, explicitly given as "top". */
+export declare const ColNamesTop = "top";
+/** The column names domain defined as bounded string set domain representing possible column names. */
+export type ColNamesDomain = string[] | typeof ColNamesTop;
+/**
+ * The data frame shape domain representing possible data frame shapes, defined as product domain of
+ * the {@link ColNamesDomain} for the columns names and {@link IntervalDomain} for the number of columns and rows.
+ * */
+export interface DataFrameDomain {
+    colnames: ColNamesDomain;
+    cols: IntervalDomain;
+    rows: IntervalDomain;
+}
+/**
+ * The bottom element (least element) of the data frame shape domain representing no possible value, mapping the columns names to {@link ColNamesBottom}
+ * and the number of columns and rows to {@link IntervalBottom}.
+ */
+export declare const DataFrameBottom: {
+    readonly colnames: [];
+    readonly cols: "bottom";
+    readonly rows: "bottom";
+};
+/**
+ * The top element (greatest element) of the data frame shape domain representing all possible value, mapping the columns names to {@link ColNamesTop}
+ * and the number of columns and rows to {@link IntervalTop}.
+ */
+export declare const DataFrameTop: {
+    readonly colnames: "top";
+    readonly cols: [0, number];
+    readonly rows: [0, number];
+};
+/**
+ * The data frame shape state domain representing possible memory states, mapping AST node IDs to data frame shape values of the {@link DataFrameDomain}.
+ */
+export type DataFrameStateDomain = Map<NodeId, DataFrameDomain>;
+/** Checks if two abstract values of the column names domain are equal. */
+export declare function equalColNames(set1: ColNamesDomain, set2: ColNamesDomain): boolean;
+/** Checks if two abstract values of the column names domain are ordered according to the partial ordering of the column names lattice. */
+export declare function leqColNames(set1: ColNamesDomain, set2: ColNamesDomain): boolean;
+/** Joins two abstract values of the columns names domain according to the column names lattice by creating the least upper bound (LUB). */
+export declare function joinColNames(set1: ColNamesDomain, set2: ColNamesDomain, maxColNames?: number): ColNamesDomain;
+/** Meets two abstract values of the columns names domain according to the column names lattice by creating the greatest lower bound (GLB). */
+export declare function meetColNames(set1: ColNamesDomain, set2: ColNamesDomain): ColNamesDomain;
+/** Subtracts an abstract value from another abstract value of the column names domain by performing a set minus. */
+export declare function subtractColNames(set1: ColNamesDomain, set2: ColNamesDomain): ColNamesDomain;
+/**
+ * Widens two abstract values of the column names domain via naive widening to soundly over-approximate the join in (possibly infinite) fixpoint iterations.
+ *
+ * This is technically not necessary, as the join is limited by the maximum number of inferred column names.
+ * However, this speeds up the iteration in larger loops significantly, as we are over-approximating the column names much earlier.
+ */
+export declare function wideningColNames(set1: ColNamesDomain, set2: ColNamesDomain): ColNamesDomain;
+/** Checks whether an abstract value of the column names domain satisfies a column name */
+export declare function satisfiesColsNames(set: ColNamesDomain, value: string): boolean;
+/** Checks if two abstract values of the positive interval domain are equal. */
+export declare function equalInterval(interval1: IntervalDomain, interval2: IntervalDomain): boolean;
+/** Checks if two abstract values of the positive interval domain are ordered according to the partial ordering of the positive interval lattice. */
+export declare function leqInterval(interval1: IntervalDomain, interval2: IntervalDomain): boolean;
+/** Joins two abstract values of the positive interval domain according to the positive interval lattice by creating the least upper bound (LUB). */
+export declare function joinInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
+/** Meets two abstract values of the positive interval domain according to the positive interval lattice by creating the greatest lower bound (GLB). */
+export declare function meetInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
+/** Adds two abstract values of the positive interval domain, by adding the lower bounds and upper bounds. */
+export declare function addInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
+/** Subtracts an abstract value from another abstract values of the positive interval domain, by subtracting the lower bounds and upper bounds. */
+export declare function subtractInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
+/** Creates the minium of two abstract values of the positive interval domain, by creating the minimum of the lower bounds and upper bounds. */
+export declare function minInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
+/** Creates the maximum of two abstract values of the positive interval domain, by creating the maximum of the lower bounds and upper bounds. */
+export declare function maxInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
+/** Extrends the lower bound of an abstract value of the positive interval domain to 0. */
+export declare function extendIntervalToZero(interval: IntervalDomain): IntervalDomain;
+/** Extrends the upper bound of an abstract value of the positive interval domain to infinity. */
+export declare function extendIntervalToInfinity(interval: IntervalDomain): IntervalDomain;
+/** Widens two abstract values of the positive interval domain via naive widening to soundly over-approximate the join in (possibly infinite) fixpoint iterations. */
+export declare function wideningInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
+/** Checks whether an abstract value of the positive interval domain satisfies a numeric value. */
+export declare function satisfiesInterval(interval: IntervalDomain, value: number): boolean;
+/** Checks whether a numeric value satisfies the less-than relation with an abstract value of the positive interval domain. */
+export declare function satisfiesLeqInterval(interval: IntervalDomain, value: number): boolean;
+/** Checks if two abstract values of the data frame shape domain are equal. */
+export declare function equalDataFrameDomain(value1: DataFrameDomain, value2: DataFrameDomain): boolean;
+/** Joins multiple abstract values of the data frame shape domain by creating the least upper bound (LUB). */
+export declare function joinDataFrames(...values: DataFrameDomain[]): DataFrameDomain;
+/** Meets multiple abstract values of the data frame shape domain by creating the greatest lower bound (GLB). */
+export declare function meetDataFrames(...values: DataFrameDomain[]): DataFrameDomain;
+/** Widens two abstract values of the data frame shape domain by widening the column names and number of columns and rows. */
+export declare function wideningDataFrames(value1: DataFrameDomain, value2: DataFrameDomain): DataFrameDomain;
+/** Checks if two abstract states of the data frame shape state domain are equal. */
+export declare function equalDataFrameState(state1: DataFrameStateDomain, state2: DataFrameStateDomain): boolean;
+/** Joins multiple abstract states of the data frame shape state domain by joining each data frame shape of the states. */
+export declare function joinDataFrameStates(...states: DataFrameStateDomain[]): DataFrameStateDomain;
+/** Meets multiple abstract states of the data frame shape state domain by meeting each data frame shape of the states. */
+export declare function meetDataFrameStates(...states: DataFrameStateDomain[]): DataFrameStateDomain;
+/** Widens two abstract states of the data frame shape state domain by widening each data frame shape of the states. */
+export declare function wideningDataFrameStates(state1: DataFrameStateDomain, state2: DataFrameStateDomain): DataFrameStateDomain;
+export {};