redscript-mc 1.2.30 → 2.0.0

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

@@ -0,0 +1,373 @@
+/**
+ * HIR (High-level IR) Types — Stage 2 of the RedScript compiler pipeline.
+ *
+ * HIR is a desugared, structured representation. Compared to the AST:
+ * - `for` loops → `while` loops with explicit init/step
+ * - `a += b` → `a = a + b`
+ * - `a && b` → `if(a) { b } else { false }`
+ * - `a || b` → `if(a) { true } else { b }`
+ * - `cond ? a : b` → if/else expression (not present in RedScript, but pattern applies)
+ * - `as_block`, `at_block`, `as_at` → unified `execute` with subcommands
+ *
+ * All types and names are preserved from the AST.
+ */
+import type { Span, TypeNode, EntitySelector, CoordComponent, Decorator, RangeExpr, FStringPart, SelectorFilter, EntityTypeName, LambdaParam } from '../../src/ast/types';
+import type { BinOp, CmpOp } from '../../src/ast/types';
+export type { Span, TypeNode, EntitySelector, CoordComponent, Decorator, RangeExpr, FStringPart, SelectorFilter, EntityTypeName, LambdaParam, BinOp, CmpOp, };
+export type HIRExpr = {
+    kind: 'int_lit';
+    value: number;
+    span?: Span;
+} | {
+    kind: 'float_lit';
+    value: number;
+    span?: Span;
+} | {
+    kind: 'byte_lit';
+    value: number;
+    span?: Span;
+} | {
+    kind: 'short_lit';
+    value: number;
+    span?: Span;
+} | {
+    kind: 'long_lit';
+    value: number;
+    span?: Span;
+} | {
+    kind: 'double_lit';
+    value: number;
+    span?: Span;
+} | {
+    kind: 'bool_lit';
+    value: boolean;
+    span?: Span;
+} | {
+    kind: 'str_lit';
+    value: string;
+    span?: Span;
+} | {
+    kind: 'range_lit';
+    range: RangeExpr;
+    span?: Span;
+} | {
+    kind: 'array_lit';
+    elements: HIRExpr[];
+    span?: Span;
+} | {
+    kind: 'struct_lit';
+    fields: {
+        name: string;
+        value: HIRExpr;
+    }[];
+    span?: Span;
+} | {
+    kind: 'rel_coord';
+    value: string;
+    span?: Span;
+} | {
+    kind: 'local_coord';
+    value: string;
+    span?: Span;
+} | {
+    kind: 'mc_name';
+    value: string;
+    span?: Span;
+} | {
+    kind: 'blockpos';
+    x: CoordComponent;
+    y: CoordComponent;
+    z: CoordComponent;
+    span?: Span;
+} | {
+    kind: 'selector';
+    raw: string;
+    isSingle: boolean;
+    sel: EntitySelector;
+    span?: Span;
+} | {
+    kind: 'str_interp';
+    parts: Array<string | HIRExpr>;
+    span?: Span;
+} | {
+    kind: 'f_string';
+    parts: FStringPart[];
+    span?: Span;
+} | {
+    kind: 'ident';
+    name: string;
+    span?: Span;
+} | {
+    kind: 'binary';
+    op: BinOp | CmpOp | '&&' | '||';
+    left: HIRExpr;
+    right: HIRExpr;
+    span?: Span;
+} | {
+    kind: 'unary';
+    op: '!' | '-';
+    operand: HIRExpr;
+    span?: Span;
+} | {
+    kind: 'is_check';
+    expr: HIRExpr;
+    entityType: EntityTypeName;
+    span?: Span;
+} | {
+    kind: 'assign';
+    target: string;
+    value: HIRExpr;
+    span?: Span;
+} | {
+    kind: 'member_assign';
+    obj: HIRExpr;
+    field: string;
+    value: HIRExpr;
+    span?: Span;
+} | {
+    kind: 'member';
+    obj: HIRExpr;
+    field: string;
+    span?: Span;
+} | {
+    kind: 'index';
+    obj: HIRExpr;
+    index: HIRExpr;
+    span?: Span;
+} | {
+    kind: 'call';
+    fn: string;
+    args: HIRExpr[];
+    span?: Span;
+} | {
+    kind: 'invoke';
+    callee: HIRExpr;
+    args: HIRExpr[];
+    span?: Span;
+} | {
+    kind: 'static_call';
+    type: string;
+    method: string;
+    args: HIRExpr[];
+    span?: Span;
+} | {
+    kind: 'lambda';
+    params: LambdaParam[];
+    returnType?: TypeNode;
+    body: HIRExpr | HIRBlock;
+    span?: Span;
+};
+export type HIRExecuteSubcommand = {
+    kind: 'as';
+    selector: EntitySelector;
+} | {
+    kind: 'at';
+    selector: EntitySelector;
+} | {
+    kind: 'positioned';
+    x: string;
+    y: string;
+    z: string;
+} | {
+    kind: 'positioned_as';
+    selector: EntitySelector;
+} | {
+    kind: 'rotated';
+    yaw: string;
+    pitch: string;
+} | {
+    kind: 'rotated_as';
+    selector: EntitySelector;
+} | {
+    kind: 'facing';
+    x: string;
+    y: string;
+    z: string;
+} | {
+    kind: 'facing_entity';
+    selector: EntitySelector;
+    anchor: 'eyes' | 'feet';
+} | {
+    kind: 'anchored';
+    anchor: 'eyes' | 'feet';
+} | {
+    kind: 'align';
+    axes: string;
+} | {
+    kind: 'in';
+    dimension: string;
+} | {
+    kind: 'on';
+    relation: string;
+} | {
+    kind: 'summon';
+    entity: string;
+} | {
+    kind: 'if_entity';
+    selector?: EntitySelector;
+    varName?: string;
+    filters?: SelectorFilter;
+} | {
+    kind: 'unless_entity';
+    selector?: EntitySelector;
+    varName?: string;
+    filters?: SelectorFilter;
+} | {
+    kind: 'if_block';
+    pos: [string, string, string];
+    block: string;
+} | {
+    kind: 'unless_block';
+    pos: [string, string, string];
+    block: string;
+} | {
+    kind: 'if_score';
+    target: string;
+    targetObj: string;
+    op: string;
+    source: string;
+    sourceObj: string;
+} | {
+    kind: 'unless_score';
+    target: string;
+    targetObj: string;
+    op: string;
+    source: string;
+    sourceObj: string;
+} | {
+    kind: 'if_score_range';
+    target: string;
+    targetObj: string;
+    range: string;
+} | {
+    kind: 'unless_score_range';
+    target: string;
+    targetObj: string;
+    range: string;
+} | {
+    kind: 'store_result';
+    target: string;
+    targetObj: string;
+} | {
+    kind: 'store_success';
+    target: string;
+    targetObj: string;
+};
+export type HIRStmt = {
+    kind: 'let';
+    name: string;
+    type?: TypeNode;
+    init: HIRExpr;
+    span?: Span;
+} | {
+    kind: 'expr';
+    expr: HIRExpr;
+    span?: Span;
+} | {
+    kind: 'return';
+    value?: HIRExpr;
+    span?: Span;
+} | {
+    kind: 'break';
+    span?: Span;
+} | {
+    kind: 'continue';
+    span?: Span;
+} | {
+    kind: 'if';
+    cond: HIRExpr;
+    then: HIRBlock;
+    else_?: HIRBlock;
+    span?: Span;
+} | {
+    kind: 'while';
+    cond: HIRExpr;
+    body: HIRBlock;
+    step?: HIRBlock;
+    span?: Span;
+} | {
+    kind: 'foreach';
+    binding: string;
+    iterable: HIRExpr;
+    body: HIRBlock;
+    executeContext?: string;
+    span?: Span;
+} | {
+    kind: 'match';
+    expr: HIRExpr;
+    arms: {
+        pattern: HIRExpr | null;
+        body: HIRBlock;
+    }[];
+    span?: Span;
+} | {
+    kind: 'execute';
+    subcommands: HIRExecuteSubcommand[];
+    body: HIRBlock;
+    span?: Span;
+} | {
+    kind: 'raw';
+    cmd: string;
+    span?: Span;
+};
+export type HIRBlock = HIRStmt[];
+export interface HIRParam {
+    name: string;
+    type: TypeNode;
+    default?: HIRExpr;
+}
+export interface HIRFunction {
+    name: string;
+    params: HIRParam[];
+    returnType: TypeNode;
+    decorators: Decorator[];
+    body: HIRBlock;
+    isLibraryFn?: boolean;
+    span?: Span;
+}
+export interface HIRStructField {
+    name: string;
+    type: TypeNode;
+}
+export interface HIRStruct {
+    name: string;
+    fields: HIRStructField[];
+    span?: Span;
+}
+export interface HIRImplBlock {
+    typeName: string;
+    methods: HIRFunction[];
+    span?: Span;
+}
+export interface HIREnumVariant {
+    name: string;
+    value?: number;
+}
+export interface HIREnum {
+    name: string;
+    variants: HIREnumVariant[];
+    span?: Span;
+}
+export interface HIRConst {
+    name: string;
+    type: TypeNode;
+    value: HIRExpr;
+    span?: Span;
+}
+export interface HIRGlobal {
+    name: string;
+    type: TypeNode;
+    init: HIRExpr;
+    mutable: boolean;
+    span?: Span;
+}
+export interface HIRModule {
+    namespace: string;
+    globals: HIRGlobal[];
+    functions: HIRFunction[];
+    structs: HIRStruct[];
+    implBlocks: HIRImplBlock[];
+    enums: HIREnum[];
+    consts: HIRConst[];
+    isLibrary?: boolean;
+}

package/dist/src2/hir/types.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * HIR (High-level IR) Types — Stage 2 of the RedScript compiler pipeline.
+ *
+ * HIR is a desugared, structured representation. Compared to the AST:
+ * - `for` loops → `while` loops with explicit init/step
+ * - `a += b` → `a = a + b`
+ * - `a && b` → `if(a) { b } else { false }`
+ * - `a || b` → `if(a) { true } else { b }`
+ * - `cond ? a : b` → if/else expression (not present in RedScript, but pattern applies)
+ * - `as_block`, `at_block`, `as_at` → unified `execute` with subcommands
+ *
+ * All types and names are preserved from the AST.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/src2/lir/lower.d.ts

@@ -0,0 +1,15 @@
+/**
+ * MIR → LIR Lowering — Stage 5 of the RedScript compiler pipeline.
+ *
+ * Converts 3-address MIR (CFG with basic blocks) to 2-address LIR
+ * (flat instruction lists with MC scoreboard semantics).
+ *
+ * Key transformations:
+ * - Each MIR Temp → a Slot (player = $tempname, obj = module.objective)
+ * - 3-address arithmetic → score_copy dst←a, then score_op dst←b
+ * - CFG control flow → call_if_matches / call_unless_matches to extracted functions
+ * - MIR calls → parameter slot setup + call instruction
+ */
+import type { MIRModule } from '../mir/types';
+import type { LIRModule } from './types';
+export declare function lowerToLIR(mir: MIRModule): LIRModule;