@eagleoutice/flowr 2.0.15 → 2.0.17

package/reconstruct/reconstruct.js

@@ -268,8 +268,8 @@ function reconstructArgument(argument, name, value) {
     }
 }
 function reconstructParameter(parameter, name, defaultValue, configuration) {
-    if (!isSelected(configuration, parameter)) {
-        return [];
+    if (isSelected(configuration, parameter)) {
+        return plain(getLexeme(parameter));
     }
     if (parameter.defaultValue !== undefined && name.length > 0) {
         return plain(`${getLexeme(parameter.name)}=${getLexeme(parameter.defaultValue)}`);
@@ -282,7 +282,7 @@ function reconstructParameter(parameter, name, defaultValue, configuration) {
     }
 }
 function reconstructFunctionDefinition(definition, functionParameters, body, config) {
-    // if a definition is not selected, we only use the body - slicing will always select the definition
+    // if a definition is not selected, we only use the body - slicing will always select the definition if it is required
     if (functionParameters.every(p => p.length === 0)) {
         const empty = body === undefined || body.length === 0;
         const selected = isSelected(config, definition);

package/slicing/criterion/parse.d.ts

@@ -1,6 +1,5 @@
-import type { NoInfo } from '../../r-bridge/lang-4.x/ast/model/model';
 import { type NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 /** Either `line:column`, `line@variable-name`, or `$id` */
 export type SingleSlicingCriterion = `${number}:${number}` | `${number}@${string}` | `$${number}`;
 export type SlicingCriteria = SingleSlicingCriterion[];
@@ -13,10 +12,10 @@ export declare class CriteriaParseError extends Error {
 /**
  * Takes a criterion in the form of `line:column` or `line@variable-name` and returns the corresponding node id
  */
-export declare function slicingCriterionToId<OtherInfo = NoInfo>(criterion: SingleSlicingCriterion, decorated: NormalizedAst<OtherInfo & ParentInformation>): NodeId;
+export declare function slicingCriterionToId(criterion: SingleSlicingCriterion, idMap: AstIdMap): NodeId;
 export interface DecodedCriterion {
     criterion: SingleSlicingCriterion;
     id: NodeId;
 }
 export type DecodedCriteria = ReadonlyArray<DecodedCriterion>;
-export declare function convertAllSlicingCriteriaToIds(criteria: SlicingCriteria, decorated: NormalizedAst): DecodedCriteria;
+export declare function convertAllSlicingCriteriaToIds(criteria: SlicingCriteria, decorated: AstIdMap): DecodedCriteria;

package/slicing/criterion/parse.js

@@ -17,18 +17,18 @@ exports.CriteriaParseError = CriteriaParseError;
 /**
  * Takes a criterion in the form of `line:column` or `line@variable-name` and returns the corresponding node id
  */
-function slicingCriterionToId(criterion, decorated) {
+function slicingCriterionToId(criterion, idMap) {
     let resolved;
     if (criterion.startsWith('$')) {
         resolved = (0, node_id_1.normalizeIdToNumberIfPossible)(criterion.substring(1));
     }
     else if (criterion.includes(':')) {
         const [line, column] = criterion.split(':').map(c => parseInt(c));
-        resolved = locationToId([line, column], decorated.idMap);
+        resolved = locationToId([line, column], idMap);
     }
     else if (criterion.includes('@')) {
         const [line, name] = criterion.split(/@(.*)/s); // only split at first occurrence
-        resolved = conventionalCriteriaToId(parseInt(line), name, decorated.idMap);
+        resolved = conventionalCriteriaToId(parseInt(line), name, idMap);
     }
     if (resolved === undefined) {
         throw new CriteriaParseError(`invalid slicing criterion ${criterion}`);

package/slicing/static/slice-call.js

@@ -7,6 +7,7 @@ const linker_1 = require("../../dataflow/internal/linker");
 const environment_1 = require("../../dataflow/environments/environment");
 const scoping_1 = require("../../dataflow/environments/scoping");
 const overwrite_1 = require("../../dataflow/environments/overwrite");
+const graph_1 = require("../../dataflow/graph/graph");
 const built_in_1 = require("../../dataflow/environments/built-in");
 const resolve_by_name_1 = require("../../dataflow/environments/resolve-by-name");
 const edge_1 = require("../../dataflow/graph/edge");
@@ -23,6 +24,31 @@ function retrieveActiveEnvironment(callerInfo, baseEnvironment) {
     }
     return (0, overwrite_1.overwriteEnvironment)(baseEnvironment, callerEnvironment);
 }
+function includeArgumentFunctionCallClosure(arg, baseEnvironment, activeEnvironment, queue, dataflowGraph) {
+    const valueRoot = (0, graph_1.getReferenceOfArgument)(arg);
+    if (!valueRoot) {
+        return;
+    }
+    const callTargets = (0, linker_1.getAllLinkedFunctionDefinitions)(new Set([valueRoot]), dataflowGraph);
+    linkCallTargets(false, callTargets, baseEnvironment, (0, fingerprint_1.envFingerprint)(baseEnvironment), activeEnvironment, (0, fingerprint_1.envFingerprint)(activeEnvironment), queue);
+}
+function linkCallTargets(onlyForSideEffects, functionCallTargets, baseEnvironment, baseEnvPrint, activeEnvironment, activeEnvironmentFingerprint, queue) {
+    for (const functionCallTarget of functionCallTargets) {
+        // all those linked within the scopes of other functions are already linked when exiting a function definition
+        for (const openIn of functionCallTarget.subflow.in) {
+            const defs = openIn.name ? (0, resolve_by_name_1.resolveByName)(openIn.name, activeEnvironment) : undefined;
+            if (defs === undefined) {
+                continue;
+            }
+            for (const def of defs.filter(d => d.nodeId !== built_in_1.BuiltIn)) {
+                queue.add(def.nodeId, baseEnvironment, baseEnvPrint, onlyForSideEffects);
+            }
+        }
+        for (const exitPoint of functionCallTarget.exitPoints) {
+            queue.add(exitPoint, activeEnvironment, activeEnvironmentFingerprint, onlyForSideEffects);
+        }
+    }
+}
 /** returns the new threshold hit count */
 function sliceForCall(current, callerInfo, dataflowGraph, queue) {
     // bind with call-local environments during slicing
@@ -42,21 +68,17 @@ function sliceForCall(current, callerInfo, dataflowGraph, queue) {
         }
     }
     const functionCallTargets = (0, linker_1.getAllLinkedFunctionDefinitions)(new Set(functionCallDefs), dataflowGraph);
-    for (const functionCallTarget of functionCallTargets) {
-        // all those linked within the scopes of other functions are already linked when exiting a function definition
-        for (const openIn of functionCallTarget.subflow.in) {
-            const defs = openIn.name ? (0, resolve_by_name_1.resolveByName)(openIn.name, activeEnvironment) : undefined;
-            if (defs === undefined) {
-                continue;
-            }
-            for (const def of defs.filter(d => d.nodeId !== built_in_1.BuiltIn)) {
-                queue.add(def.nodeId, baseEnvironment, baseEnvPrint, current.onlyForSideEffects);
-            }
-        }
-        for (const exitPoint of functionCallTarget.exitPoints) {
-            queue.add(exitPoint, activeEnvironment, activeEnvironmentFingerprint, current.onlyForSideEffects);
+    if (functionCallTargets.size === 0) {
+        /*
+         * if we do not have any call to resolve this function, we have to assume that every function passed is actually called!
+         * hence, we add a new flag and add all argument values to the queue causing directly
+         */
+        for (const arg of callerInfo.args) {
+            includeArgumentFunctionCallClosure(arg, baseEnvironment, activeEnvironment, queue, dataflowGraph);
         }
+        return;
     }
+    linkCallTargets(current.onlyForSideEffects, functionCallTargets, baseEnvironment, baseEnvPrint, activeEnvironment, activeEnvironmentFingerprint, queue);
 }
 exports.sliceForCall = sliceForCall;
 /** Returns true if we found at least one return edge */

package/slicing/static/static-slicer.d.ts

@@ -13,4 +13,4 @@ export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogOb
  * @param criteria  - The criteras to slice on.
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  */
-export declare function staticSlicing(graph: DataflowGraph, ast: NormalizedAst, criteria: SlicingCriteria, threshold?: number): Readonly<SliceResult>;
+export declare function staticSlicing(graph: DataflowGraph, { idMap }: NormalizedAst, criteria: SlicingCriteria, threshold?: number): Readonly<SliceResult>;

package/slicing/static/static-slicer.js

@@ -20,9 +20,9 @@ exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
  * @param criteria  - The criteras to slice on.
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  */
-function staticSlicing(graph, ast, criteria, threshold = 75) {
+function staticSlicing(graph, { idMap }, criteria, threshold = 75) {
     (0, assert_1.guard)(criteria.length > 0, 'must have at least one seed id to calculate slice');
-    const decodedCriteria = (0, parse_1.convertAllSlicingCriteriaToIds)(criteria, ast);
+    const decodedCriteria = (0, parse_1.convertAllSlicingCriteriaToIds)(criteria, idMap);
     (0, log_1.expensiveTrace)(exports.slicerLogger, () => `calculating slice for ${decodedCriteria.length} seed criteria: ${decodedCriteria.map(s => JSON.stringify(s)).join(', ')}`);
     const queue = new visiting_queue_1.VisitingQueue(threshold);
     let minDepth = Number.MAX_SAFE_INTEGER;
@@ -34,9 +34,15 @@ function staticSlicing(graph, ast, criteria, threshold = 75) {
         for (const { id: startId } of decodedCriteria) {
             queue.add(startId, emptyEnv, basePrint, false);
             // retrieve the minimum depth of all nodes to only add control dependencies if they are "part" of the current execution
-            minDepth = Math.min(minDepth, ast.idMap.get(startId)?.info.depth ?? minDepth);
+            minDepth = Math.min(minDepth, idMap.get(startId)?.info.depth ?? minDepth);
             sliceSeedIds.add(startId);
         }
+        /* additionally,
+         * include all the implicit side effects that we have to consider as we are unable to narrow them down
+         */
+        for (const id of graph.unknownSideEffects) {
+            queue.add(id, emptyEnv, basePrint, true);
+        }
     }
     while (queue.nonEmpty()) {
         const current = queue.next();
@@ -52,7 +58,7 @@ function staticSlicing(graph, ast, criteria, threshold = 75) {
         if (currentVertex.controlDependencies && currentVertex.controlDependencies.length > 0) {
             const topLevel = graph.isRoot(id) || sliceSeedIds.has(id);
             for (const cd of currentVertex.controlDependencies.filter(({ id }) => !queue.hasId(id))) {
-                if (!topLevel || (ast.idMap.get(cd.id)?.info.depth ?? 0) <= minDepth) {
+                if (!topLevel || (idMap.get(cd.id)?.info.depth ?? 0) <= minDepth) {
                     queue.add(cd.id, baseEnvironment, baseEnvFingerprint, false);
                 }
             }

package/statistics/statistics.js

@@ -64,7 +64,7 @@ function initializeFeatureStatistics() {
     const result = {};
     for (const key of feature_1.allFeatureNames) {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        result[key] = JSON.parse(JSON.stringify(feature_1.ALL_FEATURES[key].initialValue, json_1.jsonReplacer), json_1.jsonRetriever);
+        result[key] = JSON.parse(JSON.stringify(feature_1.ALL_FEATURES[key].initialValue, json_1.jsonReplacer), json_1.jsonBigIntRetriever);
     }
     return result;
 }

package/util/json.d.ts

@@ -1,2 +1,2 @@
 export declare function jsonReplacer(key: any, value: any): any;
-export declare function jsonRetriever(key: string, value: unknown): unknown;
+export declare function jsonBigIntRetriever(key: string, value: unknown): unknown;

package/util/json.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.jsonRetriever = exports.jsonReplacer = void 0;
+exports.jsonBigIntRetriever = exports.jsonReplacer = void 0;
 // to get the types within JSON.stringify
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function jsonReplacer(key, value) {
@@ -16,7 +16,7 @@ function jsonReplacer(key, value) {
     }
 }
 exports.jsonReplacer = jsonReplacer;
-function jsonRetriever(key, value) {
+function jsonBigIntRetriever(key, value) {
     if (typeof value === 'string' && value.endsWith('n')) {
         return BigInt(value.slice(0, -1));
     }
@@ -24,5 +24,5 @@ function jsonRetriever(key, value) {
         return value;
     }
 }
-exports.jsonRetriever = jsonRetriever;
+exports.jsonBigIntRetriever = jsonBigIntRetriever;
 //# sourceMappingURL=json.js.map

package/util/logic.d.ts

@@ -1 +1,5 @@
-export type Ternary = 'always' | 'maybe' | 'never';
+export declare const enum Ternary {
+    Always = 0,
+    Maybe = 1,
+    Never = 2
+}

package/util/version.js

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

package/abstract-interpretation/domain.d.ts

@@ -1,57 +0,0 @@
-interface IntervalBound {
-    readonly value: number;
-    readonly inclusive: boolean;
-}
-export declare class Interval {
-    readonly min: IntervalBound;
-    readonly max: IntervalBound;
-    /**
-     * Build a new interval from the given bounds.
-     * If the interval represents a scalar, the min and max bounds should be equal, as well as their inclusivity.
-     * @param min - The minimum bound of the interval.
-     * @param max - The maximum bound of the interval.
-     */
-    constructor(min: IntervalBound, max: IntervalBound);
-    toString(): string;
-}
-/**
- * A domain represents a set of intervals describing a range of possible values a variable may hold.
- * In the future we may want to extend this to support more complex types.
- */
-export declare class Domain {
-    /** set of intervals to hold */
-    private readonly _intervals;
-    private constructor();
-    static bottom(): Domain;
-    static fromIntervals(intervals: readonly Interval[] | ReadonlySet<Interval>): Domain;
-    static fromScalar(n: number): Domain;
-    get intervals(): Set<Interval>;
-    private set intervals(value);
-    addInterval(interval: Interval): void;
-    toString(): string;
-}
-/**
- * Returns true if the given intervals overlap, checking for inclusivity.
- */
-export declare function doIntervalsOverlap(interval1: Interval, interval2: Interval): boolean;
-/**
- * Unifies the given domains by creating a new domain that contains all values from all given domains.
- */
-export declare function unifyDomains(domains: readonly Domain[]): Domain;
-/**
- * Unify all intervals which overlap with each other to one.
- */
-export declare function unifyOverlappingIntervals(intervals: readonly Interval[]): Interval[];
-/**
- * Returns domain1 + domain2, mapping the inclusivity.
- *
- * @see subtractDomains
- */
-export declare function addDomains(domain1: Domain, domain2: Domain): Domain;
-/**
- * Returns domain1 - domain2, mapping the inclusivity.
- *
- * @see addDomains
- */
-export declare function subtractDomains(domain1: Domain, domain2: Domain): Domain;
-export {};

package/abstract-interpretation/domain.js

@@ -1,176 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.subtractDomains = exports.addDomains = exports.unifyOverlappingIntervals = exports.unifyDomains = exports.doIntervalsOverlap = exports.Domain = exports.Interval = void 0;
-const assert_1 = require("../util/assert");
-class Interval {
-    min;
-    max;
-    /**
-     * Build a new interval from the given bounds.
-     * If the interval represents a scalar, the min and max bounds should be equal, as well as their inclusivity.
-     * @param min - The minimum bound of the interval.
-     * @param max - The maximum bound of the interval.
-     */
-    constructor(min, max) {
-        this.min = min;
-        this.max = max;
-        (0, assert_1.guard)(min.value <= max.value, () => `The interval ${this.toString()} has a minimum that is greater than its maximum`);
-        (0, assert_1.guard)(min.value !== max.value || (min.inclusive === max.inclusive), `The bound ${min.value} cannot be in- and exclusive at the same time`);
-    }
-    toString() {
-        return `${this.min.inclusive ? '[' : '('}${this.min.value}, ${this.max.value}${this.max.inclusive ? ']' : ')'}`;
-    }
-}
-exports.Interval = Interval;
-/**
- * A domain represents a set of intervals describing a range of possible values a variable may hold.
- * In the future we may want to extend this to support more complex types.
- */
-class Domain {
-    /** set of intervals to hold */
-    _intervals;
-    constructor(intervals = []) {
-        this._intervals = new Set(unifyOverlappingIntervals(intervals));
-    }
-    static bottom() {
-        return new Domain();
-    }
-    static fromIntervals(intervals) {
-        return new Domain(Array.from(intervals));
-    }
-    static fromScalar(n) {
-        return new Domain([new Interval({ value: n, inclusive: true }, { value: n, inclusive: true })]);
-    }
-    get intervals() {
-        return this._intervals;
-    }
-    set intervals(intervals) {
-        this._intervals.clear();
-        for (const interval of intervals) {
-            this._intervals.add(interval);
-        }
-    }
-    addInterval(interval) {
-        this.intervals = unifyOverlappingIntervals([...this.intervals, interval]);
-    }
-    toString() {
-        return `{${Array.from(this.intervals).join(', ')}}`;
-    }
-}
-exports.Domain = Domain;
-function compareIntervals(compareType, interval1, interval2) {
-    const diff = interval1.value - interval2.value;
-    if (diff !== 0 || compareType === 2 /* CompareType.IgnoreInclusivity */) {
-        return diff;
-    }
-    switch (compareType) {
-        case 0 /* CompareType.Min */:
-            return Number(!interval1.inclusive) - Number(!interval2.inclusive);
-        case 1 /* CompareType.Max */:
-            return Number(interval1.inclusive) - Number(interval2.inclusive);
-        default:
-            (0, assert_1.assertUnreachable)(compareType);
-    }
-}
-function compareIntervalsByTheirMinimum(interval1, interval2) {
-    return compareIntervals(0 /* CompareType.Min */, interval1.min, interval2.min);
-}
-function compareIntervalsByTheirMaximum(interval1, interval2) {
-    return compareIntervals(1 /* CompareType.Max */, interval1.max, interval2.max);
-}
-/**
- * Returns true if the given intervals overlap, checking for inclusivity.
- */
-function doIntervalsOverlap(interval1, interval2) {
-    const diff1 = compareIntervals(2 /* CompareType.IgnoreInclusivity */, interval1.max, interval2.min);
-    const diff2 = compareIntervals(2 /* CompareType.IgnoreInclusivity */, interval2.max, interval1.min);
-    // If one interval ends before the other starts, they don't overlap
-    if (diff1 < 0 || diff2 < 0) {
-        return false;
-    }
-    // If their end and start are equal, they only overlap if both are inclusive
-    if (diff1 === 0) {
-        return interval1.max.inclusive && interval2.min.inclusive;
-    }
-    if (diff2 === 0) {
-        return interval2.max.inclusive && interval1.min.inclusive;
-    }
-    return true;
-}
-exports.doIntervalsOverlap = doIntervalsOverlap;
-/**
- * Unifies the given domains by creating a new domain that contains all values from all given domains.
- */
-function unifyDomains(domains) {
-    const unifiedIntervals = unifyOverlappingIntervals(domains.flatMap(domain => Array.from(domain.intervals)));
-    return Domain.fromIntervals(unifiedIntervals);
-}
-exports.unifyDomains = unifyDomains;
-/**
- * Unify all intervals which overlap with each other to one.
- */
-function unifyOverlappingIntervals(intervals) {
-    if (intervals.length === 0) {
-        return [];
-    }
-    const sortedIntervals = [...intervals].sort(compareIntervalsByTheirMinimum);
-    const unifiedIntervals = [];
-    let currentInterval = sortedIntervals[0];
-    for (const nextInterval of sortedIntervals) {
-        if (doIntervalsOverlap(currentInterval, nextInterval)) {
-            const intervalWithEarlierStart = compareIntervalsByTheirMinimum(currentInterval, nextInterval) < 0 ? currentInterval : nextInterval;
-            const intervalWithLaterEnd = compareIntervalsByTheirMaximum(currentInterval, nextInterval) > 0 ? currentInterval : nextInterval;
-            currentInterval = new Interval(intervalWithEarlierStart.min, intervalWithLaterEnd.max);
-        }
-        else {
-            unifiedIntervals.push(currentInterval);
-            currentInterval = nextInterval;
-        }
-    }
-    unifiedIntervals.push(currentInterval);
-    return unifiedIntervals;
-}
-exports.unifyOverlappingIntervals = unifyOverlappingIntervals;
-/**
- * Returns domain1 + domain2, mapping the inclusivity.
- *
- * @see subtractDomains
- */
-function addDomains(domain1, domain2) {
-    const intervals = new Set();
-    for (const interval1 of domain1.intervals) {
-        for (const interval2 of domain2.intervals) {
-            intervals.add(new Interval({
-                value: interval1.min.value + interval2.min.value,
-                inclusive: interval1.min.inclusive && interval2.min.inclusive
-            }, {
-                value: interval1.max.value + interval2.max.value,
-                inclusive: interval1.max.inclusive && interval2.max.inclusive
-            }));
-        }
-    }
-    return Domain.fromIntervals(intervals);
-}
-exports.addDomains = addDomains;
-/**
- * Returns domain1 - domain2, mapping the inclusivity.
- *
- * @see addDomains
- */
-function subtractDomains(domain1, domain2) {
-    const intervals = new Set();
-    for (const interval1 of domain1.intervals) {
-        for (const interval2 of domain2.intervals) {
-            intervals.add(new Interval({
-                value: interval1.min.value - interval2.max.value,
-                inclusive: interval1.min.inclusive && interval2.max.inclusive
-            }, {
-                value: interval1.max.value - interval2.min.value,
-                inclusive: interval1.max.inclusive && interval2.min.inclusive
-            }));
-        }
-    }
-    return Domain.fromIntervals(intervals);
-}
-exports.subtractDomains = subtractDomains;
-//# sourceMappingURL=domain.js.map

package/abstract-interpretation/handler/binop/binop.d.ts

@@ -1,15 +0,0 @@
-import type { Handler } from '../handler';
-import type { AINode } from '../../processor';
-import type { ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { RBinaryOp } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-binary-op';
-export type BinaryOpProcessor = (lhs: AINode, rhs: AINode, node: RBinaryOp<ParentInformation>) => AINode;
-export declare class BinOp implements Handler<AINode> {
-    readonly node: RBinaryOp<ParentInformation>;
-    lhs: AINode | undefined;
-    rhs: AINode | undefined;
-    constructor(node: RBinaryOp<ParentInformation>);
-    getName(): string;
-    enter(): void;
-    exit(): AINode;
-    next(node: AINode): void;
-}

package/abstract-interpretation/handler/binop/binop.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BinOp = void 0;
-const processor_1 = require("../../processor");
-const assert_1 = require("../../../util/assert");
-const operators_1 = require("./operators");
-class BinOp {
-    node;
-    lhs;
-    rhs;
-    constructor(node) {
-        this.node = node;
-    }
-    getName() {
-        return `Bin Op (${this.node.operator})`;
-    }
-    enter() {
-        processor_1.aiLogger.trace(`Entered ${this.getName()}`);
-    }
-    exit() {
-        processor_1.aiLogger.trace(`Exited ${this.getName()}`);
-        (0, assert_1.guard)(this.lhs !== undefined, `No LHS found for assignment ${this.node.info.id}`);
-        (0, assert_1.guard)(this.rhs !== undefined, `No RHS found for assignment ${this.node.info.id}`);
-        const processor = operators_1.operators[this.node.operator];
-        (0, assert_1.guard)(processor !== undefined, `No processor found for binary operator ${this.node.operator}`);
-        return processor(this.lhs, this.rhs, this.node);
-    }
-    next(node) {
-        processor_1.aiLogger.trace(`${this.getName()} received`);
-        if (this.lhs === undefined) {
-            this.lhs = node;
-        }
-        else if (this.rhs === undefined) {
-            this.rhs = node;
-        }
-        else {
-            (0, assert_1.guard)(false, `BinOp ${this.node.info.id} already has both LHS and RHS`);
-        }
-    }
-}
-exports.BinOp = BinOp;
-//# sourceMappingURL=binop.js.map

package/abstract-interpretation/handler/binop/operators.d.ts

@@ -1,2 +0,0 @@
-import type { BinaryOpProcessor } from './binop';
-export declare const operators: Record<string, BinaryOpProcessor>;

package/abstract-interpretation/handler/binop/operators.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.operators = void 0;
-const domain_1 = require("../../domain");
-exports.operators = {
-    '<-': (lhs, rhs, node) => {
-        return {
-            id: lhs.id,
-            domain: rhs.domain,
-            astNode: node.lhs,
-        };
-    },
-    '+': (lhs, rhs, node) => {
-        return {
-            id: lhs.id,
-            domain: (0, domain_1.addDomains)(lhs.domain, rhs.domain),
-            astNode: node,
-        };
-    },
-    '-': (lhs, rhs, node) => {
-        return {
-            id: lhs.id,
-            domain: (0, domain_1.subtractDomains)(lhs.domain, rhs.domain),
-            astNode: node,
-        };
-    }
-};
-//# sourceMappingURL=operators.js.map

package/abstract-interpretation/handler/handler.d.ts

@@ -1,6 +0,0 @@
-export interface Handler<ValueType> {
-    getName: () => string;
-    enter: () => void;
-    exit: () => ValueType;
-    next: (value: ValueType) => void;
-}

package/abstract-interpretation/handler/handler.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=handler.js.map

package/abstract-interpretation/processor.d.ts

@@ -1,11 +0,0 @@
-import type { DataflowInformation } from '../dataflow/info';
-import { Domain } from './domain';
-import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { NormalizedAst, ParentInformation, RNodeWithParent } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
-export declare const aiLogger: import("tslog").Logger<import("tslog").ILogObj>;
-export interface AINode {
-    readonly id: NodeId;
-    readonly domain: Domain;
-    readonly astNode: RNodeWithParent<ParentInformation>;
-}
-export declare function runAbstractInterpretation(ast: NormalizedAst, dfg: DataflowInformation): DataflowInformation;