c-next 0.2.11 → 0.2.13

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

@@ -8,6 +8,7 @@
  * - TCppSymbol: C++ header symbols (string types)
  */
 
+import { produce, enableMapSet } from "immer";
 import ESourceLanguage from "../../../utils/types/ESourceLanguage";
 import LiteralUtils from "../../../utils/LiteralUtils";
 import IConflict from "../../types/IConflict";
@@ -23,6 +24,38 @@ import IVariableSymbol from "../../types/symbols/IVariableSymbol";
 import TypeResolver from "../../../utils/TypeResolver";
 import SymbolNameUtils from "./cnext/utils/SymbolNameUtils";
 
+// Enable immer support for Map and Set (must be called once at module scope)
+enableMapSet();
+
+/**
+ * Issue #958: Immutable struct symbol state managed via immer produce().
+ * All mutations are additive-only — no unmark/delete operations.
+ * Resolution (e.g., "is this type truly opaque?") happens at query time.
+ */
+interface IStructSymbolState {
+  /** Typedef names declared with forward-declared structs (additive only) */
+  opaqueTypes: Set<string>;
+  /** ALL typedef struct types from C headers: name → sourceFile (additive only) */
+  typedefStructTypes: Map<string, string>;
+  /** Struct tag → typedef name (e.g., "_widget_t" → "widget_t") */
+  structTagAliases: Map<string, string>;
+  /** Typedef name → struct tag (reverse of structTagAliases) */
+  typedefToTag: Map<string, string>;
+  /** Struct tags that have full definitions (bodies) */
+  structTagsWithBodies: Set<string>;
+}
+
+/** Create a fresh initial struct symbol state */
+function createInitialStructState(): IStructSymbolState {
+  return {
+    opaqueTypes: new Set(),
+    typedefStructTypes: new Map(),
+    structTagAliases: new Map(),
+    typedefToTag: new Map(),
+    structTagsWithBodies: new Set(),
+  };
+}
+
 /**
  * Central symbol table for cross-language interoperability
  *
@@ -78,27 +111,10 @@ 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.
+   * Issue #958: Immutable struct symbol state — additive only, query-time resolution.
+   * Replaces separate opaqueTypes, typedefStructTypes, structTagAliases fields.
    */
-  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();
+  private structState: IStructSymbolState = createInitialStructState();
 
   /**
    * Issue #208: Track enum backing type bit widths
@@ -141,7 +157,7 @@ class SymbolTable {
    * Called automatically when adding struct symbols.
    */
   private registerStructFields(struct: IStructSymbol): void {
-    const mangledName = SymbolNameUtils.getMangledName(struct);
+    const cName = SymbolNameUtils.getTranspiledCName(struct);
 
     for (const [fieldName, fieldInfo] of struct.fields) {
       // Convert TType to string for structFields map
@@ -153,7 +169,7 @@ class SymbolTable {
       );
 
       this.addStructField(
-        mangledName,
+        cName,
         fieldName,
         typeString,
         numericDims && numericDims.length > 0 ? numericDims : undefined,
@@ -635,17 +651,29 @@ class SymbolTable {
       (s) => s.sourceLanguage === ESourceLanguage.Cpp,
     );
 
-    if (cnextDefs.length > 0 && (cDefs.length > 0 || cppDefs.length > 0)) {
-      const locations = globalDefinitions.map(
+    // Issue #967: Only global-scope C-Next symbols can conflict with C/C++ symbols.
+    // Scoped symbols (e.g., Touch.read) live in a namespace and don't compete
+    // with C's global symbols (e.g., POSIX read()).
+    const conflictingCnextDefs = cnextDefs.filter((s) => {
+      const tSymbol = s as TSymbol;
+      return tSymbol.scope.name === "";
+    });
+
+    if (
+      conflictingCnextDefs.length > 0 &&
+      (cDefs.length > 0 || cppDefs.length > 0)
+    ) {
+      const conflictingDefs = [...conflictingCnextDefs, ...cDefs, ...cppDefs];
+      const locations = conflictingDefs.map(
         (s) =>
           `${s.sourceLanguage.toUpperCase()} (${s.sourceFile}:${s.sourceLine})`,
       );
 
       return {
-        symbolName: globalDefinitions[0].name,
-        definitions: globalDefinitions,
+        symbolName: conflictingDefs[0].name,
+        definitions: conflictingDefs,
         severity: "error",
-        message: `Symbol conflict: '${globalDefinitions[0].name}' is defined in multiple languages:\n  ${locations.join("\n  ")}\nRename the C-Next symbol to resolve.`,
+        message: `Symbol conflict: '${conflictingDefs[0].name}' is defined in multiple languages:\n  ${locations.join("\n  ")}\nRename the C-Next symbol to resolve.`,
       };
     }
 
@@ -879,7 +907,7 @@ class SymbolTable {
   }
 
   // ========================================================================
-  // Opaque Type Tracking (Issue #948)
+  // Struct Symbol State (Issue #948, #958) — immer-managed, additive only
   // ========================================================================
 
   /**
@@ -887,33 +915,32 @@ class SymbolTable {
    * @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);
+    this.structState = produce(this.structState, (draft) => {
+      draft.opaqueTypes.add(typeName);
+    });
   }
 
   /**
-   * Issue #948: Check if a typedef aliases an opaque struct type.
+   * Issue #948/#958: Check if a typedef aliases a truly opaque struct type.
+   * Query-time resolution: if the underlying struct tag has a body, it's not opaque.
    * @param typeName Typedef name
-   * @returns true if the type is opaque (forward-declared)
+   * @returns true if the type is opaque (forward-declared with no body found)
    */
   isOpaqueType(typeName: string): boolean {
-    return this.opaqueTypes.has(typeName);
+    if (!this.structState.opaqueTypes.has(typeName)) return false;
+    // Resolve: if the underlying struct tag has a body, it's not truly opaque
+    const tag = this.structState.typedefToTag.get(typeName);
+    if (tag && this.structState.structTagsWithBodies.has(tag)) return false;
+    return true;
   }
 
   /**
    * Issue #948: Get all opaque type names for cache serialization.
+   * Returns the raw set — resolution happens at query time via isOpaqueType().
    * @returns Array of opaque typedef names
    */
   getAllOpaqueTypes(): string[] {
-    return Array.from(this.opaqueTypes);
+    return Array.from(this.structState.opaqueTypes);
   }
 
   /**
@@ -921,20 +948,25 @@ class SymbolTable {
    * @param typeNames Array of opaque typedef names
    */
   restoreOpaqueTypes(typeNames: string[]): void {
-    for (const name of typeNames) {
-      this.opaqueTypes.add(name);
-    }
+    this.structState = produce(this.structState, (draft) => {
+      for (const name of typeNames) {
+        draft.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.
+   * Populates both forward (tag→typedef) and reverse (typedef→tag) maps.
    * @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);
+    this.structState = produce(this.structState, (draft) => {
+      draft.structTagAliases.set(structTag, typedefName);
+      draft.typedefToTag.set(typedefName, structTag);
+    });
   }
 
   /**
@@ -943,7 +975,59 @@ class SymbolTable {
    * @returns The typedef alias name, or undefined if none registered
    */
   getStructTagAlias(structTag: string): string | undefined {
-    return this.structTagAliases.get(structTag);
+    return this.structState.structTagAliases.get(structTag);
+  }
+
+  /**
+   * Issue #958: Record that a struct tag has a full definition (body).
+   * Used by query-time resolution: opaque types with bodies are not truly opaque.
+   * @param structTag The struct tag name (e.g., "_widget_t")
+   */
+  markStructTagHasBody(structTag: string): void {
+    this.structState = produce(this.structState, (draft) => {
+      draft.structTagsWithBodies.add(structTag);
+    });
+  }
+
+  /**
+   * Issue #958: Get all struct tags with bodies for cache serialization.
+   * @returns Array of struct tag names
+   */
+  getAllStructTagsWithBodies(): string[] {
+    return Array.from(this.structState.structTagsWithBodies);
+  }
+
+  /**
+   * Issue #958: Restore struct tags with bodies from cache.
+   * @param tags Array of struct tag names
+   */
+  restoreStructTagsWithBodies(tags: string[]): void {
+    this.structState = produce(this.structState, (draft) => {
+      for (const tag of tags) {
+        draft.structTagsWithBodies.add(tag);
+      }
+    });
+  }
+
+  /**
+   * Issue #958: Get all struct tag aliases for cache serialization.
+   * @returns Array of [structTag, typedefName] pairs
+   */
+  getAllStructTagAliases(): Array<[string, string]> {
+    return Array.from(this.structState.structTagAliases.entries());
+  }
+
+  /**
+   * Issue #958: Restore struct tag aliases from cache.
+   * @param entries Array of [structTag, typedefName] pairs
+   */
+  restoreStructTagAliases(entries: Array<[string, string]>): void {
+    this.structState = produce(this.structState, (draft) => {
+      for (const [tag, typedefName] of entries) {
+        draft.structTagAliases.set(tag, typedefName);
+        draft.typedefToTag.set(typedefName, tag);
+      }
+    });
   }
 
   // ========================================================================
@@ -952,36 +1036,26 @@ class SymbolTable {
 
   /**
    * Issue #958: Mark a typedef as aliasing a struct type.
-   * Records the source file to enable same-file vs cross-file distinction.
+   * Records the source file. Additive only — never removed.
    * @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);
-    }
+    this.structState = produce(this.structState, (draft) => {
+      draft.typedefStructTypes.set(typedefName, sourceFile);
+    });
   }
 
   /**
    * Issue #958: Check if a typedef aliases a struct type.
-   * Used for scope variables which should be pointers for external struct types.
+   * Used for scope variables, function parameters, and local variables
+   * which should be pointers for C-header 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);
+    const result = this.structState.typedefStructTypes.has(typeName);
+    return result;
   }
 
   /**
@@ -989,7 +1063,7 @@ class SymbolTable {
    * @returns Map entries as [typeName, sourceFile] pairs
    */
   getAllTypedefStructTypes(): Array<[string, string]> {
-    return Array.from(this.typedefStructTypes.entries());
+    return Array.from(this.structState.typedefStructTypes.entries());
   }
 
   /**
@@ -997,9 +1071,11 @@ class SymbolTable {
    * @param entries Array of [typeName, sourceFile] pairs
    */
   restoreTypedefStructTypes(entries: Array<[string, string]>): void {
-    for (const [name, sourceFile] of entries) {
-      this.typedefStructTypes.set(name, sourceFile);
-    }
+    this.structState = produce(this.structState, (draft) => {
+      for (const [name, sourceFile] of entries) {
+        draft.typedefStructTypes.set(name, sourceFile);
+      }
+    });
   }
 
   // ========================================================================
@@ -1151,10 +1227,8 @@ class SymbolTable {
     // Auxiliary
     this.structFields.clear();
     this.needsStructKeyword.clear();
-    this.opaqueTypes.clear();
-    this.structTagAliases.clear();
+    this.structState = createInitialStructState();
     this.enumBitWidth.clear();
-    this.typedefStructTypes.clear();
   }
 }
 

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

@@ -478,6 +478,84 @@ describe("SymbolTable", () => {
       // Two globals with same name IS a conflict
       expect(symbolTable.hasConflict("globalVar")).toBe(true);
     });
+
+    // Issue #967: Scoped C-Next symbols live in a namespace and don't conflict
+    // with C's global symbols. Only global-scope C-Next symbols can conflict.
+    it("should NOT detect conflict for scoped C-Next method vs C function with same bare name", () => {
+      const globalScope = TestScopeUtils.createMockGlobalScope();
+      const touchScope = TestScopeUtils.createMockScope("Touch", globalScope);
+
+      // Add C-Next scoped function 'read' in scope 'Touch'
+      // This transpiles to Touch_read()
+      symbolTable.addTSymbol({
+        kind: "function",
+        name: "read",
+        sourceFile: "touch.cnx",
+        sourceLine: 28,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        returnType: TTypeUtils.createPrimitive("u8"),
+        parameters: [],
+        scope: touchScope,
+        visibility: "public",
+        body: null,
+      } as IFunctionSymbol);
+
+      // Add C function 'read' from POSIX headers
+      // This stays as read()
+      symbolTable.addCSymbol({
+        kind: "function",
+        name: "read",
+        sourceFile: "lv_pthread.h",
+        sourceLine: 80,
+        sourceLanguage: ESourceLanguage.C,
+        isExported: true,
+        type: "ssize_t",
+        parameters: [
+          { name: "fd", type: "int", isConst: false, isArray: false },
+          { name: "buf", type: "void*", isConst: false, isArray: false },
+          { name: "count", type: "size_t", isConst: false, isArray: false },
+        ],
+      });
+
+      // Touch.read() is in a namespace — does NOT conflict with C's global read()
+      expect(symbolTable.hasConflict("read")).toBe(false);
+    });
+
+    // Issue #967: Global C-Next functions SHOULD still conflict with C functions
+    it("should detect conflict for global C-Next function vs C function", () => {
+      const globalScope = TestScopeUtils.createMockGlobalScope();
+
+      // Add global C-Next function 'read'
+      symbolTable.addTSymbol({
+        kind: "function",
+        name: "read",
+        sourceFile: "utils.cnx",
+        sourceLine: 5,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        returnType: TTypeUtils.createPrimitive("u8"),
+        parameters: [],
+        scope: globalScope,
+        visibility: "public",
+        body: null,
+      } as IFunctionSymbol);
+
+      // Add C function 'read'
+      symbolTable.addCSymbol({
+        kind: "function",
+        name: "read",
+        sourceFile: "unistd.h",
+        sourceLine: 100,
+        sourceLanguage: ESourceLanguage.C,
+        isExported: true,
+        type: "ssize_t",
+        parameters: [],
+      });
+
+      // Global C-Next read() DOES conflict with C's read()
+      expect(symbolTable.hasConflict("read")).toBe(true);
+    });
   });
 
   // ========================================================================
@@ -621,13 +699,25 @@ describe("SymbolTable", () => {
       expect(symbolTable.isOpaqueType("other_t")).toBe(false);
     });
 
-    it("should unmark opaque types when full definition found", () => {
+    it("should resolve opaque type as non-opaque when struct tag has body", () => {
+      // typedef struct _point point_t; → mark opaque + register alias
       symbolTable.markOpaqueType("point_t");
+      symbolTable.registerStructTagAlias("_point", "point_t");
       expect(symbolTable.isOpaqueType("point_t")).toBe(true);
-      symbolTable.unmarkOpaqueType("point_t");
+
+      // struct _point { int x; int y; }; → mark body
+      symbolTable.markStructTagHasBody("_point");
+      // Query-time resolution: no longer opaque
       expect(symbolTable.isOpaqueType("point_t")).toBe(false);
     });
 
+    it("should keep opaque type when no body found for struct tag", () => {
+      symbolTable.markOpaqueType("handle_t");
+      symbolTable.registerStructTagAlias("_handle", "handle_t");
+      // No markStructTagHasBody call → stays opaque
+      expect(symbolTable.isOpaqueType("handle_t")).toBe(true);
+    });
+
     it("should get all opaque types", () => {
       symbolTable.markOpaqueType("handle_t");
       symbolTable.markOpaqueType("context_t");
@@ -662,20 +752,14 @@ describe("SymbolTable", () => {
       expect(symbolTable.isTypedefStructType("other_t")).toBe(false);
     });
 
-    it("should unmark typedef struct type when definition is in same file", () => {
+    it("should always return true for typedef struct types (additive only)", () => {
+      // Issue #958: typedef struct types are never unmarked
       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);
+      // Even after marking the body, typedef struct type stays marked
+      symbolTable.registerStructTagAlias("_point", "point_t");
+      symbolTable.markStructTagHasBody("_point");
+      expect(symbolTable.isTypedefStructType("point_t")).toBe(true);
     });
 
     it("should get all typedef struct types", () => {
@@ -704,6 +788,65 @@ describe("SymbolTable", () => {
     });
   });
 
+  // ========================================================================
+  // Struct Tag Aliases and Body Tracking (Issue #958)
+  // ========================================================================
+
+  describe("Struct Tag Aliases and Body Tracking", () => {
+    it("should register and retrieve struct tag aliases", () => {
+      symbolTable.registerStructTagAlias("_widget", "widget_t");
+      expect(symbolTable.getStructTagAlias("_widget")).toBe("widget_t");
+      expect(symbolTable.getStructTagAlias("_unknown")).toBeUndefined();
+    });
+
+    it("should populate forward and reverse alias maps", () => {
+      symbolTable.registerStructTagAlias("_foo", "foo_t");
+      const aliases = symbolTable.getAllStructTagAliases();
+      expect(aliases).toContainEqual(["_foo", "foo_t"]);
+    });
+
+    it("should track struct tags with bodies", () => {
+      symbolTable.markStructTagHasBody("_widget");
+      const bodies = symbolTable.getAllStructTagsWithBodies();
+      expect(bodies).toContain("_widget");
+    });
+
+    it("should restore struct tag aliases from cache", () => {
+      symbolTable.restoreStructTagAliases([
+        ["_foo", "foo_t"],
+        ["_bar", "bar_t"],
+      ]);
+      expect(symbolTable.getStructTagAlias("_foo")).toBe("foo_t");
+      expect(symbolTable.getStructTagAlias("_bar")).toBe("bar_t");
+    });
+
+    it("should restore reverse map (typedefToTag) so isOpaqueType resolves after cache restore", () => {
+      // Simulate cache restore: aliases + opaque types + bodies
+      symbolTable.restoreStructTagAliases([["_widget", "widget_t"]]);
+      symbolTable.restoreOpaqueTypes(["widget_t"]);
+      // widget_t is opaque (no body for _widget)
+      expect(symbolTable.isOpaqueType("widget_t")).toBe(true);
+      // Now restore body — isOpaqueType should resolve via typedefToTag
+      symbolTable.restoreStructTagsWithBodies(["_widget"]);
+      expect(symbolTable.isOpaqueType("widget_t")).toBe(false);
+    });
+
+    it("should restore struct tags with bodies from cache", () => {
+      symbolTable.restoreStructTagsWithBodies(["_foo", "_bar"]);
+      const bodies = symbolTable.getAllStructTagsWithBodies();
+      expect(bodies).toContain("_foo");
+      expect(bodies).toContain("_bar");
+    });
+
+    it("should clear all struct state on clear()", () => {
+      symbolTable.registerStructTagAlias("_foo", "foo_t");
+      symbolTable.markStructTagHasBody("_foo");
+      symbolTable.clear();
+      expect(symbolTable.getStructTagAlias("_foo")).toBeUndefined();
+      expect(symbolTable.getAllStructTagsWithBodies()).toHaveLength(0);
+    });
+  });
+
   // ========================================================================
   // Clear
   // ========================================================================

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

@@ -664,7 +664,7 @@ describe("CResolver - Opaque Type Detection (Issue #948)", () => {
     expect(symbolTable.isOpaqueType("point_t")).toBe(false);
   });
 
-  it("unmarks opaque type when full definition is found in separate parse", () => {
+  it("resolves opaque type as non-opaque when full definition is found in separate parse", () => {
     // Forward declaration first
     const tree1 = TestHelpers.parseC(`typedef struct _foo foo_t;`);
     const symbolTable = new SymbolTable();
@@ -672,14 +672,14 @@ describe("CResolver - Opaque Type Detection (Issue #948)", () => {
 
     expect(symbolTable.isOpaqueType("foo_t")).toBe(true);
 
-    // Full definition later
+    // Full definition later — query-time resolution sees body
     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", () => {
+  it("resolves opaque type as non-opaque 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; };

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

@@ -137,47 +137,17 @@ class StructCollector {
       }
     }
 
-    // Issue #958: Track ALL typedef struct types (forward-declared OR complete)
-    // Records source file to enable same-file vs cross-file distinction
+    // Issue #958: Track forward-declared typedef struct types (no body).
+    // These always need pointer semantics (ADR-006). Inline typedefs with
+    // bodies (typedef struct { ... } X;) are concrete value types.
     // Issue #957: Don't track pointer typedefs - they're already pointers.
-    if (isTypedef && typedefName && !isPointerTypedef) {
+    if (isTypedef && !hasBody && typedefName && !isPointerTypedef) {
       symbolTable.markTypedefStructType(typedefName, sourceFile);
     }
 
-    // Issue #948: Unmark opaque type if full definition is found
-    if (hasBody) {
-      StructCollector.unmarkOpaqueTypesOnDefinition(
-        symbolTable,
-        sourceFile,
-        structTag,
-        typedefName,
-      );
-    }
-  }
-
-  /**
-   * Unmark opaque and typedef struct types when a full struct definition is encountered.
-   * Handles: typedef struct _foo foo; struct _foo { ... };
-   * Issue #958: Only unmarks typedefStructTypes when definition is in SAME file.
-   */
-  private static unmarkOpaqueTypesOnDefinition(
-    symbolTable: SymbolTable,
-    sourceFile: string,
-    structTag?: string,
-    typedefName?: string,
-  ): void {
-    if (structTag) {
-      const typedefAlias = symbolTable.getStructTagAlias(structTag);
-      symbolTable.unmarkOpaqueType(structTag);
-      symbolTable.unmarkTypedefStructType(structTag, sourceFile);
-      if (typedefAlias) {
-        symbolTable.unmarkOpaqueType(typedefAlias);
-        symbolTable.unmarkTypedefStructType(typedefAlias, sourceFile);
-      }
-    }
-    if (typedefName) {
-      symbolTable.unmarkOpaqueType(typedefName);
-      symbolTable.unmarkTypedefStructType(typedefName, sourceFile);
+    // Issue #958: Record struct tag body for query-time opaque resolution
+    if (hasBody && structTag) {
+      symbolTable.markStructTagHasBody(structTag);
     }
   }