@eagleoutice/flowr 2.10.3 → 2.10.5

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

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractDomain = exports.DEFAULT_INFERENCE_LIMIT = void 0;
-exports.domainElementToString = domainElementToString;
-exports.isAbstractDomain = isAbstractDomain;
 const assert_1 = require("../../util/assert");
 const lattice_1 = require("./lattice");
 /**
@@ -62,31 +60,31 @@ class AbstractDomain {
         (0, assert_1.guard)(values.length > 0 || defaultValue !== undefined, 'Abstract values to meet cannot be empty');
         return values[0]?.meetAll(values.slice(1)) ?? defaultValue;
     }
-}
-exports.AbstractDomain = AbstractDomain;
-/**
- * Converts an element of an abstract domain into a string.
- */
-function domainElementToString(value) {
-    if (typeof value === 'object' && value !== null && value.toString !== Object.prototype.toString) {
-        // eslint-disable-next-line @typescript-eslint/no-base-to-string
-        return value.toString();
-    }
-    else if (value === lattice_1.Top) {
-        return lattice_1.TopSymbol;
-    }
-    else if (value === lattice_1.Bottom) {
-        return lattice_1.BottomSymbol;
-    }
-    return JSON.stringify(value);
-}
-/**
- * Checks whether a value is an abstract domain.
- */
-function isAbstractDomain(value) {
-    if (typeof value !== 'object' || value === null) {
-        return false;
+    /**
+     * Converts an element of an abstract domain into a string.
+     */
+    static toString(value) {
+        if (value instanceof Map) {
+            return `{${value.entries().map(([key, value]) => `${AbstractDomain.toString(key)} -> ${AbstractDomain.toString(value)}`).toArray().join(', ')}}`;
+        }
+        else if (value instanceof Set) {
+            return `{${value.values().map(AbstractDomain.toString).toArray().join(', ')}}`;
+        }
+        else if (typeof value === 'object' && value !== null && value.toString !== Object.prototype.toString) {
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string
+            return value.toString();
+        }
+        else if (Array.isArray(value)) {
+            return `[${value.map(AbstractDomain.toString).join(', ')}]`;
+        }
+        else if (value === lattice_1.Top) {
+            return lattice_1.TopSymbol;
+        }
+        else if (value === lattice_1.Bottom) {
+            return lattice_1.BottomSymbol;
+        }
+        return JSON.stringify(value);
     }
-    return ['value', 'top', 'bottom', 'leq', 'join', 'meet', 'widen', 'narrow', 'concretize', 'abstract'].every(property => property in value);
 }
+exports.AbstractDomain = AbstractDomain;
 //# sourceMappingURL=abstract-domain.js.map

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

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

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

@@ -0,0 +1,32 @@
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { type AbstractProduct, PartialProductDomain } from './partial-product-domain';
+import { type StateDomainLift, StateAbstractDomain } from './state-abstract-domain';
+/**
+ * A reduction function for abstract values of a product domain.
+ */
+export type Reduction<Product extends AbstractProduct> = (value: Product) => Product;
+/**
+ * A multi-value state abstract domain that maps AST node IDs to multiple abstract values from different abstract domains.
+ * @template Product - Type of the abstract product of the multi-value domain combining multiple abstract values
+ * @see {@link NodeId} for the node IDs of the AST nodes
+ */
+export declare class MultiValueStateDomain<Product extends AbstractProduct, Value extends StateDomainLift<MultiValueDomain<Product>> = StateDomainLift<MultiValueDomain<Product>>> extends StateAbstractDomain<MultiValueDomain<Product>, Value> {
+    constructor(value: Value, domain: Required<Product>, reductions?: readonly Reduction<Product>[]);
+    create(value: StateDomainLift<MultiValueDomain<Product>>): this;
+    getValue<Key extends keyof Product>(node: NodeId, property: Key): Product[Key] | undefined;
+    hasValue(node: NodeId, property: keyof Product): boolean;
+    setValue<Key extends keyof Product>(node: NodeId, property: Key, value: Product[Key]): void;
+}
+/**
+ * A multi-value abstract domain as a (partial) product domain that combines multiple abstract domains.
+ * The Bottom element is defined as mapping every sub abstract domain to Bottom and the Top element is defined as having no sub abstract domain value.
+ * @template Product - Type of the abstract product of the multi-value domain combining multiple abstract values
+ * @see {@link MultiValueStateDomain} for a state abstract domain of a multi-value domain
+ */
+export declare class MultiValueDomain<Product extends AbstractProduct> extends PartialProductDomain<Product> {
+    readonly reductions: readonly Reduction<Product>[];
+    constructor(value: Product, domain: Required<Product>, reductions?: readonly Reduction<Product>[]);
+    create(value: Product): this;
+    static top<Product extends AbstractProduct>(domain: Required<Product>, reductions?: readonly Reduction<Product>[]): MultiValueDomain<Product>;
+    protected reduce(value: Product): Product;
+}

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiValueDomain = exports.MultiValueStateDomain = void 0;
+const lattice_1 = require("./lattice");
+const partial_product_domain_1 = require("./partial-product-domain");
+const state_abstract_domain_1 = require("./state-abstract-domain");
+/**
+ * A multi-value state abstract domain that maps AST node IDs to multiple abstract values from different abstract domains.
+ * @template Product - Type of the abstract product of the multi-value domain combining multiple abstract values
+ * @see {@link NodeId} for the node IDs of the AST nodes
+ */
+class MultiValueStateDomain extends state_abstract_domain_1.StateAbstractDomain {
+    constructor(value, domain, reductions = []) {
+        super(value, new MultiValueDomain(domain, domain, reductions));
+    }
+    create(value) {
+        return new MultiValueStateDomain(value, this.domain.domain, this.domain.reductions);
+    }
+    getValue(node, property) {
+        if (this.value === lattice_1.Bottom) {
+            return this.domain.value[property]?.bottom();
+        }
+        return this.value.get(node)?.value[property];
+    }
+    hasValue(node, property) {
+        return this.value !== lattice_1.Bottom && this.value.get(node)?.value[property] !== undefined;
+    }
+    setValue(node, property, value) {
+        if (this.value !== lattice_1.Bottom) {
+            const oldValue = this.get(node);
+            const newValue = { ...oldValue?.value ?? {}, [property]: value };
+            this._value.set(node, new MultiValueDomain(newValue, this.domain.domain, this.domain.reductions));
+        }
+    }
+}
+exports.MultiValueStateDomain = MultiValueStateDomain;
+/**
+ * A multi-value abstract domain as a (partial) product domain that combines multiple abstract domains.
+ * The Bottom element is defined as mapping every sub abstract domain to Bottom and the Top element is defined as having no sub abstract domain value.
+ * @template Product - Type of the abstract product of the multi-value domain combining multiple abstract values
+ * @see {@link MultiValueStateDomain} for a state abstract domain of a multi-value domain
+ */
+class MultiValueDomain extends partial_product_domain_1.PartialProductDomain {
+    reductions;
+    constructor(value, domain, reductions = []) {
+        super(value, domain);
+        this.reductions = reductions;
+    }
+    create(value) {
+        return new MultiValueDomain(value, this.domain, this.reductions);
+    }
+    static top(domain, reductions = []) {
+        return new MultiValueDomain({}, domain, reductions);
+    }
+    reduce(value) {
+        return this.reductions.reduce((current, reduction) => reduction(current), value);
+    }
+}
+exports.MultiValueDomain = MultiValueDomain;
+//# sourceMappingURL=multi-value-state-domain.js.map

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

@@ -0,0 +1,43 @@
+import { type AnyAbstractDomain, AbstractDomain } from './abstract-domain';
+import { Top } from './lattice';
+/** The type of an abstract product of a product domain mapping named properties of the product to abstract domains */
+export type AbstractProduct<Domain extends AnyAbstractDomain = AnyAbstractDomain> = {
+    [key in string]?: Domain;
+};
+/** The type of the concrete product of an abstract product mapping each property to a concrete value in the respective concrete domain */
+export type ConcreteProductOf<Product extends AbstractProduct> = {
+    [Key in keyof Product]: Product[Key] extends AbstractDomain<infer Concrete, unknown, unknown, unknown> ? Concrete : never;
+};
+/**
+ * A partial product abstract domain as named Cartesian product of (optional) sub abstract domains.
+ * The sub abstract domains are represented by a (partial) record mapping property names to abstract domains.
+ * The Bottom element is defined as mapping every sub abstract domain to Bottom and the Top element is defined as having no sub abstract domain value.
+ * @template Product - Type of the abstract product of the product domain mapping (optional) property names to abstract domains
+ */
+export declare abstract class PartialProductDomain<Product extends AbstractProduct> extends AbstractDomain<ConcreteProductOf<Product>, Product, Product, Product> {
+    readonly domain: Required<Product>;
+    constructor(value: Product, domain: Required<Product>);
+    abstract create(value: Product): this;
+    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<ConcreteProductOf<Product>> | typeof Top;
+    abstract(concrete: ReadonlySet<ConcreteProductOf<Product>> | typeof Top): this;
+    toJson(): unknown;
+    toString(): string;
+    isTop(): boolean;
+    isTop(): this is this;
+    isBottom(): boolean;
+    isBottom(): this is this;
+    isValue(): boolean;
+    isValue(): this is this;
+    /**
+     * Optional reduction function for a reduced product domain.
+     */
+    protected reduce(value: Product): Product;
+}

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

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartialProductDomain = void 0;
+const abstract_domain_1 = require("./abstract-domain");
+const lattice_1 = require("./lattice");
+const record_1 = require("../../util/record");
+/**
+ * A partial product abstract domain as named Cartesian product of (optional) sub abstract domains.
+ * The sub abstract domains are represented by a (partial) record mapping property names to abstract domains.
+ * The Bottom element is defined as mapping every sub abstract domain to Bottom and the Top element is defined as having no sub abstract domain value.
+ * @template Product - Type of the abstract product of the product domain mapping (optional) property names to abstract domains
+ */
+class PartialProductDomain extends abstract_domain_1.AbstractDomain {
+    domain;
+    constructor(value, domain) {
+        super(record_1.Record.mapProperties(value, entry => entry?.create(entry.value)));
+        this._value = this.reduce(this.value);
+        this.domain = domain;
+    }
+    bottom() {
+        const result = this.create(this.domain);
+        for (const key in result.value) {
+            result.value[key] = this.domain[key]?.bottom();
+        }
+        return result;
+    }
+    top() {
+        return this.create({});
+    }
+    equals(other) {
+        if (this.value === other.value) {
+            return true;
+        }
+        for (const key in this.value) {
+            if (this.value[key] == other.value[key]) {
+                continue;
+            }
+            else if (this.value[key] === undefined || other.value[key] === undefined || !this.value[key].equals(other.value[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    leq(other) {
+        if (this.value === other.value) {
+            return true;
+        }
+        for (const key in this.value) {
+            if (this.value[key] === other.value[key] || other.value[key] === undefined) {
+                continue;
+            }
+            else if (this.value[key] === undefined || !this.value[key].leq(other.value[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    join(other) {
+        const result = {};
+        for (const key in this.domain) {
+            if (this.value[key] !== undefined && other.value[key] !== undefined) {
+                result[key] = this.value[key].join(other.value[key]);
+            }
+        }
+        return this.create(result);
+    }
+    meet(other) {
+        const result = {};
+        for (const key in this.domain) {
+            if (this.value[key] === undefined) {
+                result[key] = other.value[key];
+            }
+            else if (other.value[key] === undefined) {
+                result[key] = this.value[key];
+            }
+            else {
+                result[key] = this.value[key].meet(other.value[key]);
+            }
+        }
+        return this.create(result);
+    }
+    widen(other) {
+        const result = {};
+        for (const key in this.domain) {
+            if (this.value[key] !== undefined && other.value[key] !== undefined) {
+                result[key] = this.value[key].widen(other.value[key]);
+            }
+        }
+        return this.create(result);
+    }
+    narrow(other) {
+        const result = {};
+        for (const key in this.domain) {
+            if (this.value[key] === undefined) {
+                result[key] = other.value[key];
+            }
+            else if (other.value[key] === undefined) {
+                result[key] = this.value[key];
+            }
+            else {
+                result[key] = this.value[key].narrow(other.value[key]);
+            }
+        }
+        return this.create(result);
+    }
+    concretize(limit) {
+        let result = new Set([{}]);
+        for (const key in this.value) {
+            if (this.value[key] === undefined) {
+                continue;
+            }
+            const concrete = this.value[key].concretize(limit);
+            if (concrete === lattice_1.Top) {
+                return lattice_1.Top;
+            }
+            const newResult = new Set();
+            for (const value of concrete) {
+                for (const entry of result) {
+                    if (newResult.size >= limit) {
+                        return lattice_1.Top;
+                    }
+                    newResult.add({ ...entry, [key]: value });
+                }
+            }
+            result = newResult;
+        }
+        return result;
+    }
+    abstract(concrete) {
+        if (concrete === lattice_1.Top) {
+            return this.top();
+        }
+        const result = {};
+        for (const key in this.domain) {
+            const concreteValues = new Set(concrete.values().map(value => value[key]));
+            result[key] = this.domain[key]?.abstract(concreteValues);
+        }
+        return this.create(result);
+    }
+    toJson() {
+        return record_1.Record.mapProperties(this.value, entry => entry?.toJson());
+    }
+    toString() {
+        return '(' + record_1.Record.entries(this.value).map(([key, value]) => `${key}: ${value.toString()}`).join(', ') + ')';
+    }
+    isTop() {
+        return record_1.Record.values(this.value).length === 0;
+    }
+    isBottom() {
+        return record_1.Record.values(this.value).every(value => value.isBottom());
+    }
+    isValue() {
+        return true;
+    }
+    /**
+     * Optional reduction function for a reduced product domain.
+     */
+    reduce(value) {
+        return value;
+    }
+}
+exports.PartialProductDomain = PartialProductDomain;
+//# sourceMappingURL=partial-product-domain.js.map

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

@@ -1,41 +1,14 @@
-import { AbstractDomain, type AnyAbstractDomain } from './abstract-domain';
-import { Top } from './lattice';
-/** The type of an abstract product of a product domain mapping named properties of the product to abstract domains */
-export type AbstractProduct = Record<string, AnyAbstractDomain>;
-/** The type of the concrete product of an abstract product mapping each property to a concrete value in the respective concrete domain */
-export type ConcreteProduct<Product extends AbstractProduct> = {
-    [Key in keyof Product]: Product[Key] extends AbstractDomain<infer Concrete, unknown, unknown, unknown> ? Concrete : never;
-};
+import { type AbstractProduct, PartialProductDomain } from './partial-product-domain';
 /**
  * A product abstract domain as named Cartesian product of sub abstract domains.
  * The sub abstract domains are represented by a record mapping property names to abstract domains.
  * The Bottom element is defined as mapping every sub abstract domain to Bottom and the Top element is defined as mapping every sub abstract domain to Top.
  * @template Product - Type of the abstract product of the product domain mapping property names to abstract domains
  */
-export declare abstract class ProductDomain<Product extends AbstractProduct> extends AbstractDomain<ConcreteProduct<Product>, Product, Product, Product> {
+export declare abstract class ProductDomain<Product extends Required<AbstractProduct>> extends PartialProductDomain<Product> {
     constructor(value: Product);
     abstract create(value: Product): this;
-    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<ConcreteProduct<Product>> | typeof Top;
-    abstract(concrete: ReadonlySet<ConcreteProduct<Product>> | typeof Top): this;
-    toJson(): unknown;
-    toString(): string;
     isTop(): boolean;
     isTop(): this is this;
-    isBottom(): boolean;
-    isBottom(): this is this;
-    isValue(): boolean;
-    isValue(): this is this;
-    /**
-     * Optional reduction function for a reduced product domain.
-     */
-    protected reduce(value: Product): Product;
-    private refine;
 }

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

@@ -1,144 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProductDomain = void 0;
-const abstract_domain_1 = require("./abstract-domain");
-const lattice_1 = require("./lattice");
 const record_1 = require("../../util/record");
+const partial_product_domain_1 = require("./partial-product-domain");
 /**
  * A product abstract domain as named Cartesian product of sub abstract domains.
  * The sub abstract domains are represented by a record mapping property names to abstract domains.
  * The Bottom element is defined as mapping every sub abstract domain to Bottom and the Top element is defined as mapping every sub abstract domain to Top.
  * @template Product - Type of the abstract product of the product domain mapping property names to abstract domains
  */
-class ProductDomain extends abstract_domain_1.AbstractDomain {
+class ProductDomain extends partial_product_domain_1.PartialProductDomain {
     constructor(value) {
-        super(record_1.Record.mapProperties(value, entry => entry.create(entry.value)));
-        this._value = this.reduce(this.value);
-    }
-    bottom() {
-        const result = this.create(this.value);
-        for (const key in result.value) {
-            result._value[key] = result.value[key].bottom();
-        }
-        return result;
+        super(value, value);
     }
     top() {
-        const result = this.create(this.value);
-        for (const key in result.value) {
-            result._value[key] = result.value[key].top();
-        }
-        return result;
-    }
-    equals(other) {
-        if (this.value === other.value) {
-            return true;
-        }
-        for (const key in this.value) {
-            if (!this.value[key].equals(other.value[key])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    leq(other) {
-        if (this.value === other.value) {
-            return true;
-        }
-        for (const key in this.value) {
-            if (!this.value[key].leq(other.value[key])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    join(other) {
-        const result = this.create(this.value);
-        for (const key in result.value) {
-            result._value[key] = result.value[key].join(other.value[key]);
-        }
-        return result.refine();
-    }
-    meet(other) {
-        const result = this.create(this.value);
-        for (const key in result.value) {
-            result._value[key] = result.value[key].meet(other.value[key]);
-        }
-        return result.refine();
-    }
-    widen(other) {
-        const result = this.create(this.value);
-        for (const key in result.value) {
-            result._value[key] = result.value[key].widen(other.value[key]);
-        }
-        return result.refine();
-    }
-    narrow(other) {
-        const result = this.create(this.value);
+        const result = this.create(this.domain);
         for (const key in result.value) {
-            result._value[key] = result.value[key].narrow(other.value[key]);
-        }
-        return result.refine();
-    }
-    concretize(limit) {
-        let result = new Set([{}]);
-        for (const key in this.value) {
-            const concrete = this.value[key].concretize(limit);
-            if (concrete === lattice_1.Top) {
-                return lattice_1.Top;
-            }
-            const newResult = new Set();
-            for (const value of concrete) {
-                for (const entry of result) {
-                    if (newResult.size >= limit) {
-                        return lattice_1.Top;
-                    }
-                    newResult.add({ ...entry, [key]: value });
-                }
-            }
-            result = newResult;
+            result.value[key] = result.value[key]?.top();
         }
         return result;
     }
-    abstract(concrete) {
-        if (concrete === lattice_1.Top) {
-            return this.top();
-        }
-        const result = this.create(this.value);
-        for (const key in result.value) {
-            const concreteValues = new Set(concrete.values().map(value => value[key]));
-            result._value[key] = result.value[key].abstract(concreteValues);
-        }
-        return result.refine();
-    }
-    toJson() {
-        return record_1.Record.mapProperties(this.value, entry => entry.toJson());
-    }
-    toString() {
-        return '(' + Object.entries(this.value).map(([key, value]) => `${key}: ${value.toString()}`).join(', ') + ')';
-    }
     isTop() {
-        return Object.values(this.value).every(value => value.isTop());
-    }
-    isBottom() {
-        return Object.values(this.value).every(value => value.isBottom());
-    }
-    isValue() {
-        return true;
-    }
-    /**
-     * Optional reduction function for a reduced product domain.
-     */
-    reduce(value) {
-        return value;
-    }
-    refine() {
-        if (!this.isTop() || this.isBottom()) {
-            const reduced = this.reduce(this.value);
-            if (reduced !== this.value) {
-                return this.create(reduced);
-            }
-        }
-        return this;
+        return record_1.Record.values(this.value).every(value => value.isTop());
     }
 }
 exports.ProductDomain = ProductDomain;

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

@@ -382,11 +382,11 @@ class SetRangeDomain extends abstract_domain_1.AbstractDomain {
             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(', ');
+            const minString = this.value.min.values().map(abstract_domain_1.AbstractDomain.toString).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(', ');
+        const minString = this.value.min.values().map(abstract_domain_1.AbstractDomain.toString).toArray().join(', ');
+        const rangeString = this.value.range.values().map(abstract_domain_1.AbstractDomain.toString).toArray().join(', ');
         return `[{${minString}}, {${rangeString}}]`;
     }
     isTop() {

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

@@ -180,7 +180,7 @@ class SetUpperBoundDomain extends abstract_domain_1.AbstractDomain {
         else if (this.value === lattice_1.Bottom) {
             return lattice_1.BottomSymbol;
         }
-        const string = this.value.values().map(abstract_domain_1.domainElementToString).toArray().join(', ');
+        const string = this.value.values().map(abstract_domain_1.AbstractDomain.toString).toArray().join(', ');
         return `{${string}}`;
     }
     isTop() {

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

@@ -114,7 +114,7 @@ class SingletonDomain extends abstract_domain_1.AbstractDomain {
         else if (this.value === lattice_1.Bottom) {
             return lattice_1.BottomSymbol;
         }
-        return (0, abstract_domain_1.domainElementToString)(this.value);
+        return abstract_domain_1.AbstractDomain.toString(this.value);
     }
     isTop() {
         return this.value === lattice_1.Top;