c-next 0.2.16 → 0.2.18

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

@@ -648,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);
@@ -673,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", () => {
@@ -708,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);
@@ -732,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");
@@ -761,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 }");
     });
   });
 
@@ -1339,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();
+    });
+  });
 });

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

@@ -1504,7 +1504,7 @@ describe("CodeGenerator", () => {
 
     it("should generate multi-dimensional array", () => {
       const source = `
-        u32[3] matrix[3];
+        u32[3][3] matrix;
         void main() { }
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -2944,7 +2944,7 @@ describe("CodeGenerator", () => {
   describe("Inferred array size", () => {
     it("should generate array with inferred size from initializer", () => {
       const source = `
-        u32 values[] <- [1, 2, 3, 4, 5];
+        u32[] values <- [1, 2, 3, 4, 5];
         void main() { }
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -3799,7 +3799,7 @@ describe("CodeGenerator", () => {
   describe("Nested array initializers", () => {
     it("should generate 2D array initializer", () => {
       const source = `
-        u32[2] matrix[3] <- [[1, 2, 3], [4, 5, 6]];
+        u32[2][3] matrix <- [[1, 2, 3], [4, 5, 6]];
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
       const generator = new CodeGenerator();
@@ -4097,7 +4097,7 @@ describe("CodeGenerator", () => {
   describe("Multi-dimensional array", () => {
     it("should generate 3D array declaration", () => {
       const source = `
-        u8[2] cube[3][4];
+        u8[2][3][4] cube;
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
       const generator = new CodeGenerator();
@@ -6932,7 +6932,7 @@ describe("CodeGenerator", () => {
         expect(code).toContain("ExternalClass obj = {}");
       });
 
-      it("should initialize known structs to {0} even in C++ mode", () => {
+      it("should initialize known structs to {} in C++ mode (Issue #1004)", () => {
         const source = `
           struct Point { i32 x; i32 y; }
           void main() {
@@ -6950,8 +6950,10 @@ describe("CodeGenerator", () => {
           cppMode: true,
         });
 
-        // Known C-Next structs are POD types, {0} works fine
-        expect(code).toContain("Point p = {0}");
+        // Issue #1004: C++ value-initialization ({}) is valid for any struct,
+        // including ones whose first field is an enum where {0} would be an
+        // invalid int->enum narrowing.
+        expect(code).toContain("Point p = {}");
       });
 
       // Note: Template type tests skipped - template argument transformation
@@ -7023,7 +7025,7 @@ describe("CodeGenerator", () => {
         expect(code).not.toContain("uint8_t* buf");
       });
 
-      it("should generate primitive C-Next style arrays with {0} in C++ mode", () => {
+      it("should generate primitive C-Next style arrays with {} in C++ mode (Issue #1004)", () => {
         const source = `
           void main() {
               u32[8] counters;
@@ -7040,8 +7042,9 @@ describe("CodeGenerator", () => {
           cppMode: true,
         });
 
-        // Primitive type arrays should still use {0}
-        expect(code).toContain("uint32_t counters[8] = {0}");
+        // Issue #1004: C++ arrays value-initialize with {} regardless of
+        // element type (one unified aggregate zero-init rule).
+        expect(code).toContain("uint32_t counters[8] = {}");
       });
 
       it("should generate unknown user type C-Next style arrays with {} in C++ mode", () => {
@@ -7065,7 +7068,7 @@ describe("CodeGenerator", () => {
         expect(code).toContain("UnknownType items[4] = {}");
       });
 
-      it("should generate known C-Next struct arrays with {0} in C++ mode", () => {
+      it("should generate known C-Next struct arrays with {} in C++ mode (Issue #1004)", () => {
         const source = `
           struct Point { i32 x; i32 y; }
           void main() {
@@ -7083,8 +7086,9 @@ describe("CodeGenerator", () => {
           cppMode: true,
         });
 
-        // Known C-Next structs are POD types, {0} is correct
-        expect(code).toContain("Point pts[3] = {0}");
+        // Issue #1004: C++ struct arrays value-initialize with {}, valid even
+        // when the struct's first field is an enum.
+        expect(code).toContain("Point pts[3] = {}");
       });
     });
   });
@@ -8450,6 +8454,17 @@ describe("CodeGenerator", () => {
         const generator = new CodeGenerator();
         const tSymbols = CNextResolver.resolve(tree, "test.cnx");
         const symbols = TSymbolInfoAdapter.convert(tSymbols);
+        // Issue #1100: SymbolTable must be wired up (as the real Transpiler
+        // pipeline always does, see setupGenerator() above) so
+        // getMemberTypeInfo() can resolve struct field array-ness. Without
+        // this, getStructFieldInfo() always returns null and the struct
+        // field's array-ness is never determined via the correct path — this
+        // test was previously passing only because a since-removed blanket
+        // "parameter -> array access" rule (Issue #579) coincidentally
+        // produced the right output for the wrong reason.
+        const symbolTable = new SymbolTable();
+        symbolTable.addTSymbols(tSymbols);
+        CodeGenState.symbolTable = symbolTable;
 
         const code = generator.generate(tree, tokenStream, {
           symbolInfo: symbols,
@@ -8483,7 +8498,7 @@ describe("CodeGenerator", () => {
       it("should handle multi-dimensional array access", () => {
         const source = `
           void test() {
-            u32[3] matrix[3];
+            u32[3][3] matrix;
             u32 val <- matrix[1][2];
           }
         `;
@@ -9420,7 +9435,9 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("(x > 3U) ? 10U : 20U");
+        // Issue #1032: Comparison operands don't get U suffix (would change semantics)
+        // but ternary arms do (they're assigned to u32 result)
+        expect(code).toContain("(x > 3) ? 10U : 20U");
       });
     });
 
@@ -11293,7 +11310,7 @@ describe("CodeGenerator", () => {
       it("should allow empty brackets for size inference", () => {
         const source = `
           void test() {
-            u8 data[] <- [1, 2, 3];
+            u8[] data <- [1, 2, 3];
           }
         `;
         const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -11309,7 +11326,7 @@ describe("CodeGenerator", () => {
         expect(code).toContain("uint8_t data[3]");
       });
 
-      it("should allow multi-dimensional C-style arrays", () => {
+      it("should reject multi-dimensional C-style arrays (Issue #1014)", () => {
         const source = `
           void test() {
             u8 matrix[4][4];
@@ -11321,6 +11338,26 @@ describe("CodeGenerator", () => {
         const tSymbols = CNextResolver.resolve(tree, "test.cnx");
         const symbols = TSymbolInfoAdapter.convert(tSymbols);
 
+        expect(() =>
+          generator.generate(tree, tokenStream, {
+            symbolInfo: symbols,
+            sourcePath: "test.cnx",
+          }),
+        ).toThrow("C-style array declaration is not allowed");
+      });
+
+      it("should allow multi-dimensional C-Next style arrays", () => {
+        const source = `
+          void test() {
+            u8[4][4] matrix;
+            matrix[0][0] <- 0;
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
         const code = generator.generate(tree, tokenStream, {
           symbolInfo: symbols,
           sourcePath: "test.cnx",
@@ -14042,7 +14079,7 @@ describe("CodeGenerator", () => {
       it("should detect array element of string array", () => {
         const source = `
           void test() {
-            string<32> names[3];
+            string<32>[3] names;
             names[0] <- "Alice";
             bool check <- (names[0] = "Alice");
           }
@@ -14086,7 +14123,7 @@ describe("CodeGenerator", () => {
       it("should register multi-dimensional array", () => {
         const source = `
           void test() {
-            u8[10] matrix[20];
+            u8[10][20] matrix;
             matrix[0][0] <- 0;
           }
         `;
@@ -14892,11 +14929,12 @@ describe("CodeGenerator", () => {
       });
     });
 
-    describe("break and continue statements", () => {
-      it("should generate break in loop", () => {
+    describe("break and continue rejection (Issue #1011)", () => {
+      it("should reject break - not part of C-Next spec", () => {
         const source = `
           void test() {
-            while (true) {
+            u32 i <- 0;
+            while (i < 10) {
               break;
             }
           }
@@ -14906,15 +14944,15 @@ describe("CodeGenerator", () => {
         const tSymbols = CNextResolver.resolve(tree, "test.cnx");
         const symbols = TSymbolInfoAdapter.convert(tSymbols);
 
-        const code = generator.generate(tree, tokenStream, {
-          symbolInfo: symbols,
-          sourcePath: "test.cnx",
-        });
-
-        expect(code).toContain("break;");
+        expect(() =>
+          generator.generate(tree, tokenStream, {
+            symbolInfo: symbols,
+            sourcePath: "test.cnx",
+          }),
+        ).toThrow("'break' is not supported in C-Next");
       });
 
-      it("should generate continue in loop", () => {
+      it("should reject continue - not part of C-Next spec", () => {
         const source = `
           void test() {
             u32 i <- 0;
@@ -14931,12 +14969,12 @@ describe("CodeGenerator", () => {
         const tSymbols = CNextResolver.resolve(tree, "test.cnx");
         const symbols = TSymbolInfoAdapter.convert(tSymbols);
 
-        const code = generator.generate(tree, tokenStream, {
-          symbolInfo: symbols,
-          sourcePath: "test.cnx",
-        });
-
-        expect(code).toContain("continue;");
+        expect(() =>
+          generator.generate(tree, tokenStream, {
+            symbolInfo: symbols,
+            sourcePath: "test.cnx",
+          }),
+        ).toThrow("'continue' is not supported in C-Next");
       });
     });
 
@@ -15632,4 +15670,94 @@ describe("CodeGenerator", () => {
       }).toThrow("Error: enum generator not registered");
     });
   });
+
+  describe("struct initializer — declaration vs expression context", () => {
+    it("should use designated initializer without type cast for global struct declaration", () => {
+      const source = `
+        struct Point { i32 x; i32 y; }
+        Point origin <- {x: 0, y: 0};
+      `;
+      const { tree, tokenStream } = CNextSourceParser.parse(source);
+      const generator = new CodeGenerator();
+      const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+      const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+      const code = generator.generate(tree, tokenStream, {
+        symbolInfo: symbols,
+        sourcePath: "test.cnx",
+      });
+
+      // Must use plain designated initializer — (Point){...} is not a C99 constant expression
+      // and fails to compile at file scope on GCC < 13
+      expect(code).toContain("origin = { .x = 0, .y = 0 }");
+      expect(code).not.toContain("(Point)");
+    });
+
+    it("should use designated initializer without type cast for local struct declaration", () => {
+      const source = `
+        struct Point { i32 x; i32 y; }
+        void foo() {
+          Point p <- {x: 10, y: 20};
+        }
+      `;
+      const { tree, tokenStream } = CNextSourceParser.parse(source);
+      const generator = new CodeGenerator();
+      const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+      const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+      const code = generator.generate(tree, tokenStream, {
+        symbolInfo: symbols,
+        sourcePath: "test.cnx",
+      });
+
+      expect(code).toContain("p = { .x = 10, .y = 20 }");
+      expect(code).not.toContain("(Point)");
+    });
+
+    it("should use designated initializer for nested struct literals in declaration", () => {
+      const source = `
+        struct Point { i32 x; i32 y; }
+        struct Line { Point start; Point end; }
+        Line seg <- {start: {x: 0, y: 0}, end: {x: 100, y: 100}};
+      `;
+      const { tree, tokenStream } = CNextSourceParser.parse(source);
+      const generator = new CodeGenerator();
+      const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+      const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+      const code = generator.generate(tree, tokenStream, {
+        symbolInfo: symbols,
+        sourcePath: "test.cnx",
+      });
+
+      // Neither outer nor inner initializer should have a type cast prefix
+      expect(code).toContain(
+        "{ .start = { .x = 0, .y = 0 }, .end = { .x = 100, .y = 100 } }",
+      );
+      expect(code).not.toContain("(Line)");
+      expect(code).not.toContain("(Point)");
+    });
+
+    it("should keep compound literal type cast for struct re-assignment (expression context)", () => {
+      const source = `
+        struct Point { i32 x; i32 y; }
+        void foo() {
+          Point p <- {x: 0, y: 0};
+          p <- {x: 10, y: 20};
+        }
+      `;
+      const { tree, tokenStream } = CNextSourceParser.parse(source);
+      const generator = new CodeGenerator();
+      const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+      const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+      const code = generator.generate(tree, tokenStream, {
+        symbolInfo: symbols,
+        sourcePath: "test.cnx",
+      });
+
+      // Re-assignment must use compound literal — plain { } is not valid as an expression
+      expect(code).toContain("p = (Point){ .x = 10, .y = 20 }");
+    });
+  });
 });

package/src/transpiler/output/codegen/__tests__/TrackVariableTypeHelpers.test.ts

@@ -27,7 +27,7 @@ describe("trackVariableTypeWithName helpers", () => {
   describe("extractArrayDimensionsSimple", () => {
     it("handles string array with single dimension", async () => {
       const source = `
-        string<32> messages[4];
+        string<32>[4] messages;
         void main() {
           messages[0] <- "Hello";
         }
@@ -39,7 +39,7 @@ describe("trackVariableTypeWithName helpers", () => {
 
     it("handles string array with multiple dimensions", async () => {
       const source = `
-        string<16> grid[2][3];
+        string<16>[2][3] grid;
         void main() {
           grid[0][0] <- "test";
         }