@eagleoutice/flowr 1.5.2 → 2.0.0

package/util/cfg/cfg.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cfg2quads = exports.equalCfg = exports.extractCFG = exports.emptyControlFlowInformation = exports.ControlFlowGraph = void 0;
-const r_bridge_1 = require("../../r-bridge");
 const set_1 = require("../set");
 const quads_1 = require("../quads");
 const log_1 = require("../log");
 const json_1 = require("../json");
+const fold_1 = require("../../r-bridge/lang-4.x/ast/model/processing/fold");
+const convert_values_1 = require("../../r-bridge/lang-4.x/convert-values");
+const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 /**
  * 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()}).
@@ -70,19 +72,9 @@ const cfgFolds = {
     foldLogical: cfgLeaf("expression" /* CfgVertexType.Expression */),
     foldSymbol: cfgLeaf("expression" /* CfgVertexType.Expression */),
     foldAccess: cfgAccess,
-    binaryOp: {
-        foldLogicalOp: cfgBinaryOp,
-        foldArithmeticOp: cfgBinaryOp,
-        foldComparisonOp: cfgBinaryOp,
-        foldAssignment: cfgBinaryOp,
-        foldPipe: cfgBinaryOp,
-        foldModelFormula: cfgBinaryOp
-    },
-    unaryOp: {
-        foldArithmeticOp: cfgUnaryOp,
-        foldLogicalOp: cfgUnaryOp,
-        foldModelFormula: cfgUnaryOp
-    },
+    foldBinaryOp: cfgBinaryOp,
+    foldPipe: cfgBinaryOp,
+    foldUnaryOp: cfgUnaryOp,
     other: {
         foldComment: cfgIgnore,
         foldLineDirective: cfgIgnore
@@ -104,7 +96,7 @@ const cfgFolds = {
     }
 };
 function extractCFG(ast) {
-    return (0, r_bridge_1.foldAst)(ast.ast, cfgFolds);
+    return (0, fold_1.foldAst)(ast.ast, cfgFolds);
 }
 exports.extractCFG = extractCFG;
 function cfgLeaf(type) {
@@ -137,10 +129,10 @@ function cfgIfThenElse(ifNode, condition, then, otherwise) {
     }
     for (const exitPoint of condition.exitPoints) {
         for (const entryPoint of then.entryPoints) {
-            graph.addEdge(entryPoint, exitPoint, { label: 'CD', when: r_bridge_1.RTrue });
+            graph.addEdge(entryPoint, exitPoint, { label: 'CD', when: convert_values_1.RTrue });
         }
         for (const entryPoint of otherwise?.entryPoints ?? []) {
-            graph.addEdge(entryPoint, exitPoint, { label: 'CD', when: r_bridge_1.RFalse });
+            graph.addEdge(entryPoint, exitPoint, { label: 'CD', when: convert_values_1.RFalse });
         }
     }
     for (const entryPoint of condition.entryPoints) {
@@ -151,7 +143,7 @@ function cfgIfThenElse(ifNode, condition, then, otherwise) {
     }
     if (!otherwise) {
         for (const exitPoint of condition.exitPoints) {
-            graph.addEdge(ifNode.info.id + '-exit', exitPoint, { label: 'CD', when: r_bridge_1.RFalse });
+            graph.addEdge(ifNode.info.id + '-exit', exitPoint, { label: 'CD', when: convert_values_1.RFalse });
         }
     }
     return {
@@ -189,7 +181,7 @@ function cfgWhile(whileLoop, condition, body) {
     }
     for (const exit of condition.exitPoints) {
         for (const entry of body.entryPoints) {
-            graph.addEdge(entry, exit, { label: 'CD', when: r_bridge_1.RTrue });
+            graph.addEdge(entry, exit, { label: 'CD', when: convert_values_1.RTrue });
         }
     }
     for (const entryPoint of body.entryPoints) {
@@ -203,7 +195,7 @@ function cfgWhile(whileLoop, condition, body) {
     }
     // while can break on the condition as well
     for (const exit of condition.exitPoints) {
-        graph.addEdge(whileLoop.info.id + '-exit', exit, { label: 'CD', when: r_bridge_1.RFalse });
+        graph.addEdge(whileLoop.info.id + '-exit', exit, { label: 'CD', when: convert_values_1.RFalse });
     }
     return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: [whileLoop.info.id + '-exit'], entryPoints: [whileLoop.info.id] };
 }
@@ -223,7 +215,7 @@ function cfgFor(forLoop, variable, vector, body) {
     }
     for (const exit of variable.exitPoints) {
         for (const entry of body.entryPoints) {
-            graph.addEdge(entry, exit, { label: 'CD', when: r_bridge_1.RTrue });
+            graph.addEdge(entry, exit, { label: 'CD', when: convert_values_1.RTrue });
         }
     }
     for (const next of [...body.nexts, ...body.exitPoints]) {
@@ -234,7 +226,7 @@ function cfgFor(forLoop, variable, vector, body) {
     }
     // while can break on the condition as well
     for (const exit of variable.exitPoints) {
-        graph.addEdge(forLoop.info.id + '-exit', exit, { label: 'CD', when: r_bridge_1.RFalse });
+        graph.addEdge(forLoop.info.id + '-exit', exit, { label: 'CD', when: convert_values_1.RFalse });
     }
     return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: [forLoop.info.id + '-exit'], entryPoints: [forLoop.info.id] };
 }
@@ -279,7 +271,7 @@ function cfgFunctionCall(call, name, args) {
     graph.addVertex({ id: call.info.id + '-exit', name: 'call-exit', type: "end-marker" /* CfgVertexType.EndMarker */ });
     let lastArgExits = [call.info.id + '-name'];
     for (const arg of args) {
-        if (arg === undefined) {
+        if (arg === r_function_call_1.EmptyArgument) {
             continue;
         }
         graph.merge(arg.graph);
@@ -368,11 +360,8 @@ function cfgAccess(access, name, accessors) {
     }
     result.entryPoints = [access.info.id];
     result.exitPoints = [access.info.id + '-exit'];
-    if (typeof accessors === 'string') {
-        return result;
-    }
     for (const accessor of accessors) {
-        if (accessor === null) {
+        if (accessor === r_function_call_1.EmptyArgument) {
             continue;
         }
         graph.merge(accessor.graph);
@@ -391,7 +380,7 @@ function cfgUnaryOp(unary, operand) {
     graph.addVertex({ id: unary.info.id, name: unary.type, type: "end-marker" /* CfgVertexType.EndMarker */ });
     return result;
 }
-function cfgExprList(_node, expressions) {
+function cfgExprList(_node, _grouping, expressions) {
     const result = { graph: new ControlFlowGraph(), breaks: [], nexts: [], returns: [], exitPoints: [], entryPoints: [] };
     let first = true;
     for (const expression of expressions) {

package/util/cfg/visitor.d.ts

@@ -1,5 +1,5 @@
-import type { NodeId } from '../../r-bridge';
 import type { CfgEdge, CfgVertex, ControlFlowInformation } from './cfg';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 export interface NodeVisitingContext {
     parent: {
         vertex: NodeId;

package/util/defaultmap.d.ts

@@ -1,5 +1,5 @@
 /**
- * A default map allows for a generator to produce values automatically if you want to add something to a map that does not have a value associated with a given key.
+ * A default map allows for a generator producing values automatically if you want to add something to a map that does not have a value associated with a given key.
  * This does not implement the default map interface as return types (and some future methods may) change
  */
 export declare class DefaultMap<K, V = K> {

package/util/defaultmap.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultMap = void 0;
 /**
- * A default map allows for a generator to produce values automatically if you want to add something to a map that does not have a value associated with a given key.
+ * A default map allows for a generator producing values automatically if you want to add something to a map that does not have a value associated with a given key.
  * This does not implement the default map interface as return types (and some future methods may) change
  */
 class DefaultMap {

package/util/diff.d.ts

@@ -18,7 +18,7 @@ export interface DifferenceReport {
    */
     comments(): readonly string[] | undefined;
     /**
-   * @returns true iff the compared structures are equal
+   * @returns true iff the compared structures are equal (i.e., the diff is empty)
    */
     isEqual(): boolean;
 }
@@ -30,14 +30,14 @@ export interface WriteableDifferenceReport extends DifferenceReport {
  * The `leftname` and `rightname` fields are only used to provide more useful
  * information in the difference report.
  */
-export interface GenericDifferenceInformation extends MergeableRecord {
+export interface GenericDifferenceInformation<Report extends WriteableDifferenceReport> extends MergeableRecord {
     /** A human-readable name for the left structure in `left == right`. */
     readonly leftname: string;
     /** A human-readable name for the right structure in `left == right`. */
     readonly rightname: string;
     /** The report on the difference of the two structures. */
-    readonly report: WriteableDifferenceReport;
+    readonly report: Report;
     /** A human-readable indication of where we are (the prefix of the information if the structures differ) */
     readonly position: string;
 }
-export declare function setDifference<T>(left: ReadonlySet<T>, right: ReadonlySet<T>, info: GenericDifferenceInformation): void;
+export declare function setDifference<T, Report extends WriteableDifferenceReport = WriteableDifferenceReport>(left: ReadonlySet<T>, right: ReadonlySet<T>, info: GenericDifferenceInformation<Report>): void;

package/util/files.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import type { RParseRequestFromFile } from '../r-bridge';
+import type { RParseRequestFromFile } from '../r-bridge/retriever';
 /**
  * Represents a table, identified by a header and a list of rows.
  */
@@ -9,7 +9,7 @@ export interface Table {
 }
 /**
  * Retrieves all files in the given directory recursively
- * @param dir    - Directory-path to start the search from
+ * @param dir    - Directory path to start the search from
  * @param suffix - Suffix of the files to be retrieved
  * Based on {@link https://stackoverflow.com/a/45130990}
  */

package/util/files.js

@@ -33,7 +33,7 @@ const log_1 = require("./log");
 const n_readlines_1 = __importDefault(require("n-readlines"));
 /**
  * Retrieves all files in the given directory recursively
- * @param dir    - Directory-path to start the search from
+ * @param dir    - Directory path to start the search from
  * @param suffix - Suffix of the files to be retrieved
  * Based on {@link https://stackoverflow.com/a/45130990}
  */

package/util/log.d.ts

@@ -1,5 +1,6 @@
 import { type ILogObj, type ISettingsParam, Logger } from 'tslog';
 import { type Options } from 'rotating-file-stream';
+export declare const expensiveTrace: (log: Logger<ILogObj>, supplier: () => string) => void;
 export declare class FlowrLogger extends Logger<ILogObj> {
     /** by keeping track of all children we can propagate updates of the settings (e.g., in tests) */
     private readonly childLoggers;

package/util/log.js

@@ -1,8 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.log = exports.FlowrLogger = void 0;
+exports.log = exports.FlowrLogger = exports.expensiveTrace = void 0;
 const tslog_1 = require("tslog");
 const rotating_file_stream_1 = require("rotating-file-stream");
+const expensiveTrace = (log, supplier) => {
+    if (log.settings.minLevel <= 1 /* LogLevel.Trace */) {
+        log.trace(supplier());
+    }
+};
+exports.expensiveTrace = expensiveTrace;
 class FlowrLogger extends tslog_1.Logger {
     /** by keeping track of all children we can propagate updates of the settings (e.g., in tests) */
     childLoggers = [];

package/util/logic.d.ts

@@ -0,0 +1 @@
+export type Ternary = 'always' | 'maybe' | 'never';

package/util/logic.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=logic.js.map

package/util/mermaid/ast.d.ts

@@ -1,4 +1,4 @@
-import type { RNodeWithParent } from '../../r-bridge';
+import type { RNodeWithParent } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 export declare function normalizedAstToMermaid(ast: RNodeWithParent, prefix?: string): string;
 /**
  * Use mermaid to visualize the normalized AST.

package/util/mermaid/ast.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizedAstToMermaidUrl = exports.normalizedAstToMermaid = void 0;
-const r_bridge_1 = require("../../r-bridge");
 const mermaid_1 = require("./mermaid");
+const visitor_1 = require("../../r-bridge/lang-4.x/ast/model/processing/visitor");
 function normalizedAstToMermaid(ast, prefix = '') {
     let output = prefix + 'flowchart TD\n';
-    (0, r_bridge_1.visitAst)(ast, n => {
+    (0, visitor_1.visitAst)(ast, 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) {

package/util/mermaid/cfg.d.ts

@@ -1,5 +1,5 @@
-import type { NormalizedAst } from '../../r-bridge';
 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;
 /**
  * Use mermaid to visualize the normalized AST.

package/util/mermaid/dfg.d.ts

@@ -1,21 +1,47 @@
-import type { NodeId } from '../../r-bridge';
 import type { SourceRange } from '../range';
-import type { DataflowGraph, DataflowMap } from '../../dataflow';
+import type { DataflowGraph } from '../../dataflow/graph/graph';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+type MarkVertex = NodeId;
+type MarkEdge = `${string}->${string}`;
+type Mark = MarkVertex | MarkEdge;
+interface MermaidGraph {
+    nodeLines: string[];
+    edgeLines: string[];
+    hasBuiltIn: boolean;
+    includeEnvironments: boolean;
+    mark: ReadonlySet<Mark> | undefined;
+    /** in the form of from-\>to because I am lazy, see {@link encodeEdge} */
+    presentEdges: Set<string>;
+    rootGraph: DataflowGraph;
+}
 export declare function formatRange(range: SourceRange | undefined): string;
-export declare function graphToMermaid(graph: DataflowGraph, dataflowIdMap: DataflowMap | undefined, prefix?: string | null, idPrefix?: string, includeEnvironments?: boolean, mark?: Set<NodeId>, rootGraph?: DataflowGraph): string;
+interface MermaidGraphConfiguration {
+    graph: DataflowGraph;
+    prefix?: string | null;
+    idPrefix?: string;
+    includeEnvironments?: boolean;
+    mark?: ReadonlySet<Mark>;
+    rootGraph?: DataflowGraph;
+    presentEdges?: Set<string>;
+}
+export declare function graphToMermaid(config: MermaidGraphConfiguration): {
+    string: string;
+    mermaid: MermaidGraph;
+};
 /**
  * Converts a dataflow graph to a mermaid url that visualizes the graph.
  *
  * @param graph         - The graph to convert
- * @param dataflowIdMap - ID map to use to get access to the graph id mappings
  * @param includeEnvironments - Whether to include the environments in the mermaid graph code
- * @param mark          - Special nodes to mark (e.g. those included in the slice)
+ * @param mark          - Special nodes to mark (e.g., those included in the slice)
  */
-export declare function graphToMermaidUrl(graph: DataflowGraph, dataflowIdMap: DataflowMap, includeEnvironments?: boolean, mark?: Set<NodeId>): string;
+export declare function graphToMermaidUrl(graph: DataflowGraph, includeEnvironments?: boolean, mark?: ReadonlySet<NodeId>): string;
 export interface LabeledDiffGraph {
     label: string;
     graph: DataflowGraph;
+    mark?: Set<Mark>;
 }
 /** uses same id map but ensures, it is different from the rhs so that mermaid can work with that */
-export declare function diffGraphsToMermaid(left: LabeledDiffGraph, right: LabeledDiffGraph, dataflowIdMap: DataflowMap | undefined, prefix: string): string;
-export declare function diffGraphsToMermaidUrl(left: LabeledDiffGraph, right: LabeledDiffGraph, dataflowIdMap: DataflowMap | undefined, prefix: string): string;
+export declare function diffGraphsToMermaid(left: LabeledDiffGraph, right: LabeledDiffGraph, prefix: string): string;
+export declare function diffGraphsToMermaidUrl(left: LabeledDiffGraph, right: LabeledDiffGraph, prefix: string): string;
+export {};

package/util/mermaid/dfg.js

@@ -1,38 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.diffGraphsToMermaidUrl = exports.diffGraphsToMermaid = exports.graphToMermaidUrl = exports.graphToMermaid = exports.formatRange = void 0;
-const dataflow_1 = require("../../dataflow");
 const assert_1 = require("../assert");
-const json_1 = require("../json");
 const mermaid_1 = require("./mermaid");
+const graph_1 = require("../../dataflow/graph/graph");
+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 environment_1 = require("../../dataflow/environments/environment");
+const built_in_1 = require("../../dataflow/environments/built-in");
 function formatRange(range) {
     if (range === undefined) {
-        return '??';
+        return '??-??';
     }
-    return `${range.start.line}.${range.start.column}-${range.end.line}.${range.end.column}`;
+    return `${range[0]}.${range[1]}-${range[2]}.${range[3]}`;
 }
 exports.formatRange = formatRange;
-function scopeToMermaid(scope, when) {
-    const whenText = when === 'always' ? '' : `, ${when}`;
-    return `, *${scope.replace('<', '#lt;')}${whenText}*`;
-}
-function createArtificialExitPoints(exitPoints, mermaid, dataflowIdMap, idPrefix) {
-    for (const exitPoint of exitPoints) {
-        if (!mermaid.rootGraph.hasNode(exitPoint, true)) {
-            const node = dataflowIdMap.get(exitPoint);
-            (0, assert_1.guard)(node !== undefined, 'exit point not found');
-            mermaid.nodeLines.push(` ${idPrefix}${exitPoint}{{"${node.lexeme ?? '??'} (${exitPoint})\n      ${formatRange(dataflowIdMap.get(exitPoint)?.location)}"}}`);
-        }
-        mermaid.nodeLines.push(`    style ${idPrefix}${exitPoint} stroke-width:6.5px;`);
-    }
-}
-function subflowToMermaid(nodeId, exitPoints, subflow, dataflowIdMap, mermaid, idPrefix = '') {
+function subflowToMermaid(nodeId, exitPoints, subflow, mermaid, idPrefix = '') {
     if (subflow === undefined) {
         return;
     }
     const subflowId = `${idPrefix}flow-${nodeId}`;
     mermaid.nodeLines.push(`\nsubgraph "${subflowId}" [function ${nodeId}]`);
-    const subgraph = graphToMermaidGraph(subflow.graph, mermaid.rootGraph, dataflowIdMap, null, idPrefix, mermaid.includeEnvironments, mermaid.mark, mermaid.rootGraph);
+    const subgraph = graphToMermaidGraph(subflow.graph, {
+        graph: mermaid.rootGraph,
+        rootGraph: mermaid.rootGraph,
+        idPrefix,
+        includeEnvironments: mermaid.includeEnvironments,
+        mark: mermaid.mark,
+        prefix: null
+    });
     mermaid.nodeLines.push(...subgraph.nodeLines);
     mermaid.edgeLines.push(...subgraph.edgeLines);
     for (const [color, pool] of [['purple', subflow.in], ['green', subflow.out], ['orange', subflow.unknownReferences]]) {
@@ -43,123 +39,156 @@ function subflowToMermaid(nodeId, exitPoints, subflow, dataflowIdMap, mermaid, i
             }
         }
     }
-    if (dataflowIdMap !== undefined) {
-        createArtificialExitPoints(exitPoints, mermaid, dataflowIdMap, idPrefix);
-    }
     mermaid.nodeLines.push('end');
     mermaid.edgeLines.push(`${idPrefix}${nodeId} -.-|function| ${subflowId}\n`);
 }
 function printArg(arg) {
-    if (arg === 'empty') {
-        return '';
+    if (arg === undefined) {
+        return '??';
+    }
+    else if (arg === r_function_call_1.EmptyArgument) {
+        return '[empty]';
+    }
+    else if ((0, graph_1.isNamedArgument)(arg)) {
+        const deps = arg.controlDependencies ? ', :maybe:' + arg.controlDependencies.join(',') : '';
+        return `${arg.name} (${arg.nodeId}${deps})`;
     }
-    if (arg === undefined || arg === '<value>') {
+    else if ((0, graph_1.isPositionalArgument)(arg)) {
+        const deps = arg.controlDependencies ? ' (:maybe:' + arg.controlDependencies.join(',') + ')' : '';
+        return `${arg.nodeId}${deps}`;
+    }
+    else {
         return '??';
     }
-    return `${arg.nodeId}`;
 }
 function displayFunctionArgMapping(argMapping) {
     const result = [];
     for (const arg of argMapping) {
-        result.push(Array.isArray(arg) ? `${arg[0]} -> ${printArg(arg[1])}` : `${printArg(arg)}`);
+        result.push(printArg(arg));
     }
     return result.length === 0 ? '' : `\n    (${result.join(', ')})`;
 }
-function encodeEdge(from, to, types, attribute) {
-    // sort from and to for same edges and relates be order independent
-    if (types.has(dataflow_1.EdgeType.SameReadRead) || types.has(dataflow_1.EdgeType.SameDefDef) || types.has(dataflow_1.EdgeType.Relates)) {
-        if (from > to) {
-            ({ from, to } = { from: to, to: from });
-        }
-    }
-    return `${from}->${to}["${[...types].join(':')} (${attribute})"]`;
+function encodeEdge(from, to, types) {
+    return `${from}->${to}["${[...types].join(':')}"]`;
 }
-function mermaidNodeBrackets(def, fCall) {
+function mermaidNodeBrackets(tag) {
     let open;
     let close;
-    if (def) {
+    if (tag === 'function-definition' || tag === 'variable-definition') {
         open = '[';
         close = ']';
     }
-    else if (fCall) {
+    else if (tag === "function-call" /* VertexType.FunctionCall */) {
         open = '[[';
         close = ']]';
     }
+    else if (tag === 'value') {
+        open = '{{';
+        close = '}}';
+    }
     else {
         open = '([';
         close = '])';
     }
     return { open, close };
 }
-function nodeToMermaid(graph, info, mermaid, id, idPrefix, dataflowIdMap, mark) {
-    const def = info.tag === 'variable-definition' || info.tag === 'function-definition';
-    const fCall = info.tag === 'function-call';
-    const defText = def ? scopeToMermaid(info.scope, info.when) : '';
-    const { open, close } = mermaidNodeBrackets(def, fCall);
-    if (mermaid.includeEnvironments) {
-        mermaid.nodeLines.push(`    %% ${id}: ${JSON.stringify(info.environment, json_1.jsonReplacer)}`);
-    }
-    mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${(0, mermaid_1.escapeMarkdown)(info.name)} (${id}${defText})\n      *${formatRange(dataflowIdMap?.get(id)?.location)}*${fCall ? displayFunctionArgMapping(info.args) : ''}\`"${close}`);
+function printIdentifier(id) {
+    return `${id.name} (${id.nodeId}, ${id.kind},${id.controlDependencies ? ' {' + id.controlDependencies.join(',') + '},' : ''} def. @${id.definedAt})`;
+}
+function printEnvironmentToLines(env) {
+    if (env === undefined) {
+        return ['??'];
+    }
+    else if (env.id === environment_1.BuiltInEnvironment.id) {
+        return ['Built-in'];
+    }
+    const lines = [...printEnvironmentToLines(env.parent), `${env.id}--${env.name}${'-'.repeat(40)}`];
+    const longestName = Math.max(...[...env.memory.keys()].map(x => x.length));
+    for (const [name, defs] of env.memory.entries()) {
+        const printName = `${name}:`;
+        lines.push(`  ${printName.padEnd(longestName + 1, ' ')} {${defs.map(printIdentifier).join(', ')}}`);
+    }
+    return lines;
+}
+function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
+    const fCall = info.tag === "function-call" /* VertexType.FunctionCall */;
+    const { open, close } = mermaidNodeBrackets(info.tag);
+    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'));
+        }
+    }
+    const node = mermaid.rootGraph.idMap?.get(info.id);
+    const escapedName = (0, mermaid_1.escapeMarkdown)(node ? `[${node.type}] ${node.lexeme ?? '??'}` : '??');
+    const deps = info.controlDependencies ? ', :maybe:' + info.controlDependencies.join(',') : '';
+    mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}${escapedName.length > 10 ? '\n      ' : ' '}(${id}${deps})\n      *${formatRange(mermaid.rootGraph.idMap?.get(id)?.location)}*${fCall ? displayFunctionArgMapping(info.args) : ''}\`"${close}`);
     if (mark?.has(id)) {
         mermaid.nodeLines.push(`    style ${idPrefix}${id} stroke:black,stroke-width:7px; `);
     }
     const edges = mermaid.rootGraph.get(id, true);
     (0, assert_1.guard)(edges !== undefined, `node ${id} must be found`);
-    for (const [target, edge] of [...edges[1]]) {
-        const dotEdge = edge.types.has(dataflow_1.EdgeType.SameDefDef) || edge.types.has(dataflow_1.EdgeType.SameReadRead) || edge.types.has(dataflow_1.EdgeType.Relates);
-        const edgeId = encodeEdge(idPrefix + id, idPrefix + target, edge.types, edge.attribute);
+    const artificialCdEdges = (info.controlDependencies ?? []).map(x => [x, { types: new Set(['CD']) }]);
+    for (const [target, edge] of [...edges[1], ...artificialCdEdges]) {
+        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} ${dotEdge ? '-.-' : '-->'}|"${[...edge.types].join(', ')} (${edge.attribute})"| ${idPrefix}${target}`);
-            if (target === dataflow_1.BuiltIn) {
+            mermaid.edgeLines.push(`    ${idPrefix}${id} -->|"${[...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} stroke:red,color:red,stroke-width:4px;`);
+            }
+            if (edgeTypes.has('CD')) {
+                mermaid.edgeLines.push(`    linkStyle ${mermaid.presentEdges.size - 1} stroke:gray,color:gray;`);
+            }
+            if (target === built_in_1.BuiltIn) {
                 mermaid.hasBuiltIn = true;
             }
         }
     }
     if (info.tag === 'function-definition') {
-        subflowToMermaid(id, info.exitPoints, info.subflow, dataflowIdMap, mermaid, idPrefix);
+        subflowToMermaid(id, info.exitPoints, info.subflow, mermaid, idPrefix);
     }
 }
 // make the passing of root ids more performant again
-function graphToMermaidGraph(rootIds, graph, dataflowIdMap, prefix = 'flowchart TD', idPrefix = '', includeEnvironments = true, mark, rootGraph) {
-    const mermaid = { nodeLines: prefix === null ? [] : [prefix], edgeLines: [], presentEdges: new Set(), hasBuiltIn: false, mark, rootGraph: rootGraph ?? graph, includeEnvironments };
+function graphToMermaidGraph(rootIds, { graph, prefix = 'flowchart TD', idPrefix = '', includeEnvironments = true, mark, rootGraph, presentEdges = new Set() }) {
+    const mermaid = { nodeLines: prefix === null ? [] : [prefix], edgeLines: [], presentEdges, hasBuiltIn: false, mark, rootGraph: rootGraph ?? graph, includeEnvironments };
     for (const [id, info] of graph.vertices(true)) {
         if (rootIds.has(id)) {
-            nodeToMermaid(graph, info, mermaid, id, idPrefix, dataflowIdMap, mark);
+            vertexToMermaid(info, mermaid, id, idPrefix, mark);
         }
     }
     if (mermaid.hasBuiltIn) {
-        mermaid.nodeLines.push(`    ${idPrefix}${dataflow_1.BuiltIn}["Built-in"]`);
+        mermaid.nodeLines.push(`    ${idPrefix}${built_in_1.BuiltIn}["Built-in"]`);
     }
     return mermaid;
 }
-function graphToMermaid(graph, dataflowIdMap, prefix = 'flowchart TD', idPrefix = '', includeEnvironments, mark, rootGraph) {
-    const mermaid = graphToMermaidGraph(graph.rootIds(), graph, dataflowIdMap, prefix, idPrefix, includeEnvironments, mark, rootGraph);
-    return `${mermaid.nodeLines.join('\n')}\n${mermaid.edgeLines.join('\n')}`;
+function graphToMermaid(config) {
+    const mermaid = graphToMermaidGraph(config.graph.rootIds(), config);
+    return { string: `${mermaid.nodeLines.join('\n')}\n${mermaid.edgeLines.join('\n')}`, mermaid };
 }
 exports.graphToMermaid = graphToMermaid;
 /**
  * Converts a dataflow graph to a mermaid url that visualizes the graph.
  *
  * @param graph         - The graph to convert
- * @param dataflowIdMap - ID map to use to get access to the graph id mappings
  * @param includeEnvironments - Whether to include the environments in the mermaid graph code
- * @param mark          - Special nodes to mark (e.g. those included in the slice)
+ * @param mark          - Special nodes to mark (e.g., those included in the slice)
  */
-function graphToMermaidUrl(graph, dataflowIdMap, includeEnvironments, mark) {
-    return (0, mermaid_1.mermaidCodeToUrl)(graphToMermaid(graph, dataflowIdMap, undefined, undefined, includeEnvironments, mark));
+function graphToMermaidUrl(graph, includeEnvironments, mark) {
+    return (0, mermaid_1.mermaidCodeToUrl)(graphToMermaid({ graph, includeEnvironments, mark }).string);
 }
 exports.graphToMermaidUrl = graphToMermaidUrl;
 /** uses same id map but ensures, it is different from the rhs so that mermaid can work with that */
-function diffGraphsToMermaid(left, right, dataflowIdMap, prefix) {
+function diffGraphsToMermaid(left, right, prefix) {
     // we add the prefix ourselves
-    const leftGraph = graphToMermaid(left.graph, dataflowIdMap, '', `l-${left.label}`);
-    const rightGraph = graphToMermaid(right.graph, dataflowIdMap, '', `r-${right.label}`);
+    const { string: leftGraph, mermaid } = graphToMermaid({ graph: left.graph, prefix: '', idPrefix: `l-${left.label}`, includeEnvironments: true, mark: left.mark });
+    const { string: rightGraph } = graphToMermaid({ graph: right.graph, prefix: '', idPrefix: `r-${right.label}`, includeEnvironments: true, mark: right.mark, presentEdges: mermaid.presentEdges });
     return `${prefix}flowchart TD\nsubgraph "${left.label}"\n${leftGraph}\nend\nsubgraph "${right.label}"\n${rightGraph}\nend`;
 }
 exports.diffGraphsToMermaid = diffGraphsToMermaid;
-function diffGraphsToMermaidUrl(left, right, dataflowIdMap, prefix) {
-    return (0, mermaid_1.mermaidCodeToUrl)(diffGraphsToMermaid(left, right, dataflowIdMap, prefix));
+function diffGraphsToMermaidUrl(left, right, prefix) {
+    return (0, mermaid_1.mermaidCodeToUrl)(diffGraphsToMermaid(left, right, prefix));
 }
 exports.diffGraphsToMermaidUrl = diffGraphsToMermaidUrl;
 //# sourceMappingURL=dfg.js.map

package/util/mermaid/mermaid.d.ts

@@ -4,4 +4,4 @@ export declare function escapeMarkdown(text: string): string;
  *
  * @param code - code to convert
  */
-export declare function mermaidCodeToUrl(code: string): string;
+export declare function mermaidCodeToUrl(code: string, edit?: boolean): string;

package/util/mermaid/mermaid.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mermaidCodeToUrl = exports.escapeMarkdown = void 0;
 function escapeMarkdown(text) {
-    return text.replaceAll(/([+*])/g, '\\$1').replaceAll('"', '\'\'');
+    return text.replaceAll(/([+*<>-])/g, '\\$1').replaceAll('"', '\'\'');
 }
 exports.escapeMarkdown = escapeMarkdown;
 /**
@@ -10,15 +10,14 @@ exports.escapeMarkdown = escapeMarkdown;
  *
  * @param code - code to convert
  */
-function mermaidCodeToUrl(code) {
+function mermaidCodeToUrl(code, edit = false) {
     const obj = {
         code,
-        mermaid: {},
-        updateEditor: false,
-        autoSync: true,
-        updateDiagram: false
+        mermaid: {
+            autoSync: true
+        }
     };
-    return `https://mermaid.live/edit#base64:${Buffer.from(JSON.stringify(obj)).toString('base64')}`;
+    return `https://mermaid.live/${edit ? 'edit' : 'view'}#base64:${Buffer.from(JSON.stringify(obj)).toString('base64')}`;
 }
 exports.mermaidCodeToUrl = mermaidCodeToUrl;
 //# sourceMappingURL=mermaid.js.map