c-next 0.2.15 → 0.2.17

package/src/transpiler/output/codegen/CodeGenerator.ts

@@ -726,6 +726,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface.
    * ADR-045: Used to detect string comparisons and generate strcmp().
    * Issue #137: Extended to handle array element access (e.g., names[0])
+   * Issue #1030: Extended to handle struct member access (e.g., person.name)
    */
   isStringExpression(ctx: Parser.RelationalExpressionContext): boolean {
     const text = ctx.getText();
@@ -743,6 +744,11 @@ export default class CodeGenerator implements IOrchestrator {
       }
     }
 
+    // Issue #1030: Check for struct member access (e.g., person.name)
+    if (this._isStructMemberStringExpression(text)) {
+      return true;
+    }
+
     // Issue #137: Check for array element access (e.g., names[0], arr[i])
     return this._isArrayAccessStringExpression(text);
   }
@@ -800,6 +806,59 @@ export default class CodeGenerator implements IOrchestrator {
     );
   }
 
+  /**
+   * Check if struct member access expression evaluates to a string.
+   * Issue #1030: Handles patterns like person.name, config.key
+   */
+  private _isStructMemberStringExpression(text: string): boolean {
+    // Pattern: identifier.identifier (simple member access)
+    // Must not end with a property that returns a number
+    if (
+      text.endsWith(".char_count") ||
+      text.endsWith(".capacity") ||
+      text.endsWith(".size") ||
+      text.endsWith(".length") ||
+      text.endsWith(".bit_length") ||
+      text.endsWith(".byte_length") ||
+      text.endsWith(".element_count")
+    ) {
+      return false;
+    }
+
+    // Match simple struct.member pattern
+    const memberMatch = /^([a-zA-Z_]\w*)\.([a-zA-Z_]\w*)$/.exec(text);
+    if (!memberMatch) {
+      return false;
+    }
+
+    const [, varName, fieldName] = memberMatch;
+
+    // Get the struct variable's type
+    const typeInfo = CodeGenState.getVariableTypeInfo(varName);
+    if (!typeInfo) {
+      return false;
+    }
+
+    // Get the struct type name - it might be directly the baseType
+    // or we might need to look it up by the variable's type
+    const structTypeName = typeInfo.baseType;
+    if (!structTypeName) {
+      return false;
+    }
+
+    // Look up the field type from the struct
+    const fieldType = CodeGenState.getStructFieldType(
+      structTypeName,
+      fieldName,
+    );
+    if (!fieldType) {
+      return false;
+    }
+
+    // Check if the field is a string type (e.g., "string<64>")
+    return fieldType.startsWith("string");
+  }
+
   /**
    * Get type of additive expression.
    * Part of IOrchestrator interface - delegates to private implementation.
@@ -1311,9 +1370,10 @@ export default class CodeGenerator implements IOrchestrator {
    * ADR-017: Handle enum types by initializing to first member
    */
   getZeroInitializer(typeCtx: Parser.TypeContext, isArray: boolean): string {
-    // Issue #379: Arrays need element type checking for C++ classes
+    // Issue #379 / #1004: arrays zero-init with the aggregate brace ({} in
+    // C++, {0} in C) regardless of element type.
     if (isArray) {
-      return this._getArrayZeroInitializer(typeCtx);
+      return this._getAggregateZeroInitBrace();
     }
 
     // Handle named types (scoped, global, qualified, user)
@@ -1323,11 +1383,10 @@ export default class CodeGenerator implements IOrchestrator {
       if (CodeGenState.symbols!.knownEnums.has(resolved.name)) {
         return this._getEnumZeroValue(resolved.name, resolved.separator);
       }
-      // Check if C++ type needing {} (only for userType, not qualified/scoped/global)
-      if (resolved.checkCppType && this._needsEmptyBraceInit(resolved.name)) {
-        return "{}";
-      }
-      return "{0}";
+      // Issue #1004: struct/class zero-init. C++ value-initialization ({})
+      // works for every aggregate (including ones whose first field is an
+      // enum, where {0} is an invalid int->enum narrowing); C uses {0}.
+      return this._getAggregateZeroInitBrace();
     }
 
     // Issue #295: C++ template types use value initialization {}
@@ -1335,6 +1394,11 @@ export default class CodeGenerator implements IOrchestrator {
       return "{}";
     }
 
+    // Issue #1019: string<N> types use empty string initializer
+    if (typeCtx.stringType()) {
+      return '""';
+    }
+
     // Primitive types use lookup map
     if (typeCtx.primitiveType()) {
       const primType = typeCtx.primitiveType()!.getText();
@@ -1490,9 +1554,9 @@ export default class CodeGenerator implements IOrchestrator {
               if (p.isArray) {
                 // Array parameters: type name[]
                 return `${constMod}${p.type} ${p.name}${p.arrayDims}`;
-              } else if (p.isPointer) {
-                // ADR-006: Non-array, non-callback parameters become pointers
-                // In C++ mode, use reference (&) instead of pointer (*)
+              } else if (p.isStruct) {
+                // ADR-006: Struct parameters become pointers (C) or references (C++)
+                // Only struct types get pointer/reference semantics, not primitives
                 const ptrOrRef = this.isCppMode() ? "&" : "*";
                 return `${constMod}${p.type}${ptrOrRef}`;
               } else {
@@ -1776,7 +1840,17 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     if (ctx.IDENTIFIER()) {
-      return this._resolveIdentifierExpression(ctx.IDENTIFIER()!.getText());
+      const id = ctx.IDENTIFIER()!.getText();
+      // Issue #1011: break/continue are not part of C-Next - use structured conditions
+      // ADR-026 (Status: Rejected) explicitly excludes break/continue from the language
+      if (id === "break" || id === "continue") {
+        const line = ctx.start?.line ?? 0;
+        const col = ctx.start?.column ?? 0;
+        throw new Error(
+          `${line}:${col} error[E0703]: '${id}' is not supported in C-Next - use structured conditions instead`,
+        );
+      }
+      return this._resolveIdentifierExpression(id);
     }
     if (ctx.literal()) {
       return this._generateLiteralExpression(ctx.literal()!);
@@ -2085,15 +2159,6 @@ export default class CodeGenerator implements IOrchestrator {
     return identifiers.join("_");
   }
 
-  /**
-   * Issue #304: Check if a type name is from a C++ header
-   * Used to determine whether to use {} or {0} for initialization.
-   * C++ types with constructors may fail with {0} but work with {}.
-   */
-  private isCppType(typeName: string): boolean {
-    return SymbolLookupHelper.isCppType(CodeGenState.symbolTable, typeName);
-  }
-
   /**
    * Generate C code from a C-Next program
    * @param tree The parsed C-Next program
@@ -2689,6 +2754,7 @@ export default class CodeGenerator implements IOrchestrator {
       type: string;
       isConst: boolean;
       isPointer: boolean;
+      isStruct: boolean;
       isArray: boolean;
       arrayDims: string;
     }> = [];
@@ -2704,6 +2770,8 @@ export default class CodeGenerator implements IOrchestrator {
 
         // ADR-029: Check if parameter type is itself a callback type
         const isCallbackParam = CodeGenState.callbackTypes.has(typeName);
+        // ADR-006: Check if parameter type is a struct (for pointer/reference semantics)
+        const isStruct = this.isStructType(typeName);
 
         let paramType: string;
         let isPointer: boolean;
@@ -2715,8 +2783,8 @@ export default class CodeGenerator implements IOrchestrator {
           isPointer = false; // Function pointers are already pointers
         } else {
           paramType = this.generateType(param.type());
-          // ADR-006: Non-array parameters become pointers
-          isPointer = !isArray;
+          // ADR-006: Non-array struct parameters become pointers in C mode
+          isPointer = !isArray && isStruct;
         }
 
         let arrayDims: string;
@@ -2739,6 +2807,7 @@ export default class CodeGenerator implements IOrchestrator {
           type: paramType,
           isConst,
           isPointer,
+          isStruct,
           isArray,
           arrayDims,
         });
@@ -3211,7 +3280,7 @@ export default class CodeGenerator implements IOrchestrator {
     decl += this._getStringCapacityDimension(varDecl.type());
 
     if (varDecl.expression()) {
-      decl += ` = ${this.generateExpression(varDecl.expression()!)}`;
+      decl += ` = ${CodeGenState.withDeclarationInit(() => this.generateExpression(varDecl.expression()!))}`;
     } else {
       // ADR-015: Zero initialization for uninitialized scope variables
       decl += ` = ${this.getZeroInitializer(varDecl.type(), isArray)}`;
@@ -3495,8 +3564,9 @@ export default class CodeGenerator implements IOrchestrator {
     );
 
     if (!fieldList) {
-      // Empty initializer: Point {} -> (Point){ 0 } or {} for C++ classes
-      return isCppClass ? "{}" : `(${castType}){ 0 }`;
+      // Empty initializer: Point {} -> { 0 } in declaration context, (Point){ 0 } elsewhere
+      if (isCppClass) return "{}";
+      return CodeGenState.inDeclarationInit ? "{ 0 }" : `(${castType}){ 0 }`;
     }
 
     // Get field type info for nested initializers
@@ -3507,28 +3577,10 @@ export default class CodeGenerator implements IOrchestrator {
 
     const fields = fieldList.fieldInitializer().map((field) => {
       const fieldName = field.IDENTIFIER().getText();
-
-      // Compute expected type for nested initializers
-      let fieldType: string | undefined;
-      if (structFieldTypes?.has(fieldName)) {
-        // Issue #502: Convert underscore format to correct output format
-        // C-Next struct fields may store C++ types with _ separator (e.g., SeaDash_Parse_ParseResult)
-        // but code generation needs :: for C++ types (e.g., SeaDash::Parse::ParseResult)
-        fieldType = structFieldTypes.get(fieldName)!;
-        if (fieldType.includes("_")) {
-          // Check if this looks like a qualified type (contains _) and convert
-          const parts = fieldType.split("_");
-          if (parts.length > 1 && this.isCppScopeSymbol(parts[0])) {
-            // It's a C++ namespaced type - convert _ to ::
-            fieldType = parts.join("::");
-          }
-        }
-      }
-
+      const fieldType = this._resolveFieldType(fieldName, structFieldTypes);
       const value = CodeGenState.withExpectedType(fieldType, () =>
         this.generateExpression(field.expression()),
       );
-
       return { fieldName, value };
     });
 
@@ -3545,6 +3597,23 @@ export default class CodeGenerator implements IOrchestrator {
     // For C-Next/C structs, generate designated initializer
     const fieldInits = fields.map((f) => `.${f.fieldName} = ${f.value}`);
 
+    return this.formatStructInitializer(typeName, castType, fieldInits);
+  }
+
+  private formatStructInitializer(
+    typeName: string,
+    castType: string,
+    fieldInits: string[],
+  ): string {
+    const initializer: string = `{ ${fieldInits.join(", ")} }`;
+
+    // In a declaration initializer context, use plain designated initializer — no type cast
+    // prefix needed, and compound literals are not C99 constant expressions so they fail
+    // at file scope on GCC < 13.
+    if (CodeGenState.inDeclarationInit) {
+      return initializer;
+    }
+
     // Issue #882: In C++ mode, anonymous structs/unions must use plain brace init.
     // Compound literals like (struct { ... }){ ... } create incompatible types in C++
     // because each struct { ... } definition creates a distinct nominal type.
@@ -3552,10 +3621,33 @@ export default class CodeGenerator implements IOrchestrator {
       CodeGenState.cppMode &&
       (typeName.startsWith("struct {") || typeName.startsWith("union {"))
     ) {
-      return `{ ${fieldInits.join(", ")} }`;
+      return initializer;
     }
 
-    return `(${castType}){ ${fieldInits.join(", ")} }`;
+    if (!CodeGenState.inFunctionBody) {
+      return initializer;
+    }
+
+    return `(${castType})${initializer}`;
+  }
+
+  /**
+   * Resolve the C type string for a named struct field, converting C++ underscore-separated
+   * names to :: notation. Returns undefined if the field is not in the type map.
+   * Issue #502: C-Next stores C++ types with _ separator; codegen needs ::.
+   */
+  private _resolveFieldType(
+    fieldName: string,
+    structFieldTypes: Map<string, string> | undefined,
+  ): string | undefined {
+    if (!structFieldTypes?.has(fieldName)) return undefined;
+    const fieldType = structFieldTypes.get(fieldName)!;
+    if (!fieldType.includes("_")) return fieldType;
+    const parts = fieldType.split("_");
+    if (parts.length > 1 && this.isCppScopeSymbol(parts[0])) {
+      return parts.join("::");
+    }
+    return fieldType;
   }
 
   /**
@@ -3776,6 +3868,8 @@ export default class CodeGenerator implements IOrchestrator {
       forceConst,
       isTypedefStructType: (t) =>
         CodeGenState.symbolTable?.isTypedefStructType(t) ?? false,
+      // Issue #995: Opaque handles should not get auto-const
+      isOpaqueType: (t) => CodeGenState.isOpaqueType(t),
     });
 
     // Use shared builder with C/C++ mode
@@ -4102,31 +4196,13 @@ export default class CodeGenerator implements IOrchestrator {
   // and _generateConstructorDecl have been extracted to VariableDeclHelper.ts
 
   /**
-   * Get zero initializer for array types.
-   * Issue #379: C++ class arrays must use {} instead of {0}
+   * Brace initializer that zero-initializes an aggregate (struct or array).
+   * Issue #379 / #1004: C++ uses value-initialization ({}), which is valid for
+   * any aggregate element type (POD, struct, class) including enum-first
+   * structs where {0} is an invalid int->enum narrowing; C uses {0}.
    */
-  private _getArrayZeroInitializer(typeCtx: Parser.TypeContext): string {
-    // Check if element type is a C++ class or template type
-    if (typeCtx.userType()) {
-      const typeName = typeCtx.userType()!.getText();
-      if (this._needsEmptyBraceInit(typeName)) {
-        return "{}";
-      }
-    }
-    // Also check C-Next style array type (e.g., CppClass[4]) where
-    // the userType is nested inside arrayType.
-    if (typeCtx.arrayType()?.userType()) {
-      const typeName = typeCtx.arrayType()!.userType()!.getText();
-      if (this._needsEmptyBraceInit(typeName)) {
-        return "{}";
-      }
-    }
-    // Template types are always C++ classes
-    if (typeCtx.templateType()) {
-      return "{}";
-    }
-    // Default: POD arrays use {0}
-    return "{0}";
+  private _getAggregateZeroInitBrace(): string {
+    return CodeGenState.cppMode ? "{}" : "{0}";
   }
 
   /**
@@ -4158,20 +4234,19 @@ export default class CodeGenerator implements IOrchestrator {
 
   /**
    * Resolve full type name from any TypeContext variant.
-   * Returns { name, separator, checkCppType } or null if not a named type.
+   * Returns { name, separator } or null if not a named type.
    * ADR-016: Handles scoped, global, qualified, and user types
-   * checkCppType: only true for userType (original behavior preserved)
    */
   private _resolveTypeNameFromContext(
     typeCtx: Parser.TypeContext,
-  ): { name: string; separator: string; checkCppType: boolean } | null {
+  ): { name: string; separator: string } | null {
     // ADR-016: Check for scoped types (this.Type)
     if (typeCtx.scopedType()) {
       const localName = typeCtx.scopedType()!.IDENTIFIER().getText();
       const name = CodeGenState.currentScope
         ? `${CodeGenState.currentScope}_${localName}`
         : localName;
-      return { name, separator: "_", checkCppType: false };
+      return { name, separator: "_" };
     }
 
     // Issue #478: Check for global types (global.Type)
@@ -4179,7 +4254,6 @@ export default class CodeGenerator implements IOrchestrator {
       return {
         name: typeCtx.globalType()!.IDENTIFIER().getText(),
         separator: "_",
-        checkCppType: false,
       };
     }
 
@@ -4189,7 +4263,7 @@ export default class CodeGenerator implements IOrchestrator {
       const parts = typeCtx.qualifiedType()!.IDENTIFIER();
       const name = this.resolveQualifiedType(parts.map((id) => id.getText()));
       const separator = name.includes("::") ? "::" : "_";
-      return { name, separator, checkCppType: false };
+      return { name, separator };
     }
 
     // Check for user-defined types (structs/classes/enums)
@@ -4197,28 +4271,12 @@ export default class CodeGenerator implements IOrchestrator {
       return {
         name: typeCtx.userType()!.getText(),
         separator: "_",
-        checkCppType: true,
       };
     }
 
     return null;
   }
 
-  /**
-   * Check if a type needs empty brace initialization {}.
-   * Issue #304: C++ types with constructors may fail with {0}
-   * Issue #309: Unknown user types in C++ mode may have non-trivial constructors
-   */
-  private _needsEmptyBraceInit(typeName: string): boolean {
-    // C++ types (external libraries with constructors)
-    if (this.isCppType(typeName)) {
-      return true;
-    }
-    // In C++ mode, unknown user types may have non-trivial constructors
-    // Known structs (C-Next or C headers) are POD types where {0} works
-    return CodeGenState.cppMode && !this.isKnownStruct(typeName);
-  }
-
   /**
    * Generate a safe bit mask expression.
    * Avoids undefined behavior when width >= 32 for 32-bit integers.
@@ -4750,8 +4808,7 @@ export default class CodeGenerator implements IOrchestrator {
     // MISRA 10.3: Cast limit macros to target type (they have type 'int')
     const finalCast = CppModeHelper.cast(targetType, `(${expr})`);
     const castMax = CppModeHelper.cast(targetType, maxValue);
-    const castMin =
-      minValue === "0" ? "0" : CppModeHelper.cast(targetType, minValue);
+    const castMin = CppModeHelper.cast(targetType, minValue);
     return `((${expr}) > ${maxComparison} ? ${castMax} : (${expr}) < ${minComparison} ? ${castMin} : ${finalCast})`;
   }
 

package/src/transpiler/output/codegen/__tests__/CodeGenerator.coverage.test.ts

@@ -502,9 +502,10 @@ describe("CodeGenerator Coverage Tests", () => {
     });
 
     it("should generate scope with private function", () => {
+      // ADR-016: Functions are public by default, so explicit 'private' needed
       const source = `
         scope Motor {
-          void internalUpdate() {}
+          private void internalUpdate() {}
         }
       `;
       const { code } = setupGenerator(source);
@@ -647,12 +648,15 @@ describe("CodeGenerator Coverage Tests", () => {
   // Issue #834: generateStructInitializer with named struct tags
   // ==========================================================================
   describe("generateStructInitializer() with named struct tags", () => {
-    it("should include struct keyword in compound literal for named struct tags", () => {
-      // Test the fix for issue #834: named struct tags need 'struct' prefix in cast
+    it("should include struct keyword in compound literal for named struct tags (assignment context)", () => {
+      // Test the fix for issue #834: named struct tags need 'struct' prefix in cast.
+      // In declaration context, no compound literal is emitted.
+      // In assignment (expression) context, the struct keyword must be present.
       const source = `
         struct NamedPoint { i32 x; i32 y; }
         void test() {
-          NamedPoint p <- {x: 10, y: 20};
+          NamedPoint p <- {x: 0, y: 0};
+          p <- {x: 10, y: 20};
         }
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -672,10 +676,10 @@ describe("CodeGenerator Coverage Tests", () => {
         cppMode: false,
       });
 
-      // The compound literal cast should include 'struct' keyword
-      expect(code).toContain("(struct NamedPoint)");
-      expect(code).toContain(".x = 10");
-      expect(code).toContain(".y = 20");
+      // Declaration uses plain designated initializer (no compound literal)
+      expect(code).toContain("p = { .x = 0, .y = 0 }");
+      // Assignment (expression context) must keep compound literal with struct keyword
+      expect(code).toContain("(struct NamedPoint){ .x = 10, .y = 20 }");
     });
 
     it("should include struct keyword in empty initializer via return statement", () => {
@@ -707,12 +711,14 @@ describe("CodeGenerator Coverage Tests", () => {
       expect(code).toContain("(struct ReturnStruct){ 0 }");
     });
 
-    it("should NOT include struct keyword for typedef'd structs in C mode", () => {
-      // This tests the branch where checkNeedsStructKeyword returns false
+    it("should NOT include struct keyword for typedef'd structs in assignment context", () => {
+      // This tests the branch where checkNeedsStructKeyword returns false.
+      // Compound literals (expression context) for typedef'd structs must NOT have 'struct'.
       const source = `
         struct TypedefPoint { i32 x; i32 y; }
         void test() {
-          TypedefPoint p <- {x: 1, y: 2};
+          TypedefPoint p <- {x: 0, y: 0};
+          p <- {x: 1, y: 2};
         }
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -731,22 +737,23 @@ describe("CodeGenerator Coverage Tests", () => {
         cppMode: false,
       });
 
-      // Should NOT have 'struct' keyword since it's not marked
+      // Assignment (expression context) should use plain type, no 'struct' keyword
       expect(code).not.toContain("(struct TypedefPoint)");
-      expect(code).toContain("(TypedefPoint)");
+      expect(code).toContain("(TypedefPoint){ .x = 1, .y = 2 }");
     });
 
-    it("should NOT include struct keyword in C++ mode", () => {
+    it("should NOT include struct keyword in C++ mode (assignment context)", () => {
+      // Even if marked, C++ mode should not use struct keyword in compound literals.
       const source = `
         struct CppPoint { i32 x; i32 y; }
         void test() {
-          CppPoint p <- {x: 5, y: 10};
+          CppPoint p <- {x: 0, y: 0};
+          p <- {x: 5, y: 10};
         }
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
 
       const symbolTable = new SymbolTable();
-      // Even if marked, C++ mode should not use struct keyword
       symbolTable.markNeedsStructKeyword("CppPoint");
 
       const tSymbols = CNextResolver.resolve(tree, "test.cnx");
@@ -760,9 +767,9 @@ describe("CodeGenerator Coverage Tests", () => {
         cppMode: true,
       });
 
-      // In C++ mode, struct keyword should NOT be in the cast
+      // Assignment (expression context) in C++ mode must not use 'struct' keyword
       expect(code).not.toContain("(struct CppPoint)");
-      expect(code).toContain("(CppPoint)");
+      expect(code).toContain("(CppPoint){ .x = 5, .y = 10 }");
     });
   });
 
@@ -1338,4 +1345,146 @@ describe("CodeGenerator Coverage Tests", () => {
       expect(code).not.toContain("widget_t* w");
     });
   });
+
+  // ==========================================================================
+  // PR: _generateScopeVariable with struct initializer (line 3214)
+  // Covers withDeclarationInit wrapping in scope variable declarations
+  // ==========================================================================
+  describe("_generateScopeVariable() with struct initializer", () => {
+    it("should use plain designated initializer for scope struct variable", () => {
+      const source = `
+        struct Settings { i32 timeout; i32 retries; }
+        scope Config {
+          public Settings defaults <- {timeout: 30, retries: 3};
+        }
+      `;
+      const { code } = setupGenerator(source);
+      // Scope variable initializer uses withDeclarationInit, producing plain designated init
+      expect(code).toContain(".timeout = 30");
+      expect(code).toContain(".retries = 3");
+      // Should NOT have compound literal prefix in declaration context
+      expect(code).not.toContain("(Settings){ .timeout");
+    });
+
+    it("should use plain designated initializer for private scope struct variable", () => {
+      const source = `
+        struct Point { i32 x; i32 y; }
+        scope Drawing {
+          Point origin <- {x: 0, y: 0};
+        }
+      `;
+      const { code } = setupGenerator(source);
+      expect(code).toContain(
+        "static Point Drawing_origin = { .x = 0, .y = 0 }",
+      );
+    });
+  });
+
+  // ==========================================================================
+  // PR: formatStructInitializer with inDeclarationInit (line 3544)
+  // Covers the plain designated initializer path in declaration context
+  // ==========================================================================
+  describe("formatStructInitializer() in declaration context", () => {
+    it("should use plain designated init (no compound literal) for global struct variable", () => {
+      const source = `
+        struct Point { i32 x; i32 y; }
+        Point origin <- {x: 0, y: 0};
+      `;
+      const { code } = setupGenerator(source);
+      // Global declaration: plain designated init, no compound literal prefix
+      expect(code).toContain("Point origin = { .x = 0, .y = 0 }");
+      expect(code).not.toContain("(Point){ .x");
+    });
+
+    it("should use compound literal for struct in assignment context", () => {
+      const source = `
+        struct Point { i32 x; i32 y; }
+        void main() {
+          Point p <- {x: 0, y: 0};
+          p <- {x: 10, y: 20};
+        }
+      `;
+      const { code } = setupGenerator(source);
+      // Declaration: plain init
+      expect(code).toContain("Point p = { .x = 0, .y = 0 }");
+      // Assignment: compound literal with type cast
+      expect(code).toContain("(Point){ .x = 10, .y = 20 }");
+    });
+  });
+
+  // ==========================================================================
+  // PR: _resolveFieldType with underscore field types (lines 3577-3581)
+  // Covers the C++ underscore-to-:: conversion path
+  // ==========================================================================
+  describe("_resolveFieldType() with underscore types", () => {
+    it("should convert underscore type to :: when first part is a C++ namespace", () => {
+      const source = `
+        struct Outer { i32 dummy; }
+        void main() {
+          Outer o <- {dummy: 1};
+        }
+      `;
+      const { tree, tokenStream } = CNextSourceParser.parse(source);
+
+      const symbolTable = new SymbolTable();
+      const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+      symbolTable.addTSymbols(tSymbols);
+      const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+      // Register a C++ namespace so isCppScopeSymbol("SeaDash") returns true
+      symbolTable.addCppSymbol({
+        kind: "namespace",
+        name: "SeaDash",
+        sourceFile: "SeaDash.h",
+        sourceLine: 1,
+        sourceLanguage: ESourceLanguage.Cpp,
+        isExported: true,
+      });
+
+      // Register struct field type with underscore (simulates C++ imported struct)
+      symbolTable.addStructField("Outer", "dummy", "SeaDash_Parse_Result");
+
+      const generator = new CodeGenerator();
+      CodeGenState.symbolTable = symbolTable;
+      const code = generator.generate(tree, tokenStream, {
+        symbolInfo: symbols,
+        sourcePath: "test.cnx",
+        cppMode: false,
+      });
+
+      // The field type should be converted from SeaDash_Parse_Result to SeaDash::Parse::Result
+      // This exercises _resolveFieldType lines 3577-3579
+      expect(code).toBeDefined();
+    });
+
+    it("should keep underscore type when first part is not a C++ namespace", () => {
+      const source = `
+        struct Data { i32 value; }
+        void main() {
+          Data d <- {value: 42};
+        }
+      `;
+      const { tree, tokenStream } = CNextSourceParser.parse(source);
+
+      const symbolTable = new SymbolTable();
+      const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+      symbolTable.addTSymbols(tSymbols);
+      const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+      // Register struct field type with underscore but NOT a C++ namespace
+      symbolTable.addStructField("Data", "value", "some_plain_type");
+
+      const generator = new CodeGenerator();
+      CodeGenState.symbolTable = symbolTable;
+      const code = generator.generate(tree, tokenStream, {
+        symbolInfo: symbols,
+        sourcePath: "test.cnx",
+        cppMode: false,
+      });
+
+      // The field type should remain unchanged (not a C++ namespace)
+      // This exercises _resolveFieldType line 3581
+      expect(code).toBeDefined();
+    });
+  });
 });