redscript-mc 1.0.0

package/dist/__tests__/typechecker.test.js

@@ -0,0 +1,364 @@
+"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('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);
+        });
+    });
+    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);
+        });
+    });
+});
+//# sourceMappingURL=typechecker.test.js.map

package/dist/ast/types.d.ts

@@ -0,0 +1,357 @@
+/**
+ * RedScript AST Types
+ *
+ * This module defines the Abstract Syntax Tree structure for RedScript.
+ * The AST is produced by the parser and consumed by the lowering pass.
+ */
+import type { BinOp, CmpOp } from '../ir/types';
+export interface Span {
+    line: number;
+    col: number;
+    endLine?: number;
+    endCol?: number;
+}
+export type PrimitiveType = 'int' | 'bool' | 'float' | 'string' | 'void' | 'BlockPos' | 'byte' | 'short' | 'long' | 'double';
+export type TypeNode = {
+    kind: 'named';
+    name: PrimitiveType;
+} | {
+    kind: 'array';
+    elem: TypeNode;
+} | {
+    kind: 'struct';
+    name: string;
+} | {
+    kind: 'enum';
+    name: string;
+} | {
+    kind: 'function_type';
+    params: TypeNode[];
+    return: TypeNode;
+};
+export interface LambdaParam {
+    name: string;
+    type?: TypeNode;
+}
+export interface LambdaExpr {
+    kind: 'lambda';
+    params: LambdaParam[];
+    returnType?: TypeNode;
+    body: Expr | Block;
+}
+export interface RangeExpr {
+    min?: number;
+    max?: number;
+}
+export type SelectorKind = '@a' | '@e' | '@s' | '@p' | '@r' | '@n';
+export interface SelectorFilter {
+    type?: string;
+    distance?: RangeExpr;
+    tag?: string[];
+    notTag?: string[];
+    scores?: Record<string, RangeExpr>;
+    limit?: number;
+    sort?: 'nearest' | 'furthest' | 'random' | 'arbitrary';
+    nbt?: string;
+    gamemode?: string;
+}
+export interface EntitySelector {
+    kind: SelectorKind;
+    filters?: SelectorFilter;
+}
+export type CoordComponent = {
+    kind: 'absolute';
+    value: number;
+} | {
+    kind: 'relative';
+    offset: number;
+} | {
+    kind: 'local';
+    offset: number;
+};
+export interface BlockPosExpr {
+    kind: 'blockpos';
+    x: CoordComponent;
+    y: CoordComponent;
+    z: CoordComponent;
+}
+export type AssignOp = '=' | '+=' | '-=' | '*=' | '/=' | '%=';
+export type Expr = {
+    kind: 'int_lit';
+    value: number;
+    span?: Span;
+} | {
+    kind: 'float_lit';
+    value: number;
+    span?: Span;
+} | {
+    kind: 'byte_lit';
+    value: number;
+    span?: Span;
+} | {
+    kind: 'short_lit';
+    value: number;
+    span?: Span;
+} | {
+    kind: 'long_lit';
+    value: number;
+    span?: Span;
+} | {
+    kind: 'double_lit';
+    value: number;
+    span?: Span;
+} | {
+    kind: 'bool_lit';
+    value: boolean;
+    span?: Span;
+} | {
+    kind: 'str_lit';
+    value: string;
+    span?: Span;
+} | {
+    kind: 'mc_name';
+    value: string;
+    span?: Span;
+} | {
+    kind: 'str_interp';
+    parts: Array<string | Expr>;
+    span?: Span;
+} | {
+    kind: 'range_lit';
+    range: RangeExpr;
+    span?: Span;
+} | (BlockPosExpr & {
+    span?: Span;
+}) | {
+    kind: 'ident';
+    name: string;
+    span?: Span;
+} | {
+    kind: 'selector';
+    raw: string;
+    isSingle: boolean;
+    sel: EntitySelector;
+    span?: Span;
+} | {
+    kind: 'binary';
+    op: BinOp | CmpOp | '&&' | '||';
+    left: Expr;
+    right: Expr;
+    span?: Span;
+} | {
+    kind: 'unary';
+    op: '!' | '-';
+    operand: Expr;
+    span?: Span;
+} | {
+    kind: 'assign';
+    target: string;
+    op: AssignOp;
+    value: Expr;
+    span?: Span;
+} | {
+    kind: 'call';
+    fn: string;
+    args: Expr[];
+    span?: Span;
+} | {
+    kind: 'invoke';
+    callee: Expr;
+    args: Expr[];
+    span?: Span;
+} | {
+    kind: 'member';
+    obj: Expr;
+    field: string;
+    span?: Span;
+} | {
+    kind: 'struct_lit';
+    fields: {
+        name: string;
+        value: Expr;
+    }[];
+    span?: Span;
+} | {
+    kind: 'member_assign';
+    obj: Expr;
+    field: string;
+    op: AssignOp;
+    value: Expr;
+    span?: Span;
+} | {
+    kind: 'index';
+    obj: Expr;
+    index: Expr;
+    span?: Span;
+} | {
+    kind: 'array_lit';
+    elements: Expr[];
+    span?: Span;
+} | {
+    kind: 'static_call';
+    type: string;
+    method: string;
+    args: Expr[];
+    span?: Span;
+} | (LambdaExpr & {
+    span?: Span;
+});
+export type LiteralExpr = Extract<Expr, {
+    kind: 'int_lit';
+}> | Extract<Expr, {
+    kind: 'float_lit';
+}> | Extract<Expr, {
+    kind: 'bool_lit';
+}> | Extract<Expr, {
+    kind: 'str_lit';
+}>;
+export type ExecuteSubcommand = {
+    kind: 'as';
+    selector: EntitySelector;
+} | {
+    kind: 'at';
+    selector: EntitySelector;
+} | {
+    kind: 'if_entity';
+    selector: EntitySelector;
+} | {
+    kind: 'unless_entity';
+    selector: EntitySelector;
+} | {
+    kind: 'in';
+    dimension: string;
+};
+export type Stmt = {
+    kind: 'let';
+    name: string;
+    type?: TypeNode;
+    init: Expr;
+    span?: Span;
+} | {
+    kind: 'expr';
+    expr: Expr;
+    span?: Span;
+} | {
+    kind: 'return';
+    value?: Expr;
+    span?: Span;
+} | {
+    kind: 'if';
+    cond: Expr;
+    then: Block;
+    else_?: Block;
+    span?: Span;
+} | {
+    kind: 'while';
+    cond: Expr;
+    body: Block;
+    span?: Span;
+} | {
+    kind: 'for';
+    init?: Stmt;
+    cond: Expr;
+    step: Expr;
+    body: Block;
+    span?: Span;
+} | {
+    kind: 'foreach';
+    binding: string;
+    iterable: Expr;
+    body: Block;
+    span?: Span;
+} | {
+    kind: 'for_range';
+    varName: string;
+    start: Expr;
+    end: Expr;
+    body: Block;
+    span?: Span;
+} | {
+    kind: 'match';
+    expr: Expr;
+    arms: {
+        pattern: Expr | null;
+        body: Block;
+    }[];
+    span?: Span;
+} | {
+    kind: 'as_block';
+    selector: EntitySelector;
+    body: Block;
+    span?: Span;
+} | {
+    kind: 'at_block';
+    selector: EntitySelector;
+    body: Block;
+    span?: Span;
+} | {
+    kind: 'as_at';
+    as_sel: EntitySelector;
+    at_sel: EntitySelector;
+    body: Block;
+    span?: Span;
+} | {
+    kind: 'execute';
+    subcommands: ExecuteSubcommand[];
+    body: Block;
+    span?: Span;
+} | {
+    kind: 'raw';
+    cmd: string;
+    span?: Span;
+};
+export type Block = Stmt[];
+export interface Decorator {
+    name: 'tick' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team';
+    args?: {
+        rate?: number;
+        trigger?: string;
+        advancement?: string;
+        item?: string;
+        team?: string;
+    };
+}
+export interface Param {
+    name: string;
+    type: TypeNode;
+    default?: Expr;
+}
+export interface FnDecl {
+    name: string;
+    params: Param[];
+    returnType: TypeNode;
+    decorators: Decorator[];
+    body: Block;
+    span?: Span;
+}
+export interface StructField {
+    name: string;
+    type: TypeNode;
+}
+export interface StructDecl {
+    name: string;
+    fields: StructField[];
+    span?: Span;
+}
+export interface EnumVariant {
+    name: string;
+    value?: number;
+}
+export interface EnumDecl {
+    name: string;
+    variants: EnumVariant[];
+    span?: Span;
+}
+export interface ConstDecl {
+    name: string;
+    type: TypeNode;
+    value: LiteralExpr;
+    span?: Span;
+}
+export interface Program {
+    namespace: string;
+    declarations: FnDecl[];
+    structs: StructDecl[];
+    enums: EnumDecl[];
+    consts: ConstDecl[];
+}

package/dist/ast/types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * RedScript AST Types
+ *
+ * This module defines the Abstract Syntax Tree structure for RedScript.
+ * The AST is produced by the parser and consumed by the lowering pass.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map