Linters pass!

Author: tmr232

bun.lockb

@@ -16,7 +16,7 @@
     "lru-cache": "^11.0.2",
     "object-hash": "^3.0.0",
     "svgdom": "^0.1.19",
-    "web-tree-sitter": "^0.25.0"
+    "web-tree-sitter": "^0.25.3"
   },
   "devDependencies": {
     "@biomejs/biome": "1.9.4",

package.json

@@ -1,9 +1,9 @@
-import type { Parser } from "web-tree-sitter";
+import type { Node as SyntaxNode } from "web-tree-sitter";
 import { type CFG, mergeNodeAttrs } from "../src/control-flow/cfg-defs.ts";
 import { type Language, newCFGBuilder } from "../src/control-flow/cfg.ts";
 import { simplifyCFG, trimFor } from "../src/control-flow/graph-ops.ts";
 
-export function buildCFG(func: Parser.SyntaxNode, language: Language): CFG {
+export function buildCFG(func: SyntaxNode, language: Language): CFG {
   const builder = newCFGBuilder(language, { flatSwitch: true });
 
   let cfg = builder.buildCFG(func);

scripts/cfg-helper.ts

@@ -1,8 +1,7 @@
 import * as path from "node:path";
 import { parseArgs } from "node:util";
 import { Graphviz } from "@hpcc-js/wasm-graphviz";
-import type { Parser } from "web-tree-sitter";
-import type { SyntaxNode } from "web-tree-sitter";
+import type { Node as SyntaxNode } from "web-tree-sitter";
 import { type Language, supportedLanguages } from "../src/control-flow/cfg.ts";
 import {
   deserializeColorList,
@@ -92,7 +91,7 @@ async function main() {
 
   const language: Language = values.language ?? getLanguage(filepath);
 
-  const possibleMatches: { name: string; func: Parser.SyntaxNode }[] = [];
+  const possibleMatches: { name: string; func: SyntaxNode }[] = [];
   const sourceCode = await Bun.file(filepath).text();
   const startIndex = Number.parseInt(functionName);
   let startPosition: { row: number; column: number } | undefined;
@@ -131,7 +130,7 @@ async function main() {
   }
 
   // @ts-expect-error: possibleMatches will always have exactly one value.
-  const func: Parser.SyntaxNode = possibleMatches[0].func;
+  const func: SyntaxNode = possibleMatches[0].func;
   const graphviz = await Graphviz.load();
   const cfg = buildCFG(func, language);
 

scripts/render-function.ts

@@ -1,5 +1,5 @@
 <script lang="ts">
-  import Parser from "web-tree-sitter";
+  import { Node as SyntaxNode } from "web-tree-sitter";
   import { newCFGBuilder, type Language } from "../control-flow/cfg";
   import {
     mergeNodeAttrs,
@@ -47,7 +47,7 @@
 
   function renderRanges(
     cfg: CFG,
-    functionSyntax: Parser.SyntaxNode,
+    functionSyntax: SyntaxNode,
     sourceText: string,
     nodeColors: NodeColors,
   ): string {

src/components/CodeSegmentation.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-  import Parser from "web-tree-sitter";
+  import { Tree } from "web-tree-sitter";
   import { type Language } from "../control-flow/cfg";
   import { Graphviz } from "@hpcc-js/wasm-graphviz";
   import {
@@ -20,7 +20,7 @@
   let parsers: Parsers;
   let graphviz: Graphviz;
   let dot: string;
-  let tree: Parser.Tree;
+  let tree: Tree;
   let savedSvg: string;
   let getNodeOffset: (nodeId: string) => number | undefined = () => undefined;
   export let colorList = getLightColorList();

src/components/Graph.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-  import Parser, { type SyntaxNode } from "web-tree-sitter";
+  import { type Node as SyntaxNode, type Tree } from "web-tree-sitter";
   import { functionNodeTypes, type Language } from "../control-flow/cfg";
   import { Graphviz } from "@hpcc-js/wasm-graphviz";
   import { initialize as initializeUtils, type Parsers } from "./utils";
@@ -15,7 +15,7 @@
   let graphviz: Graphviz;
   let dot: string;
   let getNodeOffset: (nodeId: string) => number | undefined = () => undefined;
-  let tree: Parser.Tree;
+  let tree: Tree;
   let svg: string;
   export let colorList = getLightColorList();
   export let codeAndOffset: CodeAndOffset | null = null;
@@ -43,10 +43,10 @@
   }
 
   function getFunctionAtOffset(
-    tree: Parser.Tree,
+    tree: Tree,
     offset: number,
     language: Language,
-  ): Parser.SyntaxNode | null {
+  ): SyntaxNode | null {
     let syntax: SyntaxNode | null = tree.rootNode.descendantForIndex(offset);
 
     while (syntax) {

src/components/WebviewRenderer.svelte

@@ -1,7 +1,7 @@
 import type { Graphviz } from "@hpcc-js/wasm-graphviz";
 import type { G, Polygon } from "@svgdotjs/svg.js";
 import objectHash from "object-hash";
-import type { Parser } from "web-tree-sitter";
+import type { Node as SyntaxNode } from "web-tree-sitter";
 import { type Language, newCFGBuilder } from "../control-flow/cfg";
 import { mergeNodeAttrs, remapNodeTargets } from "../control-flow/cfg-defs";
 import { type ColorList, listToScheme } from "../control-flow/colors";
@@ -27,7 +27,7 @@ export interface RenderOptions {
 export class Renderer {
   private memoizedRenderStatic = memoizeFunction({
     func: this.renderStatic.bind(this),
-    hash: (functionSyntax: Parser.SyntaxNode, language: Language) =>
+    hash: (functionSyntax: SyntaxNode, language: Language) =>
       objectHash({ code: functionSyntax.text, language }),
     max: 100,
   });
@@ -38,7 +38,7 @@ export class Renderer {
   ) {}
 
   public render(
-    functionSyntax: Parser.SyntaxNode,
+    functionSyntax: SyntaxNode,
     language: Language,
     offsetToHighlight?: number,
   ): {
@@ -86,7 +86,7 @@ export class Renderer {
     return dom.svg();
   }
 
-  private renderStatic(functionSyntax: Parser.SyntaxNode, language: Language) {
+  private renderStatic(functionSyntax: SyntaxNode, language: Language) {
     const overlayBuilder = new OverlayBuilder(functionSyntax);
 
     const builder = newCFGBuilder(language, {

src/components/renderer.ts

@@ -1,5 +1,5 @@
 import { Graphviz } from "@hpcc-js/wasm-graphviz";
-import type { Parser } from "web-tree-sitter";
+import type { Parser, Node as SyntaxNode, Tree } from "web-tree-sitter";
 import {
   type Language,
   functionNodeTypes,
@@ -23,10 +23,10 @@ export async function initializeParsers(): Promise<Parsers> {
 }
 
 export function getFirstFunction(
-  tree: Parser.Tree,
+  tree: Tree,
   language: Language,
-): Parser.SyntaxNode | null {
-  let functionNode: Parser.SyntaxNode | null = null;
+): SyntaxNode | null {
+  let functionNode: SyntaxNode | null = null;
   const cursor = tree.walk();
   const visitNode = () => {
     if (functionNodeTypes[language].includes(cursor.nodeType)) {
@@ -61,8 +61,11 @@ export interface TestResults {
 
 export function runTest(record: TestFuncRecord): TestResults[] {
   const tree = parsers[record.language].parse(record.code);
+  if (!tree) {
+    throw new Error(`Failed to parse code from ${record}`);
+  }
   const testFunc: TestFunction = {
-    function: getFirstFunction(tree, record.language) as Parser.SyntaxNode,
+    function: getFirstFunction(tree, record.language) as SyntaxNode,
     language: record.language,
     name: record.name,
     reqs: record.reqs,
@@ -87,10 +90,10 @@ export function processRecord(
   options: RenderOptions,
 ): { dot?: string; ast: string; svg?: string; error?: Error } {
   const tree = parsers[record.language].parse(record.code);
-  const functionSyntax = getFirstFunction(
-    tree,
-    record.language,
-  ) as Parser.SyntaxNode;
+  if (!tree) {
+    throw new Error(`Failed to parse code from ${record}`);
+  }
+  const functionSyntax = getFirstFunction(tree, record.language) as SyntaxNode;
 
   const ast = functionSyntax.toString();
 

src/components/utils.ts

@@ -1,15 +1,19 @@
-import type { Parser, Node as SyntaxNode } from "web-tree-sitter";
+import type {
+  QueryMatch,
+  QueryOptions,
+  Node as SyntaxNode,
+} from "web-tree-sitter";
 import { Query } from "web-tree-sitter";
 import { type BasicBlock, BlockHandler } from "./cfg-defs.ts";
 import { evolve } from "./evolve.ts";
 
-const defaultQueryOptions: Parser.QueryOptions = { maxStartDepth: 0 };
+const defaultQueryOptions: QueryOptions = { maxStartDepth: 0 };
 
 function matchQuery(
   syntax: SyntaxNode,
   queryString: string,
-  options?: Parser.QueryOptions,
-): Parser.QueryMatch {
+  options?: QueryOptions,
+): QueryMatch {
   const language = syntax.tree.language;
   const query = new Query(language, queryString);
   options = evolve(defaultQueryOptions, options ?? {});
@@ -27,35 +31,32 @@ export function matchExistsIn(
   queryString: string,
 ): boolean {
   const language = syntax.tree.language;
-  const query = language.query(queryString);
+  const query = new Query(language, queryString);
   const matches = query.matches(syntax);
   return matches.length > 0;
 }
 
-function getSyntax(
-  match: Parser.QueryMatch,
-  name: string,
-): SyntaxNode | undefined {
+function getSyntax(match: QueryMatch, name: string): SyntaxNode | undefined {
   return getSyntaxMany(match, name)[0];
 }
 
 function getLastSyntax(
-  match: Parser.QueryMatch,
+  match: QueryMatch,
   name: string,
 ): SyntaxNode | undefined {
   const many = getSyntaxMany(match, name);
   return many[many.length - 1];
 }
 
-function requireSyntax(match: Parser.QueryMatch, name: string): SyntaxNode {
+function requireSyntax(match: QueryMatch, name: string): 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): SyntaxNode[] {
+function getSyntaxMany(match: QueryMatch, name: string): SyntaxNode[] {
   return match.captures
     .filter((capture) => capture.name === name)
     .map((capture) => capture.node);
@@ -73,7 +74,7 @@ export class BlockMatcher {
   public match(
     syntax: SyntaxNode,
     queryString: string,
-    options?: Parser.QueryOptions,
+    options?: QueryOptions,
   ): Match {
     const match = matchQuery(syntax, queryString, options);
     return new Match(match, this.blockHandler, this.dispatchSingle);
@@ -98,12 +99,12 @@ export class BlockMatcher {
  * [tree-sitter query reference](https://tree-sitter.github.io/tree-sitter/using-parsers#pattern-matching-with-queries
  */
 export class Match {
-  private match: Parser.QueryMatch;
+  private match: QueryMatch;
   private blockHandler: BlockHandler;
   private dispatchSingle: BlockMatcher["dispatchSingle"];
 
   constructor(
-    match: Parser.QueryMatch,
+    match: QueryMatch,
     blockHandler: BlockHandler,
     dispatchSingle: BlockMatcher["dispatchSingle"],
   ) {