redscript-mc 2.0.0 → 2.1.1

package/dist/__tests__/typechecker.test.js

@@ -1,552 +0,0 @@
-"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

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

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

@@ -1,69 +0,0 @@
-"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