Merge pull request #11 from tmr232/cfgbuilder-refactor

This PR includes a significant refactor of all CFGBuilder classes.
We moved from separate classes with code duplication, to a unified GenericCFGBuilder that take all the different syntax handlers as arguments.
This reduces duplication, and creates a more consistent base to build on for future languages.

It should also make new features, like navigation support, easier to implement.

Author: tmr232

.gitignore

@@ -3,3 +3,4 @@ dist
 node_modules
 .vscode-test/
 *.vsix
+/.idea

CHANGELOG.md

@@ -6,6 +6,19 @@ Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how
 
 ## [Unreleased]
 
+### Fixed
+
+- Rendering of `select` blocks in Go was broken.
+
+### Changed
+
+- Massive refactoring of `CFGBuilder` classes.
+  New design now uses the same`GenericCGBuilder` class
+  for all languages, and takes statement handlers as
+  arguments.
+  This reduces code duplication and makes it easier to add
+  new languages in the future.
+
 ## [0.0.5] - 2024-09-18
 
 ### Added

eslint.config.js

@@ -31,6 +31,7 @@ export default tseslint.config(
         },
       ],
       "@typescript-eslint/no-unnecessary-condition": "error",
+      "@typescript-eslint/unbound-method": "error",
     },
   },
 );

package.json

@@ -104,4 +104,4 @@
   "engines": {
     "vscode": "^1.86.0"
   }
-}
+}

src/control-flow/block-matcher.ts

@@ -0,0 +1,113 @@
+import Parser from "web-tree-sitter";
+import { type BasicBlock, BlockHandler } from "./cfg-defs.ts";
+
+function matchQuery(
+  syntax: Parser.SyntaxNode,
+  queryString: string,
+): Parser.QueryMatch {
+  const language = syntax.tree.getLanguage();
+  const query = language.query(queryString);
+  const matches = query.matches(syntax, { maxStartDepth: 0 });
+  if (matches.length === 0) {
+    throw new Error(`No match found for query.`);
+  }
+  return matches[0];
+}
+
+export function matchExistsIn(
+  syntax: Parser.SyntaxNode,
+  mainName: string,
+  queryString: string,
+): boolean {
+  const language = syntax.tree.getLanguage();
+  const query = language.query(queryString);
+  const matches = query.matches(syntax);
+  return matches.length > 0;
+}
+
+function getSyntax(
+  match: Parser.QueryMatch,
+  name: string,
+): Parser.SyntaxNode | undefined {
+  return getSyntaxMany(match, name)[0];
+}
+
+function requireSyntax(
+  match: Parser.QueryMatch,
+  name: string,
+): Parser.SyntaxNode {
+  const syntax = getSyntax(match, name);
+  if (!syntax) {
+    throw new Error(`Failed getting syntax for ${name}`);
+  }
+  return syntax;
+}
+
+function getSyntaxMany(
+  match: Parser.QueryMatch,
+  name: string,
+): Parser.SyntaxNode[] {
+  return match.captures
+    .filter((capture) => capture.name === name)
+    .map((capture) => capture.node);
+}
+
+export class BlockMatcher {
+  private blockHandler: BlockHandler = new BlockHandler();
+  private processBlock: (syntax: Parser.SyntaxNode | null) => BasicBlock;
+  public update = this.blockHandler.update.bind(this.blockHandler);
+
+  constructor(processBlock: BlockMatcher["processBlock"]) {
+    this.processBlock = processBlock;
+  }
+
+  public match(syntax: Parser.SyntaxNode, queryString: string): Match {
+    const match = matchQuery(syntax, queryString);
+    return new Match(match, this.blockHandler, this.processBlock);
+  }
+
+  public tryMatch(
+    syntax: Parser.SyntaxNode,
+    queryString: string,
+  ): Match | null {
+    try {
+      return this.match(syntax, queryString);
+    } catch {
+      return null;
+    }
+  }
+
+  public get state() {
+    return this.blockHandler;
+  }
+}
+
+export class Match {
+  private match: Parser.QueryMatch;
+  private blockHandler: BlockHandler;
+  private processBlock: BlockMatcher["processBlock"];
+  constructor(
+    match: Parser.QueryMatch,
+    blockHandler: BlockHandler,
+    processBlock: BlockMatcher["processBlock"],
+  ) {
+    this.match = match;
+    this.blockHandler = blockHandler;
+    this.processBlock = processBlock;
+  }
+
+  public getSyntax(name: string): ReturnType<typeof getSyntax> {
+    return getSyntax(this.match, name);
+  }
+
+  public requireSyntax(name: string): ReturnType<typeof requireSyntax> {
+    return requireSyntax(this.match, name);
+  }
+
+  public getSyntaxMany(name: string): ReturnType<typeof getSyntaxMany> {
+    return getSyntaxMany(this.match, name);
+  }
+  public getBlock(syntax: Parser.SyntaxNode | null | undefined) {
+    return syntax ? this.blockHandler.update(this.processBlock(syntax)) : null;
+  }
+}

src/control-flow/builder.ts

@@ -0,0 +1,86 @@
+import type {
+  CFGGraph,
+  Cluster,
+  ClusterId,
+  ClusterType,
+  EdgeType,
+  NodeType,
+} from "./cfg-defs.ts";
+import { MultiDirectedGraph } from "graphology";
+
+export class Builder {
+  private graph: CFGGraph = new MultiDirectedGraph();
+  private nodeId: number = 0;
+  private clusterId: ClusterId = 0;
+  private activeClusters: Cluster[] = [];
+
+  private startCluster(type: ClusterType): Cluster {
+    const parent =
+      this.activeClusters.length === 0
+        ? undefined
+        : this.activeClusters[this.activeClusters.length - 1];
+    const cluster = {
+      id: this.clusterId++,
+      type,
+      parent,
+      depth: this.activeClusters.length + 1,
+    };
+    this.activeClusters.push(cluster);
+    return cluster;
+  }
+
+  private endCluster(_cluster: Cluster) {
+    // We assume that all clusters form a stack.
+    this.activeClusters.pop();
+  }
+
+  public withCluster<T>(type: ClusterType, fn: (cluster: Cluster) => T): T {
+    const cluster = this.startCluster(type);
+    try {
+      return fn(cluster);
+    } finally {
+      this.endCluster(cluster);
+    }
+  }
+
+  public addNode(type: NodeType, code: string, lines: number = 1): string {
+    const id = `node${this.nodeId++}`;
+    const cluster = this.activeClusters[this.activeClusters.length - 1];
+    this.graph.addNode(id, {
+      type,
+      code,
+      lines,
+      markers: [],
+      cluster,
+    });
+    return id;
+  }
+
+  public cloneNode(node: string, overrides?: { cluster: Cluster }): string {
+    const id = `node${this.nodeId++}`;
+    const originalAttrs = this.graph.getNodeAttributes(node);
+    const nodeAttrs = structuredClone(originalAttrs);
+    nodeAttrs.cluster = originalAttrs.cluster;
+    Object.assign(nodeAttrs, overrides);
+    this.graph.addNode(id, nodeAttrs);
+    return id;
+  }
+
+  public addMarker(node: string, marker: string) {
+    this.graph.getNodeAttributes(node).markers.push(marker);
+  }
+
+  public addEdge(
+    source: string,
+    target: string,
+    type: EdgeType = "regular",
+  ): void {
+    if (!this.graph.hasEdge(source, target)) {
+      this.graph.addEdge(source, target, { type });
+    }
+  }
+
+  public getGraph(): CFGGraph {
+    return this.graph;
+  }
+}