c-next 0.1.70 → 0.1.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.70",
+  "version": "0.1.71",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "packageManager": "npm@11.9.0",
   "type": "module",

package/src/lib/__tests__/parseCHeader.mocked.test.ts

@@ -4,18 +4,15 @@
  */
 
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import ESymbolKind from "../../utils/types/ESymbolKind";
 
-// Create mock collect function that we can control per test
-const mockCollect = vi.fn();
+// Create mock resolve function that we can control per test
+const mockResolve = vi.fn();
 
-// Mock CSymbolCollector before importing parseCHeader
-vi.mock("../../transpiler/logic/symbols/CSymbolCollector", () => {
+// Mock CResolver before importing parseCHeader
+vi.mock("../../transpiler/logic/symbols/c", () => {
   return {
-    default: class MockCSymbolCollector {
-      collect() {
-        return mockCollect();
-      }
+    default: {
+      resolve: () => mockResolve(),
     },
   };
 });
@@ -25,23 +22,28 @@ import parseCHeader from "../parseCHeader";
 
 describe("parseCHeader mocked scenarios", () => {
   beforeEach(() => {
-    mockCollect.mockReset();
-    // Default to returning empty array
-    mockCollect.mockReturnValue([]);
+    mockResolve.mockReset();
+    // Default to returning empty result
+    mockResolve.mockReturnValue({ symbols: [], warnings: [] });
   });
 
   describe("mapSymbolKind default case", () => {
     it("maps Namespace kind to variable (default case)", () => {
       // Return a symbol with Namespace kind (not explicitly handled in switch)
-      mockCollect.mockReturnValue([
-        {
-          name: "TestNamespace",
-          kind: ESymbolKind.Namespace,
-          type: undefined,
-          parent: undefined,
-          sourceLine: 1,
-        },
-      ]);
+      // Use TCSymbol format which then gets converted by CTSymbolAdapter
+      mockResolve.mockReturnValue({
+        symbols: [
+          {
+            name: "TestNamespace",
+            kind: "namespace",
+            sourceFile: "<header>",
+            sourceLine: 1,
+            sourceLanguage: 0,
+            isExported: true,
+          },
+        ],
+        warnings: [],
+      });
 
       const result = parseCHeader("// any valid C");
 
@@ -52,15 +54,19 @@ describe("parseCHeader mocked scenarios", () => {
     });
 
     it("maps Class kind to variable (default case)", () => {
-      mockCollect.mockReturnValue([
-        {
-          name: "TestClass",
-          kind: ESymbolKind.Class,
-          type: "class",
-          parent: undefined,
-          sourceLine: 5,
-        },
-      ]);
+      mockResolve.mockReturnValue({
+        symbols: [
+          {
+            name: "TestClass",
+            kind: "class",
+            sourceFile: "<header>",
+            sourceLine: 5,
+            sourceLanguage: 0,
+            isExported: true,
+          },
+        ],
+        warnings: [],
+      });
 
       const result = parseCHeader("// any valid C");
 
@@ -69,15 +75,19 @@ describe("parseCHeader mocked scenarios", () => {
     });
 
     it("maps Bitmap kind to variable (default case)", () => {
-      mockCollect.mockReturnValue([
-        {
-          name: "TestBitmap",
-          kind: ESymbolKind.Bitmap,
-          type: undefined,
-          parent: undefined,
-          sourceLine: 1,
-        },
-      ]);
+      mockResolve.mockReturnValue({
+        symbols: [
+          {
+            name: "TestBitmap",
+            kind: "bitmap",
+            sourceFile: "<header>",
+            sourceLine: 1,
+            sourceLanguage: 0,
+            isExported: true,
+          },
+        ],
+        warnings: [],
+      });
 
       const result = parseCHeader("// any valid C");
 
@@ -86,15 +96,20 @@ describe("parseCHeader mocked scenarios", () => {
     });
 
     it("defaults line to 0 when sourceLine is undefined", () => {
-      mockCollect.mockReturnValue([
-        {
-          name: "NoLineSymbol",
-          kind: ESymbolKind.Function,
-          type: "void",
-          parent: undefined,
-          sourceLine: undefined, // No source line info
-        },
-      ]);
+      mockResolve.mockReturnValue({
+        symbols: [
+          {
+            name: "NoLineSymbol",
+            kind: "function",
+            type: "void",
+            sourceFile: "<header>",
+            sourceLine: undefined,
+            sourceLanguage: 0,
+            isExported: true,
+          },
+        ],
+        warnings: [],
+      });
 
       const result = parseCHeader("// any valid C");
 
@@ -104,9 +119,9 @@ describe("parseCHeader mocked scenarios", () => {
   });
 
   describe("error handling catch block", () => {
-    it("returns error result when collector throws Error", () => {
-      mockCollect.mockImplementation(() => {
-        throw new Error("Collector failed");
+    it("returns error result when resolver throws Error", () => {
+      mockResolve.mockImplementation(() => {
+        throw new Error("Resolver failed");
       });
 
       const result = parseCHeader("int x;");
@@ -114,14 +129,14 @@ describe("parseCHeader mocked scenarios", () => {
       expect(result.success).toBe(false);
       expect(result.symbols).toHaveLength(0);
       expect(result.errors).toHaveLength(1);
-      expect(result.errors[0].message).toBe("Collector failed");
+      expect(result.errors[0].message).toBe("Resolver failed");
       expect(result.errors[0].severity).toBe("error");
       expect(result.errors[0].line).toBe(1);
       expect(result.errors[0].column).toBe(0);
     });
 
     it("handles non-Error exceptions (string throw)", () => {
-      mockCollect.mockImplementation(() => {
+      mockResolve.mockImplementation(() => {
         throw "String error message";
       });
 
@@ -132,7 +147,7 @@ describe("parseCHeader mocked scenarios", () => {
     });
 
     it("handles non-Error exceptions (number throw)", () => {
-      mockCollect.mockImplementation(() => {
+      mockResolve.mockImplementation(() => {
         throw 42;
       });
 

package/src/lib/parseCHeader.ts

@@ -1,38 +1,81 @@
 /**
  * Parse C/C++ header source and extract symbols for IDE features
+ * ADR-055 Phase 7: Direct TCSymbol → ISymbolInfo conversion (no ISymbol intermediate)
  */
 
 import { CharStream, CommonTokenStream } from "antlr4ng";
 import { CLexer } from "../transpiler/logic/parser/c/grammar/CLexer";
 import { CParser } from "../transpiler/logic/parser/c/grammar/CParser";
-import CSymbolCollector from "../transpiler/logic/symbols/CSymbolCollector";
-import ESymbolKind from "../utils/types/ESymbolKind";
+import CResolver from "../transpiler/logic/symbols/c";
 import ISymbolInfo from "./types/ISymbolInfo";
 import IParseWithSymbolsResult from "./types/IParseWithSymbolsResult";
 import TSymbolKind from "./types/TSymbolKind";
+import TCSymbol from "../transpiler/types/symbols/c/TCSymbol";
 
 /**
- * Map ESymbolKind to TSymbolKind for extension use
+ * Map TCSymbol kind to library TSymbolKind
  */
-function mapSymbolKind(kind: ESymbolKind): TSymbolKind {
+function mapCSymbolKind(kind: TCSymbol["kind"]): TSymbolKind {
   switch (kind) {
-    case ESymbolKind.Struct:
+    case "struct":
       return "struct";
-    case ESymbolKind.Function:
+    case "function":
       return "function";
-    case ESymbolKind.Variable:
+    case "variable":
       return "variable";
-    case ESymbolKind.Enum:
+    case "enum":
       return "enum";
-    case ESymbolKind.EnumMember:
+    case "enum_member":
       return "enumMember";
-    case ESymbolKind.Type:
+    case "type":
       return "type";
     default:
       return "variable";
   }
 }
 
+/**
+ * ADR-055 Phase 7: Convert TCSymbol directly to ISymbolInfo.
+ * Handles the discriminated union by extracting common fields and type-specific fields.
+ */
+function convertTCSymbolsToISymbolInfo(
+  symbols: TCSymbol[],
+  filePath?: string,
+): ISymbolInfo[] {
+  return symbols.map((sym) => {
+    // Extract type and parent based on symbol kind
+    let type: string | undefined;
+    let parent: string | undefined;
+
+    switch (sym.kind) {
+      case "function":
+        type = sym.type;
+        break;
+      case "variable":
+        type = sym.type;
+        break;
+      case "enum_member":
+        parent = sym.parent;
+        break;
+      case "type":
+        type = sym.type;
+        break;
+      // struct and enum have no type field
+    }
+
+    return {
+      name: sym.name,
+      fullName: parent ? `${parent}.${sym.name}` : sym.name,
+      kind: mapCSymbolKind(sym.kind),
+      type,
+      parent,
+      line: sym.sourceLine ?? 0,
+      sourceFile: filePath,
+      language: "c",
+    };
+  });
+}
+
 /**
  * Parse C/C++ header source and extract symbols for IDE features
  *
@@ -75,20 +118,10 @@ function parseCHeader(
     parser.removeErrorListeners();
 
     const tree = parser.compilationUnit();
-    const collector = new CSymbolCollector(filePath ?? "<header>");
-    const rawSymbols = collector.collect(tree);
+    const result = CResolver.resolve(tree, filePath ?? "<header>");
 
-    // Transform ISymbol[] to ISymbolInfo[]
-    const symbols: ISymbolInfo[] = rawSymbols.map((sym) => ({
-      name: sym.name,
-      fullName: sym.parent ? `${sym.parent}.${sym.name}` : sym.name,
-      kind: mapSymbolKind(sym.kind),
-      type: sym.type,
-      parent: sym.parent,
-      line: sym.sourceLine ?? 0,
-      sourceFile: filePath,
-      language: "c",
-    }));
+    // ADR-055 Phase 7: Direct TCSymbol → ISymbolInfo conversion
+    const symbols = convertTCSymbolsToISymbolInfo(result.symbols, filePath);
 
     return {
       success: true,

package/src/lib/parseWithSymbols.ts

@@ -1,55 +1,211 @@
 /**
  * Parse C-Next source and extract symbols for IDE features
+ * ADR-055 Phase 7: Direct TSymbol → ISymbolInfo conversion (no ISymbol intermediate)
  */
 
 import CNextSourceParser from "../transpiler/logic/parser/CNextSourceParser";
 import CNextResolver from "../transpiler/logic/symbols/cnext/index";
-import TSymbolAdapter from "../transpiler/logic/symbols/cnext/adapters/TSymbolAdapter";
-import SymbolTable from "../transpiler/logic/symbols/SymbolTable";
-import ESymbolKind from "../utils/types/ESymbolKind";
+import SymbolNameUtils from "../transpiler/logic/symbols/cnext/utils/SymbolNameUtils";
+import TypeResolver from "../utils/TypeResolver";
 import ISymbolInfo from "./types/ISymbolInfo";
 import IParseWithSymbolsResult from "./types/IParseWithSymbolsResult";
-import TSymbolKind from "./types/TSymbolKind";
+import TSymbol from "../transpiler/types/symbols/TSymbol";
 
 /**
- * Map ESymbolKind to TSymbolKind for extension use
+ * ADR-055 Phase 7: Convert TSymbol directly to ISymbolInfo array.
+ * Expands compound symbols (bitmaps, enums, registers) into multiple ISymbolInfo entries.
  */
-function mapSymbolKind(kind: ESymbolKind): TSymbolKind {
-  switch (kind) {
-    case ESymbolKind.Namespace:
-      return "namespace";
-    case ESymbolKind.Struct:
-      return "struct";
-    case ESymbolKind.Register:
-      return "register";
-    case ESymbolKind.Function:
-      return "function";
-    case ESymbolKind.Variable:
-      return "variable";
-    case ESymbolKind.RegisterMember:
-      return "registerMember";
-    case ESymbolKind.Enum:
-      return "enum";
-    case ESymbolKind.EnumMember:
-      return "enumMember";
-    case ESymbolKind.Bitmap:
-      return "bitmap";
-    case ESymbolKind.BitmapField:
-      return "bitmapField";
-    default:
-      return "variable";
+function convertTSymbolsToISymbolInfo(symbols: TSymbol[]): ISymbolInfo[] {
+  const result: ISymbolInfo[] = [];
+
+  for (const symbol of symbols) {
+    switch (symbol.kind) {
+      case "bitmap":
+        result.push(...convertBitmap(symbol));
+        break;
+      case "enum":
+        result.push(...convertEnum(symbol));
+        break;
+      case "struct":
+        result.push(convertStruct(symbol));
+        break;
+      case "function":
+        result.push(...convertFunction(symbol));
+        break;
+      case "variable":
+        result.push(convertVariable(symbol));
+        break;
+      case "register":
+        result.push(...convertRegister(symbol));
+        break;
+      case "scope":
+        result.push(convertScope(symbol));
+        break;
+    }
   }
+
+  return result;
 }
 
-/**
- * Extract local name from full qualified name
- * e.g., "LED_toggle" with parent "LED" -> "toggle"
- */
-function extractLocalName(fullName: string, parent?: string): string {
-  if (parent && fullName.startsWith(parent + "_")) {
-    return fullName.substring(parent.length + 1);
+function convertBitmap(
+  bitmap: import("../transpiler/types/symbols/IBitmapSymbol").default,
+): ISymbolInfo[] {
+  const result: ISymbolInfo[] = [];
+  const mangledName = SymbolNameUtils.getMangledName(bitmap);
+  const parent = bitmap.scope.name || undefined;
+
+  result.push({
+    name: bitmap.name,
+    fullName: mangledName,
+    kind: "bitmap",
+    type: bitmap.backingType,
+    parent,
+    line: bitmap.sourceLine,
+  });
+
+  // Add bitmap fields
+  for (const [fieldName, fieldInfo] of bitmap.fields) {
+    result.push({
+      name: fieldName,
+      fullName: `${mangledName}.${fieldName}`,
+      kind: "bitmapField",
+      parent: mangledName,
+      line: bitmap.sourceLine,
+      size: fieldInfo.width,
+    });
+  }
+
+  return result;
+}
+
+function convertEnum(
+  enumSym: import("../transpiler/types/symbols/IEnumSymbol").default,
+): ISymbolInfo[] {
+  const result: ISymbolInfo[] = [];
+  const mangledName = SymbolNameUtils.getMangledName(enumSym);
+  const parent = enumSym.scope.name || undefined;
+
+  result.push({
+    name: enumSym.name,
+    fullName: mangledName,
+    kind: "enum",
+    parent,
+    line: enumSym.sourceLine,
+  });
+
+  // Add enum members
+  for (const [memberName] of enumSym.members) {
+    result.push({
+      name: memberName,
+      fullName: `${mangledName}_${memberName}`,
+      kind: "enumMember",
+      parent: mangledName,
+      line: enumSym.sourceLine,
+    });
+  }
+
+  return result;
+}
+
+function convertStruct(
+  struct: import("../transpiler/types/symbols/IStructSymbol").default,
+): ISymbolInfo {
+  const mangledName = SymbolNameUtils.getMangledName(struct);
+  const parent = struct.scope.name || undefined;
+
+  return {
+    name: struct.name,
+    fullName: mangledName,
+    kind: "struct",
+    parent,
+    line: struct.sourceLine,
+  };
+}
+
+function convertFunction(
+  func: import("../transpiler/types/symbols/IFunctionSymbol").default,
+): ISymbolInfo[] {
+  const result: ISymbolInfo[] = [];
+  const mangledName = SymbolNameUtils.getMangledName(func);
+  const parent = func.scope.name || undefined;
+  const returnType = TypeResolver.getTypeName(func.returnType);
+
+  // Build signature
+  const paramTypes = func.parameters.map((p) =>
+    TypeResolver.getTypeName(p.type),
+  );
+  const signature = `${returnType} ${mangledName}(${paramTypes.join(", ")})`;
+
+  result.push({
+    name: func.name,
+    fullName: mangledName,
+    kind: "function",
+    type: returnType,
+    parent,
+    signature,
+    accessModifier: func.isExported ? "public" : "private",
+    line: func.sourceLine,
+  });
+
+  return result;
+}
+
+function convertVariable(
+  variable: import("../transpiler/types/symbols/IVariableSymbol").default,
+): ISymbolInfo {
+  const mangledName = SymbolNameUtils.getMangledName(variable);
+  const parent = variable.scope.name || undefined;
+  const typeStr = TypeResolver.getTypeName(variable.type);
+
+  return {
+    name: variable.name,
+    fullName: mangledName,
+    kind: "variable",
+    type: typeStr,
+    parent,
+    line: variable.sourceLine,
+  };
+}
+
+function convertRegister(
+  register: import("../transpiler/types/symbols/IRegisterSymbol").default,
+): ISymbolInfo[] {
+  const result: ISymbolInfo[] = [];
+  const mangledName = SymbolNameUtils.getMangledName(register);
+  const parent = register.scope.name || undefined;
+
+  result.push({
+    name: register.name,
+    fullName: mangledName,
+    kind: "register",
+    parent,
+    line: register.sourceLine,
+  });
+
+  // Add register members
+  for (const [memberName, memberInfo] of register.members) {
+    result.push({
+      name: memberName,
+      fullName: `${mangledName}.${memberName}`,
+      kind: "registerMember",
+      parent: mangledName,
+      accessModifier: memberInfo.access,
+      line: register.sourceLine,
+    });
   }
-  return fullName;
+
+  return result;
+}
+
+function convertScope(
+  scope: import("../transpiler/types/symbols/IScopeSymbol").default,
+): ISymbolInfo {
+  return {
+    name: scope.name,
+    fullName: scope.name,
+    kind: "namespace",
+    line: scope.sourceLine,
+  };
 }
 
 /**
@@ -74,23 +230,9 @@ function parseWithSymbols(source: string): IParseWithSymbolsResult {
   // Parse C-Next source
   const { tree, errors } = CNextSourceParser.parse(source);
 
-  // Collect symbols from the parse tree (ADR-055: use CNextResolver + TSymbolAdapter)
+  // ADR-055 Phase 7: Direct TSymbol → ISymbolInfo conversion (no ISymbol intermediate)
   const tSymbols = CNextResolver.resolve(tree, "<source>");
-  const symbolTable = new SymbolTable();
-  const rawSymbols = TSymbolAdapter.toISymbols(tSymbols, symbolTable);
-
-  // Transform ISymbol[] to ISymbolInfo[]
-  const symbols: ISymbolInfo[] = rawSymbols.map((sym) => ({
-    name: extractLocalName(sym.name, sym.parent),
-    fullName: sym.name,
-    kind: mapSymbolKind(sym.kind),
-    type: sym.type,
-    parent: sym.parent,
-    signature: sym.signature,
-    accessModifier: sym.accessModifier,
-    line: sym.sourceLine,
-    size: sym.size,
-  }));
+  const symbols = convertTSymbolsToISymbolInfo(tSymbols);
 
   return {
     success: errors.length === 0,