redscript-mc 1.2.30 → 2.1.0

package/dist/index.d.ts

@@ -1,62 +0,0 @@
-/**
- * RedScript Compiler
- *
- * Main entry point for programmatic usage.
- */
-export declare const version = "1.2.11";
-import type { Warning } from './lowering';
-import { DatapackFile } from './codegen/mcfunction';
-import type { IRModule } from './ir/types';
-import type { Program } from './ast/types';
-import type { DiagnosticError } from './diagnostics';
-import { type OptimizationStats } from './optimizer/commands';
-export interface CompileOptions {
-    namespace?: string;
-    optimize?: boolean;
-    typeCheck?: boolean;
-    filePath?: string;
-    dce?: boolean;
-    mangle?: boolean;
-    /** Scoreboard objective used for all variable slots.
-     *  Defaults to '__<namespace>' (e.g. '__mathshow') to avoid collisions when
-     *  multiple RedScript datapacks are loaded simultaneously, without occupying
-     *  the user's own namespace. Override only if you need a specific name. */
-    scoreboardObjective?: string;
-}
-export interface CompileResult {
-    files: DatapackFile[];
-    advancements: DatapackFile[];
-    ast: Program;
-    ir: IRModule;
-    typeErrors?: DiagnosticError[];
-    warnings?: Warning[];
-    stats?: OptimizationStats;
-    sourceMap?: Record<string, string>;
-}
-/**
- * Compile RedScript source code to a Minecraft datapack.
- *
- * @param source - The RedScript source code
- * @param options - Compilation options
- * @returns Compiled datapack files
- */
-export declare function compile(source: string, options?: CompileOptions): CompileResult;
-/**
- * Check RedScript source code for errors without generating output.
- *
- * @param source - The RedScript source code
- * @param namespace - Optional namespace
- * @returns null if no errors, or an error object
- */
-export declare function check(source: string, namespace?: string, filePath?: string): Error | null;
-export { Lexer } from './lexer';
-export { Parser } from './parser';
-export { TypeChecker } from './typechecker';
-export { Lowering } from './lowering';
-export { optimize } from './optimizer/passes';
-export { generateDatapack } from './codegen/mcfunction';
-export { MCCommandValidator } from './mc-validator';
-export type { DatapackFile } from './codegen/mcfunction';
-export type { IRModule, IRFunction } from './ir/types';
-export type { Program, FnDecl, Expr, Stmt, Span } from './ast/types';
-export type { DiagnosticError } from './diagnostics';

package/dist/ir/builder.d.ts

@@ -1,33 +0,0 @@
-/**
- * IRBuilder — helper for constructing IR programmatically.
- * AST → IR lowering uses this.
- */
-import type { IRFunction, IRInstr, IRModule, Operand } from './types';
-export declare class IRBuilder {
-    private tempCount;
-    private labelCount;
-    private currentBlock;
-    private blocks;
-    private locals;
-    freshTemp(): string;
-    freshLabel(hint?: string): string;
-    startBlock(label: string): void;
-    private get block();
-    private sealBlock;
-    emitAssign(dst: string, src: Operand): void;
-    emitBinop(dst: string, lhs: Operand, bop: IRInstr & {
-        op: 'binop';
-    } extends {
-        bop: infer B;
-    } ? B : never, rhs: Operand): void;
-    emitCmp(dst: string, lhs: Operand, cop: '==' | '!=' | '<' | '<=' | '>' | '>=', rhs: Operand): void;
-    emitCall(fn: string, args: Operand[], dst?: string): void;
-    emitRaw(cmd: string): void;
-    emitJump(target: string): void;
-    emitJumpIf(cond: string, then: string, else_: string): void;
-    emitReturn(value?: Operand): void;
-    emitTickYield(continuation: string): void;
-    build(name: string, params: string[], isTickLoop?: boolean): IRFunction;
-}
-import type { GlobalVar } from './types';
-export declare function buildModule(namespace: string, fns: IRFunction[], globals?: GlobalVar[]): IRModule;

package/dist/ir/builder.js

@@ -1,99 +0,0 @@
-"use strict";
-/**
- * IRBuilder — helper for constructing IR programmatically.
- * AST → IR lowering uses this.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IRBuilder = void 0;
-exports.buildModule = buildModule;
-class IRBuilder {
-    constructor() {
-        this.tempCount = 0;
-        this.labelCount = 0;
-        this.currentBlock = null;
-        this.blocks = [];
-        this.locals = new Set();
-    }
-    // -------------------------------------------------------------------------
-    // Names
-    // -------------------------------------------------------------------------
-    freshTemp() {
-        const name = `$t${this.tempCount++}`;
-        this.locals.add(name);
-        return name;
-    }
-    freshLabel(hint = 'L') {
-        return `${hint}_${this.labelCount++}`;
-    }
-    // -------------------------------------------------------------------------
-    // Block management
-    // -------------------------------------------------------------------------
-    startBlock(label) {
-        this.currentBlock = { label, instrs: [], term: { op: 'return' } };
-    }
-    get block() {
-        if (!this.currentBlock)
-            throw new Error('No active block');
-        return this.currentBlock;
-    }
-    sealBlock(term) {
-        this.block.term = term;
-        this.blocks.push(this.block);
-        this.currentBlock = null;
-    }
-    // -------------------------------------------------------------------------
-    // Emit instructions
-    // -------------------------------------------------------------------------
-    emitAssign(dst, src) {
-        this.locals.add(dst);
-        this.block.instrs.push({ op: 'assign', dst, src });
-    }
-    emitBinop(dst, lhs, bop, rhs) {
-        this.locals.add(dst);
-        this.block.instrs.push({ op: 'binop', dst, lhs, bop, rhs });
-    }
-    emitCmp(dst, lhs, cop, rhs) {
-        this.locals.add(dst);
-        this.block.instrs.push({ op: 'cmp', dst, lhs, cop, rhs });
-    }
-    emitCall(fn, args, dst) {
-        if (dst)
-            this.locals.add(dst);
-        this.block.instrs.push({ op: 'call', fn, args, dst });
-    }
-    emitRaw(cmd) {
-        this.block.instrs.push({ op: 'raw', cmd });
-    }
-    // -------------------------------------------------------------------------
-    // Terminators
-    // -------------------------------------------------------------------------
-    emitJump(target) {
-        this.sealBlock({ op: 'jump', target });
-    }
-    emitJumpIf(cond, then, else_) {
-        this.sealBlock({ op: 'jump_if', cond, then, else_ });
-    }
-    emitReturn(value) {
-        this.sealBlock({ op: 'return', value });
-    }
-    emitTickYield(continuation) {
-        this.sealBlock({ op: 'tick_yield', continuation });
-    }
-    // -------------------------------------------------------------------------
-    // Build
-    // -------------------------------------------------------------------------
-    build(name, params, isTickLoop = false) {
-        return {
-            name,
-            params,
-            locals: Array.from(this.locals),
-            blocks: this.blocks,
-            isTickLoop,
-        };
-    }
-}
-exports.IRBuilder = IRBuilder;
-function buildModule(namespace, fns, globals = []) {
-    return { namespace, functions: fns, globals };
-}
-//# sourceMappingURL=builder.js.map

package/dist/ir/types.d.ts

@@ -1,132 +0,0 @@
-/**
- * RedScript IR — Three-Address Code (TAC)
- *
- * Compilation pipeline:
- *   Source → AST → IR → (optimize) → CodeGen → mcfunction / cmdblock
- *
- * Variable storage in MC Java Edition:
- *   - Integer vars  → scoreboard fake player  ($name on objective "rs_vars")
- *   - Complex data  → NBT storage             (redscript:stack / redscript:heap)
- *   - Return value  → fake player $ret
- *   - Temporaries   → $_0, $_1, ...
- */
-export type Operand = {
-    kind: 'var';
-    name: string;
-} | {
-    kind: 'const';
-    value: number;
-} | {
-    kind: 'storage';
-    path: string;
-} | {
-    kind: 'param';
-    index: number;
-};
-export type BinOp = '+' | '-' | '*' | '/' | '%';
-export type CmpOp = '==' | '!=' | '<' | '<=' | '>' | '>=';
-export type IRInstr = {
-    op: 'assign';
-    dst: string;
-    src: Operand;
-} | {
-    op: 'binop';
-    dst: string;
-    lhs: Operand;
-    bop: BinOp;
-    rhs: Operand;
-} | {
-    op: 'cmp';
-    dst: string;
-    lhs: Operand;
-    cop: CmpOp;
-    rhs: Operand;
-} | {
-    op: 'jump';
-    target: string;
-} | {
-    op: 'jump_if';
-    cond: string;
-    target: string;
-} | {
-    op: 'jump_unless';
-    cond: string;
-    target: string;
-} | {
-    op: 'call';
-    fn: string;
-    args: Operand[];
-    dst?: string;
-} | {
-    op: 'return';
-    value?: Operand;
-} | {
-    op: 'label';
-    id: string;
-} | {
-    op: 'raw';
-    cmd: string;
-} | {
-    op: 'tick_yield';
-};
-export type Terminator = {
-    op: 'jump';
-    target: string;
-} | {
-    op: 'jump_if';
-    cond: string;
-    then: string;
-    else_: string;
-} | {
-    op: 'jump_unless';
-    cond: string;
-    then: string;
-    else_: string;
-} | {
-    op: 'return';
-    value?: Operand;
-} | {
-    op: 'tick_yield';
-    continuation: string;
-};
-export interface IRBlock {
-    label: string;
-    instrs: IRInstr[];
-    term: Terminator;
-}
-export interface IRCommand {
-    cmd: string;
-    conditional?: boolean;
-    label?: string;
-}
-export interface IRFunction {
-    name: string;
-    params: string[];
-    locals: string[];
-    blocks: IRBlock[];
-    commands?: IRCommand[];
-    isTickLoop?: boolean;
-    isLoadInit?: boolean;
-    requiredLoads?: string[];
-    isTriggerHandler?: boolean;
-    triggerName?: string;
-    eventTrigger?: {
-        kind: 'advancement' | 'craft' | 'death' | 'login' | 'join_team';
-        value?: string;
-    };
-    eventHandler?: {
-        eventType: string;
-        tag: string;
-    };
-    isMacroFunction?: boolean;
-    macroParamNames?: string[];
-}
-export interface GlobalVar {
-    name: string;
-    init: number;
-}
-export interface IRModule {
-    namespace: string;
-    functions: IRFunction[];
-    globals: GlobalVar[];
-}

package/dist/ir/types.js

@@ -1,15 +0,0 @@
-"use strict";
-/**
- * RedScript IR — Three-Address Code (TAC)
- *
- * Compilation pipeline:
- *   Source → AST → IR → (optimize) → CodeGen → mcfunction / cmdblock
- *
- * Variable storage in MC Java Edition:
- *   - Integer vars  → scoreboard fake player  ($name on objective "rs_vars")
- *   - Complex data  → NBT storage             (redscript:stack / redscript:heap)
- *   - Return value  → fake player $ret
- *   - Temporaries   → $_0, $_1, ...
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map

package/dist/isqrttest.map.json

@@ -1,15 +0,0 @@
-{
-  "$e": "n",
-  "$g": "p0",
-  "$j": "i",
-  "$k": "x",
-  "$p": "next",
-  "$s": "f",
-  "$u": "result",
-  "$a": "const:0",
-  "$b": "const:1",
-  "$c": "const:2",
-  "$d": "const:16",
-  "$f": "internal:p0",
-  "$i": "internal:ret"
-}

package/dist/lowering/index.d.ts

@@ -1,188 +0,0 @@
-/**
- * RedScript Lowering
- *
- * Transforms AST into IR (Three-Address Code).
- * Handles control flow, function extraction for foreach, and builtin calls.
- */
-import type { IRModule } from '../ir/types';
-import type { SourceRange } from '../compile';
-import type { Program } from '../ast/types';
-/** Current scoreboard objective. Set once per compile() call. */
-export declare let LOWERING_OBJ: string;
-export declare function setScoreboardObjective(obj: string): void;
-export interface Warning {
-    message: string;
-    code: string;
-    line?: number;
-    col?: number;
-}
-export declare class Lowering {
-    private namespace;
-    private readonly sourceRanges;
-    private functions;
-    private globals;
-    private globalNames;
-    private fnDecls;
-    private implMethods;
-    private specializedFunctions;
-    private currentFn;
-    /** Unique IR variable name for a local variable, scoped to the current function.
-     *  Prevents cross-function scoreboard slot collisions: $fn_x ≠ $gn_x.
-     *  Only applies to user-defined locals/params; internal slots ($p0, $ret) are
-     *  intentionally global (calling convention). */
-    private fnVar;
-    private currentStdlibCallSite?;
-    private foreachCounter;
-    private lambdaCounter;
-    private timeoutCounter;
-    private intervalCounter;
-    readonly warnings: Warning[];
-    private entityContextStack;
-    private currentEntityContext;
-    private builder;
-    private varMap;
-    private lambdaBindings;
-    private intervalBindings;
-    private intervalFunctions;
-    private currentCallbackBindings;
-    private currentContext;
-    private blockPosVars;
-    private structDefs;
-    private structDecls;
-    private enumDefs;
-    private functionDefaults;
-    private constValues;
-    private stringValues;
-    private varTypes;
-    private floatVars;
-    private worldObjCounter;
-    private loopStack;
-    private currentFnParamNames;
-    private currentFnMacroParams;
-    private macroFunctionInfo;
-    constructor(namespace: string, sourceRanges?: SourceRange[]);
-    private preScanMacroFunctions;
-    private preScanStmts;
-    private preScanStmt;
-    private preScanExpr;
-    /**
-     * If `expr` is a function parameter that needs macro treatment (runtime value
-     * used in a literal position), returns the param name; otherwise null.
-     */
-    private tryGetMacroParam;
-    private tryGetMacroParamByName;
-    /**
-     * Converts an expression to a string for use as a builtin arg.
-     * If the expression is a macro param, returns `$(name)` and sets macroParam.
-     */
-    private exprToBuiltinArg;
-    /**
-     * Emits a call to a macro function, setting up both scoreboard params
-     * (for arithmetic use) and NBT macro args (for coordinate/literal use).
-     */
-    private emitMacroFunctionCall;
-    lower(program: Program): IRModule;
-    private lowerFn;
-    private getTickRate;
-    private wrapWithTickRate;
-    private lowerBlock;
-    private lowerStmt;
-    private lowerLetStmt;
-    private lowerReturnStmt;
-    private lowerBreakStmt;
-    private lowerContinueStmt;
-    private lowerIfStmt;
-    private lowerIsCheckIfStmt;
-    private lowerWhileStmt;
-    private lowerForStmt;
-    private lowerForRangeStmt;
-    private lowerForeachStmt;
-    private lowerMatchStmt;
-    private emitMatchArmSubFunction;
-    private lowerArrayForeachStmt;
-    private lowerAsBlockStmt;
-    private lowerAtBlockStmt;
-    private lowerAsAtStmt;
-    private lowerExecuteStmt;
-    private lowerExpr;
-    private lowerMemberExpr;
-    private lowerMemberAssign;
-    private lowerIndexExpr;
-    private lowerBinaryExpr;
-    private isFloatExpr;
-    private lowerUnaryExpr;
-    private lowerAssignExpr;
-    private lowerCallExpr;
-    private lowerStaticCallExpr;
-    private lowerInvokeExpr;
-    private inlineLambdaInvoke;
-    private emitDirectFunctionCall;
-    private emitMethodCall;
-    private resolveFunctionRefExpr;
-    private resolveFunctionRefByName;
-    private ensureSpecializedFunction;
-    private ensureSpecializedFunctionWithContext;
-    private lowerLambdaExpr;
-    private withSavedFunctionState;
-    private lowerBuiltinCall;
-    private lowerSetTimeout;
-    private lowerSetInterval;
-    private lowerClearInterval;
-    private lowerNamedLambdaFunction;
-    private lowerIntervalWrapperFunction;
-    private resolveIntervalFunctionName;
-    private lowerRichTextBuiltin;
-    private getRichTextArgIndex;
-    private buildRichTextJson;
-    private appendRichTextExpr;
-    private exprToString;
-    private exprToEntitySelector;
-    private appendTypeFilter;
-    private exprToSnbt;
-    private exprToTargetString;
-    private exprToLiteral;
-    private exprToQuotedString;
-    private exprToTextComponent;
-    private exprToBoolString;
-    private isTeamTextOption;
-    private exprToScoreboardObjective;
-    private resolveScoreboardObjective;
-    private getObjectiveNamespace;
-    private tryGetStdlibInternalObjective;
-    private getStdlibInternalResourceBase;
-    private getStdlibCallSiteContext;
-    private serializeCallSite;
-    private shortHash;
-    private isStdlibFile;
-    private filePathForSpan;
-    private lowerCoordinateBuiltin;
-    private lowerTpCommand;
-    private lowerTpCommandMacroAware;
-    private resolveBlockPosExpr;
-    private getArrayStorageName;
-    private inferLambdaReturnType;
-    private inferExprType;
-    /**
-     * Checks a raw() command string for `${...}` interpolation containing runtime variables.
-     * - If the interpolated expression is a numeric literal → OK (MC macro syntax).
-     * - If the interpolated name is a compile-time constant (in constValues) → OK.
-     * - If the interpolated name is a known runtime variable (in varMap) → DiagnosticError.
-     * - Unknown names → OK (could be MC macro params or external constants).
-     *
-     * This catches the common mistake of writing raw("say ${score}") expecting interpolation,
-     * which would silently emit a literal `${score}` in the MC command.
-     */
-    private checkRawCommandInterpolation;
-    private resolveInstanceMethod;
-    private normalizeType;
-    private readArrayElement;
-    private emitRawSubFunction;
-    private storeStringValue;
-    private resolveStaticString;
-    private getStringStoragePath;
-    private lowerConstLiteral;
-    private operandToVar;
-    private selectorToString;
-    private finalizeSelector;
-    private rangeToString;
-}