@eagleoutice/flowr 2.9.9 → 2.9.11

package/abstract-interpretation/absint-visitor.js

@@ -6,10 +6,12 @@ const semantic_cfg_guided_visitor_1 = require("../control-flow/semantic-cfg-guid
 const built_in_1 = require("../dataflow/environments/built-in");
 const vertex_1 = require("../dataflow/graph/vertex");
 const dfg_get_origin_1 = require("../dataflow/origin/dfg-get-origin");
+const model_1 = require("../r-bridge/lang-4.x/ast/model/model");
 const r_function_call_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
 const assert_1 = require("../util/assert");
 const abstract_domain_1 = require("./domains/abstract-domain");
+const state_abstract_domain_1 = require("./domains/state-abstract-domain");
 /**
  * A control flow graph visitor to perform abstract interpretation.
  *
@@ -23,14 +25,35 @@ class AbstractInterpretationVisitor extends semantic_cfg_guided_visitor_1.Semant
     /**
      * The current abstract state domain at the currently processed AST node.
      */
-    currentState;
+    _currentState;
     /**
      * A set of nodes representing variable definitions that have already been visited but whose assignment has not yet been processed.
      */
     unassigned = new Set();
+    /**
+     * Whether the current abstract state has been copied/cloned and is save to modify in place.
+     */
+    stateCopied = false;
     constructor(config) {
         super({ ...config, defaultVisitingOrder: 'forward', defaultVisitingType: 'exit' });
-        this.currentState = config.domain.bottom();
+        this._currentState = new state_abstract_domain_1.MutableStateAbstractDomain(new Map());
+    }
+    get currentState() {
+        return this._currentState;
+    }
+    removeState(node) {
+        if (!this.stateCopied) {
+            this._currentState = this._currentState.create(this.currentState.value);
+            this.stateCopied = true;
+        }
+        this._currentState.remove(node);
+    }
+    updateState(node, value) {
+        if (!this.stateCopied) {
+            this._currentState = this._currentState.create(this.currentState.value);
+            this.stateCopied = true;
+        }
+        this._currentState.set(node, value);
     }
     /**
      * Resolves the inferred abstract value of an AST node.
@@ -49,7 +72,7 @@ class AbstractInterpretationVisitor extends semantic_cfg_guided_visitor_1.Semant
             return state.get(node.info.id);
         }
         const vertex = this.getDataflowGraph(node.info.id);
-        const call = vertex?.tag === vertex_1.VertexType.FunctionCall ? vertex : undefined;
+        const call = (0, vertex_1.isFunctionCallVertex)(vertex) ? vertex : undefined;
         const origins = Array.isArray(call?.origin) ? call.origin : [];
         if (node.type === type_1.RType.Symbol) {
             const values = this.getVariableOrigins(node.info.id).map(origin => state?.get(origin));
@@ -100,9 +123,9 @@ class AbstractInterpretationVisitor extends semantic_cfg_guided_visitor_1.Semant
      */
     getEndState() {
         const exitPoints = this.config.controlFlow.exitPoints.map(id => this.getCfgVertex(id)).filter(assert_1.isNotUndefined);
-        const exitNodes = exitPoints.map(vertex => control_flow_graph_1.CfgVertex.getRootId(vertex)).filter(assert_1.isNotUndefined);
-        const states = exitNodes.map(node => this.getAbstractState(node)).filter(assert_1.isNotUndefined);
-        return this.config.domain.bottom().joinAll(states);
+        const exitNodes = exitPoints.map(control_flow_graph_1.CfgVertex.getRootId).filter(assert_1.isNotUndefined);
+        const states = exitNodes.map(node => this.trace.get(node)).filter(assert_1.isNotUndefined);
+        return abstract_domain_1.AbstractDomain.joinAll(states, this._currentState.top());
     }
     /**
      * Gets the inferred abstract trace mapping AST nodes to the inferred abstract state at the respective node.
@@ -116,38 +139,66 @@ class AbstractInterpretationVisitor extends semantic_cfg_guided_visitor_1.Semant
         super.start();
         this.unassigned.clear();
     }
+    startVisitor(start) {
+        const stack = Array.from(start);
+        while (stack.length > 0) {
+            const current = stack.pop();
+            if (!this.visitNode(current)) {
+                continue;
+            }
+            for (const next of this.config.controlFlow.graph.ingoingEdges(current)?.keys().toArray().reverse() ?? []) {
+                if (!stack.includes(next)) { // prevent double entries in working list
+                    stack.push(next);
+                }
+            }
+        }
+    }
     visitNode(vertexId) {
         const vertex = this.getCfgVertex(vertexId);
-        if (vertex === undefined) {
+        // skip exit vertices of widening points and entry vertices of complex nodes
+        if (vertex === undefined || this.shouldSkipVertex(vertex)) {
             return true;
         }
+        const predecessors = this.getPredecessorNodes(control_flow_graph_1.CfgVertex.getId(vertex));
+        const predecessorStates = predecessors.map(pred => this.trace.get(pred)).filter(assert_1.isNotUndefined);
+        // retrieve new abstract state by joining states of predecessor nodes
+        if (predecessorStates.length === 1) {
+            this._currentState = predecessorStates[0];
+        }
+        else {
+            this._currentState = abstract_domain_1.AbstractDomain.joinAll(predecessorStates, this._currentState.top());
+            this.stateCopied = true;
+        }
         const nodeId = control_flow_graph_1.CfgVertex.getRootId(vertex);
+        // differentiate between widening points and other vertices
         if (this.isWideningPoint(nodeId)) {
-            // only check widening points at the entry vertex
-            if (control_flow_graph_1.CfgVertex.isMarker(vertex)) {
-                return true;
-            }
-            const oldState = this.getAbstractState(nodeId) ?? this.config.domain.bottom();
-            const predecessorDomains = this.getPredecessorNodes(control_flow_graph_1.CfgVertex.getId(vertex)).map(pred => this.getAbstractState(pred)).filter(assert_1.isNotUndefined);
-            this.currentState = this.config.domain.bottom().joinAll(predecessorDomains);
+            const oldState = this.trace.get(nodeId) ?? this._currentState.top();
             if (this.shouldWiden(vertex)) {
-                this.currentState = oldState.widen(this.currentState);
+                this._currentState = oldState.widen(this._currentState);
+                this.stateCopied = true;
             }
-            this.trace.set(nodeId, this.currentState);
-            return this.shouldContinueVisiting(vertex, oldState);
-        }
-        else if (this.shouldSkipVertex(vertex)) {
-            return true;
+            this.trace.set(nodeId, this._currentState);
+            this.stateCopied = false;
+            const visitedCount = this.visited.get(nodeId) ?? 0;
+            this.visited.set(nodeId, visitedCount + 1);
+            // continue visiting after widening point if visited for the first time or the state changed
+            return visitedCount === 0 || !oldState.equals(this._currentState);
         }
-        const predecessorDomains = this.getPredecessorNodes(control_flow_graph_1.CfgVertex.getId(vertex)).map(pred => this.getAbstractState(pred)).filter(assert_1.isNotUndefined);
-        this.currentState = this.config.domain.bottom().joinAll(predecessorDomains);
-        this.onVisitNode(vertexId);
-        // discard the inferred abstract state when encountering functions with unknown side effects (e.g. `eval`)
-        if (this.config.dfg.unknownSideEffects.has(nodeId)) {
-            this.currentState = this.currentState.bottom();
+        else {
+            this.onVisitNode(vertexId);
+            // discard the inferred abstract state when encountering functions with unknown side effects (e.g. `eval`)
+            if (this.config.dfg.unknownSideEffects.has(nodeId)) {
+                this._currentState = this._currentState.top();
+                this.stateCopied = true;
+            }
+            this.trace.set(nodeId, this._currentState);
+            this.stateCopied = false;
+            const predecessorVisits = predecessors.map(pred => this.visited.get(pred) ?? 0);
+            const visitedCount = this.visited.get(nodeId) ?? 0;
+            this.visited.set(nodeId, visitedCount + 1);
+            // continue visiting if vertex is not a join vertex or number of visits of predecessors is the same
+            return predecessors.length <= 1 || predecessorVisits.every(visits => visits === predecessorVisits[0]);
         }
-        this.trace.set(nodeId, this.currentState);
-        return true;
     }
     onDispatchFunctionCallOrigin(call, origin) {
         super.onDispatchFunctionCallOrigin(call, origin);
@@ -183,8 +234,9 @@ class AbstractInterpretationVisitor extends semantic_cfg_guided_visitor_1.Semant
         const value = this.getAbstractValue(source);
         this.unassigned.delete(target);
         if (value !== undefined) {
-            this.currentState.set(target, value);
-            this.trace.set(target, this.currentState.create(this.currentState.value));
+            this.updateState(target, value);
+            this.trace.set(target, this._currentState);
+            this.stateCopied = false;
         }
     }
     onReplacementCall({ target }) {
@@ -204,7 +256,7 @@ class AbstractInterpretationVisitor extends semantic_cfg_guided_visitor_1.Semant
     onFunctionCall(_data) { }
     /** Gets 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 ingoing CFG edges
             .map(id => this.getCfgVertex(id))
             .flatMap(vertex => {
             if (vertex === undefined) {
@@ -226,14 +278,14 @@ class AbstractInterpretationVisitor extends semantic_cfg_guided_visitor_1.Semant
             .map(origin => origin.id)
             .filter(origin => this.trace.has(origin) && !this.unassigned.has(origin)) ?? [];
     }
-    /** We only perform widening at `for`, `while`, or `repeat` loops with more than one incoming CFG edge */
+    /** We only perform widening at `for`, `while`, or `repeat` loops with more than one ingoing CFG edge */
     isWideningPoint(nodeId) {
-        const incomingEdges = this.config.controlFlow.graph.outgoingEdges(nodeId)?.size; // outgoing dependency edges are incoming CFG edges
-        if (incomingEdges === undefined || incomingEdges <= 1) {
+        const ingoingEdges = this.config.controlFlow.graph.outgoingEdges(nodeId)?.size; // outgoing dependency edges are ingoing CFG edges
+        if (ingoingEdges === undefined || ingoingEdges <= 1) {
             return false;
         }
         const node = this.getNormalizedAst(nodeId);
-        if (node?.type === type_1.RType.ForLoop || node?.type === type_1.RType.WhileLoop || node?.type === type_1.RType.RepeatLoop) {
+        if (model_1.RLoopConstructs.is(node)) {
             return true;
         }
         const dataflowVertex = this.getDataflowGraph(nodeId);
@@ -243,26 +295,20 @@ class AbstractInterpretationVisitor extends semantic_cfg_guided_visitor_1.Semant
         const origin = dataflowVertex.origin;
         return origin.includes(built_in_1.BuiltInProcName.ForLoop) || origin.includes(built_in_1.BuiltInProcName.WhileLoop) || origin.includes(built_in_1.BuiltInProcName.RepeatLoop);
     }
-    /**
-     * Checks whether to continue visiting the control flow graph after a widening point.
-     * By default, we only continue visiting if the widening point is visited for the first time or the abstract state at the widening point changed.
-     */
-    shouldContinueVisiting(wideningPoint, oldState) {
-        const wid = control_flow_graph_1.CfgVertex.getId(wideningPoint);
-        const visitedCount = this.visited.get(wid) ?? 0;
-        this.visited.set(wid, visitedCount + 1);
-        return visitedCount === 0 || !oldState.equals(this.currentState);
-    }
     /**
      * Checks whether a control flow graph vertex should be skipped during visitation.
-     * By default, we only process vertices of leaf nodes and exit vertices (no entry nodes of complex nodes).
+     * By default, we only process entry vertices of widening points, vertices of leaf nodes, and exit vertices (no entry nodes of complex nodes).
      */
     shouldSkipVertex(vertex) {
+        if (this.isWideningPoint(control_flow_graph_1.CfgVertex.getRootId(vertex))) {
+            // skip exit vertices of widening points
+            return control_flow_graph_1.CfgVertex.isMarker(vertex);
+        }
         return !control_flow_graph_1.CfgVertex.isMarker(vertex) && !control_flow_graph_1.CfgVertex.isBlock(vertex) && control_flow_graph_1.CfgVertex.getEnd(vertex) !== undefined;
     }
     /**
      * Whether widening should be performed at a widening point.
-     * By default, we perform widening when the number of visitation of the widening point reaches the widening threshold of the config.
+     * By default, we perform widening when the number of visits of the widening point reaches the widening threshold of the config.
      */
     shouldWiden(wideningPoint) {
         return (this.visited.get(control_flow_graph_1.CfgVertex.getId(wideningPoint)) ?? 0) >= this.config.ctx.config.abstractInterpretation.wideningThreshold;

package/abstract-interpretation/data-frame/mappers/arguments.d.ts

@@ -1,6 +1,6 @@
 import type { ResolveInfo } from '../../../dataflow/eval/resolve/alias-tracking';
 import type { DataflowGraph } from '../../../dataflow/graph/graph';
-import type { RNode } from '../../../r-bridge/lang-4.x/ast/model/model';
+import { RNode } from '../../../r-bridge/lang-4.x/ast/model/model';
 import type { RArgument } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-argument';
 import { type RFunctionArgument, type RFunctionCall, EmptyArgument } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RSymbol } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';

package/abstract-interpretation/data-frame/mappers/arguments.js

@@ -15,8 +15,8 @@ exports.isValidColName = isValidColName;
 exports.parseRequestContent = parseRequestContent;
 const vertex_1 = require("../../../dataflow/graph/vertex");
 const make_argument_1 = require("../../../dataflow/internal/process/functions/call/argument/make-argument");
+const model_1 = require("../../../r-bridge/lang-4.x/ast/model/model");
 const r_function_call_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
-const visitor_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/visitor");
 const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
 const convert_values_1 = require("../../../r-bridge/lang-4.x/convert-values");
 const assert_1 = require("../../../util/assert");
@@ -133,7 +133,7 @@ function getUnresolvedSymbolsInExpression(expression, dfg) {
         return [];
     }
     const unresolvedSymbols = [];
-    (0, visitor_1.visitAst)(expression, node => {
+    model_1.RNode.visitAst(expression, node => {
         if (node.type === type_1.RType.Symbol) {
             const vertex = dfg.get(node.info.id);
             if ((0, vertex_1.isUseVertex)(vertex?.[0]) && vertex[1].size === 0) {

package/abstract-interpretation/data-frame/shape-inference.d.ts

@@ -1,7 +1,6 @@
 import type { DataflowGraphVertexFunctionCall } from '../../dataflow/graph/vertex';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { AbstractInterpretationVisitor, type AbsintVisitorConfiguration } from '../absint-visitor';
-import { StateAbstractDomain } from '../domains/state-abstract-domain';
 import { DataFrameDomain } from './dataframe-domain';
 import { ConstraintType, type DataFrameOperationArgs, type DataFrameOperationName, type DataFrameOperationOptions } from './semantics';
 interface Operation<Name extends DataFrameOperationName> {
@@ -30,15 +29,13 @@ export type DataFrameOperationType<OperationName extends DataFrameOperationName
  * A possible `undefined` array of abstract data frame operations (see {@link DataFrameOperation}).
  */
 export type DataFrameOperations<OperationName extends DataFrameOperationName = DataFrameOperationName> = DataFrameOperation<OperationName>[] | undefined;
-interface DataFrameShapeInferenceConfiguration extends Omit<AbsintVisitorConfiguration<DataFrameDomain>, 'domain'> {
+interface DataFrameShapeInferenceConfiguration extends AbsintVisitorConfiguration {
     readonly trackOperations?: boolean;
 }
 /**
  * The control flow graph visitor to infer the shape of data frames using abstract interpretation
  */
-export declare class DataFrameShapeInferenceVisitor extends AbstractInterpretationVisitor<DataFrameDomain, DataFrameShapeInferenceConfiguration & {
-    domain: StateAbstractDomain<DataFrameDomain>;
-}> {
+export declare class DataFrameShapeInferenceVisitor extends AbstractInterpretationVisitor<DataFrameDomain, DataFrameShapeInferenceConfiguration> {
     /**
      * The abstract data frame operations the function call nodes are mapped to.
      */

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataFrameShapeInferenceVisitor = void 0;
 const absint_visitor_1 = require("../absint-visitor");
-const state_abstract_domain_1 = require("../domains/state-abstract-domain");
 const dataframe_domain_1 = require("./dataframe-domain");
 const access_mapper_1 = require("./mappers/access-mapper");
 const function_mapper_1 = require("./mappers/function-mapper");
@@ -17,7 +16,7 @@ class DataFrameShapeInferenceVisitor extends absint_visitor_1.AbstractInterpreta
      */
     operations;
     constructor({ trackOperations = true, ...config }) {
-        super({ ...config, domain: state_abstract_domain_1.StateAbstractDomain.bottom() });
+        super(config);
         if (trackOperations) {
             this.operations = new Map();
         }
@@ -74,13 +73,13 @@ class DataFrameShapeInferenceVisitor extends absint_visitor_1.AbstractInterpreta
             value = (0, semantics_1.applyDataFrameSemantics)(operation, operandValue ?? dataframe_domain_1.DataFrameDomain.top(maxColNames), args, options);
             const constraintType = type ?? (0, semantics_1.getConstraintType)(operation);
             if (operand !== undefined && constraintType === semantics_1.ConstraintType.OperandModification) {
-                this.currentState.set(operand, value);
+                this.updateState(operand, value);
                 for (const origin of this.getVariableOrigins(operand)) {
-                    this.currentState.set(origin, value);
+                    this.updateState(origin, value);
                 }
             }
             else if (constraintType === semantics_1.ConstraintType.ResultPostcondition) {
-                this.currentState.set(node.info.id, value);
+                this.updateState(node.info.id, value);
             }
         }
     }

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

@@ -55,14 +55,14 @@ export declare abstract class AbstractDomain<Concrete, Abstract, Top, Bot, Value
     abstract isValue(): this is AbstractDomain<Concrete, Abstract, Top, Bot, Abstract>;
     /**
      * Joins an array of abstract values by joining the first abstract value with the other values in the array.
-     * The provided array of abstract values cannot be empty!
+     * The provided array of abstract values must not be empty or a default value must be provided!
      */
-    static joinAll<Domain extends AnyAbstractDomain>(values: Domain[]): Domain;
+    static joinAll<Domain extends AnyAbstractDomain>(values: Domain[], defaultValue?: Domain): Domain;
     /**
      * Meets an array of abstract values by meeting the first abstract value with the other values in the array.
-     * The provided array of abstract values cannot be empty!
+     * The provided array of abstract values must not be empty or a default value must be provided!
      */
-    static meetAll<Domain extends AnyAbstractDomain>(values: Domain[]): Domain;
+    static meetAll<Domain extends AnyAbstractDomain>(values: Domain[], defaultValue?: Domain): Domain;
 }
 /**
  * A type representing any abstract domain without additional information.

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

@@ -48,19 +48,19 @@ class AbstractDomain {
     }
     /**
      * Joins an array of abstract values by joining the first abstract value with the other values in the array.
-     * The provided array of abstract values cannot be empty!
+     * The provided array of abstract values must not be empty or a default value must be provided!
      */
-    static joinAll(values) {
-        (0, assert_1.guard)(values.length > 0, 'Abstract values to join cannot be empty');
-        return values[0].joinAll(values.slice(1));
+    static joinAll(values, defaultValue) {
+        (0, assert_1.guard)(values.length > 0 || defaultValue !== undefined, 'Abstract values to join cannot be empty');
+        return values[0]?.joinAll(values.slice(1)) ?? defaultValue;
     }
     /**
      * Meets an array of abstract values by meeting the first abstract value with the other values in the array.
-     * The provided array of abstract values cannot be empty!
+     * The provided array of abstract values must not be empty or a default value must be provided!
      */
-    static meetAll(values) {
-        (0, assert_1.guard)(values.length > 0, 'Abstract values to meet cannot be empty');
-        return values[0].meetAll(values.slice(1));
+    static meetAll(values, defaultValue) {
+        (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;

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

@@ -1,19 +1,19 @@
 import { AbstractDomain, type AnyAbstractDomain, type ConcreteDomain } from './abstract-domain';
 import { Top } from './lattice';
 /** The type of the concrete mapping of the concrete domain of a mapped abstract domain mapping keys to a concrete value in the concrete domain */
-type ConcreteMap<Key, Domain extends AnyAbstractDomain> = ReadonlyMap<Key, ConcreteDomain<Domain>>;
+export type ConcreteMap<Key, Domain extends AnyAbstractDomain> = ReadonlyMap<Key, ConcreteDomain<Domain>>;
 /**
  * A mapped abstract domain as mapping of keys to abstract values of an abstract domain.
  * The Bottom element is defined as empty mapping and the Top element is defined as mapping every existing key to Top.
  * @template Key       - Type of the keys of the mapping to abstract values
  * @template Domain    - Type of the abstract domain to map the keys to
  */
-export declare abstract class MappedAbstractDomain<Key, Domain extends AnyAbstractDomain> extends AbstractDomain<ConcreteMap<Key, Domain>, ReadonlyMap<Key, Domain>, ReadonlyMap<Key, Domain>, ReadonlyMap<Key, Domain>> {
+export declare class MappedAbstractDomain<Key, Domain extends AnyAbstractDomain> extends AbstractDomain<ConcreteMap<Key, Domain>, ReadonlyMap<Key, Domain>, ReadonlyMap<Key, Domain>, ReadonlyMap<Key, Domain>> {
     constructor(value: ReadonlyMap<Key, Domain>);
-    abstract create(value: ReadonlyMap<Key, Domain>): this;
+    create(value: ReadonlyMap<Key, Domain>): this;
     get(key: Key): Domain | undefined;
     has(key: Key): boolean;
-    set(key: Key, value: Domain): void;
+    protected set(key: Key, value: Domain): void;
     protected remove(key: Key): void;
     bottom(): this;
     top(): this;
@@ -31,4 +31,11 @@ export declare abstract class MappedAbstractDomain<Key, Domain extends AnyAbstra
     isBottom(): this is this;
     isValue(): this is this;
 }
-export {};
+/**
+ * A mutable version of the {@link MappedAbstractDomain} with {@link MutableMappedAbstractDomain#set|`set`} and {@link MutableMappedAbstractDomain#remove|`remove`}.
+ */
+export declare class MutableMappedAbstractDomain<Key, Domain extends AnyAbstractDomain> extends MappedAbstractDomain<Key, Domain> {
+    create(value: ReadonlyMap<Key, Domain>): this;
+    set(key: Key, value: Domain): void;
+    remove(key: Key): void;
+}

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MappedAbstractDomain = void 0;
+exports.MutableMappedAbstractDomain = exports.MappedAbstractDomain = void 0;
 const abstract_domain_1 = require("./abstract-domain");
 const lattice_1 = require("./lattice");
 /**
@@ -13,6 +13,9 @@ class MappedAbstractDomain extends abstract_domain_1.AbstractDomain {
     constructor(value) {
         super(new Map(value));
     }
+    create(value) {
+        return new MappedAbstractDomain(value);
+    }
     get(key) {
         return this._value.get(key);
     }
@@ -122,50 +125,56 @@ class MappedAbstractDomain extends abstract_domain_1.AbstractDomain {
         return result;
     }
     concretize(limit) {
-        if (this.value.values().some(value => value.isBottom())) {
+        if (this.value.size === 0) {
             return new Set();
         }
-        let states = new Set([new Map()]);
+        let mappings = new Set([new Map()]);
         for (const [key, value] of this.value) {
             const concreteValues = value.concretize(limit);
             if (concreteValues === lattice_1.Top) {
                 return lattice_1.Top;
             }
-            const newStates = new Set();
-            for (const state of states) {
+            const newMappings = new Set();
+            for (const state of mappings) {
                 for (const concrete of concreteValues) {
-                    if (newStates.size > limit) {
+                    if (newMappings.size > limit) {
                         return lattice_1.Top;
                     }
                     const map = new Map(state);
                     map.set(key, concrete);
-                    newStates.add(map);
+                    newMappings.add(map);
                 }
             }
-            states = newStates;
+            mappings = newMappings;
         }
-        return states;
+        return mappings;
     }
     abstract(concrete) {
-        const entry = [...this.value.values()][0];
-        if (concrete === lattice_1.Top || entry === undefined) {
-            return this.create(new Map());
-        }
-        const mappings = new Map();
-        for (const state of concrete) {
-            for (const [key, value] of state) {
-                const mapping = mappings.get(key);
-                if (mapping === undefined) {
-                    mappings.set(key, new Set([value]));
+        if (concrete === lattice_1.Top) {
+            return this.top();
+        }
+        else if (concrete.size === 0) {
+            return this.bottom();
+        }
+        const domain = this.value.values().toArray()[0];
+        if (domain === undefined) {
+            return this.top();
+        }
+        const mapping = new Map();
+        for (const concreteMapping of concrete) {
+            for (const [key, value] of concreteMapping) {
+                const set = mapping.get(key);
+                if (set === undefined) {
+                    mapping.set(key, new Set([value]));
                 }
                 else {
-                    mapping.add(value);
+                    set.add(value);
                 }
             }
         }
         const result = new Map();
-        for (const [key, values] of mappings) {
-            result.set(key, entry.abstract(values));
+        for (const [key, values] of mapping) {
+            result.set(key, domain.abstract(values));
         }
         return this.create(result);
     }
@@ -176,7 +185,7 @@ class MappedAbstractDomain extends abstract_domain_1.AbstractDomain {
         return '(' + this.value.entries().toArray().map(([key, value]) => `${(0, abstract_domain_1.domainElementToString)(key)} -> ${value.toString()}`).join(', ') + ')';
     }
     isTop() {
-        return this.value.size > 0 && this.value.values().every(value => value.isTop());
+        return this.value.values().some(entry => entry.isTop());
     }
     isBottom() {
         return this.value.size === 0;
@@ -186,4 +195,19 @@ class MappedAbstractDomain extends abstract_domain_1.AbstractDomain {
     }
 }
 exports.MappedAbstractDomain = MappedAbstractDomain;
+/**
+ * A mutable version of the {@link MappedAbstractDomain} with {@link MutableMappedAbstractDomain#set|`set`} and {@link MutableMappedAbstractDomain#remove|`remove`}.
+ */
+class MutableMappedAbstractDomain extends MappedAbstractDomain {
+    create(value) {
+        return new MutableMappedAbstractDomain(value);
+    }
+    set(key, value) {
+        super.set(key, value);
+    }
+    remove(key) {
+        super.remove(key);
+    }
+}
+exports.MutableMappedAbstractDomain = MutableMappedAbstractDomain;
 //# sourceMappingURL=mapped-abstract-domain.js.map

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

@@ -61,7 +61,7 @@ class SetRangeDomain extends abstract_domain_1.AbstractDomain {
         if (this.value === lattice_1.Bottom) {
             return lattice_1.Bottom;
         }
-        else if (this.value.range == lattice_1.Top) {
+        else if (this.value.range === lattice_1.Top) {
             return lattice_1.Top;
         }
         return this.value.min.union(this.value.range);

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

@@ -1,5 +1,7 @@
 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';
 /**
  * A state abstract domain as mapping of AST node IDs of a program to abstract values of an abstract domain.
@@ -8,8 +10,35 @@ import { MappedAbstractDomain } from './mapped-abstract-domain';
  * @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;
+    protected set(key: NodeId, value: Domain): void;
+    bottom(): this;
+    top(): this;
+    equals(other: this): boolean;
+    leq(other: this): boolean;
+    join(other: this): this;
+    meet(other: this): this;
+    widen(other: this): this;
+    narrow(other: this): this;
+    concretize(limit: number): ReadonlySet<ConcreteMap<NodeId, Domain>> | typeof Top;
+    abstract(concrete: typeof Top | ReadonlySet<ConcreteMap<NodeId, Domain>>): this;
+    toJson(): unknown;
+    toString(): string;
+    isTop(): this is this;
+    isBottom(): this is this;
+    isValue(): this is this;
+}
+/**
+ * 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;
-    static bottom<Domain extends AnyAbstractDomain>(): StateAbstractDomain<Domain>;
+    set(key: NodeId, value: Domain): void;
+    remove(key: NodeId): void;
 }
 /**
  * The type of the value abstract domain of a state abstract domain (i.e. the abstract domain a state abstract domain maps to).