@eagleoutice/flowr 1.3.11

package/util/arrays.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.array2bag = exports.sum = exports.getUniqueCombinationsOfSize = exports.partition = exports.allPermutations = exports.splitArrayOn = void 0;
+const assert_1 = require("./assert");
+/**
+ * Splits the array every time the given predicate fires.
+ * The element the split appears on will not be included!
+ *
+ * @example with this we can split on all empty strings:
+ * ```
+ * splitArrayOn(['a', '', 'b', '', '', 'c'], elem => elem === '')
+ * // => [['a'], ['b'], [], ['c']]
+ * ```
+ * @example if the last element satisfies the predicate, this will add an empty array element
+ * ```
+ * splitArrayOn([1,2,3], elem => true)
+ * // => [[], [], [], []]
+ * ```
+ */
+function splitArrayOn(arr, predicate) {
+    const result = [];
+    let current = [];
+    let fired = false;
+    for (const elem of arr) {
+        if (predicate(elem)) {
+            result.push(current);
+            current = [];
+            fired = true;
+        }
+        else {
+            current.push(elem);
+        }
+    }
+    if (fired || current.length > 0) {
+        result.push(current);
+    }
+    return result;
+}
+exports.splitArrayOn = splitArrayOn;
+/**
+ * Generate all permutations of the given array using Heap's algorithm (with its non-recursive variant).
+ *
+ * @param arr - The array to permute
+ * @see getUniqueCombinationsOfSize
+ */
+function* allPermutations(arr) {
+    yield arr.slice();
+    const c = new Array(arr.length).fill(0);
+    let i = 1;
+    while (i < arr.length) {
+        if (c[i] >= i) {
+            c[i] = 0;
+            ++i;
+        }
+        else {
+            // save the swap to 0 (https://stackoverflow.com/questions/9960908/permutations-in-javascript/37580979#37580979)
+            const k = i % 2 && c[i];
+            const p = arr[i];
+            arr[i] = arr[k];
+            arr[k] = p;
+            ++c[i];
+            i = 1;
+            yield arr.slice();
+        }
+    }
+}
+exports.allPermutations = allPermutations;
+function partition(arr, predicate) {
+    const left = [];
+    const right = [];
+    for (const elem of arr) {
+        if (predicate(elem)) {
+            left.push(elem);
+        }
+        else {
+            right.push(elem);
+        }
+    }
+    return [left, right];
+}
+exports.partition = partition;
+/**
+ * Generate all unique combinations of the array with the given size.
+ * In other words, given `[a,b,c]`, as well as `minSize=2` and `maxSize=2`, this will generate `[a,b]`, `[a,c]` and `[b,c]`,
+ * but not, e.g., `[a,a]` or `[b,a]`.
+ *
+ * If `minSize!=maxSize`, the result is guaranteed to be sorted by size.
+ *
+ * @param array   - The array to generate combinations from
+ * @param minSize - The inclusive minimum size of the combinations, must be at least `0` and at most `maxSize`
+ * @param maxSize - The inclusive maximum size of the combinations, must be at least `minSize` and at most `array.length`
+ */
+function* getUniqueCombinationsOfSize(array, minSize = 0, maxSize = array.length) {
+    (0, assert_1.guard)(minSize >= 0 && minSize <= maxSize, 'minSize must be at least 0 and at most maxSize');
+    (0, assert_1.guard)(maxSize >= minSize && maxSize <= array.length, 'maxSize must be at least minSize and at most the length of the array');
+    if (minSize === maxSize && minSize === 1) {
+        for (const elem of array) {
+            yield [elem];
+        }
+        return;
+    }
+    function* p(t, i, newArr) {
+        // start yielding if min size is reached
+        if (t.length >= minSize) {
+            // only yield if the array has been modified
+            if (newArr) {
+                yield t;
+            }
+            // stop yielding if inclusive max size is reached
+            if (t.length >= maxSize) {
+                return;
+            }
+        }
+        if (i >= array.length) {
+            return;
+        }
+        yield* p(t.concat(array[i]), i + 1, true);
+        yield* p(t, i + 1, false);
+    }
+    yield* p([], 0, true);
+}
+exports.getUniqueCombinationsOfSize = getUniqueCombinationsOfSize;
+/**
+ * Returns the sum of all elements in the given array
+ */
+function sum(arr) {
+    let sum = 0;
+    for (const elem of arr) {
+        sum += elem;
+    }
+    return sum;
+}
+exports.sum = sum;
+/**
+ * Converts an array into a bag data-structure (in the form of a map mapping the entries/keys to their counts)
+ */
+function array2bag(arr) {
+    const result = new Map();
+    for (const elem of arr) {
+        result.set(elem, (result.get(elem) ?? 0) + 1);
+    }
+    return result;
+}
+exports.array2bag = array2bag;
+//# sourceMappingURL=arrays.js.map

package/util/assert.d.ts

@@ -0,0 +1,11 @@
+/** use this to ensure that all cases are covered in case of a selection */
+export declare function assertUnreachable(x: never): never;
+export declare function isNotUndefined<T>(x: T | undefined): x is T;
+export declare function isNotNull<T>(x: T | null): x is T;
+export type GuardMessage = string | (() => string);
+/**
+ * @param assertion - will be asserted
+ * @param message - if a string, will be used as error message, if a function, will be called to produce the error message (can be used to avoid costly message generations)
+ * @throws GuardError - if the assertion fails
+ */
+export declare function guard(assertion: boolean, message?: GuardMessage): asserts assertion;

package/util/assert.js

@@ -0,0 +1,35 @@
+"use strict";
+/** use this to ensure that all cases are covered in case of a selection */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.guard = exports.isNotNull = exports.isNotUndefined = exports.assertUnreachable = void 0;
+/* istanbul ignore next */
+function assertUnreachable(x) {
+    throw new Error(`Unexpected object: ${JSON.stringify(x)}`);
+}
+exports.assertUnreachable = assertUnreachable;
+function isNotUndefined(x) {
+    return x !== undefined;
+}
+exports.isNotUndefined = isNotUndefined;
+function isNotNull(x) {
+    return x !== null;
+}
+exports.isNotNull = isNotNull;
+class GuardError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'GuardError';
+    }
+}
+/**
+ * @param assertion - will be asserted
+ * @param message - if a string, will be used as error message, if a function, will be called to produce the error message (can be used to avoid costly message generations)
+ * @throws GuardError - if the assertion fails
+ */
+function guard(assertion, message = 'Assertion failed') {
+    if (!assertion) {
+        throw new GuardError(typeof message === 'string' ? message : message());
+    }
+}
+exports.guard = guard;
+//# sourceMappingURL=assert.js.map

package/util/bimap.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Implementation of a bidirectional map
+ *
+ * All map-related functions are based on the normal Key -> Value map
+ */
+export declare class BiMap<K, V extends object> implements Map<K, V> {
+    readonly [Symbol.toStringTag]: string;
+    size: number;
+    private readonly k2v;
+    private v2k;
+    constructor(base?: Iterable<[K, V]>);
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    clear(): void;
+    delete(key: K): boolean;
+    entries(): IterableIterator<[K, V]>;
+    forEach(callbackFunction: (value: V, key: K, map: Map<K, V>) => void): void;
+    get(key: K): V | undefined;
+    getKey(value: V): K | undefined;
+    has(key: K): boolean;
+    hasValue(value: V): boolean;
+    keys(): IterableIterator<K>;
+    set(key: K, value: V): this;
+    values(): IterableIterator<V>;
+}

package/util/bimap.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BiMap = void 0;
+/**
+ * Implementation of a bidirectional map
+ *
+ * All map-related functions are based on the normal Key -> Value map
+ */
+class BiMap {
+    [Symbol.toStringTag] = 'BiMap';
+    size = 0;
+    k2v = new Map();
+    v2k = new WeakMap();
+    constructor(base) {
+        if (base != null) {
+            for (const [k, v] of base) {
+                this.set(k, v);
+            }
+        }
+    }
+    [Symbol.iterator]() {
+        return this.k2v[Symbol.iterator]();
+    }
+    clear() {
+        this.size = 0;
+        this.k2v.clear();
+        this.v2k = new WeakMap();
+    }
+    delete(key) {
+        const value = this.k2v.get(key);
+        if (value === undefined) {
+            return false;
+        }
+        this.k2v.delete(key);
+        this.v2k.delete(value);
+        this.size = this.k2v.size;
+        return true;
+    }
+    entries() {
+        return this.k2v.entries();
+    }
+    forEach(callbackFunction) {
+        this.k2v.forEach(callbackFunction);
+    }
+    get(key) {
+        return this.k2v.get(key);
+    }
+    getKey(value) {
+        return this.v2k.get(value);
+    }
+    has(key) {
+        return this.k2v.has(key);
+    }
+    hasValue(value) {
+        return this.v2k.has(value);
+    }
+    keys() {
+        return this.k2v.keys();
+    }
+    set(key, value) {
+        this.k2v.set(key, value);
+        this.v2k.set(value, key);
+        this.size = this.k2v.size;
+        return this;
+    }
+    values() {
+        return this.k2v.values();
+    }
+}
+exports.BiMap = BiMap;
+//# sourceMappingURL=bimap.js.map

package/util/cfg.d.ts

@@ -0,0 +1,55 @@
+import { NodeId, NormalizedAst, ParentInformation, RFalse, RTrue } from '../r-bridge';
+import { MergeableRecord } from './objects';
+import { QuadSerializationConfiguration } from './quads';
+export interface CfgVertex {
+    id: NodeId;
+    name: string;
+    /** in case of a function definition */
+    children?: NodeId[];
+}
+interface CfgFlowDependencyEdge extends MergeableRecord {
+    label: 'FD';
+}
+interface CfgControlDependencyEdge extends MergeableRecord {
+    label: 'CD';
+    when: typeof RTrue | typeof RFalse;
+}
+export type CFGEdge = CfgFlowDependencyEdge | CfgControlDependencyEdge;
+/**
+ * This class represents the control flow graph of an R program.
+ * The control flow may be hierarchical when confronted with function definitions (see {@link CfgVertex} and {@link CFG#rootVertexIds|rootVertexIds()}).
+ */
+export declare class ControlFlowGraph {
+    private rootVertices;
+    private vertexInformation;
+    private edgeInformation;
+    addVertex(vertex: CfgVertex, rootVertex?: boolean): this;
+    addEdge(from: NodeId, to: NodeId, edge: CFGEdge): this;
+    rootVertexIds(): ReadonlySet<NodeId>;
+    vertices(): ReadonlyMap<NodeId, CfgVertex>;
+    edges(): ReadonlyMap<NodeId, ReadonlyMap<NodeId, CFGEdge>>;
+    merge(other: ControlFlowGraph, forceNested?: boolean): this;
+}
+export interface ControlFlowInformation extends MergeableRecord {
+    returns: NodeId[];
+    breaks: NodeId[];
+    nexts: NodeId[];
+    /** intended to construct a hammock graph, with 0 exit points representing a block that should not be part of the CFG (like a comment) */
+    entryPoints: NodeId[];
+    /** See {@link ControlFlowInformation#entryPoints|entryPoints} */
+    exitPoints: NodeId[];
+    graph: ControlFlowGraph;
+}
+export declare function emptyControlFlowInformation(): ControlFlowInformation;
+export declare function extractCFG<Info = ParentInformation>(ast: NormalizedAst<Info>): ControlFlowInformation;
+/**
+ * Returns true if the given CFG equals the other CFG. False otherwise.
+ */
+export declare function equalCfg(a: ControlFlowGraph | undefined, b: ControlFlowGraph | undefined): boolean;
+/**
+ * @see df2quads
+ * @see serialize2quads
+ * @see graph2quads
+ */
+export declare function cfg2quads(cfg: ControlFlowInformation, config: QuadSerializationConfiguration): string;
+export {};