@eagleoutice/flowr 2.6.1 → 2.6.3

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

@@ -1,21 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SingletonDomain = void 0;
+const logic_1 = require("../../util/logic");
 const abstract_domain_1 = require("./abstract-domain");
 const lattice_1 = require("./lattice");
 /**
- * The singleton abstract domain as single possible value.
+ * The singleton abstract domain as a single possible value.
  * The Bottom element is defined as {@link Bottom} symbol and the Top element is defined as {@link Top} symbol.
  * @template T     - Type of the value in the abstract domain
  * @template Value - Type of the constraint in the abstract domain (Top, Bottom, or an actual value)
  */
-class SingletonDomain {
-    _value;
-    constructor(value) {
-        this._value = value;
-    }
-    get value() {
-        return this._value;
+class SingletonDomain extends abstract_domain_1.AbstractDomain {
+    create(value) {
+        return new SingletonDomain(value);
     }
     static top() {
         return new SingletonDomain(lattice_1.Top);
@@ -44,35 +41,35 @@ class SingletonDomain {
     leq(other) {
         return this.value === lattice_1.Bottom || other.value === lattice_1.Top || (this.isValue() && other.isValue() && this.value <= other.value);
     }
-    join(...values) {
-        const result = new SingletonDomain(this.value);
-        for (const other of values) {
-            if (result.value === lattice_1.Bottom) {
-                result._value = other.value;
-            }
-            else if (other.value === lattice_1.Bottom) {
-                result._value = result.value;
-            }
-            else if (result.value !== other.value) {
-                result._value = lattice_1.Top;
-            }
-        }
-        return result;
-    }
-    meet(...values) {
-        const result = new SingletonDomain(this.value);
-        for (const other of values) {
-            if (result.value === lattice_1.Top) {
-                result._value = other.value;
-            }
-            else if (other.value === lattice_1.Top) {
-                result._value = result.value;
-            }
-            else if (result.value !== other.value) {
-                result._value = lattice_1.Bottom;
-            }
-        }
-        return result;
+    join(other) {
+        const otherValue = other instanceof SingletonDomain ? other.value : other;
+        if (this.value === lattice_1.Bottom) {
+            return this.create(otherValue);
+        }
+        else if (otherValue === lattice_1.Bottom) {
+            return this.create(this.value);
+        }
+        else if (this.value !== otherValue) {
+            return this.top();
+        }
+        else {
+            return this.create(this.value);
+        }
+    }
+    meet(other) {
+        const otherValue = other instanceof SingletonDomain ? other.value : other;
+        if (this.value === lattice_1.Top) {
+            return this.create(otherValue);
+        }
+        else if (otherValue === lattice_1.Top) {
+            return this.create(this.value);
+        }
+        else if (this.value !== otherValue) {
+            return this.bottom();
+        }
+        else {
+            return this.create(this.value);
+        }
     }
     widen(other) {
         return this.join(other); // Using join for widening as the lattice is finite
@@ -92,6 +89,24 @@ class SingletonDomain {
     abstract(concrete) {
         return SingletonDomain.abstract(concrete);
     }
+    satisfies(value) {
+        if (this.isValue() && this.value === value) {
+            return logic_1.Ternary.Always;
+        }
+        else if (this.isTop()) {
+            return logic_1.Ternary.Maybe;
+        }
+        return logic_1.Ternary.Never;
+    }
+    toJson() {
+        if (this.value === lattice_1.Top) {
+            return lattice_1.Top.description;
+        }
+        else if (this.value === lattice_1.Bottom) {
+            return lattice_1.Bottom.description;
+        }
+        return this.value;
+    }
     toString() {
         if (this.value === lattice_1.Top) {
             return '⊤';

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

@@ -1,32 +1,16 @@
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { AbstractDomain, ConcreteDomain } from './abstract-domain';
-import { Top } from './lattice';
-/** The type of the abstract state for a abstract domain mapping AST node IDs to abstract values of an abstract domain */
-export type AbstractState<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> = Map<NodeId, Domain>;
-/** The type of the concrete state for the concrete domain of an abstract domain mapping AST node IDs to a concrete value in the concrete domain */
-export type ConcreteState<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> = ReadonlyMap<NodeId, ConcreteDomain<Domain>>;
+import type { AnyAbstractDomain } from './abstract-domain';
+import { MappedAbstractDomain } from './mapped-abstract-domain';
 /**
  * A state abstract domain as mapping of AST node IDs of a program to abstract values of an abstract domain.
  * The Bottom element is defined as empty mapping and the Top element is defined as mapping every existing mapped AST node ID to Top.
  * @template Domain - Type of the abstract domain to map the AST node IDs to
  * @see {@link NodeId} for the node IDs of the AST nodes
  */
-export declare class StateAbstractDomain<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> implements AbstractDomain<ConcreteState<Domain>, AbstractState<Domain>, AbstractState<Domain>, AbstractState<Domain>> {
-    private _value;
-    constructor(value: AbstractState<Domain>);
-    get value(): AbstractState<Domain>;
-    bottom(): StateAbstractDomain<Domain>;
-    top(): StateAbstractDomain<Domain>;
-    equals(other: StateAbstractDomain<Domain>): boolean;
-    leq(other: StateAbstractDomain<Domain>): boolean;
-    join(...values: StateAbstractDomain<Domain>[]): StateAbstractDomain<Domain>;
-    meet(...values: StateAbstractDomain<Domain>[]): StateAbstractDomain<Domain>;
-    widen(other: StateAbstractDomain<Domain>): StateAbstractDomain<Domain>;
-    narrow(other: StateAbstractDomain<Domain>): StateAbstractDomain<Domain>;
-    concretize(limit?: number): ReadonlySet<ConcreteState<Domain>> | typeof Top;
-    abstract(concrete: ReadonlySet<ConcreteState<Domain>> | typeof Top): StateAbstractDomain<Domain>;
-    toString(): string;
-    isTop(): this is StateAbstractDomain<Domain>;
-    isBottom(): this is StateAbstractDomain<Domain>;
-    isValue(): this is StateAbstractDomain<Domain>;
+export declare abstract class StateAbstractDomain<Domain extends AnyAbstractDomain> extends MappedAbstractDomain<NodeId, Domain> {
 }
+/**
+ * The type of the value abstract domain of a state abstract domain (i.e. the abstract domain a state abstract domain maps to).
+ * @template StateDomain - The state abstract domain to get the value abstract domain type for
+ */
+export type ValueAbstractDomain<StateDomain extends StateAbstractDomain<AnyAbstractDomain>> = StateDomain extends StateAbstractDomain<infer Domain> ? Domain : never;

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

@@ -1,179 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StateAbstractDomain = void 0;
-const abstract_domain_1 = require("./abstract-domain");
-const lattice_1 = require("./lattice");
+const mapped_abstract_domain_1 = require("./mapped-abstract-domain");
 /**
  * A state abstract domain as mapping of AST node IDs of a program to abstract values of an abstract domain.
  * The Bottom element is defined as empty mapping and the Top element is defined as mapping every existing mapped AST node ID to Top.
  * @template Domain - Type of the abstract domain to map the AST node IDs to
  * @see {@link NodeId} for the node IDs of the AST nodes
  */
-class StateAbstractDomain {
-    _value;
-    constructor(value) {
-        this._value = new Map(value);
-    }
-    get value() {
-        return this._value;
-    }
-    bottom() {
-        return new StateAbstractDomain(new Map());
-    }
-    top() {
-        const result = new StateAbstractDomain(this.value);
-        for (const [key, value] of result.value) {
-            result._value.set(key, value.top());
-        }
-        return result;
-    }
-    equals(other) {
-        if (this.value === other.value) {
-            return true;
-        }
-        else if (this.value.size !== other.value.size) {
-            return false;
-        }
-        for (const [nodeId, value] of this.value) {
-            const otherValue = other.value.get(nodeId);
-            if (otherValue === undefined || !value.equals(otherValue)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    leq(other) {
-        if (this.value === other.value) {
-            return true;
-        }
-        for (const [nodeId, value] of this.value) {
-            const otherValue = other.value.get(nodeId);
-            if (otherValue === undefined || !value.leq(otherValue)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    join(...values) {
-        const result = new StateAbstractDomain(this.value);
-        for (const other of values) {
-            for (const [nodeId, value] of other.value) {
-                const currValue = result.value.get(nodeId);
-                if (currValue === undefined) {
-                    result.value.set(nodeId, value);
-                }
-                else {
-                    result.value.set(nodeId, currValue.join(value));
-                }
-            }
-        }
-        return result;
-    }
-    meet(...values) {
-        const result = new StateAbstractDomain(this.value);
-        for (const other of values) {
-            for (const [nodeId] of result.value) {
-                if (!other.value.has(nodeId)) {
-                    result.value.delete(nodeId);
-                }
-            }
-            for (const [nodeId, value] of other.value) {
-                const currValue = result.value.get(nodeId);
-                if (currValue !== undefined) {
-                    result.value.set(nodeId, currValue.meet(value));
-                }
-            }
-        }
-        return result;
-    }
-    widen(other) {
-        const result = new StateAbstractDomain(this.value);
-        for (const [nodeId, value] of other.value) {
-            const currValue = result.value.get(nodeId);
-            if (currValue === undefined) {
-                result.value.set(nodeId, value);
-            }
-            else {
-                result.value.set(nodeId, currValue.widen(value));
-            }
-        }
-        return result;
-    }
-    narrow(other) {
-        const result = new StateAbstractDomain(this.value);
-        for (const [nodeId] of this.value) {
-            if (!other.value.has(nodeId)) {
-                result.value.delete(nodeId);
-            }
-        }
-        for (const [nodeId, value] of other.value) {
-            const currValue = result.value.get(nodeId);
-            if (currValue !== undefined) {
-                result.value.set(nodeId, currValue.narrow(value));
-            }
-        }
-        return result;
-    }
-    concretize(limit = abstract_domain_1.DEFAULT_INFERENCE_LIMIT) {
-        if (this.value.values().some(value => value.isBottom())) {
-            return new Set();
-        }
-        let states = new Set([new Map()]);
-        for (const [nodeId, value] of this.value) {
-            const concreteValues = value.concretize(limit);
-            if (concreteValues === lattice_1.Top) {
-                return lattice_1.Top;
-            }
-            const newStates = new Set();
-            for (const state of states) {
-                for (const concrete of concreteValues) {
-                    if (newStates.size > limit) {
-                        return lattice_1.Top;
-                    }
-                    const map = new Map(state);
-                    map.set(nodeId, concrete);
-                    newStates.add(map);
-                }
-            }
-            states = newStates;
-        }
-        return states;
-    }
-    abstract(concrete) {
-        const entry = [...this.value.values()][0];
-        if (concrete === lattice_1.Top || entry === undefined) {
-            return new StateAbstractDomain(new Map());
-        }
-        const mappings = new Map();
-        for (const state of concrete) {
-            for (const [nodeId, value] of state) {
-                const mapping = mappings.get(nodeId);
-                if (mapping === undefined) {
-                    mappings.set(nodeId, new Set([value]));
-                }
-                else {
-                    mapping.add(value);
-                }
-            }
-        }
-        const result = new Map();
-        for (const [nodeId, values] of mappings) {
-            result.set(nodeId, entry.abstract(values));
-        }
-        return new StateAbstractDomain(result);
-    }
-    toString() {
-        return '(' + this.value.entries().toArray().map(([key, value]) => `${key} -> ${value.toString()}`).join(', ') + ')';
-    }
-    isTop() {
-        return this.value.values().every(value => value.isTop());
-    }
-    isBottom() {
-        return this.value.size === 0;
-    }
-    isValue() {
-        return true;
-    }
+class StateAbstractDomain extends mapped_abstract_domain_1.MappedAbstractDomain {
 }
 exports.StateAbstractDomain = StateAbstractDomain;
 //# sourceMappingURL=state-abstract-domain.js.map

package/abstract-interpretation/normalized-ast-fold.d.ts

@@ -1,7 +1,6 @@
 import type { NoInfo, RNode } from '../r-bridge/lang-4.x/ast/model/model';
 import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
-import type { RFunctionCall } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
-import { EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type RFunctionCall, EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RFunctionDefinition } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-definition';
 import { RType } from '../r-bridge/lang-4.x/ast/model/type';
 import type { RForLoop } from '../r-bridge/lang-4.x/ast/model/nodes/r-for-loop';
@@ -26,7 +25,7 @@ type FoldOfType<T extends RType, Returns = void, Info = NoInfo> = (node: Extract
     type: T;
 }>) => Returns;
 /** explicitly excludes types that are not visitable */
-export type FoldableRType = Exclude<RType, RType.Delimiter>;
+export type FoldableRType = Exclude<RType, RType.Delimiter | RType.Project>;
 /**
  * Describes the fold functions for each node type.
  */
@@ -48,10 +47,8 @@ export type EntryExitVisitor<Info> = ((node: RNode<Info>) => void) | undefined;
  * You can control the value passing (`Returns` generic)
  * by providing sensible Monoid behavior overwriting the {@link DefaultNormalizedAstFold#concat|concat} method
  * and supplying the empty value in the constructor.
- *
  * @note By providing `entry` and `exit` you can use this as an extension to the simpler {@link visitAst} function but without
  *       the early termination within the visitors (for this, you can overwrite the respective `fold*` methods).
- *
  * @example First you want to create your own fold:
  *
  * ```ts
@@ -84,15 +81,12 @@ export declare class DefaultNormalizedAstFold<Returns = void, Info = NoInfo> imp
     constructor(empty: Returns, enter?: EntryExitVisitor<Info>, exit?: EntryExitVisitor<Info>);
     /**
      * Monoid::concat
-     *
-     *
      * @see {@link https://en.wikipedia.org/wiki/Monoid}
      * @see {@link DefaultNormalizedAstFold#concatAll|concatAll}
      */
     protected concat(_a: Returns, _b: Returns): Returns;
     /**
      * overwrite this method, if you have a faster way to concat multiple nodes
-     *
      * @see {@link DefaultNormalizedAstFold#concatAll|concatAll}
      */
     protected concatAll(nodes: readonly Returns[]): Returns;

package/abstract-interpretation/normalized-ast-fold.js

@@ -9,10 +9,8 @@ const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
  * You can control the value passing (`Returns` generic)
  * by providing sensible Monoid behavior overwriting the {@link DefaultNormalizedAstFold#concat|concat} method
  * and supplying the empty value in the constructor.
- *
  * @note By providing `entry` and `exit` you can use this as an extension to the simpler {@link visitAst} function but without
  *       the early termination within the visitors (for this, you can overwrite the respective `fold*` methods).
- *
  * @example First you want to create your own fold:
  *
  * ```ts
@@ -49,8 +47,6 @@ class DefaultNormalizedAstFold {
     }
     /**
      * Monoid::concat
-     *
-     *
      * @see {@link https://en.wikipedia.org/wiki/Monoid}
      * @see {@link DefaultNormalizedAstFold#concatAll|concatAll}
      */
@@ -59,7 +55,6 @@ class DefaultNormalizedAstFold {
     }
     /**
      * overwrite this method, if you have a faster way to concat multiple nodes
-     *
      * @see {@link DefaultNormalizedAstFold#concatAll|concatAll}
      */
     concatAll(nodes) {

package/benchmark/slicer.d.ts

@@ -9,11 +9,11 @@ import type { ReconstructionResult } from '../reconstruct/reconstruct';
 import type { PerSliceStats, SlicerStats, SlicerStatsDfShape } from './stats/stats';
 import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { SlicingCriteria } from '../slicing/criterion/parse';
-import type { RParseRequestFromFile, RParseRequestFromText } from '../r-bridge/retriever';
-import type { SlicingCriteriaFilter } from '../slicing/criterion/collect-all';
+import { type RParseRequestFromFile, type RParseRequestFromText } from '../r-bridge/retriever';
+import { type SlicingCriteriaFilter } from '../slicing/criterion/collect-all';
 import type { AutoSelectPredicate } from '../reconstruct/auto-select/auto-select-defaults';
 import type { KnownParserName } from '../r-bridge/parser';
-import type { FlowrConfigOptions } from '../config';
+import { type FlowrConfigOptions } from '../config';
 /**
  * The logger to be used for benchmarking as a global object.
  */
@@ -58,6 +58,7 @@ export declare class BenchmarkSlicer {
     private readonly deltas;
     private readonly parserName;
     private config;
+    private context;
     private stats;
     private loadedXml;
     private dataflow;
@@ -93,7 +94,6 @@ export declare class BenchmarkSlicer {
     /**
      * Slice for the given {@link SlicingCriteria}.
      * @see SingleSlicingCriterion
-     *
      * @returns The per slice stats retrieved for this slicing criteria
      */
     slice(...slicingCriteria: SlicingCriteria): Promise<BenchmarkSingleSliceStats>;
@@ -103,7 +103,6 @@ export declare class BenchmarkSlicer {
     extractCFG(): void;
     /**
      * Infer the shape of data frames using abstract interpretation with {@link inferDataFrameShapes}
-     *
      * @returns The statistics of the data frame shape inference
      */
     inferDataFrameShapes(): SlicerStatsDfShape;
@@ -118,9 +117,7 @@ export declare class BenchmarkSlicer {
      * See {@link collectAllSlicingCriteria} for details.
      * <p>
      * the `report` function will be called *before* each *individual* slice is performed.
-     *
      * @returns The number of slices that were produced
-     *
      * @see collectAllSlicingCriteria
      * @see SlicingCriteriaFilter
      */

package/benchmark/slicer.js

@@ -27,9 +27,9 @@ 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 domain_1 = require("../abstract-interpretation/data-frame/domain");
 const shape_inference_1 = require("../abstract-interpretation/data-frame/shape-inference");
 const fs_1 = __importDefault(require("fs"));
+const flowr_analyzer_context_1 = require("../project/context/flowr-analyzer-context");
 /**
  * The logger to be used for benchmarking as a global object.
  */
@@ -41,6 +41,7 @@ class BenchmarkSlicer {
     deltas = new Map();
     parserName;
     config;
+    context;
     stats;
     loadedXml;
     dataflow;
@@ -72,13 +73,14 @@ class BenchmarkSlicer {
                 return new tree_sitter_executor_1.TreeSitterExecutor();
             }
         });
+        this.context = (0, flowr_analyzer_context_1.contextFromInput)({ ...request }, config);
         this.executor = (0, default_pipelines_1.createSlicePipeline)(this.parser, {
-            request: { ...request },
+            context: this.context,
             criterion: [],
             autoSelectIf,
             threshold,
-        }, config);
-        this.loadedXml = (await this.measureCommonStep('parse', 'retrieve AST from R code')).parsed;
+        });
+        this.loadedXml = (await this.measureCommonStep('parse', 'retrieve AST from R code')).files.map(p => p.parsed);
         this.normalizedAst = await this.measureCommonStep('normalize', 'normalize R AST');
         this.dataflow = await this.measureCommonStep('dataflow', 'produce dataflow information');
         this.executor.switchToRequestStage();
@@ -101,9 +103,9 @@ class BenchmarkSlicer {
                 }
                 return ret;
             };
-            const root = this.loadedXml.rootNode;
-            numberOfRTokens = countChildren(root);
-            numberOfRTokensNoComments = countChildren(root, true);
+            const root = this.loadedXml.map(t => t.rootNode);
+            numberOfRTokens = root.map(r => countChildren(r)).reduce((a, b) => a + b, 0);
+            numberOfRTokensNoComments = root.map(r => countChildren(r, true)).reduce((a, b) => a + b, 0);
         }
         (0, assert_1.guard)(this.normalizedAst !== undefined, 'normalizedAst should be defined after initialization');
         (0, assert_1.guard)(this.dataflow !== undefined, 'dataflow should be defined after initialization');
@@ -126,7 +128,7 @@ class BenchmarkSlicer {
         let nodesNoComments = 0;
         let commentChars = 0;
         let commentCharsNoWhitespace = 0;
-        (0, visitor_1.visitAst)(this.normalizedAst.ast, t => {
+        (0, visitor_1.visitAst)(this.normalizedAst.ast.files.map(f => f.root), t => {
             nodes++;
             const comments = t.info.additionalTokens?.filter(t => t.type === type_1.RType.Comment);
             if (comments && comments.length > 0) {
@@ -222,7 +224,6 @@ class BenchmarkSlicer {
     /**
      * Slice for the given {@link SlicingCriteria}.
      * @see SingleSlicingCriterion
-     *
      * @returns The per slice stats retrieved for this slicing criteria
      */
     async slice(...slicingCriteria) {
@@ -276,12 +277,10 @@ class BenchmarkSlicer {
         (0, assert_1.guard)(this.config !== undefined, 'config should be defined for control flow extraction');
         const ast = this.normalizedAst;
         const dfg = this.dataflow.graph;
-        const config = this.config;
-        this.controlFlow = this.measureSimpleStep('extract control flow graph', () => (0, extract_cfg_1.extractCfg)(ast, config, dfg));
+        this.controlFlow = this.measureSimpleStep('extract control flow graph', () => (0, extract_cfg_1.extractCfg)(ast, this.context, dfg));
     }
     /**
      * Infer the shape of data frames using abstract interpretation with {@link inferDataFrameShapes}
-     *
      * @returns The statistics of the data frame shape inference
      */
     inferDataFrameShapes() {
@@ -294,7 +293,6 @@ class BenchmarkSlicer {
         const ast = this.normalizedAst;
         const dfg = this.dataflow.graph;
         const cfinfo = this.controlFlow;
-        const config = this.config;
         const stats = {
             numberOfDataFrameFiles: 0,
             numberOfNonDataFrameFiles: 0,
@@ -308,20 +306,20 @@ class BenchmarkSlicer {
             sizeOfInfo: 0,
             perNodeStats: new Map()
         };
-        const result = this.measureSimpleStep('infer data frame shapes', () => (0, shape_inference_1.inferDataFrameShapes)(cfinfo, dfg, ast, config));
-        stats.numberOfResultConstraints = result.size;
-        for (const value of result.values()) {
-            if ((0, domain_1.equalDataFrameDomain)(value, domain_1.DataFrameTop)) {
+        const result = this.measureSimpleStep('infer data frame shapes', () => (0, shape_inference_1.inferDataFrameShapes)(cfinfo, dfg, ast, this.context));
+        stats.numberOfResultConstraints = result.value.size;
+        for (const value of result.value.values()) {
+            if (value.isTop()) {
                 stats.numberOfResultingTop++;
             }
-            else if ((0, domain_1.equalDataFrameDomain)(value, domain_1.DataFrameBottom)) {
+            else if (value.isBottom()) {
                 stats.numberOfResultingBottom++;
             }
             else {
                 stats.numberOfResultingValues++;
             }
         }
-        (0, visitor_1.visitAst)(this.normalizedAst.ast, (node) => {
+        (0, visitor_1.visitAst)(this.normalizedAst.ast.files.map(f => f.root), (node) => {
             if (node.info.dataFrame === undefined) {
                 return;
             }
@@ -334,17 +332,17 @@ class BenchmarkSlicer {
                 return;
             }
             const nodeStats = {
-                numberOfEntries: node.info.dataFrame?.domain?.size ?? 0
+                numberOfEntries: node.info.dataFrame?.domain?.value.size ?? 0
             };
             if (expression !== undefined) {
                 nodeStats.mappedOperations = expression.operations.map(op => op.operation);
                 stats.numberOfOperationNodes++;
                 if (value !== undefined) {
-                    nodeStats.inferredColNames = value.colnames === domain_1.ColNamesTop ? 'top' : value.colnames.length;
+                    nodeStats.inferredColNames = value.colnames.isValue() ? value.colnames.value.size : value.colnames.isTop() ? 'top' : 'bottom';
                     nodeStats.inferredColCount = this.getInferredSize(value.cols);
                     nodeStats.inferredRowCount = this.getInferredSize(value.rows);
-                    nodeStats.approxRangeColCount = value.cols === domain_1.IntervalBottom ? 0 : value.cols[1] - value.cols[0];
-                    nodeStats.approxRangeRowCount = value.rows === domain_1.IntervalBottom ? 0 : value.rows[1] - value.rows[0];
+                    nodeStats.approxRangeColCount = value.cols.isValue() ? value.cols.value[1] - value.cols.value[0] : 0;
+                    nodeStats.approxRangeRowCount = value.rows.isValue() ? value.rows.value[1] - value.rows.value[0] : 0;
                 }
             }
             if (value !== undefined) {
@@ -362,16 +360,16 @@ class BenchmarkSlicer {
         return stats;
     }
     getInferredSize(value) {
-        if ((0, domain_1.equalInterval)(value, domain_1.IntervalTop)) {
+        if (value.isTop()) {
             return 'top';
         }
-        else if (value === domain_1.IntervalBottom) {
-            return 'bottom';
-        }
-        else if (!isFinite(value[1])) {
+        else if (value.isValue() && !isFinite(value.value[1])) {
             return 'infinite';
         }
-        return Math.floor((value[0] + value[1]) / 2);
+        else if (value.isValue()) {
+            return Math.floor((value.value[0] + value.value[1]) / 2);
+        }
+        return 'bottom';
     }
     /** Bridging the gap between the new internal and the old names for the benchmarking */
     async measureCommonStep(expectedStep, keyToMeasure) {
@@ -410,9 +408,7 @@ class BenchmarkSlicer {
      * See {@link collectAllSlicingCriteria} for details.
      * <p>
      * the `report` function will be called *before* each *individual* slice is performed.
-     *
      * @returns The number of slices that were produced
-     *
      * @see collectAllSlicingCriteria
      * @see SlicingCriteriaFilter
      */

package/benchmark/stats/print.d.ts

@@ -1,8 +1,14 @@
 import type { SummarizedSlicerStats, UltimateSlicerStats } from '../summarizer/data';
+/**
+ * Formats the given nanoseconds into a human-readable string.
+ */
 export declare function formatNanoseconds(nanoseconds: bigint | number): string;
 /**
  * Converts the given stats to a human-readable string.
  * You may have to {@link summarizeSlicerStats | summarize} the stats first.
  */
 export declare function stats2string(stats: SummarizedSlicerStats): string;
+/**
+ * Converts reduction stats to a human-readable string.
+ */
 export declare function ultimateStats2String(stats: UltimateSlicerStats): string;

package/benchmark/stats/print.js

@@ -8,6 +8,9 @@ const padSize = 15;
 function pad(string) {
     return String(string).padStart(padSize, ' ');
 }
+/**
+ * Formats the given nanoseconds into a human-readable string.
+ */
 function formatNanoseconds(nanoseconds) {
     if (nanoseconds < 0) {
         return '??';
@@ -186,6 +189,9 @@ Dataframe shape inference:
     }
     return result;
 }
+/**
+ * Converts reduction stats to a human-readable string.
+ */
 function ultimateStats2String(stats) {
     let result = `
 Summarized: ${stats.totalRequests} requests and ${stats.totalSlices} slices