redscript-mc 1.2.29 → 2.0.0

package/dist/src/diagnostics/index.js

@@ -0,0 +1,140 @@
+"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/src/events/types.d.ts

@@ -0,0 +1,35 @@
+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/src/events/types.js

@@ -0,0 +1,59 @@
+"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/src/formatter/index.d.ts

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

package/dist/src/formatter/index.js

@@ -0,0 +1,26 @@
+"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/src/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * RedScript Compiler
+ *
+ * Main entry point for programmatic usage.
+ */
+export declare const version = "2.0.0";
+export { compile, CompileOptions, CompileResult } from '../src2/emit/compile';
+export type { DatapackFile } from '../src2/emit/index';
+export { Lexer } from './lexer';
+export { Parser } from './parser';
+export { preprocessSource, preprocessSourceWithMetadata } from './compile';
+export { MCCommandValidator } from './mc-validator';
+export type { Program, FnDecl, Expr, Stmt, Span } from './ast/types';
+export type { DiagnosticError } from './diagnostics';
+/**
+ * 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;

package/dist/src/index.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * RedScript Compiler
+ *
+ * Main entry point for programmatic usage.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCCommandValidator = exports.preprocessSourceWithMetadata = exports.preprocessSource = exports.Parser = exports.Lexer = exports.compile = exports.version = void 0;
+exports.check = check;
+exports.version = '2.0.0';
+const lexer_1 = require("./lexer");
+const parser_1 = require("./parser");
+const compile_1 = require("./compile");
+// Re-export v2 compile API
+var compile_2 = require("../src2/emit/compile");
+Object.defineProperty(exports, "compile", { enumerable: true, get: function () { return compile_2.compile; } });
+// Re-export utilities
+var lexer_2 = require("./lexer");
+Object.defineProperty(exports, "Lexer", { enumerable: true, get: function () { return lexer_2.Lexer; } });
+var parser_2 = require("./parser");
+Object.defineProperty(exports, "Parser", { enumerable: true, get: function () { return parser_2.Parser; } });
+var compile_3 = require("./compile");
+Object.defineProperty(exports, "preprocessSource", { enumerable: true, get: function () { return compile_3.preprocessSource; } });
+Object.defineProperty(exports, "preprocessSourceWithMetadata", { enumerable: true, get: function () { return compile_3.preprocessSourceWithMetadata; } });
+var mc_validator_1 = require("./mc-validator");
+Object.defineProperty(exports, "MCCommandValidator", { enumerable: true, get: function () { return mc_validator_1.MCCommandValidator; } });
+/**
+ * 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
+ */
+function check(source, namespace = 'redscript', filePath) {
+    try {
+        const preprocessedSource = (0, compile_1.preprocessSource)(source, { filePath });
+        const tokens = new lexer_1.Lexer(preprocessedSource, filePath).tokenize();
+        new parser_1.Parser(tokens, preprocessedSource, filePath).parse(namespace);
+        return null;
+    }
+    catch (err) {
+        return err;
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/src/ir/builder.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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/src/ir/builder.js

@@ -0,0 +1,99 @@
+"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/src/ir/types.d.ts

@@ -0,0 +1,132 @@
+/**
+ * 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/src/ir/types.js

@@ -0,0 +1,15 @@
+"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/src/lexer/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * RedScript Lexer
+ *
+ * Tokenizes RedScript source code into a stream of tokens.
+ * Handles special cases like entity selectors vs decorators,
+ * range literals, and raw commands.
+ */
+export type TokenKind = 'fn' | 'let' | 'const' | 'if' | 'else' | 'while' | 'for' | 'foreach' | 'match' | 'return' | 'break' | 'continue' | 'as' | 'at' | 'in' | 'is' | 'struct' | 'impl' | 'enum' | 'trigger' | 'namespace' | 'module' | 'execute' | 'run' | 'unless' | 'declare' | 'int' | 'bool' | 'float' | 'string' | 'void' | 'BlockPos' | 'true' | 'false' | 'selector' | 'decorator' | 'int_lit' | 'float_lit' | 'byte_lit' | 'short_lit' | 'long_lit' | 'double_lit' | 'string_lit' | 'f_string' | 'range_lit' | 'rel_coord' | 'local_coord' | '+' | '-' | '*' | '/' | '%' | '~' | '^' | '==' | '!=' | '<' | '<=' | '>' | '>=' | '&&' | '||' | '!' | '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '{' | '}' | '(' | ')' | '[' | ']' | ',' | ';' | ':' | '::' | '->' | '=>' | '.' | 'ident' | 'mc_name' | 'raw_cmd' | 'eof';
+export interface Token {
+    kind: TokenKind;
+    value: string;
+    line: number;
+    col: number;
+}
+export declare class Lexer {
+    private source;
+    private sourceLines;
+    private pos;
+    private line;
+    private col;
+    private tokens;
+    private filePath?;
+    constructor(source: string, filePath?: string);
+    private error;
+    tokenize(): Token[];
+    private isAtEnd;
+    private peek;
+    private advance;
+    private addToken;
+    private scanToken;
+    private scanAtToken;
+    private scanSelectorParams;
+    private scanString;
+    private scanFString;
+    private scanNumber;
+    private scanIdentifier;
+}