c-next 0.1.6 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "main": "src/index.ts",
   "bin": {

package/src/codegen/CodeGenerator.ts

@@ -6749,9 +6749,15 @@ export default class CodeGenerator implements IOrchestrator {
                   subscriptDepth >= dimensions.length
                 ) {
                   // Array member fully subscripted (e.g., ts.arr[0][1].length) -> return element bit width
-                  // Try C-Next types first, then C types
-                  const bitWidth =
+                  // Try C-Next types first, then C types, then enum types
+                  let bitWidth =
                     TYPE_WIDTH[memberType] || C_TYPE_WIDTH[memberType] || 0;
+                  // Issue #208: Check if it's a typed enum
+                  if (bitWidth === 0 && this.symbolTable) {
+                    const enumWidth =
+                      this.symbolTable.getEnumBitWidth(memberType);
+                    if (enumWidth) bitWidth = enumWidth;
+                  }
                   if (bitWidth > 0) {
                     result = String(bitWidth);
                   } else {
@@ -6759,9 +6765,15 @@ export default class CodeGenerator implements IOrchestrator {
                   }
                 } else {
                   // Non-array member -> return bit width
-                  // Try C-Next types first, then C types
-                  const bitWidth =
+                  // Try C-Next types first, then C types, then enum types
+                  let bitWidth =
                     TYPE_WIDTH[memberType] || C_TYPE_WIDTH[memberType] || 0;
+                  // Issue #208: Check if it's a typed enum
+                  if (bitWidth === 0 && this.symbolTable) {
+                    const enumWidth =
+                      this.symbolTable.getEnumBitWidth(memberType);
+                    if (enumWidth) bitWidth = enumWidth;
+                  }
                   if (bitWidth > 0) {
                     result = String(bitWidth);
                   } else {

package/src/pipeline/CacheManager.ts

@@ -27,7 +27,7 @@ import ICachedFileEntry from "./types/ICachedFileEntry";
 import ISerializedSymbol from "./types/ISerializedSymbol";
 
 /** Current cache format version - increment when serialization format changes */
-const CACHE_VERSION = 1;
+const CACHE_VERSION = 2; // Issue #208: Added enumBitWidth
 
 // Read version from package.json
 // eslint-disable-next-line @typescript-eslint/no-var-requires
@@ -109,6 +109,7 @@ class CacheManager {
     symbols: ISymbol[];
     structFields: Map<string, Map<string, IStructFieldInfo>>;
     needsStructKeyword: string[];
+    enumBitWidth: Map<string, number>;
   } | null {
     const entry = this.entries.get(filePath);
     if (!entry) {
@@ -128,10 +129,19 @@ class CacheManager {
       structFields.set(structName, fieldMap);
     }
 
+    // Issue #208: Convert enum bit widths from plain object to Map
+    const enumBitWidth = new Map<string, number>();
+    if (entry.enumBitWidth) {
+      for (const [enumName, width] of Object.entries(entry.enumBitWidth)) {
+        enumBitWidth.set(enumName, width);
+      }
+    }
+
     return {
       symbols,
       structFields,
       needsStructKeyword: entry.needsStructKeyword ?? [],
+      enumBitWidth,
     };
   }
 
@@ -143,6 +153,7 @@ class CacheManager {
     symbols: ISymbol[],
     structFields: Map<string, Map<string, IStructFieldInfo>>,
     needsStructKeyword?: string[],
+    enumBitWidth?: Map<string, number>,
   ): void {
     // Get current mtime
     let mtime: number;
@@ -169,6 +180,14 @@ class CacheManager {
       }
     }
 
+    // Issue #208: Convert enum bit widths from Map to plain object
+    const serializedEnumBitWidth: Record<string, number> = {};
+    if (enumBitWidth) {
+      for (const [enumName, width] of enumBitWidth) {
+        serializedEnumBitWidth[enumName] = width;
+      }
+    }
+
     // Create entry
     const entry: ICachedFileEntry = {
       filePath,
@@ -176,6 +195,7 @@ class CacheManager {
       symbols: serializedSymbols,
       structFields: serializedFields,
       needsStructKeyword,
+      enumBitWidth: serializedEnumBitWidth,
     };
 
     this.entries.set(filePath, entry);

package/src/pipeline/Pipeline.ts

@@ -26,7 +26,6 @@ import { CPP14Parser } from "../parser/cpp/grammar/CPP14Parser";
 import CodeGenerator from "../codegen/CodeGenerator";
 import HeaderGenerator from "../codegen/HeaderGenerator";
 import SymbolTable from "../symbols/SymbolTable";
-import ISymbol from "../types/ISymbol";
 import CNextSymbolCollector from "../symbols/CNextSymbolCollector";
 import CSymbolCollector from "../symbols/CSymbolCollector";
 import CppSymbolCollector from "../symbols/CppSymbolCollector";
@@ -44,6 +43,7 @@ import IFileResult from "./types/IFileResult";
 import runAnalyzers from "./runAnalyzers";
 import CacheManager from "./CacheManager";
 import IStructFieldInfo from "../symbols/types/IStructFieldInfo";
+import detectCppSyntax from "./detectCppSyntax";
 
 /**
  * Unified transpilation pipeline
@@ -312,10 +312,11 @@ class Pipeline {
     if (this.cacheManager?.isValid(file.path)) {
       const cached = this.cacheManager.getSymbols(file.path);
       if (cached) {
-        // Restore symbols, struct fields, and needsStructKeyword from cache
+        // Restore symbols, struct fields, needsStructKeyword, and enumBitWidth from cache
         this.symbolTable.addSymbols(cached.symbols);
         this.symbolTable.restoreStructFields(cached.structFields);
         this.symbolTable.restoreNeedsStructKeyword(cached.needsStructKeyword);
+        this.symbolTable.restoreEnumBitWidths(cached.enumBitWidth);
         return; // Cache hit - skip parsing
       }
     }
@@ -356,23 +357,35 @@ class Pipeline {
       const needsStructKeyword = this.extractNeedsStructKeywordForFile(
         file.path,
       );
+      const enumBitWidth = this.extractEnumBitWidthsForFile(file.path);
       this.cacheManager.setSymbols(
         file.path,
         symbols,
         structFields,
         needsStructKeyword,
+        enumBitWidth,
       );
     }
   }
 
   /**
-   * Parse a C header using dual-parse strategy
+   * Issue #208: Parse a C header using single-parser strategy
+   * Uses heuristic detection to choose the appropriate parser
    */
   private parseCHeader(content: string, filePath: string): void {
-    let cSymbols: ISymbol[] = [];
-    let cppSymbols: ISymbol[] = [];
+    if (detectCppSyntax(content)) {
+      // Use C++14 parser for headers with C++ syntax (typed enums, classes, etc.)
+      this.parseCppHeader(content, filePath);
+    } else {
+      // Use C parser for pure C headers
+      this.parsePureCHeader(content, filePath);
+    }
+  }
 
-    // Try C parser first
+  /**
+   * Issue #208: Parse a pure C header (no C++ syntax detected)
+   */
+  private parsePureCHeader(content: string, filePath: string): void {
     try {
       const charStream = CharStream.fromString(content);
       const lexer = new CLexer(charStream);
@@ -382,36 +395,12 @@ class Pipeline {
 
       const tree = parser.compilationUnit();
       const collector = new CSymbolCollector(filePath, this.symbolTable);
-      cSymbols = collector.collect(tree);
-    } catch {
-      // C parser failed
-    }
-
-    // Also try C++ parser for better C++11 support
-    try {
-      const cppCharStream = CharStream.fromString(content);
-      const cppLexer = new CPP14Lexer(cppCharStream);
-      const cppTokenStream = new CommonTokenStream(cppLexer);
-      const cppParser = new CPP14Parser(cppTokenStream);
-      cppParser.removeErrorListeners();
-
-      const cppTree = cppParser.translationUnit();
-      const cppCollector = new CppSymbolCollector(filePath, this.symbolTable);
-      cppSymbols = cppCollector.collect(cppTree);
+      const symbols = collector.collect(tree);
+      if (symbols.length > 0) {
+        this.symbolTable.addSymbols(symbols);
+      }
     } catch {
-      // C++ parser failed
-    }
-
-    // Merge symbols: prefer C++ but supplement with C-only symbols
-    const cppSymbolNames = new Set(cppSymbols.map((s) => s.name));
-    const additionalSymbols = cSymbols.filter(
-      (s) => !cppSymbolNames.has(s.name),
-    );
-
-    const allSymbols = [...cppSymbols, ...additionalSymbols];
-
-    if (allSymbols.length > 0) {
-      this.symbolTable.addSymbols(allSymbols);
+      // Silently ignore parse errors in headers
     }
   }
 
@@ -961,6 +950,31 @@ class Pipeline {
     const allNeedsKeyword = this.symbolTable.getAllNeedsStructKeyword();
     return structNames.filter((name) => allNeedsKeyword.includes(name));
   }
+
+  /**
+   * Issue #208: Extract enum bit widths for a specific file
+   * Returns enum bit widths for enums defined in that file
+   */
+  private extractEnumBitWidthsForFile(filePath: string): Map<string, number> {
+    const result = new Map<string, number>();
+
+    // Get enum names defined in this file
+    const fileSymbols = this.symbolTable.getSymbolsByFile(filePath);
+    const enumNames = fileSymbols
+      .filter((s) => s.kind === "enum")
+      .map((s) => s.name);
+
+    // Get bit widths for each enum
+    const allBitWidths = this.symbolTable.getAllEnumBitWidths();
+    for (const enumName of enumNames) {
+      const width = allBitWidths.get(enumName);
+      if (width !== undefined) {
+        result.set(enumName, width);
+      }
+    }
+
+    return result;
+  }
 }
 
 export default Pipeline;

package/src/pipeline/detectCppSyntax.ts

@@ -0,0 +1,42 @@
+/**
+ * Issue #208: Detect if header content contains C++ syntax requiring C++14 parser
+ *
+ * This heuristic determines whether to parse a .h file with the C or C++ parser.
+ * Previously, the pipeline would parse ALL .h files with BOTH parsers and merge,
+ * which was wasteful and led to issues with C++-specific features like typed enums.
+ *
+ * C++ indicators:
+ * - Typed enums: enum Name : type { ... }
+ * - Class/struct inheritance: class Foo : public Bar
+ * - Namespaces: namespace Foo { ... }
+ * - Templates: template<...>
+ * - Access specifiers: public:, private:, protected:
+ */
+
+/**
+ * Detect if header content contains C++ syntax requiring C++14 parser
+ * @param content Raw header file content
+ * @returns true if C++ parser should be used, false for C parser
+ */
+function detectCppSyntax(content: string): boolean {
+  // Typed enums: enum Name : type { (C++14 feature, key for Issue #208)
+  if (/enum\s+\w+\s*:\s*\w+\s*\{/.test(content)) return true;
+
+  // Class/struct with inheritance: class Foo : public/private/protected Bar
+  if (/\b(class|struct)\s+\w+\s*:\s*(public|private|protected)/.test(content))
+    return true;
+
+  // namespace keyword: namespace Foo {
+  if (/\bnamespace\s+\w+/.test(content)) return true;
+
+  // template declarations: template<...>
+  if (/\btemplate\s*</.test(content)) return true;
+
+  // Access specifiers at line start (class members)
+  if (/^\s*(public|private|protected)\s*:/m.test(content)) return true;
+
+  // Default to C parser for pure C headers
+  return false;
+}
+
+export default detectCppSyntax;

package/src/pipeline/types/ICachedFileEntry.ts

@@ -16,6 +16,8 @@ interface ICachedFileEntry {
   structFields: Record<string, Record<string, IStructFieldInfo>>;
   /** Issue #196 Bug 3: Struct names requiring 'struct' keyword in C */
   needsStructKeyword?: string[];
+  /** Issue #208: Enum bit widths from typed enums (enum name -> bit width) */
+  enumBitWidth?: Record<string, number>;
 }
 
 export default ICachedFileEntry;

package/src/symbols/CppSymbolCollector.ts

@@ -384,6 +384,66 @@ class CppSymbolCollector {
       isExported: true,
       parent: this.currentNamespace,
     });
+
+    // Issue #208: Extract enum backing type for typed enums (e.g., enum EPressureType : uint8_t)
+    if (this.symbolTable) {
+      const enumbase = enumHead.enumbase?.();
+      if (enumbase) {
+        const typeSpecSeq = enumbase.typeSpecifierSeq?.();
+        if (typeSpecSeq) {
+          const typeName = typeSpecSeq.getText();
+          const bitWidth = this.getTypeWidth(typeName);
+          if (bitWidth > 0) {
+            this.symbolTable.addEnumBitWidth(fullName, bitWidth);
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Issue #208: Map C/C++ type names to their bit widths
+   * Supports standard integer types used as enum backing types
+   */
+  private getTypeWidth(typeName: string): number {
+    const typeWidths: Record<string, number> = {
+      // stdint.h types
+      uint8_t: 8,
+      int8_t: 8,
+      uint16_t: 16,
+      int16_t: 16,
+      uint32_t: 32,
+      int32_t: 32,
+      uint64_t: 64,
+      int64_t: 64,
+      // Standard C types (common sizes)
+      char: 8,
+      "signed char": 8,
+      "unsigned char": 8,
+      short: 16,
+      "short int": 16,
+      "signed short": 16,
+      "signed short int": 16,
+      "unsigned short": 16,
+      "unsigned short int": 16,
+      int: 32,
+      "signed int": 32,
+      unsigned: 32,
+      "unsigned int": 32,
+      long: 32,
+      "long int": 32,
+      "signed long": 32,
+      "signed long int": 32,
+      "unsigned long": 32,
+      "unsigned long int": 32,
+      "long long": 64,
+      "long long int": 64,
+      "signed long long": 64,
+      "signed long long int": 64,
+      "unsigned long long": 64,
+      "unsigned long long int": 64,
+    };
+    return typeWidths[typeName] ?? 0;
   }
 
   // Helper methods

package/src/symbols/SymbolTable.ts

@@ -33,6 +33,12 @@ class SymbolTable {
    */
   private needsStructKeyword: Set<string> = new Set();
 
+  /**
+   * Issue #208: Track enum backing type bit widths
+   * C++14 typed enums: enum Name : uint8_t { ... } have explicit bit widths
+   */
+  private enumBitWidth: Map<string, number> = new Map();
+
   /**
    * Add a symbol to the table
    */
@@ -237,6 +243,42 @@ class SymbolTable {
     }
   }
 
+  /**
+   * Issue #208: Add enum bit width for a typed enum
+   * @param enumName Name of the enum (e.g., "EPressureType")
+   * @param bitWidth Bit width from backing type (e.g., 8 for uint8_t)
+   */
+  addEnumBitWidth(enumName: string, bitWidth: number): void {
+    this.enumBitWidth.set(enumName, bitWidth);
+  }
+
+  /**
+   * Issue #208: Get enum bit width for a typed enum
+   * @param enumName Name of the enum
+   * @returns Bit width or undefined if not a typed enum
+   */
+  getEnumBitWidth(enumName: string): number | undefined {
+    return this.enumBitWidth.get(enumName);
+  }
+
+  /**
+   * Issue #208: Get all enum bit widths for cache serialization
+   * @returns Map of enum name -> bit width
+   */
+  getAllEnumBitWidths(): Map<string, number> {
+    return this.enumBitWidth;
+  }
+
+  /**
+   * Issue #208: Restore enum bit widths from cache
+   * @param bitWidths Map of enum name -> bit width
+   */
+  restoreEnumBitWidths(bitWidths: Map<string, number>): void {
+    for (const [enumName, width] of bitWidths) {
+      this.enumBitWidth.set(enumName, width);
+    }
+  }
+
   /**
    * Get all fields for a struct
    * @param structName Name of the struct
@@ -301,6 +343,8 @@ class SymbolTable {
     this.symbols.clear();
     this.byFile.clear();
     this.structFields.clear();
+    this.needsStructKeyword.clear();
+    this.enumBitWidth.clear();
   }
 
   /**