@eagleoutice/flowr 2.7.0 → 2.7.3

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 { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-analyzer-context';
-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 { 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/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/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;

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

@@ -19,6 +19,11 @@ type SetRangeTop = typeof SetRangeTop;
 type SetRangeBottom = typeof Bottom;
 /** The type of the abstract values of the set range domain that are Top, Bottom, or actual values */
 type SetRangeLift<T> = SetRangeValue<T> | SetRangeTop | SetRangeBottom;
+/** The type of the actual values of the set range domain with a finite range (the range cannot be Top) */
+type SetRangeFinite<T> = {
+    readonly min: ReadonlySet<T>;
+    readonly range: ReadonlySet<T>;
+};
 /** The type of the actual values of the set range domain as array tuple with a minimum array and range array for better readability (e.g. `[["id","name"], []]`, or `[["id"], ["score"]]`) */
 export type ArrayRangeValue<T> = {
     readonly min: T[];
@@ -48,11 +53,11 @@ export declare class SetRangeDomain<T, Value extends SetRangeLift<T> = SetRangeL
     /**
      * The minimum set (lower bound) of the set range representing all values that must exist (subset of {@link upper}).
      */
-    lower(): SetRangeValue<T>['min'] | typeof Bottom;
+    lower(): Value extends SetRangeValue<T> ? ReadonlySet<T> : ReadonlySet<T> | typeof Bottom;
     /**
      * The maximum set (upper bound) of the set range representing all values that can possibly exist (union of {@link lower} and range).
      */
-    upper(): SetRangeValue<T>['range'] | typeof Bottom;
+    upper(): Value extends SetRangeFinite<T> ? ReadonlySet<T> : Value extends SetRangeValue<T> ? ReadonlySet<T> | typeof Top : ReadonlySet<T> | typeof Top | typeof Bottom;
     static top<T>(limit?: SetRangeLimit | number, setType?: typeof Set<T>): SetRangeDomain<T, SetRangeTop>;
     static bottom<T>(limit?: SetRangeLimit | number, setType?: typeof Set<T>): SetRangeDomain<T, SetRangeBottom>;
     static abstract<T>(concrete: ReadonlySet<ReadonlySet<T>> | typeof Top, limit?: SetRangeLimit | number, setType?: typeof Set<T>): SetRangeDomain<T>;
@@ -60,10 +65,10 @@ export declare class SetRangeDomain<T, Value extends SetRangeLift<T> = SetRangeL
     bottom(): this & SetRangeDomain<T, SetRangeBottom>;
     equals(other: this): boolean;
     leq(other: this): boolean;
-    join(other: this): this;
     join(other: SetRangeLift<T> | ArrayRangeValue<T>): this;
-    meet(other: this): this;
+    join(other: this): this;
     meet(other: SetRangeLift<T> | ArrayRangeValue<T>): this;
+    meet(other: this): this;
     /**
      * Creates the union of this abstract value and another abstract value by creating the union of the minimum and maximum set, respectively.
      */
@@ -94,5 +99,6 @@ export declare class SetRangeDomain<T, Value extends SetRangeLift<T> = SetRangeL
     isTop(): this is SetRangeDomain<T, SetRangeTop>;
     isBottom(): this is SetRangeDomain<T, SetRangeBottom>;
     isValue(): this is SetRangeDomain<T, SetRangeValue<T>>;
+    isFinite(): this is SetRangeDomain<T, SetRangeFinite<T>>;
 }
 export {};

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

@@ -61,7 +61,10 @@ class SetRangeDomain extends abstract_domain_1.AbstractDomain {
         if (this.value === lattice_1.Bottom) {
             return lattice_1.Bottom;
         }
-        return this.value.range === lattice_1.Top ? lattice_1.Top : this.value.min.union(this.value.range);
+        else if (this.value.range == lattice_1.Top) {
+            return lattice_1.Top;
+        }
+        return this.value.min.union(this.value.range);
     }
     static top(limit, setType) {
         return new SetRangeDomain(exports.SetRangeTop, limit, setType);
@@ -395,6 +398,9 @@ class SetRangeDomain extends abstract_domain_1.AbstractDomain {
     isValue() {
         return this.value !== lattice_1.Bottom;
     }
+    isFinite() {
+        return this.value !== lattice_1.Bottom && this.value.range !== lattice_1.Top;
+    }
 }
 exports.SetRangeDomain = SetRangeDomain;
 //# sourceMappingURL=set-range-domain.js.map

package/abstract-interpretation/domains/set-upper-bound-domain.d.ts

@@ -32,10 +32,10 @@ export declare class SetUpperBoundDomain<T, Value extends SetUpperBoundLift<T> =
     bottom(): this & SetUpperBoundDomain<T, SetUpperBoundBottom>;
     equals(other: this): boolean;
     leq(other: this): boolean;
-    join(other: this): this;
     join(other: SetUpperBoundLift<T> | T[]): this;
-    meet(other: this): this;
+    join(other: this): this;
     meet(other: SetUpperBoundLift<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/singleton-domain.d.ts

@@ -25,10 +25,10 @@ export declare class SingletonDomain<T, Value extends SingletonLift<T> = Singlet
     bottom(): this & SingletonDomain<T, SingletonBottom>;
     equals(other: this): boolean;
     leq(other: this): boolean;
-    join(other: this): this;
     join(other: SingletonLift<T>): this;
-    meet(other: this): this;
+    join(other: this): this;
     meet(other: SingletonLift<T>): this;
+    meet(other: this): this;
     widen(other: this): this;
     narrow(other: this): this;
     concretize(): ReadonlySet<T> | typeof Top;

package/benchmark/slicer.js

@@ -26,7 +26,6 @@ const vertex_1 = require("../dataflow/graph/vertex");
 const arrays_1 = require("../util/collections/arrays");
 const config_1 = require("../config");
 const extract_cfg_1 = require("../control-flow/extract-cfg");
-const absint_info_1 = require("../abstract-interpretation/data-frame/absint-info");
 const shape_inference_1 = require("../abstract-interpretation/data-frame/shape-inference");
 const lattice_1 = require("../abstract-interpretation/domains/lattice");
 const set_range_domain_1 = require("../abstract-interpretation/domains/set-range-domain");
@@ -291,7 +290,7 @@ class BenchmarkSlicer {
         (0, assert_1.guard)(this.normalizedAst !== undefined, 'normalizedAst should be defined for data frame shape inference');
         (0, assert_1.guard)(this.dataflow !== undefined, 'dataflow should be defined for data frame shape inference');
         (0, assert_1.guard)(this.controlFlow !== undefined, 'controlFlow should be defined for data frame shape inference');
-        (0, assert_1.guard)(this.config !== undefined, 'config should be defined for data frame shape inference');
+        (0, assert_1.guard)(this.context !== undefined, 'context should be defined for data frame shape inference');
         const ast = this.normalizedAst;
         const dfg = this.dataflow.graph;
         const cfinfo = this.controlFlow;
@@ -308,7 +307,9 @@ class BenchmarkSlicer {
             sizeOfInfo: 0,
             perNodeStats: new Map()
         };
-        const result = this.measureSimpleStep('infer data frame shapes', () => (0, shape_inference_1.inferDataFrameShapes)(cfinfo, dfg, ast, this.context));
+        const inference = new shape_inference_1.DataFrameShapeInferenceVisitor({ controlFlow: cfinfo, dfg, normalizedAst: ast, ctx: this.context });
+        this.measureSimpleStep('infer data frame shapes', () => inference.start());
+        const result = inference.getEndState();
         stats.numberOfResultConstraints = result.value.size;
         for (const value of result.value.values()) {
             if (value.isTop()) {
@@ -321,23 +322,21 @@ class BenchmarkSlicer {
                 stats.numberOfResultingValues++;
             }
         }
-        (0, visitor_1.visitAst)(this.normalizedAst.ast.files.map(f => f.root), (node) => {
-            if (node.info.dataFrame === undefined) {
-                return;
-            }
-            stats.sizeOfInfo += (0, size_of_1.safeSizeOf)([node.info.dataFrame]);
-            const expression = (0, absint_info_1.hasDataFrameExpressionInfo)(node) ? node.info.dataFrame : undefined;
-            const value = node.info.dataFrame.domain?.get(node.info.id);
+        (0, visitor_1.visitAst)(this.normalizedAst.ast.files.map(file => file.root), node => {
+            const operations = inference.getAbstractOperations(node.info.id);
+            const value = inference.getAbstractValue(node.info.id);
             // Only store per-node information for nodes representing expressions or nodes with abstract values
-            if (expression === undefined && value === undefined) {
+            if (operations === undefined && value === undefined) {
                 stats.numberOfEmptyNodes++;
                 return;
             }
+            const state = inference.getAbstractState(node.info.id);
+            stats.sizeOfInfo += (0, size_of_1.safeSizeOf)([state]);
             const nodeStats = {
-                numberOfEntries: node.info.dataFrame?.domain?.value.size ?? 0
+                numberOfEntries: state?.value.size ?? 0
             };
-            if (expression !== undefined) {
-                nodeStats.mappedOperations = expression.operations.map(op => op.operation);
+            if (operations !== undefined) {
+                nodeStats.mappedOperations = operations.map(op => op.operation);
                 stats.numberOfOperationNodes++;
                 if (value !== undefined) {
                     nodeStats.inferredColNames = this.getInferredNumber(value.colnames);