c-next 0.2.16 → 0.2.17

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

@@ -822,7 +822,159 @@ describe("InitializationAnalyzer", () => {
   });
 
   // ========================================================================
-  // Group I: C++ Non-Struct Symbol
+  // Group I: Compound Assignment (Issue #1012)
+  // ========================================================================
+
+  describe("compound assignment (Issue #1012)", () => {
+    it("should flag compound assignment on uninitialized variable", () => {
+      const code = `
+        void main() {
+          u32 sum;
+          sum +<- 5;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0381");
+      expect(errors[0].variable).toBe("sum");
+    });
+
+    it("should not flag compound assignment on initialized variable", () => {
+      const code = `
+        void main() {
+          u32 sum <- 0;
+          sum +<- 5;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should flag compound assignment on uninitialized struct field", () => {
+      const code = `
+        struct Point {
+          u32 x;
+          u32 y;
+        }
+        void main() {
+          Point p;
+          p.x +<- 10;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0381");
+      expect(errors[0].variable).toContain("p.x");
+    });
+
+    it("should not flag compound assignment on initialized struct field", () => {
+      const code = `
+        struct Point {
+          u32 x;
+          u32 y;
+        }
+        void main() {
+          Point p <- {x: 10, y: 20};
+          p.x +<- 5;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should flag all compound operators on uninitialized variable", () => {
+      const operators = [
+        "+<-",
+        "-<-",
+        "*<-",
+        "/<-",
+        "%<-",
+        "&<-",
+        "|<-",
+        "^<-",
+        "<<<-",
+        ">><-",
+      ];
+
+      for (const op of operators) {
+        const code = `
+          void main() {
+            u32 x;
+            x ${op} 1;
+          }
+        `;
+        const tree = parse(code);
+        const analyzer = new InitializationAnalyzer();
+        const errors = analyzer.analyze(tree);
+
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].code).toBe("E0381");
+        expect(errors[0].variable).toBe("x");
+      }
+    });
+
+    it("should not flag simple assignment on uninitialized variable", () => {
+      const code = `
+        void main() {
+          u32 x;
+          x <- 5;
+          u32 y <- x;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      // Simple assignment initializes the variable, so no error
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should flag compound assignment on array element with uninitialized array", () => {
+      const code = `
+        void main() {
+          u32[4] arr;
+          arr[0] +<- 5;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      // Array is uninitialized, reading arr[0] for compound assignment is an error
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0381");
+      expect(errors[0].variable).toBe("arr");
+    });
+
+    it("should not flag compound assignment on array element with initialized array", () => {
+      const code = `
+        void main() {
+          u32[4] arr <- [1, 2, 3, 4];
+          arr[0] +<- 5;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(0);
+    });
+  });
+
+  // ========================================================================
+  // Group J: C++ Non-Struct Symbol
   // ========================================================================
 
   describe("C++ non-struct symbol", () => {
@@ -854,4 +1006,237 @@ describe("InitializationAnalyzer", () => {
       expect(errors[0].variable).toBe("e");
     });
   });
+
+  // ========================================================================
+  // Issue #1019: Scope Member Initialization
+  // ========================================================================
+
+  describe("scope member initialization (Issue #1019)", () => {
+    it("should allow reading scope member with inline initializer", () => {
+      const code = `
+        scope S {
+          u32 value <- 42;
+          public u32 get() { return value; }
+        }
+        void main() {
+          u32 v <- S.get();
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should allow reading scope member assigned in another function", () => {
+      const code = `
+        scope S {
+          u32 value;
+          public void init() { value <- 10; }
+          public u32 get() { return value; }
+        }
+        void main() {
+          S.init();
+          u32 v <- S.get();
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      // value is assigned in init(), so get() can read it
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should flag uninitialized scope member read", () => {
+      const code = `
+        scope S {
+          u32 value;
+          public u32 get() { return value; }
+        }
+        void main() {
+          u32 v <- S.get();
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      // value is never assigned - should error
+      expect(errors.length).toBeGreaterThan(0);
+      expect(errors[0].code).toBe("E0381");
+      expect(errors[0].variable).toBe("value");
+    });
+
+    it("should detect assignment in do-while body", () => {
+      const code = `
+        scope S {
+          u32 count;
+          public void init() {
+            u32 i <- 0;
+            do {
+              count <- i;
+              i <- i + 1;
+            } while (i < 1);
+          }
+          public u32 get() { return count; }
+        }
+        void main() {
+          S.init();
+          u32 c <- S.get();
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      // count is assigned inside do-while in init()
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should detect assignment in if statement", () => {
+      const code = `
+        scope S {
+          u32 value;
+          public void set(bool flag) {
+            if (flag = true) {
+              value <- 1;
+            }
+          }
+          public u32 get() { return value; }
+        }
+        void main() {
+          S.set(true);
+          u32 v <- S.get();
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      // value is assigned in if branch
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should detect assignment in for loop", () => {
+      const code = `
+        scope S {
+          u32 total;
+          public void calc() {
+            for (u32 i <- 0; i < 5; i <- i + 1) {
+              total <- i;
+            }
+          }
+          public u32 get() { return total; }
+        }
+        void main() {
+          S.calc();
+          u32 t <- S.get();
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      // total is assigned in for loop
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should detect assignment via this.member", () => {
+      const code = `
+        scope S {
+          u32 data;
+          public void set() { this.data <- 100; }
+          public u32 get() { return data; }
+        }
+        void main() {
+          S.set();
+          u32 d <- S.get();
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      // data is assigned via this.data
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should detect assignment in switch case", () => {
+      const code = `
+        scope S {
+          u32 result;
+          public void choose(u32 opt) {
+            switch (opt) {
+              case 1 { result <- 10; }
+              case 2 { result <- 20; }
+            }
+          }
+          public u32 get() { return result; }
+        }
+        void main() {
+          S.choose(1);
+          u32 r <- S.get();
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      // result is assigned in switch cases
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should detect assignment in while loop", () => {
+      const code = `
+        scope S {
+          u32 counter;
+          public void loop() {
+            u32 i <- 0;
+            while (i < 3) {
+              counter <- i;
+              i <- i + 1;
+            }
+          }
+          public u32 get() { return counter; }
+        }
+        void main() {
+          S.loop();
+          u32 c <- S.get();
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      // counter is assigned in while loop
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should detect assignment in switch default case", () => {
+      const code = `
+        scope S {
+          u32 result;
+          public void choose(u32 opt) {
+            switch (opt) {
+              case 1 { result <- 10; }
+              default { result <- 99; }
+            }
+          }
+          public u32 get() { return result; }
+        }
+        void main() {
+          S.choose(5);
+          u32 r <- S.get();
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      // result is assigned in default case
+      expect(errors).toHaveLength(0);
+    });
+  });
 });

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

@@ -411,4 +411,215 @@ describe("SignedShiftAnalyzer", () => {
       expect(errors).toHaveLength(0);
     });
   });
+
+  // ========================================================================
+  // Compound Shift-Assign (Issue #1008)
+  // ========================================================================
+
+  describe("compound shift-assign (issue #1008)", () => {
+    it("should detect left shift compound-assign with i8 target", () => {
+      const code = `
+        void main() {
+          i8 x <- 1;
+          x <<<- 2;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new SignedShiftAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0805");
+      expect(errors[0].message).toContain("Shift operator '<<<-'");
+      expect(errors[0].message).toContain("signed integer types");
+    });
+
+    it("should detect right shift compound-assign with i8 target", () => {
+      const code = `
+        void main() {
+          i8 x <- 64;
+          x >><- 2;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new SignedShiftAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0805");
+      expect(errors[0].message).toContain("Shift operator '>><-'");
+    });
+
+    it("should detect left shift compound-assign with i16 target", () => {
+      const code = `
+        void main() {
+          i16 x <- 1;
+          x <<<- 4;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new SignedShiftAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0805");
+    });
+
+    it("should detect left shift compound-assign with i32 target", () => {
+      const code = `
+        void main() {
+          i32 x <- 1;
+          x <<<- 8;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new SignedShiftAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0805");
+    });
+
+    it("should detect left shift compound-assign with i64 target", () => {
+      const code = `
+        void main() {
+          i64 x <- 1;
+          x <<<- 16;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new SignedShiftAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0805");
+    });
+
+    it("should not flag left shift compound-assign with u8 target", () => {
+      const code = `
+        void main() {
+          u8 x <- 1;
+          x <<<- 2;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new SignedShiftAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should not flag right shift compound-assign with u32 target", () => {
+      const code = `
+        void main() {
+          u32 x <- 256;
+          x >><- 4;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new SignedShiftAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should detect multiple compound shift-assign violations", () => {
+      const code = `
+        void main() {
+          i8 a <- 1;
+          a <<<- 2;
+          i16 b <- 64;
+          b >><- 3;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new SignedShiftAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(2);
+      expect(errors[0].message).toContain("<<<-");
+      expect(errors[1].message).toContain(">><-");
+    });
+
+    it("should not flag other compound-assign operators on signed types", () => {
+      const code = `
+        void main() {
+          i32 x <- 10;
+          x +<- 5;
+          x -<- 2;
+          x *<- 3;
+          x /<- 2;
+          x %<- 3;
+          x &<- 0xFF;
+          x |<- 0x0F;
+          x ^<- 0xAA;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new SignedShiftAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(0);
+    });
+  });
+
+  // ========================================================================
+  // Struct Member Compound Shift-Assign (PR #1013 review feedback)
+  // ========================================================================
+
+  describe("struct member compound shift-assign", () => {
+    it("should detect left shift compound-assign on signed struct field", () => {
+      // Note: This requires CodeGenState.symbols to have struct field info
+      // In real usage, symbols are populated during transpilation
+      // For unit tests without symbols, we rely on the integration tests
+      const code = `
+        struct Data { i8 val; }
+        void main() {
+          Data d <- {val: 1};
+          d.val <<<- 2;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new SignedShiftAnalyzer();
+      // Without CodeGenState.symbols populated, this won't detect the issue
+      // The integration test covers this case
+      const errors = analyzer.analyze(tree);
+      // This returns 0 because CodeGenState.getStructFieldType returns undefined
+      // without populated symbols. The integration test verifies the full path.
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should not flag unsigned struct field shift", () => {
+      const code = `
+        struct Data { u8 val; }
+        void main() {
+          Data d <- {val: 1};
+          d.val <<<- 2;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new SignedShiftAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should still detect simple signed variable shift alongside struct access", () => {
+      const code = `
+        struct Data { u8 val; }
+        void main() {
+          Data d <- {val: 1};
+          i8 x <- 1;
+          x <<<- 2;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new SignedShiftAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0805");
+      expect(errors[0].message).toContain("<<<-");
+    });
+  });
 });