c-next 0.2.13 → 0.2.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.2.13",
+  "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/cli/ArgParser.ts

@@ -42,10 +42,8 @@ function configureYargs(args: string[], argv: string[]) {
       .scriptName("cnext")
       .usage(
         `Usage:
-  cnext <file.cnx>                          Single file (outputs file.c)
+  cnext <file.cnx>                          Entry point file (follows includes)
   cnext <file.cnx> -o <output.c>            Single file with explicit output
-  cnext <files...> -o <dir>                 Multi-file mode
-  cnext <dir>                               Directory mode (recursive)
 
 A safer C for embedded systems development.`,
       )
@@ -156,10 +154,8 @@ A safer C for embedded systems development.`,
       // Config file documentation (shown in help)
       .epilogue(
         `Examples:
-  cnext main.cnx                            # Outputs main.c (same dir)
+  cnext src/main.cnx                        # Entry point (follows includes)
   cnext main.cnx -o build/main.c            # Explicit output path
-  cnext src/*.cnx -o build/                 # Multiple files to directory
-  cnext src/                                # Compile all .cnx files in src/ (recursive)
 
 Target platforms: teensy41, cortex-m7, cortex-m4, cortex-m3, cortex-m0+, cortex-m0, avr
 

package/src/cli/PlatformIOCommand.ts

@@ -46,37 +46,36 @@ class PlatformIOCommand {
     // Create cnext_build.py script
     // Issue #833: Run transpilation at import time (before compilation),
     // not as a pre-action on buildprog (which runs after compilation)
-    const buildScript = `Import("env")
+    const buildScript = String.raw`Import("env")
 import subprocess
 import sys
 from pathlib import Path
 
 def transpile_cnext():
-    """Transpile all .cnx files before build"""
-    # Find all .cnx files in src directory
-    src_dir = Path("src")
-    if not src_dir.exists():
+    """Transpile from main.cnx entry point — cnext follows includes"""
+    entry = Path("src/main.cnx")
+    if not entry.exists():
         return
 
-    cnx_files = list(src_dir.rglob("*.cnx"))
-    if not cnx_files:
-        return
-
-    print(f"Transpiling {len(cnx_files)} c-next files...")
-
-    for cnx_file in cnx_files:
-        try:
-            result = subprocess.run(
-                ["cnext", str(cnx_file)],
-                check=True,
-                capture_output=True,
-                text=True
-            )
-            print(f"  ✓ {cnx_file.name}")
-        except subprocess.CalledProcessError as e:
-            print(f"  ✗ Error: {cnx_file.name}")
-            print(e.stderr)
-            sys.exit(1)
+    print("Transpiling from main.cnx...")
+
+    try:
+        result = subprocess.run(
+            ["cnext", str(entry)],
+            check=True,
+            capture_output=True,
+            text=True
+        )
+        if result.stdout:
+            lines = result.stdout.strip().split("\n")
+            for line in lines:
+                if line.startswith(("Compiled", "Collected", "Generated")):
+                    print(f"  {line}")
+        print("  ✓ Transpilation complete")
+    except subprocess.CalledProcessError as e:
+        print(f"  ✗ Transpilation failed")
+        print(e.stderr)
+        sys.exit(1)
 
 # Run transpilation at import time (before compilation starts)
 transpile_cnext()
@@ -119,13 +118,12 @@ transpile_cnext()
     console.log("✓ PlatformIO integration configured!");
     console.log("");
     console.log("Next steps:");
-    console.log(
-      "  1. Create .cnx files in src/ (alongside your .c/.cpp files)",
-    );
-    console.log("  2. Run: pio run");
+    console.log("  1. Create src/main.cnx as your entry point");
+    console.log("  2. Use #include to pull in other .cnx files");
+    console.log("  3. Run: pio run");
     console.log("");
     console.log(
-      "The transpiler will automatically convert .cnx → .c before each build.",
+      "The transpiler will follow includes from main.cnx automatically.",
     );
     console.log("Commit both .cnx and generated .c files to version control.");
   }

package/src/cli/__tests__/PlatformIOCommand.test.ts

@@ -68,6 +68,29 @@ describe("PlatformIOCommand", () => {
       expect(scriptCall?.[1]).toContain("transpile_cnext");
     });
 
+    it("generates script that uses entry point, not per-file loop", () => {
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue("[env:esp32]\n");
+
+      PlatformIOCommand.install();
+
+      const writeCalls = vi.mocked(fs.writeFileSync).mock.calls;
+      const scriptCall = writeCalls.find((call) =>
+        (call[0] as string).includes("cnext_build.py"),
+      );
+
+      expect(scriptCall).toBeDefined();
+      const scriptContent = scriptCall?.[1] as string;
+
+      // Should use entry point approach
+      expect(scriptContent).toContain('Path("src/main.cnx")');
+      expect(scriptContent).toContain('["cnext", str(entry)]');
+
+      // Should NOT loop over individual .cnx files
+      expect(scriptContent).not.toContain("for cnx_file");
+      expect(scriptContent).not.toContain("rglob");
+    });
+
     it("generates script that runs at import time, not as buildprog pre-action (issue #833)", () => {
       // Issue #833: buildprog fires AFTER compilation, so transpile runs too late
       // The script should run transpilation at import time (before compilation)

package/src/transpiler/Transpiler.ts

@@ -491,7 +491,11 @@ class Transpiler {
     );
 
     // Resolve includes from source content
-    const resolver = new IncludeResolver(searchPaths, this.fs);
+    const resolver = new IncludeResolver(
+      searchPaths,
+      this.fs,
+      this.cppDetected,
+    );
     const resolved = resolver.resolve(source, sourcePath);
     this.warnings.push(...resolved.warnings);
 
@@ -864,7 +868,11 @@ class Transpiler {
     );
 
     // Resolve includes
-    const resolver = new IncludeResolver(searchPaths, this.fs);
+    const resolver = new IncludeResolver(
+      searchPaths,
+      this.fs,
+      this.cppDetected,
+    );
     const resolved = resolver.resolve(content, cnxFile.path);
 
     this._collectHeaders(resolved, cnextBaseNames, headerSet);

package/src/transpiler/data/IncludeResolver.ts

@@ -60,12 +60,21 @@ class IncludeResolver {
 
   private readonly resolvedPaths: Set<string> = new Set();
   private readonly fs: IFileSystem;
+  private readonly cppMode: boolean;
 
+  /**
+   * @param cppMode Controls .h vs .hpp extension for .cnx include directives.
+   *   Note: In the Transpiler, cppDetected may change after IncludeResolver runs
+   *   (e.g., when a .hpp header is discovered during Stage 2). HeaderGeneratorUtils
+   *   uses stem-based dedup to handle any resulting .h/.hpp mismatch.
+   */
   constructor(
     private readonly searchPaths: string[],
     fs: IFileSystem = defaultFs,
+    cppMode: boolean = false,
   ) {
     this.fs = fs;
+    this.cppMode = cppMode;
   }
 
   /**
@@ -164,7 +173,8 @@ class IncludeResolver {
       // Issue #854: Track header directive for cnext includes so their types
       // can be mapped by ExternalTypeHeaderBuilder, preventing duplicate
       // forward declarations (MISRA Rule 5.6)
-      const headerPath = includeInfo.path.replace(/\.cnx$|\.cnext$/, ".h");
+      const ext = this.cppMode ? ".hpp" : ".h";
+      const headerPath = includeInfo.path.replace(/\.cnx$|\.cnext$/, ext);
       const directive = includeInfo.isLocal
         ? `#include "${headerPath}"`
         : `#include <${headerPath}>`;

package/src/transpiler/data/__tests__/IncludeResolver.test.ts

@@ -315,6 +315,56 @@ describe("IncludeResolver", () => {
     });
   });
 
+  // ========================================================================
+  // C++ Mode (cppMode) — Issue: .hpp vs .h in headerIncludeDirectives
+  // ========================================================================
+
+  describe("cppMode header directive extension", () => {
+    it("should use .h extension for cnx includes in C mode (default)", () => {
+      const resolver = new IncludeResolver([includeDir]);
+      const content = '#include "shared.cnx"';
+
+      const result = resolver.resolve(content);
+
+      const directives = [...result.headerIncludeDirectives.values()];
+      expect(directives).toHaveLength(1);
+      expect(directives[0]).toBe('#include "shared.h"');
+    });
+
+    it("should use .hpp extension for cnx includes in C++ mode", () => {
+      const resolver = new IncludeResolver([includeDir], undefined, true);
+      const content = '#include "shared.cnx"';
+
+      const result = resolver.resolve(content);
+
+      const directives = [...result.headerIncludeDirectives.values()];
+      expect(directives).toHaveLength(1);
+      expect(directives[0]).toBe('#include "shared.hpp"');
+    });
+
+    it("should use .hpp for angle-bracket cnx includes in C++ mode", () => {
+      const resolver = new IncludeResolver([includeDir], undefined, true);
+      const content = "#include <shared.cnx>";
+
+      const result = resolver.resolve(content);
+
+      const directives = [...result.headerIncludeDirectives.values()];
+      expect(directives).toHaveLength(1);
+      expect(directives[0]).toBe("#include <shared.hpp>");
+    });
+
+    it("should not affect C/C++ header directives (only cnx includes)", () => {
+      const resolver = new IncludeResolver([includeDir], undefined, true);
+      const content = '#include "types.h"';
+
+      const result = resolver.resolve(content);
+
+      const directives = [...result.headerIncludeDirectives.values()];
+      expect(directives).toHaveLength(1);
+      expect(directives[0]).toBe('#include "types.h"');
+    });
+  });
+
   // ========================================================================
   // Edge Cases
   // ========================================================================

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/output/headers/HeaderGeneratorUtils.ts

@@ -289,22 +289,29 @@ class HeaderGeneratorUtils {
     }
 
     // External type header includes (skip duplicates of user includes)
-    // Note: headersToInclude comes from IncludeResolver which always produces .h
-    // (it runs before cppDetected is set). We need to match against userIncludes
-    // which may have .hpp in C++ mode, so normalize both for deduplication.
+    // Dedup by basename stem to handle:
+    // - Different path styles (e.g., <AppConfig.hpp> vs "../AppConfig.hpp")
+    // - Extension mismatch from timing (.h from IncludeResolver before cppDetected,
+    //   .hpp from IncludeExtractor after cppDetected)
     const userIncludeSet = new Set(options.userIncludes ?? []);
-    // Issue #941: Also add .h variants for dedup since headersToInclude uses .h
-    if (options.cppMode && options.userIncludes) {
-      for (const inc of options.userIncludes) {
-        // Add the .h version so we can match against headersToInclude
-        const hVersion = inc.replace(/\.hpp"/, '.h"').replace(/\.hpp>/, ".h>");
-        userIncludeSet.add(hVersion);
-      }
-    }
+    const extractStem = (inc: string): string => {
+      const match = /["<]([^">]+)[">]/.exec(inc);
+      if (!match) return inc;
+      return match[1].replace(/^.*\//, "").replace(/\.(?:h|hpp)$/, "");
+    };
+    const userIncludeStems = new Set(
+      (options.userIncludes ?? []).map(extractStem),
+    );
     for (const directive of headersToInclude) {
-      if (!userIncludeSet.has(directive)) {
-        lines.push(directive);
+      if (userIncludeSet.has(directive)) {
+        continue;
+      }
+      // Check if a user include already covers the same file
+      const stem = extractStem(directive);
+      if (stem && userIncludeStems.has(stem)) {
+        continue;
       }
+      lines.push(directive);
     }
 
     // Add blank line if any includes were added

package/src/transpiler/output/headers/__tests__/HeaderGeneratorUtils.test.ts

@@ -571,17 +571,31 @@ describe("HeaderGeneratorUtils", () => {
       expect(lines).toContain('#include "types.hpp"');
     });
 
-    it("deduplicates headersToInclude against userIncludes with .h/.hpp normalization in C++ mode", () => {
+    it("deduplicates headersToInclude against userIncludes by basename in C++ mode", () => {
       const result = HeaderGeneratorUtils.generateIncludes(
         {
-          userIncludes: ['#include "types.hpp"'],
+          userIncludes: ["#include <AppConfig.hpp>"],
+          cppMode: true,
+        },
+        new Set(['#include "../AppConfig.hpp"']),
+      );
+      // Should NOT have duplicate - different path styles for same file should dedup
+      const configIncludes = result.filter((l) => l.includes("AppConfig"));
+      expect(configIncludes).toEqual(["#include <AppConfig.hpp>"]);
+    });
+
+    it("deduplicates .h vs .hpp extension mismatch from timing difference", () => {
+      // IncludeExtractor produces .hpp (after cppDetected), IncludeResolver
+      // produces .h (before cppDetected) — stem-based dedup handles this
+      const result = HeaderGeneratorUtils.generateIncludes(
+        {
+          userIncludes: ["#include <Display/AppData.hpp>"],
           cppMode: true,
         },
-        new Set(['#include "types.h"']),
+        new Set(["#include <Display/AppData.h>"]),
       );
-      // Should NOT have duplicate - the .h version should be filtered
-      const typeIncludes = result.filter((l) => l.includes("types"));
-      expect(typeIncludes).toEqual(['#include "types.hpp"']);
+      const appDataIncludes = result.filter((l) => l.includes("AppData"));
+      expect(appDataIncludes).toEqual(["#include <Display/AppData.hpp>"]);
     });
   });
 

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",