redscript-mc 2.3.0 → 2.4.1

package/dist/__tests__/typechecker.test.js

@@ -0,0 +1,552 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const typechecker_1 = require("../typechecker");
+function typeCheck(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse('test');
+    const checker = new typechecker_1.TypeChecker(source);
+    return checker.check(ast);
+}
+describe('TypeChecker', () => {
+    describe('variable declaration', () => {
+        it('allows using top-level consts inside functions', () => {
+            const errors = typeCheck(`
+const MAX_HP: int = 100
+
+fn test() {
+    let hp: int = MAX_HP;
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('allows using declared variables', () => {
+            const errors = typeCheck(`
+fn test() {
+    let x: int = 5;
+    let y: int = x;
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('detects undeclared variable usage', () => {
+            const errors = typeCheck(`
+fn test() {
+    let x: int = y;
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("'y' used before declaration");
+            expect(errors[0].location.line).toBe(3);
+            expect(errors[0].location.col).toBe(18);
+        });
+        it('detects undeclared variable in expression', () => {
+            const errors = typeCheck(`
+fn test() {
+    let x: int = 5 + undeclared;
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("'undeclared' used before declaration");
+        });
+        it('accepts BlockPos literals for BlockPos variables', () => {
+            const errors = typeCheck(`
+fn test() {
+    let spawn: BlockPos = (~0, 64, ~0);
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('rejects assigning to const', () => {
+            const errors = typeCheck(`
+const MAX_HP: int = 100
+
+fn test() {
+    MAX_HP = 50;
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("Cannot assign to const 'MAX_HP'");
+        });
+    });
+    describe('function calls', () => {
+        it('allows correct number of arguments', () => {
+            const errors = typeCheck(`
+fn add(a: int, b: int) -> int {
+    return a + b;
+}
+
+fn test() {
+    let x: int = add(1, 2);
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('detects wrong number of arguments', () => {
+            const errors = typeCheck(`
+fn add(a: int, b: int) -> int {
+    return a + b;
+}
+
+fn test() {
+    let x: int = add(1);
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("expects 2 arguments, got 1");
+            expect(errors[0].location.line).toBe(7);
+        });
+        it('allows omitting trailing default arguments', () => {
+            const errors = typeCheck(`
+fn greet(name: string, formal: bool = false) {
+    say(name);
+}
+
+fn test() {
+    greet("Player");
+    greet("Player", true);
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('allows f-strings in runtime output builtins', () => {
+            const errors = typeCheck(`
+fn test() {
+    let score: int = 5;
+    say(f"Score: {score}");
+    tellraw(@a, f"Score: {score}");
+    actionbar(@s, f"Score: {score}");
+    title(@s, f"Score: {score}");
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('rejects f-strings outside runtime output builtins', () => {
+            const errors = typeCheck(`
+fn test() {
+    let msg: string = f"Score";
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('expected string, got format_string');
+        });
+        it('rejects unsupported f-string placeholder types', () => {
+            const errors = typeCheck(`
+fn test() {
+    say(f"Flag: {true}");
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('f-string placeholder must be int or string');
+        });
+        it('detects too many arguments', () => {
+            const errors = typeCheck(`
+fn greet() {
+    say("hello");
+}
+
+fn test() {
+    greet(1, 2, 3);
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("expects 0 arguments, got 3");
+        });
+        it('rejects a required parameter after a default parameter', () => {
+            const errors = typeCheck(`
+fn bad(a: int = 1, b: int) {}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("cannot follow a default parameter");
+        });
+        it('rejects non-single selector tp destinations', () => {
+            const errors = typeCheck(`
+fn test() {
+    tp(@s, @a);
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('tp destination must be a single-entity selector');
+        });
+        it('allows single-selector and BlockPos tp destinations', () => {
+            const singleErrors = typeCheck(`
+fn test() {
+    tp(@s, @p);
+    tp(@s, @e[limit=1, tag=target]);
+}
+`);
+            expect(singleErrors).toHaveLength(0);
+            const posErrors = typeCheck(`
+fn test() {
+    tp(@a, (1, 64, 1));
+    tp(@s, (~0, ~10, ~0));
+}
+`);
+            expect(posErrors).toHaveLength(0);
+        });
+        it('treats bossbar_get_value() as int', () => {
+            const errors = typeCheck(`
+fn test() {
+    let current: int = bossbar_get_value("ns:health");
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('allows lambda variables to be called via function types', () => {
+            const errors = typeCheck(`
+fn test() {
+    let double: (int) -> int = (x: int) => x * 2;
+    let result: int = double(5);
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('allows lambdas as callback arguments', () => {
+            const errors = typeCheck(`
+fn apply(val: int, cb: (int) -> int) -> int {
+    return cb(val);
+}
+
+fn test() {
+    let result: int = apply(5, (x: int) => x * 3);
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('infers single-parameter lambdas from the expected function type', () => {
+            const errors = typeCheck(`
+fn test() {
+    let double: (int) -> int = x => x * 2;
+    let result: int = double(5);
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('type checks timer builtins with void callbacks and interval IDs', () => {
+            const errors = typeCheck(`
+fn test() {
+    setTimeout(100, () => {
+        say("later");
+    });
+    let intervalId: int = setInterval(20, () => {
+        say("tick");
+    });
+    clearInterval(intervalId);
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('rejects timer callbacks with the wrong return type', () => {
+            const errors = typeCheck(`
+fn test() {
+    setTimeout(100, () => 1);
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('Return type mismatch: expected void, got int');
+        });
+        it('allows impl instance methods with inferred self type', () => {
+            const errors = typeCheck(`
+struct Timer { duration: int }
+
+impl Timer {
+  fn elapsed(self) -> int {
+    return self.duration;
+  }
+}
+
+fn test() {
+  let timer: Timer = { duration: 10 };
+  let value: int = timer.elapsed();
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('records then-branch entity narrowing for is-checks', () => {
+            const source = `
+fn test() {
+    foreach (e in @e) {
+        if (e is Player) {
+            kill(e);
+        }
+    }
+}
+`;
+            const tokens = new lexer_1.Lexer(source).tokenize();
+            const ast = new parser_1.Parser(tokens).parse('test');
+            const checker = new typechecker_1.TypeChecker(source);
+            checker.check(ast);
+            const foreachStmt = ast.declarations[0].body[0];
+            const ifStmt = foreachStmt.body[0];
+            expect(checker.getThenBranchNarrowing(ifStmt.cond)).toEqual({
+                name: 'e',
+                type: { kind: 'entity', entityType: 'Player' },
+                mutable: false,
+            });
+        });
+        it('allows static impl method calls', () => {
+            const errors = typeCheck(`
+struct Timer { duration: int }
+
+impl Timer {
+  fn new(duration: int) -> Timer {
+    return { duration: duration };
+  }
+}
+
+fn test() {
+  let timer: Timer = Timer::new(10);
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('rejects using is-checks on non-entity values', () => {
+            const errors = typeCheck(`
+fn test() {
+    let x: int = 1;
+    if (x is Player) {
+        say("nope");
+    }
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("'is' checks require an entity expression, got int");
+        });
+        it('rejects calling instance impl methods as static methods', () => {
+            const errors = typeCheck(`
+struct Point { x: int, y: int }
+
+impl Point {
+  fn distance(self) -> int {
+    return self.x + self.y;
+  }
+}
+
+fn test() {
+  let total: int = Point::distance();
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("Method 'Point::distance' is an instance method");
+        });
+    });
+    describe('entity is-check narrowing', () => {
+        it('allows entity type checks on foreach bindings', () => {
+            const errors = typeCheck(`
+fn test() {
+    foreach (e in @e) {
+        if (e is Player) {
+            kill(@s);
+        }
+    }
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('rejects is-checks on non-entity expressions', () => {
+            const errors = typeCheck(`
+fn test() {
+    let x: int = 1;
+    if (x is Player) {}
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("'is' checks require an entity expression");
+        });
+    });
+    describe('return type checking', () => {
+        it('allows matching return type', () => {
+            const errors = typeCheck(`
+fn get_five() -> int {
+    return 5;
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('detects return type mismatch', () => {
+            const errors = typeCheck(`
+fn get_bool() -> bool {
+    return 5;
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("Return type mismatch");
+        });
+        it('detects missing return value', () => {
+            const errors = typeCheck(`
+fn get_int() -> int {
+    return;
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("Missing return value");
+        });
+        it('allows void return with no value', () => {
+            const errors = typeCheck(`
+fn do_nothing() {
+    return;
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+    });
+    describe('member access', () => {
+        it('allows struct field access', () => {
+            const errors = typeCheck(`
+struct Point { x: int, y: int }
+
+fn test() {
+    let p: Point = { x: 10, y: 20 };
+    let val: int = p.x;
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('detects invalid struct field', () => {
+            const errors = typeCheck(`
+struct Point { x: int, y: int }
+
+fn test() {
+    let p: Point = { x: 10, y: 20 };
+    let val: int = p.z;
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("has no field 'z'");
+            expect(errors[0].location.line).toBe(6);
+        });
+        it('allows array.len access', () => {
+            const errors = typeCheck(`
+fn test() {
+    let arr: int[] = [1, 2, 3];
+    let len: int = arr.len;
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('detects member access on primitive', () => {
+            const errors = typeCheck(`
+fn test() {
+    let x: int = 5;
+    let y: int = x.value;
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("Cannot access member");
+        });
+        it('allows enum variants and enum-typed variables', () => {
+            const errors = typeCheck(`
+enum Direction { North, South, East, West }
+
+fn test() {
+    let dir: Direction = Direction.North;
+    if (dir == Direction.South) {
+        say("south");
+    }
+    match (dir) {
+        Direction.East => { say("east"); }
+        _ => { say("other"); }
+    }
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+    });
+    describe('control flow', () => {
+        it('checks conditions in if statements', () => {
+            const errors = typeCheck(`
+fn test() {
+    if (undeclared > 0) {
+        say("yes");
+    }
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("'undeclared' used before declaration");
+        });
+        it('checks conditions in while loops', () => {
+            const errors = typeCheck(`
+fn test() {
+    while (missing) {
+        say("loop");
+    }
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("'missing' used before declaration");
+        });
+        it('checks for loop parts', () => {
+            const errors = typeCheck(`
+fn test() {
+    for (let i: int = 0; i < count; i = i + 1) {
+        say("loop");
+    }
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("'count' used before declaration");
+        });
+    });
+    describe('complex programs', () => {
+        it('handles valid complex program', () => {
+            const errors = typeCheck(`
+struct Stats { health: int, mana: int }
+
+fn heal(amount: int) -> int {
+    let bonus: int = amount * 2;
+    return bonus;
+}
+
+@tick
+fn game_loop() {
+    let stats: Stats = { health: 100, mana: 50 };
+    let healed: int = heal(10);
+    stats.health = stats.health + healed;
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('collects multiple errors', () => {
+            const errors = typeCheck(`
+fn broken() -> int {
+    let x: int = undefined_var;
+    let y: int = another_undefined;
+    missing_func();
+    return false;
+}
+`);
+            // Should have multiple errors: 2 undefined vars, return type mismatch
+            // (missing_func is not checked since it's not defined as a user function)
+            expect(errors.length).toBeGreaterThanOrEqual(3);
+        });
+    });
+    describe('event handlers', () => {
+        it('accepts matching @on event signatures', () => {
+            const errors = typeCheck(`
+@on(PlayerDeath)
+fn handle_death(player: Player) {
+    tp(player, @p);
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('rejects unknown event types', () => {
+            const errors = typeCheck(`
+@on(NotARealEvent)
+fn handle(player: Player) {}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("Unknown event type 'NotARealEvent'");
+        });
+        it('rejects mismatched event signatures', () => {
+            const errors = typeCheck(`
+@on(BlockBreak)
+fn handle_break(player: Player) {}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('must declare 2 parameter(s)');
+        });
+    });
+});
+//# sourceMappingURL=typechecker.test.js.map

package/dist/__tests__/var-allocator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/var-allocator.test.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const var_allocator_1 = require("../codegen/var-allocator");
+describe('VarAllocator', () => {
+    describe('mangle mode (default)', () => {
+        it('generates sequential names: a, b, ..., z, aa, ab', () => {
+            const alloc = new var_allocator_1.VarAllocator(true);
+            const names = [];
+            for (let i = 0; i < 28; i++) {
+                names.push(alloc.alloc(`var${i}`));
+            }
+            expect(names[0]).toBe('$a');
+            expect(names[1]).toBe('$b');
+            expect(names[25]).toBe('$z');
+            expect(names[26]).toBe('$aa');
+            expect(names[27]).toBe('$ab');
+        });
+        it('caches: same name returns same result', () => {
+            const alloc = new var_allocator_1.VarAllocator(true);
+            const first = alloc.alloc('x');
+            const second = alloc.alloc('x');
+            expect(first).toBe(second);
+        });
+        it('constant() is content-addressed: same value returns same result', () => {
+            const alloc = new var_allocator_1.VarAllocator(true);
+            const first = alloc.constant(42);
+            const second = alloc.constant(42);
+            expect(first).toBe(second);
+        });
+        it('different variables get different names', () => {
+            const alloc = new var_allocator_1.VarAllocator(true);
+            const a = alloc.alloc('foo');
+            const b = alloc.alloc('bar');
+            expect(a).not.toBe(b);
+        });
+        it('alloc, constant, and internal share the same sequential pool', () => {
+            const alloc = new var_allocator_1.VarAllocator(true);
+            const v = alloc.alloc('x'); // $a
+            const c = alloc.constant(1); // $b
+            const i = alloc.internal('ret'); // $c
+            expect(v).toBe('$a');
+            expect(c).toBe('$b');
+            expect(i).toBe('$c');
+        });
+        it('strips $ prefix from variable names', () => {
+            const alloc = new var_allocator_1.VarAllocator(true);
+            const a = alloc.alloc('$foo');
+            const b = alloc.alloc('foo');
+            expect(a).toBe(b); // same underlying name
+        });
+    });
+    describe('no-mangle mode', () => {
+        it('uses $<name> for user vars', () => {
+            const alloc = new var_allocator_1.VarAllocator(false);
+            expect(alloc.alloc('counter')).toBe('$counter');
+        });
+        it('uses $const_<value> for constants', () => {
+            const alloc = new var_allocator_1.VarAllocator(false);
+            expect(alloc.constant(10)).toBe('$const_10');
+            expect(alloc.constant(-3)).toBe('$const_-3');
+        });
+        it('uses $<suffix> for internals', () => {
+            const alloc = new var_allocator_1.VarAllocator(false);
+            expect(alloc.internal('ret')).toBe('$ret');
+            expect(alloc.internal('p0')).toBe('$p0');
+        });
+    });
+});
+//# sourceMappingURL=var-allocator.test.js.map