redscript-mc 2.6.2 → 3.0.0

package/dist/src/formatter/index.js

@@ -2,25 +2,50 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.format = format;
 function format(source) {
-    const lines = source.split("\n");
+    const lines = source.replace(/\r\n/g, '\n').split('\n');
+    const normalized = [];
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (line === '{' && normalized.length > 0) {
+            let idx = normalized.length - 1;
+            while (idx >= 0 && normalized[idx] === '')
+                idx--;
+            if (idx >= 0) {
+                normalized[idx] = `${normalized[idx]} {`;
+                continue;
+            }
+        }
+        normalized.push(line);
+    }
     let indent = 0;
     const result = [];
-    for (let line of lines) {
-        line = line.trim();
+    let blankCount = 0;
+    for (const line of normalized) {
         if (!line) {
-            result.push("");
+            if (result.length === 0)
+                continue;
+            if (blankCount >= 2)
+                continue;
+            result.push('');
+            blankCount++;
             continue;
         }
+        blankCount = 0;
         // Decrease indent before }
-        if (line.startsWith("}"))
+        if (line.startsWith('}'))
             indent = Math.max(0, indent - 1);
         // Add indentation
-        result.push("    ".repeat(indent) + line);
+        result.push('  '.repeat(indent) + line);
         // Increase indent after {
-        if (line.endsWith("{"))
+        if (line.endsWith('{'))
             indent++;
     }
+    while (result.length > 0 && result[result.length - 1] === '') {
+        result.pop();
+    }
     // Ensure single newline at end
-    return result.join("\n").trimEnd() + "\n";
+    if (result.length === 0)
+        return '\n';
+    return result.join('\n') + '\n';
 }
 //# sourceMappingURL=index.js.map

package/dist/src/hir/deprecated.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Deprecated function checker — Stage 2.5 of the RedScript compiler pipeline.
+ *
+ * Walks HIR to find calls to @deprecated-annotated functions and collects
+ * compile-time warnings (non-fatal).
+ */
+import type { HIRModule } from './types';
+/**
+ * Walk HIR and emit a warning for every call to a @deprecated function.
+ *
+ * Returns an array of warning strings (same format as parser.warnings).
+ */
+export declare function checkDeprecatedCalls(hir: HIRModule): string[];

package/dist/src/hir/deprecated.js

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * Deprecated function checker — Stage 2.5 of the RedScript compiler pipeline.
+ *
+ * Walks HIR to find calls to @deprecated-annotated functions and collects
+ * compile-time warnings (non-fatal).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDeprecatedCalls = checkDeprecatedCalls;
+/**
+ * Build a map from function name → deprecation message for all @deprecated functions.
+ */
+function buildDeprecatedMap(hir) {
+    const deprecated = new Map();
+    for (const fn of hir.functions) {
+        const dep = getDeprecatedDecorator(fn.decorators);
+        if (dep !== null) {
+            deprecated.set(fn.name, dep);
+        }
+    }
+    // Also check impl block methods
+    for (const ib of hir.implBlocks) {
+        for (const m of ib.methods) {
+            const dep = getDeprecatedDecorator(m.decorators);
+            if (dep !== null) {
+                deprecated.set(`${ib.typeName}::${m.name}`, dep);
+            }
+        }
+    }
+    return deprecated;
+}
+function getDeprecatedDecorator(decorators) {
+    for (const dec of decorators) {
+        if (dec.name === 'deprecated') {
+            return dec.args?.message ?? '';
+        }
+    }
+    return null;
+}
+/**
+ * Walk HIR and emit a warning for every call to a @deprecated function.
+ *
+ * Returns an array of warning strings (same format as parser.warnings).
+ */
+function checkDeprecatedCalls(hir) {
+    const deprecated = buildDeprecatedMap(hir);
+    if (deprecated.size === 0)
+        return [];
+    const warnings = [];
+    for (const fn of hir.functions) {
+        walkBlock(fn.body, fn.name, deprecated, warnings);
+    }
+    for (const ib of hir.implBlocks) {
+        for (const m of ib.methods) {
+            walkBlock(m.body, `${ib.typeName}::${m.name}`, deprecated, warnings);
+        }
+    }
+    return warnings;
+}
+function walkBlock(block, caller, deprecated, warnings) {
+    for (const stmt of block) {
+        walkStmt(stmt, caller, deprecated, warnings);
+    }
+}
+function walkStmt(stmt, caller, deprecated, warnings) {
+    switch (stmt.kind) {
+        case 'let':
+        case 'let_destruct':
+            walkExpr(stmt.init, caller, deprecated, warnings);
+            break;
+        case 'expr':
+            walkExpr(stmt.expr, caller, deprecated, warnings);
+            break;
+        case 'return':
+            if (stmt.value)
+                walkExpr(stmt.value, caller, deprecated, warnings);
+            break;
+        case 'if':
+            walkExpr(stmt.cond, caller, deprecated, warnings);
+            walkBlock(stmt.then, caller, deprecated, warnings);
+            if (stmt.else_)
+                walkBlock(stmt.else_, caller, deprecated, warnings);
+            break;
+        case 'while':
+            walkExpr(stmt.cond, caller, deprecated, warnings);
+            walkBlock(stmt.body, caller, deprecated, warnings);
+            if (stmt.step)
+                walkBlock(stmt.step, caller, deprecated, warnings);
+            break;
+        case 'foreach':
+            walkExpr(stmt.iterable, caller, deprecated, warnings);
+            walkBlock(stmt.body, caller, deprecated, warnings);
+            break;
+        case 'match':
+            walkExpr(stmt.expr, caller, deprecated, warnings);
+            for (const arm of stmt.arms) {
+                walkBlock(arm.body, caller, deprecated, warnings);
+            }
+            break;
+        // break/continue/raw/execute: no sub-exprs to walk for deprecation purposes
+        default:
+            break;
+    }
+}
+function walkExpr(expr, caller, deprecated, warnings) {
+    switch (expr.kind) {
+        case 'call': {
+            // Check if this function is deprecated
+            if (deprecated.has(expr.fn)) {
+                const msg = deprecated.get(expr.fn);
+                const location = expr.span ? `line ${expr.span.line}, col ${expr.span.col}: ` : '';
+                const detail = msg ? `: ${msg}` : '';
+                warnings.push(`[DeprecatedUsage] ${location}'${expr.fn}' is deprecated${detail} (called from '${caller}')`);
+            }
+            for (const arg of expr.args)
+                walkExpr(arg, caller, deprecated, warnings);
+            break;
+        }
+        case 'static_call': {
+            const qualName = `${expr.type}::${expr.method}`;
+            if (deprecated.has(qualName)) {
+                const msg = deprecated.get(qualName);
+                const location = expr.span ? `line ${expr.span.line}, col ${expr.span.col}: ` : '';
+                const detail = msg ? `: ${msg}` : '';
+                warnings.push(`[DeprecatedUsage] ${location}'${qualName}' is deprecated${detail} (called from '${caller}')`);
+            }
+            for (const arg of expr.args)
+                walkExpr(arg, caller, deprecated, warnings);
+            break;
+        }
+        case 'invoke':
+            walkExpr(expr.callee, caller, deprecated, warnings);
+            for (const arg of expr.args)
+                walkExpr(arg, caller, deprecated, warnings);
+            break;
+        case 'binary':
+            walkExpr(expr.left, caller, deprecated, warnings);
+            walkExpr(expr.right, caller, deprecated, warnings);
+            break;
+        case 'unary':
+            walkExpr(expr.operand, caller, deprecated, warnings);
+            break;
+        case 'is_check':
+            walkExpr(expr.expr, caller, deprecated, warnings);
+            break;
+        case 'type_cast':
+            walkExpr(expr.expr, caller, deprecated, warnings);
+            break;
+        case 'assign':
+            walkExpr(expr.value, caller, deprecated, warnings);
+            break;
+        case 'member_assign':
+            walkExpr(expr.obj, caller, deprecated, warnings);
+            walkExpr(expr.value, caller, deprecated, warnings);
+            break;
+        case 'index_assign':
+            walkExpr(expr.obj, caller, deprecated, warnings);
+            walkExpr(expr.index, caller, deprecated, warnings);
+            walkExpr(expr.value, caller, deprecated, warnings);
+            break;
+        case 'member':
+            walkExpr(expr.obj, caller, deprecated, warnings);
+            break;
+        case 'index':
+            walkExpr(expr.obj, caller, deprecated, warnings);
+            walkExpr(expr.index, caller, deprecated, warnings);
+            break;
+        case 'array_lit':
+            for (const el of expr.elements)
+                walkExpr(el, caller, deprecated, warnings);
+            break;
+        case 'struct_lit':
+            for (const f of expr.fields)
+                walkExpr(f.value, caller, deprecated, warnings);
+            break;
+        case 'str_interp':
+            for (const part of expr.parts) {
+                if (typeof part !== 'string')
+                    walkExpr(part, caller, deprecated, warnings);
+            }
+            break;
+        case 'f_string':
+            for (const part of expr.parts) {
+                if (part.kind === 'expr')
+                    walkExpr(part.expr, caller, deprecated, warnings);
+            }
+            break;
+        case 'some_lit':
+            walkExpr(expr.value, caller, deprecated, warnings);
+            break;
+        case 'unwrap_or':
+            walkExpr(expr.opt, caller, deprecated, warnings);
+            walkExpr(expr.default_, caller, deprecated, warnings);
+            break;
+        case 'lambda': {
+            const body = expr.body;
+            if (Array.isArray(body)) {
+                walkBlock(body, caller, deprecated, warnings);
+            }
+            else {
+                walkExpr(body, caller, deprecated, warnings);
+            }
+            break;
+        }
+        case 'tuple_lit':
+            for (const el of expr.elements)
+                walkExpr(el, caller, deprecated, warnings);
+            break;
+        case 'enum_construct':
+            for (const arg of expr.args)
+                walkExpr(arg.value, caller, deprecated, warnings);
+            break;
+        // Terminals: int_lit, float_lit, bool_lit, str_lit, ident, selector, etc.
+        default:
+            break;
+    }
+}
+//# sourceMappingURL=deprecated.js.map

package/dist/src/hir/lower.js

@@ -13,27 +13,32 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lowerToHIR = lowerToHIR;
+const expand_1 = require("../structs/expand");
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
 function lowerToHIR(program) {
+    const structs = (0, expand_1.expandStructDeclarations)(program.structs).map((s) => ({
+        name: s.name,
+        extends: s.extends,
+        fields: s.fields.map(f => ({ name: f.name, type: f.type })),
+        isSingleton: s.isSingleton,
+        span: s.span,
+    }));
     return {
         namespace: program.namespace,
         globals: program.globals.map(lowerGlobal),
         functions: program.declarations.map(lowerFunction),
-        structs: program.structs.map((s) => ({
-            name: s.name,
-            fields: s.fields.map(f => ({ name: f.name, type: f.type })),
-            span: s.span,
-        })),
+        structs,
         implBlocks: program.implBlocks.map((ib) => ({
             typeName: ib.typeName,
+            traitName: ib.traitName,
             methods: ib.methods.map(lowerFunction),
             span: ib.span,
         })),
         enums: program.enums.map((e) => ({
             name: e.name,
-            variants: e.variants.map(v => ({ name: v.name, value: v.value })),
+            variants: e.variants.map(v => ({ name: v.name, value: v.value, fields: v.fields })),
             span: e.span,
         })),
         consts: program.consts.map((c) => ({
@@ -55,6 +60,7 @@ function lowerMatchPattern(pat) {
         case 'PatInt': return pat;
         case 'PatWild': return pat;
         case 'PatExpr': return { kind: 'PatExpr', expr: lowerExpr(pat.expr) };
+        case 'PatEnum': return { kind: 'PatEnum', enumName: pat.enumName, variant: pat.variant, bindings: pat.bindings };
     }
 }
 // ---------------------------------------------------------------------------
@@ -80,6 +86,8 @@ function lowerFunction(fn) {
         isLibraryFn: fn.isLibraryFn,
         isExported: fn.isExported,
         span: fn.span,
+        sourceFile: fn.sourceFile,
+        watchObjective: fn.watchObjective,
     };
 }
 function lowerParam(p) {
@@ -112,6 +120,8 @@ function lowerStmt(stmt) {
             return { kind: 'let', name: stmt.name, type: stmt.type, init: lowerExpr(stmt.init), span: stmt.span };
         case 'let_destruct':
             return { kind: 'let_destruct', names: stmt.names, type: stmt.type, init: lowerExpr(stmt.init), span: stmt.span };
+        case 'const_decl':
+            return { kind: 'const_decl', name: stmt.name, type: stmt.type, value: lowerExpr(stmt.value), span: stmt.span };
         case 'expr':
             return { kind: 'expr', expr: lowerExpr(stmt.expr), span: stmt.span };
         case 'return':
@@ -120,6 +130,24 @@ function lowerStmt(stmt) {
             return { kind: 'break', span: stmt.span };
         case 'continue':
             return { kind: 'continue', span: stmt.span };
+        case 'break_label':
+            return { kind: 'break_label', label: stmt.label, span: stmt.span };
+        case 'continue_label':
+            return { kind: 'continue_label', label: stmt.label, span: stmt.span };
+        case 'labeled_loop': {
+            // Lower the body — for desugared loops (for_each, for_range, etc.) this may return
+            // an array of [init..., while_stmt]. The label should attach to the while stmt only;
+            // any init stmts come before as plain statements.
+            const lowered = lowerStmt(stmt.body);
+            if (Array.isArray(lowered)) {
+                // Multiple stmts: init stmts + while (last element)
+                const inits = lowered.slice(0, -1);
+                const loopStmt = lowered[lowered.length - 1];
+                const labeled = { kind: 'labeled_loop', label: stmt.label, body: loopStmt, span: stmt.span };
+                return [...inits, labeled];
+            }
+            return { kind: 'labeled_loop', label: stmt.label, body: lowered, span: stmt.span };
+        }
         case 'if':
             return {
                 kind: 'if',
@@ -371,6 +399,68 @@ function lowerStmt(stmt) {
                 else_: stmt.else_ ? lowerBlock(stmt.else_) : undefined,
                 span: stmt.span,
             };
+        // --- Desugaring: do_while → body + while(cond) { body } ---
+        // Emits the body once unconditionally, then a while loop:
+        //   <body>
+        //   while (cond) { <body> }
+        case 'do_while': {
+            const firstBody = lowerBlock(stmt.body);
+            const loopBody = lowerBlock(stmt.body);
+            const whileStmt = {
+                kind: 'while',
+                cond: lowerExpr(stmt.cond),
+                body: loopBody,
+                span: stmt.span,
+            };
+            return [...firstBody, whileStmt];
+        }
+        // --- Desugaring: repeat N → let __repeat_i = 0; while(__repeat_i < N) { body; __repeat_i = __repeat_i + 1 } ---
+        case 'repeat': {
+            const id = repeatCounter++;
+            const idxName = `__repeat_i_${id}`;
+            const initStmt = {
+                kind: 'let',
+                name: idxName,
+                type: { kind: 'named', name: 'int' },
+                init: { kind: 'int_lit', value: 0 },
+                span: stmt.span,
+            };
+            const body = lowerBlock(stmt.body);
+            const step = [{
+                    kind: 'expr',
+                    expr: {
+                        kind: 'assign',
+                        target: idxName,
+                        value: {
+                            kind: 'binary',
+                            op: '+',
+                            left: { kind: 'ident', name: idxName },
+                            right: { kind: 'int_lit', value: 1 },
+                        },
+                    },
+                }];
+            const whileStmt = {
+                kind: 'while',
+                cond: {
+                    kind: 'binary',
+                    op: '<',
+                    left: { kind: 'ident', name: idxName },
+                    right: { kind: 'int_lit', value: stmt.count },
+                },
+                body,
+                step,
+                span: stmt.span,
+            };
+            return [initStmt, whileStmt];
+        }
+        case 'while_let_some':
+            return {
+                kind: 'while_let_some',
+                binding: stmt.binding,
+                init: lowerExpr(stmt.init),
+                body: lowerBlock(stmt.body),
+                span: stmt.span,
+            };
         default: {
             const _exhaustive = stmt;
             throw new Error(`Unknown statement kind: ${_exhaustive.kind}`);
@@ -389,6 +479,8 @@ function lowerExecuteSubcommand(sub) {
 // ---------------------------------------------------------------------------
 /** Counter to generate unique variable names for for_each desugaring */
 let forEachCounter = 0;
+/** Counter to generate unique variable names for repeat desugaring */
+let repeatCounter = 0;
 /** Map compound assignment operator to its base binary op */
 const COMPOUND_TO_BINOP = {
     '+=': '+',
@@ -432,8 +524,12 @@ function lowerExpr(expr) {
                 parts: expr.parts.map(p => typeof p === 'string' ? p : lowerExpr(p)),
                 span: expr.span,
             };
-        case 'f_string':
-            return { kind: 'f_string', parts: expr.parts, span: expr.span };
+        case 'f_string': {
+            const hirParts = expr.parts.map(part => part.kind === 'text'
+                ? { kind: 'text', value: part.value }
+                : { kind: 'expr', expr: lowerExpr(part.expr) });
+            return { kind: 'f_string', parts: hirParts, span: expr.span };
+        }
         // Binary ops — && and || preserved as-is (short-circuit → control flow in MIR)
         case 'binary':
             return {
@@ -538,12 +634,22 @@ function lowerExpr(expr) {
             };
         case 'path_expr':
             return { kind: 'path_expr', enumName: expr.enumName, variant: expr.variant, span: expr.span };
+        case 'enum_construct':
+            return {
+                kind: 'enum_construct',
+                enumName: expr.enumName,
+                variant: expr.variant,
+                args: expr.args.map(a => ({ name: a.name, value: lowerExpr(a.value) })),
+                span: expr.span,
+            };
         case 'tuple_lit':
             return { kind: 'tuple_lit', elements: expr.elements.map(lowerExpr), span: expr.span };
         case 'some_lit':
             return { kind: 'some_lit', value: lowerExpr(expr.value), span: expr.span };
         case 'none_lit':
             return { kind: 'none_lit', span: expr.span };
+        case 'unwrap_or':
+            return { kind: 'unwrap_or', opt: lowerExpr(expr.opt), default_: lowerExpr(expr.default_), span: expr.span };
         case 'type_cast':
             return { kind: 'type_cast', expr: lowerExpr(expr.expr), targetType: expr.targetType, span: expr.span };
         case 'lambda': {

package/dist/src/hir/monomorphize.js

@@ -245,10 +245,25 @@ class Monomorphizer {
                     then: this.rewriteBlock(stmt.then, ctx),
                     else_: stmt.else_ ? this.rewriteBlock(stmt.else_, ctx) : undefined,
                 };
+            case 'while_let_some':
+                return {
+                    ...stmt,
+                    init: this.rewriteExpr(stmt.init, ctx),
+                    body: this.rewriteBlock(stmt.body, ctx),
+                };
+            case 'const_decl':
+                return { ...stmt, value: this.rewriteExpr(stmt.value, ctx) };
             case 'break':
             case 'continue':
             case 'raw':
                 return stmt;
+            case 'break_label':
+            case 'continue_label':
+                return stmt;
+            case 'labeled_loop': {
+                const body = this.rewriteStmt(stmt.body, ctx);
+                return { ...stmt, body };
+            }
         }
     }
     rewriteExpr(expr, ctx) {
@@ -305,12 +320,17 @@ class Monomorphizer {
             case 'str_interp':
                 return { ...expr, parts: expr.parts.map(p => typeof p === 'string' ? p : this.rewriteExpr(p, ctx)) };
             case 'f_string':
-                // FStringPart uses AST Expr (not HIRExpr) — pass through without rewriting
-                return expr;
+                // HIRFStringPart uses HIRExpr — rewrite expr parts
+                return {
+                    ...expr,
+                    parts: expr.parts.map(p => p.kind === 'text' ? p : { kind: 'expr', expr: this.rewriteExpr(p.expr, ctx) }),
+                };
             case 'some_lit':
                 return { ...expr, value: this.rewriteExpr(expr.value, ctx) };
             case 'none_lit':
                 return expr;
+            case 'unwrap_or':
+                return { ...expr, opt: this.rewriteExpr(expr.opt, ctx), default_: this.rewriteExpr(expr.default_, ctx) };
             // Literals / terminals — pass through unchanged
             default:
                 return expr;

package/dist/src/hir/types.d.ts

@@ -91,7 +91,7 @@ export type HIRExpr = {
     span?: Span;
 } | {
     kind: 'f_string';
-    parts: FStringPart[];
+    parts: HIRFStringPart[];
     span?: Span;
 } | {
     kind: 'ident';
@@ -163,6 +163,15 @@ export type HIRExpr = {
     enumName: string;
     variant: string;
     span?: Span;
+} | {
+    kind: 'enum_construct';
+    enumName: string;
+    variant: string;
+    args: {
+        name: string;
+        value: HIRExpr;
+    }[];
+    span?: Span;
 } | {
     kind: 'lambda';
     params: LambdaParam[];
@@ -180,12 +189,25 @@ export type HIRExpr = {
 } | {
     kind: 'none_lit';
     span?: Span;
+} | {
+    kind: 'unwrap_or';
+    opt: HIRExpr;
+    default_: HIRExpr;
+    span?: Span;
 } | {
     kind: 'type_cast';
     expr: HIRExpr;
     targetType: TypeNode;
     span?: Span;
 };
+/** HIR-level f-string part — uses HIRExpr instead of AST Expr */
+export type HIRFStringPart = {
+    kind: 'text';
+    value: string;
+} | {
+    kind: 'expr';
+    expr: HIRExpr;
+};
 export type HIRExecuteSubcommand = {
     kind: 'as';
     selector: EntitySelector;
@@ -295,6 +317,11 @@ export type HIRMatchPattern = {
 } | {
     kind: 'PatExpr';
     expr: HIRExpr;
+} | {
+    kind: 'PatEnum';
+    enumName: string;
+    variant: string;
+    bindings: string[];
 };
 export type HIRStmt = {
     kind: 'let';
@@ -308,6 +335,12 @@ export type HIRStmt = {
     type?: TypeNode;
     init: HIRExpr;
     span?: Span;
+} | {
+    kind: 'const_decl';
+    name: string;
+    type: TypeNode;
+    value: HIRExpr;
+    span?: Span;
 } | {
     kind: 'expr';
     expr: HIRExpr;
@@ -322,6 +355,19 @@ export type HIRStmt = {
 } | {
     kind: 'continue';
     span?: Span;
+} | {
+    kind: 'break_label';
+    label: string;
+    span?: Span;
+} | {
+    kind: 'continue_label';
+    label: string;
+    span?: Span;
+} | {
+    kind: 'labeled_loop';
+    label: string;
+    body: HIRStmt;
+    span?: Span;
 } | {
     kind: 'if';
     cond: HIRExpr;
@@ -365,6 +411,12 @@ export type HIRStmt = {
     then: HIRBlock;
     else_?: HIRBlock;
     span?: Span;
+} | {
+    kind: 'while_let_some';
+    binding: string;
+    init: HIRExpr;
+    body: HIRBlock;
+    span?: Span;
 };
 export type HIRBlock = HIRStmt[];
 export interface HIRParam {
@@ -383,6 +435,9 @@ export interface HIRFunction {
     isLibraryFn?: boolean;
     isExported?: boolean;
     span?: Span;
+    sourceFile?: string;
+    /** Set when the function is decorated with @watch("objective") — the scoreboard objective to watch. */
+    watchObjective?: string;
 }
 export interface HIRStructField {
     name: string;
@@ -390,17 +445,26 @@ export interface HIRStructField {
 }
 export interface HIRStruct {
     name: string;
+    extends?: string;
     fields: HIRStructField[];
+    /** True when the struct was declared with `@singleton` */
+    isSingleton?: boolean;
     span?: Span;
 }
 export interface HIRImplBlock {
     typeName: string;
+    /** Trait name when declared as `impl TraitName for TypeName` (e.g. "Display") */
+    traitName?: string;
     methods: HIRFunction[];
     span?: Span;
 }
 export interface HIREnumVariant {
     name: string;
     value?: number;
+    fields?: {
+        name: string;
+        type: TypeNode;
+    }[];
 }
 export interface HIREnum {
     name: string;