c-next 0.1.67 → 0.1.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.67",
+  "version": "0.1.68",
   "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

@@ -53,7 +53,6 @@ import ITranspileError from "../lib/types/ITranspileError";
 import TranspilerState from "./types/TranspilerState";
 import runAnalyzers from "./logic/analysis/runAnalyzers";
 import ModificationAnalyzer from "./logic/analysis/ModificationAnalyzer";
-import AnalyzerContextBuilder from "./logic/analysis/AnalyzerContextBuilder";
 import CacheManager from "../utils/cache/CacheManager";
 import MapUtils from "../utils/MapUtils";
 import detectCppSyntax from "./logic/detectCppSyntax";
@@ -247,7 +246,7 @@ class Transpiler {
    *
    * Both run() and transpileSource() delegate here after file discovery.
    *
-   * Stage 2: Collect symbols from C/C++ headers
+   * Stage 2: Collect symbols from C/C++ headers (includes building analyzer context)
    * Stage 3: Collect symbols from C-Next files
    * Stage 3b: Resolve external const array dimensions
    * Stage 4: Check for symbol conflicts
@@ -258,8 +257,9 @@ class Transpiler {
     input: IPipelineInput,
     result: ITranspilerResult,
   ): Promise<void> {
-    // Stage 2: Collect symbols from C/C++ headers
+    // Stage 2: Collect symbols from C/C++ headers and build analyzer context
     this._collectAllHeaderSymbols(input.headerFiles, result);
+    CodeGenState.buildExternalStructFields();
 
     // Stage 3: Collect symbols from C-Next files
     if (!this._collectAllCNextSymbolsFromPipeline(input.cnextFiles, result)) {
@@ -395,16 +395,8 @@ class Transpiler {
         return this.buildParseOnlyResult(sourcePath, declarationCount);
       }
 
-      // Run analyzers
-      const externalStructFields =
-        AnalyzerContextBuilder.buildExternalStructFields(
-          CodeGenState.symbolTable,
-        );
-
-      const analyzerErrors = runAnalyzers(tree, tokenStream, {
-        externalStructFields,
-        symbolTable: CodeGenState.symbolTable,
-      });
+      // Run analyzers (reads externalStructFields and symbolTable from CodeGenState)
+      const analyzerErrors = runAnalyzers(tree, tokenStream);
       if (analyzerErrors.length > 0) {
         return this.buildErrorResult(
           sourcePath,

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

@@ -21,6 +21,7 @@ import ExpressionUtils from "../../../utils/ExpressionUtils";
 import ParserUtils from "../../../utils/ParserUtils";
 import analyzePostfixOps from "../../../utils/PostfixAnalysisUtils";
 import SymbolTable from "../symbols/SymbolTable";
+import CodeGenState from "../../state/CodeGenState";
 import ESourceLanguage from "../../../utils/types/ESourceLanguage";
 import ESymbolKind from "../../../utils/types/ESymbolKind";
 
@@ -408,8 +409,11 @@ class InitializationAnalyzer {
 
   private scopeStack: ScopeStack<IVariableState> = new ScopeStack();
 
-  /** Known struct types and their fields */
-  private readonly structFields: Map<string, Set<string>> = new Map();
+  /**
+   * C-Next struct fields from current file (collected at analysis time).
+   * External struct fields from C/C++ headers are accessed via CodeGenState.
+   */
+  private cnextStructFields: Map<string, Set<string>> = new Map();
 
   /** Track if we're processing a write target (left side of assignment) */
   private inWriteContext: boolean = false;
@@ -418,17 +422,25 @@ class InitializationAnalyzer {
   private symbolTable: SymbolTable | null = null;
 
   /**
-   * Register external struct fields from C/C++ headers
-   * This allows the analyzer to recognize types defined in headers
-   *
-   * @param externalFields Map of struct name -> Set of field names
+   * Get struct fields for a given struct type.
+   * Checks C-Next structs first, then falls back to CodeGenState for external structs.
    */
-  public registerExternalStructFields(
-    externalFields: Map<string, Set<string>>,
-  ): void {
-    for (const [structName, fields] of externalFields) {
-      this.structFields.set(structName, fields);
+  private getStructFields(structName: string): Set<string> | undefined {
+    // Check C-Next structs from current file first
+    const cnextFields = this.cnextStructFields.get(structName);
+    if (cnextFields) {
+      return cnextFields;
     }
+
+    // Check external structs from CodeGenState
+    return CodeGenState.getExternalStructFields().get(structName);
+  }
+
+  /**
+   * Check if a type name is a known struct.
+   */
+  private isKnownStruct(typeName: string): boolean {
+    return this.getStructFields(typeName) !== undefined;
   }
 
   /**
@@ -469,9 +481,10 @@ class InitializationAnalyzer {
     this.errors = [];
     this.scopeStack = new ScopeStack();
     this.symbolTable = symbolTable ?? null;
-    // Don't clear structFields - external fields may have been registered
+    // Clear C-Next struct fields from previous analysis (external fields come from CodeGenState)
+    this.cnextStructFields = new Map();
 
-    // First pass: collect struct definitions
+    // First pass: collect struct definitions from current file
     this.collectStructDefinitions(tree);
 
     // Create global scope with all global/namespace variable declarations
@@ -553,7 +566,8 @@ class InitializationAnalyzer {
   }
 
   /**
-   * Collect struct definitions to know their fields
+   * Collect struct definitions from current file to know their fields.
+   * This supplements the external struct fields from CodeGenState.
    */
   private collectStructDefinitions(tree: Parser.ProgramContext): void {
     for (const decl of tree.declaration()) {
@@ -567,7 +581,7 @@ class InitializationAnalyzer {
           fields.add(fieldName);
         }
 
-        this.structFields.set(structName, fields);
+        this.cnextStructFields.set(structName, fields);
       }
     }
   }
@@ -610,9 +624,9 @@ class InitializationAnalyzer {
       this.enterScope();
     }
 
-    const isStruct = typeName !== null && this.structFields.has(typeName);
+    const isStruct = typeName !== null && this.isKnownStruct(typeName);
     const fields = isStruct
-      ? this.structFields.get(typeName)!
+      ? this.getStructFields(typeName)!
       : new Set<string>();
 
     // Issue #503: C++ classes with default constructors are automatically initialized
@@ -637,13 +651,11 @@ class InitializationAnalyzer {
    * SonarCloud S3776: Refactored to use helper methods.
    */
   public recordAssignment(name: string, field?: string): void {
-    const structFields = this.structFields;
-
     this.scopeStack.update(name, (state) => {
       if (field) {
-        this.recordFieldAssignment(state, field, structFields);
+        this.recordFieldAssignment(state, field);
       } else {
-        this.recordWholeAssignment(state, structFields);
+        this.recordWholeAssignment(state);
       }
       return state;
     });
@@ -652,16 +664,12 @@ class InitializationAnalyzer {
   /**
    * Handle field-level assignment.
    */
-  private recordFieldAssignment(
-    state: IVariableState,
-    field: string,
-    structFields: Map<string, Set<string>>,
-  ): void {
+  private recordFieldAssignment(state: IVariableState, field: string): void {
     state.initializedFields.add(field);
     // Check if all fields are now initialized
     if (!state.isStruct || !state.typeName) return;
 
-    const allFields = structFields.get(state.typeName);
+    const allFields = this.getStructFields(state.typeName);
     if (!allFields) return;
 
     const allInitialized = [...allFields].every((f) =>
@@ -675,15 +683,12 @@ class InitializationAnalyzer {
   /**
    * Handle whole-variable assignment.
    */
-  private recordWholeAssignment(
-    state: IVariableState,
-    structFields: Map<string, Set<string>>,
-  ): void {
+  private recordWholeAssignment(state: IVariableState): void {
     state.initialized = true;
     // Mark all fields as initialized too
     if (!state.isStruct || !state.typeName) return;
 
-    const fields = structFields.get(state.typeName);
+    const fields = this.getStructFields(state.typeName);
     if (fields) {
       state.initializedFields = new Set(fields);
     }
@@ -745,8 +750,8 @@ class InitializationAnalyzer {
     field: string,
     state: IVariableState,
   ): void {
-    const structFields = this.structFields.get(state.typeName!);
-    if (!structFields?.has(field)) return;
+    const structFieldSet = this.getStructFields(state.typeName!);
+    if (!structFieldSet?.has(field)) return;
 
     if (!state.initializedFields.has(field)) {
       this.addError(`${name}.${field}`, line, column, state.declaration, false);
@@ -874,9 +879,9 @@ class InitializationAnalyzer {
       this.enterScope();
     }
 
-    const isStruct = typeName !== null && this.structFields.has(typeName);
+    const isStruct = typeName !== null && this.isKnownStruct(typeName);
     const fields = isStruct
-      ? this.structFields.get(typeName)!
+      ? this.getStructFields(typeName)!
       : new Set<string>();
 
     const state: IVariableState = {

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

@@ -4,11 +4,12 @@
  */
 
 import { CharStream, CommonTokenStream } from "antlr4ng";
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, beforeEach } from "vitest";
 import { CNextLexer } from "../../parser/grammar/CNextLexer";
 import { CNextParser } from "../../parser/grammar/CNextParser";
 import InitializationAnalyzer from "../InitializationAnalyzer";
 import SymbolTable from "../../symbols/SymbolTable";
+import CodeGenState from "../../../state/CodeGenState";
 import ESymbolKind from "../../../../utils/types/ESymbolKind";
 import ESourceLanguage from "../../../../utils/types/ESourceLanguage";
 
@@ -24,6 +25,12 @@ function parse(source: string) {
 }
 
 describe("InitializationAnalyzer", () => {
+  // Reset CodeGenState before each test
+  beforeEach(() => {
+    CodeGenState.reset();
+    CodeGenState.symbolTable.clear();
+  });
+
   // ========================================================================
   // Issue #503: C++ Class Initialization
   // ========================================================================
@@ -38,9 +45,8 @@ describe("InitializationAnalyzer", () => {
       `;
       const tree = parse(code);
 
-      // Create symbol table with C++ class
-      const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      // Set up CodeGenState with C++ class
+      CodeGenState.symbolTable.addSymbol({
         name: "CppMessage",
         kind: ESymbolKind.Class,
         sourceLanguage: ESourceLanguage.Cpp,
@@ -49,14 +55,13 @@ describe("InitializationAnalyzer", () => {
         isExported: true,
       });
       // Add the field so the analyzer knows about it
-      symbolTable.addStructField("CppMessage", "pgn", "u16");
+      CodeGenState.symbolTable.addStructField("CppMessage", "pgn", "u16");
 
-      const analyzer = new InitializationAnalyzer();
-      analyzer.registerExternalStructFields(
-        new Map([["CppMessage", new Set(["pgn"])]]),
-      );
+      // Build external struct fields from symbol table
+      CodeGenState.buildExternalStructFields();
 
-      const errors = analyzer.analyze(tree, symbolTable);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree, CodeGenState.symbolTable);
 
       // Should have NO errors - C++ class is initialized by constructor
       expect(errors).toHaveLength(0);
@@ -95,9 +100,8 @@ describe("InitializationAnalyzer", () => {
       `;
       const tree = parse(code);
 
-      // Create symbol table with C++ struct (not class)
-      const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      // Set up CodeGenState with C++ struct (not class)
+      CodeGenState.symbolTable.addSymbol({
         name: "CppStruct",
         kind: ESymbolKind.Struct,
         sourceLanguage: ESourceLanguage.Cpp,
@@ -105,14 +109,13 @@ describe("InitializationAnalyzer", () => {
         sourceLine: 1,
         isExported: true,
       });
-      symbolTable.addStructField("CppStruct", "value", "u32");
+      CodeGenState.symbolTable.addStructField("CppStruct", "value", "u32");
 
-      const analyzer = new InitializationAnalyzer();
-      analyzer.registerExternalStructFields(
-        new Map([["CppStruct", new Set(["value"])]]),
-      );
+      // Build external struct fields from symbol table
+      CodeGenState.buildExternalStructFields();
 
-      const errors = analyzer.analyze(tree, symbolTable);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree, CodeGenState.symbolTable);
 
       // Should have NO errors - C++ structs also have default constructors
       expect(errors).toHaveLength(0);
@@ -127,9 +130,8 @@ describe("InitializationAnalyzer", () => {
       `;
       const tree = parse(code);
 
-      // Create symbol table with C struct (not C++)
-      const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      // Set up CodeGenState with C struct (not C++)
+      CodeGenState.symbolTable.addSymbol({
         name: "CStruct",
         kind: ESymbolKind.Struct,
         sourceLanguage: ESourceLanguage.C,
@@ -137,14 +139,13 @@ describe("InitializationAnalyzer", () => {
         sourceLine: 1,
         isExported: true,
       });
-      symbolTable.addStructField("CStruct", "value", "u32");
+      CodeGenState.symbolTable.addStructField("CStruct", "value", "u32");
 
-      const analyzer = new InitializationAnalyzer();
-      analyzer.registerExternalStructFields(
-        new Map([["CStruct", new Set(["value"])]]),
-      );
+      // Build external struct fields from symbol table (as pipeline does)
+      CodeGenState.buildExternalStructFields();
 
-      const errors = analyzer.analyze(tree, symbolTable);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree, CodeGenState.symbolTable);
 
       // SHOULD have an error - C structs don't have constructors
       expect(errors.length).toBeGreaterThan(0);

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

@@ -2,12 +2,13 @@
  * Unit tests for runAnalyzers
  * Tests that all 8 analyzers run in sequence with early returns on errors
  */
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, beforeEach } from "vitest";
 import { CharStream, CommonTokenStream } from "antlr4ng";
 import { CNextLexer } from "../../parser/grammar/CNextLexer";
 import { CNextParser } from "../../parser/grammar/CNextParser";
 import runAnalyzers from "../runAnalyzers";
 import SymbolTable from "../../symbols/SymbolTable";
+import CodeGenState from "../../../state/CodeGenState";
 import ESymbolKind from "../../../../utils/types/ESymbolKind";
 import ESourceLanguage from "../../../../utils/types/ESourceLanguage";
 
@@ -24,6 +25,12 @@ function parseWithStream(source: string) {
 }
 
 describe("runAnalyzers", () => {
+  // Reset CodeGenState before each test
+  beforeEach(() => {
+    CodeGenState.reset();
+    CodeGenState.symbolTable.clear();
+  });
+
   // ========================================================================
   // Happy Path
   // ========================================================================
@@ -206,24 +213,33 @@ describe("runAnalyzers", () => {
   });
 
   // ========================================================================
-  // Options: externalStructFields and symbolTable
+  // Options: CodeGenState integration and symbolTable
   // ========================================================================
 
   describe("options", () => {
-    it("should pass externalStructFields to InitializationAnalyzer", () => {
-      // Code that uses a field from an external struct - the externalStructFields
-      // option tells the analyzer about external struct types
+    it("should read externalStructFields from CodeGenState", () => {
+      // Code that uses a field from an external struct - externalStructFields
+      // are now read from CodeGenState
       const { tree, tokenStream } = parseWithStream(`
         void main() {
           u32 x <- 5;
         }
       `);
 
-      const externalStructFields = new Map<string, Set<string>>([
-        ["ExternalStruct", new Set(["field1", "field2"])],
-      ]);
+      // Set up external struct fields in CodeGenState
+      CodeGenState.symbolTable.addStructField(
+        "ExternalStruct",
+        "field1",
+        "u32",
+      );
+      CodeGenState.symbolTable.addStructField(
+        "ExternalStruct",
+        "field2",
+        "u32",
+      );
+      CodeGenState.buildExternalStructFields();
 
-      const errors = runAnalyzers(tree, tokenStream, { externalStructFields });
+      const errors = runAnalyzers(tree, tokenStream);
       expect(errors).toHaveLength(0);
     });
 
@@ -248,18 +264,15 @@ describe("runAnalyzers", () => {
       expect(errors).toHaveLength(0);
     });
 
-    it("should pass both options together", () => {
+    it("should use CodeGenState.symbolTable by default", () => {
       const { tree, tokenStream } = parseWithStream(`
         void main() {
           u32 x <- 5;
         }
       `);
 
-      const externalStructFields = new Map<string, Set<string>>([
-        ["CppMessage", new Set(["pgn"])],
-      ]);
-      const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      // Set up C++ class in CodeGenState.symbolTable
+      CodeGenState.symbolTable.addSymbol({
         name: "CppMessage",
         kind: ESymbolKind.Class,
         sourceLanguage: ESourceLanguage.Cpp,
@@ -267,11 +280,11 @@ describe("runAnalyzers", () => {
         sourceLine: 1,
         isExported: true,
       });
+      CodeGenState.symbolTable.addStructField("CppMessage", "pgn", "u16");
+      CodeGenState.buildExternalStructFields();
 
-      const errors = runAnalyzers(tree, tokenStream, {
-        externalStructFields,
-        symbolTable,
-      });
+      // No options passed - should use CodeGenState.symbolTable
+      const errors = runAnalyzers(tree, tokenStream);
       expect(errors).toHaveLength(0);
     });
   });

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

@@ -17,20 +17,16 @@ import FloatModuloAnalyzer from "./FloatModuloAnalyzer";
 import CommentExtractor from "./CommentExtractor";
 import ITranspileError from "../../../lib/types/ITranspileError";
 import SymbolTable from "../symbols/SymbolTable";
+import CodeGenState from "../../state/CodeGenState";
 
 /**
  * Options for running analyzers
  */
 interface IAnalyzerOptions {
-  /**
-   * External struct field information from C/C++ headers
-   * Maps struct name -> Set of field names
-   */
-  externalStructFields?: Map<string, Set<string>>;
-
   /**
    * Symbol table containing external function definitions from C/C++ headers
-   * Used by FunctionCallAnalyzer to recognize external functions
+   * Used by FunctionCallAnalyzer to recognize external functions.
+   * Falls back to CodeGenState.symbolTable if not provided.
    */
   symbolTable?: SymbolTable;
 }
@@ -100,13 +96,11 @@ function runAnalyzers(
 
   // 3. Initialization analysis (Rust-style use-before-init detection)
   const initAnalyzer = new InitializationAnalyzer();
-  if (options?.externalStructFields) {
-    initAnalyzer.registerExternalStructFields(options.externalStructFields);
-  }
-  // Issue #503: Pass symbol table so C++ classes with default constructors are recognized
+  // External struct fields and symbolTable are read from CodeGenState directly
+  const symbolTable = options?.symbolTable ?? CodeGenState.symbolTable;
   if (
     collectErrors(
-      initAnalyzer.analyze(tree, options?.symbolTable),
+      initAnalyzer.analyze(tree, symbolTable),
       errors,
       formatWithCode,
     )
@@ -115,10 +109,10 @@ function runAnalyzers(
   }
 
   // 4. Call analysis (ADR-030: define-before-use)
-  const funcAnalyzer = new FunctionCallAnalyzer();
+  const callAnalyzer = new FunctionCallAnalyzer();
   if (
     collectErrors(
-      funcAnalyzer.analyze(tree, options?.symbolTable),
+      callAnalyzer.analyze(tree, symbolTable),
       errors,
       formatWithCode,
     )

package/src/transpiler/output/codegen/generators/expressions/PostfixExpressionGenerator.ts

@@ -1441,16 +1441,33 @@ const generateMemberAccess = (
   state: IGeneratorState,
   orchestrator: IOrchestrator,
   effects: TGeneratorEffect[],
-): MemberAccessResult =>
-  tryBitmapFieldAccess(ctx, input, effects) ??
-  tryScopeMemberAccess(ctx, input, state, orchestrator) ??
-  tryKnownScopeAccess(ctx, input, state, orchestrator) ??
-  tryEnumMemberAccess(ctx, input, state, orchestrator) ??
-  tryRegisterMemberAccess(ctx, input, state) ??
-  tryStructParamAccess(ctx, orchestrator) ??
-  tryRegisterBitmapAccess(ctx, input, effects) ??
-  tryStructBitmapAccess(ctx, input, effects) ??
-  generateDefaultAccess(ctx, orchestrator);
+): MemberAccessResult => {
+  // Check for enum shadowing before dispatch - catches case where identifier
+  // was resolved to a scope member that shadows a global enum
+  MemberAccessValidator.validateGlobalEntityAccess(
+    ctx.result,
+    ctx.memberName,
+    "enum",
+    state.currentScope,
+    ctx.isGlobalAccess,
+    {
+      rootIdentifier: ctx.rootIdentifier,
+      knownEnums: input.symbols!.knownEnums,
+    },
+  );
+
+  return (
+    tryBitmapFieldAccess(ctx, input, effects) ??
+    tryScopeMemberAccess(ctx, input, state, orchestrator) ??
+    tryKnownScopeAccess(ctx, input, state, orchestrator) ??
+    tryEnumMemberAccess(ctx, input, state, orchestrator) ??
+    tryRegisterMemberAccess(ctx, input, state) ??
+    tryStructParamAccess(ctx, orchestrator) ??
+    tryRegisterBitmapAccess(ctx, input, effects) ??
+    tryStructBitmapAccess(ctx, input, effects) ??
+    generateDefaultAccess(ctx, orchestrator)
+  );
+};
 
 // ========================================================================
 // Member Access Handlers
@@ -1575,12 +1592,15 @@ const tryEnumMemberAccess = (
     return null;
   }
 
+  // Shadowing check already done in generateMemberAccess; this catches
+  // direct conflicts where ctx.result is the enum name (no resolution happened)
   MemberAccessValidator.validateGlobalEntityAccess(
     ctx.result,
     ctx.memberName,
     "enum",
     state.currentScope,
     ctx.isGlobalAccess,
+    { scopeMembers: state.scopeMembers },
   );
 
   const output = initializeMemberOutput(ctx);
@@ -1606,6 +1626,7 @@ const tryRegisterMemberAccess = (
     "register",
     state.currentScope,
     ctx.isGlobalAccess,
+    { scopeMembers: state.scopeMembers },
   );
 
   MemberAccessValidator.validateRegisterReadAccess(

package/src/transpiler/output/codegen/generators/expressions/__tests__/PostfixExpressionGenerator.test.ts

@@ -1318,7 +1318,7 @@ describe("PostfixExpressionGenerator", () => {
       expect(result.code).toBe("Color_Red");
     });
 
-    it("throws when accessing enum without global prefix inside scope", () => {
+    it("throws when accessing enum with naming conflict inside scope", () => {
       const symbols = createMockSymbols({
         knownEnums: new Set(["Color"]),
       });
@@ -1326,7 +1326,8 @@ describe("PostfixExpressionGenerator", () => {
         createMockPostfixOp({ identifier: "Red" }),
       ]);
       const input = createMockInput({ symbols });
-      const state = createMockState({ currentScope: "Motor" });
+      const scopeMembers = new Map([["Motor", new Set(["Color"])]]);
+      const state = createMockState({ currentScope: "Motor", scopeMembers });
       const orchestrator = createMockOrchestrator({
         generatePrimaryExpr: () => "Color",
         getScopeSeparator: () => "_",
@@ -1336,6 +1337,48 @@ describe("PostfixExpressionGenerator", () => {
         generatePostfixExpression(ctx, input, state, orchestrator),
       ).toThrow("Use 'global.Color.Red' to access enum 'Color'");
     });
+
+    it("allows enum access without global prefix when no naming conflict", () => {
+      const symbols = createMockSymbols({
+        knownEnums: new Set(["Color"]),
+      });
+      const ctx = createMockPostfixExpressionContext("Color", [
+        createMockPostfixOp({ identifier: "Red" }),
+      ]);
+      const input = createMockInput({ symbols });
+      const scopeMembers = new Map([["Motor", new Set(["speed"])]]);
+      const state = createMockState({ currentScope: "Motor", scopeMembers });
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "Color",
+        getScopeSeparator: () => "_",
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("Color_Red");
+    });
+
+    it("throws when scope member shadows global enum (resolved identifier differs)", () => {
+      const symbols = createMockSymbols({
+        knownEnums: new Set(["Color"]),
+      });
+      const ctx = createMockPostfixExpressionContext("Color", [
+        createMockPostfixOp({ identifier: "Red" }),
+      ]);
+      const input = createMockInput({ symbols });
+      const scopeMembers = new Map([["Motor", new Set(["Color"])]]);
+      const state = createMockState({ currentScope: "Motor", scopeMembers });
+      const orchestrator = createMockOrchestrator({
+        // Simulates identifier resolution: Color -> Motor_Color (scope member)
+        generatePrimaryExpr: () => "Motor_Color",
+        getScopeSeparator: () => "_",
+      });
+
+      expect(() =>
+        generatePostfixExpression(ctx, input, state, orchestrator),
+      ).toThrow(
+        "Use 'global.Color.Red' to access enum 'Color' from inside scope 'Motor' (scope member 'Color' shadows the global enum)",
+      );
+    });
   });
 
   describe("register member access", () => {
@@ -1375,7 +1418,7 @@ describe("PostfixExpressionGenerator", () => {
       ).toThrow("cannot read from write-only register member 'DATA'");
     });
 
-    it("throws when accessing register without global prefix inside scope", () => {
+    it("throws when accessing register with naming conflict inside scope", () => {
       const symbols = createMockSymbols({
         knownRegisters: new Set(["GPIO"]),
       });
@@ -1383,7 +1426,8 @@ describe("PostfixExpressionGenerator", () => {
         createMockPostfixOp({ identifier: "PIN0" }),
       ]);
       const input = createMockInput({ symbols });
-      const state = createMockState({ currentScope: "Motor" });
+      const scopeMembers = new Map([["Motor", new Set(["GPIO"])]]);
+      const state = createMockState({ currentScope: "Motor", scopeMembers });
       const orchestrator = createMockOrchestrator({
         generatePrimaryExpr: () => "GPIO",
       });
@@ -1392,6 +1436,24 @@ describe("PostfixExpressionGenerator", () => {
         generatePostfixExpression(ctx, input, state, orchestrator),
       ).toThrow("Use 'global.GPIO.PIN0' to access register 'GPIO'");
     });
+
+    it("allows register access without global prefix when no naming conflict", () => {
+      const symbols = createMockSymbols({
+        knownRegisters: new Set(["GPIO"]),
+      });
+      const ctx = createMockPostfixExpressionContext("GPIO", [
+        createMockPostfixOp({ identifier: "PIN0" }),
+      ]);
+      const input = createMockInput({ symbols });
+      const scopeMembers = new Map([["Motor", new Set(["speed"])]]);
+      const state = createMockState({ currentScope: "Motor", scopeMembers });
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "GPIO",
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("GPIO_PIN0");
+    });
   });
 
   describe("struct parameter access", () => {

package/src/transpiler/output/codegen/helpers/MemberAccessValidator.ts

@@ -55,13 +55,22 @@ class MemberAccessValidator {
 
   /**
    * ADR-016/057: Validate that a global entity (enum or register) is accessed
-   * with 'global.' prefix when inside a scope that doesn't own the entity.
+   * with 'global.' prefix when inside a scope that has a naming conflict.
    *
-   * @param entityName - The entity being accessed (e.g., "Color", "GPIO")
+   * Detects two types of conflicts:
+   * 1. Scope member with same name as entity (via scopeMembers lookup)
+   * 2. Identifier was resolved to scope member, shadowing a global enum
+   *    (via rootIdentifier != resolvedName comparison)
+   *
+   * @param entityName - The resolved entity name (e.g., "Color" or "Motor_Color")
    * @param memberName - The member after the entity (e.g., "Red", "PIN0")
    * @param entityType - "enum" or "register" (for error message)
    * @param currentScope - Active scope context (null = not in a scope)
    * @param isGlobalAccess - Whether the access used 'global.' prefix
+   * @param options - Optional conflict detection parameters
+   * @param options.scopeMembers - Map of scope names to their member names
+   * @param options.rootIdentifier - Original identifier before resolution (for shadowing detection)
+   * @param options.knownEnums - Set of known enum names (for shadowing detection)
    */
   static validateGlobalEntityAccess(
     entityName: string,
@@ -69,18 +78,50 @@ class MemberAccessValidator {
     entityType: string,
     currentScope: string | null,
     isGlobalAccess: boolean,
+    options?: {
+      scopeMembers?: ReadonlyMap<string, ReadonlySet<string>>;
+      rootIdentifier?: string;
+      knownEnums?: ReadonlySet<string>;
+    },
   ): void {
     if (isGlobalAccess) {
       return;
     }
-    if (currentScope) {
-      const belongsToCurrentScope = entityName.startsWith(currentScope + "_");
-      if (!belongsToCurrentScope) {
+    if (!currentScope) {
+      return;
+    }
+
+    const { scopeMembers, rootIdentifier, knownEnums } = options ?? {};
+
+    // Check 1: Shadowing detection - identifier was resolved to a scope member
+    // that shadows a global enum. This produces invalid C (e.g., Motor_Color.RED).
+    // This check must run BEFORE the belongsToCurrentScope check because
+    // the resolved name (e.g., Motor_Color) will start with the scope prefix.
+    if (rootIdentifier && knownEnums) {
+      const wasResolved = entityName !== rootIdentifier;
+      const rootIsEnum = knownEnums.has(rootIdentifier);
+      const resolvedIsNotEnum = !knownEnums.has(entityName);
+      if (wasResolved && rootIsEnum && resolvedIsNotEnum) {
         throw new Error(
-          `Error: Use 'global.${entityName}.${memberName}' to access ${entityType} '${entityName}' from inside scope '${currentScope}'`,
+          `Error: Use 'global.${rootIdentifier}.${memberName}' to access enum '${rootIdentifier}' from inside scope '${currentScope}' (scope member '${rootIdentifier}' shadows the global enum)`,
         );
       }
     }
+
+    // Skip check if entity belongs to current scope (e.g., Motor_State in scope Motor)
+    const belongsToCurrentScope = entityName.startsWith(currentScope + "_");
+    if (belongsToCurrentScope) {
+      return;
+    }
+
+    // Check 2: Direct conflict - scope has a member with the same name as the entity
+    const scopeMemberNames = scopeMembers?.get(currentScope);
+    const hasConflict = scopeMemberNames?.has(entityName) ?? false;
+    if (hasConflict) {
+      throw new Error(
+        `Error: Use 'global.${entityName}.${memberName}' to access ${entityType} '${entityName}' from inside scope '${currentScope}'`,
+      );
+    }
   }
 }
 

package/src/transpiler/output/codegen/helpers/__tests__/MemberAccessValidator.test.ts

@@ -118,7 +118,8 @@ describe("MemberAccessValidator", () => {
   });
 
   describe("validateGlobalEntityAccess", () => {
-    it("throws when in scope and entity does not belong to current scope", () => {
+    it("throws when in scope and entity name conflicts with scope member", () => {
+      const scopeMembers = new Map([["Motor", new Set(["Color", "speed"])]]);
       expect(() =>
         MemberAccessValidator.validateGlobalEntityAccess(
           "Color",
@@ -126,13 +127,29 @@ describe("MemberAccessValidator", () => {
           "enum",
           "Motor",
           false,
+          { scopeMembers },
         ),
       ).toThrow(
         "Use 'global.Color.Red' to access enum 'Color' from inside scope 'Motor'",
       );
     });
 
-    it("does NOT throw when isGlobalAccess is true", () => {
+    it("does NOT throw when in scope but no naming conflict", () => {
+      const scopeMembers = new Map([["Motor", new Set(["speed"])]]);
+      expect(() =>
+        MemberAccessValidator.validateGlobalEntityAccess(
+          "Color",
+          "Red",
+          "enum",
+          "Motor",
+          false,
+          { scopeMembers },
+        ),
+      ).not.toThrow();
+    });
+
+    it("does NOT throw when isGlobalAccess is true even with conflict", () => {
+      const scopeMembers = new Map([["Motor", new Set(["Color"])]]);
       expect(() =>
         MemberAccessValidator.validateGlobalEntityAccess(
           "Color",
@@ -140,6 +157,7 @@ describe("MemberAccessValidator", () => {
           "enum",
           "Motor",
           true,
+          { scopeMembers },
         ),
       ).not.toThrow();
     });
@@ -168,7 +186,8 @@ describe("MemberAccessValidator", () => {
       ).not.toThrow();
     });
 
-    it("works with register entity type", () => {
+    it("throws for register with naming conflict", () => {
+      const scopeMembers = new Map([["Motor", new Set(["GPIO"])]]);
       expect(() =>
         MemberAccessValidator.validateGlobalEntityAccess(
           "GPIO",
@@ -176,10 +195,97 @@ describe("MemberAccessValidator", () => {
           "register",
           "Motor",
           false,
+          { scopeMembers },
         ),
       ).toThrow(
         "Use 'global.GPIO.PIN0' to access register 'GPIO' from inside scope 'Motor'",
       );
     });
+
+    it("does NOT throw for register without naming conflict", () => {
+      const scopeMembers = new Map([["Motor", new Set(["speed"])]]);
+      expect(() =>
+        MemberAccessValidator.validateGlobalEntityAccess(
+          "GPIO",
+          "PIN0",
+          "register",
+          "Motor",
+          false,
+          { scopeMembers },
+        ),
+      ).not.toThrow();
+    });
+
+    it("does NOT throw when options is undefined", () => {
+      expect(() =>
+        MemberAccessValidator.validateGlobalEntityAccess(
+          "Color",
+          "Red",
+          "enum",
+          "Motor",
+          false,
+          undefined,
+        ),
+      ).not.toThrow();
+    });
+
+    // Shadowing detection tests (using rootIdentifier and knownEnums)
+    it("throws when scope member shadows global enum (resolved identifier differs)", () => {
+      const knownEnums = new Set(["Color"]);
+      expect(() =>
+        MemberAccessValidator.validateGlobalEntityAccess(
+          "Motor_Color", // resolved to scope member
+          "Red",
+          "enum",
+          "Motor",
+          false,
+          { rootIdentifier: "Color", knownEnums },
+        ),
+      ).toThrow(
+        "Use 'global.Color.Red' to access enum 'Color' from inside scope 'Motor' (scope member 'Color' shadows the global enum)",
+      );
+    });
+
+    it("does NOT throw for shadowing when isGlobalAccess is true", () => {
+      const knownEnums = new Set(["Color"]);
+      expect(() =>
+        MemberAccessValidator.validateGlobalEntityAccess(
+          "Motor_Color",
+          "Red",
+          "enum",
+          "Motor",
+          true,
+          { rootIdentifier: "Color", knownEnums },
+        ),
+      ).not.toThrow();
+    });
+
+    it("does NOT throw when root is not a known enum", () => {
+      const knownEnums = new Set(["OtherEnum"]);
+      expect(() =>
+        MemberAccessValidator.validateGlobalEntityAccess(
+          "Motor_Color",
+          "Red",
+          "enum",
+          "Motor",
+          false,
+          { rootIdentifier: "Color", knownEnums },
+        ),
+      ).not.toThrow();
+    });
+
+    it("does NOT throw when resolved name IS a known enum", () => {
+      const knownEnums = new Set(["Color", "Motor_Color"]);
+      expect(() =>
+        MemberAccessValidator.validateGlobalEntityAccess(
+          "Motor_Color",
+          "Red",
+          "enum",
+          "Motor",
+          false,
+          { rootIdentifier: "Color", knownEnums },
+        ),
+      ).not.toThrow();
+    });
   });
 });

package/src/transpiler/state/CodeGenState.ts

@@ -90,6 +90,13 @@ export default class CodeGenState {
    */
   static symbolTable: SymbolTable = new SymbolTable();
 
+  /**
+   * External struct fields from C/C++ headers for initialization analysis.
+   * Maps struct name -> Set of non-array field names.
+   * Persists across per-file reset() calls, cleared at start of run.
+   */
+  static externalStructFields: Map<string, Set<string>> = new Map();
+
   // ===========================================================================
   // TYPE TRACKING
   // ===========================================================================
@@ -650,6 +657,39 @@ export default class CodeGenState {
     return this.symbols?.enumMembers.get(enumName);
   }
 
+  /**
+   * Build external struct fields from the symbol table.
+   * Called once per run after all headers are processed.
+   * Issue #355: Excludes array fields from init checking.
+   */
+  static buildExternalStructFields(): void {
+    this.externalStructFields.clear();
+    const allStructFields = this.symbolTable.getAllStructFields();
+
+    for (const [structName, fieldMap] of allStructFields) {
+      const nonArrayFields = new Set<string>();
+      for (const [fieldName, fieldInfo] of fieldMap) {
+        // Only include non-array fields in init checking
+        if (
+          !fieldInfo.arrayDimensions ||
+          fieldInfo.arrayDimensions.length === 0
+        ) {
+          nonArrayFields.add(fieldName);
+        }
+      }
+      if (nonArrayFields.size > 0) {
+        this.externalStructFields.set(structName, nonArrayFields);
+      }
+    }
+  }
+
+  /**
+   * Get external struct fields for initialization analysis.
+   */
+  static getExternalStructFields(): Map<string, Set<string>> {
+    return this.externalStructFields;
+  }
+
   /**
    * Get function return type.
    */

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

@@ -453,4 +453,123 @@ describe("CodeGenState", () => {
       expect(CodeGenState.isLocalArray("myArr")).toBe(true);
     });
   });
+
+  describe("buildExternalStructFields", () => {
+    it("returns empty map when no struct fields exist", () => {
+      CodeGenState.buildExternalStructFields();
+      const result = CodeGenState.getExternalStructFields();
+      expect(result.size).toBe(0);
+    });
+
+    it("includes non-array fields in result", () => {
+      // Manually add struct fields to the symbol table
+      const structFields = new Map<
+        string,
+        Map<string, { type: string; arrayDimensions?: number[] }>
+      >();
+      const pointFields = new Map<
+        string,
+        { type: string; arrayDimensions?: number[] }
+      >();
+      pointFields.set("x", { type: "i32" });
+      pointFields.set("y", { type: "i32" });
+      structFields.set("Point", pointFields);
+
+      // Use restoreStructFields to populate the symbol table
+      CodeGenState.symbolTable.restoreStructFields(structFields);
+
+      CodeGenState.buildExternalStructFields();
+      const result = CodeGenState.getExternalStructFields();
+
+      expect(result.has("Point")).toBe(true);
+      const fields = result.get("Point");
+      expect(fields?.has("x")).toBe(true);
+      expect(fields?.has("y")).toBe(true);
+    });
+
+    it("excludes array fields from result (Issue #355)", () => {
+      const structFields = new Map<
+        string,
+        Map<string, { type: string; arrayDimensions?: number[] }>
+      >();
+      const bufferFields = new Map<
+        string,
+        { type: string; arrayDimensions?: number[] }
+      >();
+      bufferFields.set("size", { type: "u32" }); // Non-array
+      bufferFields.set("data", { type: "u8", arrayDimensions: [256] }); // Array
+
+      structFields.set("Buffer", bufferFields);
+      CodeGenState.symbolTable.restoreStructFields(structFields);
+
+      CodeGenState.buildExternalStructFields();
+      const result = CodeGenState.getExternalStructFields();
+
+      expect(result.has("Buffer")).toBe(true);
+      const fields = result.get("Buffer");
+      expect(fields?.has("size")).toBe(true); // Non-array included
+      expect(fields?.has("data")).toBe(false); // Array excluded
+    });
+
+    it("excludes structs with only array fields", () => {
+      const structFields = new Map<
+        string,
+        Map<string, { type: string; arrayDimensions?: number[] }>
+      >();
+      const arrayOnlyFields = new Map<
+        string,
+        { type: string; arrayDimensions?: number[] }
+      >();
+      arrayOnlyFields.set("items", { type: "u8", arrayDimensions: [10] });
+      arrayOnlyFields.set("values", { type: "i32", arrayDimensions: [5] });
+
+      structFields.set("ArrayOnly", arrayOnlyFields);
+      CodeGenState.symbolTable.restoreStructFields(structFields);
+
+      CodeGenState.buildExternalStructFields();
+      const result = CodeGenState.getExternalStructFields();
+
+      // Struct should not be included since all fields are arrays
+      expect(result.has("ArrayOnly")).toBe(false);
+    });
+
+    it("handles mixed structs correctly", () => {
+      const structFields = new Map<
+        string,
+        Map<string, { type: string; arrayDimensions?: number[] }>
+      >();
+
+      // Struct with mixed fields
+      const mixedFields = new Map<
+        string,
+        { type: string; arrayDimensions?: number[] }
+      >();
+      mixedFields.set("id", { type: "u32" });
+      mixedFields.set("name", { type: "string", arrayDimensions: [32] });
+      mixedFields.set("count", { type: "u16" });
+
+      // Struct with only non-array
+      const simpleFields = new Map<
+        string,
+        { type: string; arrayDimensions?: number[] }
+      >();
+      simpleFields.set("value", { type: "f32" });
+
+      structFields.set("Mixed", mixedFields);
+      structFields.set("Simple", simpleFields);
+      CodeGenState.symbolTable.restoreStructFields(structFields);
+
+      CodeGenState.buildExternalStructFields();
+      const result = CodeGenState.getExternalStructFields();
+
+      // Mixed struct should have only non-array fields
+      expect(result.get("Mixed")?.size).toBe(2);
+      expect(result.get("Mixed")?.has("id")).toBe(true);
+      expect(result.get("Mixed")?.has("count")).toBe(true);
+      expect(result.get("Mixed")?.has("name")).toBe(false);
+
+      // Simple struct should have its field
+      expect(result.get("Simple")?.has("value")).toBe(true);
+    });
+  });
 });

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

@@ -1,58 +0,0 @@
-/**
- * AnalyzerContextBuilder
- * Issue #591: Extracted from Transpiler.transpileSource() to reduce complexity
- *
- * Builds the context needed for running semantic analyzers, specifically
- * converting struct field information from the symbol table format to
- * the analyzer-compatible format.
- */
-
-import SymbolTable from "../symbols/SymbolTable";
-
-/**
- * Builds analyzer context from symbol table data.
- *
- * The analyzer requires struct fields as Map<string, Set<string>> (structName -> fieldNames)
- * while the symbol table stores more detailed IStructFieldInfo. This builder handles
- * the conversion, including Issue #355's requirement to exclude array fields.
- */
-class AnalyzerContextBuilder {
-  /**
-   * Build external struct fields map for analyzer from symbol table.
-   *
-   * Converts the symbol table's detailed struct field info to the simpler
-   * format needed by InitializationAnalyzer.
-   *
-   * Issue #355: Excludes array fields from init checking since the analyzer
-   * can't prove loop-based array initialization is complete.
-   *
-   * @param symbolTable - Symbol table containing struct definitions
-   * @returns Map of struct name to set of non-array field names
-   */
-  static buildExternalStructFields(
-    symbolTable: SymbolTable,
-  ): Map<string, Set<string>> {
-    const externalStructFields = new Map<string, Set<string>>();
-    const allStructFields = symbolTable.getAllStructFields();
-
-    for (const [structName, fieldMap] of allStructFields) {
-      const nonArrayFields = new Set<string>();
-      for (const [fieldName, fieldInfo] of fieldMap) {
-        // Only include non-array fields in init checking
-        if (
-          !fieldInfo.arrayDimensions ||
-          fieldInfo.arrayDimensions.length === 0
-        ) {
-          nonArrayFields.add(fieldName);
-        }
-      }
-      if (nonArrayFields.size > 0) {
-        externalStructFields.set(structName, nonArrayFields);
-      }
-    }
-
-    return externalStructFields;
-  }
-}
-
-export default AnalyzerContextBuilder;

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

@@ -1,137 +0,0 @@
-/**
- * Unit tests for AnalyzerContextBuilder
- * Issue #591: Tests for struct field conversion utility
- */
-
-import { describe, it, expect, beforeEach } from "vitest";
-
-import AnalyzerContextBuilder from "../AnalyzerContextBuilder";
-import SymbolTable from "../../symbols/SymbolTable";
-
-describe("AnalyzerContextBuilder", () => {
-  let symbolTable: SymbolTable;
-
-  beforeEach(() => {
-    symbolTable = new SymbolTable();
-  });
-
-  describe("buildExternalStructFields", () => {
-    it("returns empty map when no struct fields exist", () => {
-      const result =
-        AnalyzerContextBuilder.buildExternalStructFields(symbolTable);
-
-      expect(result.size).toBe(0);
-    });
-
-    it("includes non-array fields in result", () => {
-      // Manually add struct fields to the symbol table
-      const structFields = new Map<
-        string,
-        Map<string, { type: string; arrayDimensions?: number[] }>
-      >();
-      const pointFields = new Map<
-        string,
-        { type: string; arrayDimensions?: number[] }
-      >();
-      pointFields.set("x", { type: "i32" });
-      pointFields.set("y", { type: "i32" });
-      structFields.set("Point", pointFields);
-
-      // Use restoreStructFields to populate the symbol table
-      symbolTable.restoreStructFields(structFields);
-
-      const result =
-        AnalyzerContextBuilder.buildExternalStructFields(symbolTable);
-
-      expect(result.has("Point")).toBe(true);
-      const fields = result.get("Point");
-      expect(fields?.has("x")).toBe(true);
-      expect(fields?.has("y")).toBe(true);
-    });
-
-    it("excludes array fields from result (Issue #355)", () => {
-      const structFields = new Map<
-        string,
-        Map<string, { type: string; arrayDimensions?: number[] }>
-      >();
-      const bufferFields = new Map<
-        string,
-        { type: string; arrayDimensions?: number[] }
-      >();
-      bufferFields.set("size", { type: "u32" }); // Non-array
-      bufferFields.set("data", { type: "u8", arrayDimensions: [256] }); // Array
-
-      structFields.set("Buffer", bufferFields);
-      symbolTable.restoreStructFields(structFields);
-
-      const result =
-        AnalyzerContextBuilder.buildExternalStructFields(symbolTable);
-
-      expect(result.has("Buffer")).toBe(true);
-      const fields = result.get("Buffer");
-      expect(fields?.has("size")).toBe(true); // Non-array included
-      expect(fields?.has("data")).toBe(false); // Array excluded
-    });
-
-    it("excludes structs with only array fields", () => {
-      const structFields = new Map<
-        string,
-        Map<string, { type: string; arrayDimensions?: number[] }>
-      >();
-      const arrayOnlyFields = new Map<
-        string,
-        { type: string; arrayDimensions?: number[] }
-      >();
-      arrayOnlyFields.set("items", { type: "u8", arrayDimensions: [10] });
-      arrayOnlyFields.set("values", { type: "i32", arrayDimensions: [5] });
-
-      structFields.set("ArrayOnly", arrayOnlyFields);
-      symbolTable.restoreStructFields(structFields);
-
-      const result =
-        AnalyzerContextBuilder.buildExternalStructFields(symbolTable);
-
-      // Struct should not be included since all fields are arrays
-      expect(result.has("ArrayOnly")).toBe(false);
-    });
-
-    it("handles mixed structs correctly", () => {
-      const structFields = new Map<
-        string,
-        Map<string, { type: string; arrayDimensions?: number[] }>
-      >();
-
-      // Struct with mixed fields
-      const mixedFields = new Map<
-        string,
-        { type: string; arrayDimensions?: number[] }
-      >();
-      mixedFields.set("id", { type: "u32" });
-      mixedFields.set("name", { type: "string", arrayDimensions: [32] });
-      mixedFields.set("count", { type: "u16" });
-
-      // Struct with only non-array
-      const simpleFields = new Map<
-        string,
-        { type: string; arrayDimensions?: number[] }
-      >();
-      simpleFields.set("value", { type: "f32" });
-
-      structFields.set("Mixed", mixedFields);
-      structFields.set("Simple", simpleFields);
-      symbolTable.restoreStructFields(structFields);
-
-      const result =
-        AnalyzerContextBuilder.buildExternalStructFields(symbolTable);
-
-      // Mixed struct should have only non-array fields
-      expect(result.get("Mixed")?.size).toBe(2);
-      expect(result.get("Mixed")?.has("id")).toBe(true);
-      expect(result.get("Mixed")?.has("count")).toBe(true);
-      expect(result.get("Mixed")?.has("name")).toBe(false);
-
-      // Simple struct should have its field
-      expect(result.get("Simple")?.has("value")).toBe(true);
-    });
-  });
-});