c-next 0.1.61 → 0.1.63

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);
@@ -7347,7 +7348,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 +7933,7 @@ describe("CodeGenerator", () => {
         const source = `
           void callee(u32 arr[10]) { }
           void test() {
-            u32 data[10];
+            u32[10] data;
             callee(data);
           }
         `;
@@ -7976,7 +7977,7 @@ describe("CodeGenerator", () => {
         const source = `
           void callee(u32 val) { }
           void test() {
-            u32 arr[10];
+            u32[10] arr;
             callee(arr[0]);
           }
         `;
@@ -8426,7 +8427,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 +8492,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 +8576,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 +8598,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 +8779,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 +9142,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 +9211,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 +9717,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 +9834,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 +11131,7 @@ describe("CodeGenerator", () => {
             data[0] <- 1;
           }
           void test() {
-            u32 arr[10];
+            u32[10] arr;
             process(arr);
           }
         `;
@@ -11436,7 +11437,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 +11459,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 +11476,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 +12293,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 +12453,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 +12474,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 +12887,7 @@ describe("CodeGenerator", () => {
         const source = `
           struct Item { u32 id; }
           void test() {
-            Item items[10];
+            Item[10] items;
             items[0].id <- 42;
           }
         `;
@@ -13071,7 +13156,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 +13174,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 +13675,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 +13696,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];
@@ -13780,6 +13865,1951 @@ describe("CodeGenerator", () => {
 
         expect(code).toContain("strlen");
       });
+
+      it("should generate cache for multiple .length accesses", () => {
+        const source = `
+          void test() {
+            string<32> s <- "hello";
+            if (s.length > 0) {
+              u32 x <- s.length;
+            }
+          }
+        `;
+        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",
+        });
+
+        // Should generate cache variable for repeated .length access
+        expect(code).toContain("strlen");
+      });
+
+      it("should not cache for single .length access", () => {
+        const source = `
+          void test() {
+            string<32> s <- "hello";
+            u32 len <- s.length;
+          }
+        `;
+        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",
+        });
+
+        // Single access should just use strlen directly
+        expect(code).toContain("strlen(s)");
+      });
+    });
+
+    describe("scope-qualified function resolution", () => {
+      it("should resolve this.method() to CurrentScope_method", () => {
+        const source = `
+          enum MyEnum { A, B }
+          scope Foo {
+            public MyEnum bar() {
+              return global.MyEnum.A;
+            }
+            public void test() {
+              MyEnum result <- this.bar();
+            }
+          }
+        `;
+        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",
+        });
+
+        // this.bar() should become Foo_bar()
+        expect(code).toContain("Foo_bar()");
+      });
+
+      it("should resolve Scope.method() to Scope_method", () => {
+        const source = `
+          scope Utils {
+            public u32 getValue() {
+              return 42;
+            }
+          }
+          void main() {
+            u32 v <- Utils.getValue();
+          }
+        `;
+        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("Utils_getValue()");
+      });
+
+      it("should resolve global.func() to func", () => {
+        const source = `
+          u32 getNumber() {
+            return 100;
+          }
+          scope Test {
+            public void run() {
+              u32 n <- global.getNumber();
+            }
+          }
+        `;
+        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",
+        });
+
+        // global.getNumber() should become getNumber()
+        expect(code).toContain("getNumber()");
+      });
+
+      it("should resolve global.Scope.method() to Scope_method", () => {
+        const source = `
+          scope Config {
+            public u32 getTimeout() {
+              return 1000;
+            }
+          }
+          scope Other {
+            public void test() {
+              u32 t <- global.Config.getTimeout();
+            }
+          }
+        `;
+        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",
+        });
+
+        // global.Config.getTimeout() should become Config_getTimeout()
+        expect(code).toContain("Config_getTimeout()");
+      });
+    });
+
+    describe("expression type checking", () => {
+      it("should detect decimal integer literal in comparison", () => {
+        const source = `
+          void test() {
+            u32 val <- 5;
+            bool isZero <- (val = 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",
+        });
+
+        // Integer comparison should work
+        expect(code).toContain("val == 0");
+      });
+
+      it("should detect hex literal in comparison", () => {
+        const source = `
+          void test() {
+            u32 flags <- 0;
+            bool check <- (flags = 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",
+        });
+
+        expect(code).toContain("0xFF");
+      });
+
+      it("should detect binary literal in comparison", () => {
+        const source = `
+          void test() {
+            u32 mode <- 0;
+            bool check <- (mode = 0b1010);
+          }
+        `;
+        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",
+        });
+
+        // Binary literal passes through (not converted)
+        expect(code).toContain("0b1010");
+      });
+
+      it("should detect variable of integer type", () => {
+        const source = `
+          void test() {
+            i32 code <- 5;
+            i32 limit <- 10;
+            bool check <- (code = limit);
+          }
+        `;
+        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",
+        });
+
+        // Comparison with integer variable
+        expect(code).toContain("code == limit");
+      });
+
+      it("should detect string literal", () => {
+        const source = `
+          void test() {
+            string<32> s <- "hello";
+            bool check <- (s = "hello");
+          }
+        `;
+        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",
+        });
+
+        // String comparison should use strcmp
+        expect(code).toContain("strcmp");
+      });
+
+      it("should detect string variable", () => {
+        const source = `
+          void test() {
+            string<32> s1 <- "hello";
+            string<32> s2 <- "world";
+            bool check <- (s1 = s2);
+          }
+        `;
+        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",
+        });
+
+        // String comparison should use strcmp
+        expect(code).toContain("strcmp");
+      });
+
+      it("should detect array element of string array", () => {
+        const source = `
+          void test() {
+            string<32> names[3];
+            names[0] <- "Alice";
+            bool check <- (names[0] = "Alice");
+          }
+        `;
+        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",
+        });
+
+        // String array element comparison should use strcmp
+        expect(code).toContain("strcmp");
+      });
+    });
+
+    describe("array type registration", () => {
+      it("should register array type correctly", () => {
+        const source = `
+          void test() {
+            u8[10] buffer;
+            buffer[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",
+        });
+
+        expect(code).toContain("uint8_t buffer[10]");
+      });
+
+      it("should register multi-dimensional array", () => {
+        const source = `
+          void test() {
+            u8[10] matrix[20];
+            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[10][20]");
+      });
+
+      it("should handle i32 array type", () => {
+        const source = `
+          void test() {
+            i32[5] values;
+            values[0] <- 100;
+          }
+        `;
+        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("int32_t values[5]");
+      });
+
+      it("should handle const array type", () => {
+        const source = `
+          void test() {
+            const u8[4] data <- [1, 2, 3, 4];
+          }
+        `;
+        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 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", () => {
+      it("should detect parameter member access needing conversion", () => {
+        const source = `
+          struct Config {
+            u32 value;
+          }
+          void process(Config cfg) {
+            u32 v <- cfg.value;
+          }
+        `;
+        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,
+        });
+
+        // In C++ mode, struct params use . not ->
+        expect(code).toContain("cfg.value");
+      });
+
+      it("should detect array element member access", () => {
+        const source = `
+          struct Item {
+            u32 id;
+          }
+          void process() {
+            Item[3] items;
+            u32 first <- items[0].id;
+          }
+        `;
+        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,
+        });
+
+        // Array element member access
+        expect(code).toContain("items[0].id");
+      });
+
+      it("should use arrow for struct params in C mode", () => {
+        const source = `
+          struct Config {
+            u32 value;
+          }
+          void process(Config cfg) {
+            u32 v <- cfg.value;
+          }
+        `;
+        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: false,
+        });
+
+        // In C mode, struct params use ->
+        expect(code).toContain("cfg->value");
+      });
+
+      it("should handle const struct parameters in C++ mode", () => {
+        const source = `
+          struct Settings {
+            u32 timeout;
+            bool enabled;
+          }
+          void configure(const Settings s) {
+            u32 t <- s.timeout;
+          }
+        `;
+        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 struct param should use reference in C++
+        expect(code).toContain("const Settings&");
+        expect(code).toContain("s.timeout");
+      });
+    });
+
+    describe("struct generation", () => {
+      it("should generate struct typedef", () => {
+        const source = `
+          struct Point {
+            i32 x;
+            i32 y;
+          }
+        `;
+        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("typedef struct");
+        expect(code).toContain("int32_t x");
+        expect(code).toContain("int32_t y");
+        expect(code).toContain("} Point;");
+      });
+
+      it("should generate struct with callback field", () => {
+        const source = `
+          void handler(u32 val) {}
+          struct Button {
+            u32 id;
+            handler onClick;
+          }
+        `;
+        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("typedef struct");
+        expect(code).toContain("} Button;");
+      });
+    });
+
+    describe("register generation", () => {
+      it("should generate register comment", () => {
+        const source = `
+          register GPIO7 @ 0x42004000 {
+            rw u32 DR @ 0x00;
+          }
+        `;
+        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",
+        });
+
+        // Register declaration generates a comment
+        expect(code).toContain("Register: GPIO7");
+      });
+
+      it("should generate scoped register comment", () => {
+        const source = `
+          scope Teensy4 {
+            register GPIO7 @ 0x42004000 {
+              rw u32 DR @ 0x00;
+            }
+          }
+        `;
+        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",
+        });
+
+        // Scoped register should show scope in output
+        expect(code).toContain("Teensy4");
+        expect(code).toContain("GPIO7");
+      });
+    });
+
+    describe("enum type checking in expressions", () => {
+      it("should handle enum variable assignment", () => {
+        const source = `
+          enum Color { RED, GREEN, BLUE }
+          void test() {
+            Color c <- Color.RED;
+            c <- Color.GREEN;
+          }
+        `;
+        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_RED");
+        expect(code).toContain("Color_GREEN");
+      });
+
+      it("should handle enum comparison", () => {
+        const source = `
+          enum Status { OK, ERROR }
+          void test() {
+            Status s <- Status.OK;
+            if (s = Status.ERROR) {
+              s <- Status.OK;
+            }
+          }
+        `;
+        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("s == Status_ERROR");
+      });
+
+      it("should handle enum return from function", () => {
+        const source = `
+          enum Result { SUCCESS, FAILURE }
+          Result getResult() {
+            return Result.SUCCESS;
+          }
+          void test() {
+            Result r <- getResult();
+          }
+        `;
+        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("Result_SUCCESS");
+        expect(code).toContain("getResult()");
+      });
+    });
+
+    describe("overflow helpers", () => {
+      it("should generate clamp add helper", () => {
+        const source = `
+          clamp u8 val <- 250;
+          void test() {
+            val +<- 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("cnx_clamp_add_u8");
+      });
+
+      it("should generate clamp sub helper", () => {
+        const source = `
+          clamp u8 val <- 5;
+          void test() {
+            val -<- 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("cnx_clamp_sub_u8");
+      });
+    });
+
+    describe("preprocessor directives", () => {
+      it("should handle C include directive", () => {
+        const source = `
+          #include <stdio.h>
+          void test() {}
+        `;
+        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("#include <stdio.h>");
+      });
+
+      it("should handle #define without value", () => {
+        const source = `
+          #define DEBUG_MODE
+          void test() {}
+        `;
+        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("#define DEBUG_MODE");
+      });
+    });
+
+    describe("bit range access", () => {
+      it("should generate bit range read expression", () => {
+        const source = `
+          void test() {
+            u32 val <- 0xFF00;
+            u8 byte <- val[8, 8];
+          }
+        `;
+        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",
+        });
+
+        // Bit range access generates shift and mask
+        expect(code).toContain(">> 8");
+        expect(code).toContain("0xFF");
+      });
+
+      it("should generate bit range write expression", () => {
+        const source = `
+          void test() {
+            u32 val <- 0;
+            val[8, 8] <- 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",
+        });
+
+        // Bit range write should use mask-and-shift pattern
+        expect(code).toContain("val");
+      });
+
+      it("should generate single bit write", () => {
+        const source = `
+          void test() {
+            u32 flags <- 0;
+            flags[3] <- 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",
+        });
+
+        // Single bit write
+        expect(code).toContain("flags");
+        expect(code).toContain("1 << 3");
+      });
+
+      it("should generate array element write", () => {
+        const source = `
+          void test() {
+            u32[10] arr;
+            arr[5] <- 42;
+          }
+        `;
+        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("arr[5] = 42");
+      });
+
+      it("should generate bit range at position 0", () => {
+        const source = `
+          void test() {
+            u32 val <- 0x1234;
+            u8 lowByte <- val[0, 8];
+          }
+        `;
+        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",
+        });
+
+        // Position 0 should NOT generate >> 0
+        expect(code).not.toContain(">> 0");
+      });
+
+      it("should generate 64-bit mask for u64 values", () => {
+        const source = `
+          void test() {
+            u64 val <- 0xFFFFFFFFFFFFFFFF;
+            u32 upper <- val[32, 32];
+          }
+        `;
+        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",
+        });
+
+        // 64-bit operations should have ULL suffix
+        expect(code).toContain(">> 32");
+      });
+    });
+
+    describe("type name resolution", () => {
+      it("should resolve this.Type for scoped types", () => {
+        const source = `
+          scope Motor {
+            enum State { IDLE, RUNNING }
+            public State getState() {
+              return global.Motor.State.IDLE;
+            }
+          }
+        `;
+        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("Motor_State");
+      });
+
+      it("should resolve global.Type for global types inside scope", () => {
+        const source = `
+          enum Color { RED, GREEN }
+          scope Display {
+            public void setColor(Color c) {
+              Color myColor <- c;
+            }
+          }
+        `;
+        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");
+      });
+    });
+
+    describe("switch statement generation", () => {
+      it("should generate switch with exhaustive enum cases", () => {
+        const source = `
+          enum State { OFF, ON }
+          void test() {
+            State s <- State.OFF;
+            switch (s) {
+              case State.OFF { }
+              case State.ON { }
+            }
+          }
+        `;
+        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("switch");
+        expect(code).toContain("case State_OFF");
+        expect(code).toContain("case State_ON");
+        expect(code).toContain("break;");
+      });
+
+      it("should generate switch with default case", () => {
+        const source = `
+          void test() {
+            u32 val <- 5;
+            switch (val) {
+              case 1 { }
+              case 2 { }
+              default { }
+            }
+          }
+        `;
+        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("switch");
+        expect(code).toContain("default:");
+      });
+    });
+
+    describe("while loop generation", () => {
+      it("should generate while loop", () => {
+        const source = `
+          void test() {
+            u32 i <- 0;
+            while (i < 10) {
+              i +<- 1;
+            }
+          }
+        `;
+        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("while (i < 10)");
+      });
+    });
+
+    describe("for loop generation", () => {
+      it("should generate for loop", () => {
+        const source = `
+          void test() {
+            for (u32 i <- 0; i < 10; i +<- 1) {
+              u32 x <- i;
+            }
+          }
+        `;
+        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("for (");
+        expect(code).toContain("uint32_t i = 0");
+        expect(code).toContain("i < 10");
+      });
+    });
+
+    describe("do-while loop generation", () => {
+      it("should generate do-while loop", () => {
+        const source = `
+          void test() {
+            u32 i <- 0;
+            do {
+              i +<- 1;
+            } while (i < 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("do {");
+        expect(code).toContain("} while (i < 10)");
+      });
+    });
+
+    describe("break and continue statements", () => {
+      it("should generate break in loop", () => {
+        const source = `
+          void test() {
+            while (true) {
+              break;
+            }
+          }
+        `;
+        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("break;");
+      });
+
+      it("should generate continue in loop", () => {
+        const source = `
+          void test() {
+            u32 i <- 0;
+            while (i < 10) {
+              i +<- 1;
+              if (i = 5) {
+                continue;
+              }
+            }
+          }
+        `;
+        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("continue;");
+      });
+    });
+
+    describe("function with parameters", () => {
+      it("should generate function with multiple params", () => {
+        const source = `
+          u32 add(u32 a, u32 b) {
+            return a + b;
+          }
+        `;
+        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("uint32_t add(uint32_t a, uint32_t b)");
+        expect(code).toContain("return a + b");
+      });
+
+      it("should generate function with array parameter", () => {
+        const source = `
+          void process(u32 arr[10]) {
+            u32 val <- arr[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("uint32_t arr[10]");
+      });
+    });
+
+    describe("global variable declarations", () => {
+      it("should generate global variable initialization", () => {
+        const source = `
+          u32 globalCounter <- 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("uint32_t globalCounter");
+        expect(code).toContain("= 0");
+      });
+
+      it("should generate const global", () => {
+        const source = `
+          const u32 MAX_VALUE <- 100;
+        `;
+        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 uint32_t MAX_VALUE");
+        expect(code).toContain("= 100");
+      });
+    });
+
+    describe("arithmetic expressions", () => {
+      it("should generate modulo operation", () => {
+        const source = `
+          void test() {
+            u32 a <- 10;
+            u32 b <- a % 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("a % 3");
+      });
+
+      it("should generate bitwise operations", () => {
+        const source = `
+          void test() {
+            u32 a <- 0xFF;
+            u32 b <- a & 0x0F;
+            u32 c <- a | 0xF0;
+            u32 d <- a ^ 0xAA;
+            u32 e <- ~a;
+          }
+        `;
+        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("a & 0x0F");
+        expect(code).toContain("a | 0xF0");
+        expect(code).toContain("a ^ 0xAA");
+        expect(code).toContain("~a");
+      });
+
+      it("should generate shift operations", () => {
+        const source = `
+          void test() {
+            u32 a <- 1;
+            u32 b <- a << 4;
+            u32 c <- a >> 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("a << 4");
+        expect(code).toContain("a >> 2");
+      });
+    });
+
+    describe("logical expressions", () => {
+      it("should generate logical AND and OR", () => {
+        const source = `
+          void test() {
+            bool a <- true;
+            bool b <- false;
+            bool c <- a && b;
+            bool d <- a || b;
+          }
+        `;
+        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("a && b");
+        expect(code).toContain("a || b");
+      });
+
+      it("should generate NOT operation", () => {
+        const source = `
+          void test() {
+            bool a <- true;
+            bool b <- !a;
+          }
+        `;
+        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("!a");
+      });
+    });
+
+    describe("ternary expression", () => {
+      it("should generate ternary expression", () => {
+        const source = `
+          void test() {
+            u32 a <- 5;
+            u32 b <- (a > 3) ? 10 : 20;
+          }
+        `;
+        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("a > 3");
+        expect(code).toContain("?");
+        expect(code).toContain("10");
+        expect(code).toContain("20");
+      });
+    });
+
+    describe("unary expressions", () => {
+      it("should generate negative number", () => {
+        const source = `
+          void test() {
+            i32 a <- 5;
+            i32 b <- -a;
+          }
+        `;
+        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("-a");
+      });
+
+      it("should generate bitwise NOT", () => {
+        const source = `
+          void test() {
+            u32 a <- 0xFF;
+            u32 b <- ~a;
+          }
+        `;
+        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("~a");
+      });
+    });
+
+    describe("bitmap type", () => {
+      it("should generate bitmap field access", () => {
+        const source = `
+          bitmap8 Flags {
+            bit0,
+            bit1,
+            bit2,
+            bit3,
+            bit4,
+            bit5,
+            bit6,
+            bit7
+          }
+          void test() {
+            Flags f <- 0;
+            bool isSet <- f.bit0;
+          }
+        `;
+        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");
+      });
+    });
+
+    describe("function call expressions", () => {
+      it("should generate function call with arguments", () => {
+        const source = `
+          u32 multiply(u32 x, u32 y) {
+            return x * y;
+          }
+          void test() {
+            u32 result <- multiply(5, 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("multiply(5, 10)");
+      });
+
+      it("should generate scoped function call", () => {
+        const source = `
+          scope Math {
+            public u32 square(u32 x) {
+              return x * x;
+            }
+          }
+          void test() {
+            u32 result <- Math.square(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);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+        });
+
+        expect(code).toContain("Math_square(5)");
+      });
+    });
+
+    describe("ISR declaration", () => {
+      it("should generate ISR attribute", () => {
+        const source = `
+          isr void TIMER0_IRQ() {
+            u32 x <- 1;
+          }
+        `;
+        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",
+        });
+
+        // ISR functions should have special attributes
+        expect(code).toContain("TIMER0_IRQ");
+      });
+    });
+
+    describe("atomic variable", () => {
+      it("should generate volatile for atomic", () => {
+        const source = `
+          atomic u32 counter <- 0;
+          void test() {
+            counter <- 1;
+          }
+        `;
+        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("volatile");
+      });
+    });
+
+    describe("wrap overflow behavior", () => {
+      it("should not add helpers for wrap types", () => {
+        const source = `
+          wrap u8 val <- 250;
+          void test() {
+            val +<- 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",
+        });
+
+        // Wrap types just use += without helper
+        expect(code).toContain("+=");
+        expect(code).not.toContain("cnx_");
+      });
+    });
+
+    describe("safe division", () => {
+      it("should generate safe division helper", () => {
+        const source = `
+          void test() {
+            u32 a <- 10;
+            u32 b <- 0;
+            u32 c <- a / b;
+          }
+        `;
+        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",
+        });
+
+        // Division should work
+        expect(code).toContain("a / b");
+      });
+    });
+
+    describe("parenthesized expressions", () => {
+      it("should preserve parentheses in expressions", () => {
+        const source = `
+          void test() {
+            u32 a <- 2;
+            u32 b <- 3;
+            u32 c <- 4;
+            u32 result <- (a + b) * c;
+          }
+        `;
+        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("(a + b) * c");
+      });
+    });
+
+    describe("array access via ArrayAccessHelper", () => {
+      it("should generate single-index array access", () => {
+        const source = `
+          u32[10] arr;
+          void test() {
+            u32 val <- arr[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);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+        });
+
+        expect(code).toContain("arr[5]");
+      });
+
+      it("should generate array access with variable index", () => {
+        const source = `
+          u8[100] data;
+          void test(u32 idx) {
+            u8 val <- data[idx];
+          }
+        `;
+        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("data[idx]");
+      });
+
+      it("should generate integer bit range access", () => {
+        const source = `
+          void test() {
+            u32 value <- 0xFF00;
+            u8 byte <- value[8, 8];
+          }
+        `;
+        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(">> 8");
+        expect(code).toContain("& 0xFF");
+      });
+
+      it("should generate float bit range access with memcpy", () => {
+        const source = `
+          void test() {
+            f32 fval <- 1.5;
+            u8 byte <- fval[0, 8];
+          }
+        `;
+        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("memcpy");
+        expect(code).toContain("__bits_fval");
+      });
+
+      it("should generate f64 bit range access with uint64_t shadow", () => {
+        const source = `
+          void test() {
+            f64 dval <- 1.5;
+            u8 byte <- dval[0, 8];
+          }
+        `;
+        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("uint64_t __bits_dval");
+        expect(code).toContain("memcpy");
+      });
+    });
+  });
+
+  describe("Issue #741: const scope members bare reference inlining", () => {
+    it("should inline private const when referenced without this. prefix", () => {
+      const source = `
+        scope Foo {
+          const u32 MY_CONSTANT <- 42;
+
+          public u32 getConstant() {
+            return MY_CONSTANT;
+          }
+        }
+      `;
+      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",
+      });
+
+      // Should inline the value, not generate a reference to Foo_MY_CONSTANT
+      expect(code).toContain("return 42;");
+      expect(code).not.toContain("Foo_MY_CONSTANT");
+    });
+
+    it("should inline private const in expressions without this. prefix", () => {
+      const source = `
+        scope Bar {
+          const u8 OFFSET <- 10;
+
+          public u8 compute() {
+            u8 result <- OFFSET + 5;
+            return result;
+          }
+        }
+      `;
+      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",
+      });
+
+      // Expression should be constant-folded: 10 + 5 = 15
+      expect(code).toContain("uint8_t result = 15;");
+      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");
     });
   });
 });