c-next 0.1.62 → 0.1.64

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

@@ -1466,7 +1466,7 @@ describe("CodeGenerator", () => {
   describe("Array declarations", () => {
     it("should generate array declaration", () => {
       const source = `
-        u32 arr[10];
+        u32[10] arr;
         void main() { }
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -1485,7 +1485,7 @@ describe("CodeGenerator", () => {
 
     it("should generate array with initializer", () => {
       const source = `
-        u32 arr[3] <- [1, 2, 3];
+        u32[3] arr <- [1, 2, 3];
         void main() { }
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -1505,7 +1505,7 @@ describe("CodeGenerator", () => {
 
     it("should generate multi-dimensional array", () => {
       const source = `
-        u32 matrix[3][3];
+        u32[3] matrix[3];
         void main() { }
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -2586,7 +2586,7 @@ describe("CodeGenerator", () => {
   describe("Array element assignment", () => {
     it("should generate array element assignment", () => {
       const source = `
-        wrap u32 arr[10];
+        wrap u32[10] arr;
         void main() {
           arr[0] <- 42;
           arr[5] <- 100;
@@ -2734,7 +2734,7 @@ describe("CodeGenerator", () => {
     it("should generate struct with array field", () => {
       const source = `
         struct Buffer {
-          u8 data[64];
+          u8[64] data;
           u32 length;
         }
       `;
@@ -3297,7 +3297,7 @@ describe("CodeGenerator", () => {
     it("should generate struct with array member access", () => {
       const source = `
         struct Buffer {
-          u8 data[64];
+          u8[64] data;
         }
         Buffer buf;
         void main() {
@@ -3427,7 +3427,7 @@ describe("CodeGenerator", () => {
   describe("Const array", () => {
     it("should generate const array", () => {
       const source = `
-        const u32 LOOKUP[4] <- [10, 20, 30, 40];
+        const u32[4] LOOKUP <- [10, 20, 30, 40];
         void main() { }
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -3853,7 +3853,7 @@ describe("CodeGenerator", () => {
   describe("Array fill-all syntax", () => {
     it("should generate fill-all array [0*]", () => {
       const source = `
-        u32 data[10] <- [0*];
+        u32[10] data <- [0*];
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
       const generator = new CodeGenerator();
@@ -3872,7 +3872,7 @@ describe("CodeGenerator", () => {
 
     it("should generate fill-all array with non-zero value", () => {
       const source = `
-        u8 buffer[4] <- [255*];
+        u8[4] buffer <- [255*];
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
       const generator = new CodeGenerator();
@@ -3893,7 +3893,7 @@ describe("CodeGenerator", () => {
   describe("Nested array initializers", () => {
     it("should generate 2D array initializer", () => {
       const source = `
-        u32 matrix[2][3] <- [[1, 2, 3], [4, 5, 6]];
+        u32[2] matrix[3] <- [[1, 2, 3], [4, 5, 6]];
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
       const generator = new CodeGenerator();
@@ -3914,7 +3914,7 @@ describe("CodeGenerator", () => {
     it("should generate array of struct initializers", () => {
       const source = `
         struct Point { i32 x; i32 y; }
-        Point points[2] <- [{x: 1, y: 2}, {x: 3, y: 4}];
+        Point[2] points <- [{x: 1, y: 2}, {x: 3, y: 4}];
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
       const generator = new CodeGenerator();
@@ -4184,7 +4184,7 @@ describe("CodeGenerator", () => {
     it("should resolve const as array dimension at file scope", () => {
       const source = `
         const u32 SIZE <- 10;
-        u32 data[SIZE];
+        u32[SIZE] data;
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
       const generator = new CodeGenerator();
@@ -4205,7 +4205,7 @@ describe("CodeGenerator", () => {
   describe("Multi-dimensional array", () => {
     it("should generate 3D array declaration", () => {
       const source = `
-        u8 cube[2][3][4];
+        u8[2] cube[3][4];
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
       const generator = new CodeGenerator();
@@ -4686,7 +4686,7 @@ describe("CodeGenerator", () => {
   describe("Array indexing with expressions", () => {
     it("should generate array index with arithmetic", () => {
       const source = `
-        u32 data[10];
+        u32[10] data;
         wrap u32 i <- 2;
         void main() {
           data[i * 2 + 1] <- 42;
@@ -4877,7 +4877,7 @@ describe("CodeGenerator", () => {
   describe("Array length", () => {
     it("should generate array length using sizeof", () => {
       const source = `
-        u32 data[10];
+        u32[10] data;
         u32 len <- data.length;
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -5285,7 +5285,7 @@ describe("CodeGenerator", () => {
     it("should pass array without address-of operator", () => {
       const source = `
         void processData(u32 data[]) { }
-        u32 myData[5];
+        u32[5] myData;
         void main() {
           processData(myData);
         }
@@ -5310,7 +5310,7 @@ describe("CodeGenerator", () => {
     it("should generate struct with array field", () => {
       const source = `
         struct Buffer {
-          u8 data[64];
+          u8[64] data;
           u32 length;
         }
       `;
@@ -5694,7 +5694,7 @@ describe("CodeGenerator", () => {
   describe("Array bounds checking", () => {
     it("should throw error for out-of-bounds constant index", () => {
       const source = `
-        u32 data[5];
+        u32[5] data;
         void main() {
           data[10] <- 1;
         }
@@ -5899,7 +5899,7 @@ describe("CodeGenerator", () => {
   describe("Sizeof variable", () => {
     it("should generate sizeof for variable", () => {
       const source = `
-        u32 arr[10];
+        u32[10] arr;
         u32 size <- sizeof(arr);
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -5921,7 +5921,7 @@ describe("CodeGenerator", () => {
     it("should resolve const to literal for file-scope array", () => {
       const source = `
         const u32 BUFFER_SIZE <- 256;
-        u8 buffer[BUFFER_SIZE];
+        u8[BUFFER_SIZE] buffer;
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
       const generator = new CodeGenerator();
@@ -6056,7 +6056,7 @@ describe("CodeGenerator", () => {
     it("should generate struct with array field access", () => {
       const source = `
         struct Message {
-          u8 data[8];
+          u8[8] data;
           u8 length;
         }
         Message msg;
@@ -6166,7 +6166,7 @@ describe("CodeGenerator", () => {
       const source = `
         void setup() {
           const u32 SIZE <- 5;
-          u32 data[SIZE];
+          u32[SIZE] data;
         }
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -6181,7 +6181,8 @@ describe("CodeGenerator", () => {
       });
 
       expect(code).toContain("SIZE");
-      expect(code).toContain("[SIZE]");
+      // Const value is evaluated at compile time
+      expect(code).toContain("data[5]");
     });
   });
 
@@ -6666,7 +6667,7 @@ describe("CodeGenerator", () => {
 
   describe("Array with literal size", () => {
     it("should generate array with integer literal size", () => {
-      const source = `u32 buffer[100];`;
+      const source = `u32[100] buffer;`;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
       const generator = new CodeGenerator();
       const symbolTable = new SymbolTable();
@@ -6793,7 +6794,7 @@ describe("CodeGenerator", () => {
 
   describe("Array initialization with values", () => {
     it("should generate array with initialization list", () => {
-      const source = `u8 data[4] <- [1, 2, 3, 4];`;
+      const source = `u8[4] data <- [1, 2, 3, 4];`;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
       const generator = new CodeGenerator();
       const symbolTable = new SymbolTable();
@@ -6814,7 +6815,7 @@ describe("CodeGenerator", () => {
       const source = `
         void process(u8 arr[]) { }
         void main() {
-          u8 local[10];
+          u8[10] local;
           process(local);
         }
       `;
@@ -7081,7 +7082,7 @@ describe("CodeGenerator", () => {
       it("should initialize POD arrays to {0}", () => {
         const source = `
           void main() {
-            u32 values[10];
+            u32[10] values;
           }
         `;
         const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -7102,7 +7103,7 @@ describe("CodeGenerator", () => {
         const source = `
           struct Point { i32 x; i32 y; }
           void main() {
-            Point points[5];
+            Point[5] points;
           }
         `;
         const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -7168,6 +7169,142 @@ describe("CodeGenerator", () => {
 
       // Note: Template type tests skipped - template argument transformation
       // (i32 -> int32_t) is a separate issue to be addressed in another PR
+
+      it("should generate C-Next style array params with dimensions in C++ mode", () => {
+        const source = `
+          void fill(u8[8] buf) {
+              buf[0] <- 0xFF;
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+          cppMode: true,
+        });
+
+        // C-Next style u8[8] param should generate uint8_t buf[8], not uint8_t& buf
+        expect(code).toContain("uint8_t buf[8]");
+        expect(code).not.toContain("uint8_t& buf");
+        expect(code).not.toContain("uint8_t&  buf");
+      });
+
+      it("should generate const C-Next style array params in C++ mode", () => {
+        const source = `
+          u8 read(const u8[4] data) {
+              return data[0];
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+          cppMode: true,
+        });
+
+        // Const C-Next style array param should retain dimension
+        expect(code).toContain("const uint8_t data[4]");
+        expect(code).not.toContain("const uint8_t& data");
+      });
+
+      it("should generate C-Next style array params in C mode too", () => {
+        const source = `
+          void fill(u8[8] buf) {
+              buf[0] <- 0xFF;
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+        });
+
+        // C mode should also generate uint8_t buf[8]
+        expect(code).toContain("uint8_t buf[8]");
+        expect(code).not.toContain("uint8_t* buf");
+      });
+
+      it("should generate primitive C-Next style arrays with {0} in C++ mode", () => {
+        const source = `
+          void main() {
+              u32[8] counters;
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+          cppMode: true,
+        });
+
+        // Primitive type arrays should still use {0}
+        expect(code).toContain("uint32_t counters[8] = {0}");
+      });
+
+      it("should generate unknown user type C-Next style arrays with {} in C++ mode", () => {
+        const source = `
+          void main() {
+              UnknownType[4] items;
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+          cppMode: true,
+        });
+
+        // Unknown types in C++ mode use {} (may have non-trivial constructors)
+        expect(code).toContain("UnknownType items[4] = {}");
+      });
+
+      it("should generate known C-Next struct arrays with {0} in C++ mode", () => {
+        const source = `
+          struct Point { i32 x; i32 y; }
+          void main() {
+              Point[3] pts;
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+          cppMode: true,
+        });
+
+        // Known C-Next structs are POD types, {0} is correct
+        expect(code).toContain("Point pts[3] = {0}");
+      });
     });
   });
 
@@ -7347,7 +7484,7 @@ describe("CodeGenerator", () => {
       it("should generate struct array member write", () => {
         const source = `
           struct Item { u32 value; }
-          Item items[3];
+          Item[3] items;
           void main() {
               items[0].value <- 42;
           }
@@ -7932,7 +8069,7 @@ describe("CodeGenerator", () => {
         const source = `
           void callee(u32 arr[10]) { }
           void test() {
-            u32 data[10];
+            u32[10] data;
             callee(data);
           }
         `;
@@ -7976,7 +8113,7 @@ describe("CodeGenerator", () => {
         const source = `
           void callee(u32 val) { }
           void test() {
-            u32 arr[10];
+            u32[10] arr;
             callee(arr[0]);
           }
         `;
@@ -8426,7 +8563,7 @@ describe("CodeGenerator", () => {
       it("should handle sizeof on variable", () => {
         const source = `
           void test() {
-            u32 arr[10];
+            u32[10] arr;
             u32 size <- sizeof(arr);
           }
         `;
@@ -8491,7 +8628,7 @@ describe("CodeGenerator", () => {
       it("should handle single index array access", () => {
         const source = `
           void test() {
-            u32 arr[10];
+            u32[10] arr;
             u32 val <- arr[5];
           }
         `;
@@ -8575,7 +8712,7 @@ describe("CodeGenerator", () => {
       it("should handle C++ mode array access", () => {
         const source = `
           void test() {
-            u32 arr[10];
+            u32[10] arr;
             u32 val <- arr[5];
           }
         `;
@@ -8597,7 +8734,7 @@ describe("CodeGenerator", () => {
       it("should handle multi-dimensional array access", () => {
         const source = `
           void test() {
-            u32 matrix[3][3];
+            u32[3] matrix[3];
             u32 val <- matrix[1][2];
           }
         `;
@@ -8778,7 +8915,7 @@ describe("CodeGenerator", () => {
         const source = `
           struct Point { u32 x; u32 y; }
           void test() {
-            Point points[10];
+            Point[10] points;
             u32 x <- points[0].x;
           }
         `;
@@ -9141,7 +9278,7 @@ describe("CodeGenerator", () => {
       it("should resolve const values in expressions", () => {
         const source = `
           const u32 MAX_SIZE <- 100;
-          u32 buffer[MAX_SIZE];
+          u32[MAX_SIZE] buffer;
         `;
         const { tree, tokenStream } = CNextSourceParser.parse(source);
         const generator = new CodeGenerator();
@@ -9210,7 +9347,7 @@ describe("CodeGenerator", () => {
       it("should handle array access in assignment target", () => {
         const source = `
           void test() {
-            u32 arr[10];
+            u32[10] arr;
             arr[5] <- 42;
           }
         `;
@@ -9716,7 +9853,7 @@ describe("CodeGenerator", () => {
       it("should generate struct with array member", () => {
         const source = `
           struct Buffer {
-            u8 data[64];
+            u8[64] data;
             u32 size;
           }
           Buffer buf;
@@ -9833,7 +9970,7 @@ describe("CodeGenerator", () => {
       it("should generate array with initializer list", () => {
         const source = `
           void test() {
-            u32 arr[5] <- [1, 2, 3, 4, 5];
+            u32[5] arr <- [1, 2, 3, 4, 5];
           }
         `;
         const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -11130,7 +11267,7 @@ describe("CodeGenerator", () => {
             data[0] <- 1;
           }
           void test() {
-            u32 arr[10];
+            u32[10] arr;
             process(arr);
           }
         `;
@@ -11436,7 +11573,7 @@ describe("CodeGenerator", () => {
       it("should handle array with size in declaration", () => {
         const source = `
           void test() {
-            u8 buffer[10];
+            u8[10] buffer;
             buffer[0] <- 0xFF;
           }
         `;
@@ -11458,7 +11595,7 @@ describe("CodeGenerator", () => {
         const source = `
           const u32 BUFFER_SIZE <- 64;
           void test() {
-            u8 buffer[BUFFER_SIZE];
+            u8[BUFFER_SIZE] buffer;
             buffer[0] <- 0;
           }
         `;
@@ -11475,6 +11612,90 @@ describe("CodeGenerator", () => {
 
         expect(code).toContain("BUFFER_SIZE");
       });
+
+      it("should reject C-style array declaration for primitive types", () => {
+        const source = `
+          void test() {
+            u8 buffer[10];
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        expect(() => {
+          generator.generate(tree, symbolTable, tokenStream, {
+            symbolInfo: symbols,
+            sourcePath: "test.cnx",
+          });
+        }).toThrow(/C-style array declaration is not allowed/);
+      });
+
+      it("should reject C-style array declaration for user types", () => {
+        const source = `
+          struct Data {
+            u32 value;
+          }
+          void test() {
+            Data items[5];
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        expect(() => {
+          generator.generate(tree, symbolTable, tokenStream, {
+            symbolInfo: symbols,
+            sourcePath: "test.cnx",
+          });
+        }).toThrow(/C-style array declaration is not allowed/);
+      });
+
+      it("should allow empty brackets for size inference", () => {
+        const source = `
+          void test() {
+            u8 data[] <- [1, 2, 3];
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+        });
+
+        expect(code).toContain("uint8_t data[3]");
+      });
+
+      it("should allow multi-dimensional C-style arrays", () => {
+        const source = `
+          void test() {
+            u8 matrix[4][4];
+            matrix[0][0] <- 0;
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+        });
+
+        expect(code).toContain("uint8_t matrix[4][4]");
+      });
     });
 
     describe("string expression type checking", () => {
@@ -12208,7 +12429,7 @@ describe("CodeGenerator", () => {
       it("should handle sizeof on local array", () => {
         const source = `
           void test() {
-            u8 buffer[16];
+            u8[16] buffer;
             u32 size <- sizeof(buffer);
           }
         `;
@@ -12368,7 +12589,7 @@ describe("CodeGenerator", () => {
       it("should resolve array element access in expression", () => {
         const source = `
           void test() {
-            u32 arr[10];
+            u32[10] arr;
             u32 val <- arr[5];
           }
         `;
@@ -12389,7 +12610,7 @@ describe("CodeGenerator", () => {
       it("should resolve array element with variable index", () => {
         const source = `
           void test() {
-            u32 arr[10];
+            u32[10] arr;
             u32 i <- 3;
             u32 val <- arr[i];
           }
@@ -12802,7 +13023,7 @@ describe("CodeGenerator", () => {
         const source = `
           struct Item { u32 id; }
           void test() {
-            Item items[10];
+            Item[10] items;
             items[0].id <- 42;
           }
         `;
@@ -13071,7 +13292,7 @@ describe("CodeGenerator", () => {
       it("should handle array type with user-defined struct", () => {
         const source = `
           struct Point { i32 x; i32 y; }
-          Point points[10];
+          Point[10] points;
         `;
         const { tree, tokenStream } = CNextSourceParser.parse(source);
         const generator = new CodeGenerator();
@@ -13089,8 +13310,8 @@ describe("CodeGenerator", () => {
 
       it("should handle array type with primitive types", () => {
         const source = `
-          u8 buffer[256];
-          i32 numbers[10];
+          u8[256] buffer;
+          i32[10] numbers;
         `;
         const { tree, tokenStream } = CNextSourceParser.parse(source);
         const generator = new CodeGenerator();
@@ -13590,7 +13811,7 @@ describe("CodeGenerator", () => {
     describe("array access resolution helpers", () => {
       it("should resolve simple array access", () => {
         const source = `
-          u8 buffer[10];
+          u8[10] buffer;
           void test() {
             u8 val <- buffer[5];
           }
@@ -13611,7 +13832,7 @@ describe("CodeGenerator", () => {
 
       it("should handle array access with variable index", () => {
         const source = `
-          u8 data[20];
+          u8[20] data;
           void test() {
             u32 idx <- 3;
             u8 val <- data[idx];
@@ -14098,7 +14319,7 @@ describe("CodeGenerator", () => {
       it("should register array type correctly", () => {
         const source = `
           void test() {
-            u8 buffer[10];
+            u8[10] buffer;
             buffer[0] <- 0xFF;
           }
         `;
@@ -14119,7 +14340,7 @@ describe("CodeGenerator", () => {
       it("should register multi-dimensional array", () => {
         const source = `
           void test() {
-            u8 matrix[10][20];
+            u8[10] matrix[20];
             matrix[0][0] <- 0;
           }
         `;
@@ -14140,7 +14361,7 @@ describe("CodeGenerator", () => {
       it("should handle i32 array type", () => {
         const source = `
           void test() {
-            i32 values[5];
+            i32[5] values;
             values[0] <- 100;
           }
         `;
@@ -14161,7 +14382,7 @@ describe("CodeGenerator", () => {
       it("should handle const array type", () => {
         const source = `
           void test() {
-            const u8 data[4] <- [1, 2, 3, 4];
+            const u8[4] data <- [1, 2, 3, 4];
           }
         `;
         const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -14177,6 +14398,111 @@ describe("CodeGenerator", () => {
 
         expect(code).toContain("const uint8_t data[4]");
       });
+
+      it("should handle struct array with C-Next syntax", () => {
+        const source = `
+          struct Point {
+            i32 x;
+            i32 y;
+          }
+          void test() {
+            Point[3] points;
+            points[0].x <- 10;
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+        });
+
+        expect(code).toContain("Point points[3]");
+        expect(code).toContain("points[0].x = 10");
+      });
+
+      it("should handle bitmap array with C-Next syntax", () => {
+        const source = `
+          bitmap8 Flags {
+            active,
+            ready,
+            error,
+            mode[3],
+            priority[2]
+          }
+          void test() {
+            Flags[4] flags;
+            flags[0].active <- true;
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+        });
+
+        expect(code).toContain("Flags flags[4]");
+        // Bitmap field access should generate bit manipulation
+        expect(code).toContain("flags[0]");
+      });
+
+      it("should handle enum array with C-Next syntax", () => {
+        const source = `
+          enum Color {
+            RED,
+            GREEN,
+            BLUE
+          }
+          void test() {
+            Color[3] colors;
+            colors[0] <- RED;
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+        });
+
+        expect(code).toContain("Color colors[3]");
+        expect(code).toContain("colors[0] = Color_RED");
+      });
+
+      it("should handle struct array initializer with C-Next syntax", () => {
+        const source = `
+          struct Item {
+            u8 id;
+          }
+          const Item[2] items <- [{id: 1}, {id: 2}];
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+        });
+
+        expect(code).toContain("const Item items[2]");
+        expect(code).toContain(".id = 1");
+      });
     });
 
     describe("C++ mode member conversion", () => {
@@ -14211,7 +14537,7 @@ describe("CodeGenerator", () => {
             u32 id;
           }
           void process() {
-            Item items[3];
+            Item[3] items;
             u32 first <- items[0].id;
           }
         `;
@@ -14610,7 +14936,7 @@ describe("CodeGenerator", () => {
       it("should generate array element write", () => {
         const source = `
           void test() {
-            u32 arr[10];
+            u32[10] arr;
             arr[5] <- 42;
           }
         `;
@@ -15384,7 +15710,7 @@ describe("CodeGenerator", () => {
     describe("array access via ArrayAccessHelper", () => {
       it("should generate single-index array access", () => {
         const source = `
-          u32 arr[10];
+          u32[10] arr;
           void test() {
             u32 val <- arr[5];
           }
@@ -15405,7 +15731,7 @@ describe("CodeGenerator", () => {
 
       it("should generate array access with variable index", () => {
         const source = `
-          u8 data[100];
+          u8[100] data;
           void test(u32 idx) {
             u8 val <- data[idx];
           }
@@ -15546,4 +15872,80 @@ describe("CodeGenerator", () => {
       expect(code).not.toContain("Bar_OFFSET");
     });
   });
+
+  describe("Generator registration error paths", () => {
+    it("throws error when struct generator is not registered", () => {
+      // First call initializes the registry
+      const initSource = `u8 x;`;
+      const { tree: initTree, tokenStream: initTokenStream } =
+        CNextSourceParser.parse(initSource);
+      const generator = new CodeGenerator();
+      const initSymbolTable = new SymbolTable();
+      const initTSymbols = CNextResolver.resolve(initTree, "init.cnx");
+      const initSymbols = TSymbolInfoAdapter.convert(initTSymbols);
+      generator.generate(initTree, initSymbolTable, initTokenStream, {
+        symbolInfo: initSymbols,
+        sourcePath: "init.cnx",
+      });
+
+      // Unregister the struct generator to test error path
+      const registry = (
+        generator as unknown as {
+          registry: { unregisterDeclaration: (kind: string) => void };
+        }
+      ).registry;
+      registry.unregisterDeclaration("struct");
+
+      // Second call should throw because struct generator is now missing
+      const source = `struct Point { i32 x; i32 y; }`;
+      const { tree, tokenStream } = CNextSourceParser.parse(source);
+      const symbolTable = new SymbolTable();
+      const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+      const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+      expect(() => {
+        generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+        });
+      }).toThrow("Error: struct generator not registered");
+    });
+
+    it("throws error when enum generator is not registered", () => {
+      // First call initializes the registry
+      const initSource = `u8 x;`;
+      const { tree: initTree, tokenStream: initTokenStream } =
+        CNextSourceParser.parse(initSource);
+      const generator = new CodeGenerator();
+      const initSymbolTable = new SymbolTable();
+      const initTSymbols = CNextResolver.resolve(initTree, "init.cnx");
+      const initSymbols = TSymbolInfoAdapter.convert(initTSymbols);
+      generator.generate(initTree, initSymbolTable, initTokenStream, {
+        symbolInfo: initSymbols,
+        sourcePath: "init.cnx",
+      });
+
+      // Unregister the enum generator to test error path
+      const registry = (
+        generator as unknown as {
+          registry: { unregisterDeclaration: (kind: string) => void };
+        }
+      ).registry;
+      registry.unregisterDeclaration("enum");
+
+      // Second call should throw because enum generator is now missing
+      const source = `enum State { IDLE, RUNNING }`;
+      const { tree, tokenStream } = CNextSourceParser.parse(source);
+      const symbolTable = new SymbolTable();
+      const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+      const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+      expect(() => {
+        generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+        });
+      }).toThrow("Error: enum generator not registered");
+    });
+  });
 });