redscript-mc 2.6.2 → 3.0.0

package/dist/src/__tests__/compiler/deprecated.test.js

@@ -0,0 +1,285 @@
+"use strict";
+/**
+ * Tests for @deprecated decorator and compile-time deprecation warnings.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../../emit/compile");
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const lower_1 = require("../../hir/lower");
+const monomorphize_1 = require("../../hir/monomorphize");
+const deprecated_1 = require("../../hir/deprecated");
+// ---------------------------------------------------------------------------
+// Parser: recognizes @deprecated decorator
+// ---------------------------------------------------------------------------
+describe('@deprecated decorator — parser', () => {
+    it('parses @deprecated("message") on a function', () => {
+        const src = `
+      @deprecated("use take_damage() instead")
+      fn apply_damage(amount: int) {
+        let x: int = amount
+      }
+    `;
+        const tokens = new lexer_1.Lexer(src).tokenize();
+        const ast = new parser_1.Parser(tokens, src).parse('test');
+        expect(ast.declarations).toHaveLength(1);
+        const fn = ast.declarations[0];
+        expect(fn.decorators).toHaveLength(1);
+        const dec = fn.decorators[0];
+        expect(dec.name).toBe('deprecated');
+        expect(dec.args?.message).toBe('use take_damage() instead');
+    });
+    it('parses @deprecated with no message', () => {
+        const src = `
+      @deprecated("")
+      fn old_fn() {
+        let x: int = 1
+      }
+    `;
+        const tokens = new lexer_1.Lexer(src).tokenize();
+        const ast = new parser_1.Parser(tokens, src).parse('test');
+        const fn = ast.declarations[0];
+        const dec = fn.decorators[0];
+        expect(dec.name).toBe('deprecated');
+        expect(dec.args?.message).toBe('');
+    });
+});
+// ---------------------------------------------------------------------------
+// HIR: deprecated function marked in decorators
+// ---------------------------------------------------------------------------
+describe('@deprecated decorator — HIR', () => {
+    it('preserves @deprecated decorator in HIR function', () => {
+        const src = `
+      @deprecated("use new_fn() instead")
+      fn old_fn(x: int) {
+        let y: int = x
+      }
+    `;
+        const tokens = new lexer_1.Lexer(src).tokenize();
+        const ast = new parser_1.Parser(tokens, src).parse('test');
+        const hir = (0, lower_1.lowerToHIR)(ast);
+        const fn = hir.functions.find(f => f.name === 'old_fn');
+        expect(fn).toBeDefined();
+        const dep = fn.decorators.find(d => d.name === 'deprecated');
+        expect(dep).toBeDefined();
+        expect(dep.args?.message).toBe('use new_fn() instead');
+    });
+});
+// ---------------------------------------------------------------------------
+// checkDeprecatedCalls: warning generation
+// ---------------------------------------------------------------------------
+describe('checkDeprecatedCalls', () => {
+    it('emits warning when a deprecated function is called', () => {
+        const src = `
+      @deprecated("use take_damage() instead")
+      fn apply_damage(amount: int) {
+        let x: int = amount
+      }
+
+      fn test() {
+        apply_damage(5)
+      }
+    `;
+        const tokens = new lexer_1.Lexer(src).tokenize();
+        const ast = new parser_1.Parser(tokens, src).parse('test');
+        const hirRaw = (0, lower_1.lowerToHIR)(ast);
+        const hir = (0, monomorphize_1.monomorphize)(hirRaw);
+        const warnings = (0, deprecated_1.checkDeprecatedCalls)(hir);
+        expect(warnings).toHaveLength(1);
+        expect(warnings[0]).toContain('apply_damage');
+        expect(warnings[0]).toContain('deprecated');
+        expect(warnings[0]).toContain('use take_damage() instead');
+        expect(warnings[0]).toContain('[DeprecatedUsage]');
+    });
+    it('emits no warning when calling a non-deprecated function', () => {
+        const src = `
+      fn safe_fn(amount: int) {
+        let x: int = amount
+      }
+
+      fn test() {
+        safe_fn(5)
+      }
+    `;
+        const tokens = new lexer_1.Lexer(src).tokenize();
+        const ast = new parser_1.Parser(tokens, src).parse('test');
+        const hirRaw = (0, lower_1.lowerToHIR)(ast);
+        const hir = (0, monomorphize_1.monomorphize)(hirRaw);
+        const warnings = (0, deprecated_1.checkDeprecatedCalls)(hir);
+        expect(warnings).toHaveLength(0);
+    });
+    it('emits warning with caller function name in message', () => {
+        const src = `
+      @deprecated("old api")
+      fn old_api() {
+        let x: int = 1
+      }
+
+      fn caller_fn() {
+        old_api()
+      }
+    `;
+        const tokens = new lexer_1.Lexer(src).tokenize();
+        const ast = new parser_1.Parser(tokens, src).parse('test');
+        const hirRaw = (0, lower_1.lowerToHIR)(ast);
+        const hir = (0, monomorphize_1.monomorphize)(hirRaw);
+        const warnings = (0, deprecated_1.checkDeprecatedCalls)(hir);
+        expect(warnings[0]).toContain("caller_fn");
+        expect(warnings[0]).toContain("old_api");
+    });
+    it('emits multiple warnings when deprecated fn is called multiple times', () => {
+        const src = `
+      @deprecated("outdated")
+      fn legacy(x: int) {
+        let y: int = x
+      }
+
+      fn main_fn() {
+        legacy(1)
+        legacy(2)
+        legacy(3)
+      }
+    `;
+        const tokens = new lexer_1.Lexer(src).tokenize();
+        const ast = new parser_1.Parser(tokens, src).parse('test');
+        const hirRaw = (0, lower_1.lowerToHIR)(ast);
+        const hir = (0, monomorphize_1.monomorphize)(hirRaw);
+        const warnings = (0, deprecated_1.checkDeprecatedCalls)(hir);
+        expect(warnings).toHaveLength(3);
+    });
+});
+// ---------------------------------------------------------------------------
+// compile(): end-to-end — warnings propagate through full pipeline
+// ---------------------------------------------------------------------------
+describe('@deprecated end-to-end via compile()', () => {
+    it('emits [DeprecatedUsage] warning in compile result', () => {
+        const src = `
+      @deprecated("use take_damage() instead")
+      @tick
+      fn apply_damage() {
+        let x: int = 1
+      }
+
+      @tick
+      fn test_caller() {
+        apply_damage()
+      }
+    `;
+        const result = (0, compile_1.compile)(src, { namespace: 'test' });
+        const depWarnings = result.warnings.filter(w => w.includes('[DeprecatedUsage]'));
+        expect(depWarnings).toHaveLength(1);
+        expect(depWarnings[0]).toContain('apply_damage');
+        expect(depWarnings[0]).toContain('use take_damage() instead');
+    });
+    it('does not emit warnings when no deprecated calls exist', () => {
+        const src = `
+      @tick
+      fn safe_fn() {
+        let x: int = 1
+      }
+    `;
+        const result = (0, compile_1.compile)(src, { namespace: 'test' });
+        const depWarnings = result.warnings.filter(w => w.includes('[DeprecatedUsage]'));
+        expect(depWarnings).toHaveLength(0);
+    });
+    it('deprecated function itself can still compile successfully', () => {
+        const src = `
+      @deprecated("use new_fn()")
+      @tick
+      fn old_fn() {
+        let x: int = 42
+      }
+    `;
+        // Should compile without throwing — @deprecated doesn't prevent compilation
+        expect(() => (0, compile_1.compile)(src, { namespace: 'test' })).not.toThrow();
+    });
+});
+function mkDecorator(message) {
+    return message === undefined ? { name: 'deprecated' } : { name: 'deprecated', args: { message } };
+}
+function mkFn(name, body, decorators = []) {
+    return {
+        name,
+        params: [],
+        returnType: { kind: 'named', name: 'void' },
+        decorators,
+        body,
+    };
+}
+function span(line, col = 1) {
+    return { line, col };
+}
+function call(fn, callSpan) {
+    return callSpan ? { kind: 'call', fn, args: [], span: callSpan } : { kind: 'call', fn, args: [] };
+}
+describe('checkDeprecatedCalls — manual walker coverage', () => {
+    it('walks nested stmt/expr forms and skips execute/raw-style statements', () => {
+        const module = {
+            namespace: 'test',
+            globals: [],
+            structs: [],
+            enums: [],
+            consts: [],
+            functions: [
+                mkFn('old_fn', [], [mkDecorator('use new_fn')]),
+                mkFn('old_empty', [], [mkDecorator()]),
+                mkFn('caller', [
+                    { kind: 'let', name: 'a', init: call('old_fn', span(1, 2)) },
+                    { kind: 'expr', expr: call('old_empty') },
+                    { kind: 'return' },
+                    { kind: 'if', cond: call('old_fn'), then: [{ kind: 'expr', expr: call('old_fn') }], else_: [{ kind: 'expr', expr: call('old_empty') }] },
+                    { kind: 'if', cond: call('old_fn'), then: [] },
+                    { kind: 'while', cond: call('old_fn'), body: [{ kind: 'expr', expr: call('old_fn') }], step: [{ kind: 'expr', expr: call('old_empty') }] },
+                    { kind: 'while', cond: call('old_fn'), body: [] },
+                    { kind: 'foreach', binding: 'item', iterable: call('old_fn'), body: [{ kind: 'expr', expr: call('old_fn') }] },
+                    { kind: 'match', expr: call('old_fn'), arms: [{ pattern: { kind: 'PatWild' }, body: [{ kind: 'expr', expr: call('old_fn') }] }] },
+                    { kind: 'execute', subcommands: [], body: [{ kind: 'expr', expr: call('old_fn') }] },
+                    { kind: 'raw', cmd: 'say ignored' },
+                    { kind: 'break' },
+                    { kind: 'continue' },
+                    { kind: 'expr', expr: { kind: 'static_call', type: 'Box', method: 'old_method', args: [], span: span(3, 4) } },
+                    { kind: 'expr', expr: { kind: 'static_call', type: 'Box', method: 'old_empty_method', args: [] } },
+                    { kind: 'expr', expr: { kind: 'invoke', callee: call('old_fn'), args: [call('old_empty')] } },
+                    { kind: 'expr', expr: { kind: 'binary', op: '+', left: call('old_fn'), right: call('old_empty') } },
+                    { kind: 'expr', expr: { kind: 'unary', op: '-', operand: call('old_fn') } },
+                    { kind: 'expr', expr: { kind: 'is_check', expr: call('old_fn'), entityType: 'entity' } },
+                    { kind: 'expr', expr: { kind: 'type_cast', expr: call('old_fn'), targetType: { kind: 'named', name: 'int' } } },
+                    { kind: 'expr', expr: { kind: 'assign', target: 'value', value: call('old_fn') } },
+                    { kind: 'expr', expr: { kind: 'member_assign', obj: call('old_fn'), field: 'x', value: call('old_empty') } },
+                    { kind: 'expr', expr: { kind: 'index_assign', obj: call('old_fn'), index: call('old_empty'), op: '=', value: call('old_fn') } },
+                    { kind: 'expr', expr: { kind: 'member', obj: call('old_fn'), field: 'x' } },
+                    { kind: 'expr', expr: { kind: 'index', obj: call('old_fn'), index: call('old_empty') } },
+                    { kind: 'expr', expr: { kind: 'array_lit', elements: [call('old_fn')] } },
+                    { kind: 'expr', expr: { kind: 'struct_lit', fields: [{ name: 'x', value: call('old_fn') }] } },
+                    { kind: 'expr', expr: { kind: 'str_interp', parts: ['x=', call('old_fn')] } },
+                    { kind: 'expr', expr: { kind: 'f_string', parts: [{ kind: 'text', value: 'x=' }, { kind: 'expr', expr: call('old_fn') }] } },
+                    { kind: 'expr', expr: { kind: 'some_lit', value: call('old_fn') } },
+                    { kind: 'expr', expr: { kind: 'unwrap_or', opt: call('old_fn'), default_: call('old_empty') } },
+                    { kind: 'expr', expr: { kind: 'lambda', params: [], body: [{ kind: 'expr', expr: call('old_fn') }] } },
+                    { kind: 'expr', expr: { kind: 'lambda', params: [], body: call('old_empty') } },
+                    { kind: 'expr', expr: { kind: 'tuple_lit', elements: [call('old_fn')] } },
+                    { kind: 'expr', expr: { kind: 'enum_construct', enumName: 'State', variant: 'On', args: [{ name: 'value', value: call('old_fn') }] } },
+                ]),
+            ],
+            implBlocks: [
+                {
+                    typeName: 'Box',
+                    methods: [
+                        mkFn('old_method', [], [mkDecorator('use Box::new_method')]),
+                        mkFn('old_empty_method', [], [mkDecorator()]),
+                        mkFn('helper', []),
+                    ],
+                },
+            ],
+        };
+        const warnings = (0, deprecated_1.checkDeprecatedCalls)(module);
+        expect(warnings).toHaveLength(43);
+        expect(warnings.some(w => w.includes("line 1, col 2: 'old_fn' is deprecated: use new_fn"))).toBe(true);
+        expect(warnings.some(w => w.includes("'old_empty' is deprecated (called from 'caller')"))).toBe(true);
+        expect(warnings.some(w => w.includes("line 3, col 4: 'Box::old_method' is deprecated: use Box::new_method"))).toBe(true);
+        expect(warnings.some(w => w.includes("'Box::old_empty_method' is deprecated (called from 'caller')"))).toBe(true);
+        expect(warnings.some(w => w.includes('(called from \'caller\')'))).toBe(true);
+        expect(warnings.some(w => w.includes('line 3, col 4'))).toBe(true);
+    });
+});
+//# sourceMappingURL=deprecated.test.js.map

package/dist/src/__tests__/compiler/do-while.test.d.ts

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

package/dist/src/__tests__/compiler/do-while.test.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const lower_1 = require("../../hir/lower");
+const lower_2 = require("../../mir/lower");
+const verify_1 = require("../../mir/verify");
+const compile_1 = require("../../emit/compile");
+const DO_WHILE_SOURCE = `
+  fn test_do_while() {
+    let i: int = 0
+    do {
+      i = i + 1
+    } while i < 5
+  }
+`;
+const REPEAT_SOURCE = `
+  fn test_repeat() {
+    let count: int = 0
+    repeat 5 {
+      count = count + 1
+    }
+  }
+`;
+function parse(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    return new parser_1.Parser(tokens, source).parse('test');
+}
+function lowerFn(source, fnName) {
+    const ast = parse(source);
+    const hir = (0, lower_1.lowerToHIR)(ast);
+    const mir = (0, lower_2.lowerToMIR)(hir);
+    expect((0, verify_1.verifyMIR)(mir)).toEqual([]);
+    return mir.functions.find(fn => fn.name === fnName);
+}
+// ---------------------------------------------------------------------------
+// do-while tests
+// ---------------------------------------------------------------------------
+describe('do-while statement', () => {
+    test('parser recognizes do_while AST node', () => {
+        const ast = parse(DO_WHILE_SOURCE);
+        const fn = ast.declarations[0];
+        // let i + do_while
+        const doWhile = fn.body[1];
+        expect(doWhile.kind).toBe('do_while');
+        if (doWhile.kind !== 'do_while')
+            throw new Error('expected do_while');
+        expect(doWhile.cond).toBeDefined();
+        expect(doWhile.body.length).toBeGreaterThan(0);
+    });
+    test('HIR lowering desugars do_while to body + while', () => {
+        const ast = parse(DO_WHILE_SOURCE);
+        const hir = (0, lower_1.lowerToHIR)(ast);
+        const fn = hir.functions[0];
+        // HIR should have: let i, <body stmts>, while
+        const stmts = fn.body;
+        const whileStmt = stmts[stmts.length - 1];
+        expect(whileStmt.kind).toBe('while');
+    });
+    test('MIR has a loop_header block (condition check)', () => {
+        const fn = lowerFn(DO_WHILE_SOURCE, 'test_do_while');
+        const headerBlock = fn.blocks.find(b => b.id.startsWith('loop_header'));
+        expect(headerBlock).toBeDefined();
+    });
+    test('end-to-end compile accepts do-while program', () => {
+        expect(() => (0, compile_1.compile)(DO_WHILE_SOURCE, { namespace: 'test' })).not.toThrow();
+    });
+    test('do-while body runs at least once (parse + HIR sanity)', () => {
+        // The body statements appear before the while node in HIR
+        const ast = parse(DO_WHILE_SOURCE);
+        const hir = (0, lower_1.lowerToHIR)(ast);
+        const fn = hir.functions[0];
+        // stmts: let i=0, body[0] (i = i+1), while(i<5) { body[0] }
+        // There should be at least 3 statements (let, unconditional body, while)
+        expect(fn.body.length).toBeGreaterThanOrEqual(3);
+    });
+});
+// ---------------------------------------------------------------------------
+// repeat N tests
+// ---------------------------------------------------------------------------
+describe('repeat N statement', () => {
+    test('parser recognizes repeat AST node with correct count', () => {
+        const ast = parse(REPEAT_SOURCE);
+        const fn = ast.declarations[0];
+        // let count + repeat
+        const repeatStmt = fn.body[1];
+        expect(repeatStmt.kind).toBe('repeat');
+        if (repeatStmt.kind !== 'repeat')
+            throw new Error('expected repeat');
+        expect(repeatStmt.count).toBe(5);
+        expect(repeatStmt.body.length).toBeGreaterThan(0);
+    });
+    test('HIR lowering desugars repeat to let counter + while', () => {
+        const ast = parse(REPEAT_SOURCE);
+        const hir = (0, lower_1.lowerToHIR)(ast);
+        const fn = hir.functions[0];
+        // stmts: let count, let __repeat_i_N, while(...)
+        const whileStmt = fn.body[fn.body.length - 1];
+        expect(whileStmt.kind).toBe('while');
+        if (whileStmt.kind !== 'while')
+            throw new Error('expected while in HIR');
+        // condition: __repeat_i_N < 5
+        expect(whileStmt.cond.kind).toBe('binary');
+        if (whileStmt.cond.kind === 'binary') {
+            expect(whileStmt.cond.op).toBe('<');
+            expect(whileStmt.cond.right).toMatchObject({ kind: 'int_lit', value: 5 });
+        }
+    });
+    test('MIR has loop blocks for repeat', () => {
+        const fn = lowerFn(REPEAT_SOURCE, 'test_repeat');
+        const headerBlock = fn.blocks.find(b => b.id.startsWith('loop_header'));
+        expect(headerBlock).toBeDefined();
+        const exitBlock = fn.blocks.find(b => b.id.startsWith('loop_exit'));
+        expect(exitBlock).toBeDefined();
+    });
+    test('end-to-end compile accepts repeat program', () => {
+        expect(() => (0, compile_1.compile)(REPEAT_SOURCE, { namespace: 'test' })).not.toThrow();
+    });
+});
+//# sourceMappingURL=do-while.test.js.map

package/dist/src/__tests__/compiler/enum-payload.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Enum with payload tests.
+ *
+ * Tests cover:
+ * - Parser: enum variants with payload fields, enum_construct expr, PatEnum
+ * - Type checker: payload field validation, binding type inference
+ * - MIR/E2E: construction emits NBT writes; match emits tag check + NBT reads
+ */
+export {};