c-next 0.2.16 → 0.2.18

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

@@ -1117,4 +1117,204 @@ describe("FunctionCallAnalyzer", () => {
       );
     });
   });
+
+  // ========================================================================
+  // Issue #985: global. prefix function call validation
+  // ========================================================================
+
+  describe("global prefix function calls (Issue #985)", () => {
+    it("should detect undeclared global.func() call", () => {
+      const code = `
+        scope Test {
+          void run() {
+            u32 now <- global.millis();
+          }
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new FunctionCallAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0422");
+      expect(errors[0].message).toContain("'millis'");
+      expect(errors[0].message).toContain(
+        "not declared in any included header",
+      );
+      expect(errors[0].message).toContain("#include <Arduino.h>");
+    });
+
+    it("should detect undeclared global.func() with unknown function", () => {
+      const code = `
+        scope Test {
+          void run() {
+            u32 result <- global.unknownFunc();
+          }
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new FunctionCallAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0422");
+      expect(errors[0].message).toContain("'unknownFunc'");
+      expect(errors[0].message).toContain(
+        "not declared in any included header",
+      );
+      expect(errors[0].message).not.toContain("#include");
+    });
+
+    it("should allow global.func() when function is defined", () => {
+      const code = `
+        void helper() {
+          u32 x <- 5;
+        }
+        scope Test {
+          void run() {
+            global.helper();
+          }
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new FunctionCallAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should allow global.func() when header is included", () => {
+      const code = `
+        #include <Arduino.h>
+        scope Test {
+          void run() {
+            u32 now <- global.millis();
+          }
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new FunctionCallAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should allow global.Scope.method() when scope is defined", () => {
+      const code = `
+        scope Motor {
+          public void start() {
+            u32 x <- 5;
+          }
+        }
+        scope Controller {
+          void run() {
+            global.Motor.start();
+          }
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new FunctionCallAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should detect undeclared global.Scope.method() call", () => {
+      const code = `
+        scope Motor {
+          public void start() {
+            u32 x <- 5;
+          }
+        }
+        scope Controller {
+          void run() {
+            global.Motor.undefinedMethod();
+          }
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new FunctionCallAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0422");
+      expect(errors[0].functionName).toBe("Motor_undefinedMethod");
+      expect(errors[0].message).toContain("called before definition");
+      expect(errors[0].message).not.toContain(
+        "not declared in any included header",
+      );
+    });
+
+    it("should NOT resolve global.helper() to scope method Test_helper", () => {
+      const code = `
+        scope Test {
+          void helper() {
+          }
+          void run() {
+            global.helper();
+          }
+        }
+      `;
+      const tree = parse(code);
+      const symbolTable = new SymbolTable();
+
+      const analyzer = new FunctionCallAnalyzer();
+      const errors = analyzer.analyze(tree, symbolTable);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0422");
+      expect(errors[0].functionName).toBe("helper");
+    });
+
+    it("should say 'called before definition' for global.func() on local function", () => {
+      const code = `
+        scope Test {
+          void run() {
+            global.helper();
+          }
+        }
+        void helper() {
+        }
+      `;
+      const tree = parse(code);
+      const symbolTable = new SymbolTable();
+
+      const analyzer = new FunctionCallAnalyzer();
+      const errors = analyzer.analyze(tree, symbolTable);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0422");
+      expect(errors[0].message).toContain("called before definition");
+      expect(errors[0].message).not.toContain(
+        "not declared in any included header",
+      );
+    });
+
+    it("should allow global.func() for external C function", () => {
+      const code = `
+        scope Test {
+          void run() {
+            global.externalFunc();
+          }
+        }
+      `;
+      const tree = parse(code);
+      const symbolTable = new SymbolTable();
+      symbolTable.addCSymbol({
+        name: "externalFunc",
+        kind: "function",
+        sourceLanguage: ESourceLanguage.C,
+        sourceFile: "external.h",
+        sourceLine: 1,
+        isExported: true,
+        type: "void",
+        parameters: [],
+      });
+
+      const analyzer = new FunctionCallAnalyzer();
+      const errors = analyzer.analyze(tree, symbolTable);
+
+      expect(errors).toHaveLength(0);
+    });
+  });
 });

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);
+    });
+  });
 });