@eagleoutice/flowr 2.4.5 → 2.4.7

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

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetBoundedSetDomain = void 0;
+const set_1 = require("../../util/collections/set");
+const abstract_domain_1 = require("./abstract-domain");
+const lattice_1 = require("./lattice");
+/**
+ * The set bounded set abstract domain as sets capturing possible values of the concrete set bounded by a `limit` for the maximum number of inferred values.
+ * The Bottom element is defined as the{@link Bottom} and the Top element is defined as {@link Top} symbol.
+ * @template T     - Type of the values in the abstract domain
+ * @template Value - Type of the constraint in the abstract domain (Top, Bottom, or an actual value)
+ */
+class SetBoundedSetDomain {
+    limit;
+    _value;
+    constructor(value, limit = abstract_domain_1.DEFAULT_INFERENCE_LIMIT) {
+        if (value !== lattice_1.Top && value !== lattice_1.Bottom) {
+            this._value = (value.size > limit ? lattice_1.Top : new Set(value));
+        }
+        else {
+            this._value = value;
+        }
+        this.limit = limit;
+    }
+    get value() {
+        return this._value;
+    }
+    static top(limit) {
+        return new SetBoundedSetDomain(lattice_1.Top, limit);
+    }
+    static bottom(limit) {
+        return new SetBoundedSetDomain(lattice_1.Bottom, limit);
+    }
+    static abstract(concrete, limit) {
+        if (concrete === lattice_1.Top) {
+            return SetBoundedSetDomain.top(limit);
+        }
+        else if (concrete.size === 0) {
+            return SetBoundedSetDomain.bottom(limit);
+        }
+        return new SetBoundedSetDomain(concrete.values().reduce((result, set) => result.union(set)), limit);
+    }
+    top() {
+        return SetBoundedSetDomain.top(this.limit);
+    }
+    bottom() {
+        return SetBoundedSetDomain.bottom(this.limit);
+    }
+    equals(other) {
+        return this.value === other.value || (this.isValue() && other.isValue() && (0, set_1.setEquals)(this.value, other.value));
+    }
+    leq(other) {
+        return this.value === lattice_1.Bottom || other.value === lattice_1.Top || (this.isValue() && other.isValue() && this.value.isSubsetOf(other.value));
+    }
+    join(...values) {
+        const result = new SetBoundedSetDomain(this.value, this.limit);
+        for (const other of values) {
+            if (result.value === lattice_1.Top || other.value === lattice_1.Top) {
+                result._value = lattice_1.Top;
+            }
+            else if (result.value === lattice_1.Bottom) {
+                result._value = other.value;
+            }
+            else if (other.value === lattice_1.Bottom) {
+                result._value = result.value;
+            }
+            else {
+                const join = result.value.union(other.value);
+                result._value = join.size > this.limit ? lattice_1.Top : join;
+            }
+        }
+        return result;
+    }
+    meet(...values) {
+        const result = new SetBoundedSetDomain(this.value, this.limit);
+        for (const other of values) {
+            if (result.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+                result._value = lattice_1.Bottom;
+            }
+            else if (result.value === lattice_1.Top) {
+                result._value = other.value;
+            }
+            else if (other.value === lattice_1.Top) {
+                result._value = result.value;
+            }
+            else {
+                result._value = result.value.intersection(other.value);
+            }
+        }
+        return result;
+    }
+    /**
+     * 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) {
+        if (this.value === lattice_1.Top) {
+            return this.top();
+        }
+        else if (this.value === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        else if (other.value === lattice_1.Top || other.value === lattice_1.Bottom) {
+            return new SetBoundedSetDomain(this.value, this.limit);
+        }
+        else {
+            return new SetBoundedSetDomain(this.value.difference(other.value), this.limit);
+        }
+    }
+    widen(other) {
+        if (this.value === lattice_1.Bottom) {
+            return new SetBoundedSetDomain(other.value, this.limit);
+        }
+        else if (other.value === lattice_1.Bottom) {
+            return new SetBoundedSetDomain(this.value, this.limit);
+        }
+        return other.leq(this) ? new SetBoundedSetDomain(this.value, this.limit) : this.top();
+    }
+    narrow(other) {
+        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        return this.isTop() ? other : this;
+    }
+    concretize(limit = abstract_domain_1.DEFAULT_INFERENCE_LIMIT) {
+        if (this.value === lattice_1.Bottom) {
+            return new Set();
+        }
+        else if (this.value === lattice_1.Top || 2 ** (this.value.size) > limit) {
+            return lattice_1.Top;
+        }
+        const subsets = [new Set()];
+        for (const element of this.value.values()) {
+            const newSubsets = subsets.map(subset => new Set([...subset, element]));
+            for (const subset of newSubsets) {
+                subsets.push(subset);
+            }
+        }
+        return new Set(subsets);
+    }
+    abstract(concrete) {
+        return SetBoundedSetDomain.abstract(concrete, this.limit);
+    }
+    toString() {
+        if (this.value === lattice_1.Top) {
+            return '⊤';
+        }
+        else if (this.value === lattice_1.Bottom) {
+            return '⊥';
+        }
+        const string = this.value.values().map(abstract_domain_1.domainElementToString).toArray().join(', ');
+        return `{${string}}`;
+    }
+    isTop() {
+        return this.value === lattice_1.Top;
+    }
+    isBottom() {
+        return this.value == lattice_1.Bottom;
+    }
+    isValue() {
+        return this.value !== lattice_1.Top && this.value !== lattice_1.Bottom;
+    }
+}
+exports.SetBoundedSetDomain = SetBoundedSetDomain;
+//# sourceMappingURL=set-bounded-set-domain.js.map

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

@@ -0,0 +1,38 @@
+import { type AbstractDomain } from './abstract-domain';
+import { Bottom, Top } from './lattice';
+/** The type of the actual values of the singleton domain as single value */
+export type SingletonValue<T> = T;
+/** The type of the Top element of the singleton domain as {@link Top} symbol */
+export type SingletonTop = typeof Top;
+/** The type of the Bottom element of the singleton domain as {@link Bottom} symbol */
+export type SingletonBottom = typeof Bottom;
+/** The type of the abstract values of the singleton domain that are Top, Bottom, or actual values */
+export type SingletonLift<T> = SingletonValue<T> | SingletonTop | SingletonBottom;
+/**
+ * The singleton abstract domain as 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)
+ */
+export declare class SingletonDomain<T, Value extends SingletonLift<T> = SingletonLift<T>> implements AbstractDomain<T, SingletonValue<T>, SingletonTop, SingletonBottom, Value> {
+    private _value;
+    constructor(value: Value);
+    get value(): Value;
+    static top<T>(): SingletonDomain<T, SingletonTop>;
+    static bottom<T>(): SingletonDomain<T, SingletonBottom>;
+    static abstract<T>(concrete: ReadonlySet<T> | typeof Top): SingletonDomain<T>;
+    top(): SingletonDomain<T, SingletonTop>;
+    bottom(): SingletonDomain<T, SingletonBottom>;
+    equals(other: SingletonDomain<T>): boolean;
+    leq(other: SingletonDomain<T>): boolean;
+    join(...values: SingletonDomain<T>[]): SingletonDomain<T>;
+    meet(...values: SingletonDomain<T>[]): SingletonDomain<T>;
+    widen(other: SingletonDomain<T>): SingletonDomain<T>;
+    narrow(other: SingletonDomain<T>): SingletonDomain<T>;
+    concretize(): ReadonlySet<T> | typeof Top;
+    abstract(concrete: ReadonlySet<T> | typeof Top): SingletonDomain<T>;
+    toString(): string;
+    isTop(): this is SingletonDomain<T, SingletonTop>;
+    isBottom(): this is SingletonDomain<T, SingletonBottom>;
+    isValue(): this is SingletonDomain<T, SingletonValue<T>>;
+}

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

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingletonDomain = void 0;
+const abstract_domain_1 = require("./abstract-domain");
+const lattice_1 = require("./lattice");
+/**
+ * The singleton abstract domain as 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;
+    }
+    static top() {
+        return new SingletonDomain(lattice_1.Top);
+    }
+    static bottom() {
+        return new SingletonDomain(lattice_1.Bottom);
+    }
+    static abstract(concrete) {
+        if (concrete === lattice_1.Top || concrete.size > 1) {
+            return SingletonDomain.top();
+        }
+        else if (concrete.size === 0) {
+            return SingletonDomain.bottom();
+        }
+        return new SingletonDomain([...concrete][0]);
+    }
+    top() {
+        return SingletonDomain.top();
+    }
+    bottom() {
+        return SingletonDomain.bottom();
+    }
+    equals(other) {
+        return this.value === other.value;
+    }
+    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;
+    }
+    widen(other) {
+        return this.join(other); // Using join for widening as the lattice is finite
+    }
+    narrow(other) {
+        return this.meet(other); // Using meet for narrowing as the lattice is finite
+    }
+    concretize() {
+        if (this.value === lattice_1.Top) {
+            return lattice_1.Top;
+        }
+        else if (this.value === lattice_1.Bottom) {
+            return new Set();
+        }
+        return new Set([this.value]);
+    }
+    abstract(concrete) {
+        return SingletonDomain.abstract(concrete);
+    }
+    toString() {
+        if (this.value === lattice_1.Top) {
+            return '⊤';
+        }
+        else if (this.value === lattice_1.Bottom) {
+            return '⊥';
+        }
+        return (0, abstract_domain_1.domainElementToString)(this.value);
+    }
+    isTop() {
+        return this.value === lattice_1.Top;
+    }
+    isBottom() {
+        return this.value === lattice_1.Bottom;
+    }
+    isValue() {
+        return this.value !== lattice_1.Top && this.value !== lattice_1.Bottom;
+    }
+}
+exports.SingletonDomain = SingletonDomain;
+//# sourceMappingURL=singleton-domain.js.map

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

@@ -0,0 +1,32 @@
+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>>;
+/**
+ * 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>;
+}

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

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateAbstractDomain = void 0;
+const abstract_domain_1 = require("./abstract-domain");
+const lattice_1 = require("./lattice");
+/**
+ * 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;
+    }
+}
+exports.StateAbstractDomain = StateAbstractDomain;
+//# sourceMappingURL=state-abstract-domain.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.4.5",
+  "version": "2.4.7",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {

package/util/version.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrVersion = flowrVersion;
 const semver_1 = require("semver");
 // this is automatically replaced with the current version by release-it
-const version = '2.4.5';
+const version = '2.4.7';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }