c-next 0.2.9 → 0.2.11

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

@@ -56,6 +56,7 @@ function createMockSymbols(
     scopeVariableUsage: new Map(),
     scopePrivateConstValues: new Map(),
     functionReturnTypes: overrides.functionReturnTypes ?? new Map(),
+    opaqueTypes: new Set(),
     getSingleFunctionForVariable: () => null,
     hasPublicSymbols: () => false,
   };
@@ -136,6 +137,38 @@ describe("ArrayIndexTypeAnalyzer", () => {
       expect(errors).toHaveLength(0);
     });
 
+    it("should allow enum-typed variable as array index (Issue #949)", () => {
+      const tree = parse(`
+        enum EColor { RED, GREEN, BLUE, COUNT }
+        void getValue(EColor color) {
+          u8[4] arr;
+          arr[color] <- 1;
+        }
+      `);
+      const analyzer = new ArrayIndexTypeAnalyzer();
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["EColor"]),
+      });
+      const errors = analyzer.analyze(tree);
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should allow enum-typed parameter as array index (Issue #949)", () => {
+      const tree = parse(`
+        enum EState { IDLE, RUNNING, STOPPED }
+        u32[3] stateCounts;
+        void incrementState(EState state) {
+          stateCounts[state] <- stateCounts[state] + 1;
+        }
+      `);
+      const analyzer = new ArrayIndexTypeAnalyzer();
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["EState"]),
+      });
+      const errors = analyzer.analyze(tree);
+      expect(errors).toHaveLength(0);
+    });
+
     it("should allow unsigned for-loop variable as index", () => {
       const tree = parse(`
         void main() {
@@ -525,6 +558,145 @@ describe("ArrayIndexTypeAnalyzer", () => {
     });
   });
 
+  // ========================================================================
+  // Nested array subscript (Issue #950)
+  // ========================================================================
+
+  describe("nested array subscript", () => {
+    it("should allow arr[data[i]] where data is u8[8] (Issue #950)", () => {
+      const tree = parse(`
+        void main() {
+          u8[10] arr;
+          u8[8] data <- [0, 0, 3, 0, 0, 0, 0, 0];
+          arr[data[2]] <- 5;
+        }
+      `);
+      const analyzer = new ArrayIndexTypeAnalyzer();
+      const errors = analyzer.analyze(tree);
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should allow arr[data[i] - 1] where data is u8[8] (Issue #950)", () => {
+      const tree = parse(`
+        void main() {
+          u8[10] arr;
+          u8[8] data <- [0, 0, 3, 0, 0, 0, 0, 0];
+          arr[data[2] - 1] <- 5;
+        }
+      `);
+      const analyzer = new ArrayIndexTypeAnalyzer();
+      const errors = analyzer.analyze(tree);
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should allow nested subscript with const array param (Issue #950)", () => {
+      const tree = parse(`
+        void process(const u8[8] data) {
+          u8[10] inputs;
+          inputs[data[2] - 1] <- data[1];
+        }
+      `);
+      const analyzer = new ArrayIndexTypeAnalyzer();
+      const errors = analyzer.analyze(tree);
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should reject nested subscript when inner array is signed", () => {
+      const tree = parse(`
+        void main() {
+          u8[10] arr;
+          i8[8] data;
+          arr[data[2]] <- 5;
+        }
+      `);
+      const analyzer = new ArrayIndexTypeAnalyzer();
+      const errors = analyzer.analyze(tree);
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0850");
+      expect(errors[0].actualType).toBe("i8");
+    });
+
+    it("should allow multi-dimensional array index access", () => {
+      const tree = parse(`
+        void main() {
+          u8[10] arr;
+          u8[4][4] matrix;
+          arr[matrix[1][2]] <- 5;
+        }
+      `);
+      const analyzer = new ArrayIndexTypeAnalyzer();
+      const errors = analyzer.analyze(tree);
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should handle constant-dimension arrays (PR #951 review)", () => {
+      // Regression test: regex must handle non-numeric dimensions
+      // e.g., "u8[DEVICE_COUNT]" should strip to "u8"
+      const tree = parse(`
+        void main() {
+          u8[10] arr;
+          u8[4] lookup;
+          arr[lookup[0]] <- 5;
+        }
+      `);
+      const analyzer = new ArrayIndexTypeAnalyzer();
+      const errors = analyzer.analyze(tree);
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should reject unknown type as index with E0852 (branch coverage)", () => {
+      // Tests the branch where isKnownEnum returns false for non-enum types
+      // This triggers E0852 for types that aren't signed, float, unsigned, or enum
+      const tree = parse(`
+        void main() {
+          u8[10] arr;
+          UnknownType x;
+          arr[x] <- 5;
+        }
+      `);
+      const analyzer = new ArrayIndexTypeAnalyzer();
+      // No mock symbols - UnknownType is not a known enum
+      const errors = analyzer.analyze(tree);
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0852");
+      expect(errors[0].actualType).toBe("UnknownType");
+    });
+
+    it("should handle struct type in subscript chain (branch coverage)", () => {
+      // Tests the branch where array stripping doesn't find brackets
+      // Covers the case where strippedType === currentType (not an array)
+      CodeGenState.symbols = createMockSymbols({
+        knownStructs: new Set(["Wrapper"]),
+        structFields: new Map([["Wrapper", new Map([["idx", "u32"]])]]),
+      });
+      const tree = parse(`
+        void main() {
+          u8[10] arr;
+          Wrapper w;
+          arr[w.idx] <- 5;
+        }
+      `);
+      const analyzer = new ArrayIndexTypeAnalyzer();
+      const errors = analyzer.analyze(tree);
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should allow bit index from signed integer as array index (branch coverage)", () => {
+      // Tests the SIGNED_TYPES branch in resolvePostfixOpType for LBRACKET
+      // i32[bit] returns "bool", which is valid for array indexing
+      const tree = parse(`
+        void main() {
+          u8[2] arr;
+          i32 signedFlags <- 1;
+          arr[signedFlags[0]] <- 5;
+        }
+      `);
+      const analyzer = new ArrayIndexTypeAnalyzer();
+      const errors = analyzer.analyze(tree);
+      expect(errors).toHaveLength(0);
+    });
+  });
+
   // ========================================================================
   // getErrors() accessor
   // ========================================================================

package/src/transpiler/logic/symbols/SymbolTable.ts

@@ -77,6 +77,29 @@ class SymbolTable {
    */
   private readonly needsStructKeyword: Set<string> = new Set();
 
+  /**
+   * Issue #948: Track typedef names that alias incomplete (forward-declared) struct types.
+   * These are "opaque" types that can only be used as pointers.
+   */
+  private readonly opaqueTypes: Set<string> = new Set();
+
+  /**
+   * Issue #958: Track typedef struct type names with their source files.
+   * Maps typeName -> sourceFile. Used for scope variables which should be pointers
+   * when the struct definition comes from a different file than the typedef.
+   * If definition is in the same file as typedef, the entry is removed (value type).
+   * If definition is in a different file, the entry remains (pointer type).
+   */
+  private readonly typedefStructTypes: Map<string, string> = new Map();
+
+  /**
+   * Issue #948: Track struct tag -> typedef name relationships.
+   * When a typedef declares an alias for a struct tag (e.g., typedef struct _foo foo_t),
+   * we record structTagAliases["_foo"] = "foo_t". This allows us to unmark the typedef
+   * as opaque when the full struct definition is later found.
+   */
+  private readonly structTagAliases: Map<string, string> = new Map();
+
   /**
    * Issue #208: Track enum backing type bit widths
    * C++14 typed enums: enum Name : uint8_t { ... } have explicit bit widths
@@ -855,6 +878,130 @@ class SymbolTable {
     }
   }
 
+  // ========================================================================
+  // Opaque Type Tracking (Issue #948)
+  // ========================================================================
+
+  /**
+   * Issue #948: Mark a typedef as aliasing an opaque (forward-declared) struct type.
+   * @param typeName Typedef name (e.g., "widget_t")
+   */
+  markOpaqueType(typeName: string): void {
+    this.opaqueTypes.add(typeName);
+  }
+
+  /**
+   * Issue #948: Unmark a typedef when full struct definition is found.
+   * Handles edge case: typedef before definition.
+   * @param typeName Typedef name
+   */
+  unmarkOpaqueType(typeName: string): void {
+    this.opaqueTypes.delete(typeName);
+  }
+
+  /**
+   * Issue #948: Check if a typedef aliases an opaque struct type.
+   * @param typeName Typedef name
+   * @returns true if the type is opaque (forward-declared)
+   */
+  isOpaqueType(typeName: string): boolean {
+    return this.opaqueTypes.has(typeName);
+  }
+
+  /**
+   * Issue #948: Get all opaque type names for cache serialization.
+   * @returns Array of opaque typedef names
+   */
+  getAllOpaqueTypes(): string[] {
+    return Array.from(this.opaqueTypes);
+  }
+
+  /**
+   * Issue #948: Restore opaque types from cache.
+   * @param typeNames Array of opaque typedef names
+   */
+  restoreOpaqueTypes(typeNames: string[]): void {
+    for (const name of typeNames) {
+      this.opaqueTypes.add(name);
+    }
+  }
+
+  /**
+   * Issue #948: Register a struct tag -> typedef name relationship.
+   * Called when processing: typedef struct _foo foo_t;
+   * This allows unmarking foo_t when struct _foo { ... } is later defined.
+   * @param structTag The struct tag name (e.g., "_foo")
+   * @param typedefName The typedef alias name (e.g., "foo_t")
+   */
+  registerStructTagAlias(structTag: string, typedefName: string): void {
+    this.structTagAliases.set(structTag, typedefName);
+  }
+
+  /**
+   * Issue #948: Get the typedef alias for a struct tag, if any.
+   * @param structTag The struct tag name
+   * @returns The typedef alias name, or undefined if none registered
+   */
+  getStructTagAlias(structTag: string): string | undefined {
+    return this.structTagAliases.get(structTag);
+  }
+
+  // ========================================================================
+  // Issue #958: Typedef Struct Type Tracking
+  // ========================================================================
+
+  /**
+   * Issue #958: Mark a typedef as aliasing a struct type.
+   * Records the source file to enable same-file vs cross-file distinction.
+   * @param typedefName The typedef name (e.g., "widget_t")
+   * @param sourceFile The file where the typedef was declared
+   */
+  markTypedefStructType(typedefName: string, sourceFile: string): void {
+    this.typedefStructTypes.set(typedefName, sourceFile);
+  }
+
+  /**
+   * Issue #958: Unmark a typedef struct type when full definition is found.
+   * Only unmarks if the definition is in the SAME file as the typedef declaration.
+   * Cross-file definitions keep the typedef marked (pointer semantics).
+   * @param typeName The typedef name to unmark
+   * @param sourceFile The file where the definition was found
+   */
+  unmarkTypedefStructType(typeName: string, sourceFile: string): void {
+    const typedefFile = this.typedefStructTypes.get(typeName);
+    if (typedefFile === sourceFile) {
+      this.typedefStructTypes.delete(typeName);
+    }
+  }
+
+  /**
+   * Issue #958: Check if a typedef aliases a struct type.
+   * Used for scope variables which should be pointers for external struct types.
+   * @param typeName The type name to check
+   * @returns true if this is a typedef'd struct type from C headers
+   */
+  isTypedefStructType(typeName: string): boolean {
+    return this.typedefStructTypes.has(typeName);
+  }
+
+  /**
+   * Issue #958: Get all typedef struct types for cache serialization.
+   * @returns Map entries as [typeName, sourceFile] pairs
+   */
+  getAllTypedefStructTypes(): Array<[string, string]> {
+    return Array.from(this.typedefStructTypes.entries());
+  }
+
+  /**
+   * Issue #958: Restore typedef struct types from cache.
+   * @param entries Array of [typeName, sourceFile] pairs
+   */
+  restoreTypedefStructTypes(entries: Array<[string, string]>): void {
+    for (const [name, sourceFile] of entries) {
+      this.typedefStructTypes.set(name, sourceFile);
+    }
+  }
+
   // ========================================================================
   // Enum Bit Width Tracking
   // ========================================================================
@@ -1004,7 +1151,10 @@ class SymbolTable {
     // Auxiliary
     this.structFields.clear();
     this.needsStructKeyword.clear();
+    this.opaqueTypes.clear();
+    this.structTagAliases.clear();
     this.enumBitWidth.clear();
+    this.typedefStructTypes.clear();
   }
 }
 

package/src/transpiler/logic/symbols/__tests__/SymbolTable.test.ts

@@ -610,6 +610,100 @@ describe("SymbolTable", () => {
     });
   });
 
+  // ========================================================================
+  // Opaque Type Tracking (Issue #948)
+  // ========================================================================
+
+  describe("Opaque Type Tracking", () => {
+    it("should mark and check opaque types", () => {
+      symbolTable.markOpaqueType("widget_t");
+      expect(symbolTable.isOpaqueType("widget_t")).toBe(true);
+      expect(symbolTable.isOpaqueType("other_t")).toBe(false);
+    });
+
+    it("should unmark opaque types when full definition found", () => {
+      symbolTable.markOpaqueType("point_t");
+      expect(symbolTable.isOpaqueType("point_t")).toBe(true);
+      symbolTable.unmarkOpaqueType("point_t");
+      expect(symbolTable.isOpaqueType("point_t")).toBe(false);
+    });
+
+    it("should get all opaque types", () => {
+      symbolTable.markOpaqueType("handle_t");
+      symbolTable.markOpaqueType("context_t");
+      const all = symbolTable.getAllOpaqueTypes();
+      expect(all).toContain("handle_t");
+      expect(all).toContain("context_t");
+      expect(all).toHaveLength(2);
+    });
+
+    it("should clear opaque types on clear()", () => {
+      symbolTable.markOpaqueType("widget_t");
+      symbolTable.clear();
+      expect(symbolTable.isOpaqueType("widget_t")).toBe(false);
+    });
+
+    it("should restore opaque types from cache", () => {
+      symbolTable.restoreOpaqueTypes(["widget_t", "handle_t"]);
+      expect(symbolTable.isOpaqueType("widget_t")).toBe(true);
+      expect(symbolTable.isOpaqueType("handle_t")).toBe(true);
+      expect(symbolTable.getAllOpaqueTypes()).toHaveLength(2);
+    });
+  });
+
+  // ========================================================================
+  // Typedef Struct Type Tracking (Issue #958)
+  // ========================================================================
+
+  describe("Typedef Struct Type Tracking", () => {
+    it("should mark and check typedef struct types", () => {
+      symbolTable.markTypedefStructType("widget_t", "widget_types.h");
+      expect(symbolTable.isTypedefStructType("widget_t")).toBe(true);
+      expect(symbolTable.isTypedefStructType("other_t")).toBe(false);
+    });
+
+    it("should unmark typedef struct type when definition is in same file", () => {
+      symbolTable.markTypedefStructType("point_t", "point.h");
+      expect(symbolTable.isTypedefStructType("point_t")).toBe(true);
+      // Same file - should unmark
+      symbolTable.unmarkTypedefStructType("point_t", "point.h");
+      expect(symbolTable.isTypedefStructType("point_t")).toBe(false);
+    });
+
+    it("should retain typedef struct type when definition is in different file", () => {
+      symbolTable.markTypedefStructType("widget_t", "widget_types.h");
+      expect(symbolTable.isTypedefStructType("widget_t")).toBe(true);
+      // Different file - should NOT unmark (cross-file pattern)
+      symbolTable.unmarkTypedefStructType("widget_t", "widget_private.h");
+      expect(symbolTable.isTypedefStructType("widget_t")).toBe(true);
+    });
+
+    it("should get all typedef struct types", () => {
+      symbolTable.markTypedefStructType("handle_t", "handle.h");
+      symbolTable.markTypedefStructType("context_t", "context.h");
+      const all = symbolTable.getAllTypedefStructTypes();
+      expect(all).toHaveLength(2);
+      expect(all).toContainEqual(["handle_t", "handle.h"]);
+      expect(all).toContainEqual(["context_t", "context.h"]);
+    });
+
+    it("should clear typedef struct types on clear()", () => {
+      symbolTable.markTypedefStructType("widget_t", "widget.h");
+      symbolTable.clear();
+      expect(symbolTable.isTypedefStructType("widget_t")).toBe(false);
+    });
+
+    it("should restore typedef struct types from cache", () => {
+      symbolTable.restoreTypedefStructTypes([
+        ["widget_t", "widget_types.h"],
+        ["handle_t", "handle.h"],
+      ]);
+      expect(symbolTable.isTypedefStructType("widget_t")).toBe(true);
+      expect(symbolTable.isTypedefStructType("handle_t")).toBe(true);
+      expect(symbolTable.getAllTypedefStructTypes()).toHaveLength(2);
+    });
+  });
+
   // ========================================================================
   // Clear
   // ========================================================================
@@ -632,14 +726,18 @@ describe("SymbolTable", () => {
 
       symbolTable.addStructField("Point", "x", "int");
       symbolTable.markNeedsStructKeyword("RawStruct");
+      symbolTable.markOpaqueType("widget_t");
       symbolTable.addEnumBitWidth("SmallEnum", 8);
+      symbolTable.markTypedefStructType("handle_t", "handle.h");
 
       symbolTable.clear();
 
       expect(symbolTable.getAllSymbols().length).toBe(0);
       expect(symbolTable.getStructFieldType("Point", "x")).toBeUndefined();
       expect(symbolTable.checkNeedsStructKeyword("RawStruct")).toBe(false);
+      expect(symbolTable.isOpaqueType("widget_t")).toBe(false);
       expect(symbolTable.getEnumBitWidth("SmallEnum")).toBeUndefined();
+      expect(symbolTable.isTypedefStructType("handle_t")).toBe(false);
     });
   });
 });

package/src/transpiler/logic/symbols/__tests__/TransitiveEnumCollector.test.ts

@@ -43,6 +43,7 @@ describe("TransitiveEnumCollector", () => {
       scopePrivateConstValues: new Map(),
       functionReturnTypes: new Map(),
       getSingleFunctionForVariable: () => null,
+      opaqueTypes: new Set(),
       hasPublicSymbols: () => false,
     };
   }

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

@@ -573,6 +573,33 @@ describe("CResolver - Additional Edge Cases", () => {
     expect(result.symbols[0].kind).toBe("function");
   });
 
+  it("collects pointer return type from function definition (Issue #945)", () => {
+    // Tests that collectFromDefinition detects pointer return types
+    const tree = TestHelpers.parseC(
+      `widget_t *create_label(void *parent) { return 0; }`,
+    );
+    const result = CResolver.resolve(tree!, "test.h");
+
+    expect(result.symbols).toHaveLength(1);
+    const symbol = result.symbols[0];
+    expect(symbol.name).toBe("create_label");
+    expect(symbol.kind).toBe("function");
+    if (symbol.kind === "function") {
+      expect(symbol.type).toBe("widget_t*");
+      expect(symbol.isDeclaration).toBe(false);
+    }
+  });
+
+  it("collects non-pointer return type from function definition (Issue #945)", () => {
+    const tree = TestHelpers.parseC(`int getValue(void) { return 42; }`);
+    const result = CResolver.resolve(tree!, "test.h");
+
+    if (result.symbols[0].kind === "function") {
+      expect(result.symbols[0].type).toBe("int");
+      expect(result.symbols[0].isDeclaration).toBe(false);
+    }
+  });
+
   it("collects pointer return type from function prototype (Issue #895 Bug B)", () => {
     const tree = TestHelpers.parseC(`widget_t *widget_create(int w, int h);`);
     const result = CResolver.resolve(tree!, "test.h");
@@ -611,4 +638,74 @@ describe("CResolver - Without SymbolTable", () => {
   });
 });
 
-// ADR-055 Phase 7: CTSymbolAdapter tests removed - adapter deleted
+describe("CResolver - Opaque Type Detection (Issue #948)", () => {
+  it("marks typedef struct forward declaration as opaque", () => {
+    const tree = TestHelpers.parseC(`typedef struct _widget_t widget_t;`);
+    const symbolTable = new SymbolTable();
+    CResolver.resolve(tree!, "test.h", symbolTable);
+
+    expect(symbolTable.isOpaqueType("widget_t")).toBe(true);
+  });
+
+  it("does not mark typedef struct with named body as opaque", () => {
+    const tree = TestHelpers.parseC(
+      `typedef struct _point { int x; int y; } point_t;`,
+    );
+    const symbolTable = new SymbolTable();
+    CResolver.resolve(tree!, "test.h", symbolTable);
+
+    expect(symbolTable.isOpaqueType("point_t")).toBe(false);
+  });
+
+  it("does not mark typedef struct with anonymous body as opaque", () => {
+    const tree = TestHelpers.parseC(`typedef struct { int x; } point_t;`);
+    const symbolTable = new SymbolTable();
+    CResolver.resolve(tree!, "test.h", symbolTable);
+    expect(symbolTable.isOpaqueType("point_t")).toBe(false);
+  });
+
+  it("unmarks opaque type when full definition is found in separate parse", () => {
+    // Forward declaration first
+    const tree1 = TestHelpers.parseC(`typedef struct _foo foo_t;`);
+    const symbolTable = new SymbolTable();
+    CResolver.resolve(tree1!, "test.h", symbolTable);
+
+    expect(symbolTable.isOpaqueType("foo_t")).toBe(true);
+
+    // Full definition later
+    const tree2 = TestHelpers.parseC(`struct _foo { int value; };`);
+    CResolver.resolve(tree2!, "test.h", symbolTable);
+
+    expect(symbolTable.isOpaqueType("foo_t")).toBe(false);
+  });
+
+  it("unmarks opaque type when full definition follows typedef in same parse", () => {
+    const tree = TestHelpers.parseC(`
+      typedef struct _point_t point_t;
+      struct _point_t { int x; int y; };
+    `);
+    const symbolTable = new SymbolTable();
+    CResolver.resolve(tree!, "test.h", symbolTable);
+    expect(symbolTable.isOpaqueType("point_t")).toBe(false);
+  });
+
+  it("handles multiple forward declarations", () => {
+    const tree = TestHelpers.parseC(`
+      typedef struct _widget_t widget_t;
+      typedef struct _display_t display_t;
+    `);
+    const symbolTable = new SymbolTable();
+    CResolver.resolve(tree!, "test.h", symbolTable);
+
+    expect(symbolTable.isOpaqueType("widget_t")).toBe(true);
+    expect(symbolTable.isOpaqueType("display_t")).toBe(true);
+  });
+
+  it("registers struct tag to typedef alias relationship", () => {
+    const tree = TestHelpers.parseC(`typedef struct _widget_t widget_t;`);
+    const symbolTable = new SymbolTable();
+    CResolver.resolve(tree!, "test.h", symbolTable);
+
+    expect(symbolTable.getStructTagAlias("_widget_t")).toBe("widget_t");
+  });
+});

package/src/transpiler/logic/symbols/c/__tests__/PointerTypedef.test.ts

@@ -0,0 +1,47 @@
+/**
+ * Issue #957: Test pointer typedef detection
+ */
+
+import { describe, expect, it } from "vitest";
+import CResolver from "../index";
+import TestHelpers from "./testHelpers";
+import SymbolTable from "../../SymbolTable";
+
+describe("Issue #957 - Pointer Typedef Detection", () => {
+  it("should NOT mark pointer typedef as opaque", () => {
+    const symbolTable = new SymbolTable();
+    const tree = TestHelpers.parseC(
+      `typedef struct spi_device_t *spi_device_handle_t;`,
+    );
+
+    CResolver.resolve(tree!, "test.h", symbolTable);
+
+    // spi_device_handle_t should NOT be marked as opaque
+    // because the typedef has a pointer declarator (*spi_device_handle_t)
+    expect(symbolTable.isOpaqueType("spi_device_handle_t")).toBe(false);
+  });
+
+  it("should mark forward-declared struct typedef as opaque", () => {
+    const symbolTable = new SymbolTable();
+    const tree = TestHelpers.parseC(`typedef struct _widget_t widget_t;`);
+
+    CResolver.resolve(tree!, "test.h", symbolTable);
+
+    // widget_t SHOULD be marked as opaque because it's a forward declaration
+    // without a pointer declarator
+    expect(symbolTable.isOpaqueType("widget_t")).toBe(true);
+  });
+
+  it("should unmark opaque when full definition follows", () => {
+    const symbolTable = new SymbolTable();
+    const tree = TestHelpers.parseC(`
+      typedef struct _widget_t widget_t;
+      struct _widget_t { int x; };
+    `);
+
+    CResolver.resolve(tree!, "test.h", symbolTable);
+
+    // widget_t should NOT be opaque because full definition was found
+    expect(symbolTable.isOpaqueType("widget_t")).toBe(false);
+  });
+});