c-next 0.1.70 → 0.1.72

package/src/utils/__tests__/TypeResolver.test.ts

@@ -0,0 +1,332 @@
+import { describe, it, expect } from "vitest";
+import TypeResolver from "../TypeResolver";
+import type TType from "../../transpiler/types/TType";
+
+describe("TypeResolver", () => {
+  describe("resolve - primitive types", () => {
+    it("resolves void", () => {
+      const result = TypeResolver.resolve("void");
+      expect(result).toEqual({ kind: "primitive", primitive: "void" });
+    });
+
+    it("resolves bool", () => {
+      const result = TypeResolver.resolve("bool");
+      expect(result).toEqual({ kind: "primitive", primitive: "bool" });
+    });
+
+    it("resolves u8", () => {
+      const result = TypeResolver.resolve("u8");
+      expect(result).toEqual({ kind: "primitive", primitive: "u8" });
+    });
+
+    it("resolves i8", () => {
+      const result = TypeResolver.resolve("i8");
+      expect(result).toEqual({ kind: "primitive", primitive: "i8" });
+    });
+
+    it("resolves u16", () => {
+      const result = TypeResolver.resolve("u16");
+      expect(result).toEqual({ kind: "primitive", primitive: "u16" });
+    });
+
+    it("resolves i16", () => {
+      const result = TypeResolver.resolve("i16");
+      expect(result).toEqual({ kind: "primitive", primitive: "i16" });
+    });
+
+    it("resolves u32", () => {
+      const result = TypeResolver.resolve("u32");
+      expect(result).toEqual({ kind: "primitive", primitive: "u32" });
+    });
+
+    it("resolves i32", () => {
+      const result = TypeResolver.resolve("i32");
+      expect(result).toEqual({ kind: "primitive", primitive: "i32" });
+    });
+
+    it("resolves u64", () => {
+      const result = TypeResolver.resolve("u64");
+      expect(result).toEqual({ kind: "primitive", primitive: "u64" });
+    });
+
+    it("resolves i64", () => {
+      const result = TypeResolver.resolve("i64");
+      expect(result).toEqual({ kind: "primitive", primitive: "i64" });
+    });
+
+    it("resolves f32", () => {
+      const result = TypeResolver.resolve("f32");
+      expect(result).toEqual({ kind: "primitive", primitive: "f32" });
+    });
+
+    it("resolves f64", () => {
+      const result = TypeResolver.resolve("f64");
+      expect(result).toEqual({ kind: "primitive", primitive: "f64" });
+    });
+  });
+
+  describe("resolve - string types", () => {
+    it("resolves string<32>", () => {
+      const result = TypeResolver.resolve("string<32>");
+      expect(result).toEqual({ kind: "string", capacity: 32 });
+    });
+
+    it("resolves string<64>", () => {
+      const result = TypeResolver.resolve("string<64>");
+      expect(result).toEqual({ kind: "string", capacity: 64 });
+    });
+
+    it("resolves string<1>", () => {
+      const result = TypeResolver.resolve("string<1>");
+      expect(result).toEqual({ kind: "string", capacity: 1 });
+    });
+
+    it("resolves string<256>", () => {
+      const result = TypeResolver.resolve("string<256>");
+      expect(result).toEqual({ kind: "string", capacity: 256 });
+    });
+  });
+
+  describe("resolve - array types", () => {
+    it("resolves u8[10]", () => {
+      const result = TypeResolver.resolve("u8[10]");
+      expect(result).toEqual({
+        kind: "array",
+        elementType: { kind: "primitive", primitive: "u8" },
+        dimensions: [10],
+      });
+    });
+
+    it("resolves i32[5]", () => {
+      const result = TypeResolver.resolve("i32[5]");
+      expect(result).toEqual({
+        kind: "array",
+        elementType: { kind: "primitive", primitive: "i32" },
+        dimensions: [5],
+      });
+    });
+
+    it("resolves f64[100]", () => {
+      const result = TypeResolver.resolve("f64[100]");
+      expect(result).toEqual({
+        kind: "array",
+        elementType: { kind: "primitive", primitive: "f64" },
+        dimensions: [100],
+      });
+    });
+
+    it("resolves multi-dimensional array u8[10][20]", () => {
+      const result = TypeResolver.resolve("u8[10][20]");
+      expect(result).toEqual({
+        kind: "array",
+        elementType: { kind: "primitive", primitive: "u8" },
+        dimensions: [10, 20],
+      });
+    });
+
+    it("resolves 3D array u32[2][3][4]", () => {
+      const result = TypeResolver.resolve("u32[2][3][4]");
+      expect(result).toEqual({
+        kind: "array",
+        elementType: { kind: "primitive", primitive: "u32" },
+        dimensions: [2, 3, 4],
+      });
+    });
+
+    it("resolves array with string dimension (C macro)", () => {
+      const result = TypeResolver.resolve("u8[BUFFER_SIZE]");
+      expect(result).toEqual({
+        kind: "array",
+        elementType: { kind: "primitive", primitive: "u8" },
+        dimensions: ["BUFFER_SIZE"],
+      });
+    });
+
+    it("resolves array with mixed dimensions", () => {
+      const result = TypeResolver.resolve("u8[10][ROWS]");
+      expect(result).toEqual({
+        kind: "array",
+        elementType: { kind: "primitive", primitive: "u8" },
+        dimensions: [10, "ROWS"],
+      });
+    });
+
+    it("resolves string array string<32>[10]", () => {
+      const result = TypeResolver.resolve("string<32>[10]");
+      expect(result).toEqual({
+        kind: "array",
+        elementType: { kind: "string", capacity: 32 },
+        dimensions: [10],
+      });
+    });
+  });
+
+  describe("resolve - struct types", () => {
+    it("resolves Point as struct", () => {
+      const result = TypeResolver.resolve("Point");
+      expect(result).toEqual({ kind: "struct", name: "Point" });
+    });
+
+    it("resolves Configuration as struct", () => {
+      const result = TypeResolver.resolve("Configuration");
+      expect(result).toEqual({ kind: "struct", name: "Configuration" });
+    });
+
+    it("resolves MyStruct as struct", () => {
+      const result = TypeResolver.resolve("MyStruct");
+      expect(result).toEqual({ kind: "struct", name: "MyStruct" });
+    });
+  });
+
+  describe("resolve - enum types", () => {
+    it("resolves EColor as enum (E prefix convention)", () => {
+      const result = TypeResolver.resolve("EColor");
+      expect(result).toEqual({ kind: "enum", name: "EColor" });
+    });
+
+    it("resolves EStatus as enum", () => {
+      const result = TypeResolver.resolve("EStatus");
+      expect(result).toEqual({ kind: "enum", name: "EStatus" });
+    });
+
+    it("resolves EPressureType as enum", () => {
+      const result = TypeResolver.resolve("EPressureType");
+      expect(result).toEqual({ kind: "enum", name: "EPressureType" });
+    });
+  });
+
+  describe("resolve - external types (C++ templates)", () => {
+    it("resolves FlexCAN_T4<CAN1>", () => {
+      const result = TypeResolver.resolve("FlexCAN_T4<CAN1>");
+      expect(result).toEqual({ kind: "external", name: "FlexCAN_T4<CAN1>" });
+    });
+
+    it("resolves std::vector<int>", () => {
+      const result = TypeResolver.resolve("std::vector<int>");
+      expect(result).toEqual({ kind: "external", name: "std::vector<int>" });
+    });
+
+    it("resolves Complex::Namespace::Type<T>", () => {
+      const result = TypeResolver.resolve("Complex::Namespace::Type<T>");
+      expect(result).toEqual({
+        kind: "external",
+        name: "Complex::Namespace::Type<T>",
+      });
+    });
+  });
+
+  describe("resolve - struct arrays", () => {
+    it("resolves Point[5]", () => {
+      const result = TypeResolver.resolve("Point[5]");
+      expect(result).toEqual({
+        kind: "array",
+        elementType: { kind: "struct", name: "Point" },
+        dimensions: [5],
+      });
+    });
+
+    it("resolves Configuration[10][20]", () => {
+      const result = TypeResolver.resolve("Configuration[10][20]");
+      expect(result).toEqual({
+        kind: "array",
+        elementType: { kind: "struct", name: "Configuration" },
+        dimensions: [10, 20],
+      });
+    });
+  });
+
+  describe("resolve - enum arrays", () => {
+    it("resolves EColor[3]", () => {
+      const result = TypeResolver.resolve("EColor[3]");
+      expect(result).toEqual({
+        kind: "array",
+        elementType: { kind: "enum", name: "EColor" },
+        dimensions: [3],
+      });
+    });
+  });
+
+  describe("resolve - edge cases", () => {
+    it("handles whitespace in type string", () => {
+      const result = TypeResolver.resolve("  u32  ");
+      expect(result).toEqual({ kind: "primitive", primitive: "u32" });
+    });
+
+    it("handles whitespace in array dimensions", () => {
+      const result = TypeResolver.resolve("u8[ 10 ]");
+      expect(result).toEqual({
+        kind: "array",
+        elementType: { kind: "primitive", primitive: "u8" },
+        dimensions: [10],
+      });
+    });
+
+    it("handles whitespace in string capacity", () => {
+      const result = TypeResolver.resolve("string< 32 >");
+      expect(result).toEqual({ kind: "string", capacity: 32 });
+    });
+
+    it("throws for empty string", () => {
+      expect(() => TypeResolver.resolve("")).toThrow(
+        "Cannot resolve empty type string",
+      );
+    });
+
+    it("throws for whitespace-only string", () => {
+      expect(() => TypeResolver.resolve("   ")).toThrow(
+        "Cannot resolve empty type string",
+      );
+    });
+  });
+
+  describe("getTypeName - round-trip compatibility", () => {
+    it("returns primitive name", () => {
+      const type: TType = { kind: "primitive", primitive: "u32" };
+      expect(TypeResolver.getTypeName(type)).toBe("u32");
+    });
+
+    it("returns string with capacity", () => {
+      const type: TType = { kind: "string", capacity: 64 };
+      expect(TypeResolver.getTypeName(type)).toBe("string<64>");
+    });
+
+    it("returns struct name", () => {
+      const type: TType = { kind: "struct", name: "Point" };
+      expect(TypeResolver.getTypeName(type)).toBe("Point");
+    });
+
+    it("returns enum name", () => {
+      const type: TType = { kind: "enum", name: "EColor" };
+      expect(TypeResolver.getTypeName(type)).toBe("EColor");
+    });
+
+    it("returns external name", () => {
+      const type: TType = { kind: "external", name: "FlexCAN_T4<CAN1>" };
+      expect(TypeResolver.getTypeName(type)).toBe("FlexCAN_T4<CAN1>");
+    });
+
+    it("returns array type with dimensions", () => {
+      const type: TType = {
+        kind: "array",
+        elementType: { kind: "primitive", primitive: "u8" },
+        dimensions: [10, 20],
+      };
+      expect(TypeResolver.getTypeName(type)).toBe("u8[10][20]");
+    });
+
+    it("returns callback name", () => {
+      const type: TType = { kind: "callback", name: "onClick" };
+      expect(TypeResolver.getTypeName(type)).toBe("onClick");
+    });
+
+    it("returns register name", () => {
+      const type: TType = { kind: "register", name: "PORTB" };
+      expect(TypeResolver.getTypeName(type)).toBe("PORTB");
+    });
+
+    it("returns bitmap name", () => {
+      const type: TType = { kind: "bitmap", name: "StatusFlags", bitWidth: 8 };
+      expect(TypeResolver.getTypeName(type)).toBe("StatusFlags");
+    });
+  });
+});

package/src/utils/cache/CacheManager.ts

@@ -15,8 +15,8 @@ import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { FlatCache, create as createFlatCache } from "flat-cache";
 import CacheKeyGenerator from "./CacheKeyGenerator";
-import ISymbol from "../types/ISymbol";
-import IStructFieldInfo from "../../transpiler/logic/symbols/types/IStructFieldInfo";
+// ADR-055 Phase 7: ISymbol removed - using ISerializedSymbol directly
+import IStructFieldInfo from "../../transpiler/types/symbols/IStructFieldInfo";
 import SymbolTable from "../../transpiler/logic/symbols/SymbolTable";
 import ICacheConfig from "../../transpiler/types/ICacheConfig";
 import ICachedFileEntry from "../../transpiler/types/ICachedFileEntry";
@@ -24,12 +24,15 @@ import ISerializedSymbol from "../../transpiler/types/ISerializedSymbol";
 import IFileSystem from "../../transpiler/types/IFileSystem";
 import NodeFileSystem from "../../transpiler/NodeFileSystem";
 import packageJson from "../../../package.json" with { type: "json" };
+import TAnySymbol from "../../transpiler/types/symbols/TAnySymbol";
+import TypeResolver from "../TypeResolver";
+import ESourceLanguage from "../types/ESourceLanguage";
 
 /** Default file system instance (singleton for performance) */
 const defaultFs = NodeFileSystem.instance;
 
 /** Current cache format version - increment when serialization format changes */
-const CACHE_VERSION = 3; // ADR-055 Phase 4: cacheKey replaces mtime
+const CACHE_VERSION = 4; // ADR-055 Phase 7: TAnySymbol replaces ISymbol
 
 const TRANSPILER_VERSION = packageJson.version;
 
@@ -124,9 +127,10 @@ class CacheManager {
 
   /**
    * Get cached symbols and struct fields for a file
+   * ADR-055 Phase 7: Returns ISerializedSymbol[] directly (no ISymbol intermediate)
    */
   getSymbols(filePath: string): {
-    symbols: ISymbol[];
+    symbols: ISerializedSymbol[];
     structFields: Map<string, Map<string, IStructFieldInfo>>;
     needsStructKeyword: string[];
     enumBitWidth: Map<string, number>;
@@ -139,8 +143,8 @@ class CacheManager {
     }
     const cachedEntry = entry as ICachedFileEntry;
 
-    // Deserialize symbols
-    const symbols = cachedEntry.symbols.map((s) => this.deserializeSymbol(s));
+    // ADR-055 Phase 7: Return serialized symbols directly
+    const symbols = cachedEntry.symbols;
 
     // Convert struct fields from plain objects to Maps
     const structFields = new Map<string, Map<string, IStructFieldInfo>>();
@@ -174,10 +178,11 @@ class CacheManager {
 
   /**
    * Store symbols and struct fields for a file
+   * ADR-055 Phase 7: Takes ISerializedSymbol[] directly
    */
   setSymbols(
     filePath: string,
-    symbols: ISymbol[],
+    symbols: ISerializedSymbol[],
     structFields: Map<string, Map<string, IStructFieldInfo>>,
     needsStructKeyword?: string[],
     enumBitWidth?: Map<string, number>,
@@ -193,8 +198,8 @@ class CacheManager {
       return;
     }
 
-    // Serialize symbols
-    const serializedSymbols = symbols.map((s) => this.serializeSymbol(s));
+    // ADR-055 Phase 7: symbols are already serialized
+    const serializedSymbols = symbols;
 
     // Convert struct fields from Maps to plain objects
     const serializedFields: Record<
@@ -242,8 +247,9 @@ class CacheManager {
    * @param symbolTable - SymbolTable containing all parsed symbols
    */
   setSymbolsFromTable(filePath: string, symbolTable: SymbolTable): void {
-    // Extract symbols for this file
-    const symbols = symbolTable.getSymbolsByFile(filePath);
+    // ADR-055 Phase 7: Serialize TAnySymbol directly to ISerializedSymbol
+    const typedSymbols = symbolTable.getSymbolsByFile(filePath);
+    const symbols = typedSymbols.map((s) => this.serializeTypedSymbol(s));
 
     // Extract struct fields for structs defined in this file
     const structFields = this.extractStructFieldsForFile(filePath, symbolTable);
@@ -475,60 +481,95 @@ class CacheManager {
   }
 
   /**
-   * Serialize an ISymbol to JSON-safe format
+   * ADR-055 Phase 7: Serialize TAnySymbol directly to ISerializedSymbol.
+   * No intermediate ISymbol format.
    */
-  private serializeSymbol(symbol: ISymbol): ISerializedSymbol {
+  private serializeTypedSymbol(symbol: TAnySymbol): ISerializedSymbol {
     const serialized: ISerializedSymbol = {
       name: symbol.name,
-      kind: symbol.kind, // Already a string from enum
+      kind: symbol.kind,
       sourceFile: symbol.sourceFile,
       sourceLine: symbol.sourceLine,
-      sourceLanguage: symbol.sourceLanguage, // Already a string from enum
+      sourceLanguage: symbol.sourceLanguage,
       isExported: symbol.isExported,
     };
 
-    // Add optional fields only if present
-    if (symbol.type !== undefined) serialized.type = symbol.type;
-    if (symbol.isDeclaration !== undefined)
-      serialized.isDeclaration = symbol.isDeclaration;
-    if (symbol.signature !== undefined) serialized.signature = symbol.signature;
-    if (symbol.parent !== undefined) serialized.parent = symbol.parent;
-    if (symbol.accessModifier !== undefined)
-      serialized.accessModifier = symbol.accessModifier;
-    if (symbol.size !== undefined) serialized.size = symbol.size;
-    if (symbol.parameters !== undefined)
-      serialized.parameters = symbol.parameters;
+    this.addTypeFieldToSerialized(symbol, serialized);
+    this.addVariableFieldsToSerialized(symbol, serialized);
+    this.addFunctionFieldsToSerialized(symbol, serialized);
 
     return serialized;
   }
 
   /**
-   * Deserialize a symbol from JSON format back to ISymbol
+   * Add type field to ISerializedSymbol, converting TType to string for C-Next symbols.
    */
-  private deserializeSymbol(serialized: ISerializedSymbol): ISymbol {
-    const symbol: ISymbol = {
-      name: serialized.name,
-      kind: serialized.kind as ISymbol["kind"], // Cast string back to enum
-      sourceFile: serialized.sourceFile,
-      sourceLine: serialized.sourceLine,
-      sourceLanguage: serialized.sourceLanguage as ISymbol["sourceLanguage"],
-      isExported: serialized.isExported,
-    };
+  private addTypeFieldToSerialized(
+    symbol: TAnySymbol,
+    serialized: ISerializedSymbol,
+  ): void {
+    if (!("type" in symbol) || symbol.type === undefined) {
+      return;
+    }
+    const isCNextWithTType =
+      symbol.sourceLanguage === ESourceLanguage.CNext &&
+      typeof symbol.type !== "string";
+    serialized.type = isCNextWithTType
+      ? TypeResolver.getTypeName(symbol.type)
+      : (symbol.type as string);
+  }
+
+  /**
+   * Add variable-specific fields to ISerializedSymbol.
+   */
+  private addVariableFieldsToSerialized(
+    symbol: TAnySymbol,
+    serialized: ISerializedSymbol,
+  ): void {
+    if (symbol.kind !== "variable") {
+      return;
+    }
+    if ("isConst" in symbol && symbol.isConst !== undefined) {
+      serialized.isConst = symbol.isConst;
+    }
+    if ("isAtomic" in symbol && symbol.isAtomic !== undefined) {
+      serialized.isAtomic = symbol.isAtomic;
+    }
+    if ("isArray" in symbol && symbol.isArray !== undefined) {
+      serialized.isArray = symbol.isArray;
+    }
+    if ("arrayDimensions" in symbol && symbol.arrayDimensions) {
+      serialized.arrayDimensions = symbol.arrayDimensions.map(String);
+    }
+    if ("initialValue" in symbol && symbol.initialValue !== undefined) {
+      serialized.initialValue = symbol.initialValue;
+    }
+  }
 
-    // Add optional fields only if present
-    if (serialized.type !== undefined) symbol.type = serialized.type;
-    if (serialized.isDeclaration !== undefined)
-      symbol.isDeclaration = serialized.isDeclaration;
-    if (serialized.signature !== undefined)
-      symbol.signature = serialized.signature;
-    if (serialized.parent !== undefined) symbol.parent = serialized.parent;
-    if (serialized.accessModifier !== undefined)
-      symbol.accessModifier = serialized.accessModifier;
-    if (serialized.size !== undefined) symbol.size = serialized.size;
-    if (serialized.parameters !== undefined)
-      symbol.parameters = serialized.parameters;
-
-    return symbol;
+  /**
+   * Add function-specific fields to ISerializedSymbol.
+   */
+  private addFunctionFieldsToSerialized(
+    symbol: TAnySymbol,
+    serialized: ISerializedSymbol,
+  ): void {
+    if (symbol.kind !== "function") {
+      return;
+    }
+    if ("returnType" in symbol && symbol.returnType !== undefined) {
+      serialized.type = TypeResolver.getTypeName(symbol.returnType);
+    }
+    if ("parameters" in symbol && symbol.parameters) {
+      serialized.parameters = symbol.parameters.map((p) => ({
+        name: p.name,
+        type:
+          typeof p.type === "string"
+            ? p.type
+            : TypeResolver.getTypeName(p.type),
+        isConst: p.isConst,
+        isArray: p.isArray,
+      }));
+    }
   }
 }