@eagleoutice/flowr 2.2.10 → 2.2.12

package/util/arrays.js

@@ -8,6 +8,8 @@ exports.getUniqueCombinationsOfSize = getUniqueCombinationsOfSize;
 exports.arraySum = arraySum;
 exports.array2bag = array2bag;
 exports.arrayEqual = arrayEqual;
+exports.equidistantSampling = equidistantSampling;
+exports.cartesianProduct = cartesianProduct;
 const assert_1 = require("./assert");
 /**
  * Splits the array every time the given predicate fires.
@@ -174,4 +176,43 @@ function arrayEqual(a, b) {
     }
     return true;
 }
+/**
+ * Samples elements from a list such that the distance between the sampled elements is as equal as possible.
+ *
+ * If the number of elements to sample is greater or equal to the number of elements in the list, the list is returned as is.
+ * If the number of elements to sample is less than or equal to 0, an empty list is returned.
+ *
+ * @param list - list of elements
+ * @param sampleCount - number of elements to sample
+ * @param rounding - rounding mode to use for the index calculation
+ * @returns - a list of elements equidistantly sampled from the input list
+ */
+function equidistantSampling(list, sampleCount, rounding = 'ceil') {
+    if (sampleCount >= list.length) {
+        return list.slice();
+    }
+    else if (sampleCount <= 0) {
+        return [];
+    }
+    const result = [];
+    const step = list.length / sampleCount;
+    for (let i = 0; i < sampleCount; i++) {
+        const index = rounding === 'floor' ? Math.floor(i * step) : Math.ceil(i * step);
+        result.push(list[index]);
+    }
+    return result;
+}
+/**
+ * Returns the cartesian product of the given arrays.
+ * @example
+ *
+ * ```ts
+ * cartesianProduct([1, 2], ['a', 'b', 'c'], [true, false])
+ * // -> [[1, 'a', true], [1, 'a', false], [1, 'b', true], [1, 'b', false], [1, 'c', true], [1, 'c', false], [2, 'a', true], [2, 'a', false], [2, 'b', true], [2, 'b', false], [2, 'c', true], [2, 'c', false]]
+ * ```
+ *
+ */
+function cartesianProduct(...arrays) {
+    return arrays.reduce((a, b) => a.flatMap(x => b.map(y => x.concat(y))), [[]]);
+}
 //# sourceMappingURL=arrays.js.map

package/util/cfg/visitor.d.ts

@@ -6,4 +6,4 @@ import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-i
  * @param startNode - The node to start the traversal from.
  * @param visitor   - The visitor function to call for each node, if you return true the traversal from this node will be stopped.
  */
-export declare function visitInReverseOrder(graph: ControlFlowGraph, startNode: NodeId, visitor: (node: NodeId) => boolean | void): void;
+export declare function visitCfgInReverseOrder(graph: ControlFlowGraph, startNode: NodeId, visitor: (node: NodeId) => boolean | void): void;

package/util/cfg/visitor.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.visitInReverseOrder = visitInReverseOrder;
+exports.visitCfgInReverseOrder = visitCfgInReverseOrder;
 /**
  * Visit all nodes reachable from the start node in the control flow graph, traversing the dependencies but ignoring cycles.
  * @param graph     - The control flow graph.
  * @param startNode - The node to start the traversal from.
  * @param visitor   - The visitor function to call for each node, if you return true the traversal from this node will be stopped.
  */
-function visitInReverseOrder(graph, startNode, 
+function visitCfgInReverseOrder(graph, startNode, 
 // eslint-disable-next-line @typescript-eslint/no-invalid-void-type -- void is used to indicate that the return value is ignored/we never stop
 visitor) {
     const visited = new Set();

package/util/{list-access.d.ts → containers.d.ts}

@@ -1,10 +1,30 @@
 import type { REnvironmentInformation } from '../dataflow/environments/environment';
-import type { ContainerIndices, ContainerIndicesCollection } from '../dataflow/graph/vertex';
+import type { Identifier } from '../dataflow/environments/identifier';
+import type { ContainerIndices, ContainerIndicesCollection, IndexIdentifier } from '../dataflow/graph/vertex';
 import type { RAccess } from '../r-bridge/lang-4.x/ast/model/nodes/r-access';
+import type { RArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-argument';
+import type { RFunctionArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+/**
+ * Returns the accessed and access argument of an access operation by filtering the operation arguments.
+ */
+export declare function getAccessOperands<OtherInfo>(args: readonly RFunctionArgument<OtherInfo & ParentInformation>[]): {
+    accessedArg: RArgument<OtherInfo & ParentInformation> | undefined;
+    accessArg: RArgument<OtherInfo & ParentInformation> | undefined;
+};
+/**
+ * Resolves the passed name in the passed environment and returns the indicesCollection of the resolved definitions.
+ *
+ * @param name - Name to resolve
+ * @param environment - Environment in which name is resolved
+ * @returns The indicesCollection of the resolved definitions
+ */
+export declare function resolveIndicesByName(name: Identifier, environment: REnvironmentInformation): ContainerIndices[] | undefined;
 /**
  * Resolves {@link accessedArg} in the {@link environment} and filters its indices according to {@link accessArg}.
  *
+ * If no indices could be found that match the `accessArg`, the original indices are returned as overapproximation.
+ *
  * @param accessedArg - The argument to resolve
  * @param accessArg - The argument which is used to filter the indices
  * @param environment - The environment in which {@link accessedArg} is resolved
@@ -14,7 +34,7 @@ export declare function resolveSingleIndex(accessedArg: {
     lexeme: string;
 }, accessArg: {
     lexeme: string;
-}, environment: REnvironmentInformation): ContainerIndicesCollection;
+}, environment: REnvironmentInformation, isIndexBasedAccess: boolean): ContainerIndicesCollection;
 /**
  * Filters the single indices of the {@link indicesCollection} according to the lexeme of the {@link accessArg}.
  *
@@ -24,7 +44,7 @@ export declare function resolveSingleIndex(accessedArg: {
  */
 export declare function filterIndices(indicesCollection: ContainerIndicesCollection, accessArg: {
     lexeme: string;
-}): ContainerIndicesCollection;
+}, isIndexBasedAccess: boolean): ContainerIndicesCollection;
 /**
  * Constructs the definition of a nested access.
  *
@@ -38,7 +58,7 @@ export declare function filterIndices(indicesCollection: ContainerIndicesCollect
  * @param leafIndices - The index at the end of the nested access i.e. `c` in `a$b$c`.
  * @returns The constructed nested access
  */
-export declare function constructNestedAccess<OtherInfo>(accessedArg: RAccess<OtherInfo & ParentInformation>, leafIndices: ContainerIndices): ContainerIndices[];
+export declare function constructNestedAccess<OtherInfo>(accessedArg: RAccess<OtherInfo & ParentInformation>, leafIndices: ContainerIndices, constructIdentifier: (arg: RArgument<OtherInfo & ParentInformation>) => IndexIdentifier): ContainerIndices[];
 /**
  * Adds the passed list of {@link leafSubIndices} to the leaf (sub-)indices of {@link indicesCollection}.
  *

package/util/{list-access.js → containers.js}

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccessOperands = getAccessOperands;
+exports.resolveIndicesByName = resolveIndicesByName;
 exports.resolveSingleIndex = resolveSingleIndex;
 exports.filterIndices = filterIndices;
 exports.constructNestedAccess = constructNestedAccess;
@@ -8,19 +10,47 @@ const resolve_by_name_1 = require("../dataflow/environments/resolve-by-name");
 const vertex_1 = require("../dataflow/graph/vertex");
 const r_function_call_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
+/**
+ * Returns the accessed and access argument of an access operation by filtering the operation arguments.
+ */
+function getAccessOperands(args) {
+    const nonEmptyArgs = args.filter(arg => arg !== r_function_call_1.EmptyArgument);
+    const accessedArg = nonEmptyArgs.find(arg => arg.info.role === "accessed" /* RoleInParent.Accessed */);
+    const accessArg = nonEmptyArgs.find(arg => arg.info.role === "index-access" /* RoleInParent.IndexAccess */);
+    return { accessedArg, accessArg };
+}
+/**
+ * Resolves the passed name in the passed environment and returns the indicesCollection of the resolved definitions.
+ *
+ * @param name - Name to resolve
+ * @param environment - Environment in which name is resolved
+ * @returns The indicesCollection of the resolved definitions
+ */
+function resolveIndicesByName(name, environment) {
+    const definitions = (0, resolve_by_name_1.resolveByName)(name, environment);
+    return definitions?.flatMap(def => def?.indicesCollection ?? []);
+}
 /**
  * Resolves {@link accessedArg} in the {@link environment} and filters its indices according to {@link accessArg}.
  *
+ * If no indices could be found that match the `accessArg`, the original indices are returned as overapproximation.
+ *
  * @param accessedArg - The argument to resolve
  * @param accessArg - The argument which is used to filter the indices
  * @param environment - The environment in which {@link accessedArg} is resolved
  * @returns The filtered {@link ContainerIndicesCollection} of the resolved {@link accessedArg}
  */
-function resolveSingleIndex(accessedArg, accessArg, environment) {
-    const definitions = (0, resolve_by_name_1.resolveByName)(accessedArg.lexeme, environment);
-    const indicesCollection = definitions?.flatMap(def => def?.indicesCollection ?? []);
-    const accessedIndicesCollection = filterIndices(indicesCollection, accessArg);
-    return accessedIndicesCollection;
+function resolveSingleIndex(accessedArg, accessArg, environment, isIndexBasedAccess) {
+    const indicesCollection = resolveIndicesByName(accessedArg.lexeme, environment);
+    const accessedIndicesCollection = filterIndices(indicesCollection, accessArg, isIndexBasedAccess);
+    // If the accessed indices couldn't be resolved, overapproximate by returning the original indices.
+    // This could also be the case, when nothing is acccessed, but we better be safe.
+    if (accessedIndicesCollection === undefined) {
+        return indicesCollection;
+    }
+    else {
+        return accessedIndicesCollection;
+    }
 }
 /**
  * Filters the single indices of the {@link indicesCollection} according to the lexeme of the {@link accessArg}.
@@ -29,11 +59,11 @@ function resolveSingleIndex(accessedArg, accessArg, environment) {
  * @param accessArg - The argument which is used to filter {@link indicesCollection}
  * @returns The filtered copy of {@link indicesCollection}
  */
-function filterIndices(indicesCollection, accessArg) {
+function filterIndices(indicesCollection, accessArg, isIndexBasedAccess) {
     let accessedIndicesCollection = undefined;
     for (const indices of indicesCollection ?? []) {
-        const filteredIndices = indices.indices.filter(index => accessArg.lexeme === index.lexeme);
-        if (filteredIndices.length == 0) {
+        const filteredIndices = indices.indices.filter(index => (0, vertex_1.isAccessed)(index, accessArg.lexeme, isIndexBasedAccess));
+        if (filteredIndices.length === 0) {
             continue;
         }
         accessedIndicesCollection ??= [];
@@ -57,7 +87,7 @@ function filterIndices(indicesCollection, accessArg) {
  * @param leafIndices - The index at the end of the nested access i.e. `c` in `a$b$c`.
  * @returns The constructed nested access
  */
-function constructNestedAccess(accessedArg, leafIndices) {
+function constructNestedAccess(accessedArg, leafIndices, constructIdentifier) {
     const accessed = accessedArg.accessed;
     const accesses = accessedArg.access.filter(arg => arg !== r_function_call_1.EmptyArgument).map(arg => arg);
     const indices = [];
@@ -65,7 +95,7 @@ function constructNestedAccess(accessedArg, leafIndices) {
         const newIndices = {
             indices: [
                 {
-                    lexeme: access.lexeme,
+                    identifier: constructIdentifier(access),
                     nodeId: access.info.id,
                     subIndices: [leafIndices],
                 }
@@ -73,7 +103,7 @@ function constructNestedAccess(accessedArg, leafIndices) {
             isContainer: false,
         };
         if (accessed.type === type_1.RType.Access) {
-            const nestedIndices = constructNestedAccess(accessed, newIndices);
+            const nestedIndices = constructNestedAccess(accessed, newIndices, constructIdentifier);
             indices.push(...nestedIndices);
         }
         else {
@@ -112,4 +142,4 @@ function addSubIndicesToLeafIndices(indicesCollection, leafSubIndices) {
     }
     return result;
 }
-//# sourceMappingURL=list-access.js.map
+//# sourceMappingURL=containers.js.map

package/util/mermaid/ast.js

@@ -5,9 +5,10 @@ exports.normalizedAstToMermaidUrl = normalizedAstToMermaidUrl;
 const mermaid_1 = require("./mermaid");
 const visitor_1 = require("../../r-bridge/lang-4.x/ast/model/processing/visitor");
 const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
+const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 function normalizedAstToMermaid(ast, prefix = 'flowchart TD\n') {
     let output = prefix;
-    (0, visitor_1.visitAst)(ast, n => {
+    function showNode(n) {
         const name = `${n.type} (${n.info.id})\\n${n.lexeme ?? ' '}`;
         output += `    n${n.info.id}(["${(0, mermaid_1.escapeMarkdown)(name)}"])\n`;
         if (n.info.parent !== undefined) {
@@ -19,6 +20,16 @@ function normalizedAstToMermaid(ast, prefix = 'flowchart TD\n') {
             output += `    n${n.info.id} -.-|"group-open"| n${n.grouping[0].info.id}\n`;
             output += `    n${n.info.id} -.-|"group-close"| n${n.grouping[1].info.id}\n`;
         }
+    }
+    (0, visitor_1.visitAst)(ast, n => {
+        showNode(n);
+        if (n.type === 'RAccess' && (n.operator !== '[' && n.operator !== '[[')) {
+            for (const k of n.access) {
+                if (k !== r_function_call_1.EmptyArgument) {
+                    showNode(k);
+                }
+            }
+        }
         return false;
     });
     return output;

package/util/mermaid/cfg.js

@@ -6,8 +6,8 @@ const mermaid_1 = require("./mermaid");
 function getLexeme(n) {
     return n ? n.info.fullLexeme ?? n.lexeme ?? '<unknown>' : '';
 }
-function cfgToMermaid(cfg, normalizedAst, prefix = '') {
-    let output = prefix + 'flowchart BT\n';
+function cfgToMermaid(cfg, normalizedAst, prefix = 'flowchart BT\n') {
+    let output = prefix;
     for (const [id, vertex] of cfg.graph.vertices()) {
         const normalizedVertex = normalizedAst.idMap.get(id);
         const content = getLexeme(normalizedVertex);

package/util/parallel.d.ts

@@ -13,12 +13,13 @@ export declare class LimitedThreadPool {
     private skipped;
     private currentlyRunning;
     private reportingInterval;
+    private readonly timeLimitInMs;
     /**
    * Create a new parallel helper that runs the given `module` once for each list of {@link Arguments} in the `queue`.
    * The `limit` stops the execution if `<limit>` number of runs exited successfully.
    * The `parallel` parameter limits the number of parallel executions.
    */
-    constructor(module: string, queue: WorkingQueue, limit: number, parallel: number);
+    constructor(module: string, queue: WorkingQueue, limit: number, parallel: number, timeLimitInMs?: number);
     run(): Promise<void>;
     getStats(): {
         counter: number;

package/util/parallel.js

@@ -56,16 +56,18 @@ class LimitedThreadPool {
     skipped = [];
     currentlyRunning = new Set();
     reportingInterval = undefined;
+    timeLimitInMs;
     /**
    * Create a new parallel helper that runs the given `module` once for each list of {@link Arguments} in the `queue`.
    * The `limit` stops the execution if `<limit>` number of runs exited successfully.
    * The `parallel` parameter limits the number of parallel executions.
    */
-    constructor(module, queue, limit, parallel) {
+    constructor(module, queue, limit, parallel, timeLimitInMs) {
         this.workingQueue = queue;
         this.limit = limit;
         this.module = module;
         this.parallel = parallel;
+        this.timeLimitInMs = timeLimitInMs;
     }
     async run() {
         this.reportingInterval = setInterval(() => {
@@ -93,8 +95,15 @@ class LimitedThreadPool {
         console.log(`[${this.counter}/${this.limit}] Running next, currently running: ${this.currentlyRunning.size}, queue: ${this.workingQueue.length} [args: ${args.join(' ')}]`);
         const child = cp.fork(this.module, args);
         child.on('exit', this.onChildExit(args));
+        let timeout;
+        if (this.timeLimitInMs) {
+            timeout = setTimeout(() => {
+                log_1.log.error(`Killing child process with '${JSON.stringify(args)}' after ${this.timeLimitInMs}ms`);
+                child.kill();
+            }, this.timeLimitInMs);
+        }
         // schedule re-schedule
-        await new Promise(resolve => child.on('exit', resolve)).then(() => this.runNext());
+        await new Promise(resolve => child.on('exit', resolve)).then(() => clearTimeout(timeout)).then(() => this.runNext());
     }
     onChildExit(args) {
         return (code, signal) => {

package/util/prefix.d.ts

@@ -0,0 +1,13 @@
+/**
+ * given a potentially partial prefix like `hell`, this finds the matching name in the map, but only
+ * if it is unique!
+ *
+ * @example
+ * ```typescript
+ * findByPrefixIfUnique('hell', { 'hello', 'bar' }) // => 'hello'
+ * findByPrefixIfUnique('hell', { 'hello', 'hell' }) // => 'hell' (full match)
+ * findByPrefixIfUnique('h', { 'hello', 'hell' }) // => undefined (not unique)
+ * findByPrefixIfUnique('', { 'hello', 'hell' }) // => undefined (empty prefix)
+ * ```
+ */
+export declare function findByPrefixIfUnique(prefix: string, keys: readonly string[]): string | undefined;

package/util/prefix.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findByPrefixIfUnique = findByPrefixIfUnique;
+/**
+ * given a potentially partial prefix like `hell`, this finds the matching name in the map, but only
+ * if it is unique!
+ *
+ * @example
+ * ```typescript
+ * findByPrefixIfUnique('hell', { 'hello', 'bar' }) // => 'hello'
+ * findByPrefixIfUnique('hell', { 'hello', 'hell' }) // => 'hell' (full match)
+ * findByPrefixIfUnique('h', { 'hello', 'hell' }) // => undefined (not unique)
+ * findByPrefixIfUnique('', { 'hello', 'hell' }) // => undefined (empty prefix)
+ * ```
+ */
+function findByPrefixIfUnique(prefix, keys) {
+    if (prefix === '') {
+        return undefined;
+    }
+    let found = undefined;
+    for (const key of keys) {
+        if (key === prefix) {
+            return key;
+        }
+        if (key.startsWith(prefix)) {
+            if (found) {
+                return undefined;
+            }
+            found = key;
+        }
+    }
+    return found;
+}
+//# sourceMappingURL=prefix.js.map

package/util/version.js

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