@eagleoutice/flowr 2.6.2 → 2.7.0

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

@@ -10,7 +10,7 @@ export interface SatisfiableDomain<T> {
     satisfies(value: T): Ternary;
 }
 /**
- * Represents the different types of numerical comparators for satifiability checks for an abstract domain.
+ * Represents the different types of numerical comparators for satisfiability checks for an abstract domain.
  */
 export declare enum NumericalComparator {
     Equal = 0,
@@ -20,7 +20,7 @@ export declare enum NumericalComparator {
     GreaterOrEqual = 4
 }
 /**
- * Represents the different types of set comparators for satifiability checks for an abstract domain.
+ * Represents the different types of set comparators for satisfiability checks for an abstract domain.
  */
 export declare enum SetComparator {
     Equal = 0,

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SetComparator = exports.NumericalComparator = void 0;
 /**
- * Represents the different types of numerical comparators for satifiability checks for an abstract domain.
+ * Represents the different types of numerical comparators for satisfiability checks for an abstract domain.
  */
 var NumericalComparator;
 (function (NumericalComparator) {
@@ -13,7 +13,7 @@ var NumericalComparator;
     NumericalComparator[NumericalComparator["GreaterOrEqual"] = 4] = "GreaterOrEqual";
 })(NumericalComparator || (exports.NumericalComparator = NumericalComparator = {}));
 /**
- * Represents the different types of set comparators for satifiability checks for an abstract domain.
+ * Represents the different types of set comparators for satisfiability checks for an abstract domain.
  */
 var SetComparator;
 (function (SetComparator) {

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

@@ -0,0 +1,98 @@
+import { Ternary } from '../../util/logic';
+import { AbstractDomain } from './abstract-domain';
+import { Bottom, Top } from './lattice';
+import type { SatisfiableDomain } from './satisfiable-domain';
+import { SetComparator } from './satisfiable-domain';
+/** The Top element of the set range domain with an empty set as minimum set and {@link Top} as range set */
+export declare const SetRangeTop: {
+    readonly min: Set<never>;
+    readonly range: typeof Top;
+};
+/** The type of the actual values of the set range domain as tuple with a minimum set and range set of additional possible values (i.e. `[{"id","name"}, ∅]`, or `[{"id"}, {"score"}]`) */
+type SetRangeValue<T> = {
+    readonly min: ReadonlySet<T>;
+    readonly range: ReadonlySet<T> | typeof Top;
+};
+/** The type of the Top element of the set range domain as tuple with the empty set as minimum set and {@link Top} as range set (i.e. `[∅, Top]`) */
+type SetRangeTop = typeof SetRangeTop;
+/** The type of the Bottom element of the set range domain as {@link Bottom} */
+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 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[];
+    readonly range: T[] | typeof Top;
+};
+/** The type for the maximum number of elements in the minimum set and maximum set of the set range domain before over-approximation */
+export type SetRangeLimit = {
+    readonly min: number;
+    readonly range: number;
+};
+/**
+ * The set range abstract domain as range of possible value sets with a minimum set of values and a range of possible additional values
+ * (similar to an interval like structure with a lower bound and a difference to the upper bound).
+ * The Bottom element is defined as {@link Bottom} symbol and the Top element is defined as the range `[∅, Top]` where the minimum set is the empty set and the range is {@link Top}.
+ * @template T     - Type of the values in the sets in the abstract domain
+ * @template Value - Type of the constraint in the abstract domain (Top, Bottom, or an actual value)
+ */
+export declare class SetRangeDomain<T, Value extends SetRangeLift<T> = SetRangeLift<T>> extends AbstractDomain<ReadonlySet<T>, SetRangeValue<T>, SetRangeTop, SetRangeBottom, Value> implements SatisfiableDomain<ReadonlySet<T>> {
+    readonly limit: SetRangeLimit;
+    private readonly setType;
+    /**
+     * @param limit -  A limit for the maximum number of elements to store in the minimum set and maximum set before over-approximation
+     * @param newSet - An optional set constructor for the domain elements if the type `T` is not storable in a HashSet
+     */
+    constructor(value: Value | ArrayRangeValue<T>, limit?: SetRangeLimit | number, setType?: typeof Set<T>);
+    create(value: SetRangeLift<T> | ArrayRangeValue<T>): this;
+    /**
+     * 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;
+    /**
+     * 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;
+    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>;
+    top(): this & SetRangeDomain<T, SetRangeTop>;
+    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;
+    meet(other: SetRangeLift<T> | ArrayRangeValue<T>): this;
+    /**
+     * Creates the union of this abstract value and another abstract value by creating the union of the minimum and maximum set, respectively.
+     */
+    union(other: this | SetRangeLift<T> | ArrayRangeValue<T>): this;
+    /**
+     * Creates the intersection of this abstract value and another abstract value by creating the intersection of the minimum and maximum set, respectively.
+     */
+    intersect(other: this | SetRangeLift<T> | ArrayRangeValue<T>): this;
+    /**
+     * Subtracts another abstract value from the current abstract value by removing all elements of the other abstract value from the current abstract value.
+     */
+    subtract(other: this | SetRangeLift<T> | ArrayRangeValue<T>): this;
+    widen(other: this): this;
+    narrow(other: this): this;
+    concretize(limit: number): ReadonlySet<ReadonlySet<T>> | typeof Top;
+    abstract(concrete: ReadonlySet<ReadonlySet<T>> | typeof Top): this;
+    satisfies(set: ReadonlySet<T> | T[], comparator?: SetComparator): Ternary;
+    /**
+     * Extends the minimum set of the current abstract value down to the empty set.
+     */
+    widenDown(): this;
+    /**
+     * Extends the maximum set of the current abstract value up to {@link Top}.
+     */
+    widenUp(): this;
+    toJson(): unknown;
+    toString(): string;
+    isTop(): this is SetRangeDomain<T, SetRangeTop>;
+    isBottom(): this is SetRangeDomain<T, SetRangeBottom>;
+    isValue(): this is SetRangeDomain<T, SetRangeValue<T>>;
+}
+export {};

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

@@ -0,0 +1,400 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetRangeDomain = exports.SetRangeTop = void 0;
+const assert_1 = require("../../util/assert");
+const set_1 = require("../../util/collections/set");
+const logic_1 = require("../../util/logic");
+const abstract_domain_1 = require("./abstract-domain");
+const lattice_1 = require("./lattice");
+const satisfiable_domain_1 = require("./satisfiable-domain");
+/* eslint-disable @typescript-eslint/unified-signatures */
+/** The Top element of the set range domain with an empty set as minimum set and {@link Top} as range set */
+exports.SetRangeTop = { min: new Set(), range: lattice_1.Top };
+const DefaultLimit = { min: abstract_domain_1.DEFAULT_INFERENCE_LIMIT, range: abstract_domain_1.DEFAULT_INFERENCE_LIMIT };
+/**
+ * The set range abstract domain as range of possible value sets with a minimum set of values and a range of possible additional values
+ * (similar to an interval like structure with a lower bound and a difference to the upper bound).
+ * The Bottom element is defined as {@link Bottom} symbol and the Top element is defined as the range `[∅, Top]` where the minimum set is the empty set and the range is {@link Top}.
+ * @template T     - Type of the values in the sets in the abstract domain
+ * @template Value - Type of the constraint in the abstract domain (Top, Bottom, or an actual value)
+ */
+class SetRangeDomain extends abstract_domain_1.AbstractDomain {
+    limit;
+    setType;
+    /**
+     * @param limit -  A limit for the maximum number of elements to store in the minimum set and maximum set before over-approximation
+     * @param newSet - An optional set constructor for the domain elements if the type `T` is not storable in a HashSet
+     */
+    constructor(value, limit = DefaultLimit, setType = Set) {
+        limit = typeof limit === 'number' ? { min: limit, range: limit } : limit;
+        if (value !== lattice_1.Bottom) {
+            const minSet = new setType(value.min);
+            const rangeSet = value.range === lattice_1.Top ? lattice_1.Top : new setType(value.range);
+            const minExceeds = minSet.size > limit.min;
+            const rangeExceeds = rangeSet === lattice_1.Top || rangeSet.size > limit.range || minSet.size + rangeSet.size > limit.min + limit.range;
+            const min = minExceeds ? new setType(minSet.values().take(limit.min)) : minSet;
+            const range = rangeExceeds ? lattice_1.Top : minSet.union(rangeSet).difference(min);
+            super({ min, range });
+        }
+        else {
+            super(value);
+        }
+        this.limit = limit;
+        this.setType = setType;
+    }
+    create(value) {
+        return new SetRangeDomain(value, this.limit, this.setType);
+    }
+    /**
+     * The minimum set (lower bound) of the set range representing all values that must exist (subset of {@link upper}).
+     */
+    lower() {
+        if (this.value === lattice_1.Bottom) {
+            return lattice_1.Bottom;
+        }
+        return this.value.min;
+    }
+    /**
+     * The maximum set (upper bound) of the set range representing all values that can possibly exist (union of {@link lower} and range).
+     */
+    upper() {
+        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);
+    }
+    static top(limit, setType) {
+        return new SetRangeDomain(exports.SetRangeTop, limit, setType);
+    }
+    static bottom(limit, setType) {
+        return new SetRangeDomain(lattice_1.Bottom, limit, setType);
+    }
+    static abstract(concrete, limit, setType) {
+        if (concrete === lattice_1.Top) {
+            return SetRangeDomain.top(limit, setType);
+        }
+        else if (concrete.size === 0) {
+            return SetRangeDomain.bottom(limit, setType);
+        }
+        const lower = concrete.values().reduce((result, set) => result.intersection(set));
+        const upper = concrete.values().reduce((result, set) => result.union(set));
+        return new SetRangeDomain({ min: lower, range: upper.difference(lower) }, limit, setType);
+    }
+    top() {
+        return SetRangeDomain.top(this.limit, this.setType);
+    }
+    bottom() {
+        return SetRangeDomain.bottom(this.limit, this.setType);
+    }
+    equals(other) {
+        if (this.value === other.value) {
+            return true;
+        }
+        else if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom || !(0, set_1.setEquals)(this.value.min, other.value.min)) {
+            return false;
+        }
+        else if (this.value.range === other.value.range) {
+            return true;
+        }
+        return this.value.range !== lattice_1.Top && other.value.range !== lattice_1.Top && (0, set_1.setEquals)(this.value.range, other.value.range);
+    }
+    leq(other) {
+        const thisLower = this.lower(), thisUpper = this.upper();
+        const otherLower = other.lower(), otherUpper = other.upper();
+        if (thisLower === lattice_1.Bottom || thisUpper === lattice_1.Bottom) {
+            return true;
+        }
+        else if (otherLower === lattice_1.Bottom || otherUpper === lattice_1.Bottom || !otherLower.isSubsetOf(thisLower)) {
+            return false;
+        }
+        else if (otherUpper === lattice_1.Top) {
+            return true;
+        }
+        return thisUpper !== lattice_1.Top && thisUpper.isSubsetOf(otherUpper);
+    }
+    join(other) {
+        other = other instanceof SetRangeDomain ? other : this.create(other);
+        const thisLower = this.lower(), thisUpper = this.upper();
+        const otherLower = other.lower(), otherUpper = other.upper();
+        if (thisLower === lattice_1.Bottom || thisUpper === lattice_1.Bottom) {
+            return this.create(other.value);
+        }
+        else if (otherLower === lattice_1.Bottom || otherUpper === lattice_1.Bottom) {
+            return this.create(this.value);
+        }
+        const joinLower = thisLower.intersection(otherLower);
+        let joinUpper;
+        if (thisUpper === lattice_1.Top || otherUpper === lattice_1.Top) {
+            joinUpper = lattice_1.Top;
+        }
+        else {
+            joinUpper = thisUpper.union(otherUpper);
+        }
+        return this.create({ min: joinLower, range: joinUpper === lattice_1.Top ? lattice_1.Top : joinUpper.difference(joinLower) });
+    }
+    meet(other) {
+        other = other instanceof SetRangeDomain ? other : this.create(other);
+        const thisLower = this.lower(), thisUpper = this.upper();
+        const otherLower = other.lower(), otherUpper = other.upper();
+        if (thisLower === lattice_1.Bottom || thisUpper === lattice_1.Bottom || otherLower === lattice_1.Bottom || otherUpper === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        const meetLower = thisLower.union(otherLower);
+        let meetUpper;
+        if (thisUpper === lattice_1.Top) {
+            meetUpper = otherUpper;
+        }
+        else if (otherUpper === lattice_1.Top) {
+            meetUpper = thisUpper;
+        }
+        else {
+            meetUpper = thisUpper.intersection(otherUpper);
+        }
+        if (meetUpper !== lattice_1.Top && !meetLower.isSubsetOf(meetUpper)) {
+            return this.bottom();
+        }
+        return this.create({ min: meetLower, range: meetUpper === lattice_1.Top ? lattice_1.Top : meetUpper.difference(meetLower) });
+    }
+    /**
+     * Creates the union of this abstract value and another abstract value by creating the union of the minimum and maximum set, respectively.
+     */
+    union(other) {
+        other = other instanceof SetRangeDomain ? other : this.create(other);
+        const thisLower = this.lower(), thisUpper = this.upper();
+        const otherLower = other.lower(), otherUpper = other.upper();
+        if (thisLower === lattice_1.Bottom || thisUpper === lattice_1.Bottom) {
+            return this.create(other.value);
+        }
+        else if (otherLower === lattice_1.Bottom || otherUpper === lattice_1.Bottom) {
+            return this.create(this.value);
+        }
+        const unionLower = thisLower.union(otherLower);
+        let unionUpper;
+        if (thisUpper === lattice_1.Top || otherUpper === lattice_1.Top) {
+            unionUpper = lattice_1.Top;
+        }
+        else {
+            unionUpper = thisUpper.union(otherUpper);
+        }
+        return this.create({ min: unionLower, range: unionUpper === lattice_1.Top ? lattice_1.Top : unionUpper.difference(unionLower) });
+    }
+    /**
+     * Creates the intersection of this abstract value and another abstract value by creating the intersection of the minimum and maximum set, respectively.
+     */
+    intersect(other) {
+        other = other instanceof SetRangeDomain ? other : this.create(other);
+        const thisLower = this.lower(), thisUpper = this.upper();
+        const otherLower = other.lower(), otherUpper = other.upper();
+        if (thisLower === lattice_1.Bottom || thisUpper === lattice_1.Bottom || otherLower === lattice_1.Bottom || otherUpper === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        const intersectLower = thisLower.intersection(otherLower);
+        let intersectUpper;
+        if (thisUpper === lattice_1.Top) {
+            intersectUpper = otherUpper;
+        }
+        else if (otherUpper === lattice_1.Top) {
+            intersectUpper = thisUpper;
+        }
+        else {
+            intersectUpper = thisUpper.intersection(otherUpper);
+        }
+        return this.create({ min: intersectLower, range: intersectUpper === lattice_1.Top ? lattice_1.Top : intersectUpper.difference(intersectLower) });
+    }
+    /**
+     * Subtracts another abstract value from the current abstract value by removing all elements of the other abstract value from the current abstract value.
+     */
+    subtract(other) {
+        other = other instanceof SetRangeDomain ? other : this.create(other);
+        const thisLower = this.lower(), thisUpper = this.upper();
+        const otherLower = other.lower(), otherUpper = other.upper();
+        if (thisLower === lattice_1.Bottom || thisUpper === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        else if (otherLower === lattice_1.Bottom || otherUpper === lattice_1.Bottom) {
+            return this.create(this.value);
+        }
+        let subLower;
+        if (otherUpper === lattice_1.Top) {
+            subLower = new Set();
+        }
+        else {
+            subLower = thisLower.difference(otherUpper);
+        }
+        let subUpper;
+        if (thisUpper === lattice_1.Top) {
+            subUpper = lattice_1.Top;
+        }
+        else if (otherUpper === lattice_1.Top) {
+            subUpper = thisUpper.difference(otherLower);
+        }
+        else {
+            subUpper = thisUpper.difference(otherUpper);
+        }
+        return this.create({ min: subLower, range: subUpper === lattice_1.Top ? lattice_1.Top : subUpper.difference(subLower) });
+    }
+    widen(other) {
+        const thisLower = this.lower(), thisUpper = this.upper();
+        const otherLower = other.lower(), otherUpper = other.upper();
+        if (thisLower === lattice_1.Bottom || thisUpper === lattice_1.Bottom) {
+            return this.create(other.value);
+        }
+        else if (otherLower === lattice_1.Bottom || otherUpper === lattice_1.Bottom) {
+            return this.create(this.value);
+        }
+        let widenLower;
+        if (!thisLower.isSubsetOf(otherLower)) {
+            widenLower = new Set();
+        }
+        else {
+            widenLower = thisLower;
+        }
+        let widenUpper;
+        if (thisUpper === lattice_1.Top || otherUpper === lattice_1.Top || !otherUpper.isSubsetOf(thisUpper)) {
+            widenUpper = lattice_1.Top;
+        }
+        else {
+            widenUpper = thisUpper;
+        }
+        return this.create({ min: widenLower, range: widenUpper === lattice_1.Top ? lattice_1.Top : widenUpper.difference(widenLower) });
+    }
+    narrow(other) {
+        const thisLower = this.lower(), thisUpper = this.upper();
+        const otherLower = other.lower(), otherUpper = other.upper();
+        if (thisLower === lattice_1.Bottom || thisUpper === lattice_1.Bottom || otherLower === lattice_1.Bottom || otherUpper === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        let meetUpper;
+        if (thisUpper === lattice_1.Top) {
+            meetUpper = otherUpper;
+        }
+        else if (otherUpper === lattice_1.Top) {
+            meetUpper = thisUpper;
+        }
+        else {
+            meetUpper = thisUpper.intersection(otherUpper);
+        }
+        if (meetUpper !== lattice_1.Top && !thisLower.union(otherLower).isSubsetOf(meetUpper)) {
+            return this.bottom();
+        }
+        let narrowLower;
+        if (thisLower.size === 0) {
+            narrowLower = otherLower;
+        }
+        else {
+            narrowLower = thisLower;
+        }
+        let narrowUpper;
+        if (thisUpper === lattice_1.Top) {
+            narrowUpper = otherUpper;
+        }
+        else {
+            narrowUpper = thisUpper;
+        }
+        return this.create({ min: narrowLower, range: narrowUpper === lattice_1.Top ? lattice_1.Top : narrowUpper.difference(narrowLower) });
+    }
+    concretize(limit) {
+        if (this.value === lattice_1.Bottom) {
+            return new Set();
+        }
+        else if (this.value.range === lattice_1.Top || 2 ** (this.value.range.size) > limit) {
+            return lattice_1.Top;
+        }
+        const subsets = [new this.setType()];
+        for (const element of this.value.range) {
+            const newSubsets = subsets.map(subset => new this.setType([...subset, element]));
+            for (const subset of newSubsets) {
+                subsets.push(subset);
+            }
+        }
+        return new Set(subsets.map(subset => this.value === lattice_1.Bottom ? subset : this.value.min.union(subset)));
+    }
+    abstract(concrete) {
+        return SetRangeDomain.abstract(concrete, this.limit);
+    }
+    satisfies(set, comparator = satisfiable_domain_1.SetComparator.Equal) {
+        const value = new this.setType(set);
+        const lower = this.lower(), upper = this.upper();
+        if (lower === lattice_1.Bottom || upper === lattice_1.Bottom) {
+            return logic_1.Ternary.Never;
+        }
+        switch (comparator) {
+            case satisfiable_domain_1.SetComparator.Equal: {
+                if (lower.isSubsetOf(value) && (upper === lattice_1.Top || value.isSubsetOf(upper))) {
+                    return upper !== lattice_1.Top && lower.size === upper.size ? logic_1.Ternary.Always : logic_1.Ternary.Maybe;
+                }
+                return logic_1.Ternary.Never;
+            }
+            case satisfiable_domain_1.SetComparator.SubsetOrEqual: {
+                if (upper === lattice_1.Top || value.isSubsetOf(upper)) {
+                    return value.isSubsetOf(lower) ? logic_1.Ternary.Always : logic_1.Ternary.Maybe;
+                }
+                return logic_1.Ternary.Never;
+            }
+            case satisfiable_domain_1.SetComparator.Subset: {
+                if (upper === lattice_1.Top || (value.isSubsetOf(upper) && !(0, set_1.setEquals)(value, upper))) {
+                    return value.isSubsetOf(lower) && !(0, set_1.setEquals)(value, lower) ? logic_1.Ternary.Always : logic_1.Ternary.Maybe;
+                }
+                return logic_1.Ternary.Never;
+            }
+            default: {
+                (0, assert_1.assertUnreachable)(comparator);
+            }
+        }
+    }
+    /**
+     * Extends the minimum set of the current abstract value down to the empty set.
+     */
+    widenDown() {
+        const upper = this.upper();
+        if (upper === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        else {
+            return this.create({ min: new this.setType(), range: upper });
+        }
+    }
+    /**
+     * Extends the maximum set of the current abstract value up to {@link Top}.
+     */
+    widenUp() {
+        const lower = this.lower();
+        if (lower === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        else {
+            return this.create({ min: lower, range: lattice_1.Top });
+        }
+    }
+    toJson() {
+        if (this.value === lattice_1.Bottom) {
+            return this.value.description;
+        }
+        const min = this.value.min.values().toArray();
+        const range = this.value.range === lattice_1.Top ? this.value.range.description : this.value.range.values().toArray();
+        return { min, range };
+    }
+    toString() {
+        if (this.value === lattice_1.Bottom) {
+            return lattice_1.BottomSymbol;
+        }
+        else if (this.value.range === lattice_1.Top) {
+            const minString = this.value.min.values().map(abstract_domain_1.domainElementToString).toArray().join(', ');
+            return `[{${minString}}, ${lattice_1.TopSymbol}]`;
+        }
+        const minString = this.value.min.values().map(abstract_domain_1.domainElementToString).toArray().join(', ');
+        const rangeString = this.value.range.values().map(abstract_domain_1.domainElementToString).toArray().join(', ');
+        return `[{${minString}}, {${rangeString}}]`;
+    }
+    isTop() {
+        return this.value !== lattice_1.Bottom && this.value.min.size === 0 && this.value.range === lattice_1.Top;
+    }
+    isBottom() {
+        return this.value === lattice_1.Bottom;
+    }
+    isValue() {
+        return this.value !== lattice_1.Bottom;
+    }
+}
+exports.SetRangeDomain = SetRangeDomain;
+//# sourceMappingURL=set-range-domain.js.map

package/abstract-interpretation/domains/set-upper-bound-domain.js

@@ -175,10 +175,10 @@ class SetUpperBoundDomain extends abstract_domain_1.AbstractDomain {
     }
     toString() {
         if (this.value === lattice_1.Top) {
-            return '⊤';
+            return lattice_1.TopSymbol;
         }
         else if (this.value === lattice_1.Bottom) {
-            return '⊥';
+            return lattice_1.BottomSymbol;
         }
         const string = this.value.values().map(abstract_domain_1.domainElementToString).toArray().join(', ');
         return `{${string}}`;

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

@@ -109,10 +109,10 @@ class SingletonDomain extends abstract_domain_1.AbstractDomain {
     }
     toString() {
         if (this.value === lattice_1.Top) {
-            return '⊤';
+            return lattice_1.TopSymbol;
         }
         else if (this.value === lattice_1.Bottom) {
-            return '⊥';
+            return lattice_1.BottomSymbol;
         }
         return (0, abstract_domain_1.domainElementToString)(this.value);
     }

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

@@ -25,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.
  */

package/benchmark/slicer.d.ts

@@ -58,6 +58,7 @@ export declare class BenchmarkSlicer {
     private readonly deltas;
     private readonly parserName;
     private config;
+    private context;
     private stats;
     private loadedXml;
     private dataflow;
@@ -105,7 +106,8 @@ export declare class BenchmarkSlicer {
      * @returns The statistics of the data frame shape inference
      */
     inferDataFrameShapes(): SlicerStatsDfShape;
-    private getInferredSize;
+    private getInferredRange;
+    private getInferredNumber;
     /** Bridging the gap between the new internal and the old names for the benchmarking */
     private measureCommonStep;
     private measureSimpleStep;