@eagleoutice/flowr 2.0.16 → 2.0.17

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.16';
+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;

package/abstract-interpretation/processor.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runAbstractInterpretation = exports.aiLogger = void 0;
-const cfg_1 = require("../util/cfg/cfg");
-const visitor_1 = require("../util/cfg/visitor");
-const assert_1 = require("../util/assert");
-const binop_1 = require("./handler/binop/binop");
-const domain_1 = require("./domain");
-const log_1 = require("../util/log");
-const edge_1 = require("../dataflow/graph/edge");
-exports.aiLogger = log_1.log.getSubLogger({ name: 'abstract-interpretation' });
-class Stack {
-    backingStore = [];
-    size() {
-        return this.backingStore.length;
-    }
-    peek() {
-        return this.backingStore[this.size() - 1];
-    }
-    pop() {
-        return this.backingStore.pop();
-    }
-    push(item) {
-        this.backingStore.push(item);
-        return item;
-    }
-}
-function getDomainOfDfgChild(node, dfg, nodeMap) {
-    const dfgNode = dfg.graph.get(node);
-    (0, assert_1.guard)(dfgNode !== undefined, `No DFG-Node found with ID ${node}`);
-    const [_, children] = dfgNode;
-    const ids = Array.from(children.entries())
-        .filter(([_, edge]) => (0, edge_1.edgeIncludesType)(edge.types, 1 /* EdgeType.Reads */))
-        .map(([id, _]) => id);
-    const domains = [];
-    for (const id of ids) {
-        const domain = nodeMap.get(id)?.domain;
-        (0, assert_1.guard)(domain !== undefined, `No domain found for ID ${id}`);
-        domains.push(domain);
-    }
-    return (0, domain_1.unifyDomains)(domains);
-}
-function runAbstractInterpretation(ast, dfg) {
-    const cfg = (0, cfg_1.extractCFG)(ast);
-    const operationStack = new Stack();
-    const nodeMap = new Map();
-    (0, visitor_1.visitCfg)(cfg, (node, _) => {
-        const astNode = ast.idMap.get(node.id);
-        if (astNode?.type === "RBinaryOp" /* RType.BinaryOp */) {
-            operationStack.push(new binop_1.BinOp(astNode)).enter();
-        }
-        else if (astNode?.type === "RSymbol" /* RType.Symbol */) {
-            operationStack.peek()?.next({
-                id: astNode.info.id,
-                domain: getDomainOfDfgChild(node.id, dfg, nodeMap),
-                astNode: astNode,
-            });
-        }
-        else if (astNode?.type === "RNumber" /* RType.Number */) {
-            const num = astNode.content.num;
-            operationStack.peek()?.next({
-                id: astNode.info.id,
-                domain: domain_1.Domain.fromScalar(num),
-                astNode: astNode,
-            });
-        }
-        else if (node.type === "end-marker" /* CfgVertexType.EndMarker */) {
-            const operation = operationStack.pop();
-            if (operation === undefined) {
-                return;
-            }
-            const operationResult = operation.exit();
-            (0, assert_1.guard)(!nodeMap.has(operationResult.id), `Domain for ID ${operationResult.id} already exists`);
-            nodeMap.set(operationResult.id, operationResult);
-            operationStack.peek()?.next(operationResult);
-        }
-        else {
-            exports.aiLogger.warn(`Unknown node type ${node.type}`);
-        }
-    });
-    return dfg;
-}
-exports.runAbstractInterpretation = runAbstractInterpretation;
-//# sourceMappingURL=processor.js.map