Fixed deno-exclusive errors

Author: LeBoufty

deno.lock

@@ -42,6 +42,7 @@ export class CDependencyFormatter {
     if (st === "macro_constant") {
       return C_VARIABLE_TYPE as CDepSymbolType;
     }
+    throw new Error(`Unknown symbol type: ${st}`);
   }
 
   /**
@@ -133,6 +134,9 @@ export class CDependencyFormatter {
       filepath,
     );
     const includes = this.includeResolver.getInclusions().get(filepath);
+    if (!includes) {
+      throw new Error(`File not found: ${filepath}`);
+    }
     const stdincludes = Array.from(includes.standard.keys());
     const invokedDependencies = this.#formatDependencies(fileDependencies);
     const stdDependencies = this.#formatStandardIncludes(stdincludes);

packages/app/deno.lock

@@ -26,6 +26,9 @@ describe("CHeaderResolver", () => {
   test("resolves structs", () => {
     const burger = exportedSymbols.find((symbol) => symbol.name === "Burger");
     expect(burger).toBeDefined();
+    if (!burger) {
+      throw new Error("burger is undefined");
+    }
     expect(burger.type).toBe("struct");
     expect(burger.specifiers).toEqual([]);
     expect(burger.qualifiers).toEqual([]);
@@ -37,6 +40,9 @@ describe("CHeaderResolver", () => {
   test("resolves unions", () => {
     const sauce = exportedSymbols.find((symbol) => symbol.name === "Sauce");
     expect(sauce).toBeDefined();
+    if (!sauce) {
+      throw new Error("sauce is undefined");
+    }
     expect(sauce.type).toBe("union");
     expect(sauce.specifiers).toEqual([]);
     expect(sauce.qualifiers).toEqual([]);
@@ -50,6 +56,9 @@ describe("CHeaderResolver", () => {
       (symbol) => symbol.name === "Condiment",
     );
     expect(condiment).toBeDefined();
+    if (!condiment) {
+      throw new Error("condiment is undefined");
+    }
     expect(condiment.type).toBe("enum");
     expect(condiment.specifiers).toEqual([]);
     expect(condiment.qualifiers).toEqual([]);
@@ -61,10 +70,16 @@ describe("CHeaderResolver", () => {
       (symbol) => symbol.name === "ClassicSauces",
     );
     expect(classicsauces).toBeDefined();
+    if (!classicsauces) {
+      throw new Error("classicsauces is undefined");
+    }
     expect(classicsauces.type).toBe("enum");
 
     const drink_t = exportedSymbols.find((symbol) => symbol.name === "Drink_t");
     expect(drink_t).toBeDefined();
+    if (!drink_t) {
+      throw new Error("drink_t is undefined");
+    }
     expect(drink_t.type).toBe("enum");
     expect(drink_t.specifiers).toEqual([]);
     expect(drink_t.qualifiers).toEqual([]);
@@ -78,6 +93,9 @@ describe("CHeaderResolver", () => {
       (symbol) => symbol.name === "classicBurger",
     );
     expect(classicburger).toBeDefined();
+    if (!classicburger) {
+      throw new Error("classicburger is undefined");
+    }
     expect(classicburger.type).toBe("variable");
     expect(classicburger.specifiers).toEqual([]);
     expect(classicburger.qualifiers).toEqual(["const"]);
@@ -89,6 +107,9 @@ describe("CHeaderResolver", () => {
       (symbol) => symbol.name === "burger_count",
     );
     expect(burger_count).toBeDefined();
+    if (!burger_count) {
+      throw new Error("burger_count is undefined");
+    }
     expect(burger_count.type).toBe("variable");
     expect(burger_count.specifiers).toEqual(["static"]);
     expect(burger_count.qualifiers).toEqual([]);
@@ -102,6 +123,9 @@ describe("CHeaderResolver", () => {
       (symbol) => symbol.name === "BURGERS_H",
     );
     expect(burgers_h).toBeDefined();
+    if (!burgers_h) {
+      throw new Error("burgers_h is undefined");
+    }
     expect(burgers_h.type).toBe("macro_constant");
     expect(burgers_h.specifiers).toEqual([]);
     expect(burgers_h.qualifiers).toEqual([]);
@@ -113,6 +137,9 @@ describe("CHeaderResolver", () => {
       (symbol) => symbol.name === "MAX_BURGERS",
     );
     expect(max_burgers).toBeDefined();
+    if (!max_burgers) {
+      throw new Error("max_burgers is undefined");
+    }
     expect(max_burgers.type).toBe("macro_constant");
     expect(max_burgers.specifiers).toEqual([]);
     expect(max_burgers.qualifiers).toEqual([]);
@@ -136,6 +163,9 @@ describe("CHeaderResolver", () => {
   test("resolves macro functions", () => {
     const max_macro = exportedSymbols.find((symbol) => symbol.name === "MAX");
     expect(max_macro).toBeDefined();
+    if (!max_macro) {
+      throw new Error("max_macro is undefined");
+    }
     expect(max_macro.type).toBe("macro_function");
     expect(max_macro.specifiers).toEqual([]);
     expect(max_macro.qualifiers).toEqual([]);
@@ -147,6 +177,9 @@ describe("CHeaderResolver", () => {
   test("resolves typedefs", () => {
     const fries = exportedSymbols.find((symbol) => symbol.name === "Fries");
     expect(fries).toBeDefined();
+    if (!fries) {
+      throw new Error("fries is undefined");
+    }
     expect(fries.type).toBe("typedef");
     expect(fries.specifiers).toEqual([]);
     expect(fries.qualifiers).toEqual([]);
@@ -156,6 +189,9 @@ describe("CHeaderResolver", () => {
 
     const drink = exportedSymbols.find((symbol) => symbol.name === "Drink");
     expect(drink).toBeDefined();
+    if (!drink) {
+      throw new Error("drink is undefined");
+    }
     expect(drink.type).toBe("typedef");
     expect(drink.specifiers).toEqual([]);
     expect(drink.qualifiers).toEqual([]);
@@ -170,6 +206,9 @@ describe("CHeaderResolver", () => {
 
     const sprite = ccexportedSymbols.find((s) => s.name === "Sprite");
     expect(sprite).toBeDefined();
+    if (!sprite) {
+      throw new Error("sprite is undefined");
+    }
     expect(sprite.type).toBe("struct");
     expect(sprite.specifiers).toEqual([]);
     expect(sprite.qualifiers).toEqual([]);
@@ -181,6 +220,9 @@ describe("CHeaderResolver", () => {
       (s) => s.name === "PlaceholderFunction",
     );
     expect(placeholderfunction).toBeDefined();
+    if (!placeholderfunction) {
+      throw new Error("placeholderfunction is undefined");
+    }
     expect(placeholderfunction.type).toBe("function_signature");
     expect(placeholderfunction.specifiers).toEqual([]);
     expect(placeholderfunction.qualifiers).toEqual([]);
@@ -192,6 +234,9 @@ describe("CHeaderResolver", () => {
       (s) => s.name === "gMovementTypeFuncs_WanderAround",
     );
     expect(gmtfwa).toBeDefined();
+    if (!gmtfwa) {
+      throw new Error("gmtfwa is undefined");
+    }
     expect(gmtfwa.type).toBe("variable");
     expect(gmtfwa.specifiers).toEqual([]);
     expect(gmtfwa.qualifiers).toEqual([]);

packages/cli/deno.lock

@@ -27,9 +27,17 @@ export class CHeaderResolver {
       if (capture.name !== "decl" && capture.name !== "function_definition") {
         let idNode: Parser.SyntaxNode;
         if (capture.name !== "typedef") {
-          idNode = capture.node.childForFieldName("name");
+          if (!capture.node.childForFieldName("name")) {
+            throw new Error(`Couldn't find name for ${capture.node.text}`);
+          }
+          idNode = capture.node.childForFieldName("name") as Parser.SyntaxNode;
         } else {
-          idNode = capture.node.childForFieldName("declarator");
+          if (!capture.node.childForFieldName("declarator")) {
+            throw new Error(`Couldn't find name for ${capture.node.text}`);
+          }
+          idNode = capture.node.childForFieldName(
+            "declarator",
+          ) as Parser.SyntaxNode;
         }
         if (!idNode) {
           continue;
@@ -56,12 +64,24 @@ export class CHeaderResolver {
         // (e.g. in pointers or arrays)
         while (
           !currentNode.childForFieldName("declarator") ||
-          currentNode.childForFieldName("declarator").type !== "identifier"
+          currentNode.childForFieldName("declarator")?.type !== "identifier"
         ) {
           if (!currentNode.childForFieldName("declarator")) {
+            if (!currentNode.firstNamedChild) {
+              throw new Error(
+                `Could not find a named child for ${currentNode.text}`,
+              );
+            }
             currentNode = currentNode.firstNamedChild;
           } else {
-            currentNode = currentNode.childForFieldName("declarator");
+            if (!currentNode.childForFieldName("declarator")) {
+              throw new Error(
+                `Could not find a declarator for ${currentNode.text}`,
+              );
+            }
+            currentNode = currentNode.childForFieldName(
+              "declarator",
+            ) as Parser.SyntaxNode;
           }
         }
         const type = capture.name === "function_definition"
@@ -70,6 +90,11 @@ export class CHeaderResolver {
           ? "function_signature"
           : "variable";
         const idNode = currentNode.childForFieldName("declarator");
+        if (!idNode) {
+          throw new Error(
+            `Couldn't find identifier node for symbol :\n${capture.node.text}`,
+          );
+        }
         exportedSymbols.push({
           name: idNode.text,
           type: type as SymbolType,

packages/cli/src/languagePlugins/c/dependencyFormatting/index.ts

@@ -1,4 +1,4 @@
-import Parser from "tree-sitter";
+import type Parser from "tree-sitter";
 
 // Constants representing different types of symbols in C
 export const C_STRUCT_TYPE = "struct";

packages/cli/src/languagePlugins/c/headerResolver/index.test.ts

@@ -8,12 +8,11 @@ import path from "node:path";
 export class CIncludeResolver {
   symbolRegistry: Map<string, CFile>;
   files: Map<string, { path: string; rootNode: Parser.SyntaxNode }>;
-  #inclusions: Map<string, Inclusions>;
+  #inclusions?: Map<string, Inclusions>;
 
   constructor(symbolRegistry: CSymbolRegistry) {
     this.symbolRegistry = symbolRegistry.getRegistry();
     this.files = symbolRegistry.files;
-    this.#inclusions = new Map();
   }
 
   #getFile(filepath: string, sourcepath: string): CFile | undefined {

packages/cli/src/languagePlugins/c/headerResolver/index.ts

@@ -1,5 +1,5 @@
 import Parser from "tree-sitter";
-import { cParser } from "../../../helpers/treeSitter/parsers.js";
+import { cParser } from "../../../helpers/treeSitter/parsers.ts";
 
 export const C_INCLUDE_QUERY = new Parser.Query(
   cParser.getLanguage(),

packages/cli/src/languagePlugins/c/headerResolver/types.ts

@@ -4,6 +4,7 @@ import { cFilesFolder, getCFilesMap } from "../testFiles/index.ts";
 import { CSymbolRegistry } from "../symbolRegistry/index.ts";
 import { CIncludeResolver } from "../includeResolver/index.ts";
 import { CInvocationResolver } from "./index.ts";
+import type { Symbol } from "../symbolRegistry/types.ts";
 import path from "node:path";
 
 describe("CInvocationResolver", () => {
@@ -19,21 +20,21 @@ describe("CInvocationResolver", () => {
   const registry = symbolRegistry.getRegistry();
 
   test("resolves invocations for burgers.h", () => {
-    const symbols = registry.get(burgersh).symbols;
+    const symbols = registry.get(burgersh)?.symbols;
     if (!symbols) {
       throw new Error(`Symbol not found for: ${burgersh}`);
     }
-    const sauce = symbols.get("Sauce");
+    const sauce = symbols.get("Sauce") as Symbol;
     const sauceinvocations = invocationResolver.getInvocationsForSymbol(sauce);
     expect(sauceinvocations.resolved.size).toBe(1);
     expect(sauceinvocations.resolved.get("ClassicSauces")).toBeDefined();
 
-    const fries = symbols.get("Fries");
+    const fries = symbols.get("Fries") as Symbol;
     const friesinvocations = invocationResolver.getInvocationsForSymbol(fries);
     expect(friesinvocations.resolved.size).toBe(1);
     expect(friesinvocations.resolved.get("Sauce")).toBeDefined();
 
-    const burger = symbols.get("Burger");
+    const burger = symbols.get("Burger") as Symbol;
     const burgerinvocations = invocationResolver.getInvocationsForSymbol(
       burger,
     );
@@ -43,11 +44,11 @@ describe("CInvocationResolver", () => {
   });
 
   test("resolves invocations for burgers.c", () => {
-    const symbols = registry.get(burgersc).symbols;
+    const symbols = registry.get(burgersc)?.symbols;
     if (!symbols) {
       throw new Error(`Symbol not found for: ${burgersc}`);
     }
-    const create_burger = symbols.get("create_burger");
+    const create_burger = symbols.get("create_burger") as Symbol;
     const create_burger_invocations = invocationResolver
       .getInvocationsForSymbol(create_burger);
     const create_resolved = Array.from(
@@ -60,7 +61,7 @@ describe("CInvocationResolver", () => {
     expect(create_resolved).toContain("Sauce");
     expect(create_resolved).toContain("burger_count");
 
-    const destroy_burger = symbols.get("destroy_burger");
+    const destroy_burger = symbols.get("destroy_burger") as Symbol;
     const destroy_burger_invocations = invocationResolver
       .getInvocationsForSymbol(destroy_burger);
     const destroy_resolved = Array.from(
@@ -70,9 +71,12 @@ describe("CInvocationResolver", () => {
     expect(destroy_resolved).toContain("destroy_burger");
     expect(destroy_resolved).toContain("Burger");
 
-    const symbolsc = registry.get(burgersc).symbols;
+    const symbolsc = registry.get(burgersc)?.symbols;
+    if (!symbolsc) {
+      throw new Error(`Symbol not found for: ${burgersc}`);
+    }
 
-    const burgers = symbolsc.get("burgers");
+    const burgers = symbolsc.get("burgers") as Symbol;
     const burgers_invocations = invocationResolver.getInvocationsForSymbol(
       burgers,
     );
@@ -83,11 +87,11 @@ describe("CInvocationResolver", () => {
   });
 
   test("resolves invocations for personnel.c", () => {
-    const symbols = registry.get(personnelc).symbols;
+    const symbols = registry.get(personnelc)?.symbols;
     if (!symbols) {
       throw new Error(`Symbol not found for: ${personnelc}`);
     }
-    const create_employee = symbols.get("create_employee");
+    const create_employee = symbols.get("create_employee") as Symbol;
     const create_employee_invocations = invocationResolver
       .getInvocationsForSymbol(create_employee);
     const create_resolved = Array.from(
@@ -103,11 +107,11 @@ describe("CInvocationResolver", () => {
   });
 
   test("resolves invocations for main.c", () => {
-    const symbols = registry.get(main).symbols;
+    const symbols = registry.get(main)?.symbols;
     if (!symbols) {
       throw new Error(`Symbol not found for: ${main}`);
     }
-    const main_func = symbols.get("main");
+    const main_func = symbols.get("main") as Symbol;
     const main_invocations = invocationResolver.getInvocationsForSymbol(
       main_func,
     );
@@ -122,11 +126,11 @@ describe("CInvocationResolver", () => {
   });
 
   test("Crash Cases", () => {
-    const symbols = registry.get(crashcasesh).symbols;
+    const symbols = registry.get(crashcasesh)?.symbols;
     if (!symbols) {
       throw new Error(`Symbol not found for: ${crashcasesh}`);
     }
-    const crash = symbols.get("CpuFastFill");
+    const crash = symbols.get("CpuFastFill") as Symbol;
     const crash_invocations = invocationResolver.getInvocationsForSymbol(crash);
     const crash_resolved = Array.from(crash_invocations.resolved.keys());
     expect(crash_resolved.length).toBe(2);