redscript-mc 2.6.2 → 3.0.1

package/dist/src/typechecker/index.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeChecker = void 0;
 const diagnostics_1 = require("../diagnostics");
 const types_1 = require("../events/types");
+const expand_1 = require("../structs/expand");
 // Entity type hierarchy for subtype checking
 const ENTITY_HIERARCHY = {
     'entity': null,
@@ -94,6 +95,10 @@ const INT_TYPE = { kind: 'named', name: 'int' };
 const STRING_TYPE = { kind: 'named', name: 'string' };
 const FORMAT_STRING_TYPE = { kind: 'named', name: 'format_string' };
 const BUILTIN_SIGNATURES = {
+    assert: {
+        params: [{ kind: 'named', name: 'bool' }],
+        return: VOID_TYPE,
+    },
     setTimeout: {
         params: [INT_TYPE, { kind: 'function_type', params: [], return: VOID_TYPE }],
         return: VOID_TYPE,
@@ -106,6 +111,14 @@ const BUILTIN_SIGNATURES = {
         params: [INT_TYPE],
         return: VOID_TYPE,
     },
+    int_to_str: {
+        params: [INT_TYPE],
+        return: STRING_TYPE,
+    },
+    bool_to_str: {
+        params: [{ kind: 'named', name: 'bool' }],
+        return: STRING_TYPE,
+    },
 };
 // ---------------------------------------------------------------------------
 // Type Checker
@@ -117,6 +130,8 @@ class TypeChecker {
         this.implMethods = new Map();
         this.structs = new Map();
         this.enums = new Map();
+        // enumName → variantName → field list (for payload variants)
+        this.enumPayloads = new Map();
         this.consts = new Map();
         this.globals = new Map();
         this.currentFn = null;
@@ -127,6 +142,8 @@ class TypeChecker {
         // Depth of loop/conditional nesting (for static-allocation enforcement)
         this.loopDepth = 0;
         this.condDepth = 0;
+        // interface name → InterfaceDecl
+        this.interfaces = new Map();
         this.richTextBuiltins = new Map([
             ['say', { messageIndex: 0 }],
             ['announce', { messageIndex: 0 }],
@@ -167,6 +184,10 @@ class TypeChecker {
         for (const fn of program.declarations) {
             this.functions.set(fn.name, fn);
         }
+        // Register interface declarations
+        for (const iface of program.interfaces ?? []) {
+            this.interfaces.set(iface.name, iface);
+        }
         // Register global variables (mutable) so functions can reference and assign them
         for (const global of program.globals ?? []) {
             this.globals.set(global.name, this.normalizeType(global.type));
@@ -191,19 +212,59 @@ class TypeChecker {
                 methods.set(method.name, method);
             }
         }
-        for (const struct of program.structs ?? []) {
+        const expandedStructs = (0, expand_1.expandStructDeclarations)(program.structs ?? [], ({ message, node }) => {
+            this.report(message, node);
+        });
+        for (const struct of expandedStructs) {
             const fields = new Map();
             for (const field of struct.fields) {
                 fields.set(field.name, field.type);
             }
             this.structs.set(struct.name, fields);
+            // @singleton structs get synthetic static get() and set(gs) methods
+            if (struct.isSingleton) {
+                const structType = { kind: 'struct', name: struct.name };
+                let singletonMethods = this.implMethods.get(struct.name);
+                if (!singletonMethods) {
+                    singletonMethods = new Map();
+                    this.implMethods.set(struct.name, singletonMethods);
+                }
+                const voidType = { kind: 'named', name: 'void' };
+                // Synthetic get() — no params, returns struct
+                singletonMethods.set('get', {
+                    name: 'get',
+                    params: [],
+                    returnType: structType,
+                    decorators: [],
+                    body: [],
+                    typeParams: undefined,
+                    isLibraryFn: true,
+                });
+                // Synthetic set(gs: StructName) — takes struct, returns void
+                singletonMethods.set('set', {
+                    name: 'set',
+                    params: [{ name: 'gs', type: structType }],
+                    returnType: voidType,
+                    decorators: [],
+                    body: [],
+                    typeParams: undefined,
+                    isLibraryFn: true,
+                });
+            }
         }
         for (const enumDecl of program.enums ?? []) {
             const variants = new Map();
+            const payloads = new Map();
             for (const variant of enumDecl.variants) {
                 variants.set(variant.name, variant.value ?? 0);
+                if (variant.fields && variant.fields.length > 0) {
+                    payloads.set(variant.name, variant.fields);
+                }
             }
             this.enums.set(enumDecl.name, variants);
+            if (payloads.size > 0) {
+                this.enumPayloads.set(enumDecl.name, payloads);
+            }
         }
         for (const constDecl of program.consts ?? []) {
             const constType = this.normalizeType(constDecl.type);
@@ -213,6 +274,21 @@ class TypeChecker {
             }
             this.consts.set(constDecl.name, constType);
         }
+        // Verify that each `impl <Interface> for <Struct>` satisfies all interface methods
+        for (const implBlock of program.implBlocks ?? []) {
+            if (!implBlock.traitName)
+                continue;
+            const iface = this.interfaces.get(implBlock.traitName);
+            if (!iface)
+                continue; // Unknown trait — not our concern here (could be built-in like Display)
+            const implementedMethods = new Set(implBlock.methods.map(m => m.name));
+            for (const required of iface.methods) {
+                if (!implementedMethods.has(required.name)) {
+                    const span = implBlock.span ?? required.span;
+                    this.report(`Struct '${implBlock.typeName}' does not implement required method '${required.name}' from interface '${implBlock.traitName}'`, span ?? { line: 1, col: 1 });
+                }
+            }
+        }
         // Second pass: type check function bodies
         for (const fn of program.declarations) {
             this.checkFunction(fn);
@@ -262,6 +338,78 @@ class TypeChecker {
         this.currentReturnType = null;
     }
     checkFunctionDecorators(fn) {
+        const watchDecorators = fn.decorators.filter(decorator => decorator.name === 'watch');
+        if (watchDecorators.length > 1) {
+            this.report(`Function '${fn.name}' cannot have multiple @watch decorators`, fn);
+            return;
+        }
+        if (watchDecorators.length === 1) {
+            const objective = watchDecorators[0].args?.objective;
+            if (!objective) {
+                this.report(`Function '${fn.name}' is missing a scoreboard objective in @watch("...")`, fn);
+                return;
+            }
+            if (fn.params.length > 0) {
+                this.report(`@watch handler '${fn.name}' cannot declare parameters`, fn);
+            }
+        }
+        const throttleDecorators = fn.decorators.filter(decorator => decorator.name === 'throttle');
+        if (throttleDecorators.length > 1) {
+            this.report(`Function '${fn.name}' cannot have multiple @throttle decorators`, fn);
+            return;
+        }
+        if (throttleDecorators.length === 1) {
+            const ticks = throttleDecorators[0].args?.ticks;
+            if (ticks === undefined || ticks <= 0) {
+                this.report(`@throttle on '${fn.name}' requires ticks=N (positive integer)`, fn);
+            }
+        }
+        const retryDecorators = fn.decorators.filter(decorator => decorator.name === 'retry');
+        if (retryDecorators.length > 1) {
+            this.report(`Function '${fn.name}' cannot have multiple @retry decorators`, fn);
+            return;
+        }
+        if (retryDecorators.length === 1) {
+            const max = retryDecorators[0].args?.max;
+            if (max === undefined || max <= 0) {
+                this.report(`@retry on '${fn.name}' requires max=N (positive integer)`, fn);
+            }
+        }
+        const profileDecorators = fn.decorators.filter(decorator => decorator.name === 'profile');
+        if (profileDecorators.length > 1) {
+            this.report(`Function '${fn.name}' cannot have multiple @profile decorators`, fn);
+            return;
+        }
+        if (profileDecorators.length === 1 && (profileDecorators[0].rawArgs?.length || profileDecorators[0].args && Object.keys(profileDecorators[0].args).length > 0)) {
+            this.report(`@profile decorator on '${fn.name}' does not accept arguments`, fn);
+            return;
+        }
+        const benchmarkDecorators = fn.decorators.filter(decorator => decorator.name === 'benchmark');
+        if (benchmarkDecorators.length > 1) {
+            this.report(`Function '${fn.name}' cannot have multiple @benchmark decorators`, fn);
+            return;
+        }
+        if (benchmarkDecorators.length === 1 && (benchmarkDecorators[0].rawArgs?.length || benchmarkDecorators[0].args && Object.keys(benchmarkDecorators[0].args).length > 0)) {
+            this.report(`@benchmark decorator on '${fn.name}' does not accept arguments`, fn);
+            return;
+        }
+        const memoizeDecorators = fn.decorators.filter(decorator => decorator.name === 'memoize');
+        if (memoizeDecorators.length > 1) {
+            this.report(`Function '${fn.name}' cannot have multiple @memoize decorators`, fn);
+            return;
+        }
+        if (memoizeDecorators.length === 1) {
+            if (fn.params.length !== 1) {
+                this.report(`@memoize on '${fn.name}' requires exactly one parameter`, fn);
+            }
+            else {
+                const paramType = fn.params[0].type;
+                const isInt = paramType.kind === 'named' && paramType.name === 'int';
+                if (!isInt) {
+                    this.report(`@memoize on '${fn.name}' only supports int parameters (got '${paramType.kind === 'named' ? paramType.name : paramType.kind}')`, fn);
+                }
+            }
+        }
         const eventDecorators = fn.decorators.filter(decorator => decorator.name === 'on');
         if (eventDecorators.length === 0) {
             return;
@@ -372,9 +520,25 @@ class TypeChecker {
                             !this.typesMatch(subjectType, patternType)) {
                             this.report('Match arm pattern type must match subject type', arm.pattern.expr);
                         }
+                        this.checkBlock(arm.body);
+                    }
+                    else if (arm.pattern.kind === 'PatEnum') {
+                        const pat = arm.pattern;
+                        const variantPayloads = this.enumPayloads.get(pat.enumName)?.get(pat.variant) ?? [];
+                        // Bind pattern variables to their declared field types in arm scope
+                        const savedScope = new Map(this.scope);
+                        for (let i = 0; i < pat.bindings.length; i++) {
+                            const fieldDef = variantPayloads[i];
+                            const bindingType = fieldDef ? fieldDef.type : { kind: 'named', name: 'int' };
+                            this.scope.set(pat.bindings[i], { type: bindingType, mutable: false });
+                        }
+                        this.checkBlock(arm.body);
+                        this.scope = savedScope;
+                    }
+                    else {
+                        // PatSome / PatNone / PatInt / PatWild are structurally typed — no extra scope needed
+                        this.checkBlock(arm.body);
                     }
-                    // PatSome / PatNone / PatInt / PatWild are structurally typed — no expr to check
-                    this.checkBlock(arm.body);
                 }
                 break;
             case 'as_block': {
@@ -419,6 +583,22 @@ class TypeChecker {
             case 'raw':
                 // Raw commands are not type checked
                 break;
+            case 'break':
+            case 'continue':
+            case 'break_label':
+            case 'continue_label':
+                // Control flow — no sub-expressions to check
+                break;
+            case 'labeled_loop':
+                // Recurse into the labeled loop body
+                this.loopDepth++;
+                this.checkStmt(stmt.body);
+                this.loopDepth--;
+                break;
+            case 'const_decl':
+                // Local const: register in scope as immutable with its declared type
+                this.scope.set(stmt.name, { type: stmt.type, mutable: false });
+                break;
         }
     }
     checkLetDestructStmt(stmt) {
@@ -536,8 +716,8 @@ class TypeChecker {
                 if (arithmeticOps.includes(expr.op)) {
                     const leftType = this.inferType(expr.left);
                     const rightType = this.inferType(expr.right);
-                    const leftIsString = leftType.kind === 'named' && (leftType.name === 'string' || leftType.name === 'format_string');
-                    const rightIsString = rightType.kind === 'named' && (rightType.name === 'string' || rightType.name === 'format_string');
+                    const leftIsString = leftType.kind === 'named' && (leftType.name === 'string' || leftType.name === 'format_string'); // format_string kept for legacy type annotations
+                    const rightIsString = rightType.kind === 'named' && (rightType.name === 'string' || rightType.name === 'format_string'); // format_string kept for legacy type annotations
                     if (leftIsString || rightIsString) {
                         // String concatenation with + is not supported. Use f-strings instead.
                         this.report(`[StringConcat] String concatenation with '+' is not supported. Use f-strings instead: f"text{variable}" — e.g. f"Score: {score}"`, expr);
@@ -590,7 +770,29 @@ class TypeChecker {
                 break;
             case 'struct_lit':
                 for (const field of expr.fields) {
-                    this.checkExpr(field.value);
+                    let fieldType;
+                    if (expectedType) {
+                        const normalized = this.normalizeType(expectedType);
+                        if (normalized.kind === 'struct') {
+                            const structFields = this.structs.get(normalized.name);
+                            if (structFields && !structFields.has(field.name)) {
+                                this.report(`Struct '${normalized.name}' has no field '${field.name}'`, expr);
+                            }
+                            else {
+                                fieldType = structFields?.get(field.name);
+                            }
+                        }
+                    }
+                    this.checkExpr(field.value, fieldType);
+                    if (fieldType) {
+                        const actualType = this.inferType(field.value, fieldType);
+                        if (this.isNumericMismatch(fieldType, actualType)) {
+                            this.report(`Field '${field.name}' of struct expects ${this.typeToString(fieldType)}, got ${this.typeToString(actualType)}`, field.value);
+                        }
+                        else if (!this.typesMatch(fieldType, actualType)) {
+                            this.report(`Field '${field.name}' of struct expects ${this.typeToString(fieldType)}, got ${this.typeToString(actualType)}`, field.value);
+                        }
+                    }
                 }
                 break;
             case 'str_interp':
@@ -642,6 +844,32 @@ class TypeChecker {
                     }
                 }
                 break;
+            case 'enum_construct': {
+                if (!this.enums.has(expr.enumName)) {
+                    this.report(`Unknown enum '${expr.enumName}'`, expr);
+                    break;
+                }
+                const variants = this.enums.get(expr.enumName);
+                if (!variants.has(expr.variant)) {
+                    this.report(`Enum '${expr.enumName}' has no variant '${expr.variant}'`, expr);
+                    break;
+                }
+                const variantPayloads = this.enumPayloads.get(expr.enumName)?.get(expr.variant) ?? [];
+                if (variantPayloads.length === 0 && expr.args.length > 0) {
+                    this.report(`Enum variant '${expr.enumName}::${expr.variant}' has no payload fields`, expr);
+                    break;
+                }
+                for (const arg of expr.args) {
+                    const fieldDef = variantPayloads.find(f => f.name === arg.name);
+                    if (!fieldDef) {
+                        this.report(`Unknown field '${arg.name}' for enum variant '${expr.enumName}::${expr.variant}'`, expr);
+                    }
+                    else {
+                        this.checkExpr(arg.value, fieldDef.type);
+                    }
+                }
+                break;
+            }
             case 'blockpos':
                 break;
             // Literals don't need checking
@@ -741,7 +969,7 @@ class TypeChecker {
         }
         const messageType = this.inferType(message);
         if (messageType.kind !== 'named' ||
-            (messageType.name !== 'string' && messageType.name !== 'format_string')) {
+            messageType.name !== 'string') {
             this.report(`Argument ${messageIndex + 1} of '${expr.fn}' expects string or format_string, got ${this.typeToString(messageType)}`, message);
         }
     }
@@ -948,7 +1176,7 @@ class TypeChecker {
                         this.checkExpr(part.expr);
                     }
                 }
-                return FORMAT_STRING_TYPE;
+                return STRING_TYPE;
             case 'blockpos':
                 return { kind: 'named', name: 'BlockPos' };
             case 'ident':
@@ -1011,6 +1239,11 @@ class TypeChecker {
                     return { kind: 'enum', name: expr.enumName };
                 }
                 return { kind: 'named', name: 'void' };
+            case 'enum_construct':
+                if (this.enums.has(expr.enumName)) {
+                    return { kind: 'enum', name: expr.enumName };
+                }
+                return { kind: 'named', name: 'void' };
             case 'member':
                 if (expr.obj.kind === 'ident' && this.enums.has(expr.obj.name)) {
                     return { kind: 'enum', name: expr.obj.name };
@@ -1134,7 +1367,10 @@ class TypeChecker {
         if (receiverType.kind !== 'struct') {
             return null;
         }
-        const method = this.implMethods.get(receiverType.name)?.get(expr.fn);
+        // Try the method name as-is first, then try the original (pre-remap) name
+        const methodName = TypeChecker.PARSER_METHOD_REMAP[expr.fn] ?? expr.fn;
+        const method = this.implMethods.get(receiverType.name)?.get(expr.fn)
+            ?? this.implMethods.get(receiverType.name)?.get(methodName);
         if (!method || method.params[0]?.name !== 'self') {
             return null;
         }
@@ -1203,6 +1439,11 @@ class TypeChecker {
         if (expected.kind === 'selector' && actual.kind === 'selector') {
             return true; // any entity subtype is compatible
         }
+        // Fake player names (#name) are mc_name tokens typed as string — allow them
+        // where a selector is expected, since MC scoreboards accept fake player names.
+        if (expected.kind === 'selector' && actual.kind === 'named' && actual.name === 'string') {
+            return true;
+        }
         if (expected.kind !== actual.kind)
             return false;
         if (expected.kind === 'named' && actual.kind === 'named') {
@@ -1309,4 +1550,17 @@ class TypeChecker {
     }
 }
 exports.TypeChecker = TypeChecker;
+// Reverse map: parser sometimes remaps method names (e.g. add→set_add) for builtins.
+// When the receiver is a struct with an impl method matching the original name, use that.
+TypeChecker.PARSER_METHOD_REMAP = {
+    'set_add': 'add',
+    'set_contains': 'contains',
+    'set_remove': 'remove',
+    'set_clear': 'clear',
+    '__array_push': 'push',
+    '__array_pop': 'pop',
+    '__entity_tag': 'tag',
+    '__entity_untag': 'untag',
+    '__entity_has_tag': 'has_tag',
+};
 //# sourceMappingURL=index.js.map

package/docs/dev/README-benchmarks.md

@@ -0,0 +1,48 @@
+# Benchmark Suite
+
+RedScript now ships two benchmark entrypoints under `benchmarks/`.
+
+## What They Measure
+
+`benchmarks/compiler-perf.ts`
+
+- Generates synthetic RedScript programs at roughly 10, 100, and 1000 lines.
+- Measures end-to-end compiler stage time for:
+  - `parse`: preprocess, lex, parse, import merge, typecheck
+  - `HIR`: AST to HIR lowering and monomorphization
+  - `MIR`: MIR lowering, optimization, coroutine transform, and LIR lowering/optimization
+  - `emit`: datapack file emission
+- Emits a JSON report to stdout.
+
+`benchmarks/stdlib-complexity.ts`
+
+- Compiles every file in `src/stdlib/`.
+- Reports emitted instruction count, file count, and artifact size.
+- Compares three optimization presets:
+  - `O0`: no MIR/LIR optimization passes
+  - `O1`: current default optimization pipeline
+  - `O2`: `O1` plus a second MIR/LIR optimization round after coroutine lowering
+
+## How To Run
+
+Run the default compiler benchmark:
+
+```bash
+npm run bench
+```
+
+Write the compiler benchmark report to a file:
+
+```bash
+npx ts-node benchmarks/compiler-perf.ts --iterations 5 --output benchmarks/compiler-perf.report.json
+```
+
+Run the stdlib complexity benchmark:
+
+```bash
+npx ts-node benchmarks/stdlib-complexity.ts --output benchmarks/stdlib-complexity.report.json
+```
+
+## Baseline
+
+`benchmarks/baseline.json` stores one recorded run of both benchmarks on the local machine. Treat it as a local baseline, not a cross-machine performance target.