@eagleoutice/flowr 2.4.6 → 2.4.8

package/README.md

@@ -24,7 +24,7 @@ It offers a wide variety of features, for example:
     
     ```shell
     $ docker run -it --rm eagleoutice/flowr # or npm run flowr 
-    flowR repl using flowR v2.4.5, R v4.5.0 (r-shell engine)
+    flowR repl using flowR v2.4.7, R v4.5.0 (r-shell engine)
     R> :query @linter "read.csv(\"/root/x.txt\")"
     ```
     
@@ -55,7 +55,7 @@ It offers a wide variety of features, for example:
        ╰ **Dead Code** (dead-code):
            ╰ _Metadata_: <code>{"consideredNodes":5,"searchTimeMs":0,"processTimeMs":0}</code>
        ╰ **Useless Loops** (useless-loop):
-           ╰ _Metadata_: <code>{"numOfUselessLoops":0,"searchTimeMs":0,"processTimeMs":1}</code>
+           ╰ _Metadata_: <code>{"numOfUselessLoops":0,"searchTimeMs":0,"processTimeMs":0}</code>
     All queries together required ≈3 ms (1ms accuracy, total 9 ms)
     ```
     
@@ -78,7 +78,7 @@ It offers a wide variety of features, for example:
     
     _Results (prettified and summarized):_
     
-    Query: **linter** (13 ms)\
+    Query: **linter** (14 ms)\
     &nbsp;&nbsp;&nbsp;╰ **Deprecated Functions** (deprecated-functions):\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"totalDeprecatedCalls":0,"totalDeprecatedFunctionDefinitions":0,"searchTimeMs":2,"processTimeMs":0}</code>\
     &nbsp;&nbsp;&nbsp;╰ **File Path Validity** (file-path-validity):\
@@ -86,11 +86,11 @@ It offers a wide variety of features, for example:
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ Path `/root/x.txt` at 1.1-23\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"totalReads":1,"totalUnknown":0,"totalWritesBeforeAlways":0,"totalValid":0,"searchTimeMs":4,"processTimeMs":1}</code>\
     &nbsp;&nbsp;&nbsp;╰ **Seeded Randomness** (seeded-randomness):\
-    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"consumerCalls":0,"callsWithFunctionProducers":0,"callsWithAssignmentProducers":0,"callsWithNonConstantProducers":0,"searchTimeMs":0,"processTimeMs":0}</code>\
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"consumerCalls":0,"callsWithFunctionProducers":0,"callsWithAssignmentProducers":0,"callsWithNonConstantProducers":0,"searchTimeMs":0,"processTimeMs":1}</code>\
     &nbsp;&nbsp;&nbsp;╰ **Absolute Paths** (absolute-file-paths):\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ certain:\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ Path `/root/x.txt` at 1.1-23\
-    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"totalConsidered":1,"totalUnknown":0,"searchTimeMs":2,"processTimeMs":0}</code>\
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"totalConsidered":1,"totalUnknown":0,"searchTimeMs":1,"processTimeMs":1}</code>\
     &nbsp;&nbsp;&nbsp;╰ **Unused Definitions** (unused-definitions):\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"totalConsidered":0,"searchTimeMs":0,"processTimeMs":0}</code>\
     &nbsp;&nbsp;&nbsp;╰ **Naming Convention** (naming-convention):\
@@ -100,12 +100,12 @@ It offers a wide variety of features, for example:
     &nbsp;&nbsp;&nbsp;╰ **Dead Code** (dead-code):\
     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"consideredNodes":5,"searchTimeMs":1,"processTimeMs":0}</code>\
     &nbsp;&nbsp;&nbsp;╰ **Useless Loops** (useless-loop):\
-    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"numOfUselessLoops":0,"searchTimeMs":0,"processTimeMs":0}</code>\
-    _All queries together required ≈14 ms (1ms accuracy, total 209 ms)_
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ _Metadata_: <code>{"numOfUselessLoops":0,"searchTimeMs":0,"processTimeMs":1}</code>\
+    _All queries together required ≈14 ms (1ms accuracy, total 216 ms)_
     
     <details> <summary style="color:gray">Show Detailed Results as Json</summary>
     
-    The analysis required _209.4 ms_ (including parsing and normalization and the query) within the generation environment.	
+    The analysis required _215.9 ms_ (including parsing and normalization and the query) within the generation environment.	
     
     In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
     Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -156,7 +156,7 @@ It offers a wide variety of features, for example:
               "callsWithAssignmentProducers": 0,
               "callsWithNonConstantProducers": 0,
               "searchTimeMs": 0,
-              "processTimeMs": 0
+              "processTimeMs": 1
             }
           },
           "absolute-file-paths": {
@@ -175,8 +175,8 @@ It offers a wide variety of features, for example:
             ".meta": {
               "totalConsidered": 1,
               "totalUnknown": 0,
-              "searchTimeMs": 2,
-              "processTimeMs": 0
+              "searchTimeMs": 1,
+              "processTimeMs": 1
             }
           },
           "unused-definitions": {
@@ -219,12 +219,12 @@ It offers a wide variety of features, for example:
             ".meta": {
               "numOfUselessLoops": 0,
               "searchTimeMs": 0,
-              "processTimeMs": 0
+              "processTimeMs": 1
             }
           }
         },
         ".meta": {
-          "timing": 13
+          "timing": 14
         }
       },
       ".meta": {
@@ -295,7 +295,7 @@ It offers a wide variety of features, for example:
     
     ```shell
     $ docker run -it --rm eagleoutice/flowr # or npm run flowr 
-    flowR repl using flowR v2.4.5, R v4.5.0 (r-shell engine)
+    flowR repl using flowR v2.4.7, R v4.5.0 (r-shell engine)
     R> :slicer test/testfiles/example.R --criterion "11@sum"
     ```
     
@@ -342,7 +342,7 @@ It offers a wide variety of features, for example:
         
 
 * 🚀 **fast data- and control-flow graphs**\
-  Within just <i><span title="This measurement is automatically fetched from the latest benchmark!">135.6 ms</span></i> (as of Aug 20, 2025), 
+  Within just <i><span title="This measurement is automatically fetched from the latest benchmark!">135.1 ms</span></i> (as of Aug 20, 2025), 
   _flowR_ can analyze the data- and control-flow of the average real-world R script. See the [benchmarks](https://flowr-analysis.github.io/flowr/wiki/stats/benchmark) for more information,
   and consult the [wiki pages](https://github.com/flowr-analysis/flowr/wiki/Dataflow-Graph) for more details on the dataflow graph.
 
@@ -378,7 +378,7 @@ It offers a wide variety of features, for example:
     
     ```shell
     $ docker run -it --rm eagleoutice/flowr # or npm run flowr 
-    flowR repl using flowR v2.4.5, R v4.5.0 (r-shell engine)
+    flowR repl using flowR v2.4.7, R v4.5.0 (r-shell engine)
     R> :dataflow* test/testfiles/example.R
     ```
     
@@ -493,7 +493,7 @@ It offers a wide variety of features, for example:
           *7.10-20*
         (26, 27)`"]]
         23["`#91;RSymbol#93; sum
-          (23, :may:)
+          (23, :may:36+)
           *7.3-5*`"]
         29[["`#91;RBinaryOp#93; #60;#45;
           (29, :may:36+)
@@ -510,7 +510,7 @@ It offers a wide variety of features, for example:
           *8.14-24*
         (31, 32)`"]]
         30["`#91;RSymbol#93; product
-          (30, :may:)
+          (30, :may:36+)
           *8.3-9*`"]
         34[["`#91;RBinaryOp#93; #60;#45;
           (34, :may:36+)
@@ -622,64 +622,68 @@ It offers a wide variety of features, for example:
         linkStyle 44 stroke:gray,color:gray;
         23 -->|"defined-by"| 28
         23 -->|"defined-by"| 29
+        23 -->|"CD-True"| 36
+        linkStyle 47 stroke:gray,color:gray;
         29 -->|"argument"| 28
         29 -->|"returns, argument"| 23
         29 -.->|"reads, calls"| built-in:_-
-        linkStyle 49 stroke:gray;
+        linkStyle 50 stroke:gray;
         29 -->|"CD-True"| 36
-        linkStyle 50 stroke:gray,color:gray;
+        linkStyle 51 stroke:gray,color:gray;
         31 -->|"reads"| 3
         31 -->|"reads"| 30
         31 -->|"CD-True"| 36
-        linkStyle 53 stroke:gray,color:gray;
+        linkStyle 54 stroke:gray,color:gray;
         32 -->|"reads"| 12
         32 -->|"CD-True"| 36
-        linkStyle 55 stroke:gray,color:gray;
+        linkStyle 56 stroke:gray,color:gray;
         33 -->|"reads, argument"| 31
         33 -->|"reads, argument"| 32
         33 -.->|"reads, calls"| built-in:_
-        linkStyle 58 stroke:gray;
+        linkStyle 59 stroke:gray;
         33 -->|"CD-True"| 36
-        linkStyle 59 stroke:gray,color:gray;
+        linkStyle 60 stroke:gray,color:gray;
         30 -->|"defined-by"| 33
         30 -->|"defined-by"| 34
+        30 -->|"CD-True"| 36
+        linkStyle 63 stroke:gray,color:gray;
         34 -->|"argument"| 33
         34 -->|"returns, argument"| 30
         34 -.->|"reads, calls"| built-in:_-
-        linkStyle 64 stroke:gray;
+        linkStyle 66 stroke:gray;
         34 -->|"CD-True"| 36
-        linkStyle 65 stroke:gray,color:gray;
+        linkStyle 67 stroke:gray,color:gray;
         35 -->|"argument"| 29
         35 -->|"returns, argument"| 34
         35 -.->|"reads, calls"| built-in:_
-        linkStyle 68 stroke:gray;
+        linkStyle 70 stroke:gray;
         35 -->|"CD-True"| 36
-        linkStyle 69 stroke:gray,color:gray;
+        linkStyle 71 stroke:gray,color:gray;
         36 -->|"argument"| 12
         36 -->|"reads, argument"| 20
         36 -->|"argument, non-standard-evaluation"| 35
         36 -.->|"reads, calls"| built-in:for
-        linkStyle 73 stroke:gray;
+        linkStyle 75 stroke:gray;
         40 -->|"reads"| 0
         40 -->|"reads"| 23
         40 -.->|"reads"| built-in:sum
-        linkStyle 76 stroke:gray;
+        linkStyle 78 stroke:gray;
         44 -->|"argument"| 38
         44 -->|"reads, argument"| 40
         44 -->|"argument"| 42
         44 -.->|"reads, calls"| built-in:cat
-        linkStyle 80 stroke:gray;
+        linkStyle 82 stroke:gray;
         48 -->|"reads"| 3
         48 -->|"reads"| 30
         52 -->|"argument"| 46
         52 -->|"reads, argument"| 48
         52 -->|"argument"| 50
         52 -.->|"reads, calls"| built-in:cat
-        linkStyle 86 stroke:gray;
+        linkStyle 88 stroke:gray;
     ```
     
     	
-    (The analysis required _14.5 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment.)
+    (The analysis required _14.9 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment.)
     
     
     

package/abstract-interpretation/data-frame/absint-visitor.js

@@ -137,7 +137,7 @@ class DataFrameShapeInferenceVisitor extends semantic_cfg_guided_visitor_1.Seman
     }
     /** Get all AST nodes for the predecessor vertices that are leaf nodes and exit vertices */
     getPredecessorNodes(vertexId) {
-        return [...this.config.controlFlow.graph.outgoingEdges(vertexId)?.keys() ?? []] // outgoing dependency edges are incoming CFG edges
+        return this.config.controlFlow.graph.outgoingEdges(vertexId)?.keys() // outgoing dependency edges are incoming CFG edges
             .map(id => this.getCfgVertex(id))
             .flatMap(vertex => {
             if (vertex === undefined) {
@@ -150,7 +150,8 @@ class DataFrameShapeInferenceVisitor extends semantic_cfg_guided_visitor_1.Seman
                 return [this.getNormalizedAst((0, control_flow_graph_1.getVertexRootId)(vertex))];
             }
         })
-            .filter(assert_1.isNotUndefined);
+            .filter(assert_1.isNotUndefined)
+            .toArray() ?? [];
     }
     shouldWiden(vertex) {
         return (this.visited.get(vertex.id) ?? 0) >= this.config.flowrConfig.abstractInterpretation.dataFrame.wideningThreshold;

package/abstract-interpretation/data-frame/dataframe-domain.d.ts

@@ -0,0 +1,40 @@
+import type { AbstractDomain } from '../domains/abstract-domain';
+import { PosIntervalDomain } from '../domains/positive-interval-domain';
+import { ProductDomain } from '../domains/product-domain';
+import { SetBoundedSetDomain } from '../domains/set-bounded-set-domain';
+import { StateAbstractDomain } from '../domains/state-abstract-domain';
+/** The type of the abstract product representing the shape of data frames */
+export type AbstractDataFrameShape = {
+    colnames: SetBoundedSetDomain<string>;
+    cols: PosIntervalDomain;
+    rows: PosIntervalDomain;
+};
+/** The type of abstract values of a sub abstract domain (shape property) of the data frame shape product */
+type DataFrameShapeProperty<Property extends keyof AbstractDataFrameShape> = AbstractDataFrameShape[Property] extends AbstractDomain<unknown, unknown, unknown, unknown, infer Lift> ? Lift : never;
+/**
+ * The data frame abstract domain as product domain of a column names domain, column count domain, and row count domain.
+ */
+export declare class DataFrameDomain extends ProductDomain<AbstractDataFrameShape> {
+    constructor(value: AbstractDataFrameShape, maxColNames?: number);
+    create(value: AbstractDataFrameShape, maxColNames?: number): DataFrameDomain;
+    /**
+     * The current abstract value of the column names domain.
+     */
+    get colnames(): DataFrameShapeProperty<'colnames'>;
+    /**
+     * The current abstract value of the column count domain.
+     */
+    get cols(): DataFrameShapeProperty<'cols'>;
+    /**
+     * The current abstract value of the row count domain.
+     */
+    get rows(): DataFrameShapeProperty<'rows'>;
+    static bottom(maxColNames?: number): DataFrameDomain;
+    static top(maxColNames?: number): DataFrameDomain;
+}
+/**
+ * The data frame state abstract domain as state abstract domain mapping AST node IDs to inferred abstract data frame shapes.
+ */
+export declare class DateFrameStateDomain extends StateAbstractDomain<DataFrameDomain> {
+}
+export {};

package/abstract-interpretation/data-frame/dataframe-domain.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateFrameStateDomain = exports.DataFrameDomain = void 0;
+const positive_interval_domain_1 = require("../domains/positive-interval-domain");
+const product_domain_1 = require("../domains/product-domain");
+const set_bounded_set_domain_1 = require("../domains/set-bounded-set-domain");
+const state_abstract_domain_1 = require("../domains/state-abstract-domain");
+/**
+ * The data frame abstract domain as product domain of a column names domain, column count domain, and row count domain.
+ */
+class DataFrameDomain extends product_domain_1.ProductDomain {
+    constructor(value, maxColNames) {
+        super({
+            colnames: new set_bounded_set_domain_1.SetBoundedSetDomain(value.colnames.value, maxColNames),
+            cols: new positive_interval_domain_1.PosIntervalDomain(value.cols.value),
+            rows: new positive_interval_domain_1.PosIntervalDomain(value.rows.value)
+        });
+    }
+    create(value, maxColNames) {
+        return new DataFrameDomain(value, maxColNames);
+    }
+    /**
+     * The current abstract value of the column names domain.
+     */
+    get colnames() {
+        return this.value.colnames.value;
+    }
+    /**
+     * The current abstract value of the column count domain.
+     */
+    get cols() {
+        return this.value.cols.value;
+    }
+    /**
+     * The current abstract value of the row count domain.
+     */
+    get rows() {
+        return this.value.rows.value;
+    }
+    static bottom(maxColNames) {
+        return new DataFrameDomain({
+            colnames: set_bounded_set_domain_1.SetBoundedSetDomain.bottom(maxColNames),
+            cols: positive_interval_domain_1.PosIntervalDomain.bottom(),
+            rows: positive_interval_domain_1.PosIntervalDomain.bottom()
+        });
+    }
+    static top(maxColNames) {
+        return new DataFrameDomain({
+            colnames: set_bounded_set_domain_1.SetBoundedSetDomain.top(maxColNames),
+            cols: positive_interval_domain_1.PosIntervalDomain.top(),
+            rows: positive_interval_domain_1.PosIntervalDomain.top()
+        });
+    }
+}
+exports.DataFrameDomain = DataFrameDomain;
+/**
+ * The data frame state abstract domain as state abstract domain mapping AST node IDs to inferred abstract data frame shapes.
+ */
+class DateFrameStateDomain extends state_abstract_domain_1.StateAbstractDomain {
+}
+exports.DateFrameStateDomain = DateFrameStateDomain;
+//# sourceMappingURL=dataframe-domain.js.map

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

@@ -105,7 +105,7 @@ function subtractColNames(set1, set2) {
  * However, this speeds up the iteration in larger loops significantly, as we are over-approximating the column names much earlier.
  */
 function wideningColNames(set1, set2) {
-    return leqColNames(set1, set2) ? set2 : exports.ColNamesTop;
+    return leqColNames(set2, set1) ? set1 : exports.ColNamesTop;
 }
 /** Checks whether an abstract value of the column names domain satisfies a column name */
 function satisfiesColsNames(set, value) {

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

@@ -0,0 +1,56 @@
+import type { Bottom, Lattice, Top } from './lattice';
+/**
+ * The default limit of inferred constraints in {@link AbstractDomain|AbstractDomains}.
+ */
+export declare const DEFAULT_INFERENCE_LIMIT = 50;
+/**
+ * An abstract domain as complete lattice with a widening operator, narrowing operator, concretization function, and abstraction function.
+ * @template Concrete - Type of an concrete element of the concrete domain for the abstract domain
+ * @template Abstract - Type of an abstract element of the abstract domain representing possible elements (may exclude `Top` and `Bot`)
+ * @template Top      - Type of the Top element of the abstract domain representing all possible elements (defaults to {@link Top})
+ * @template Bot      - Type of the Bottom element of the abstract domain representing no possible elements (defaults to {@link Bottom})
+ * @template Lift     - Type of the abstract elements of the abstract domain (defaults to `Abstract` or `Top` or `Bot`)
+ */
+export interface AbstractDomain<Concrete, Abstract, Top = typeof Top, Bot = typeof Bottom, Lift extends Abstract | Top | Bot = Abstract | Top | Bot> extends Lattice<Abstract, Top, Bot, Lift> {
+    /**
+     * Widens the current abstract value with another abstract value as a sound over-approximation of the join (least upper bound) for fixpoint iteration acceleration.
+     */
+    widen(other: AbstractDomain<Concrete, Abstract, Top, Bot>): AbstractDomain<Concrete, Abstract, Top, Bot>;
+    /**
+     * Narrows the current abstract value with another abstract value as a sound over-approximation of the meet (greatest lower bound) to refine the value after widening.
+     */
+    narrow(other: AbstractDomain<Concrete, Abstract, Top, Bot>): AbstractDomain<Concrete, Abstract, Top, Bot>;
+    /**
+     * Maps the current abstract value into a set of possible concrete values as concretization function of the abstract domain.
+     * The result should be `Top` if the number of concrete values would reach the `limit` or the resulting set would have infinite many elements.
+     */
+    concretize(limit?: number): ReadonlySet<Concrete> | typeof Top;
+    /**
+     * Maps a set of possible concrete values into an abstract value as abstraction function of the abstract domain (should additionally be provided as static function).
+     */
+    abstract(concrete: ReadonlySet<Concrete> | typeof Top): AbstractDomain<Concrete, Abstract, Top, Bot>;
+}
+/**
+ * The type of the concrete domain of an abstract domain.
+ * @template Domain - The abstract domain to get the concrete domain type for
+ */
+export type ConcreteDomain<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> = Domain extends AbstractDomain<infer Concrete, unknown, unknown, unknown> ? Concrete : never;
+/**
+ * The type of the Top element (greatest element) of an abstract domain.
+ * @template Domain - The abstract domain to get the Top element type for
+ */
+export type AbstractDomainTop<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> = Domain extends AbstractDomain<unknown, unknown, infer Top, unknown> ? Top : never;
+/**
+ * The type of the Bottom element (least element) of an abstract domain.
+ * @template Domain - The abstract domain to get the Bottom element type for
+ */
+export type AbstractDomainBottom<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> = Domain extends AbstractDomain<unknown, unknown, unknown, infer Bot> ? Bot : never;
+/**
+ * The type of the abstract values of an abstract domain (including the Top and Bottom element).
+ * @template Domain - The abstract domain to get the abstract value type for
+ */
+export type AbstractDomainValue<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> = Domain extends AbstractDomain<unknown, infer Value, infer Top, infer Bot> ? Value | Top | Bot : never;
+/**
+ * Converts an element of an abstract domain into a string.
+ */
+export declare function domainElementToString(value: AbstractDomain<unknown, unknown, unknown, unknown> | unknown): string;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_INFERENCE_LIMIT = void 0;
+exports.domainElementToString = domainElementToString;
+/**
+ * The default limit of inferred constraints in {@link AbstractDomain|AbstractDomains}.
+ */
+exports.DEFAULT_INFERENCE_LIMIT = 50;
+/**
+ * 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();
+    }
+    return JSON.stringify(value);
+}
+//# sourceMappingURL=abstract-domain.js.map

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

@@ -0,0 +1,43 @@
+import { type AbstractDomain } from './abstract-domain';
+import { Top } from './lattice';
+/** The type of the actual values of the bounded set domain as set */
+export type BoundedSetValue<T> = ReadonlySet<T>;
+/** The type of the Top element of the bounded set domain as {@link Top} symbol */
+export type BoundedSetTop = typeof Top;
+/** The type of the Bottom element of the bounded set domain as empty set */
+export type BoundedSetBottom = ReadonlySet<never>;
+/** The type of the abstract values of the bounded set domain that are Top, Bottom, or actual values */
+export type BoundedSetLift<T> = BoundedSetValue<T> | BoundedSetTop | BoundedSetBottom;
+/**
+ * The bounded set abstract domain as sets of possible values bounded by a `limit` indicating the maximum number of inferred values.
+ * The Bottom element is defined as the empty set 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)
+ */
+export declare class BoundedSetDomain<T, Value extends BoundedSetLift<T> = BoundedSetLift<T>> implements AbstractDomain<T, BoundedSetValue<T>, BoundedSetTop, BoundedSetBottom, Value> {
+    private readonly limit;
+    private _value;
+    constructor(value: Value, limit?: number);
+    get value(): Value;
+    static top<T>(limit?: number): BoundedSetDomain<T, BoundedSetTop>;
+    static bottom<T>(limit?: number): BoundedSetDomain<T, BoundedSetBottom>;
+    static abstract<T>(concrete: ReadonlySet<T> | typeof Top, limit?: number): BoundedSetDomain<T>;
+    top(): BoundedSetDomain<T, BoundedSetTop>;
+    bottom(): BoundedSetDomain<T, BoundedSetBottom>;
+    equals(other: BoundedSetDomain<T>): boolean;
+    leq(other: BoundedSetDomain<T>): boolean;
+    join(...values: BoundedSetDomain<T>[]): BoundedSetDomain<T>;
+    meet(...values: BoundedSetDomain<T>[]): BoundedSetDomain<T>;
+    /**
+     * 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: BoundedSetDomain<T>): BoundedSetDomain<T>;
+    widen(other: BoundedSetDomain<T>): BoundedSetDomain<T>;
+    narrow(other: BoundedSetDomain<T>): BoundedSetDomain<T>;
+    concretize(limit?: number): ReadonlySet<T> | typeof Top;
+    abstract(concrete: ReadonlySet<T> | typeof Top): BoundedSetDomain<T>;
+    toString(): string;
+    isTop(): this is BoundedSetDomain<T, BoundedSetTop>;
+    isBottom(): this is BoundedSetDomain<T, BoundedSetBottom>;
+    isValue(): this is BoundedSetDomain<T, BoundedSetValue<T>>;
+}

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

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoundedSetDomain = void 0;
+const set_1 = require("../../util/collections/set");
+const abstract_domain_1 = require("./abstract-domain");
+const lattice_1 = require("./lattice");
+/**
+ * The bounded set abstract domain as sets of possible values bounded by a `limit` indicating the maximum number of inferred values.
+ * The Bottom element is defined as the empty set 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 BoundedSetDomain {
+    limit;
+    _value;
+    constructor(value, limit = abstract_domain_1.DEFAULT_INFERENCE_LIMIT) {
+        if (value !== lattice_1.Top) {
+            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 BoundedSetDomain(lattice_1.Top, limit);
+    }
+    static bottom(limit) {
+        return new BoundedSetDomain(new Set(), limit);
+    }
+    static abstract(concrete, limit) {
+        return new BoundedSetDomain(concrete, limit);
+    }
+    top() {
+        return BoundedSetDomain.top(this.limit);
+    }
+    bottom() {
+        return BoundedSetDomain.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 other.value === lattice_1.Top || (this.isValue() && this.value.isSubsetOf(other.value));
+    }
+    join(...values) {
+        const result = new BoundedSetDomain(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 {
+                const join = result.value.union(other.value);
+                result._value = join.size > this.limit ? lattice_1.Top : join;
+            }
+        }
+        return result;
+    }
+    meet(...values) {
+        const result = new BoundedSetDomain(this.value, this.limit);
+        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 {
+                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 (other.value === lattice_1.Top) {
+            return new BoundedSetDomain(this.value, this.limit);
+        }
+        else {
+            return new BoundedSetDomain(this.value.difference(other.value), this.limit);
+        }
+    }
+    widen(other) {
+        return other.leq(this) ? new BoundedSetDomain(this.value, this.limit) : this.top();
+    }
+    narrow(other) {
+        return this.isTop() ? other : this;
+    }
+    concretize(limit = this.limit) {
+        return this.value === lattice_1.Top || this.value.size > limit ? lattice_1.Top : this.value;
+    }
+    abstract(concrete) {
+        return BoundedSetDomain.abstract(concrete, this.limit);
+    }
+    toString() {
+        if (this.value === lattice_1.Top) {
+            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.Top && this.value.size === 0;
+    }
+    isValue() {
+        return this.value !== lattice_1.Top;
+    }
+}
+exports.BoundedSetDomain = BoundedSetDomain;
+//# sourceMappingURL=bounded-set-domain.js.map

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

@@ -0,0 +1,61 @@
+import { type AbstractDomain } from './abstract-domain';
+import { Bottom, Top } from './lattice';
+/** The type of the actual values of the interval domain as tuple of the lower and upper bound */
+export type IntervalValue = readonly [number, number];
+/** The type of the Top element of the interval domain as interval [-∞, +∞] from -∞ to +∞ */
+export type IntervalTop = readonly [typeof Infinity, typeof Infinity];
+/** The type of the Bottom element of the interval domain as {@link Bottom} symbol */
+export type IntervalBottom = typeof Bottom;
+/** The type of the abstract values of the interval domain that are Top, Bottom, or actual values */
+export type IntervalLift = IntervalValue | IntervalTop | IntervalBottom;
+/**
+ * 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)
+ */
+export declare class IntervalDomain<Value extends IntervalLift = IntervalLift> implements AbstractDomain<number, IntervalValue, IntervalTop, IntervalBottom, Value> {
+    private _value;
+    constructor(value: Value);
+    get value(): Value;
+    static top(): IntervalDomain<IntervalTop>;
+    static bottom(): IntervalDomain<IntervalBottom>;
+    static abstract(concrete: ReadonlySet<number> | typeof Top): IntervalDomain;
+    top(): IntervalDomain<IntervalTop>;
+    bottom(): IntervalDomain<IntervalBottom>;
+    equals(other: IntervalDomain): boolean;
+    leq(other: IntervalDomain): boolean;
+    join(...values: IntervalDomain[]): IntervalDomain;
+    meet(...values: IntervalDomain[]): IntervalDomain;
+    widen(other: IntervalDomain): IntervalDomain;
+    narrow(other: IntervalDomain): IntervalDomain;
+    concretize(limit?: number): ReadonlySet<number> | typeof Top;
+    abstract(concrete: ReadonlySet<number> | typeof Top): IntervalDomain;
+    /**
+     * Adds another abstract value to the current abstract value by adding the two lower and upper bounds, respectively.
+     */
+    add(other: IntervalDomain): IntervalDomain;
+    /**
+     * Subtracts another abstract value from the current abstract value by subtracting the two lower and upper bounds from each other, respectively.
+     */
+    subtract(other: IntervalDomain): IntervalDomain;
+    /**
+     * 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: IntervalDomain): IntervalDomain;
+    /**
+     * 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: IntervalDomain): IntervalDomain;
+    /**
+     * Extends the lower bound of the current abstract value down to -∞.
+     */
+    extendDown(): IntervalDomain;
+    /**
+     * Extends the upper bound of the current abstract value up to +∞.
+     */
+    extendUp(): IntervalDomain;
+    toString(): string;
+    isTop(): this is IntervalDomain<IntervalTop>;
+    isBottom(): this is IntervalDomain<IntervalBottom>;
+    isValue(): this is IntervalDomain<IntervalValue>;
+}