c-next 0.2.9 → 0.2.10

package/package.json

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

package/src/transpiler/Transpiler.ts

@@ -214,7 +214,8 @@ class Transpiler {
     result: ITranspilerResult,
   ): Promise<void> {
     // Stage 2: Collect symbols from C/C++ headers and build analyzer context
-    this._collectAllHeaderSymbols(input.headerFiles, result);
+    // Issue #945: Now async for preprocessing support
+    await this._collectAllHeaderSymbols(input.headerFiles, result);
     CodeGenState.buildExternalStructFields();
 
     // Stage 3: Collect symbols from C-Next files
@@ -365,6 +366,16 @@ class Transpiler {
         );
       }
 
+      // Issue #948: Merge opaque types from C/C++ headers
+      // These are forward-declared struct types that need pointer semantics
+      const externalOpaqueTypes = CodeGenState.symbolTable.getAllOpaqueTypes();
+      if (externalOpaqueTypes.length > 0) {
+        symbolInfo = TSymbolInfoAdapter.mergeOpaqueTypes(
+          symbolInfo,
+          externalOpaqueTypes,
+        );
+      }
+
       // Make symbols available to analyzers (CodeGenerator.generate() sets this too)
       CodeGenState.symbols = symbolInfo;
 
@@ -596,14 +607,15 @@ class Transpiler {
 
   /**
    * Stage 2: Collect symbols from all C/C++ headers
+   * Issue #945: Made async for preprocessing support.
    */
-  private _collectAllHeaderSymbols(
+  private async _collectAllHeaderSymbols(
     headerFiles: IDiscoveredFile[],
     result: ITranspilerResult,
-  ): void {
+  ): Promise<void> {
     for (const file of headerFiles) {
       try {
-        this.doCollectHeaderSymbols(file);
+        await this.doCollectHeaderSymbols(file);
         result.filesProcessed++;
       } catch (err) {
         this.warnings.push(`Failed to process header ${file.path}: ${err}`);
@@ -989,9 +1001,10 @@ class Transpiler {
   /**
    * Stage 2: Collect symbols from a single C/C++ header
    * Issue #592: Recursive include processing moved to IncludeResolver.resolveHeadersTransitively()
+   * Issue #945: Added preprocessing support for conditional compilation
    * SonarCloud S3776: Refactored to use helper methods for reduced complexity.
    */
-  private doCollectHeaderSymbols(file: IDiscoveredFile): void {
+  private async doCollectHeaderSymbols(file: IDiscoveredFile): Promise<void> {
     // Track as processed (for cycle detection)
     const absolutePath = resolve(file.path);
     this.state.markHeaderProcessed(absolutePath);
@@ -1001,8 +1014,8 @@ class Transpiler {
       return; // Cache hit - skip full parsing
     }
 
-    // Read content and parse
-    const content = this.fs.readFile(file.path);
+    // Issue #945: Preprocess header to evaluate #if/#ifdef directives
+    const content = await this.getHeaderContent(file);
     this.parseHeaderFile(file, content);
 
     // Debug: Show symbols found
@@ -1043,12 +1056,89 @@ class Transpiler {
     );
     CodeGenState.symbolTable.restoreEnumBitWidths(cached.enumBitWidth);
 
+    // Issue #948: Restore opaque types (forward-declared structs)
+    CodeGenState.symbolTable.restoreOpaqueTypes(cached.opaqueTypes);
+
     // Issue #211: Still check for C++ syntax even on cache hit
     this.detectCppFromFileType(file);
 
     return true;
   }
 
+  /**
+   * Get header content, optionally preprocessed.
+   * Issue #945: Evaluates #if/#ifdef directives using system preprocessor.
+   *
+   * Only preprocesses when necessary to avoid side effects from full expansion.
+   * Preprocessing is needed when the file has conditional compilation patterns
+   * like #if MACRO != 0 that require expression evaluation.
+   */
+  private async getHeaderContent(file: IDiscoveredFile): Promise<string> {
+    const rawContent = this.fs.readFile(file.path);
+
+    // Check if preprocessing is disabled
+    if (this.config.preprocess === false) {
+      return rawContent;
+    }
+
+    // Check if preprocessing is available
+    if (!this.preprocessor.isAvailable()) {
+      return rawContent;
+    }
+
+    // Issue #945: Only preprocess if file has conditional compilation patterns
+    // that require expression evaluation (e.g., #if MACRO != 0, #if MACRO == 1)
+    // Simple #ifdef/#ifndef patterns are already handled by the parser
+    if (!this.needsConditionalPreprocessing(rawContent)) {
+      return rawContent;
+    }
+
+    // Preprocess the header file
+    const result = await this.preprocessor.preprocess(file.path, {
+      defines: this.config.defines,
+      includePaths: this.config.includeDirs,
+      keepLineDirectives: false, // We don't need line mappings for symbol collection
+    });
+
+    if (!result.success) {
+      // Log warning but fall back to raw content
+      this.warnings.push(
+        `Preprocessing failed for ${file.path}: ${result.error}. Using raw content.`,
+      );
+      return rawContent;
+    }
+
+    return result.content;
+  }
+
+  /**
+   * Check if a header file needs conditional preprocessing.
+   * Issue #945: Only preprocess files with #if expressions that need evaluation.
+   */
+  private needsConditionalPreprocessing(content: string): boolean {
+    // Patterns that require the preprocessor for expression evaluation:
+    // - #if MACRO != 0
+    // - #if MACRO == 1
+    // - #if MACRO > 0
+    // - #if MACRO (bare macro as truthy check)
+    // - #elif MACRO != 0
+    // - #if defined(X) && MACRO
+    // - etc.
+    //
+    // Simple patterns handled by the parser without preprocessing:
+    // - #ifdef MACRO
+    // - #ifndef MACRO
+    // - #if defined(MACRO) (single defined check)
+    // - #if 1
+    // - #if 0
+    //
+    // Look for #if/#elif followed by an expression (not just defined() or 0/1)
+    // Also match bare macro names used as truthy checks (common in config headers)
+    const ifExpressionPattern =
+      /#(?:if|elif)\s+(?!defined\s*\()(?![01]\s*(?:$|\n|\/\*|\/\/))\w+/m;
+    return ifExpressionPattern.test(content);
+  }
+
   /**
    * Restore cached symbols to the symbol table.
    * ADR-055 Phase 7: Converts ISerializedSymbol[] from cache to typed symbols.

package/src/transpiler/__tests__/Transpiler.coverage.test.ts

@@ -1239,4 +1239,174 @@ describe("Transpiler coverage integration tests", () => {
     expect(result.outputFiles.some((f) => f.endsWith(".c"))).toBe(true);
     expect(result.outputFiles.some((f) => f.endsWith(".h"))).toBe(true);
   });
+
+  // ==========================================================================
+  // Issue #945: getHeaderContent preprocessing tests
+  // ==========================================================================
+
+  it("skips preprocessing when preprocess config is false", async () => {
+    const srcDir = join(testDir, "src");
+    const includeDir = join(testDir, "include");
+    mkdirSync(srcDir, { recursive: true });
+    mkdirSync(includeDir, { recursive: true });
+
+    // Create a header with conditional that would trigger preprocessing
+    writeFileSync(
+      join(includeDir, "config.h"),
+      `
+      #if FEATURE_ENABLED != 0
+      void enabled_func(void);
+      #endif
+      void always_available(void);
+    `,
+    );
+
+    writeFileSync(
+      join(srcDir, "main.cnx"),
+      `
+      #include "config.h"
+      void test() { always_available(); }
+    `,
+    );
+
+    const transpiler = new Transpiler({
+      inputs: [join(srcDir, "main.cnx")],
+      includeDirs: [includeDir],
+      preprocess: false, // Explicitly disable preprocessing
+      noCache: true,
+    });
+
+    const result = await transpiler.transpile({ kind: "files" });
+    expect(result.success).toBe(true);
+  });
+
+  it("handles header without conditional patterns (no preprocessing needed)", async () => {
+    const srcDir = join(testDir, "src");
+    const includeDir = join(testDir, "include");
+    mkdirSync(srcDir, { recursive: true });
+    mkdirSync(includeDir, { recursive: true });
+
+    // Create a simple header without #if MACRO patterns
+    writeFileSync(
+      join(includeDir, "simple.h"),
+      `
+      #ifndef SIMPLE_H
+      #define SIMPLE_H
+      void simple_func(void);
+      #endif
+    `,
+    );
+
+    writeFileSync(
+      join(srcDir, "main.cnx"),
+      `
+      #include "simple.h"
+      void test() { simple_func(); }
+    `,
+    );
+
+    const transpiler = new Transpiler({
+      inputs: [join(srcDir, "main.cnx")],
+      includeDirs: [includeDir],
+      noCache: true,
+    });
+
+    const result = await transpiler.transpile({ kind: "files" });
+    expect(result.success).toBe(true);
+  });
+
+  it("preprocesses header with conditional patterns when preprocessor available", async () => {
+    const srcDir = join(testDir, "src");
+    const includeDir = join(testDir, "include");
+    mkdirSync(srcDir, { recursive: true });
+    mkdirSync(includeDir, { recursive: true });
+
+    // Create a config header that defines the feature
+    writeFileSync(
+      join(includeDir, "config.h"),
+      `
+      #ifndef CONFIG_H
+      #define CONFIG_H
+      #define MY_FEATURE 1
+      #endif
+    `,
+    );
+
+    // Create a header with #if MACRO != 0 pattern that needs preprocessing
+    writeFileSync(
+      join(includeDir, "feature.h"),
+      `
+      #ifndef FEATURE_H
+      #define FEATURE_H
+      #include "config.h"
+
+      void always_available(void);
+
+      #if MY_FEATURE != 0
+      void feature_func(void);
+      #endif
+      #endif
+    `,
+    );
+
+    writeFileSync(
+      join(srcDir, "main.cnx"),
+      `
+      #include "feature.h"
+      void test() { always_available(); }
+    `,
+    );
+
+    const transpiler = new Transpiler({
+      inputs: [join(srcDir, "main.cnx")],
+      includeDirs: [includeDir],
+      noCache: true,
+    });
+
+    const result = await transpiler.transpile({ kind: "files" });
+    expect(result.success).toBe(true);
+  });
+
+  it("falls back to raw content when preprocessing fails (invalid include)", async () => {
+    const srcDir = join(testDir, "src");
+    const includeDir = join(testDir, "include");
+    mkdirSync(srcDir, { recursive: true });
+    mkdirSync(includeDir, { recursive: true });
+
+    // Create a header that includes a non-existent file (will cause preprocessing to fail)
+    writeFileSync(
+      join(includeDir, "broken.h"),
+      `
+      #ifndef BROKEN_H
+      #define BROKEN_H
+      #include "nonexistent_config.h"
+
+      #if SOME_MACRO != 0
+      void some_func(void);
+      #endif
+
+      void available_func(void);
+      #endif
+    `,
+    );
+
+    writeFileSync(
+      join(srcDir, "main.cnx"),
+      `
+      #include "broken.h"
+      void test() { available_func(); }
+    `,
+    );
+
+    const transpiler = new Transpiler({
+      inputs: [join(srcDir, "main.cnx")],
+      includeDirs: [includeDir],
+      noCache: true,
+    });
+
+    // Should succeed even if preprocessing fails (falls back to raw content)
+    const result = await transpiler.transpile({ kind: "files" });
+    // The transpiler should still succeed and add a warning
+    expect(result.success).toBe(true);
+  });
 });

package/src/transpiler/__tests__/needsConditionalPreprocessing.test.ts

@@ -0,0 +1,246 @@
+/**
+ * Unit tests for needsConditionalPreprocessing detection logic
+ * Issue #945: Tests the regex pattern that determines when header files
+ * need preprocessing for conditional compilation evaluation.
+ *
+ * Since needsConditionalPreprocessing is a private method, we test it
+ * via a subclass that exposes it for testing purposes.
+ */
+
+import { describe, it, expect } from "vitest";
+import Transpiler from "../Transpiler";
+import MockFileSystem from "./MockFileSystem";
+
+/**
+ * Test subclass that exposes the private needsConditionalPreprocessing method
+ */
+class TestableTranspiler extends Transpiler {
+  testNeedsConditionalPreprocessing(content: string): boolean {
+    // Access private method via type casting
+    return (
+      this as unknown as {
+        needsConditionalPreprocessing: (s: string) => boolean;
+      }
+    ).needsConditionalPreprocessing(content);
+  }
+}
+
+describe("needsConditionalPreprocessing", () => {
+  let transpiler: TestableTranspiler;
+
+  beforeEach(() => {
+    transpiler = new TestableTranspiler(
+      { inputs: [], noCache: true },
+      new MockFileSystem(),
+    );
+  });
+
+  describe("patterns that SHOULD trigger preprocessing", () => {
+    it("detects #if MACRO != 0", () => {
+      const content = `
+        #if FEATURE_LABEL != 0
+        void create_label(void);
+        #endif
+      `;
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(true);
+    });
+
+    it("detects #if MACRO == 1", () => {
+      const content = `
+        #if DEBUG_ENABLED == 1
+        void debug_log(const char* msg);
+        #endif
+      `;
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(true);
+    });
+
+    it("detects #if MACRO > 0", () => {
+      const content = `
+        #if LOG_LEVEL > 0
+        void log_debug(const char* msg);
+        #endif
+      `;
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(true);
+    });
+
+    it("detects bare #if MACRO (truthy check)", () => {
+      const content = `
+        #if FEATURE_ENABLED
+        void do_feature(void);
+        #endif
+      `;
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(true);
+    });
+
+    it("detects #elif MACRO != 0", () => {
+      const content = `
+        #if FEATURE_A
+        void feature_a(void);
+        #elif FEATURE_B != 0
+        void feature_b(void);
+        #endif
+      `;
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(true);
+    });
+
+    it("detects #elif with bare macro", () => {
+      const content = `
+        #ifdef FEATURE_A
+        void feature_a(void);
+        #elif FEATURE_B
+        void feature_b(void);
+        #endif
+      `;
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(true);
+    });
+
+    it("detects #if with arithmetic expression", () => {
+      const content = `
+        #if MAJOR_VERSION >= 2
+        void new_api(void);
+        #endif
+      `;
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(true);
+    });
+
+    it("does not trigger for #if defined(X) && macro (starts with defined)", () => {
+      // The regex is conservative: if the line starts with defined(),
+      // we assume the parser can handle it. Complex expressions like
+      // defined(X) && MACRO > 1 are rare enough that this trade-off is acceptable.
+      const content = `
+        #if defined(FEATURE_X) && FEATURE_LEVEL > 1
+        void advanced_feature(void);
+        #endif
+      `;
+      // Current regex doesn't match this because it starts with defined()
+      // This is a known limitation, but acceptable for most real-world headers
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(false);
+    });
+  });
+
+  describe("patterns that should NOT trigger preprocessing", () => {
+    it("does not trigger for #ifdef MACRO", () => {
+      const content = `
+        #ifdef FEATURE_ENABLED
+        void do_feature(void);
+        #endif
+      `;
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(false);
+    });
+
+    it("does not trigger for #ifndef MACRO", () => {
+      const content = `
+        #ifndef HEADER_GUARD_H
+        #define HEADER_GUARD_H
+        void foo(void);
+        #endif
+      `;
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(false);
+    });
+
+    it("does not trigger for #if defined(MACRO)", () => {
+      const content = `
+        #if defined(FEATURE_X)
+        void feature_x(void);
+        #endif
+      `;
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(false);
+    });
+
+    it("does not trigger for #if 0", () => {
+      const content = `
+        #if 0
+        // disabled code
+        void old_api(void);
+        #endif
+      `;
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(false);
+    });
+
+    it("does not trigger for #if 1", () => {
+      const content = `
+        #if 1
+        void always_enabled(void);
+        #endif
+      `;
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(false);
+    });
+
+    it("does not trigger for plain declarations without conditionals", () => {
+      const content = `
+        void foo(void);
+        void bar(int x);
+        typedef struct widget_s widget_t;
+      `;
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(false);
+    });
+
+    it("does not trigger for #if 0 with comment", () => {
+      const content = `
+        #if 0 // disabled
+        void disabled(void);
+        #endif
+      `;
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(false);
+    });
+
+    it("does not trigger for #if 1 with comment", () => {
+      const content = `
+        #if 1 /* always on */
+        void enabled(void);
+        #endif
+      `;
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(false);
+    });
+  });
+
+  describe("edge cases", () => {
+    it("handles mixed ifdef and if MACRO patterns", () => {
+      const content = `
+        #ifdef PLATFORM_LINUX
+        void linux_init(void);
+        #endif
+
+        #if DEBUG_LEVEL != 0
+        void debug_init(void);
+        #endif
+      `;
+      // Should trigger because of the #if DEBUG_LEVEL != 0 pattern
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(true);
+    });
+
+    it("handles LVGL-style config patterns", () => {
+      // Real-world pattern from LVGL headers
+      const content = `
+        #if LV_USE_LABEL != 0
+        lv_obj_t* lv_label_create(lv_obj_t* parent);
+        #endif
+      `;
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(true);
+    });
+
+    it("handles FreeRTOS-style config patterns", () => {
+      // Real-world pattern from FreeRTOS headers
+      const content = `
+        #if configUSE_MUTEXES == 1
+        SemaphoreHandle_t xSemaphoreCreateMutex(void);
+        #endif
+      `;
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(true);
+    });
+
+    it("handles whitespace variations in #if", () => {
+      const content = `
+        #if   FEATURE_X
+        void feature(void);
+        #endif
+      `;
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(true);
+    });
+
+    it("handles tab in #if directive", () => {
+      const content = "#if\tFEATURE_X\nvoid feature(void);\n#endif";
+      expect(transpiler.testNeedsConditionalPreprocessing(content)).toBe(true);
+    });
+  });
+});

package/src/transpiler/logic/analysis/ArrayIndexTypeAnalyzer.ts

@@ -127,6 +127,11 @@ class IndexTypeListener extends CNextListener {
         continue;
       }
 
+      // Enum types are valid indices (ADR-054: transpile to unsigned constants)
+      if (CodeGenState.isKnownEnum(resolvedType)) {
+        continue;
+      }
+
       // Other non-integer types (e.g., string, struct) - E0852
       const { line, column } = ParserUtils.getPosition(ctx);
       this.analyzer.addError(line, column, "E0852", resolvedType);
@@ -277,7 +282,13 @@ class IndexTypeListener extends CNextListener {
       if (TypeConstants.SIGNED_TYPES.includes(currentType)) {
         return "bool";
       }
-      // Array element type — strip array suffix
+      // Array element type — strip rightmost array dimension
+      // e.g., "u8[8]" → "u8", "u8[8][4]" → "u8[8]", "u8[CONST]" → "u8"
+      const strippedType = currentType.replace(/\[[^\]]*\]$/, "");
+      if (strippedType !== currentType) {
+        return strippedType;
+      }
+      // Not an array type (e.g., struct), return as-is
       return currentType;
     }