@eagleoutice/flowr 2.0.16 → 2.0.18

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.18';
 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