@eagleoutice/flowr 2.10.1 → 2.10.3

package/abstract-interpretation/data-frame/semantics.js

@@ -6,7 +6,6 @@ exports.getConstraintType = getConstraintType;
 const assert_1 = require("../../util/assert");
 const lattice_1 = require("../domains/lattice");
 const positive_interval_domain_1 = require("../domains/positive-interval-domain");
-const dataframe_domain_1 = require("./dataframe-domain");
 /**
  * Represents the different types of resulting constraints that are inferred by abstract data frame operations.
  */
@@ -73,7 +72,7 @@ function applyCreateSemantics(value, { colnames, rows }) {
     const colnamesValue = setRange(colnames);
     const colsValue = colnames !== undefined ? [colnames.length, colnames.length] : positive_interval_domain_1.PosIntervalTop;
     const rowsValue = Array.isArray(rows) ? rows : typeof rows === 'number' ? [rows, rows] : positive_interval_domain_1.PosIntervalTop;
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: value.colnames.create(colnamesValue),
         cols: value.cols.create(colsValue),
         rows: value.rows.create(rowsValue)
@@ -84,14 +83,14 @@ function applyReadSemantics(value, { colnames, rows }) {
 }
 function applyAccessColsSemantics(value, { columns }) {
     if (columns?.every(col => typeof col === 'string')) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames.union(setRange(columns)),
             cols: value.cols,
             rows: value.rows
         });
     }
     else if (columns?.every(col => typeof col === 'number')) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames,
             cols: columns.reduce((current, col) => current.max([col, col]), value.cols),
             rows: value.rows
@@ -101,7 +100,7 @@ function applyAccessColsSemantics(value, { columns }) {
 }
 function applyAccessRowsSemantics(value, { rows }) {
     if (rows !== undefined) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames,
             cols: value.cols,
             rows: rows.reduce((current, row) => current.max([row, row]), value.rows)
@@ -111,20 +110,20 @@ function applyAccessRowsSemantics(value, { rows }) {
 }
 function applyAssignColsSemantics(value, { columns }) {
     if (columns?.every(col => typeof col === 'string')) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames.union(setRange(columns)),
             cols: value.cols.add([0, columns.length]).max([columns.length, columns.length]),
             rows: value.rows
         });
     }
     else if (columns?.every(col => typeof col === 'number')) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames.widenUp(),
             cols: columns.reduce((current, col) => current.max([col, col]), value.cols),
             rows: value.rows
         });
     }
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: value.colnames.widenUp(),
         cols: value.cols.widenUp(),
         rows: value.rows
@@ -132,13 +131,13 @@ function applyAssignColsSemantics(value, { columns }) {
 }
 function applyAssignRowsSemantics(value, { rows }) {
     if (rows !== undefined) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames,
             cols: value.cols,
             rows: rows.reduce((current, row) => current.max([row, row]), value.rows)
         });
     }
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: value.colnames,
         cols: value.cols,
         rows: value.rows.widenUp()
@@ -146,21 +145,21 @@ function applyAssignRowsSemantics(value, { rows }) {
 }
 function applySetColNamesSemantics(value, { colnames }, options) {
     if (options?.partial) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames.widenDown().union(setRange(colnames)),
             cols: value.cols,
             rows: value.rows
         });
     }
     const allColNames = colnames?.every(assert_1.isNotUndefined) && value.cols.value !== lattice_1.Bottom && colnames.length >= value.cols.value[1];
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: allColNames ? value.colnames.create(setRange(colnames)) : value.colnames.create(setRange(colnames)).widenUp(),
         cols: value.cols,
         rows: value.rows
     });
 }
 function applyAddColsSemantics(value, { colnames }) {
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: colnames !== undefined ? value.colnames.union(setRange(colnames)) : value.colnames.widenUp(),
         cols: colnames !== undefined ? value.cols.add([colnames.length, colnames.length]) : value.cols.widenUp(),
         rows: value.rows
@@ -168,14 +167,13 @@ function applyAddColsSemantics(value, { colnames }) {
 }
 function applyAddRowsSemantics(value, { rows }) {
     if (value.cols.value !== lattice_1.Bottom && value.cols.value[0] === 0) {
-        return new dataframe_domain_1.DataFrameDomain({
-            ...value,
+        return value.create({
             colnames: value.colnames.top(),
             cols: rows !== undefined ? value.cols.add([1, 1]) : value.cols.top(),
             rows: rows !== undefined ? value.rows.add([rows, rows]) : value.rows.widenUp()
         });
     }
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: value.colnames,
         cols: value.cols,
         rows: rows !== undefined ? value.rows.add([rows, rows]) : value.rows.widenUp()
@@ -183,13 +181,13 @@ function applyAddRowsSemantics(value, { rows }) {
 }
 function applyRemoveColsSemantics(value, { colnames }, options) {
     if (options?.maybe) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: colnames !== undefined ? value.colnames.subtract(setRange(colnames)) : value.colnames.widenDown(),
             cols: colnames !== undefined ? value.cols.subtract([colnames.length, 0]) : value.cols.widenDown(),
             rows: value.rows
         });
     }
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: colnames !== undefined ? value.colnames.subtract(setRange(colnames)) : value.colnames.widenDown(),
         cols: colnames !== undefined ? value.cols.subtract([colnames.length, colnames.length]) : value.cols.widenDown(),
         rows: value.rows
@@ -197,20 +195,20 @@ function applyRemoveColsSemantics(value, { colnames }, options) {
 }
 function applyRemoveRowsSemantics(value, { rows }, options) {
     if (options?.maybe) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames,
             cols: value.cols,
             rows: rows !== undefined ? value.rows.subtract([rows, 0]) : value.rows.widenDown()
         });
     }
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: value.colnames,
         cols: value.cols,
         rows: rows !== undefined ? value.rows.subtract([rows, rows]) : value.rows.widenDown()
     });
 }
 function applyConcatColsSemantics(value, { other }) {
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: value.colnames.union(other.colnames),
         cols: value.cols.add(other.cols),
         rows: value.rows
@@ -218,14 +216,13 @@ function applyConcatColsSemantics(value, { other }) {
 }
 function applyConcatRowsSemantics(value, { other }) {
     if (value.cols.value !== lattice_1.Bottom && value.cols.value[0] === 0) {
-        return new dataframe_domain_1.DataFrameDomain({
-            ...value,
+        return value.create({
             colnames: value.colnames.join(other.colnames),
             cols: value.cols.join(other.cols),
             rows: value.rows.add(other.rows)
         });
     }
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: value.colnames,
         cols: value.cols,
         rows: value.rows.add(other.rows)
@@ -233,20 +230,20 @@ function applyConcatRowsSemantics(value, { other }) {
 }
 function applySubsetColsSemantics(value, { colnames }, options) {
     if (options?.duplicateCols) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames.top(),
             cols: colnames !== undefined ? value.cols.create([colnames.length, colnames.length]) : value.cols.top(),
             rows: value.rows
         });
     }
     else if (options?.renamedCols) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames.top(),
             cols: colnames !== undefined ? value.cols.min([colnames.length, colnames.length]) : value.cols.widenDown(),
             rows: value.rows
         });
     }
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: colnames !== undefined ? value.colnames.intersect(setRange(colnames)) : value.colnames.widenDown(),
         cols: colnames !== undefined ? value.cols.min([colnames.length, colnames.length]) : value.cols.widenDown(),
         rows: value.rows
@@ -254,27 +251,27 @@ function applySubsetColsSemantics(value, { colnames }, options) {
 }
 function applySubsetRowsSemantics(value, { rows }, options) {
     if (options?.duplicateRows) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames,
             cols: value.cols,
             rows: rows !== undefined ? value.rows.create([rows, rows]) : value.rows.top()
         });
     }
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: value.colnames,
         cols: value.cols,
         rows: rows !== undefined ? value.rows.min([rows, rows]) : value.rows.widenDown()
     });
 }
 function applyFilterRowsSemantics(value, { condition }) {
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: value.colnames,
         cols: value.cols,
         rows: condition ? value.rows : condition === false ? value.rows.create([0, 0]) : value.rows.widenDown()
     });
 }
 function applyMutateColsSemantics(value, { colnames }) {
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: colnames !== undefined ? value.colnames.union(setRange(colnames)) : value.colnames.widenUp(),
         cols: colnames !== undefined ? value.cols.add([0, colnames.length]).max([colnames.length, colnames.length]) : value.cols.widenUp(),
         rows: value.rows
@@ -282,7 +279,7 @@ function applyMutateColsSemantics(value, { colnames }) {
 }
 function applyGroupBySemantics(value, { by }, options) {
     if (options?.mutatedCols) {
-        return new dataframe_domain_1.DataFrameDomain({
+        return value.create({
             colnames: value.colnames.union(setRange(by)),
             cols: value.cols.add([0, by.length]),
             rows: value.rows
@@ -292,7 +289,7 @@ function applyGroupBySemantics(value, { by }, options) {
     return value;
 }
 function applySummarizeSemantics(value, { colnames }) {
-    return new dataframe_domain_1.DataFrameDomain({
+    return value.create({
         colnames: colnames !== undefined ? value.colnames.join(setRange([])).union(setRange(colnames)) : value.colnames.widenUp(),
         cols: colnames !== undefined ? value.cols.add([0, colnames.length]).min([colnames.length, +Infinity]) : value.cols.widenUp(),
         rows: value.rows.min([1, +Infinity]).max([0, 1])
@@ -360,8 +357,7 @@ function applyJoinSemantics(value, { other, by }, options) {
         default:
             (0, assert_1.assertUnreachable)(joinType);
     }
-    return new dataframe_domain_1.DataFrameDomain({
-        ...value,
+    return value.create({
         colnames: duplicateCols === undefined ? value.colnames.top() : duplicateCols.length > 0 ? value.colnames.union(other.colnames).subtract(setRange(duplicateCols)).widenUp() : value.colnames.union(other.colnames),
         cols: by !== undefined ? value.cols.add(other.cols).subtract([by.length, by.length]) : mergeInterval(value.cols, other.cols),
         rows: productRows ? productInterval(rows, value.rows, other.rows) : rows

package/abstract-interpretation/data-frame/shape-inference.js

@@ -16,7 +16,7 @@ class DataFrameShapeInferenceVisitor extends absint_visitor_1.AbstractInterpreta
      */
     operations;
     constructor({ trackOperations = true, ...config }) {
-        super(config);
+        super(config, dataframe_domain_1.DataFrameDomain.top());
         if (trackOperations) {
             this.operations = new Map();
         }

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

@@ -65,5 +65,6 @@ export declare class IntervalDomain<Value extends IntervalLift = IntervalLift> e
     isTop(): this is IntervalDomain<IntervalTop>;
     isBottom(): this is IntervalDomain<IntervalBottom>;
     isValue(): this is IntervalDomain<IntervalValue>;
+    isFinite(): this is IntervalDomain<IntervalValue>;
 }
 export {};

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

@@ -259,6 +259,9 @@ class IntervalDomain extends abstract_domain_1.AbstractDomain {
     isValue() {
         return this.value !== lattice_1.Bottom;
     }
+    isFinite() {
+        return this.isValue() && Number.isFinite(this.value[0]) && Number.isFinite(this.value[1]);
+    }
 }
 exports.IntervalDomain = IntervalDomain;
 //# sourceMappingURL=interval-domain.js.map

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

@@ -13,6 +13,7 @@ export type ConcreteProduct<Product extends AbstractProduct> = {
  * @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> {
+    constructor(value: Product);
     abstract create(value: Product): this;
     bottom(): this;
     top(): this;
@@ -26,7 +27,15 @@ export declare abstract class ProductDomain<Product extends AbstractProduct> ext
     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

@@ -3,6 +3,7 @@ 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");
 /**
  * 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.
@@ -10,6 +11,10 @@ const lattice_1 = require("./lattice");
  * @template Product - Type of the abstract product of the product domain mapping property names to abstract domains
  */
 class ProductDomain extends abstract_domain_1.AbstractDomain {
+    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) {
@@ -51,28 +56,28 @@ class ProductDomain extends abstract_domain_1.AbstractDomain {
         for (const key in result.value) {
             result._value[key] = result.value[key].join(other.value[key]);
         }
-        return result;
+        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;
+        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;
+        return result.refine();
     }
     narrow(other) {
         const result = this.create(this.value);
         for (const key in result.value) {
             result._value[key] = result.value[key].narrow(other.value[key]);
         }
-        return result;
+        return result.refine();
     }
     concretize(limit) {
         let result = new Set([{}]);
@@ -103,10 +108,10 @@ class ProductDomain extends abstract_domain_1.AbstractDomain {
             const concreteValues = new Set(concrete.values().map(value => value[key]));
             result._value[key] = result.value[key].abstract(concreteValues);
         }
-        return result;
+        return result.refine();
     }
     toJson() {
-        return Object.fromEntries(Object.entries(this.value).map(([key, value]) => [key, value.toJson()]));
+        return record_1.Record.mapProperties(this.value, entry => entry.toJson());
     }
     toString() {
         return '(' + Object.entries(this.value).map(([key, value]) => `${key}: ${value.toString()}`).join(', ') + ')';
@@ -120,6 +125,21 @@ class ProductDomain extends abstract_domain_1.AbstractDomain {
     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;
+    }
 }
 exports.ProductDomain = ProductDomain;
 //# sourceMappingURL=product-domain.js.map

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

@@ -1,42 +1,55 @@
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { AnyAbstractDomain } from './abstract-domain';
-import { Top } from './lattice';
-import type { ConcreteMap } from './mapped-abstract-domain';
-import { MappedAbstractDomain } from './mapped-abstract-domain';
+import { AbstractDomain, type AnyAbstractDomain, type ConcreteDomain } from './abstract-domain';
+import { Bottom, Top } from './lattice';
+/** The type of the concrete state of the concrete domain of a state abstract domain that maps keys to a concrete value in the concrete domain */
+export type ConcreteState<Domain extends AnyAbstractDomain> = ReadonlyMap<NodeId, ConcreteDomain<Domain>>;
+/** The type of the actual values of the state abstract domain as map of keys to domain values */
+type StateDomainValue<Domain extends AnyAbstractDomain> = ReadonlyMap<NodeId, Domain>;
+/** The type of the Top element of the state abstract domain as (empty) map of keys to domain values */
+type StateDomainTop = ReadonlyMap<NodeId, never>;
+/** The type of the Bottom element of the state abstract domain as {@link Bottom} symbol */
+type StateDomainBottom = typeof Bottom;
+/** The type of the abstract values of the state abstract domain that are Top, Bottom, or actual values */
+type StateDomainLift<Domain extends AnyAbstractDomain> = StateDomainValue<Domain> | StateDomainBottom;
 /**
- * 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
+ * A state abstract domain that maps AST node IDs of a program to abstract values of an abstract domain.
+ * The Bottom element is defined as {@link Bottom} symbol and the Top element as empty mapping.
+ * @template Domain - Type of the value 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 AnyAbstractDomain> extends MappedAbstractDomain<NodeId, Domain> {
-    private _isBottom;
-    constructor(value: ReadonlyMap<NodeId, Domain>, bottom?: boolean);
-    create(value: ReadonlyMap<NodeId, Domain>, bottom?: boolean): this;
-    static top<Domain extends AnyAbstractDomain>(): StateAbstractDomain<Domain>;
-    get(key: NodeId, ignoreBottom?: boolean): Domain | undefined;
+export declare class StateAbstractDomain<Domain extends AnyAbstractDomain, Value extends StateDomainLift<Domain> = StateDomainLift<Domain>> extends AbstractDomain<ConcreteState<Domain>, StateDomainValue<Domain>, StateDomainTop, StateDomainBottom, Value> {
+    protected domain: Domain;
+    constructor(value: Value, domain: Domain);
+    create(value: StateDomainLift<Domain>): this;
+    static top<Domain extends AnyAbstractDomain>(domain: Domain): StateAbstractDomain<Domain, StateDomainTop>;
+    static bottom<Domain extends AnyAbstractDomain>(domain: Domain): StateAbstractDomain<Domain, StateDomainBottom>;
+    get(key: NodeId): Domain | undefined;
+    has(key: NodeId): boolean;
     protected set(key: NodeId, value: Domain): void;
-    bottom(): this;
-    top(): this;
+    protected remove(key: NodeId): void;
+    top(): this & StateAbstractDomain<Domain, StateDomainTop>;
+    bottom(): this & StateAbstractDomain<Domain, StateDomainBottom>;
     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<NodeId, Domain>> | typeof Top;
-    abstract(concrete: typeof Top | ReadonlySet<ConcreteMap<NodeId, Domain>>): this;
+    concretize(limit: number): ReadonlySet<ConcreteState<Domain>> | typeof Top;
+    abstract(concrete: ReadonlySet<ConcreteState<Domain>> | typeof Top): this;
     toJson(): unknown;
     toString(): string;
-    isTop(): this is this;
-    isBottom(): this is this;
-    isValue(): this is this;
+    isTop(): this is this & StateAbstractDomain<Domain, StateDomainTop>;
+    isBottom(): this is this & StateAbstractDomain<Domain, StateDomainBottom>;
+    isValue(): this is this & StateAbstractDomain<Domain, StateDomainValue<Domain>>;
 }
 /**
  * A mutable version of the {@link StateAbstractDomain} with {@link MutableStateAbstractDomain#set|`set`} and {@link MutableStateAbstractDomain#remove|`remove`}.
  */
-export declare class MutableStateAbstractDomain<Domain extends AnyAbstractDomain> extends StateAbstractDomain<Domain> {
-    create(value: ReadonlyMap<NodeId, Domain>): this;
+export declare class MutableStateAbstractDomain<Domain extends AnyAbstractDomain, Value extends StateDomainLift<Domain> = StateDomainLift<Domain>> extends StateAbstractDomain<Domain, Value> {
+    create(value: StateDomainLift<Domain>): this;
+    static top<Domain extends AnyAbstractDomain>(domain: Domain): MutableStateAbstractDomain<Domain, StateDomainTop>;
+    static bottom<Domain extends AnyAbstractDomain>(domain: Domain): MutableStateAbstractDomain<Domain, StateDomainBottom>;
     set(key: NodeId, value: Domain): void;
     remove(key: NodeId): void;
 }
@@ -45,3 +58,4 @@ export declare class MutableStateAbstractDomain<Domain extends AnyAbstractDomain
  * @template StateDomain - The state abstract domain to get the value abstract domain type for
  */
 export type ValueAbstractDomain<StateDomain extends StateAbstractDomain<AnyAbstractDomain>> = StateDomain extends StateAbstractDomain<infer Domain> ? Domain : never;
+export {};