c-next 0.2.14 → 0.2.15

package/package.json

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

package/src/transpiler/logic/symbols/c/__tests__/CResolver.integration.test.ts

@@ -182,6 +182,34 @@ describe("CResolver - Variable Declarations", () => {
       }
     });
   });
+
+  it("detects pointer type in variable declaration (Issue #978)", () => {
+    const tree = TestHelpers.parseC(
+      `typedef struct { int x; } point_t;\nextern const point_t *origin;`,
+    );
+    const result = CResolver.resolve(tree!, "test.h");
+
+    const varSymbol = result.symbols.find((s) => s.name === "origin");
+    expect(varSymbol).toBeDefined();
+    expect(varSymbol?.kind).toBe("variable");
+    if (varSymbol?.kind === "variable") {
+      expect(varSymbol.type).toBe("point_t*");
+    }
+  });
+
+  it("does not add pointer suffix for non-pointer variables (Issue #978)", () => {
+    const tree = TestHelpers.parseC(
+      `typedef struct { int x; } point_t;\nextern const point_t origin;`,
+    );
+    const result = CResolver.resolve(tree!, "test.h");
+
+    const varSymbol = result.symbols.find((s) => s.name === "origin");
+    expect(varSymbol).toBeDefined();
+    expect(varSymbol?.kind).toBe("variable");
+    if (varSymbol?.kind === "variable") {
+      expect(varSymbol.type).toBe("point_t");
+    }
+  });
 });
 
 describe("CResolver - Typedefs", () => {

package/src/transpiler/logic/symbols/c/collectors/VariableCollector.ts

@@ -32,6 +32,13 @@ class VariableCollector {
       ? DeclaratorUtils.extractArrayDimensions(declarator)
       : [];
 
+    // Issue #978: Detect pointer variables (e.g., `font_t *ptr`).
+    // C grammar puts `*` in the declarator, not the type specifier.
+    // Same pattern as FunctionCollector._resolveReturnType().
+    const hasPointer =
+      declarator?.pointer?.() !== null && declarator?.pointer?.() !== undefined;
+    const resolvedType = hasPointer ? `${baseType}*` : baseType;
+
     return {
       kind: "variable",
       name,
@@ -39,7 +46,7 @@ class VariableCollector {
       sourceLine: line,
       sourceLanguage: ESourceLanguage.C,
       isExported: !isExtern,
-      type: baseType,
+      type: resolvedType,
       isArray: arrayDimensions.length > 0,
       arrayDimensions: arrayDimensions.length > 0 ? arrayDimensions : undefined,
       isExtern,
@@ -50,6 +57,10 @@ class VariableCollector {
    * Collect a variable from declaration specifiers (when identifier appears as typedefName).
    * This handles the C grammar ambiguity where variable names can be parsed as typedef names.
    *
+   * Note: No pointer detection here — this path handles declarations without an
+   * initDeclaratorList. Pointer declarations (e.g., `font_t *ptr`) always produce
+   * an initDeclaratorList (the `*` creates a declarator), so they go through collect().
+   *
    * @param name Variable name
    * @param baseType Variable type
    * @param sourceFile Source file path

package/src/transpiler/state/CodeGenState.ts

@@ -554,13 +554,31 @@ export default class CodeGenState {
     }
 
     // ADR-055 Phase 7: Fall back to SymbolTable for cross-file C-Next variables only.
-    // C/C++ header symbols don't have complete type info (e.g., isArray),
-    // so we only use C-Next TSymbols from SymbolTable.
     const symbol = this.symbolTable.getTSymbol(name);
     if (symbol?.kind === "variable" && symbol.type) {
       return this.convertTSymbolToTypeInfo(symbol);
     }
 
+    // Issue #978: Fall back to C symbols for external struct globals from .h headers.
+    // Only return type info for struct-typed variables — returning info for all
+    // C types would cause regressions (e.g., array indexing misread as bit extraction).
+    const cSymbol = this.symbolTable.getCSymbol(name);
+    if (cSymbol?.kind === "variable" && cSymbol.type) {
+      const baseType = CodeGenState.stripTrailingPointers(cSymbol.type);
+      if (
+        this.symbolTable.isTypedefStructType(baseType) ||
+        this.symbolTable.getStructFields(baseType)
+      ) {
+        return {
+          baseType,
+          bitWidth: 0,
+          isArray: cSymbol.isArray || false,
+          isConst: cSymbol.isConst || false,
+          isPointer: cSymbol.type.endsWith("*"),
+        };
+      }
+    }
+
     return undefined;
   }
 
@@ -581,7 +599,19 @@ export default class CodeGenState {
       return true;
     }
     const symbol = this.symbolTable.getTSymbol(name);
-    return symbol?.kind === "variable" && symbol.type !== undefined;
+    if (symbol?.kind === "variable" && symbol.type !== undefined) {
+      return true;
+    }
+    // Issue #978: Check C symbols for external struct globals only
+    const cSymbol = this.symbolTable.getCSymbol(name);
+    if (cSymbol?.kind === "variable" && cSymbol.type) {
+      const baseType = CodeGenState.stripTrailingPointers(cSymbol.type);
+      return (
+        this.symbolTable.isTypedefStructType(baseType) ||
+        !!this.symbolTable.getStructFields(baseType)
+      );
+    }
+    return false;
   }
 
   /**
@@ -611,6 +641,18 @@ export default class CodeGenState {
    * Convert a TSymbol IVariableSymbol to TTypeInfo for unified type lookups.
    * ADR-055 Phase 7: Works with typed TSymbol instead of ISymbol.
    */
+  /**
+   * Strip trailing pointer stars from a C type string (e.g., "font_t*" → "font_t").
+   * Uses string operations instead of regex to avoid SonarCloud ReDoS flag (S5852).
+   */
+  private static stripTrailingPointers(type: string): string {
+    let end = type.length;
+    while (end > 0 && type[end - 1] === "*") {
+      end--;
+    }
+    return type.slice(0, end).trim();
+  }
+
   private static convertTSymbolToTypeInfo(
     symbol: import("../types/symbols/IVariableSymbol").default,
   ): TTypeInfo {

package/src/transpiler/state/__tests__/CodeGenState.test.ts

@@ -105,6 +105,7 @@ function createMockSymbols(
 describe("CodeGenState", () => {
   beforeEach(() => {
     CodeGenState.reset();
+    CodeGenState.symbolTable.clear();
   });
 
   describe("reset()", () => {
@@ -435,8 +436,8 @@ describe("CodeGenState", () => {
       expect(result?.arrayDimensions).toEqual([10]);
     });
 
-    it("getVariableTypeInfo does not use C header symbols", () => {
-      // Add a C header variable (should NOT be used)
+    it("getVariableTypeInfo does not use C header symbols for primitive types", () => {
+      // Add a C header variable with primitive type (should NOT be used)
       CodeGenState.symbolTable.addCSymbol(
         createCVariableSymbol({
           name: "cHeaderVar",
@@ -447,6 +448,110 @@ describe("CodeGenState", () => {
       expect(CodeGenState.getVariableTypeInfo("cHeaderVar")).toBeUndefined();
     });
 
+    it("getVariableTypeInfo returns type info for C header struct variables (Issue #978)", () => {
+      // Register font_t as a typedef struct type
+      CodeGenState.symbolTable.markTypedefStructType("font_t", "fake_lib.h");
+
+      // Add a C header variable with struct type
+      CodeGenState.symbolTable.addCSymbol(
+        createCVariableSymbol({
+          name: "big_font",
+          type: "font_t",
+          isConst: true,
+        }),
+      );
+
+      const result = CodeGenState.getVariableTypeInfo("big_font");
+      expect(result).toBeDefined();
+      expect(result?.baseType).toBe("font_t");
+      expect(result?.isConst).toBe(true);
+      expect(result?.bitWidth).toBe(0);
+      expect(result?.isPointer).toBe(false);
+    });
+
+    it("getVariableTypeInfo returns type info for C struct via getStructFields path (Issue #978)", () => {
+      // Register struct fields directly (non-typedef struct, e.g., `struct point`)
+      CodeGenState.symbolTable.addStructField("point", "x", "int32_t");
+      CodeGenState.symbolTable.addStructField("point", "y", "int32_t");
+
+      CodeGenState.symbolTable.addCSymbol(
+        createCVariableSymbol({
+          name: "origin",
+          type: "point",
+        }),
+      );
+
+      const result = CodeGenState.getVariableTypeInfo("origin");
+      expect(result).toBeDefined();
+      expect(result?.baseType).toBe("point");
+      expect(result?.bitWidth).toBe(0);
+    });
+
+    it("getVariableTypeInfo detects pointer type from C symbol (Issue #978)", () => {
+      // Register font_t as a struct
+      CodeGenState.symbolTable.markTypedefStructType("font_t", "lib.h");
+
+      // Pointer variable: type includes * (set by VariableCollector)
+      CodeGenState.symbolTable.addCSymbol(
+        createCVariableSymbol({
+          name: "font_ptr",
+          type: "font_t*",
+        }),
+      );
+
+      const result = CodeGenState.getVariableTypeInfo("font_ptr");
+      expect(result).toBeDefined();
+      expect(result?.baseType).toBe("font_t");
+      expect(result?.isPointer).toBe(true);
+    });
+
+    it("getVariableTypeInfo ignores C array variables with primitive types", () => {
+      CodeGenState.symbolTable.addCSymbol(
+        createCVariableSymbol({
+          name: "lookup_table",
+          type: "uint8_t",
+          isArray: true,
+          arrayDimensions: [16],
+        }),
+      );
+
+      expect(CodeGenState.getVariableTypeInfo("lookup_table")).toBeUndefined();
+    });
+
+    it("getVariableTypeInfo ignores C volatile register variables", () => {
+      CodeGenState.symbolTable.addCSymbol(
+        createCVariableSymbol({
+          name: "status_reg",
+          type: "uint32_t",
+        }),
+      );
+
+      expect(CodeGenState.getVariableTypeInfo("status_reg")).toBeUndefined();
+    });
+
+    it("getVariableTypeInfo prefers TSymbol over CSymbol with same name (Issue #978)", () => {
+      // Both C-Next and C symbols exist with same name
+      CodeGenState.symbolTable.markTypedefStructType("config_t", "config.h");
+
+      CodeGenState.symbolTable.addTSymbol(
+        createCNextVariableSymbol({
+          name: "config",
+          type: TTypeUtils.createPrimitive("u32"),
+        }),
+      );
+
+      CodeGenState.symbolTable.addCSymbol(
+        createCVariableSymbol({
+          name: "config",
+          type: "config_t",
+        }),
+      );
+
+      // TSymbol should win (checked first in priority order)
+      const result = CodeGenState.getVariableTypeInfo("config");
+      expect(result?.baseType).toBe("u32");
+    });
+
     it("getVariableTypeInfo prefers local registry over SymbolTable", () => {
       // Add both local and SymbolTable version
       const localInfo: TTypeInfo = {
@@ -496,7 +601,7 @@ describe("CodeGenState", () => {
       expect(CodeGenState.hasVariableTypeInfo("unknownVar")).toBe(false);
     });
 
-    it("hasVariableTypeInfo returns false for C header variable", () => {
+    it("hasVariableTypeInfo returns false for C header primitive variable", () => {
       CodeGenState.symbolTable.addCSymbol(
         createCVariableSymbol({
           name: "cVar",
@@ -507,6 +612,43 @@ describe("CodeGenState", () => {
       expect(CodeGenState.hasVariableTypeInfo("cVar")).toBe(false);
     });
 
+    it("hasVariableTypeInfo returns true for C header struct variable (Issue #978)", () => {
+      CodeGenState.symbolTable.markTypedefStructType("widget_t", "widget.h");
+      CodeGenState.symbolTable.addCSymbol(
+        createCVariableSymbol({
+          name: "my_widget",
+          type: "widget_t",
+        }),
+      );
+
+      expect(CodeGenState.hasVariableTypeInfo("my_widget")).toBe(true);
+    });
+
+    it("hasVariableTypeInfo returns true for C struct via getStructFields path (Issue #978)", () => {
+      CodeGenState.symbolTable.addStructField("vec2", "x", "float");
+      CodeGenState.symbolTable.addStructField("vec2", "y", "float");
+
+      CodeGenState.symbolTable.addCSymbol(
+        createCVariableSymbol({
+          name: "position",
+          type: "vec2",
+        }),
+      );
+
+      expect(CodeGenState.hasVariableTypeInfo("position")).toBe(true);
+    });
+
+    it("hasVariableTypeInfo returns false for C pointer to non-struct type", () => {
+      CodeGenState.symbolTable.addCSymbol(
+        createCVariableSymbol({
+          name: "data_ptr",
+          type: "uint8_t*",
+        }),
+      );
+
+      expect(CodeGenState.hasVariableTypeInfo("data_ptr")).toBe(false);
+    });
+
     it("setVariableTypeInfo and deleteVariableTypeInfo work correctly", () => {
       const typeInfo: TTypeInfo = {
         baseType: "f32",