@eagleoutice/flowr 2.6.1 → 2.6.2

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

@@ -1,33 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntervalDomain = void 0;
+exports.IntervalDomain = exports.IntervalTop = void 0;
+const assert_1 = require("../../util/assert");
+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 interval domain as interval [-∞, +∞] */
+exports.IntervalTop = [-Infinity, +Infinity];
 /**
  * The interval abstract domain as intervals with possibly infinite bounds representing possible numeric values.
  * The Bottom element is defined as {@link Bottom} symbol and the Top element is defined as the interval [-∞, +∞].
  * @template Value - Type of the constraint in the abstract domain (Top, Bottom, or an actual value)
  */
-class IntervalDomain {
-    _value;
+class IntervalDomain extends abstract_domain_1.AbstractDomain {
     constructor(value) {
         if (Array.isArray(value)) {
             if (value.some(isNaN) || value[0] > value[1] || value[0] === +Infinity || value[1] === -Infinity) {
-                this._value = lattice_1.Bottom;
+                super(lattice_1.Bottom);
             }
             else {
-                this._value = [value[0], value[1]];
+                super([value[0], value[1]]);
             }
         }
         else {
-            this._value = value;
+            super(value);
         }
     }
-    get value() {
-        return this._value;
+    create(value) {
+        return new IntervalDomain(value);
     }
     static top() {
-        return new IntervalDomain([-Infinity, +Infinity]);
+        return new IntervalDomain(exports.IntervalTop);
     }
     static bottom() {
         return new IntervalDomain(lattice_1.Bottom);
@@ -53,45 +58,39 @@ class IntervalDomain {
     leq(other) {
         return this.value === lattice_1.Bottom || (other.isValue() && other.value[0] <= this.value[0] && this.value[1] <= other.value[1]);
     }
-    join(...values) {
-        const result = new IntervalDomain(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 {
-                result._value = [Math.min(result.value[0], other.value[0]), Math.max(result.value[1], other.value[1])];
-            }
+    join(other) {
+        const otherValue = other instanceof IntervalDomain ? 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 {
+            return this.create([Math.min(this.value[0], otherValue[0]), Math.max(this.value[1], otherValue[1])]);
         }
-        return result;
     }
-    meet(...values) {
-        const result = new IntervalDomain(this.value);
-        for (const other of values) {
-            if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
-                result._value = lattice_1.Bottom;
-            }
-            else if (Math.max(this.value[0], other.value[0]) > Math.min(this.value[1], other.value[1])) {
-                result._value = lattice_1.Bottom;
-            }
-            else {
-                result._value = [Math.max(this.value[0], other.value[0]), Math.min(this.value[1], other.value[1])];
-            }
+    meet(other) {
+        const otherValue = other instanceof IntervalDomain ? other.value : other;
+        if (this.value === lattice_1.Bottom || otherValue === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        else if (Math.max(this.value[0], otherValue[0]) > Math.min(this.value[1], otherValue[1])) {
+            return this.bottom();
+        }
+        else {
+            return this.create([Math.max(this.value[0], otherValue[0]), Math.min(this.value[1], otherValue[1])]);
         }
-        return result;
     }
     widen(other) {
         if (this.value === lattice_1.Bottom) {
-            return new IntervalDomain(other.value);
+            return this.create(other.value);
         }
         else if (other.value === lattice_1.Bottom) {
-            return new IntervalDomain(this.value);
+            return this.create(this.value);
         }
         else {
-            return new IntervalDomain([
+            return this.create([
                 this.value[0] <= other.value[0] ? this.value[0] : -Infinity,
                 this.value[1] >= other.value[1] ? this.value[1] : +Infinity
             ]);
@@ -101,12 +100,15 @@ class IntervalDomain {
         if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
             return this.bottom();
         }
-        return new IntervalDomain([
+        else if (Math.max(this.value[0], other.value[0]) > Math.min(this.value[1], other.value[1])) {
+            return this.bottom();
+        }
+        return this.create([
             this.value[0] === -Infinity ? other.value[0] : this.value[0],
             this.value[1] === +Infinity ? other.value[1] : this.value[1]
         ]);
     }
-    concretize(limit = abstract_domain_1.DEFAULT_INFERENCE_LIMIT) {
+    concretize(limit) {
         if (this.value === lattice_1.Bottom) {
             return new Set();
         }
@@ -122,48 +124,99 @@ class IntervalDomain {
     abstract(concrete) {
         return IntervalDomain.abstract(concrete);
     }
+    satisfies(value, comparator = satisfiable_domain_1.NumericalComparator.Equal) {
+        switch (comparator) {
+            case satisfiable_domain_1.NumericalComparator.Equal: {
+                if (this.isValue() && this.value[0] <= value && value <= this.value[1]) {
+                    return this.value[0] === this.value[1] ? logic_1.Ternary.Always : logic_1.Ternary.Maybe;
+                }
+                else {
+                    return logic_1.Ternary.Never;
+                }
+            }
+            case satisfiable_domain_1.NumericalComparator.Less: {
+                if (this.isValue() && value < this.value[1]) {
+                    return value < this.value[0] ? logic_1.Ternary.Always : logic_1.Ternary.Maybe;
+                }
+                else {
+                    return logic_1.Ternary.Never;
+                }
+            }
+            case satisfiable_domain_1.NumericalComparator.LessOrEqual: {
+                if (this.isValue() && value <= this.value[1]) {
+                    return value <= this.value[0] ? logic_1.Ternary.Always : logic_1.Ternary.Maybe;
+                }
+                else {
+                    return logic_1.Ternary.Never;
+                }
+            }
+            case satisfiable_domain_1.NumericalComparator.Greater: {
+                if (this.isValue() && this.value[0] <= value) {
+                    return this.value[1] <= value ? logic_1.Ternary.Always : logic_1.Ternary.Maybe;
+                }
+                else {
+                    return logic_1.Ternary.Never;
+                }
+            }
+            case satisfiable_domain_1.NumericalComparator.GreaterOrEqual: {
+                if (this.isValue() && this.value[0] < value) {
+                    return this.value[1] < value ? logic_1.Ternary.Always : logic_1.Ternary.Maybe;
+                }
+                else {
+                    return logic_1.Ternary.Never;
+                }
+            }
+            default: {
+                (0, assert_1.assertUnreachable)(comparator);
+            }
+        }
+    }
     /**
      * Adds another abstract value to the current abstract value by adding the two lower and upper bounds, respectively.
      */
     add(other) {
-        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+        const otherValue = other instanceof IntervalDomain ? other.value : other;
+        if (this.value === lattice_1.Bottom || otherValue === lattice_1.Bottom) {
             return this.bottom();
         }
         else {
-            return new IntervalDomain([this.value[0] + other.value[0], this.value[1] + other.value[1]]);
+            return this.create([this.value[0] + otherValue[0], this.value[1] + otherValue[1]]);
         }
     }
     /**
      * Subtracts another abstract value from the current abstract value by subtracting the two lower and upper bounds from each other, respectively.
      */
     subtract(other) {
-        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+        const otherValue = other instanceof IntervalDomain ? other.value : other;
+        if (this.value === lattice_1.Bottom || otherValue === lattice_1.Bottom) {
             return this.bottom();
         }
         else {
-            return new IntervalDomain([this.value[0] - other.value[0], this.value[1] - other.value[1]]);
+            return this.create([this.value[0] - otherValue[0], this.value[1] - otherValue[1]]);
         }
     }
     /**
      * Creates the minimum between the current abstract value and another abstract value by creating the minimum of the two lower and upper bounds, respectively.
      */
     min(other) {
-        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+        const otherValue = other instanceof IntervalDomain ? other.value : other;
+        if (this.value === lattice_1.Bottom || otherValue === lattice_1.Bottom) {
             return this.bottom();
         }
         else {
-            return new IntervalDomain([Math.min(this.value[0], other.value[0]), Math.min(this.value[1], other.value[1])]);
+            return this.create([Math.min(this.value[0], otherValue[0]), Math.min(this.value[1], otherValue[1])]);
         }
     }
     /**
      * Creates the maximum between the current abstract value and another abstract value by creating the maximum of the two lower and upper bounds, respectively.
      */
     max(other) {
-        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+        const otherValue = other instanceof IntervalDomain ? other.value : other;
+        if (this.value === lattice_1.Bottom || otherValue === lattice_1.Bottom) {
             return this.bottom();
         }
         else {
-            return new IntervalDomain([Math.max(this.value[0], other.value[0]), Math.max(this.value[1], other.value[1])]);
+            return this.create([Math.max(this.value[0], otherValue[0]), Math.max(this.value[1], otherValue[1])]);
         }
     }
     /**
@@ -174,7 +227,7 @@ class IntervalDomain {
             return this.bottom();
         }
         else {
-            return new IntervalDomain([-Infinity, this.value[1]]);
+            return this.create([-Infinity, this.value[1]]);
         }
     }
     /**
@@ -185,8 +238,14 @@ class IntervalDomain {
             return this.bottom();
         }
         else {
-            return new IntervalDomain([this.value[0], +Infinity]);
+            return this.create([this.value[0], +Infinity]);
+        }
+    }
+    toJson() {
+        if (this.value === lattice_1.Bottom) {
+            return this.value.description;
         }
+        return this.value;
     }
     toString() {
         if (this.value === lattice_1.Bottom) {

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

@@ -9,39 +9,47 @@ export declare const Bottom: unique symbol;
 /**
  * A complete lattice with a partially ordered set, join operator (LUB), meet operator (GLB), top element, and bottom element (e.g. for abstract domains).
  * @template Value - Type of a lattice element representing a value (may exclude `Top` and `Bot`)
- * @template Top   - Type of the Top element (greatest element) of the complete lattice (defaults to {@link Top})
- * @template Bot   - Type of the Bottom element (least element) of the complete lattice (defaults to {@link Bottom})
+ * @template Top   - Type of the Top element (greatest element) of the complete lattice
+ * @template Bot   - Type of the Bottom element (least element) of the complete lattice
  * @template Lift  - Type of the lattice elements (defaults to `Value` or `Top` or `Bot`)
  */
-export interface Lattice<Value, Top = typeof Top, Bot = typeof Bottom, Lift extends Value | Top | Bot = Value | Top | Bot> {
+export interface Lattice<Value, Top, Bot, Lift extends Value | Top | Bot = Value | Top | Bot> {
     /**
      * The current abstract value of the lattice.
      */
     get value(): Lift;
+    /**
+     * Creates an abstract value of the lattice for a given value.
+     */
+    create(value: Value | Top | Bot): this;
     /**
      * Gets the Top element (greatest element) of the complete lattice (should additionally be provided as static function).
      */
-    top(): Lattice<Value, Top, Bot, Top>;
+    top(): this & Lattice<Value, Top, Bot, Top>;
     /**
      * Gets the Bottom element (least element) of the complete lattice (should additionally be provided as static function).
      */
-    bottom(): Lattice<Value, Top, Bot, Bot>;
+    bottom(): this & Lattice<Value, Top, Bot, Bot>;
     /**
      * Checks whether the current abstract value equals to another abstract value.
      */
-    equals(other: Lattice<Value, Top, Bot>): boolean;
+    equals(other: this): boolean;
     /**
      * Checks whether the current abstract value is less than or equal to another abstract value with respect to the partial order of the lattice.
      */
-    leq(other: Lattice<Value, Top, Bot>): boolean;
+    leq(other: this): boolean;
+    /**
+     * Joins the current abstract value with another abstract value by creating the least upper bound (LUB) in the lattice.
+     */
+    join(other: this): this;
     /**
-     * Joins the current abstract value with other abstract values by creating the least upper bound (LUB) in the lattice.
+     * Meets the current abstract value with another abstract value by creating the greatest lower bound (GLB) in the lattice.
      */
-    join(...values: Lattice<Value, Top, Bot>[]): Lattice<Value, Top, Bot>;
+    meet(other: this): this;
     /**
-     * Meets the current abstract value with other abstract values by creating the greatest lower bound (GLB) in the lattice.
+     * Converts the lattice into a JSON serializable value.
      */
-    meet(...values: Lattice<Value, Top, Bot>[]): Lattice<Value, Top, Bot>;
+    toJson(): unknown;
     /**
      * Converts the lattice into a human-readable string.
      */

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

@@ -0,0 +1,34 @@
+import { AbstractDomain, type AnyAbstractDomain, type ConcreteDomain } from './abstract-domain';
+import { Top } from './lattice';
+/** The type of the concrete mapping of the concrete domain of a mapped abstract domain mapping keys to a concrete value in the concrete domain */
+type ConcreteMap<Key, Domain extends AnyAbstractDomain> = ReadonlyMap<Key, ConcreteDomain<Domain>>;
+/**
+ * A mapped abstract domain as mapping of keys 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 key to Top.
+ * @template Key       - Type of the keys of the mapping to abstract values
+ * @template Domain    - Type of the abstract domain to map the keys to
+ */
+export declare abstract class MappedAbstractDomain<Key, Domain extends AnyAbstractDomain> extends AbstractDomain<ConcreteMap<Key, Domain>, ReadonlyMap<Key, Domain>, ReadonlyMap<Key, Domain>, ReadonlyMap<Key, Domain>> {
+    constructor(value: ReadonlyMap<Key, Domain>);
+    abstract create(value: ReadonlyMap<Key, Domain>): this;
+    get(key: Key): Domain | undefined;
+    has(key: Key): boolean;
+    set(key: Key, value: Domain): void;
+    protected remove(key: Key): void;
+    bottom(): this;
+    top(): this;
+    equals(other: this): boolean;
+    leq(other: this): boolean;
+    join(other: this): this;
+    meet(other: this): this;
+    widen(other: this): this;
+    narrow(other: this): this;
+    concretize(limit: number): ReadonlySet<ConcreteMap<Key, Domain>> | typeof Top;
+    abstract(concrete: ReadonlySet<ConcreteMap<Key, Domain>> | typeof Top): this;
+    toJson(): unknown;
+    toString(): string;
+    isTop(): this is this;
+    isBottom(): this is this;
+    isValue(): this is this;
+}
+export {};

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

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MappedAbstractDomain = void 0;
+const abstract_domain_1 = require("./abstract-domain");
+const lattice_1 = require("./lattice");
+/**
+ * A mapped abstract domain as mapping of keys 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 key to Top.
+ * @template Key       - Type of the keys of the mapping to abstract values
+ * @template Domain    - Type of the abstract domain to map the keys to
+ */
+class MappedAbstractDomain extends abstract_domain_1.AbstractDomain {
+    constructor(value) {
+        super(new Map(value));
+    }
+    get(key) {
+        return this._value.get(key);
+    }
+    has(key) {
+        return this._value.has(key);
+    }
+    set(key, value) {
+        this._value.set(key, value);
+    }
+    remove(key) {
+        this._value.delete(key);
+    }
+    bottom() {
+        return this.create(new Map());
+    }
+    top() {
+        const result = this.create(this.value);
+        for (const [key, value] of result.value) {
+            result.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 [key, value] of this.value) {
+            const otherValue = other.get(key);
+            if (otherValue === undefined || !value.equals(otherValue)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    leq(other) {
+        if (this.value === other.value) {
+            return true;
+        }
+        else if (this.value.size > other.value.size) {
+            return false;
+        }
+        for (const [key, value] of this.value) {
+            const otherValue = other.get(key);
+            if (otherValue === undefined || !value.leq(otherValue)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    join(other) {
+        const result = this.create(this.value);
+        for (const [key, value] of other.value) {
+            const currValue = result.get(key);
+            if (currValue === undefined) {
+                result.set(key, value);
+            }
+            else {
+                result.set(key, currValue.join(value));
+            }
+        }
+        return result;
+    }
+    meet(other) {
+        const result = this.create(this.value);
+        for (const [key] of result.value) {
+            if (!other.has(key)) {
+                result.remove(key);
+            }
+        }
+        for (const [key, value] of other.value) {
+            const currValue = result.get(key);
+            if (currValue !== undefined) {
+                result.set(key, currValue.meet(value));
+            }
+        }
+        return result;
+    }
+    widen(other) {
+        const result = this.create(this.value);
+        for (const [key, value] of other.value) {
+            const currValue = result.get(key);
+            if (currValue === undefined) {
+                result.set(key, value);
+            }
+            else {
+                result.set(key, currValue.widen(value));
+            }
+        }
+        return result;
+    }
+    narrow(other) {
+        const result = this.create(this.value);
+        for (const [key] of this.value) {
+            if (!other.has(key)) {
+                result.remove(key);
+            }
+        }
+        for (const [key, value] of other.value) {
+            const currValue = result.get(key);
+            if (currValue !== undefined) {
+                result.set(key, currValue.narrow(value));
+            }
+        }
+        return result;
+    }
+    concretize(limit) {
+        if (this.value.values().some(value => value.isBottom())) {
+            return new Set();
+        }
+        let states = new Set([new Map()]);
+        for (const [key, 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(key, concrete);
+                    newStates.add(map);
+                }
+            }
+            states = newStates;
+        }
+        return states;
+    }
+    abstract(concrete) {
+        const entry = [...this.value.values()][0];
+        if (concrete === lattice_1.Top || entry === undefined) {
+            return this.create(new Map());
+        }
+        const mappings = new Map();
+        for (const state of concrete) {
+            for (const [key, value] of state) {
+                const mapping = mappings.get(key);
+                if (mapping === undefined) {
+                    mappings.set(key, new Set([value]));
+                }
+                else {
+                    mapping.add(value);
+                }
+            }
+        }
+        const result = new Map();
+        for (const [key, values] of mappings) {
+            result.set(key, entry.abstract(values));
+        }
+        return this.create(result);
+    }
+    toJson() {
+        return Object.fromEntries(this.value.entries().map(([key, value]) => [key, value.toJson()]));
+    }
+    toString() {
+        return '(' + this.value.entries().toArray().map(([key, value]) => `${(0, abstract_domain_1.domainElementToString)(key)} -> ${value.toString()}`).join(', ') + ')';
+    }
+    isTop() {
+        return this.value.size > 0 && this.value.values().every(value => value.isTop());
+    }
+    isBottom() {
+        return this.value.size === 0;
+    }
+    isValue() {
+        return true;
+    }
+}
+exports.MappedAbstractDomain = MappedAbstractDomain;
+//# sourceMappingURL=mapped-abstract-domain.js.map

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

@@ -1,13 +1,15 @@
 import { IntervalDomain } from './interval-domain';
 import { Bottom, Top } from './lattice';
+/** The Top element of the positive interval domain as interval [0, +∞] */
+export declare const PosIntervalTop: PosIntervalValue;
 /** The type of the actual values of the positive interval domain as tuple of the lower and upper bound */
-export type PosIntervalValue = readonly [number, number];
-/** The type of the Top element of the positive interval domain as interval [0, +∞] from 0 to +∞ */
-export type PosIntervalTop = readonly [0, typeof Infinity];
+type PosIntervalValue = readonly [lower: number, upper: number];
+/** The type of the Top element of the positive interval domain as interval [0, +∞] */
+type PosIntervalTop = typeof PosIntervalTop;
 /** The type of the Bottom element of the positive interval domain as {@link Bottom} symbol */
-export type PosIntervalBottom = typeof Bottom;
+type PosIntervalBottom = typeof Bottom;
 /** The type of the abstract values of the positive interval domain that are Top, Bottom, or actual values */
-export type PosIntervalLift = PosIntervalValue | PosIntervalTop | PosIntervalBottom;
+type PosIntervalLift = PosIntervalValue | PosIntervalBottom;
 /**
  * The positive interval abstract domain as positive intervals with possibly zero lower bounds and infinite upper bounds representing possible numeric values.
  * The Bottom element is defined as {@link Bottom} symbol and the Top element is defined as the interval [0, +∞].
@@ -15,18 +17,20 @@ export type PosIntervalLift = PosIntervalValue | PosIntervalTop | PosIntervalBot
  */
 export declare class PosIntervalDomain<Value extends PosIntervalLift = PosIntervalLift> extends IntervalDomain<Value> {
     constructor(value: Value);
+    create(value: PosIntervalLift): this;
     static top(): PosIntervalDomain<PosIntervalTop>;
     static bottom(): PosIntervalDomain<PosIntervalBottom>;
     static abstract(concrete: ReadonlySet<number> | typeof Top): PosIntervalDomain;
-    top(): PosIntervalDomain<PosIntervalTop>;
-    bottom(): PosIntervalDomain<PosIntervalBottom>;
-    widen(other: PosIntervalDomain): PosIntervalDomain;
-    narrow(other: PosIntervalDomain): PosIntervalDomain;
-    abstract(concrete: ReadonlySet<number> | typeof Top): PosIntervalDomain;
-    subtract(other: PosIntervalDomain): PosIntervalDomain;
+    top(): this & PosIntervalDomain<PosIntervalTop>;
+    bottom(): this & PosIntervalDomain<PosIntervalBottom>;
+    widen(other: this): this;
+    narrow(other: this): this;
+    abstract(concrete: ReadonlySet<number> | typeof Top): this;
+    subtract(other: this | PosIntervalLift): this;
     /**
      * Extends the lower bound of the current abstract value down to 0.
      */
-    extendDown(): PosIntervalDomain;
+    extendDown(): this;
     isTop(): this is PosIntervalDomain<PosIntervalTop>;
 }
+export {};