@eagleoutice/flowr 2.9.7 → 2.9.9

package/control-flow/useless-loop.js

@@ -10,6 +10,7 @@ const vertex_1 = require("../dataflow/graph/vertex");
 const info_1 = require("../dataflow/info");
 const r_function_call_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const assert_1 = require("../util/assert");
+const control_flow_graph_1 = require("./control-flow-graph");
 const semantic_cfg_guided_visitor_1 = require("./semantic-cfg-guided-visitor");
 exports.loopyFunctions = new Set([built_in_1.BuiltInProcName.ForLoop, built_in_1.BuiltInProcName.WhileLoop, built_in_1.BuiltInProcName.RepeatLoop]);
 /**
@@ -88,7 +89,7 @@ class CfgSingleIterationLoopDetector extends semantic_cfg_guided_visitor_1.Seman
     startVisitor(_) {
         const g = this.config.controlFlow.graph;
         const ingoing = (i) => g.ingoingEdges(i);
-        const exits = new Set(g.getVertex(this.loopToCheck)?.end ?? []);
+        const exits = new Set(control_flow_graph_1.CfgVertex.getEnd(g.getVertex(this.loopToCheck)) ?? []);
         (0, assert_1.guard)(exits.size !== 0, "Can't find end of loop");
         const stack = [this.loopToCheck];
         while (stack.length > 0) {

package/documentation/wiki-cfg.js

@@ -149,6 +149,12 @@ For readability, we structure this wiki page into various segments:
 	- [Sophisticated CFG Traversal](#cfg-traversal)
 	- [Working With Exit Points](#cfg-exit-points)
 
+${(0, doc_structure_1.block)({
+            type: 'TIP',
+            content: `FlowR provides you with various helper objects to work with the CFG, such as ${ctx.link('CfgEdge', undefined, { type: 'variable' })} and ${ctx.link('CfgVertex', undefined, { type: 'variable' })}, 
+		which you can use to easily access the properties of the CFG and its vertices and edges.`
+        })}
+
 ${(0, doc_structure_1.section)('Initial Overview', 2, 'cfg-overview')}
 
 For now, let's look at a CFG for a program without any branching:
@@ -360,7 +366,13 @@ And again it should be noted that even though the example code is more complicat
 ${(0, doc_structure_1.section)('Working with the CFG', 2, 'cfg-working')}
 
 There is a plethora of functions that you can use the traverse the [normalized AST](${doc_files_1.FlowrWikiBaseRef}/Normalized-AST) and the [dataflow graph](${doc_files_1.FlowrWikiBaseRef}/Dataflow%20Graph). 
-Similarly, flowR provides you with a set of utility functions and classes that you can use to interact with the control flow graph.
+Similarly, flowR provides you with a set of utility functions and classes that you can use to interact with the control flow graph:
+
+* ${ctx.link(simple_visitor_1.visitCfgInOrder)} and ${ctx.link(simple_visitor_1.visitCfgInReverseOrder)} for simple traversals
+* ${ctx.link(basic_cfg_guided_visitor_1.BasicCfgGuidedVisitor)}, ${ctx.link(syntax_cfg_guided_visitor_1.SyntaxAwareCfgGuidedVisitor)}, ${ctx.link(dfg_cfg_guided_visitor_1.DataflowAwareCfgGuidedVisitor)}, and ${ctx.link(semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor)} for more sophisticated traversals
+* ${ctx.link('CfgEdge', undefined, { type: 'variable' })} and ${ctx.link('CfgVertex', undefined, { type: 'variable' })} for easy access to the properties of the CFG and its vertices and edges
+* ${ctx.link(cfg_properties_1.assertCfgSatisfiesProperties)} and ${ctx.link('CfgProperties')} to check for properties of the CFG
+* ${ctx.link(diff_cfg_1.diffOfControlFlowGraphs)} to diff two CFGs
 
 ${(0, doc_structure_1.section)('Simple Traversal', 3, 'cfg-simple-traversal')}
 
@@ -515,12 +527,12 @@ But the control flow perspective gives you more! Given a simple addition like \`
 ${await (async function () {
             const cfg = await (0, doc_cfg_1.getCfg)(shell, 'x + 1');
             const [plusVertexId, plusVertex] = cfg.info.graph.vertices().entries().filter(([n]) => (0, node_id_1.recoverName)(n, cfg.ast.idMap) === '+').toArray()[0];
-            (0, assert_1.guard)(plusVertex.type === control_flow_graph_1.CfgVertexType.Expression);
-            const numOfExits = plusVertex.end?.length ?? 0;
-            (0, assert_1.guard)(plusVertex.end && numOfExits === 1);
+            (0, assert_1.guard)(control_flow_graph_1.CfgVertex.isExpression(plusVertex));
+            const numOfExits = control_flow_graph_1.CfgVertex.getEnd(plusVertex)?.length ?? 0;
+            (0, assert_1.guard)(numOfExits === 1);
             return `${await (0, doc_cfg_1.printCfgCode)(shell, 'x + 1', { showCode: true, prefix: 'flowchart RL\n' })}
 	
-Looking at the binary operation vertex for \`+\` (with id \`${plusVertexId}\`) we see that it is linked to a single exit ("end marker") point: \`${plusVertex.end[0]}\`.
+Looking at the binary operation vertex for \`+\` (with id \`${plusVertexId}\`) we see that it is linked to a single exit ("end marker") point: \`${control_flow_graph_1.CfgVertex.getEnd(plusVertex)?.[0] ?? '??'}\`.
 Checking this vertex essentially reveals all exit points of the expression ‐ in this case, this simply refers to the operands of the addition.
 However, the idea transfers to more complex expressions as well...
 	`;
@@ -530,12 +542,12 @@ ${(0, doc_structure_1.details)('Example: Exit Points for an if', await (async fu
             const expr = 'if(u) 3 else 2';
             const cfg = await (0, doc_cfg_1.getCfg)(shell, expr);
             const [ifVertexId, ifVertex] = [...cfg.info.graph.vertices()].filter(([n]) => (0, node_id_1.recoverName)(n, cfg.ast.idMap) === 'if')[0];
-            (0, assert_1.guard)(ifVertex.type === control_flow_graph_1.CfgVertexType.Statement);
-            const numOfExits = ifVertex.end?.length ?? 0;
-            (0, assert_1.guard)(ifVertex.end && numOfExits === 1);
+            (0, assert_1.guard)(control_flow_graph_1.CfgVertex.isStatement(ifVertex));
+            const numOfExits = control_flow_graph_1.CfgVertex.getEnd(ifVertex)?.length ?? 0;
+            (0, assert_1.guard)(numOfExits === 1);
             return `${await (0, doc_cfg_1.printCfgCode)(shell, expr, { showCode: true, prefix: 'flowchart RL\n' })}
 	
-Looking at the if vertex for (with id \`${ifVertexId}\`) we see that it is again linked to a single exit point: \`${ifVertex.end[0]}\`.
+Looking at the if vertex for (with id \`${ifVertexId}\`) we see that it is again linked to a single exit point: \`${control_flow_graph_1.CfgVertex.getEnd(ifVertex)?.[0] ?? '??'}\`.
 Yet, now this exit vertex is linked to the two branches of the if statement (the \`then\` and \`else\` branch).
 	`;
         })())}

package/documentation/wiki-mk/doc-maker.js

@@ -11,7 +11,7 @@ const DefaultReplacementPatterns = [
     // eslint-disable-next-line no-irregular-whitespace -- we may produce it in output
     [/\d+(\.\d+)?( |\s*)?ms/g, ''],
     [/tmp[%A-Za-z0-9-]+/g, ''],
-    [/"?(timing|searchTimeMs|processTimeMs|id|treeSitterId)"?:\s*\d+(\.\d)?,?/g, ''],
+    [/"?(timing|searchTimeMs|processTimeMs|id|tsId)"?:\s*\d+(\.\d)?,?/g, ''],
     [/"format":"compact".+/gmius, ''],
     [/%%\s*\d*-+/g, ''],
     [/"[rR]": "\d+\.\d+\.\d+.*?"/g, ''],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.9.7",
+  "version": "2.9.9",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {

package/project/context/flowr-file.d.ts

@@ -92,6 +92,11 @@ export declare abstract class FlowrFile<Content extends StringableContent = Stri
     get roles(): readonly FileRole[] | undefined;
     path(): string;
     content(): Content;
+    /**
+     * Allows to overwrite the content cache.
+     * @protected
+     */
+    protected setContent(content: Content): void;
     protected abstract loadContent(): Content;
     assignRole(role: FileRole): void;
     /**

package/project/context/flowr-file.js

@@ -62,6 +62,13 @@ class FlowrFile {
         }
         return this.contentCache;
     }
+    /**
+     * Allows to overwrite the content cache.
+     * @protected
+     */
+    setContent(content) {
+        this.contentCache = content;
+    }
     assignRole(role) {
         if (this._roles === undefined) {
             this._roles = [role];

package/project/plugins/file-plugins/files/flowr-description-file.d.ts

@@ -24,6 +24,7 @@ export declare class FlowrDescriptionFile extends FlowrFile<DeepReadonly<DCF>> {
      * @see {@link parseDCF} for details on the parsing logic.
      */
     protected loadContent(): DCF;
+    static fromDCF(dcf: DCF, path: string, roles?: FileRole[]): FlowrDescriptionFile;
     /**
      * Description file lifter, this does not re-create if already a description file
      */

package/project/plugins/file-plugins/files/flowr-description-file.js

@@ -34,6 +34,11 @@ class FlowrDescriptionFile extends flowr_file_1.FlowrFile {
     loadContent() {
         return parseDCF(this.wrapped);
     }
+    static fromDCF(dcf, path, roles) {
+        const file = new FlowrDescriptionFile(new flowr_file_1.FlowrTextFile(path, roles));
+        file.setContent(dcf);
+        return file;
+    }
     /**
      * Description file lifter, this does not re-create if already a description file
      */

package/project/plugins/file-plugins/files/flowr-namespace-file.d.ts

@@ -32,6 +32,10 @@ export declare class FlowrNamespaceFile extends FlowrFile<NamespaceFormat> {
      * and handle role assignments.
      */
     constructor(file: FlowrFileProvider, ctx?: FlowrAnalyzerContext);
+    /**
+     * Creates a {@link FlowrNamespaceFile} from a given {@link NamespaceFormat}, path and optional roles. This is useful if you already have the namespace content parsed and want to create a namespace file instance without re-parsing.
+     */
+    static fromNamespaceFormat(fmt: NamespaceFormat, path: string, roles?: FileRole[]): FlowrNamespaceFile;
     /**
      * Loads and parses the content of the wrapped file in the {@link NamespaceFormat}.
      * @see {@link parseNamespaceSimple} for details on the parsing logic.

package/project/plugins/file-plugins/files/flowr-namespace-file.js

@@ -30,6 +30,14 @@ class FlowrNamespaceFile extends flowr_file_1.FlowrFile {
         this.wrapped = file;
         this.ctx = ctx;
     }
+    /**
+     * Creates a {@link FlowrNamespaceFile} from a given {@link NamespaceFormat}, path and optional roles. This is useful if you already have the namespace content parsed and want to create a namespace file instance without re-parsing.
+     */
+    static fromNamespaceFormat(fmt, path, roles) {
+        const file = new FlowrNamespaceFile(new flowr_file_1.FlowrTextFile(path, roles));
+        file.setContent(fmt);
+        return file;
+    }
     /**
      * Loads and parses the content of the wrapped file in the {@link NamespaceFormat}.
      * @see {@link parseNamespaceSimple} for details on the parsing logic.

package/project/plugins/file-plugins/files/flowr-news-file.d.ts

@@ -24,4 +24,8 @@ export declare class FlowrNewsFile extends FlowrFile<NewsChunk[]> {
      * News file lifter, this does not re-create if already a news file
      */
     static from(file: FlowrFileProvider | FlowrNewsFile, role?: FileRole): FlowrNewsFile;
+    /**
+     * Creates a FlowrNewsFile from given news chunks, path and optional roles. This is useful if you already have the news content parsed and want to create a news file instance without re-parsing.
+     */
+    static fromNewsChunks(chunks: NewsChunk[], path: string, roles?: FileRole[]): FlowrNewsFile;
 }

package/project/plugins/file-plugins/files/flowr-news-file.js

@@ -33,6 +33,14 @@ class FlowrNewsFile extends flowr_file_1.FlowrFile {
         }
         return file instanceof FlowrNewsFile ? file : new FlowrNewsFile(file);
     }
+    /**
+     * Creates a FlowrNewsFile from given news chunks, path and optional roles. This is useful if you already have the news content parsed and want to create a news file instance without re-parsing.
+     */
+    static fromNewsChunks(chunks, path, roles) {
+        const file = new FlowrNewsFile(new flowr_file_1.FlowrTextFile(path, roles));
+        file.setContent(chunks);
+        return file;
+    }
 }
 exports.FlowrNewsFile = FlowrNewsFile;
 function makeRversionRegex() {

package/queries/catalog/control-flow-query/control-flow-query-format.js

@@ -27,7 +27,7 @@ exports.ControlFlowQueryDefinition = {
     flattenInvolvedNodes: (queryResults) => {
         const out = queryResults;
         return out.controlFlow.graph.vertices(true).entries()
-            .filter(([, v]) => v.type !== control_flow_graph_1.CfgVertexType.Block)
+            .filter(([, v]) => !control_flow_graph_1.CfgVertex.isBlock(v))
             .map(v => v[0])
             .toArray();
     }

package/r-bridge/lang-4.x/tree-sitter/tree-sitter-normalize.d.ts

@@ -2,7 +2,8 @@ import type { Tree } from 'web-tree-sitter';
 import type { RProject } from '../ast/model/nodes/r-project';
 import type { ParseStepOutputSingleFile } from '../../parser';
 export interface TreeSitterInfo {
-    treeSitterId: number;
+    /** id of the tree-sitter node this AST node was created from, used for traceability and linking back to tree-sitter nodes */
+    tsId: number;
 }
 /**
  * @param tree - The tree to normalize

package/r-bridge/lang-4.x/tree-sitter/tree-sitter-normalize.js

@@ -77,7 +77,7 @@ function convertTreeNode(node) {
             info: {
                 fullRange: undefined,
                 adToks: [],
-                treeSitterId: -1,
+                tsId: -1,
             }
         };
     }
@@ -90,7 +90,7 @@ function convertTreeNode(node) {
                 fullRange: range,
                 adToks: [],
                 fullLexeme: node.text,
-                treeSitterId: node.id
+                tsId: node.id
             }
         };
         switch (node.type) {
@@ -105,7 +105,7 @@ function convertTreeNode(node) {
                     lexeme: undefined,
                     info: {
                         adToks: remainingComments.map(c => c[1]),
-                        treeSitterId: node.id
+                        tsId: node.id
                     }
                 };
             }
@@ -138,7 +138,7 @@ function convertTreeNode(node) {
                     ],
                     info: {
                         adToks: remainingComments.map(c => c[1]),
-                        treeSitterId: node.id
+                        tsId: node.id
                     }
                 };
             }
@@ -156,7 +156,7 @@ function convertTreeNode(node) {
                     name: undefined,
                     lexeme: lhs.lexeme,
                     info: {
-                        treeSitterId: lhs.info.treeSitterId
+                        tsId: lhs.info.tsId
                     }
                 };
                 if (op.type === 'special') {
@@ -170,7 +170,7 @@ function convertTreeNode(node) {
                             lexeme: op.text,
                             content: op.text,
                             info: {
-                                treeSitterId: op.id
+                                tsId: op.id
                             }
                         },
                         arguments: [lhsAsArg, {
@@ -180,14 +180,14 @@ function convertTreeNode(node) {
                                 name: undefined,
                                 lexeme: rhs.lexeme,
                                 info: {
-                                    treeSitterId: rhs.info.treeSitterId
+                                    tsId: rhs.info.tsId
                                 }
                             }],
                         named: true,
                         infixSpecial: true,
                         info: {
                             adToks: comments,
-                            treeSitterId: node.id
+                            tsId: node.id
                         }
                     };
                 }
@@ -203,7 +203,7 @@ function convertTreeNode(node) {
                             fullRange: range,
                             adToks: comments,
                             fullLexeme: node.text,
-                            treeSitterId: node.id
+                            tsId: node.id
                         }
                     };
                 }
@@ -218,7 +218,7 @@ function convertTreeNode(node) {
                             fullRange: range,
                             adToks: comments,
                             fullLexeme: node.text,
-                            treeSitterId: node.id
+                            tsId: node.id
                         }
                     };
                 }
@@ -291,7 +291,7 @@ function convertTreeNode(node) {
                             fullRange: undefined,
                             adToks: [],
                             fullLexeme: undefined,
-                            treeSitterId: variableNode.id
+                            tsId: variableNode.id
                         }
                     },
                     vector: convertTreeNode(sequenceNode),
@@ -302,7 +302,7 @@ function convertTreeNode(node) {
                         fullRange: range,
                         adToks: variableComments.concat(sequenceComments).map(c => c[1]),
                         fullLexeme: node.text,
-                        treeSitterId: node.id
+                        tsId: node.id
                     }
                 };
             }
@@ -369,7 +369,7 @@ function convertTreeNode(node) {
                                 fullRange: range,
                                 adToks: [],
                                 fullLexeme: node.text,
-                                treeSitterId: node.id
+                                tsId: node.id
                             }
                         },
                         named: true
@@ -480,7 +480,7 @@ function convertTreeNode(node) {
                                 fullRange: rhsRange,
                                 adToks: [],
                                 fullLexeme: rhs?.text,
-                                treeSitterId: rhs?.id
+                                tsId: rhs?.id
                             }
                         }],
                     location: makeSourceRange(operator),
@@ -507,7 +507,7 @@ function convertTreeNode(node) {
                             fullRange: range,
                             adToks: [],
                             fullLexeme: name.text,
-                            treeSitterId: name.id
+                            tsId: name.id
                         }
                     },
                     special: name.text === '...',
@@ -518,7 +518,7 @@ function convertTreeNode(node) {
                         fullRange: range,
                         adToks: [],
                         fullLexeme: name.text,
-                        treeSitterId: name.id
+                        tsId: name.id
                     }
                 };
             }
@@ -560,7 +560,7 @@ function convertTreeNode(node) {
                             fullRange: nameRange,
                             adToks: [],
                             fullLexeme: nameNode.text,
-                            treeSitterId: nameNode.id
+                            tsId: nameNode.id
                         }
                     };
                 }
@@ -595,7 +595,7 @@ function convertTreeNode(node) {
         info: {
             fullRange: undefined,
             adToks: [],
-            treeSitterId: -1,
+            tsId: -1,
         }
     };
 }
@@ -624,7 +624,7 @@ function splitComments(nodes) {
                     info: {
                         adToks: [],
                         fullLexeme: node.text,
-                        treeSitterId: node.id
+                        tsId: node.id
                     }
                 }]);
         }

package/search/search-executor/search-generators.js

@@ -112,8 +112,8 @@ async function generateSyntax(input, args) {
     const nodesByTreeSitterId = new Map();
     (0, visitor_1.visitAst)((await input.normalize()).ast.files.map(f => f.root), node => {
         const treeSitterInfo = node.info;
-        if (treeSitterInfo.treeSitterId) {
-            nodesByTreeSitterId.set(treeSitterInfo.treeSitterId, node);
+        if (treeSitterInfo.tsId) {
+            nodesByTreeSitterId.set(treeSitterInfo.tsId, node);
         }
         else {
             exports.searchLogger.debug(`normalized ast node ${node.lexeme} with type ${node.type} does not have a tree-sitter id`);

package/util/assert.d.ts

@@ -26,7 +26,7 @@ export declare function assertUnreachable(x: never): never;
  * @see {@link isUndefined}
  * @see {@link isNotNull}
  */
-export declare function isNotUndefined<T>(x: T | undefined): x is T;
+export declare function isNotUndefined<T>(this: void, x: T | undefined): x is T;
 /**
  * Verifies that the given value is undefined.
  * This especially helps with a `.filter`
@@ -39,7 +39,7 @@ export declare function isNotUndefined<T>(x: T | undefined): x is T;
  * @see {@link isNotUndefined}
  * @see {@link isNotNull}
  */
-export declare function isUndefined<T>(x: T | undefined): x is undefined;
+export declare function isUndefined<T>(this: void, x: T | undefined): x is undefined;
 /**
  * Verifies that the given value is not null.
  * This especially helps with a `.filter`
@@ -52,7 +52,7 @@ export declare function isUndefined<T>(x: T | undefined): x is undefined;
  * @see {@link isUndefined}
  * @see {@link isNotUndefined}
  */
-export declare function isNotNull<T>(x: T | null): x is T;
+export declare function isNotNull<T>(this: void, x: T | null): x is T;
 /**
  * Generates a GitHub issue URL for reporting guard errors
  */

package/util/mermaid/cfg.d.ts

@@ -15,13 +15,7 @@ export declare const MermaidEntryPointDefaultMarkStyle: MermaidMarkStyle['vertex
 export declare const MermaidExitPointDefaultMarkStyle: MermaidMarkStyle['vertex'];
 /**
  * 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).
- * @param markStyle        - The style to use for marked vertices and edges.
- * @param includeOnlyIds   - If provided, only include the vertices with the given IDs.
- * @param mark             - If provided, mark the given vertices and edges.
+ * @see {@link MermaidCfgGraphPrinterInfo} for additional options.
  */
 export declare function cfgToMermaid(cfg: ControlFlowInformation, normalizedAst: NormalizedAst, { prefix, simplify, markStyle, entryPointStyle, exitPointStyle, includeOnlyIds, mark, includeBasicBlockLabel, basicBlockCharacterLimit }?: MermaidCfgGraphPrinterInfo): string;
 /**

package/util/mermaid/cfg.js

@@ -4,7 +4,6 @@ exports.MermaidExitPointDefaultMarkStyle = exports.MermaidEntryPointDefaultMarkS
 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");
@@ -17,9 +16,9 @@ function getLexeme(n) {
 }
 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])) : ''}\`"`;
+        const start = control_flow_graph_1.CfgVertex.isExpression(vert) ? '([' : '[';
+        const end = control_flow_graph_1.CfgVertex.isExpression(vert) ? '])' : ']';
+        const name = `"\`${(0, mermaid_1.escapeMarkdown)(normalizedVertex.type)} (${id})${content ? '\n' + (0, mermaid_1.escapeMarkdown)(JSON.stringify(content)) : ''}${control_flow_graph_1.CfgVertex.getCallTargets(vert) ? '\n calls:' + (0, mermaid_1.escapeMarkdown)(JSON.stringify([...control_flow_graph_1.CfgVertex.getCallTargets(vert)])) : ''}\`"`;
         output += `    n${id}${start}${name}${end}\n`;
     }
     else {
@@ -28,27 +27,25 @@ function cfgOfNode(vert, normalizedVertex, id, content, output) {
     return output;
 }
 const getDirRegex = /flowchart\s+([A-Za-z]+)/;
-function shouldIncludeNode(simplify, element, include) {
+function shouldIncludeNode(simplify, v, include) {
     if (simplify) {
         // Only basic blocks are shown, so include the BB, if at least one child is selected
-        return element.type == control_flow_graph_1.CfgVertexType.Block && element.elems.filter(elem => elem.type !== control_flow_graph_1.CfgVertexType.EndMarker).some(elem => include.has(elem.id));
+        return control_flow_graph_1.CfgVertex.isBlock(v) && control_flow_graph_1.CfgVertex.getBasicBlockElements(v)
+            .filter(elem => !control_flow_graph_1.CfgVertex.isMarker(elem))
+            .some(elem => include.has(control_flow_graph_1.CfgVertex.getId(elem)));
     }
     else {
         // Basic blocks and vertices are shown, include the BB, if all children are highlighted
-        return element.type == control_flow_graph_1.CfgVertexType.Block
-            ? element.elems.filter(elem => elem.type !== control_flow_graph_1.CfgVertexType.EndMarker).every(elem => include.has(elem.id))
-            : include.has(element.id);
+        return control_flow_graph_1.CfgVertex.isBlock(v)
+            ? control_flow_graph_1.CfgVertex.getBasicBlockElements(v)
+                .filter(elem => !control_flow_graph_1.CfgVertex.isMarker(elem))
+                .every(elem => include.has(control_flow_graph_1.CfgVertex.getId(elem)))
+            : include.has(control_flow_graph_1.CfgVertex.getId(v));
     }
 }
 /**
  * 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).
- * @param markStyle        - The style to use for marked vertices and edges.
- * @param includeOnlyIds   - If provided, only include the vertices with the given IDs.
- * @param mark             - If provided, mark the given vertices and edges.
+ * @see {@link MermaidCfgGraphPrinterInfo} for additional options.
  */
 function cfgToMermaid(cfg, normalizedAst, { prefix = 'flowchart BT\n', simplify = false, markStyle = info_1.MermaidDefaultMarkStyle, entryPointStyle = exports.MermaidEntryPointDefaultMarkStyle, exitPointStyle = exports.MermaidExitPointDefaultMarkStyle, includeOnlyIds, mark, includeBasicBlockLabel = true, basicBlockCharacterLimit = 100 } = {}) {
     const hasBbandSimplify = simplify && cfg.graph.mayHaveBasicBlocks();
@@ -68,7 +65,7 @@ function cfgToMermaid(cfg, normalizedAst, { prefix = 'flowchart BT\n', simplify
         }
         // if we have a filter, we automatically add all vertices in the cfg that are *markers* for these ids and
         for (const [id, v] of cfg.graph.vertices()) {
-            if (v.type === control_flow_graph_1.CfgVertexType.EndMarker && completed.has(v.root)) {
+            if (control_flow_graph_1.CfgVertex.isMarker(v) && completed.has(control_flow_graph_1.CfgVertex.unpackRootId(v))) {
                 completed.add(id);
             }
         }
@@ -79,53 +76,48 @@ function cfgToMermaid(cfg, normalizedAst, { prefix = 'flowchart BT\n', simplify
     for (const [id, vertex] of cfg.graph.vertices(false)) {
         const normalizedVertex = normalizedAst?.idMap.get(id);
         const content = getLexeme(normalizedVertex);
-        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 (control_flow_graph_1.CfgVertex.isBlock(vertex)) {
+            const elems = control_flow_graph_1.CfgVertex.getBasicBlockElements(vertex);
             if (simplify) {
-                if (includeOnlyIds && !vertex.elems.some(elem => includeOnlyIds.has(elem.id))) {
+                if (includeOnlyIds && !elems.some(elem => includeOnlyIds.has(control_flow_graph_1.CfgVertex.getId(elem)))) {
                     continue;
                 }
-                const ids = vertex.elems?.map(e => e.id) ?? [];
+                const ids = elems?.map(control_flow_graph_1.CfgVertex.getId) ?? [];
                 const reconstruct = limitTo((0, reconstruct_1.reconstructToCode)(normalizedAst, { nodes: new Set(ids) }, auto_select_defaults_1.doNotAutoSelect).code, basicBlockCharacterLimit);
                 const name = `"\`${includeBasicBlockLabel ? `Basic Block (${id})\n` : ''}${(0, mermaid_1.escapeMarkdown)(reconstruct)}\`"`;
                 output += `    n${id}[[${name}]]\n`;
-                diagramIncludedIds.add(vertex.id);
+                diagramIncludedIds.add(control_flow_graph_1.CfgVertex.getId(vertex));
             }
             else {
-                if (includeOnlyIds && !vertex.elems.some(elem => includeOnlyIds.has(elem.id))) {
+                if (includeOnlyIds && !elems.some(elem => includeOnlyIds.has(control_flow_graph_1.CfgVertex.getId(elem)))) {
                     continue;
                 }
-                output += `    subgraph n${vertex.id} [Block ${normalizedVertex?.info.fullLexeme ?? id}]\n`;
+                output += `    subgraph n${id} [Block ${normalizedVertex?.info.fullLexeme ?? id}]\n`;
                 output += `        direction ${dirIs}\n`;
-                diagramIncludedIds.add(vertex.id);
+                diagramIncludedIds.add(id);
                 let last = undefined;
-                for (const element of vertex.elems ?? []) {
-                    if (includeOnlyIds && !includeOnlyIds.has(element.id)) {
+                for (const element of elems ?? []) {
+                    if (includeOnlyIds && !includeOnlyIds.has(control_flow_graph_1.CfgVertex.getId(element))) {
                         last = undefined;
                         continue;
                     }
-                    const childNormalizedVertex = normalizedAst?.idMap.get(element.id);
+                    const eid = control_flow_graph_1.CfgVertex.getId(element);
+                    const childNormalizedVertex = normalizedAst?.idMap.get(eid);
                     const childContent = getLexeme(childNormalizedVertex);
-                    output = cfgOfNode(vertex, childNormalizedVertex, element.id, childContent, output);
-                    diagramIncludedIds.add(element.id);
+                    output = cfgOfNode(vertex, childNormalizedVertex, eid, childContent, output);
+                    diagramIncludedIds.add(eid);
                     // just to keep the order
                     if (last) {
-                        output += `    ${last} -.-> n${element.id}\n`;
+                        output += `    ${last} -.-> n${eid}\n`;
                     }
-                    last = `n${element.id}`;
+                    last = `n${eid}`;
                 }
                 output += '    end\n';
             }
         }
         else if (!includeOnlyIds || includeOnlyIds.has(id)) {
             output = cfgOfNode(vertex, normalizedVertex, id, content, output);
-            diagramIncludedIds.add(vertex.id);
-        }
-        if (vertex.name === type_1.RType.ExpressionList && vertex.type === control_flow_graph_1.CfgVertexType.EndMarker) {
-            output += '    end\n';
+            diagramIncludedIds.add(id);
         }
     }
     for (const [from, targets] of cfg.graph.edges()) {
@@ -136,9 +128,10 @@ function cfgToMermaid(cfg, normalizedAst, { prefix = 'flowchart BT\n', simplify
             if (!diagramIncludedIds.has(to)) {
                 continue;
             }
-            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`;
+            const isCd = control_flow_graph_1.CfgEdge.isControlDependency(edge);
+            const edgeType = isCd ? '-->' : '-.->';
+            const edgeSuffix = isCd ? ` (${control_flow_graph_1.CfgEdge.unpackWhen(edge)})` : '';
+            output += `    n${from} ${edgeType}|"${(0, mermaid_1.escapeMarkdown)(control_flow_graph_1.CfgEdge.typeToString(edge))}${edgeSuffix}"| n${to}\n`;
         }
     }
     for (const entryPoint of cfg.entryPoints) {
@@ -152,9 +145,9 @@ function cfgToMermaid(cfg, normalizedAst, { prefix = 'flowchart BT\n', simplify
         }
     }
     if (mark) {
-        for (const [_, vertex] of cfg.graph.vertices(true)) {
+        for (const [id, vertex] of cfg.graph.vertices(true)) {
             if (shouldIncludeNode(hasBbandSimplify, vertex, mark)) {
-                output += `    style n${vertex.id} ${markStyle.vertex}`;
+                output += `    style n${id} ${markStyle.vertex}`;
             }
         }
     }

package/util/version.js

@@ -6,7 +6,7 @@ exports.printVersionInformation = printVersionInformation;
 const semver_1 = require("semver");
 const assert_1 = require("./assert");
 // this is automatically replaced with the current version by release-it
-const version = '2.9.7';
+const version = '2.9.9';
 /**
  * Retrieves the current flowR version as a new {@link SemVer} object.
  */