redscript-mc 1.1.0 → 1.2.1

package/dist/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/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/index.d.ts

@@ -14,6 +14,7 @@ export interface CompileOptions {
     optimize?: boolean;
     typeCheck?: boolean;
     filePath?: string;
+    dce?: boolean;
 }
 export interface CompileResult {
     files: DatapackFile[];

package/dist/index.js

@@ -13,6 +13,7 @@ const parser_1 = require("./parser");
 const typechecker_1 = require("./typechecker");
 const lowering_1 = require("./lowering");
 const passes_1 = require("./optimizer/passes");
+const dce_1 = require("./optimizer/dce");
 const mcfunction_1 = require("./codegen/mcfunction");
 const compile_1 = require("./compile");
 const commands_1 = require("./optimizer/commands");
@@ -27,12 +28,15 @@ function compile(source, options = {}) {
     const namespace = options.namespace ?? 'redscript';
     const shouldOptimize = options.optimize ?? true;
     const shouldTypeCheck = options.typeCheck ?? true;
+    const shouldRunDce = options.dce ?? shouldOptimize;
     const filePath = options.filePath;
-    const preprocessedSource = (0, compile_1.preprocessSource)(source, { filePath });
+    const preprocessed = (0, compile_1.preprocessSourceWithMetadata)(source, { filePath });
+    const preprocessedSource = preprocessed.source;
     // Lexing
     const tokens = new lexer_1.Lexer(preprocessedSource, filePath).tokenize();
     // Parsing
-    const ast = new parser_1.Parser(tokens, preprocessedSource, filePath).parse(namespace);
+    const parsedAst = new parser_1.Parser(tokens, preprocessedSource, filePath).parse(namespace);
+    const ast = shouldRunDce ? (0, dce_1.eliminateDeadCode)(parsedAst) : parsedAst;
     // Type checking (warn mode - collect errors but don't block)
     let typeErrors;
     if (shouldTypeCheck) {
@@ -40,7 +44,7 @@ function compile(source, options = {}) {
         typeErrors = checker.check(ast);
     }
     // Lowering to IR
-    const lowering = new lowering_1.Lowering(namespace);
+    const lowering = new lowering_1.Lowering(namespace, preprocessed.ranges);
     const ir = lowering.lower(ast);
     let optimizedIR = ir;
     let generated = (0, mcfunction_1.generateDatapackWithStats)(ir, { optimizeCommands: shouldOptimize });

package/dist/ir/types.d.ts

@@ -110,6 +110,10 @@ export interface IRFunction {
         kind: 'advancement' | 'craft' | 'death' | 'login' | 'join_team';
         value?: string;
     };
+    eventHandler?: {
+        eventType: string;
+        tag: string;
+    };
 }
 export interface GlobalVar {
     name: string;

package/dist/lexer/index.d.ts

@@ -5,7 +5,7 @@
  * 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' | 'as' | 'at' | 'in' | 'struct' | 'enum' | 'trigger' | 'namespace' | 'execute' | 'run' | 'unless' | 'int' | 'bool' | 'float' | 'string' | 'void' | 'BlockPos' | 'true' | 'false' | 'selector' | 'decorator' | 'int_lit' | 'float_lit' | 'byte_lit' | 'short_lit' | 'long_lit' | 'double_lit' | 'string_lit' | 'range_lit' | '+' | '-' | '*' | '/' | '%' | '~' | '^' | '==' | '!=' | '<' | '<=' | '>' | '>=' | '&&' | '||' | '!' | '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '{' | '}' | '(' | ')' | '[' | ']' | ',' | ';' | ':' | '::' | '->' | '=>' | '.' | 'ident' | 'mc_name' | 'raw_cmd' | 'eof';
+export type TokenKind = 'fn' | 'let' | 'const' | 'if' | 'else' | 'while' | 'for' | 'foreach' | 'match' | 'return' | 'as' | 'at' | 'in' | 'is' | 'struct' | 'impl' | 'enum' | 'trigger' | 'namespace' | 'execute' | 'run' | 'unless' | '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;
@@ -31,6 +31,7 @@ export declare class Lexer {
     private scanAtToken;
     private scanSelectorParams;
     private scanString;
+    private scanFString;
     private scanNumber;
     private scanIdentifier;
 }

package/dist/lexer/index.js

@@ -26,7 +26,9 @@ const KEYWORDS = {
     as: 'as',
     at: 'at',
     in: 'in',
+    is: 'is',
     struct: 'struct',
+    impl: 'impl',
     enum: 'enum',
     trigger: 'trigger',
     namespace: 'namespace',
@@ -200,8 +202,50 @@ class Lexer {
             this.addToken('range_lit', value, startLine, startCol);
             return;
         }
+        // Relative coordinate: ~ or ~5 or ~-3 or ~0.5
+        if (char === '~') {
+            let value = '~';
+            // Check for optional sign
+            if (this.peek() === '-' || this.peek() === '+') {
+                value += this.advance();
+            }
+            // Check for number
+            while (/[0-9]/.test(this.peek())) {
+                value += this.advance();
+            }
+            // Check for decimal part
+            if (this.peek() === '.' && /[0-9]/.test(this.peek(1))) {
+                value += this.advance(); // .
+                while (/[0-9]/.test(this.peek())) {
+                    value += this.advance();
+                }
+            }
+            this.addToken('rel_coord', value, startLine, startCol);
+            return;
+        }
+        // Local coordinate: ^ or ^5 or ^-3 or ^0.5
+        if (char === '^') {
+            let value = '^';
+            // Check for optional sign
+            if (this.peek() === '-' || this.peek() === '+') {
+                value += this.advance();
+            }
+            // Check for number
+            while (/[0-9]/.test(this.peek())) {
+                value += this.advance();
+            }
+            // Check for decimal part
+            if (this.peek() === '.' && /[0-9]/.test(this.peek(1))) {
+                value += this.advance(); // .
+                while (/[0-9]/.test(this.peek())) {
+                    value += this.advance();
+                }
+            }
+            this.addToken('local_coord', value, startLine, startCol);
+            return;
+        }
         // Single-character operators and delimiters
-        const singleChar = ['+', '-', '*', '/', '%', '~', '^', '<', '>', '!', '=',
+        const singleChar = ['+', '-', '*', '/', '%', '<', '>', '!', '=',
             '{', '}', '(', ')', '[', ']', ',', ';', ':', '.'];
         if (singleChar.includes(char)) {
             this.addToken(char, char, startLine, startCol);
@@ -212,6 +256,12 @@ class Lexer {
             this.scanAtToken(startLine, startCol);
             return;
         }
+        // f-string literal
+        if (char === 'f' && this.peek() === '"') {
+            this.advance();
+            this.scanFString(startLine, startCol);
+            return;
+        }
         // String literal
         if (char === '"') {
             this.scanString(startLine, startCol);
@@ -338,6 +388,46 @@ class Lexer {
         this.advance(); // closing quote
         this.addToken('string_lit', value, startLine, startCol);
     }
+    scanFString(startLine, startCol) {
+        let value = '';
+        let interpolationDepth = 0;
+        let interpolationString = false;
+        while (!this.isAtEnd()) {
+            if (interpolationDepth === 0 && this.peek() === '"') {
+                break;
+            }
+            if (this.peek() === '\\' && this.peek(1) === '"') {
+                this.advance();
+                value += this.advance();
+                continue;
+            }
+            if (interpolationDepth === 0 && this.peek() === '{') {
+                value += this.advance();
+                interpolationDepth = 1;
+                interpolationString = false;
+                continue;
+            }
+            const char = this.advance();
+            value += char;
+            if (interpolationDepth === 0)
+                continue;
+            if (char === '"' && this.source[this.pos - 2] !== '\\') {
+                interpolationString = !interpolationString;
+                continue;
+            }
+            if (interpolationString)
+                continue;
+            if (char === '{')
+                interpolationDepth++;
+            if (char === '}')
+                interpolationDepth--;
+        }
+        if (this.isAtEnd()) {
+            this.error('Unterminated f-string', startLine, startCol);
+        }
+        this.advance(); // closing quote
+        this.addToken('f_string', value, startLine, startCol);
+    }
     scanNumber(firstChar, startLine, startCol) {
         let value = firstChar;
         // Consume integer part

package/dist/lowering/index.d.ts

@@ -5,6 +5,7 @@
  * 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';
 export interface Warning {
     message: string;
@@ -14,18 +15,25 @@ export interface Warning {
 }
 export declare class Lowering {
     private namespace;
+    private readonly sourceRanges;
     private functions;
     private globals;
     private globalNames;
     private fnDecls;
+    private implMethods;
     private specializedFunctions;
     private currentFn;
+    private currentStdlibCallSite?;
     private foreachCounter;
     private lambdaCounter;
+    private timeoutCounter;
+    private intervalCounter;
     readonly warnings: Warning[];
     private builder;
     private varMap;
     private lambdaBindings;
+    private intervalBindings;
+    private intervalFunctions;
     private currentCallbackBindings;
     private currentContext;
     private blockPosVars;
@@ -37,7 +45,7 @@ export declare class Lowering {
     private varTypes;
     private floatVars;
     private worldObjCounter;
-    constructor(namespace: string);
+    constructor(namespace: string, sourceRanges?: SourceRange[]);
     lower(program: Program): IRModule;
     private lowerFn;
     private getTickRate;
@@ -47,6 +55,7 @@ export declare class Lowering {
     private lowerLetStmt;
     private lowerReturnStmt;
     private lowerIfStmt;
+    private lowerIsCheckIfStmt;
     private lowerWhileStmt;
     private lowerForStmt;
     private lowerForRangeStmt;
@@ -67,20 +76,31 @@ export declare class Lowering {
     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;
@@ -88,12 +108,23 @@ export declare class Lowering {
     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 resolveBlockPosExpr;
     private getArrayStorageName;
     private inferLambdaReturnType;
     private inferExprType;
+    private resolveInstanceMethod;
     private normalizeType;
     private readArrayElement;
     private emitRawSubFunction;