@eagleoutice/flowr 2.6.3 → 2.7.2

package/abstract-interpretation/data-frame/semantics.js

@@ -70,7 +70,7 @@ function getConstraintType(operation) {
     return DataFrameSemanticsMapper[operation].type;
 }
 function applyCreateSemantics(value, { colnames, rows }) {
-    const colnamesValue = colnames?.every(assert_1.isNotUndefined) ? colnames : lattice_1.Top;
+    const colnamesValue = setRange(colnames);
     const colsValue = colnames !== undefined ? [colnames.length, colnames.length] : positive_interval_domain_1.PosIntervalTop;
     const rowsValue = Array.isArray(rows) ? rows : typeof rows === 'number' ? [rows, rows] : positive_interval_domain_1.PosIntervalTop;
     return new dataframe_domain_1.DataFrameDomain({
@@ -85,7 +85,7 @@ function applyReadSemantics(value, { colnames, rows }) {
 function applyAccessColsSemantics(value, { columns }) {
     if (columns?.every(col => typeof col === 'string')) {
         return new dataframe_domain_1.DataFrameDomain({
-            colnames: value.colnames.join(columns),
+            colnames: value.colnames.union(setRange(columns)),
             cols: value.cols,
             rows: value.rows
         });
@@ -93,7 +93,7 @@ function applyAccessColsSemantics(value, { columns }) {
     else if (columns?.every(col => typeof col === 'number')) {
         return new dataframe_domain_1.DataFrameDomain({
             colnames: value.colnames,
-            cols: columns?.reduce((current, col) => current.max([col, col]), value.cols),
+            cols: columns.reduce((current, col) => current.max([col, col]), value.cols),
             rows: value.rows
         });
     }
@@ -111,23 +111,22 @@ function applyAccessRowsSemantics(value, { rows }) {
 }
 function applyAssignColsSemantics(value, { columns }) {
     if (columns?.every(col => typeof col === 'string')) {
-        const cols = columns.length;
         return new dataframe_domain_1.DataFrameDomain({
-            colnames: value.colnames.join(columns),
-            cols: value.cols.add([0, cols]).max([cols, cols]),
+            colnames: value.colnames.union(setRange(columns)),
+            cols: value.cols.add([0, columns.length]).max([columns.length, columns.length]),
             rows: value.rows
         });
     }
     else if (columns?.every(col => typeof col === 'number')) {
         return new dataframe_domain_1.DataFrameDomain({
-            colnames: value.colnames.top(),
+            colnames: value.colnames.widenUp(),
             cols: columns.reduce((current, col) => current.max([col, col]), value.cols),
             rows: value.rows
         });
     }
     return new dataframe_domain_1.DataFrameDomain({
-        colnames: value.colnames.top(),
-        cols: value.cols.extendUp(),
+        colnames: value.colnames.widenUp(),
+        cols: value.cols.widenUp(),
         rows: value.rows
     });
 }
@@ -142,28 +141,28 @@ function applyAssignRowsSemantics(value, { rows }) {
     return new dataframe_domain_1.DataFrameDomain({
         colnames: value.colnames,
         cols: value.cols,
-        rows: value.rows.extendUp()
+        rows: value.rows.widenUp()
     });
 }
 function applySetColNamesSemantics(value, { colnames }, options) {
     if (options?.partial) {
         return new dataframe_domain_1.DataFrameDomain({
-            colnames: colnames?.every(assert_1.isNotUndefined) ? value.colnames.join(colnames) : value.colnames.top(),
+            colnames: value.colnames.widenDown().union(setRange(colnames)),
             cols: value.cols,
             rows: value.rows
         });
     }
     const allColNames = colnames?.every(assert_1.isNotUndefined) && value.cols.value !== lattice_1.Bottom && colnames.length >= value.cols.value[1];
     return new dataframe_domain_1.DataFrameDomain({
-        colnames: allColNames ? value.colnames.create(colnames) : value.colnames.top(),
+        colnames: allColNames ? value.colnames.create(setRange(colnames)) : value.colnames.create(setRange(colnames)).widenUp(),
         cols: value.cols,
         rows: value.rows
     });
 }
 function applyAddColsSemantics(value, { colnames }) {
     return new dataframe_domain_1.DataFrameDomain({
-        colnames: colnames?.every(assert_1.isNotUndefined) ? value.colnames.join(colnames) : value.colnames.top(),
-        cols: colnames !== undefined ? value.cols.add([colnames.length, colnames.length]) : value.cols.extendUp(),
+        colnames: colnames !== undefined ? value.colnames.union(setRange(colnames)) : value.colnames.widenUp(),
+        cols: colnames !== undefined ? value.cols.add([colnames.length, colnames.length]) : value.cols.widenUp(),
         rows: value.rows
     });
 }
@@ -173,26 +172,26 @@ function applyAddRowsSemantics(value, { rows }) {
             ...value,
             colnames: value.colnames.top(),
             cols: rows !== undefined ? value.cols.add([1, 1]) : value.cols.top(),
-            rows: rows !== undefined ? value.rows.add([rows, rows]) : value.rows.extendUp()
+            rows: rows !== undefined ? value.rows.add([rows, rows]) : value.rows.widenUp()
         });
     }
     return new dataframe_domain_1.DataFrameDomain({
         colnames: value.colnames,
         cols: value.cols,
-        rows: rows !== undefined ? value.rows.add([rows, rows]) : value.rows.extendUp()
+        rows: rows !== undefined ? value.rows.add([rows, rows]) : value.rows.widenUp()
     });
 }
 function applyRemoveColsSemantics(value, { colnames }, options) {
     if (options?.maybe) {
         return new dataframe_domain_1.DataFrameDomain({
-            colnames: colnames !== undefined ? value.colnames.subtract(colnames.filter(assert_1.isNotUndefined)) : value.colnames,
-            cols: colnames !== undefined ? value.cols.subtract([colnames.length, 0]) : value.cols.extendDown(),
+            colnames: colnames !== undefined ? value.colnames.subtract(setRange(colnames)) : value.colnames.widenDown(),
+            cols: colnames !== undefined ? value.cols.subtract([colnames.length, 0]) : value.cols.widenDown(),
             rows: value.rows
         });
     }
     return new dataframe_domain_1.DataFrameDomain({
-        colnames: colnames !== undefined ? value.colnames.subtract(colnames.filter(assert_1.isNotUndefined)) : value.colnames,
-        cols: colnames !== undefined ? value.cols.subtract([colnames.length, colnames.length]) : value.cols.extendDown(),
+        colnames: colnames !== undefined ? value.colnames.subtract(setRange(colnames)) : value.colnames.widenDown(),
+        cols: colnames !== undefined ? value.cols.subtract([colnames.length, colnames.length]) : value.cols.widenDown(),
         rows: value.rows
     });
 }
@@ -201,18 +200,18 @@ function applyRemoveRowsSemantics(value, { rows }, options) {
         return new dataframe_domain_1.DataFrameDomain({
             colnames: value.colnames,
             cols: value.cols,
-            rows: rows !== undefined ? value.rows.subtract([rows, 0]) : value.rows.extendDown()
+            rows: rows !== undefined ? value.rows.subtract([rows, 0]) : value.rows.widenDown()
         });
     }
     return new dataframe_domain_1.DataFrameDomain({
         colnames: value.colnames,
         cols: value.cols,
-        rows: rows !== undefined ? value.rows.subtract([rows, rows]) : value.rows.extendDown()
+        rows: rows !== undefined ? value.rows.subtract([rows, rows]) : value.rows.widenDown()
     });
 }
 function applyConcatColsSemantics(value, { other }) {
     return new dataframe_domain_1.DataFrameDomain({
-        colnames: value.colnames.join(other.colnames),
+        colnames: value.colnames.union(other.colnames),
         cols: value.cols.add(other.cols),
         rows: value.rows
     });
@@ -243,13 +242,13 @@ function applySubsetColsSemantics(value, { colnames }, options) {
     else if (options?.renamedCols) {
         return new dataframe_domain_1.DataFrameDomain({
             colnames: value.colnames.top(),
-            cols: colnames !== undefined ? value.cols.min([colnames.length, colnames.length]) : value.cols.extendDown(),
+            cols: colnames !== undefined ? value.cols.min([colnames.length, colnames.length]) : value.cols.widenDown(),
             rows: value.rows
         });
     }
     return new dataframe_domain_1.DataFrameDomain({
-        colnames: colnames?.every(assert_1.isNotUndefined) ? value.colnames.meet(colnames) : value.colnames,
-        cols: colnames !== undefined ? value.cols.min([colnames.length, colnames.length]) : value.cols.extendDown(),
+        colnames: colnames !== undefined ? value.colnames.intersect(setRange(colnames)) : value.colnames.widenDown(),
+        cols: colnames !== undefined ? value.cols.min([colnames.length, colnames.length]) : value.cols.widenDown(),
         rows: value.rows
     });
 }
@@ -264,27 +263,27 @@ function applySubsetRowsSemantics(value, { rows }, options) {
     return new dataframe_domain_1.DataFrameDomain({
         colnames: value.colnames,
         cols: value.cols,
-        rows: rows !== undefined ? value.rows.min([rows, rows]) : value.rows.extendDown()
+        rows: rows !== undefined ? value.rows.min([rows, rows]) : value.rows.widenDown()
     });
 }
 function applyFilterRowsSemantics(value, { condition }) {
     return new dataframe_domain_1.DataFrameDomain({
         colnames: value.colnames,
         cols: value.cols,
-        rows: condition ? value.rows : condition === false ? value.rows.create([0, 0]) : value.rows.extendDown()
+        rows: condition ? value.rows : condition === false ? value.rows.create([0, 0]) : value.rows.widenDown()
     });
 }
 function applyMutateColsSemantics(value, { colnames }) {
     return new dataframe_domain_1.DataFrameDomain({
-        colnames: colnames?.every(assert_1.isNotUndefined) ? value.colnames.join(colnames) : value.colnames.top(),
-        cols: colnames !== undefined ? value.cols.add([0, colnames.length]).max([colnames.length, colnames.length]) : value.cols.extendUp(),
+        colnames: colnames !== undefined ? value.colnames.union(setRange(colnames)) : value.colnames.widenUp(),
+        cols: colnames !== undefined ? value.cols.add([0, colnames.length]).max([colnames.length, colnames.length]) : value.cols.widenUp(),
         rows: value.rows
     });
 }
 function applyGroupBySemantics(value, { by }, options) {
     if (options?.mutatedCols) {
         return new dataframe_domain_1.DataFrameDomain({
-            colnames: by.every(assert_1.isNotUndefined) ? value.colnames.join(by) : value.colnames.top(),
+            colnames: value.colnames.union(setRange(by)),
             cols: value.cols.add([0, by.length]),
             rows: value.rows
         });
@@ -294,8 +293,8 @@ function applyGroupBySemantics(value, { by }, options) {
 }
 function applySummarizeSemantics(value, { colnames }) {
     return new dataframe_domain_1.DataFrameDomain({
-        colnames: colnames?.every(assert_1.isNotUndefined) ? value.colnames.join(colnames) : value.colnames.top(),
-        cols: colnames !== undefined ? value.cols.add([0, colnames.length]).min([colnames.length, +Infinity]) : value.cols.extendUp(),
+        colnames: colnames !== undefined ? value.colnames.join(setRange([])).union(setRange(colnames)) : value.colnames.widenUp(),
+        cols: colnames !== undefined ? value.cols.add([0, colnames.length]).min([colnames.length, +Infinity]) : value.cols.widenUp(),
         rows: value.rows.min([1, +Infinity]).max([0, 1])
     });
 }
@@ -318,35 +317,36 @@ function applyJoinSemantics(value, { other, by }, options) {
             return new positive_interval_domain_1.PosIntervalDomain([lower.value[0], interval1.value[1] * interval2.value[1]]);
         }
     };
-    const commonCols = value.colnames.meet(other.colnames);
-    let duplicateCols; // whether columns may be renamed due to occurrence in both data frames
+    let duplicateCols; // columns that may be renamed due to occurring in both data frames
     let productRows; // whether the resulting rows may be a Cartesian product of the rows of the data frames
     if (options?.natural) {
-        duplicateCols = false;
-        productRows = commonCols.isValue() && commonCols.value.size === 0;
+        const commonCols = value.colnames.intersect(other.colnames).upper();
+        duplicateCols = [];
+        productRows = commonCols !== lattice_1.Bottom && commonCols !== lattice_1.Top && commonCols.size === 0;
     }
     else if (by === undefined) {
-        duplicateCols = true;
+        duplicateCols = undefined;
         productRows = true;
     }
     else if (by.length === 0) {
-        duplicateCols = commonCols.isTop() || (commonCols.isValue() && commonCols.value.size > 0);
+        const commonCols = value.colnames.intersect(other.colnames).upper();
+        duplicateCols = commonCols !== lattice_1.Bottom ? commonCols !== lattice_1.Top ? [...commonCols] : undefined : [];
         productRows = true;
     }
     else if (by.every(assert_1.isNotUndefined)) {
-        const remainingCols = commonCols.subtract(by);
-        duplicateCols = remainingCols.isTop() || (remainingCols.isValue() && remainingCols.value.size > 0);
+        const remainingCols = value.colnames.intersect(other.colnames).subtract(setRange(by)).upper();
+        duplicateCols = remainingCols !== lattice_1.Bottom ? remainingCols !== lattice_1.Top ? [...remainingCols] : undefined : [];
         productRows = false;
     }
     else {
-        duplicateCols = true;
+        duplicateCols = undefined;
         productRows = false;
     }
     const joinType = options?.join ?? 'inner';
     let rows;
     switch (joinType) {
         case 'inner':
-            rows = value.rows.min(other.rows).extendDown();
+            rows = value.rows.min(other.rows).widenDown();
             break;
         case 'left':
             rows = value.rows;
@@ -362,7 +362,7 @@ function applyJoinSemantics(value, { other, by }, options) {
     }
     return new dataframe_domain_1.DataFrameDomain({
         ...value,
-        colnames: duplicateCols ? value.colnames.top() : value.colnames.join(other.colnames),
+        colnames: duplicateCols === undefined ? value.colnames.top() : duplicateCols.length > 0 ? value.colnames.union(other.colnames).subtract(setRange(duplicateCols)).widenUp() : value.colnames.union(other.colnames),
         cols: by !== undefined ? value.cols.add(other.cols).subtract([by.length, by.length]) : mergeInterval(value.cols, other.cols),
         rows: productRows ? productInterval(rows, value.rows, other.rows) : rows
     });
@@ -377,4 +377,8 @@ function applyUnknownSemantics(value,
 _args) {
     return value.top();
 }
+function setRange(colnames) {
+    const names = colnames?.filter(assert_1.isNotUndefined) ?? [];
+    return { min: names, range: names.length === colnames?.length ? [] : lattice_1.Top };
+}
 //# sourceMappingURL=semantics.js.map

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

@@ -1,35 +1,59 @@
-import { type ControlFlowInformation } from '../../control-flow/control-flow-graph';
-import type { DataflowGraph } from '../../dataflow/graph/graph';
-import type { RNode } from '../../r-bridge/lang-4.x/ast/model/model';
-import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { DataflowGraphVertexFunctionCall } from '../../dataflow/graph/vertex';
+import type { NoInfo } from '../../r-bridge/lang-4.x/ast/model/model';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import { type AbstractInterpretationInfo } from './absint-info';
-import { type DataFrameDomain, DataFrameStateDomain } from './dataframe-domain';
-import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-analyzer-context';
+import { AbstractInterpretationVisitor, type AbsintVisitorConfiguration } from '../absint-visitor';
+import { DataFrameDomain, DataFrameStateDomain } from './dataframe-domain';
+import { ConstraintType, type DataFrameOperationArgs, type DataFrameOperationName, type DataFrameOperationOptions } from './semantics';
+interface Operation<Name extends DataFrameOperationName> {
+    /** The type of the abstract data frame operation (see {@link DataFrameOperationName}) */
+    operation: Name;
+    /** The ID of the data frame operand of the operation (may be `undefined`) */
+    operand: NodeId | undefined;
+    /** The optional constraint type to overwrite the default type of the operation (see {@link ConstraintType}) */
+    type?: ConstraintType;
+    /** The optional additional options for the abstract operation (see {@link DataFrameOperationOptions}) */
+    options?: DataFrameOperationOptions<Name>;
+}
 /**
- * Infers the shape of data frames by performing abstract interpretation using the control flow graph of a program.
- * This directly attaches the inferred data frames shapes to the AST (see {@link AbstractInterpretationInfo}).
- * @param cfinfo - The control flow information containing the control flow graph
- * @param dfg    - The data flow graph to resolve variable origins and function arguments
- * @param ast    - The abstract syntax tree to resolve node IDs to AST nodes
- * @param ctx    - The current flowr analyzer context
- * @returns The abstract data frame state at the exit node of the control flow graph (see {@link DataFrameStateDomain}).
- * The abstract data frame states for all other nodes are attached to the AST.
+ * An abstract data frame operation.
  */
-export declare function inferDataFrameShapes(cfinfo: ControlFlowInformation, dfg: DataflowGraph, ast: NormalizedAst<ParentInformation & AbstractInterpretationInfo>, ctx: ReadOnlyFlowrAnalyzerContext): DataFrameStateDomain;
+export type DataFrameOperation<OperationName extends DataFrameOperationName = DataFrameOperationName> = {
+    [Name in OperationName]: Operation<Name> & DataFrameOperationArgs<Name>;
+}[OperationName];
 /**
- * Resolves the abstract data frame shape of a node in the AST.
- * This requires that the data frame shape inference has been executed before using {@link inferDataFrameShapes}.
- * @param id     - The node or node ID to get the data frame shape for
- * @param dfg    - The data flow graph used to resolve the data frame shape
- * @param domain - An optional abstract data frame state domain used to resolve the data frame shape (defaults to the state at the requested node)
- * @returns The abstract data frame shape of the node, or `undefined` if no data frame shape was inferred for the node
+ * An abstract data frame operation without additional options.
  */
-export declare function resolveIdToDataFrameShape(id: RNode<ParentInformation & AbstractInterpretationInfo> | NodeId | undefined, dfg: DataflowGraph | undefined, domain?: DataFrameStateDomain): DataFrameDomain | undefined;
+export type DataFrameOperationType<OperationName extends DataFrameOperationName = DataFrameOperationName> = {
+    [Name in OperationName]: Omit<Operation<Name>, 'type' | 'options'> & DataFrameOperationArgs<Name>;
+}[OperationName];
 /**
- * Gets all origins of a variable in the data flow graph that have already been visited.
- * @param node - The node to get the origins for
- * @param dfg  - The data flow graph for resolving the origins
- * @returns The origins nodes of the variable
+ * A possible `undefined` array of abstract data frame operations (see {@link DataFrameOperation}).
  */
-export declare function getVariableOrigins(node: NodeId, dfg: DataflowGraph): RNode<ParentInformation & AbstractInterpretationInfo>[];
+export type DataFrameOperations<OperationName extends DataFrameOperationName = DataFrameOperationName> = DataFrameOperation<OperationName>[] | undefined;
+interface DataFrameShapeInferenceConfiguration extends Omit<AbsintVisitorConfiguration<DataFrameDomain>, 'domain'> {
+    readonly trackOperations?: boolean;
+}
+/**
+ * The control flow graph visitor to infer the shape of data frames using abstract interpretation
+ */
+export declare class DataFrameShapeInferenceVisitor extends AbstractInterpretationVisitor<DataFrameDomain, NoInfo, DataFrameShapeInferenceConfiguration & {
+    domain: DataFrameStateDomain;
+}> {
+    /**
+     * The abstract data frame operations the function call nodes are mapped to.
+     */
+    private readonly operations?;
+    constructor({ trackOperations, ...config }: DataFrameShapeInferenceConfiguration);
+    /**
+     * Gets the mapped abstract data frame operations for an AST node (this only includes direct function calls, replacement calls, or access operations).
+     * This requires that the abstract interpretation visitor has been completed, or at least started.
+     * @param id - The ID of the node to get the mapped abstract operations for
+     * @returns The mapped abstract data frame operations for the node, or `undefined` if no abstract operation was mapped for the node or storing mapped abstract operations is disabled via the visitor config.
+     */
+    getAbstractOperations(id: NodeId | undefined): Readonly<DataFrameOperations>;
+    protected evalFunctionCall(call: DataflowGraphVertexFunctionCall, state: DataFrameStateDomain): DataFrameStateDomain;
+    protected evalReplacementCall(call: DataflowGraphVertexFunctionCall, target: NodeId, source: NodeId, state: DataFrameStateDomain): DataFrameStateDomain;
+    protected evalAccessCall(call: DataflowGraphVertexFunctionCall, state: DataFrameStateDomain): DataFrameStateDomain;
+    private applyDataFrameExpression;
+}
+export {};

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

@@ -1,109 +1,86 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.inferDataFrameShapes = inferDataFrameShapes;
-exports.resolveIdToDataFrameShape = resolveIdToDataFrameShape;
-exports.getVariableOrigins = getVariableOrigins;
-const control_flow_graph_1 = require("../../control-flow/control-flow-graph");
-const vertex_1 = require("../../dataflow/graph/vertex");
-const dfg_get_origin_1 = require("../../dataflow/origin/dfg-get-origin");
-const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
-const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
-const assert_1 = require("../../util/assert");
-const abstract_domain_1 = require("../domains/abstract-domain");
-const absint_info_1 = require("./absint-info");
-const absint_visitor_1 = require("./absint-visitor");
+exports.DataFrameShapeInferenceVisitor = void 0;
+const absint_visitor_1 = require("../absint-visitor");
 const dataframe_domain_1 = require("./dataframe-domain");
+const access_mapper_1 = require("./mappers/access-mapper");
+const function_mapper_1 = require("./mappers/function-mapper");
+const replacement_mapper_1 = require("./mappers/replacement-mapper");
+const semantics_1 = require("./semantics");
 /**
- * Infers the shape of data frames by performing abstract interpretation using the control flow graph of a program.
- * This directly attaches the inferred data frames shapes to the AST (see {@link AbstractInterpretationInfo}).
- * @param cfinfo - The control flow information containing the control flow graph
- * @param dfg    - The data flow graph to resolve variable origins and function arguments
- * @param ast    - The abstract syntax tree to resolve node IDs to AST nodes
- * @param ctx    - The current flowr analyzer context
- * @returns The abstract data frame state at the exit node of the control flow graph (see {@link DataFrameStateDomain}).
- * The abstract data frame states for all other nodes are attached to the AST.
+ * The control flow graph visitor to infer the shape of data frames using abstract interpretation
  */
-function inferDataFrameShapes(cfinfo, dfg, ast, ctx) {
-    const visitor = new absint_visitor_1.DataFrameShapeInferenceVisitor({ controlFlow: cfinfo, dfg: dfg, normalizedAst: ast, ctx });
-    visitor.start();
-    const exitPoints = cfinfo.exitPoints.map(id => cfinfo.graph.getVertex(id)).filter(assert_1.isNotUndefined);
-    const exitNodes = exitPoints.map(vertex => ast.idMap.get((0, control_flow_graph_1.getVertexRootId)(vertex))).filter(assert_1.isNotUndefined);
-    const domains = exitNodes.map(node => node.info.dataFrame?.domain).filter(assert_1.isNotUndefined);
-    return dataframe_domain_1.DataFrameStateDomain.bottom().joinAll(domains);
-}
-/**
- * Resolves the abstract data frame shape of a node in the AST.
- * This requires that the data frame shape inference has been executed before using {@link inferDataFrameShapes}.
- * @param id     - The node or node ID to get the data frame shape for
- * @param dfg    - The data flow graph used to resolve the data frame shape
- * @param domain - An optional abstract data frame state domain used to resolve the data frame shape (defaults to the state at the requested node)
- * @returns The abstract data frame shape of the node, or `undefined` if no data frame shape was inferred for the node
- */
-function resolveIdToDataFrameShape(id, dfg, domain) {
-    const node = id === undefined || typeof id === 'object' ? id : dfg?.idMap?.get(id);
-    domain ??= node?.info.dataFrame?.domain;
-    if (dfg === undefined || node === undefined || domain === undefined) {
-        return;
+class DataFrameShapeInferenceVisitor extends absint_visitor_1.AbstractInterpretationVisitor {
+    /**
+     * The abstract data frame operations the function call nodes are mapped to.
+     */
+    operations;
+    constructor({ trackOperations = true, ...config }) {
+        super({ ...config, domain: dataframe_domain_1.DataFrameStateDomain.bottom() });
+        if (trackOperations) {
+            this.operations = new Map();
+        }
     }
-    else if (domain.has(node.info.id)) {
-        return domain.get(node.info.id);
+    /**
+     * Gets the mapped abstract data frame operations for an AST node (this only includes direct function calls, replacement calls, or access operations).
+     * This requires that the abstract interpretation visitor has been completed, or at least started.
+     * @param id - The ID of the node to get the mapped abstract operations for
+     * @returns The mapped abstract data frame operations for the node, or `undefined` if no abstract operation was mapped for the node or storing mapped abstract operations is disabled via the visitor config.
+     */
+    getAbstractOperations(id) {
+        return id !== undefined ? this.operations?.get(id) : undefined;
     }
-    const vertex = dfg.getVertex(node.info.id);
-    const call = vertex?.tag === vertex_1.VertexType.FunctionCall ? vertex : undefined;
-    const origins = Array.isArray(call?.origin) ? call.origin : [];
-    if (node.type === type_1.RType.Symbol) {
-        const values = getVariableOrigins(node.info.id, dfg).map(origin => domain.get(origin.info.id));
-        if (values.length > 0 && values.every(assert_1.isNotUndefined)) {
-            return abstract_domain_1.AbstractDomain.joinAll(values);
+    evalFunctionCall(call, state) {
+        const node = this.getNormalizedAst(call.id);
+        if (node === undefined) {
+            return state;
         }
+        const operations = (0, function_mapper_1.mapDataFrameFunctionCall)(node, this, this.config.dfg, this.config.ctx);
+        return this.applyDataFrameExpression(node, operations, state);
     }
-    else if (node.type === type_1.RType.Argument && node.value !== undefined) {
-        return resolveIdToDataFrameShape(node.value, dfg, domain);
-    }
-    else if (node.type === type_1.RType.ExpressionList && node.children.length > 0) {
-        return resolveIdToDataFrameShape(node.children[node.children.length - 1], dfg, domain);
+    evalReplacementCall(call, target, source, state) {
+        const node = this.getNormalizedAst(call.id);
+        const targetNode = this.getNormalizedAst(target);
+        const sourceNode = this.getNormalizedAst(source);
+        if (node === undefined || targetNode === undefined || sourceNode === undefined) {
+            return state;
+        }
+        const operations = (0, replacement_mapper_1.mapDataFrameReplacementFunction)(node, sourceNode, this, this.config.dfg, this.config.ctx);
+        return this.applyDataFrameExpression(node, operations, state);
     }
-    else if (node.type === type_1.RType.Pipe) {
-        return resolveIdToDataFrameShape(node.rhs, dfg, domain);
+    evalAccessCall(call, state) {
+        const node = this.getNormalizedAst(call.id);
+        if (node === undefined) {
+            return state;
+        }
+        const operations = (0, access_mapper_1.mapDataFrameAccess)(node, this, this.config.dfg, this.config.ctx);
+        return this.applyDataFrameExpression(node, operations, state);
     }
-    else if (origins.includes('builtin:pipe')) {
-        if (node.type === type_1.RType.BinaryOp) {
-            return resolveIdToDataFrameShape(node.rhs, dfg, domain);
+    applyDataFrameExpression(node, operations, state) {
+        if (operations === undefined) {
+            return state;
         }
-        else if (call?.args.length === 2 && call?.args[1] !== r_function_call_1.EmptyArgument) {
-            return resolveIdToDataFrameShape(call.args[1].nodeId, dfg, domain);
+        else if (this.operations !== undefined) {
+            this.operations.set(node.info.id, operations);
         }
-    }
-    else if (node.type === type_1.RType.IfThenElse) {
-        if (node.otherwise !== undefined) {
-            const values = [node.then, node.otherwise].map(entry => resolveIdToDataFrameShape(entry, dfg, domain));
-            if (values.length > 0 && values.every(assert_1.isNotUndefined)) {
-                return abstract_domain_1.AbstractDomain.joinAll(values);
+        const maxColNames = this.config.ctx.config.abstractInterpretation.dataFrame.maxColNames;
+        let value = dataframe_domain_1.DataFrameDomain.top(maxColNames);
+        for (const { operation, operand, type, options, ...args } of operations) {
+            const operandValue = operand !== undefined ? this.getAbstractValue(operand, state) : value;
+            value = (0, semantics_1.applyDataFrameSemantics)(operation, operandValue ?? dataframe_domain_1.DataFrameDomain.top(maxColNames), args, options);
+            const constraintType = type ?? (0, semantics_1.getConstraintType)(operation);
+            if (operand !== undefined && constraintType === semantics_1.ConstraintType.OperandModification) {
+                state.set(operand, value);
+                for (const origin of this.getVariableOrigins(operand)) {
+                    state.set(origin, value);
+                }
             }
-        }
-    }
-    else if (origins.includes('builtin:if-then-else') && call?.args.every(arg => arg !== r_function_call_1.EmptyArgument)) {
-        if (call.args.length === 3) {
-            const values = call.args.slice(1, 3).map(entry => resolveIdToDataFrameShape(entry.nodeId, dfg, domain));
-            if (values.length > 0 && values.every(assert_1.isNotUndefined)) {
-                return abstract_domain_1.AbstractDomain.joinAll(values);
+            else if (constraintType === semantics_1.ConstraintType.ResultPostcondition) {
+                state.set(node.info.id, value);
             }
         }
+        return state;
     }
 }
-/**
- * Gets all origins of a variable in the data flow graph that have already been visited.
- * @param node - The node to get the origins for
- * @param dfg  - The data flow graph for resolving the origins
- * @returns The origins nodes of the variable
- */
-function getVariableOrigins(node, dfg) {
-    // get each variable origin that has already been visited and whose assignment has already been processed
-    return (0, dfg_get_origin_1.getOriginInDfg)(dfg, node)
-        ?.filter(origin => origin.type === 0 /* OriginType.ReadVariableOrigin */)
-        .map(entry => dfg.idMap?.get(entry.id))
-        .filter(assert_1.isNotUndefined)
-        .filter(origin => origin.info.dataFrame?.domain !== undefined)
-        .filter(origin => !(0, absint_info_1.hasDataFrameInfoMarker)(origin, absint_info_1.DataFrameInfoMarker.Unassigned)) ?? [];
-}
+exports.DataFrameShapeInferenceVisitor = DataFrameShapeInferenceVisitor;
 //# sourceMappingURL=shape-inference.js.map

package/abstract-interpretation/domains/abstract-domain.d.ts

@@ -5,6 +5,7 @@ import { type Lattice, Top } from './lattice';
 export declare const DEFAULT_INFERENCE_LIMIT = 50;
 /**
  * An abstract domain as complete lattice with a widening operator, narrowing operator, concretization function, and abstraction function.
+ * All operations of value abstract domains should not modify the domain in-place but return new values using {@link create}.
  * @template Concrete - Type of an concrete element of the concrete domain for the abstract domain
  * @template Abstract - Type of an abstract element of the abstract domain representing possible elements (excludes `Top` and `Bot`)
  * @template Top      - Type of the Top element of the abstract domain representing all possible elements

package/abstract-interpretation/domains/abstract-domain.js

@@ -11,6 +11,7 @@ const lattice_1 = require("./lattice");
 exports.DEFAULT_INFERENCE_LIMIT = 50;
 /**
  * An abstract domain as complete lattice with a widening operator, narrowing operator, concretization function, and abstraction function.
+ * All operations of value abstract domains should not modify the domain in-place but return new values using {@link create}.
  * @template Concrete - Type of an concrete element of the concrete domain for the abstract domain
  * @template Abstract - Type of an abstract element of the abstract domain representing possible elements (excludes `Top` and `Bot`)
  * @template Top      - Type of the Top element of the abstract domain representing all possible elements
@@ -73,10 +74,10 @@ function domainElementToString(value) {
         return value.toString();
     }
     else if (value === lattice_1.Top) {
-        return '⊤';
+        return lattice_1.TopSymbol;
     }
     else if (value === lattice_1.Bottom) {
-        return '⊥';
+        return lattice_1.BottomSymbol;
     }
     return JSON.stringify(value);
 }

package/abstract-interpretation/domains/bounded-set-domain.d.ts

@@ -34,10 +34,10 @@ export declare class BoundedSetDomain<T, Value extends BoundedSetLift<T> = Bound
     bottom(): this & BoundedSetDomain<T, BoundedSetBottom>;
     equals(other: this): boolean;
     leq(other: this): boolean;
-    join(other: this): this;
     join(other: BoundedSetLift<T> | T[]): this;
-    meet(other: this): this;
+    join(other: this): this;
     meet(other: BoundedSetLift<T> | T[]): this;
+    meet(other: this): this;
     /**
      * Subtracts another abstract value from the current abstract value by removing all elements of the other abstract value from the current abstract value.
      */

package/abstract-interpretation/domains/bounded-set-domain.js

@@ -125,7 +125,7 @@ class BoundedSetDomain extends abstract_domain_1.AbstractDomain {
     }
     toString() {
         if (this.value === lattice_1.Top) {
-            return '⊤';
+            return lattice_1.TopSymbol;
         }
         const string = this.value.values().map(abstract_domain_1.domainElementToString).toArray().join(', ');
         return `{${string}}`;

package/abstract-interpretation/domains/interval-domain.d.ts

@@ -27,10 +27,10 @@ export declare class IntervalDomain<Value extends IntervalLift = IntervalLift> e
     bottom(): this & IntervalDomain<IntervalBottom>;
     equals(other: this): boolean;
     leq(other: this): boolean;
-    join(other: this): this;
     join(other: IntervalLift): this;
-    meet(other: this): this;
+    join(other: this): this;
     meet(other: IntervalLift): this;
+    meet(other: this): this;
     widen(other: this): this;
     narrow(other: this): this;
     concretize(limit: number): ReadonlySet<number> | typeof Top;
@@ -55,11 +55,11 @@ export declare class IntervalDomain<Value extends IntervalLift = IntervalLift> e
     /**
      * Extends the lower bound of the current abstract value down to -∞.
      */
-    extendDown(): this;
+    widenDown(): this;
     /**
      * Extends the upper bound of the current abstract value up to +∞.
      */
-    extendUp(): this;
+    widenUp(): this;
     toJson(): unknown;
     toString(): string;
     isTop(): this is IntervalDomain<IntervalTop>;