@eagleoutice/flowr 2.2.11 → 2.2.13

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/diff-graph.d.ts

@@ -0,0 +1,47 @@
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { GenericDiffConfiguration, GenericDifferenceInformation, WriteableDifferenceReport } from './diff';
+import type { DataflowGraph } from '../dataflow/graph/graph';
+export interface NamedGraph<Graph = DataflowGraph> {
+    name: string;
+    graph: Graph;
+}
+interface ProblematicVertex {
+    tag: 'vertex';
+    id: NodeId;
+}
+interface ProblematicEdge {
+    tag: 'edge';
+    from: NodeId;
+    to: NodeId;
+}
+export type ProblematicDiffInfo = ProblematicVertex | ProblematicEdge;
+/**
+ * To be produced by a function differencing two graphs (e.g., {@link DataflowGraph|DFGs} or {@link ControlFlowGraph|CFGs}).
+ *
+ * @see {@link GraphDifferenceReport#isEqual|isEqual} - to check whether the graphs are equal
+ * @see {@link GraphDifferenceReport#addComment|addComment} - to add comments to the report
+ * @see {@link GraphDifferenceReport#comments|comments} - to get the attached comments
+ * @see {@link GraphDifferenceReport#problematic|problematic} - to get the problematic vertices/edges
+ */
+export declare class GraphDifferenceReport implements WriteableDifferenceReport {
+    _comments: string[] | undefined;
+    _problematic: ProblematicDiffInfo[] | undefined;
+    addComment(comment: string, ...related: readonly ProblematicDiffInfo[]): void;
+    comments(): readonly string[] | undefined;
+    problematic(): readonly ProblematicDiffInfo[] | undefined;
+    isEqual(): boolean;
+}
+/**
+ * A context that can be used by differencing functions to compare two graphs
+ * See {@link initDiffContext} for a function that creates such a context.
+ */
+export interface GraphDiffContext<Graph = DataflowGraph> extends GenericDifferenceInformation<GraphDifferenceReport> {
+    left: Graph;
+    right: Graph;
+    config: GenericDiffConfiguration;
+}
+/**
+ * Create the context for differencing two graphs
+ */
+export declare function initDiffContext<Graph>(left: NamedGraph<Graph>, right: NamedGraph<Graph>, config?: Partial<GenericDiffConfiguration>): GraphDiffContext<Graph>;
+export {};

package/util/diff-graph.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphDifferenceReport = void 0;
+exports.initDiffContext = initDiffContext;
+/**
+ * To be produced by a function differencing two graphs (e.g., {@link DataflowGraph|DFGs} or {@link ControlFlowGraph|CFGs}).
+ *
+ * @see {@link GraphDifferenceReport#isEqual|isEqual} - to check whether the graphs are equal
+ * @see {@link GraphDifferenceReport#addComment|addComment} - to add comments to the report
+ * @see {@link GraphDifferenceReport#comments|comments} - to get the attached comments
+ * @see {@link GraphDifferenceReport#problematic|problematic} - to get the problematic vertices/edges
+ */
+class GraphDifferenceReport {
+    _comments = undefined;
+    _problematic = undefined;
+    addComment(comment, ...related) {
+        if (this._comments === undefined) {
+            this._comments = [comment];
+        }
+        else {
+            this._comments.push(comment);
+        }
+        if (related.length > 0) {
+            if (this._problematic === undefined) {
+                this._problematic = [...related];
+            }
+            else {
+                this._problematic.push(...related);
+            }
+        }
+    }
+    comments() {
+        return this._comments;
+    }
+    problematic() {
+        return this._problematic;
+    }
+    isEqual() {
+        return this._comments === undefined;
+    }
+}
+exports.GraphDifferenceReport = GraphDifferenceReport;
+/**
+ * Create the context for differencing two graphs
+ */
+function initDiffContext(left, right, config) {
+    return {
+        left: left.graph,
+        leftname: left.name,
+        right: right.graph,
+        rightname: right.name,
+        report: new GraphDifferenceReport(),
+        position: '',
+        config: {
+            rightIsSubgraph: false,
+            leftIsSubgraph: false,
+            ...config
+        }
+    };
+}
+//# sourceMappingURL=diff-graph.js.map

package/util/diff.d.ts

@@ -12,14 +12,14 @@ import type { MergeableRecord } from './objects';
  */
 export interface DifferenceReport {
     /**
-   * A human-readable description of differences during the comparison
-   * In combination with {@link isEqual} this can be used to provide detailed
-   * explanation on equal structures as well (e.g., if structures _could_ be equal).
-   */
+     * A human-readable description of differences during the comparison
+     * In combination with {@link isEqual} this can be used to provide detailed
+     * explanation on equal structures as well (e.g., if structures _could_ be equal).
+     */
     comments(): readonly string[] | undefined;
     /**
-   * @returns true iff the compared structures are equal (i.e., the diff is empty)
-   */
+     * @returns true iff the compared structures are equal (i.e., the diff is empty)
+     */
     isEqual(): boolean;
 }
 export interface WriteableDifferenceReport extends DifferenceReport {

package/util/diff.js

@@ -7,7 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setDifference = setDifference;
-const set_1 = require("./set");
+const set_1 = require("./collections/set");
 function setDifference(left, right, info) {
     const lWithoutR = (0, set_1.setMinus)(left, right);
     const rWithoutL = (0, set_1.setMinus)(right, left);

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.d.ts

@@ -1,6 +1,13 @@
-import type { ControlFlowInformation } from '../cfg/cfg';
 import type { NormalizedAst } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-export declare function cfgToMermaid(cfg: ControlFlowInformation, normalizedAst: NormalizedAst, prefix?: string): string;
+import type { ControlFlowInformation } from '../../control-flow/control-flow-graph';
+/**
+ * Convert the control flow graph to a mermaid string.
+ * @param cfg              - The control flow graph to convert.
+ * @param normalizedAst    - The normalized AST to use for the vertex content.
+ * @param prefix           - The prefix to use for the mermaid string.
+ * @param simplify         - Whether to simplify the control flow graph (especially in the context of basic blocks).
+ */
+export declare function cfgToMermaid(cfg: ControlFlowInformation, normalizedAst: NormalizedAst, prefix?: string, simplify?: boolean): string;
 /**
  * Use mermaid to visualize the normalized AST.
  */

package/util/mermaid/cfg.js

@@ -3,27 +3,79 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cfgToMermaid = cfgToMermaid;
 exports.cfgToMermaidUrl = cfgToMermaidUrl;
 const mermaid_1 = require("./mermaid");
+const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
+const control_flow_graph_1 = require("../../control-flow/control-flow-graph");
+const reconstruct_1 = require("../../reconstruct/reconstruct");
+const auto_select_defaults_1 = require("../../reconstruct/auto-select/auto-select-defaults");
 function getLexeme(n) {
-    return n ? n.info.fullLexeme ?? n.lexeme ?? '<unknown>' : '';
+    return n ? n.info.fullLexeme ?? n.lexeme ?? '' : undefined;
 }
-function cfgToMermaid(cfg, normalizedAst, prefix = '') {
-    let output = prefix + 'flowchart BT\n';
-    for (const [id, vertex] of cfg.graph.vertices()) {
-        const normalizedVertex = normalizedAst.idMap.get(id);
+function cfgOfNode(vert, normalizedVertex, id, content, output) {
+    if (normalizedVertex && content !== undefined) {
+        const start = vert.type === control_flow_graph_1.CfgVertexType.Expression ? '([' : '[';
+        const end = vert.type === control_flow_graph_1.CfgVertexType.Expression ? '])' : ']';
+        const name = `"\`${(0, mermaid_1.escapeMarkdown)(normalizedVertex.type)} (${id})${content ? '\n' + (0, mermaid_1.escapeMarkdown)(JSON.stringify(content)) : ''}${vert.callTargets ? '\n calls:' + (0, mermaid_1.escapeMarkdown)(JSON.stringify([...vert.callTargets])) : ''}\`"`;
+        output += `    n${id}${start}${name}${end}\n`;
+    }
+    else {
+        output += String(id).endsWith('-exit') ? `    n${id}((${id}))\n` : `    n${id}[[${id}]]\n`;
+    }
+    return output;
+}
+const getDirRegex = /flowchart\s+([A-Za-z]+)/;
+/**
+ * Convert the control flow graph to a mermaid string.
+ * @param cfg              - The control flow graph to convert.
+ * @param normalizedAst    - The normalized AST to use for the vertex content.
+ * @param prefix           - The prefix to use for the mermaid string.
+ * @param simplify         - Whether to simplify the control flow graph (especially in the context of basic blocks).
+ */
+function cfgToMermaid(cfg, normalizedAst, prefix = 'flowchart BT\n', simplify = false) {
+    let output = prefix;
+    const dirIs = getDirRegex.exec(prefix)?.at(1) ?? 'LR';
+    for (const [id, vertex] of cfg.graph.vertices(false)) {
+        const normalizedVertex = normalizedAst?.idMap.get(id);
         const content = getLexeme(normalizedVertex);
-        if (content.length > 0) {
-            const name = `"\`${(0, mermaid_1.escapeMarkdown)(vertex.name)} (${id})\n${(0, mermaid_1.escapeMarkdown)(JSON.stringify(content))}\`"`;
-            output += `    n${id}[${name}]\n`;
+        if (vertex.name === type_1.RType.ExpressionList && vertex.type === control_flow_graph_1.CfgVertexType.Expression && cfg.graph.hasVertex(id + '-exit')) {
+            output += `    subgraph ${type_1.RType.ExpressionList} ${normalizedVertex?.info.fullLexeme ?? id}\n`;
+            output += `        direction ${dirIs}\n`;
+        }
+        if (vertex.type === control_flow_graph_1.CfgVertexType.Block) {
+            if (simplify) {
+                const ids = vertex.elems?.map(e => e.id) ?? [];
+                const reconstruct = (0, reconstruct_1.reconstructToCode)(normalizedAst, new Set(ids), auto_select_defaults_1.doNotAutoSelect).code;
+                const name = `"\`Basic Block (${id})\n${(0, mermaid_1.escapeMarkdown)(reconstruct)}\`"`;
+                output += `    n${id}[[${name}]]\n`;
+            }
+            else {
+                output += `    subgraph n${vertex.id} [Block ${normalizedVertex?.info.fullLexeme ?? id}]\n`;
+                output += `        direction ${dirIs}\n`;
+                let last = undefined;
+                for (const element of vertex.elems ?? []) {
+                    const childNormalizedVertex = normalizedAst?.idMap.get(element.id);
+                    const childContent = getLexeme(childNormalizedVertex);
+                    output = cfgOfNode(vertex, childNormalizedVertex, element.id, childContent, output);
+                    // just to keep the order
+                    if (last) {
+                        output += `    ${last} -.-> n${element.id}\n`;
+                    }
+                    last = `n${element.id}`;
+                }
+                output += '    end\n';
+            }
         }
         else {
-            output += String(id).endsWith('-exit') ? `    n${id}((${id}))\n` : `    n${id}[[${id}]]\n`;
+            output = cfgOfNode(vertex, normalizedVertex, id, content, output);
+        }
+        if (vertex.name === type_1.RType.ExpressionList && vertex.type === control_flow_graph_1.CfgVertexType.EndMarker) {
+            output += '    end\n';
         }
     }
     for (const [from, targets] of cfg.graph.edges()) {
         for (const [to, edge] of targets) {
-            const edgeType = edge.label === 'CD' ? '-->' : '-.->';
-            const edgeSuffix = edge.label === 'CD' ? ` (${edge.when})` : '';
-            output += `    n${from} ${edgeType}|"${(0, mermaid_1.escapeMarkdown)(edge.label)}${edgeSuffix}"| n${to}\n`;
+            const edgeType = edge.label === 1 /* CfgEdgeType.Cd */ ? '-->' : '-.->';
+            const edgeSuffix = edge.label === 1 /* CfgEdgeType.Cd */ ? ` (${edge.when})` : '';
+            output += `    n${from} ${edgeType}|"${(0, mermaid_1.escapeMarkdown)((0, control_flow_graph_1.edgeTypeToString)(edge.label))}${edgeSuffix}"| n${to}\n`;
         }
     }
     for (const entryPoint of cfg.entryPoints) {
@@ -37,7 +89,7 @@ function cfgToMermaid(cfg, normalizedAst, prefix = '') {
 /**
  * Use mermaid to visualize the normalized AST.
  */
-function cfgToMermaidUrl(cfg, normalizedAst, prefix = '') {
+function cfgToMermaidUrl(cfg, normalizedAst, prefix = 'flowchart BT\n') {
     return (0, mermaid_1.mermaidCodeToUrl)(cfgToMermaid(cfg, normalizedAst, prefix));
 }
 //# sourceMappingURL=cfg.js.map

package/util/mermaid/dfg.d.ts

@@ -17,12 +17,13 @@ interface MermaidGraph {
     markStyle: MermaidMarkStyle;
     /** in the form of from-\>to because I am lazy, see {@link encodeEdge} */
     presentEdges: Set<string>;
+    presentVertices: Set<string>;
     rootGraph: DataflowGraph;
     /** if given, the dataflow graph will only focus on the "important" parts */
     simplified?: boolean;
 }
 /**
- * Prints a {@link SourceRange|range} as a human readable string.
+ * Prints a {@link SourceRange|range} as a human-readable string.
  */
 export declare function formatRange(range: SourceRange | undefined): string;
 export declare function printIdentifier(id: IdentifierDefinition): string;

package/util/mermaid/dfg.js

@@ -9,14 +9,16 @@ exports.diffGraphsToMermaidUrl = diffGraphsToMermaidUrl;
 const assert_1 = require("../assert");
 const mermaid_1 = require("./mermaid");
 const graph_1 = require("../../dataflow/graph/graph");
+const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const identifier_1 = require("../../dataflow/environments/identifier");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const edge_1 = require("../../dataflow/graph/edge");
 const vertex_1 = require("../../dataflow/graph/vertex");
 const environment_1 = require("../../dataflow/environments/environment");
 const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
+const built_in_1 = require("../../dataflow/environments/built-in");
 /**
- * Prints a {@link SourceRange|range} as a human readable string.
+ * Prints a {@link SourceRange|range} as a human-readable string.
  */
 function formatRange(range) {
     if (range === undefined) {
@@ -36,14 +38,14 @@ function subflowToMermaid(nodeId, exitPoints, subflow, mermaid, idPrefix = '') {
     if (subflow === undefined) {
         return;
     }
-    const subflowId = `${idPrefix}flow-${nodeId}`;
+    const subflowId = (0, mermaid_1.escapeId)(`${idPrefix}flow-${nodeId}`);
     if (mermaid.simplified) {
         // get parent
         const idMap = mermaid.rootGraph.idMap;
         const node = idMap?.get(nodeId);
-        const nodeLexeme = node?.info.fullLexeme ?? node?.lexeme ?? '??';
+        const nodeLexeme = node?.info.fullLexeme ?? node?.lexeme ?? 'function';
         const location = node?.location?.[0] ? ` (L. ${node?.location?.[0]})` : '';
-        mermaid.nodeLines.push(`\nsubgraph "${subflowId}" ["${(0, mermaid_1.escapeMarkdown)(nodeLexeme ?? 'function')}${location}"]`);
+        mermaid.nodeLines.push(`\nsubgraph "${subflowId}" ["${(0, mermaid_1.escapeMarkdown)(nodeLexeme)}${location}"]`);
     }
     else {
         mermaid.nodeLines.push(`\nsubgraph "${subflowId}" [function ${nodeId}]`);
@@ -147,6 +149,7 @@ function printEnvironmentToLines(env) {
 function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
     const fCall = info.tag === vertex_1.VertexType.FunctionCall;
     const { open, close } = mermaidNodeBrackets(info.tag);
+    id = (0, mermaid_1.escapeId)(id);
     if (info.environment && mermaid.includeEnvironments) {
         if (info.environment.level > 0 || info.environment.current.memory.size !== 0) {
             mermaid.nodeLines.push(`    %% Environment of ${id} [level: ${info.environment.level}]:`, printEnvironmentToLines(info.environment.current).map(x => `    %% ${x}`).join('\n'));
@@ -162,24 +165,29 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
     else {
         const escapedName = (0, mermaid_1.escapeMarkdown)(node ? `[${node.type}] ${lexeme}` : '??');
         const deps = info.cds ? ', :may:' + info.cds.map(c => c.id + (c.when ? '+' : '-')).join(',') : '';
+        const lnks = info.link?.origin ? ', :links:' + info.link.origin.join(',') : '';
         const n = node?.info.fullRange ?? node?.location ?? (node?.type === type_1.RType.ExpressionList ? node?.grouping?.[0].location : undefined);
-        mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}${escapedName.length > 10 ? '\n      ' : ' '}(${id}${deps})\n      *${formatRange(n)}*${fCall ? displayFunctionArgMapping(info.args) : ''}\`"${close}`);
+        mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}${escapedName.length > 10 ? '\n      ' : ' '}(${id}${deps}${lnks})\n      *${formatRange(n)}*${fCall ? displayFunctionArgMapping(info.args) : ''}\`"${close}`);
     }
     if (mark?.has(id)) {
         mermaid.nodeLines.push(`    style ${idPrefix}${id} ${mermaid.markStyle.vertex} `);
     }
-    if (mermaid.rootGraph.unknownSideEffects.has(id)) {
+    if ([...mermaid.rootGraph.unknownSideEffects].some(l => (0, node_id_1.normalizeIdToNumberIfPossible)(l) === (0, node_id_1.normalizeIdToNumberIfPossible)(id))) {
         mermaid.nodeLines.push(`    style ${idPrefix}${id} stroke:red,stroke-width:5px; `);
     }
-    const edges = mermaid.rootGraph.get(id, true);
+    const edges = mermaid.rootGraph.get((0, node_id_1.normalizeIdToNumberIfPossible)(id), true);
     (0, assert_1.guard)(edges !== undefined, `node ${id} must be found`);
     const artificialCdEdges = (info.cds ?? []).map(x => [x.id, { types: new Set([x.when ? 'CD-True' : 'CD-False']) }]);
-    for (const [target, edge] of [...edges[1], ...artificialCdEdges]) {
+    // eslint-disable-next-line prefer-const
+    for (let [target, edge] of [...edges[1], ...artificialCdEdges]) {
+        const originalTarget = target;
+        target = (0, mermaid_1.escapeId)(target);
         const edgeTypes = typeof edge.types == 'number' ? new Set((0, edge_1.splitEdgeTypes)(edge.types)) : edge.types;
         const edgeId = encodeEdge(idPrefix + id, idPrefix + target, edgeTypes);
         if (!mermaid.presentEdges.has(edgeId)) {
             mermaid.presentEdges.add(edgeId);
-            mermaid.edgeLines.push(`    ${idPrefix}${id} -->|"${[...edgeTypes].map(e => typeof e === 'number' ? (0, edge_1.edgeTypeToName)(e) : e).join(', ')}"| ${idPrefix}${target}`);
+            const style = (0, built_in_1.isBuiltIn)(target) ? '-.->' : '-->';
+            mermaid.edgeLines.push(`    ${idPrefix}${id} ${style}|"${[...edgeTypes].map(e => typeof e === 'number' ? (0, edge_1.edgeTypeToName)(e) : e).join(', ')}"| ${idPrefix}${target}`);
             if (mermaid.mark?.has(id + '->' + target)) {
                 // who invented this syntax?!
                 mermaid.edgeLines.push(`    linkStyle ${mermaid.presentEdges.size - 1} ${mermaid.markStyle.edge}`);
@@ -187,6 +195,14 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
             if (edgeTypes.has('CD-True') || edgeTypes.has('CD-False')) {
                 mermaid.edgeLines.push(`    linkStyle ${mermaid.presentEdges.size - 1} stroke:gray,color:gray;`);
             }
+            if ((0, built_in_1.isBuiltIn)(target)) {
+                mermaid.edgeLines.push(`    linkStyle ${mermaid.presentEdges.size - 1} stroke:gray;`);
+                if (!mermaid.presentVertices.has(target)) {
+                    mermaid.nodeLines.push(`    ${idPrefix}${target}["\`Built-In:\n${(0, mermaid_1.escapeMarkdown)(String(originalTarget).replace('built-in:', ''))}\`"]`);
+                    mermaid.nodeLines.push(`    style ${idPrefix}${target} stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;`);
+                    mermaid.presentVertices.add(target);
+                }
+            }
         }
     }
     if (info.tag === 'function-definition') {
@@ -195,7 +211,7 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
 }
 // make the passing of root ids more performant again
 function graphToMermaidGraph(rootIds, { simplified, graph, prefix = 'flowchart BT', idPrefix = '', includeEnvironments = !simplified, mark, rootGraph, presentEdges = new Set(), markStyle = { vertex: 'stroke:teal,stroke-width:7px,stroke-opacity:.8;', edge: 'stroke:teal,stroke-width:4.2px,stroke-opacity:.8' } }) {
-    const mermaid = { nodeLines: prefix === null ? [] : [prefix], edgeLines: [], presentEdges, mark, rootGraph: rootGraph ?? graph, includeEnvironments, markStyle, simplified };
+    const mermaid = { nodeLines: prefix === null ? [] : [prefix], edgeLines: [], presentEdges, presentVertices: new Set(), mark, rootGraph: rootGraph ?? graph, includeEnvironments, markStyle, simplified };
     for (const [id, info] of graph.vertices(true)) {
         if (rootIds.has(id)) {
             vertexToMermaid(info, mermaid, id, idPrefix, mark);

package/util/mermaid/mermaid.d.ts

@@ -1,7 +1,9 @@
 export declare function escapeMarkdown(text: string): string;
+export declare function escapeId(text: string | number): string;
 /**
  * Converts mermaid code (potentially produced by {@link graphToMermaid}) to an url that presents the graph in the mermaid editor.
  *
  * @param code - code to convert
+ * @param edit - if true, the url will point to the editor, otherwise it will point to the viewer
  */
 export declare function mermaidCodeToUrl(code: string, edit?: boolean): string;

package/util/mermaid/mermaid.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.escapeMarkdown = escapeMarkdown;
+exports.escapeId = escapeId;
 exports.mermaidCodeToUrl = mermaidCodeToUrl;
 const replacements = {
     // keep newlines
@@ -45,10 +46,15 @@ function escapeMarkdown(text) {
     }
     return text;
 }
+function escapeId(text) {
+    text = String(text).replace(/[^a-zA-Z0-9:-]/g, '_');
+    return text;
+}
 /**
  * Converts mermaid code (potentially produced by {@link graphToMermaid}) to an url that presents the graph in the mermaid editor.
  *
  * @param code - code to convert
+ * @param edit - if true, the url will point to the editor, otherwise it will point to the viewer
  */
 function mermaidCodeToUrl(code, edit = false) {
     const obj = {

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;