@eagleoutice/flowr 2.9.14 → 2.10.2

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 {};

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

@@ -1,130 +1,231 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MutableStateAbstractDomain = exports.StateAbstractDomain = void 0;
+const abstract_domain_1 = require("./abstract-domain");
 const lattice_1 = require("./lattice");
-const mapped_abstract_domain_1 = require("./mapped-abstract-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
+ * 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
  */
-class StateAbstractDomain extends mapped_abstract_domain_1.MappedAbstractDomain {
-    _isBottom;
-    constructor(value, bottom) {
-        super(value);
-        if (bottom || value.values().some(entry => entry.isBottom())) {
-            this._isBottom = true;
+class StateAbstractDomain extends abstract_domain_1.AbstractDomain {
+    domain;
+    constructor(value, domain) {
+        if (value === lattice_1.Bottom || value.values().some(entry => entry.isBottom())) {
+            super(lattice_1.Bottom);
         }
+        else {
+            super(new Map(value));
+        }
+        this.domain = domain;
+    }
+    create(value) {
+        return new StateAbstractDomain(value, this.domain);
+    }
+    static top(domain) {
+        return new StateAbstractDomain(new Map(), domain);
     }
-    create(value, bottom) {
-        return new StateAbstractDomain(value, bottom ?? this._isBottom);
+    static bottom(domain) {
+        return new StateAbstractDomain(lattice_1.Bottom, domain);
     }
-    static top() {
-        return new StateAbstractDomain(new Map());
+    get(key) {
+        return this.value === lattice_1.Bottom ? this.domain.bottom() : this.value.get(key);
     }
-    get(key, ignoreBottom) {
-        return this._isBottom && !ignoreBottom ? super.get(key)?.bottom() : super.get(key);
+    has(key) {
+        return this.value !== lattice_1.Bottom && this.value.has(key);
     }
     set(key, value) {
-        if (value.isBottom()) {
-            this._isBottom = true;
+        if (this.value === lattice_1.Bottom) {
+            this._value = new Map();
         }
-        super.set(key, value);
+        this._value.set(key, value);
     }
-    bottom() {
-        return this.create(this.value, true);
+    remove(key) {
+        if (this.value !== lattice_1.Bottom) {
+            this._value.delete(key);
+        }
     }
     top() {
-        return this.create(new Map());
+        return StateAbstractDomain.top(this.domain);
+    }
+    bottom() {
+        return StateAbstractDomain.bottom(this.domain);
     }
     equals(other) {
-        if (this._isBottom !== other._isBottom) {
+        if (this.value === other.value) {
+            return true;
+        }
+        else if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom || this.value.size !== other.value.size) {
             return false;
         }
-        return super.equals(other);
+        for (const [key, value] of this.value.entries()) {
+            const otherValue = other.get(key);
+            if (otherValue === undefined || !value.equals(otherValue)) {
+                return false;
+            }
+        }
+        return true;
     }
     leq(other) {
-        if (this._isBottom) {
+        if (this.value === other.value || this.value === lattice_1.Bottom) {
             return true;
         }
-        else if (other._isBottom) {
+        else if (other.value === lattice_1.Bottom || this.value.size > other.value.size) {
             return false;
         }
-        return super.leq(other);
+        for (const [key, value] of this.value.entries()) {
+            const otherValue = other.get(key);
+            if (otherValue === undefined || !value.leq(otherValue)) {
+                return false;
+            }
+        }
+        return true;
     }
     join(other) {
-        if (this._isBottom) {
-            return other.create(other.value);
+        if (this.value === lattice_1.Bottom) {
+            return this.create(other.value);
         }
-        else if (other._isBottom) {
+        else if (other.value === lattice_1.Bottom) {
             return this.create(this.value);
         }
-        return super.join(other);
+        const result = this.create(this.value);
+        for (const [key, value] of other.value.entries()) {
+            const currValue = result.get(key);
+            if (currValue === undefined) {
+                result.set(key, value);
+            }
+            else {
+                result.set(key, currValue.join(value));
+            }
+        }
+        return result;
     }
     meet(other) {
-        const result = super.meet(other);
-        result._isBottom = this._isBottom || other._isBottom;
+        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        const result = this.create(this.value);
+        for (const key of result.value.keys()) {
+            if (!other.has(key)) {
+                result.remove(key);
+            }
+        }
+        for (const [key, value] of other.value.entries()) {
+            const currValue = result.get(key);
+            if (currValue !== undefined) {
+                result.set(key, currValue.meet(value));
+            }
+        }
         return result;
     }
     widen(other) {
-        if (this._isBottom) {
-            return other.create(other.value);
+        if (this.value === lattice_1.Bottom) {
+            return this.create(other.value);
         }
-        else if (other._isBottom) {
+        else if (other.value === lattice_1.Bottom) {
             return this.create(this.value);
         }
-        return super.widen(other);
+        const result = this.create(this.value);
+        for (const [key, value] of other.value.entries()) {
+            const currValue = result.get(key);
+            if (currValue === undefined) {
+                result.set(key, value);
+            }
+            else {
+                result.set(key, currValue.widen(value));
+            }
+        }
+        return result;
     }
     narrow(other) {
-        const result = super.narrow(other);
-        result._isBottom = this._isBottom || other._isBottom;
+        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        const result = this.create(this.value);
+        for (const key of result.value.keys()) {
+            if (!other.has(key)) {
+                result.remove(key);
+            }
+        }
+        for (const [key, value] of other.value.entries()) {
+            const currValue = result.get(key);
+            if (currValue !== undefined) {
+                result.set(key, currValue.narrow(value));
+            }
+        }
         return result;
     }
     concretize(limit) {
-        if (this._isBottom) {
+        if (this.value === lattice_1.Bottom) {
             return new Set();
         }
-        else if (this.value.size === 0) {
-            return lattice_1.Top;
-        }
-        return super.concretize(limit);
+        let mappings = new Set([new Map()]);
+        for (const [key, value] of this.value.entries()) {
+            const concreteValues = value.concretize(limit);
+            if (concreteValues === lattice_1.Top) {
+                return lattice_1.Top;
+            }
+            const newMappings = new Set();
+            for (const state of mappings) {
+                for (const concrete of concreteValues) {
+                    if (newMappings.size > limit) {
+                        return lattice_1.Top;
+                    }
+                    const map = new Map(state);
+                    map.set(key, concrete);
+                    newMappings.add(map);
+                }
+            }
+            mappings = newMappings;
+        }
+        return mappings;
     }
     abstract(concrete) {
         if (concrete === lattice_1.Top) {
             return this.top();
         }
         else if (concrete.size === 0) {
-            return this.create(new Map(), true);
-        }
-        return super.abstract(concrete);
+            return this.bottom();
+        }
+        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 {
+                    set.add(value);
+                }
+            }
+        }
+        const result = new Map();
+        for (const [key, values] of mapping) {
+            result.set(key, this.domain.abstract(values));
+        }
+        return this.create(result);
     }
     toJson() {
-        if (this._isBottom) {
-            return lattice_1.BottomSymbol;
-        }
-        else if (this.value.size === 0) {
-            return lattice_1.TopSymbol;
+        if (this.value === lattice_1.Bottom) {
+            return this.value.description;
         }
-        return super.toJson();
+        return Object.fromEntries(this.value.entries().map(([key, value]) => [key, value.toJson()]));
     }
     toString() {
-        if (this._isBottom) {
+        if (this.value === lattice_1.Bottom) {
             return lattice_1.BottomSymbol;
         }
-        else if (this.value.size === 0) {
-            return lattice_1.TopSymbol;
-        }
-        return super.toString();
+        return '(' + this.value.entries().toArray().map(([key, value]) => `${(0, abstract_domain_1.domainElementToString)(key)} -> ${value.toString()}`).join(', ') + ')';
     }
     isTop() {
-        return this.value.size === 0;
+        return this.value !== lattice_1.Bottom && this.value.size === 0;
     }
     isBottom() {
-        return this._isBottom ?? false;
+        return this.value == lattice_1.Bottom;
     }
     isValue() {
-        return !this._isBottom;
+        return this.value !== lattice_1.Bottom;
     }
 }
 exports.StateAbstractDomain = StateAbstractDomain;
@@ -133,7 +234,13 @@ exports.StateAbstractDomain = StateAbstractDomain;
  */
 class MutableStateAbstractDomain extends StateAbstractDomain {
     create(value) {
-        return new MutableStateAbstractDomain(value);
+        return new MutableStateAbstractDomain(value, this.domain);
+    }
+    static top(domain) {
+        return new MutableStateAbstractDomain(new Map(), domain);
+    }
+    static bottom(domain) {
+        return new MutableStateAbstractDomain(lattice_1.Bottom, domain);
     }
     set(key, value) {
         super.set(key, value);

package/abstract-interpretation/unsupported-functions.d.ts

@@ -0,0 +1,10 @@
+import { type DataflowGraphVertexArgument } from '../dataflow/graph/vertex';
+/**
+ * Helper for unsupported functions that may change the environment.
+ */
+export declare const UnsupportedFunctions: {
+    /**
+     * Checks whether a data flow graph vertex represents a unsupported (environment-changing) function call (e.g. `eval`, `load`, `attach`, `rm`, ...)
+     */
+    isUnsupportedCall(this: void, vertex: DataflowGraphVertexArgument | undefined): boolean;
+};

package/abstract-interpretation/unsupported-functions.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedFunctions = void 0;
+const identifier_1 = require("../dataflow/environments/identifier");
+const vertex_1 = require("../dataflow/graph/vertex");
+/**
+ * List of known function calls that may change the environment unresolvable/implicitly.
+ */
+const UnsupportedFunctionsList = {
+    '.Primitive': { package: 'base' },
+    '.Internal': { package: 'base' },
+    '.External': { package: 'base' },
+    '.Call': { package: 'base' },
+    '.C': { package: 'base' },
+    '.Fortran': { package: 'base' },
+    '.dyn.load': { package: 'base' },
+    'eval': { package: 'base' },
+    'evalq': { package: 'base' },
+    'eval.parent': { package: 'base' },
+    'eval_tidy': { package: 'rlang' },
+    'eval_bare': { package: 'rlang' },
+    'body<-': { package: 'base' },
+    'formals<-': { package: 'base' },
+    'environment<-': { package: 'base' },
+    'load': { package: 'base' },
+    'attach': { package: 'base' },
+    'detach': { package: 'base' },
+    'rm': { package: 'base' },
+    'remove': { package: 'base' },
+    'list2env': { package: 'base' },
+    'assignInNamespace': { package: 'utils' },
+    'assignInMyNamespace': { package: 'utils' },
+};
+/**
+ * Helper for unsupported functions that may change the environment.
+ */
+exports.UnsupportedFunctions = {
+    /**
+     * Checks whether a data flow graph vertex represents a unsupported (environment-changing) function call (e.g. `eval`, `load`, `attach`, `rm`, ...)
+     */
+    isUnsupportedCall(vertex) {
+        return (0, vertex_1.isFunctionCallVertex)(vertex) && Object.hasOwn(UnsupportedFunctionsList, identifier_1.Identifier.getName(vertex.name));
+    }
+};
+//# sourceMappingURL=unsupported-functions.js.map

package/benchmark/slicer.js

@@ -26,7 +26,6 @@ const arrays_1 = require("../util/collections/arrays");
 const config_1 = require("../config");
 const extract_cfg_1 = require("../control-flow/extract-cfg");
 const shape_inference_1 = require("../abstract-interpretation/data-frame/shape-inference");
-const lattice_1 = require("../abstract-interpretation/domains/lattice");
 const set_range_domain_1 = require("../abstract-interpretation/domains/set-range-domain");
 const fs_1 = __importDefault(require("fs"));
 const flowr_analyzer_context_1 = require("../project/context/flowr-analyzer-context");
@@ -269,9 +268,9 @@ class BenchmarkSlicer {
         const inference = new shape_inference_1.DataFrameShapeInferenceVisitor({ controlFlow: cfinfo, dfg, normalizedAst: ast, ctx: this.context });
         this.measureSimpleStep('infer data frame shapes', () => inference.start());
         const result = inference.getEndState();
-        stats.numberOfResultConstraints = result.value.size;
-        stats.sizeOfInfo = (0, size_of_1.safeSizeOf)([inference.getAbstractTrace()]);
-        for (const value of result.value.values()) {
+        stats.numberOfResultConstraints = result.isValue() ? result.value.size : 0;
+        stats.sizeOfInfo = (0, size_of_1.safeSizeOf)(inference.getAbstractTrace().entries().toArray());
+        for (const value of result.isValue() ? result.value.values() : []) {
             if (value.isTop()) {
                 stats.numberOfResultingTop++;
             }
@@ -290,8 +289,9 @@ class BenchmarkSlicer {
                 stats.numberOfEmptyNodes++;
                 return;
             }
+            const state = inference.getAbstractState(node.info.id);
             const nodeStats = {
-                numberOfEntries: inference.getAbstractState(node.info.id)?.value.size ?? 0
+                numberOfEntries: state?.isValue() ? state.value.size : 0
             };
             if (operations !== undefined) {
                 nodeStats.mappedOperations = operations.map(op => op.operation);
@@ -322,7 +322,7 @@ class BenchmarkSlicer {
     getInferredRange(value) {
         if (value.isValue()) {
             if (value instanceof set_range_domain_1.SetRangeDomain) {
-                return value.value.range === lattice_1.Top ? Infinity : value.value.range.size;
+                return value.isFinite() ? value.value.range.size : Infinity;
             }
             else {
                 return value.value[1] - value.value[0];
@@ -335,16 +335,13 @@ class BenchmarkSlicer {
             return 'top';
         }
         else if (value.isValue()) {
-            if (value instanceof set_range_domain_1.SetRangeDomain) {
-                if (value.value.range === lattice_1.Top) {
-                    return 'infinite';
-                }
+            if (!value.isFinite()) {
+                return 'infinite';
+            }
+            else if (value instanceof set_range_domain_1.SetRangeDomain) {
                 return Math.floor(value.value.min.size + (value.value.range.size / 2));
             }
             else {
-                if (!isFinite(value.value[1])) {
-                    return 'infinite';
-                }
                 return Math.floor((value.value[0] + value.value[1]) / 2);
             }
         }

package/benchmark/stats/stats.d.ts

@@ -1,4 +1,4 @@
-import type { SingleSlicingCriterion, SlicingCriteria } from '../../slicing/criterion/parse';
+import type { SlicingCriterion, SlicingCriteria } from '../../slicing/criterion/parse';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { ReconstructionResult } from '../../reconstruct/reconstruct';
 import type { RParseRequestFromFile, RParseRequestFromText } from '../../r-bridge/retriever';
@@ -15,7 +15,7 @@ export type ElapsedTime = bigint;
 export interface PerSliceStats {
     measurements: Map<PerSliceMeasurements, ElapsedTime>;
     slicingCriteria: {
-        criterion: SingleSlicingCriterion;
+        criterion: SlicingCriterion;
         id: NodeId;
     }[];
     reconstructedCode: ReconstructionResult;

package/cli/flowr.js

@@ -140,7 +140,7 @@ async function mainRepl() {
         await (0, print_version_1.printVersionRepl)(defaultEngine);
         const w = (x) => ansi_1.ansiFormatter.format(x, { color: 7 /* Colors.White */, effect: ansi_1.ColorEffect.Foreground, style: 3 /* FontStyles.Italic */ });
         console.log(w('use ') + ansi_1.ansiFormatter.format(':help', { color: 7 /* Colors.White */, effect: ansi_1.ColorEffect.Foreground, style: 1 /* FontStyles.Bold */ }) + w(' to get a list of available commands.'));
-        await (0, core_1.repl)({ analyzer: analyzer, allowRSessionAccess });
+        await (0, core_1.repl)({ analyzer, allowRSessionAccess });
     }
     process.exit(0);
 }

package/cli/repl/parser/slice-query-parser.d.ts

@@ -1,4 +1,4 @@
-import type { SingleSlicingCriterion, SlicingCriteria } from '../../../slicing/criterion/parse';
+import type { SlicingCriterion, SlicingCriteria } from '../../../slicing/criterion/parse';
 import { SliceDirection } from '../../../util/slice-direction';
 /**
  * Checks whether the given argument represents a slicing direction with an `f` suffix.
@@ -7,7 +7,7 @@ export declare function sliceDirectionParser(argument: string): SliceDirection;
 /**
  * Parses a single slicing criterion from the given argument.
  */
-export declare function sliceCriterionParser(argument: string | undefined): SingleSlicingCriterion | undefined;
+export declare function sliceCriterionParser(argument: string | undefined): SlicingCriterion | undefined;
 /**
  * Parses multiple slicing criteria from the given argument.
  */

package/config.d.ts

@@ -159,6 +159,10 @@ export interface FlowrConfig extends MergeableRecord {
              * The maximum number of iterations to perform on a single function call during slicing
              */
             readonly threshold?: number;
+            /**
+             * If set, the slicer will gain an additional post-pass
+             */
+            readonly autoExtend?: boolean;
         };
     };
     /**