Merge pull request #13 from tmr232/extension-highlight-nodes

Highlight Current Node

Author: tmr232

.vscode/extensions.json

@@ -7,4 +7,4 @@
     "ms-vscode.extension-test-runner",
     "oven.bun-vscode"
   ]
-}
+}

CHANGELOG.md

@@ -6,18 +6,29 @@ Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how
 
 ## [Unreleased]
 
+### Added
+
+- The CFG view now highlights (in black) the node matching the cursor position.
+- Basic CFG caching for tests, making them twice as fast.
+- The extension learned to only generate a CFG on code or config changes.
+  If the cursor just moves inside the same function, we don't regenerate the CFG.
+
 ### Fixed
 
 - Rendering of `select` blocks in Go was broken.
+- Empty case clauses in `switch` statements no longer cause crashes.
+- Last case of a Python `match` statement no longer assumed to match.
 
 ### Changed
 
 - Massive refactoring of `CFGBuilder` classes.
-  New design now uses the same`GenericCGBuilder` class
-  for all languages, and takes statement handlers as
-  arguments.
+  New design now uses the same`GenericCFGBuilder` 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.
+- Flat switches now generate nodes for the conditions, and not only the consequence.
+- The CodeMirror editor in the demo got it's own Svelte component now, `Editor.svelte`.
+  This allows better state management and handling/dispatching events.
 
 ## [0.0.5] - 2024-09-18
 

package.json

@@ -85,6 +85,11 @@
           "type": "boolean",
           "default": "false",
           "description": "Flatten switches, so that all cases are direct descendants of the root."
+        },
+        "functionGraphOverview.highlightCurrentNode": {
+          "type": "boolean",
+          "default": "true",
+          "description": "Highlight the CFG node matching the current code cursor position."
         }
       }
     },

src/control-flow/block-matcher.ts

@@ -1,22 +1,28 @@
 import Parser from "web-tree-sitter";
 import { type BasicBlock, BlockHandler } from "./cfg-defs.ts";
+import { evolve } from "./evolve.ts";
+
+const defaultQueryOptions: Parser.QueryOptions = { maxStartDepth: 0 };
 
 function matchQuery(
   syntax: Parser.SyntaxNode,
   queryString: string,
+  options?: Parser.QueryOptions,
 ): Parser.QueryMatch {
   const language = syntax.tree.getLanguage();
   const query = language.query(queryString);
-  const matches = query.matches(syntax, { maxStartDepth: 0 });
+  options = evolve(defaultQueryOptions, options ?? {});
+  const matches = query.matches(syntax, options);
+
   if (matches.length === 0) {
     throw new Error(`No match found for query.`);
   }
+  // @ts-expect-error: tsc can't deduce that an element must exist.
   return matches[0];
 }
 
 export function matchExistsIn(
   syntax: Parser.SyntaxNode,
-  mainName: string,
   queryString: string,
 ): boolean {
   const language = syntax.tree.getLanguage();
@@ -32,6 +38,14 @@ function getSyntax(
   return getSyntaxMany(match, name)[0];
 }
 
+function getLastSyntax(
+  match: Parser.QueryMatch,
+  name: string,
+): Parser.SyntaxNode | undefined {
+  const many = getSyntaxMany(match, name);
+  return many[many.length - 1];
+}
+
 function requireSyntax(
   match: Parser.QueryMatch,
   name: string,
@@ -54,16 +68,20 @@ function getSyntaxMany(
 
 export class BlockMatcher {
   private blockHandler: BlockHandler = new BlockHandler();
-  private processBlock: (syntax: Parser.SyntaxNode | null) => BasicBlock;
+  private dispatchSingle: (syntax: Parser.SyntaxNode | null) => BasicBlock;
   public update = this.blockHandler.update.bind(this.blockHandler);
 
-  constructor(processBlock: BlockMatcher["processBlock"]) {
-    this.processBlock = processBlock;
+  constructor(dispatchSingle: BlockMatcher["dispatchSingle"]) {
+    this.dispatchSingle = dispatchSingle;
   }
 
-  public match(syntax: Parser.SyntaxNode, queryString: string): Match {
-    const match = matchQuery(syntax, queryString);
-    return new Match(match, this.blockHandler, this.processBlock);
+  public match(
+    syntax: Parser.SyntaxNode,
+    queryString: string,
+    options?: Parser.QueryOptions,
+  ): Match {
+    const match = matchQuery(syntax, queryString, options);
+    return new Match(match, this.blockHandler, this.dispatchSingle);
   }
 
   public tryMatch(
@@ -82,32 +100,57 @@ export class BlockMatcher {
   }
 }
 
+/**
+ * Maintains a single {Parser.QueryMatch} and allows accesing the captures within it.
+ */
 export class Match {
   private match: Parser.QueryMatch;
   private blockHandler: BlockHandler;
-  private processBlock: BlockMatcher["processBlock"];
+  private dispatchSingle: BlockMatcher["dispatchSingle"];
   constructor(
     match: Parser.QueryMatch,
     blockHandler: BlockHandler,
-    processBlock: BlockMatcher["processBlock"],
+    dispatchSingle: BlockMatcher["dispatchSingle"],
   ) {
     this.match = match;
     this.blockHandler = blockHandler;
-    this.processBlock = processBlock;
+    this.dispatchSingle = dispatchSingle;
   }
 
+  /**
+   * Get the first named syntax node from the query match.
+   * @param name Name of the capture
+   * @returns {Parser.SyntaxNode|undefined} The syntax matching the capture name, if captured.
+   */
   public getSyntax(name: string): ReturnType<typeof getSyntax> {
     return getSyntax(this.match, name);
   }
 
+  public getLastSyntax(name: string): ReturnType<typeof getLastSyntax> {
+    return getLastSyntax(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;
+
+  public getBlock(syntax: Parser.SyntaxNode): BasicBlock;
+  public getBlock(
+    syntax: Parser.SyntaxNode | null | undefined,
+  ): BasicBlock | null;
+  public getBlock(
+    syntax: Parser.SyntaxNode | null | undefined,
+  ): BasicBlock | null {
+    return syntax
+      ? this.blockHandler.update(this.dispatchSingle(syntax))
+      : null;
+  }
+
+  public getManyBlocks(syntaxMany: Parser.SyntaxNode[]): BasicBlock[] {
+    return syntaxMany.map((syntax) => this.getBlock(syntax) as BasicBlock);
   }
 }

src/control-flow/builder.ts

@@ -52,6 +52,7 @@ export class Builder {
       lines,
       markers: [],
       cluster,
+      targets: [id],
     });
     return id;
   }