redscript-mc 1.2.30 → 2.0.0

package/dist/src/lowering/index.d.ts

@@ -0,0 +1,188 @@
+/**
+ * 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;
+}