redscript-mc 3.0.0 → 3.0.1

package/dist/diagnostics/index.d.ts

@@ -1,44 +0,0 @@
-/**
- * RedScript Diagnostics
- *
- * Error reporting with file path, line, column, and formatted error messages.
- */
-export type DiagnosticKind = 'LexError' | 'ParseError' | 'LoweringError' | 'TypeError';
-export interface DiagnosticLocation {
-    file?: string;
-    line: number;
-    col: number;
-}
-export declare class DiagnosticError extends Error {
-    readonly kind: DiagnosticKind;
-    readonly location: DiagnosticLocation;
-    readonly sourceLines?: string[];
-    constructor(kind: DiagnosticKind, message: string, location: DiagnosticLocation, sourceLines?: string[]);
-    /**
-     * Format the error for display:
-     * ```
-     * Error: [ParseError] line 5, col 12: Expected ';' after statement
-     *   5 |   let x = 42
-     *                   ^ expected ';'
-     * ```
-     */
-    format(): string;
-    toString(): string;
-}
-export declare class DiagnosticCollector {
-    private diagnostics;
-    private sourceLines;
-    private filePath?;
-    constructor(source?: string, filePath?: string);
-    error(kind: DiagnosticKind, message: string, line: number, col: number): void;
-    hasErrors(): boolean;
-    getErrors(): DiagnosticError[];
-    formatAll(): string;
-    throwFirst(): never;
-}
-/**
- * Create a DiagnosticError from a raw error message that includes line/col info
- * e.g., "Expected ';' at line 5, col 12"
- */
-export declare function parseErrorMessage(kind: DiagnosticKind, rawMessage: string, sourceLines?: string[], filePath?: string): DiagnosticError;
-export declare function formatError(error: Error | DiagnosticError, source?: string): string;

package/dist/diagnostics/index.js

@@ -1,140 +0,0 @@
-"use strict";
-/**
- * RedScript Diagnostics
- *
- * Error reporting with file path, line, column, and formatted error messages.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiagnosticCollector = exports.DiagnosticError = void 0;
-exports.parseErrorMessage = parseErrorMessage;
-exports.formatError = formatError;
-function formatSourcePointer(sourceLines, line, col) {
-    const lineIdx = line - 1;
-    if (lineIdx < 0 || lineIdx >= sourceLines.length) {
-        return [];
-    }
-    const sourceLine = sourceLines[lineIdx];
-    const safeCol = Math.max(1, Math.min(col, sourceLine.length + 1));
-    const pointer = `  ${' '.repeat(safeCol - 1)}^`;
-    return [`  ${sourceLine}`, pointer];
-}
-class DiagnosticError extends Error {
-    constructor(kind, message, location, sourceLines) {
-        super(message);
-        this.name = 'DiagnosticError';
-        this.kind = kind;
-        this.location = location;
-        this.sourceLines = sourceLines;
-    }
-    /**
-     * Format the error for display:
-     * ```
-     * Error: [ParseError] line 5, col 12: Expected ';' after statement
-     *   5 |   let x = 42
-     *                   ^ expected ';'
-     * ```
-     */
-    format() {
-        const { kind, message, location, sourceLines } = this;
-        const filePart = location.file ? `${location.file}:` : '';
-        const header = `Error: [${kind}] ${filePart}line ${location.line}, col ${location.col}: ${message}`;
-        if (!sourceLines || sourceLines.length === 0) {
-            return header;
-        }
-        const pointerLines = formatSourcePointer(sourceLines, location.line, location.col);
-        if (pointerLines.length === 0) {
-            return header;
-        }
-        const lineNum = String(location.line).padStart(3);
-        const prefix = `${lineNum} | `;
-        const sourceLine = sourceLines[location.line - 1];
-        const safeCol = Math.max(1, Math.min(location.col, sourceLine.length + 1));
-        const pointer = ' '.repeat(prefix.length + safeCol - 1) + '^';
-        const hint = message.toLowerCase().includes('expected')
-            ? message.split(':').pop()?.trim() || ''
-            : '';
-        return [
-            header,
-            `${prefix}${sourceLine}`,
-            `${pointer}${hint ? ` ${hint}` : ''}`,
-        ].join('\n');
-    }
-    toString() {
-        return this.format();
-    }
-}
-exports.DiagnosticError = DiagnosticError;
-// ---------------------------------------------------------------------------
-// Diagnostic Collection
-// ---------------------------------------------------------------------------
-class DiagnosticCollector {
-    constructor(source, filePath) {
-        this.diagnostics = [];
-        this.sourceLines = [];
-        if (source) {
-            this.sourceLines = source.split('\n');
-        }
-        this.filePath = filePath;
-    }
-    error(kind, message, line, col) {
-        const diagnostic = new DiagnosticError(kind, message, { file: this.filePath, line, col }, this.sourceLines);
-        this.diagnostics.push(diagnostic);
-    }
-    hasErrors() {
-        return this.diagnostics.length > 0;
-    }
-    getErrors() {
-        return this.diagnostics;
-    }
-    formatAll() {
-        return this.diagnostics.map(d => d.format()).join('\n\n');
-    }
-    throwFirst() {
-        if (this.diagnostics.length > 0) {
-            throw this.diagnostics[0];
-        }
-        throw new Error('No diagnostics to throw');
-    }
-}
-exports.DiagnosticCollector = DiagnosticCollector;
-// ---------------------------------------------------------------------------
-// Helper Functions
-// ---------------------------------------------------------------------------
-/**
- * Create a DiagnosticError from a raw error message that includes line/col info
- * e.g., "Expected ';' at line 5, col 12"
- */
-function parseErrorMessage(kind, rawMessage, sourceLines, filePath) {
-    // Try to extract line and col from message
-    const match = rawMessage.match(/at line (\d+), col (\d+)/);
-    if (match) {
-        const line = parseInt(match[1], 10);
-        const col = parseInt(match[2], 10);
-        const message = rawMessage.replace(/ at line \d+, col \d+$/, '').trim();
-        return new DiagnosticError(kind, message, { file: filePath, line, col }, sourceLines);
-    }
-    // Fallback: line 1, col 1
-    return new DiagnosticError(kind, rawMessage, { file: filePath, line: 1, col: 1 }, sourceLines);
-}
-function formatError(error, source) {
-    if (error instanceof DiagnosticError) {
-        const sourceLines = source?.split('\n') ?? error.sourceLines ?? [];
-        const { file, line, col } = error.location;
-        const locationPart = file
-            ? ` in ${file} at line ${line}, col ${col}`
-            : ` at line ${line}, col ${col}`;
-        const lines = [`Error${locationPart}:`];
-        const pointerLines = formatSourcePointer(sourceLines, line, col);
-        if (pointerLines.length > 0) {
-            lines.push(...pointerLines);
-        }
-        lines.push(error.message);
-        return lines.join('\n');
-    }
-    if (!source) {
-        return error.message;
-    }
-    const parsed = parseErrorMessage('ParseError', error.message, source.split('\n'));
-    return formatError(parsed, source);
-}
-//# sourceMappingURL=index.js.map

package/dist/events/types.d.ts

@@ -1,35 +0,0 @@
-import type { TypeNode } from '../ast/types';
-export declare const EVENT_TYPES: {
-    readonly PlayerDeath: {
-        readonly tag: "rs.just_died";
-        readonly params: readonly ["player: Player"];
-        readonly detection: "scoreboard";
-    };
-    readonly PlayerJoin: {
-        readonly tag: "rs.just_joined";
-        readonly params: readonly ["player: Player"];
-        readonly detection: "tag";
-    };
-    readonly BlockBreak: {
-        readonly tag: "rs.just_broke_block";
-        readonly params: readonly ["player: Player", "block: string"];
-        readonly detection: "advancement";
-    };
-    readonly EntityKill: {
-        readonly tag: "rs.just_killed";
-        readonly params: readonly ["player: Player"];
-        readonly detection: "scoreboard";
-    };
-    readonly ItemUse: {
-        readonly tag: "rs.just_used_item";
-        readonly params: readonly ["player: Player"];
-        readonly detection: "scoreboard";
-    };
-};
-export type EventTypeName = keyof typeof EVENT_TYPES;
-export interface EventParamSpec {
-    name: string;
-    type: TypeNode;
-}
-export declare function isEventTypeName(value: string): value is EventTypeName;
-export declare function getEventParamSpecs(eventType: EventTypeName): EventParamSpec[];

package/dist/events/types.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EVENT_TYPES = void 0;
-exports.isEventTypeName = isEventTypeName;
-exports.getEventParamSpecs = getEventParamSpecs;
-exports.EVENT_TYPES = {
-    PlayerDeath: {
-        tag: 'rs.just_died',
-        params: ['player: Player'],
-        detection: 'scoreboard',
-    },
-    PlayerJoin: {
-        tag: 'rs.just_joined',
-        params: ['player: Player'],
-        detection: 'tag',
-    },
-    BlockBreak: {
-        tag: 'rs.just_broke_block',
-        params: ['player: Player', 'block: string'],
-        detection: 'advancement',
-    },
-    EntityKill: {
-        tag: 'rs.just_killed',
-        params: ['player: Player'],
-        detection: 'scoreboard',
-    },
-    ItemUse: {
-        tag: 'rs.just_used_item',
-        params: ['player: Player'],
-        detection: 'scoreboard',
-    },
-};
-function isEventTypeName(value) {
-    return value in exports.EVENT_TYPES;
-}
-function getEventParamSpecs(eventType) {
-    return exports.EVENT_TYPES[eventType].params.map(parseEventParam);
-}
-function parseEventParam(spec) {
-    const match = spec.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([A-Za-z_][A-Za-z0-9_]*)$/);
-    if (!match) {
-        throw new Error(`Invalid event parameter spec: ${spec}`);
-    }
-    const [, name, typeName] = match;
-    return {
-        name,
-        type: toTypeNode(typeName),
-    };
-}
-function toTypeNode(typeName) {
-    if (typeName === 'Player') {
-        return { kind: 'entity', entityType: 'Player' };
-    }
-    if (typeName === 'string' || typeName === 'int' || typeName === 'bool' || typeName === 'float' || typeName === 'void' || typeName === 'BlockPos' || typeName === 'byte' || typeName === 'short' || typeName === 'long' || typeName === 'double') {
-        return { kind: 'named', name: typeName };
-    }
-    return { kind: 'struct', name: typeName };
-}
-//# sourceMappingURL=types.js.map

package/dist/formatter/index.d.ts

@@ -1 +0,0 @@
-export declare function format(source: string): string;

package/dist/formatter/index.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.format = format;
-function format(source) {
-    const lines = source.split("\n");
-    let indent = 0;
-    const result = [];
-    for (let line of lines) {
-        line = line.trim();
-        if (!line) {
-            result.push("");
-            continue;
-        }
-        // Decrease indent before }
-        if (line.startsWith("}"))
-            indent = Math.max(0, indent - 1);
-        // Add indentation
-        result.push("    ".repeat(indent) + line);
-        // Increase indent after {
-        if (line.endsWith("{"))
-            indent++;
-    }
-    // Ensure single newline at end
-    return result.join("\n").trimEnd() + "\n";
-}
-//# sourceMappingURL=index.js.map

package/dist/gcd2.map.json

@@ -1,15 +0,0 @@
-{
-  "$b": "x",
-  "$d": "p0",
-  "$h": "g",
-  "$i": "a",
-  "$j": "b",
-  "$l": "p1",
-  "$m": "c",
-  "$p": "y",
-  "$s": "r",
-  "$a": "const:0",
-  "$c": "internal:p0",
-  "$g": "internal:ret",
-  "$k": "internal:p1"
-}

package/dist/gcd3.map.json

@@ -1,17 +0,0 @@
-{
-  "$b": "x",
-  "$d": "p0",
-  "$h": "g",
-  "$i": "a",
-  "$j": "b",
-  "$l": "p1",
-  "$m": "c",
-  "$p": "y",
-  "$s": "r",
-  "$t": "k",
-  "$v": "result",
-  "$a": "const:0",
-  "$c": "internal:p0",
-  "$g": "internal:ret",
-  "$k": "internal:p1"
-}

package/dist/gcd_test.map.json

@@ -1,15 +0,0 @@
-{
-  "$b": "a",
-  "$d": "b",
-  "$f": "p0",
-  "$g": "p1",
-  "$h": "c",
-  "$k": "x",
-  "$m": "y",
-  "$o": "tmp",
-  "$q": "i",
-  "$a": "const:0",
-  "$c": "internal:p0",
-  "$e": "internal:p1",
-  "$i": "internal:ret"
-}

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[];
-}