redscript-mc 2.0.0 → 2.1.0

package/dist/src/emit/sourcemap.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Source Map Generation — Stage 7 auxiliary output.
+ *
+ * For each generated .mcfunction file, produces a parallel sourcemap.json
+ * that maps output line numbers back to .mcrs source locations.
+ *
+ * Format:
+ * {
+ *   "version": 1,
+ *   "generatedFile": "data/ns/function/main.mcfunction",
+ *   "sources": ["src/main.mcrs"],
+ *   "mappings": [
+ *     { "line": 1, "source": 0, "sourceLine": 5, "sourceCol": 2 },
+ *     ...
+ *   ]
+ * }
+ */
+import type { SourceLoc } from '../lir/types';
+export interface SourceMapEntry {
+    /** 1-based output line number in the .mcfunction file */
+    line: number;
+    /** Index into the `sources` array */
+    source: number;
+    /** 1-based line in the source .mcrs file */
+    sourceLine: number;
+    /** 1-based column in the source .mcrs file */
+    sourceCol: number;
+}
+export interface SourceMap {
+    version: 1;
+    /** Relative path to the generated .mcfunction file */
+    generatedFile: string;
+    /** List of source file paths referenced by mappings */
+    sources: string[];
+    /** One entry per mapped output line */
+    mappings: SourceMapEntry[];
+}
+export declare class SourceMapBuilder {
+    private readonly generatedFile;
+    private readonly sourceIndex;
+    private readonly sources;
+    private readonly mappings;
+    private lineNumber;
+    constructor(generatedFile: string);
+    /** Record the source location for the next output line. */
+    addLine(sourceLoc: SourceLoc | undefined): void;
+    /** Return the completed SourceMap, or null if there are no mappings. */
+    build(): SourceMap | null;
+}
+/** Serialize a SourceMap to JSON string (pretty-printed). */
+export declare function serializeSourceMap(map: SourceMap): string;
+/** Given a .mcfunction path, return the path for the sidecar sourcemap.json. */
+export declare function sourceMapPath(mcfunctionPath: string): string;

package/dist/src/emit/sourcemap.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Source Map Generation — Stage 7 auxiliary output.
+ *
+ * For each generated .mcfunction file, produces a parallel sourcemap.json
+ * that maps output line numbers back to .mcrs source locations.
+ *
+ * Format:
+ * {
+ *   "version": 1,
+ *   "generatedFile": "data/ns/function/main.mcfunction",
+ *   "sources": ["src/main.mcrs"],
+ *   "mappings": [
+ *     { "line": 1, "source": 0, "sourceLine": 5, "sourceCol": 2 },
+ *     ...
+ *   ]
+ * }
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceMapBuilder = void 0;
+exports.serializeSourceMap = serializeSourceMap;
+exports.sourceMapPath = sourceMapPath;
+// ---------------------------------------------------------------------------
+// Builder — accumulates mappings as lines are emitted
+// ---------------------------------------------------------------------------
+class SourceMapBuilder {
+    constructor(generatedFile) {
+        this.sourceIndex = new Map();
+        this.sources = [];
+        this.mappings = [];
+        this.lineNumber = 0;
+        this.generatedFile = generatedFile;
+    }
+    /** Record the source location for the next output line. */
+    addLine(sourceLoc) {
+        this.lineNumber++;
+        if (!sourceLoc)
+            return;
+        let idx = this.sourceIndex.get(sourceLoc.file);
+        if (idx === undefined) {
+            idx = this.sources.length;
+            this.sources.push(sourceLoc.file);
+            this.sourceIndex.set(sourceLoc.file, idx);
+        }
+        this.mappings.push({
+            line: this.lineNumber,
+            source: idx,
+            sourceLine: sourceLoc.line,
+            sourceCol: sourceLoc.col,
+        });
+    }
+    /** Return the completed SourceMap, or null if there are no mappings. */
+    build() {
+        if (this.mappings.length === 0)
+            return null;
+        return {
+            version: 1,
+            generatedFile: this.generatedFile,
+            sources: [...this.sources],
+            mappings: [...this.mappings],
+        };
+    }
+}
+exports.SourceMapBuilder = SourceMapBuilder;
+/** Serialize a SourceMap to JSON string (pretty-printed). */
+function serializeSourceMap(map) {
+    return JSON.stringify(map, null, 2) + '\n';
+}
+/** Given a .mcfunction path, return the path for the sidecar sourcemap.json. */
+function sourceMapPath(mcfunctionPath) {
+    return mcfunctionPath.replace(/\.mcfunction$/, '.sourcemap.json');
+}
+//# sourceMappingURL=sourcemap.js.map

package/dist/{src2 → src}/hir/lower.d.ts

@@ -10,6 +10,6 @@
  * - as_block / at_block / as_at → unified execute with subcommands
  * - All other nodes pass through with field-wise recursion
  */
-import type { Program } from '../../src/ast/types';
+import type { Program } from '../ast/types';
 import type { HIRModule } from './types';
 export declare function lowerToHIR(program: Program): HIRModule;

package/dist/{src2 → src}/hir/lower.js

@@ -60,11 +60,13 @@ function lowerGlobal(g) {
 function lowerFunction(fn) {
     return {
         name: fn.name,
+        typeParams: fn.typeParams,
         params: fn.params.map(lowerParam),
         returnType: fn.returnType,
         decorators: fn.decorators,
         body: lowerBlock(fn.body),
         isLibraryFn: fn.isLibraryFn,
+        isExported: fn.isExported,
         span: fn.span,
     };
 }
@@ -96,6 +98,8 @@ function lowerStmt(stmt) {
     switch (stmt.kind) {
         case 'let':
             return { kind: 'let', name: stmt.name, type: stmt.type, init: lowerExpr(stmt.init), span: stmt.span };
+        case 'let_destruct':
+            return { kind: 'let_destruct', names: stmt.names, type: stmt.type, init: lowerExpr(stmt.init), span: stmt.span };
         case 'expr':
             return { kind: 'expr', expr: lowerExpr(stmt.expr), span: stmt.span };
         case 'return':
@@ -225,6 +229,15 @@ function lowerStmt(stmt) {
             };
         case 'raw':
             return { kind: 'raw', cmd: stmt.cmd, span: stmt.span };
+        case 'if_let_some':
+            return {
+                kind: 'if_let_some',
+                binding: stmt.binding,
+                init: lowerExpr(stmt.init),
+                then: lowerBlock(stmt.then),
+                else_: stmt.else_ ? lowerBlock(stmt.else_) : undefined,
+                span: stmt.span,
+            };
         default: {
             const _exhaustive = stmt;
             throw new Error(`Unknown statement kind: ${_exhaustive.kind}`);
@@ -348,7 +361,7 @@ function lowerExpr(expr) {
         case 'index':
             return { kind: 'index', obj: lowerExpr(expr.obj), index: lowerExpr(expr.index), span: expr.span };
         case 'call':
-            return { kind: 'call', fn: expr.fn, args: expr.args.map(lowerExpr), span: expr.span };
+            return { kind: 'call', fn: expr.fn, args: expr.args.map(lowerExpr), typeArgs: expr.typeArgs, span: expr.span };
         case 'invoke':
             return { kind: 'invoke', callee: lowerExpr(expr.callee), args: expr.args.map(lowerExpr), span: expr.span };
         case 'static_call':
@@ -359,6 +372,14 @@ function lowerExpr(expr) {
                 args: expr.args.map(lowerExpr),
                 span: expr.span,
             };
+        case 'path_expr':
+            return { kind: 'path_expr', enumName: expr.enumName, variant: expr.variant, span: expr.span };
+        case 'tuple_lit':
+            return { kind: 'tuple_lit', elements: expr.elements.map(lowerExpr), span: expr.span };
+        case 'some_lit':
+            return { kind: 'some_lit', value: lowerExpr(expr.value), span: expr.span };
+        case 'none_lit':
+            return { kind: 'none_lit', span: expr.span };
         case 'lambda': {
             const body = Array.isArray(expr.body) ? lowerBlock(expr.body) : lowerExpr(expr.body);
             return {

package/dist/src/hir/monomorphize.d.ts

@@ -0,0 +1,22 @@
+/**
+ * HIR Monomorphization — Phase 2c: Generic functions
+ *
+ * For each generic function `fn foo<T>(...)`, each unique instantiation
+ * `foo<int>`, `foo<float>` etc. produces a concrete copy with a mangled name.
+ *
+ * Algorithm:
+ * 1. Walk the HIR module collecting all call sites to generic functions.
+ * 2. For each unique (fnName, typeArgs) pair, clone the generic HIRFunction,
+ *    substitute all occurrences of the type params, and add to module.functions.
+ * 3. Rewrite every call site: `foo<int>(x, y)` → `foo_int(x, y)`.
+ * 4. Remove original generic function definitions from the output.
+ *
+ * Type arg → suffix mapping:
+ *   int      → "int"
+ *   float    → "float"
+ *   bool     → "bool"
+ *   string   → "string"
+ *   (others) → use struct/enum name
+ */
+import type { HIRModule } from './types';
+export declare function monomorphize(module: HIRModule): HIRModule;

package/dist/src/hir/monomorphize.js

@@ -0,0 +1,379 @@
+"use strict";
+/**
+ * HIR Monomorphization — Phase 2c: Generic functions
+ *
+ * For each generic function `fn foo<T>(...)`, each unique instantiation
+ * `foo<int>`, `foo<float>` etc. produces a concrete copy with a mangled name.
+ *
+ * Algorithm:
+ * 1. Walk the HIR module collecting all call sites to generic functions.
+ * 2. For each unique (fnName, typeArgs) pair, clone the generic HIRFunction,
+ *    substitute all occurrences of the type params, and add to module.functions.
+ * 3. Rewrite every call site: `foo<int>(x, y)` → `foo_int(x, y)`.
+ * 4. Remove original generic function definitions from the output.
+ *
+ * Type arg → suffix mapping:
+ *   int      → "int"
+ *   float    → "float"
+ *   bool     → "bool"
+ *   string   → "string"
+ *   (others) → use struct/enum name
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.monomorphize = monomorphize;
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+function monomorphize(module) {
+    const mono = new Monomorphizer(module);
+    return mono.run();
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Return a stable string suffix for a type argument, used in mangled names. */
+function typeSuffix(t) {
+    switch (t.kind) {
+        case 'named': return t.name;
+        case 'struct': return t.name;
+        case 'enum': return t.name;
+        case 'array': return `arr_${typeSuffix(t.elem)}`;
+        case 'tuple': return `tup_${t.elements.map(typeSuffix).join('_')}`;
+        case 'option': return `opt_${typeSuffix(t.inner)}`;
+        default: return 'unknown';
+    }
+}
+/** Produce the mangled name for a specialization, e.g. "max_int". */
+function mangledName(fnName, typeArgs) {
+    return `${fnName}_${typeArgs.map(typeSuffix).join('_')}`;
+}
+/** Build a substitution map: type param name → concrete type. */
+function buildSubst(typeParams, typeArgs) {
+    const subst = new Map();
+    for (let i = 0; i < typeParams.length; i++) {
+        subst.set(typeParams[i], typeArgs[i]);
+    }
+    return subst;
+}
+/** Apply substitution to a TypeNode (replacing struct-kind nodes whose name
+ *  matches a type param with the concrete type). */
+function substType(t, subst) {
+    switch (t.kind) {
+        case 'struct': {
+            const replacement = subst.get(t.name);
+            if (replacement)
+                return replacement;
+            return t;
+        }
+        case 'array':
+            return { kind: 'array', elem: substType(t.elem, subst) };
+        case 'tuple':
+            return { kind: 'tuple', elements: t.elements.map(e => substType(e, subst)) };
+        case 'option':
+            return { kind: 'option', inner: substType(t.inner, subst) };
+        case 'function_type':
+            return { kind: 'function_type', params: t.params.map(p => substType(p, subst)), return: substType(t.return, subst) };
+        default:
+            return t;
+    }
+}
+class Monomorphizer {
+    constructor(module) {
+        /** Map from function name → HIRFunction for generic functions */
+        this.genericFns = new Map();
+        /** Cache: cacheKey → specialized HIRFunction (to avoid duplicate generation) */
+        this.specialized = new Map();
+        /** Worklist for BFS specialization (to handle generic calling generic) */
+        this.worklist = [];
+        this.module = module;
+    }
+    run() {
+        // Collect all generic function definitions
+        for (const fn of this.module.functions) {
+            if (fn.typeParams && fn.typeParams.length > 0) {
+                this.genericFns.set(fn.name, fn);
+            }
+        }
+        if (this.genericFns.size === 0) {
+            // Nothing to do — fast path
+            return this.module;
+        }
+        // Rewrite all non-generic functions, collecting specializations needed
+        const newFunctions = [];
+        for (const fn of this.module.functions) {
+            if (fn.typeParams && fn.typeParams.length > 0) {
+                // Skip generic function templates — they'll be replaced by specializations
+                continue;
+            }
+            const rewritten = this.rewriteFn(fn);
+            newFunctions.push(rewritten);
+        }
+        // Process worklist BFS: generate specializations (which may add more to worklist)
+        while (this.worklist.length > 0) {
+            const { fn: templateFn, typeArgs } = this.worklist.shift();
+            const key = this.cacheKey(templateFn.name, typeArgs);
+            if (this.specialized.has(key))
+                continue;
+            // Mark as in-progress to prevent cycles
+            this.specialized.set(key, null);
+            const specializedFn = this.specialize(templateFn, typeArgs);
+            this.specialized.set(key, specializedFn);
+        }
+        // Add all specializations
+        for (const fn of this.specialized.values()) {
+            if (fn)
+                newFunctions.push(fn);
+        }
+        return { ...this.module, functions: newFunctions };
+    }
+    cacheKey(fnName, typeArgs) {
+        return `${fnName}|${typeArgs.map(typeSuffix).join(',')}`;
+    }
+    /** Specialize a generic function with concrete type args. */
+    specialize(templateFn, typeArgs) {
+        const subst = buildSubst(templateFn.typeParams, typeArgs);
+        const name = mangledName(templateFn.name, typeArgs);
+        // Build initial variable scope from parameters
+        const varTypes = new Map();
+        const params = templateFn.params.map(p => {
+            const concreteType = substType(p.type, subst);
+            varTypes.set(p.name, concreteType);
+            return {
+                name: p.name,
+                type: concreteType,
+                default: p.default ? this.rewriteExpr(p.default, { subst, varTypes }) : undefined,
+            };
+        });
+        const returnType = substType(templateFn.returnType, subst);
+        const body = this.rewriteBlock(templateFn.body, { subst, varTypes });
+        return {
+            name,
+            params,
+            returnType,
+            decorators: templateFn.decorators,
+            body,
+            isLibraryFn: templateFn.isLibraryFn,
+            isExported: templateFn.isExported,
+            span: templateFn.span,
+            // No typeParams on the specialized copy
+        };
+    }
+    /** Rewrite a non-generic function (substitute calls to generic functions). */
+    rewriteFn(fn) {
+        const varTypes = new Map();
+        // Add params to scope with their concrete types
+        for (const p of fn.params) {
+            varTypes.set(p.name, p.type);
+        }
+        return {
+            ...fn,
+            params: fn.params.map(p => ({
+                ...p,
+                default: p.default ? this.rewriteExpr(p.default, { subst: new Map(), varTypes }) : undefined,
+            })),
+            body: this.rewriteBlock(fn.body, { subst: new Map(), varTypes }),
+        };
+    }
+    rewriteBlock(block, ctx) {
+        // Clone varTypes so block-local bindings don't leak
+        const localCtx = { subst: ctx.subst, varTypes: new Map(ctx.varTypes) };
+        const result = [];
+        for (const stmt of block) {
+            result.push(this.rewriteStmt(stmt, localCtx));
+        }
+        return result;
+    }
+    rewriteStmt(stmt, ctx) {
+        const { subst } = ctx;
+        switch (stmt.kind) {
+            case 'let': {
+                const init = this.rewriteExpr(stmt.init, ctx);
+                const type = stmt.type ? substType(stmt.type, subst) : undefined;
+                // Track variable type in scope
+                if (type)
+                    ctx.varTypes.set(stmt.name, type);
+                else {
+                    const inferred = this.inferExprType(init, ctx);
+                    if (inferred)
+                        ctx.varTypes.set(stmt.name, inferred);
+                }
+                return { ...stmt, type, init };
+            }
+            case 'let_destruct':
+                return { ...stmt, type: stmt.type ? substType(stmt.type, subst) : undefined, init: this.rewriteExpr(stmt.init, ctx) };
+            case 'expr':
+                return { ...stmt, expr: this.rewriteExpr(stmt.expr, ctx) };
+            case 'return':
+                return { ...stmt, value: stmt.value ? this.rewriteExpr(stmt.value, ctx) : undefined };
+            case 'if':
+                return {
+                    ...stmt,
+                    cond: this.rewriteExpr(stmt.cond, ctx),
+                    then: this.rewriteBlock(stmt.then, ctx),
+                    else_: stmt.else_ ? this.rewriteBlock(stmt.else_, ctx) : undefined,
+                };
+            case 'while':
+                return {
+                    ...stmt,
+                    cond: this.rewriteExpr(stmt.cond, ctx),
+                    body: this.rewriteBlock(stmt.body, ctx),
+                    step: stmt.step ? this.rewriteBlock(stmt.step, ctx) : undefined,
+                };
+            case 'foreach':
+                return { ...stmt, iterable: this.rewriteExpr(stmt.iterable, ctx), body: this.rewriteBlock(stmt.body, ctx) };
+            case 'match':
+                return {
+                    ...stmt,
+                    expr: this.rewriteExpr(stmt.expr, ctx),
+                    arms: stmt.arms.map(arm => ({
+                        pattern: arm.pattern ? this.rewriteExpr(arm.pattern, ctx) : null,
+                        body: this.rewriteBlock(arm.body, ctx),
+                    })),
+                };
+            case 'execute':
+                return { ...stmt, body: this.rewriteBlock(stmt.body, ctx) };
+            case 'if_let_some':
+                return {
+                    ...stmt,
+                    init: this.rewriteExpr(stmt.init, ctx),
+                    then: this.rewriteBlock(stmt.then, ctx),
+                    else_: stmt.else_ ? this.rewriteBlock(stmt.else_, ctx) : undefined,
+                };
+            case 'break':
+            case 'continue':
+            case 'raw':
+                return stmt;
+        }
+    }
+    rewriteExpr(expr, ctx) {
+        const { subst } = ctx;
+        switch (expr.kind) {
+            case 'call': {
+                const args = expr.args.map(a => this.rewriteExpr(a, ctx));
+                // Determine concrete type args for this call
+                const resolvedTypeArgs = expr.typeArgs?.map(t => substType(t, subst));
+                const genericFn = this.genericFns.get(expr.fn);
+                if (genericFn && genericFn.typeParams && genericFn.typeParams.length > 0) {
+                    // This call targets a generic function — we need to monomorphize
+                    const concreteTypeArgs = resolvedTypeArgs ?? this.inferTypeArgs(genericFn, args, ctx);
+                    if (concreteTypeArgs) {
+                        const key = this.cacheKey(expr.fn, concreteTypeArgs);
+                        if (!this.specialized.has(key)) {
+                            // Enqueue for specialization
+                            this.worklist.push({ fn: genericFn, typeArgs: concreteTypeArgs });
+                        }
+                        const name = mangledName(expr.fn, concreteTypeArgs);
+                        return { ...expr, fn: name, args, typeArgs: undefined };
+                    }
+                }
+                return { ...expr, args, typeArgs: resolvedTypeArgs };
+            }
+            case 'invoke':
+                return { ...expr, callee: this.rewriteExpr(expr.callee, ctx), args: expr.args.map(a => this.rewriteExpr(a, ctx)) };
+            case 'binary':
+                return { ...expr, left: this.rewriteExpr(expr.left, ctx), right: this.rewriteExpr(expr.right, ctx) };
+            case 'unary':
+                return { ...expr, operand: this.rewriteExpr(expr.operand, ctx) };
+            case 'assign':
+                return { ...expr, value: this.rewriteExpr(expr.value, ctx) };
+            case 'member_assign':
+                return { ...expr, obj: this.rewriteExpr(expr.obj, ctx), value: this.rewriteExpr(expr.value, ctx) };
+            case 'member':
+                return { ...expr, obj: this.rewriteExpr(expr.obj, ctx) };
+            case 'index':
+                return { ...expr, obj: this.rewriteExpr(expr.obj, ctx), index: this.rewriteExpr(expr.index, ctx) };
+            case 'array_lit':
+                return { ...expr, elements: expr.elements.map(e => this.rewriteExpr(e, ctx)) };
+            case 'struct_lit':
+                return { ...expr, fields: expr.fields.map(f => ({ name: f.name, value: this.rewriteExpr(f.value, ctx) })) };
+            case 'tuple_lit':
+                return { ...expr, elements: expr.elements.map(e => this.rewriteExpr(e, ctx)) };
+            case 'static_call':
+                return { ...expr, args: expr.args.map(a => this.rewriteExpr(a, ctx)) };
+            case 'lambda':
+                return { ...expr, body: Array.isArray(expr.body) ? this.rewriteBlock(expr.body, ctx) : this.rewriteExpr(expr.body, ctx) };
+            case 'is_check':
+                return { ...expr, expr: this.rewriteExpr(expr.expr, ctx) };
+            case 'str_interp':
+                return { ...expr, parts: expr.parts.map(p => typeof p === 'string' ? p : this.rewriteExpr(p, ctx)) };
+            case 'f_string':
+                // FStringPart uses AST Expr (not HIRExpr) — pass through without rewriting
+                return expr;
+            case 'some_lit':
+                return { ...expr, value: this.rewriteExpr(expr.value, ctx) };
+            case 'none_lit':
+                return expr;
+            // Literals / terminals — pass through unchanged
+            default:
+                return expr;
+        }
+    }
+    /**
+     * Infer type args from the actual argument expressions.
+     * Works by looking at the types of call arguments and matching them to
+     * the type parameters in the function signature.
+     *
+     * Returns null if inference fails.
+     */
+    inferTypeArgs(fn, args, ctx) {
+        const inferred = new Map();
+        const typeParams = fn.typeParams;
+        for (let i = 0; i < fn.params.length && i < args.length; i++) {
+            const paramType = fn.params[i].type;
+            const argType = this.inferExprType(args[i], ctx);
+            if (argType) {
+                this.matchTypes(paramType, argType, typeParams, inferred);
+            }
+        }
+        // Check all type params were inferred
+        if (typeParams.every(tp => inferred.has(tp))) {
+            return typeParams.map(tp => inferred.get(tp));
+        }
+        return null;
+    }
+    /** Walk a type pattern and a concrete type, binding type param names. */
+    matchTypes(pattern, concrete, typeParams, inferred) {
+        if (pattern.kind === 'struct' && typeParams.includes(pattern.name)) {
+            // This position is a type param — bind it
+            if (!inferred.has(pattern.name)) {
+                inferred.set(pattern.name, concrete);
+            }
+            return;
+        }
+        if (pattern.kind === 'array' && concrete.kind === 'array') {
+            this.matchTypes(pattern.elem, concrete.elem, typeParams, inferred);
+            return;
+        }
+        if (pattern.kind === 'tuple' && concrete.kind === 'tuple') {
+            for (let i = 0; i < pattern.elements.length && i < concrete.elements.length; i++) {
+                this.matchTypes(pattern.elements[i], concrete.elements[i], typeParams, inferred);
+            }
+        }
+    }
+    /** Infer the type of a HIR expression (best-effort, for type inference). */
+    inferExprType(expr, ctx) {
+        switch (expr.kind) {
+            case 'int_lit': return { kind: 'named', name: 'int' };
+            case 'float_lit': return { kind: 'named', name: 'float' };
+            case 'bool_lit': return { kind: 'named', name: 'bool' };
+            case 'str_lit': return { kind: 'named', name: 'string' };
+            case 'byte_lit': return { kind: 'named', name: 'byte' };
+            case 'short_lit': return { kind: 'named', name: 'short' };
+            case 'long_lit': return { kind: 'named', name: 'long' };
+            case 'double_lit': return { kind: 'named', name: 'double' };
+            case 'ident': return ctx.varTypes.get(expr.name) ?? null;
+            case 'unary':
+                // unary minus/not preserves the operand's type
+                return this.inferExprType(expr.operand, ctx);
+            case 'binary': {
+                // For arithmetic, use the left operand's type
+                const lt = this.inferExprType(expr.left, ctx);
+                if (lt)
+                    return lt;
+                return this.inferExprType(expr.right, ctx);
+            }
+            default: return null;
+        }
+    }
+}
+//# sourceMappingURL=monomorphize.js.map

package/dist/{src2 → src}/hir/types.d.ts

@@ -11,8 +11,8 @@
  *
  * 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';
+import type { Span, TypeNode, EntitySelector, CoordComponent, Decorator, RangeExpr, FStringPart, SelectorFilter, EntityTypeName, LambdaParam } from '../ast/types';
+import type { BinOp, CmpOp } from '../ast/types';
 export type { Span, TypeNode, EntitySelector, CoordComponent, Decorator, RangeExpr, FStringPart, SelectorFilter, EntityTypeName, LambdaParam, BinOp, CmpOp, };
 export type HIRExpr = {
     kind: 'int_lit';
@@ -138,6 +138,7 @@ export type HIRExpr = {
     kind: 'call';
     fn: string;
     args: HIRExpr[];
+    typeArgs?: TypeNode[];
     span?: Span;
 } | {
     kind: 'invoke';
@@ -150,12 +151,28 @@ export type HIRExpr = {
     method: string;
     args: HIRExpr[];
     span?: Span;
+} | {
+    kind: 'path_expr';
+    enumName: string;
+    variant: string;
+    span?: Span;
 } | {
     kind: 'lambda';
     params: LambdaParam[];
     returnType?: TypeNode;
     body: HIRExpr | HIRBlock;
     span?: Span;
+} | {
+    kind: 'tuple_lit';
+    elements: HIRExpr[];
+    span?: Span;
+} | {
+    kind: 'some_lit';
+    value: HIRExpr;
+    span?: Span;
+} | {
+    kind: 'none_lit';
+    span?: Span;
 };
 export type HIRExecuteSubcommand = {
     kind: 'as';
@@ -259,6 +276,12 @@ export type HIRStmt = {
     type?: TypeNode;
     init: HIRExpr;
     span?: Span;
+} | {
+    kind: 'let_destruct';
+    names: string[];
+    type?: TypeNode;
+    init: HIRExpr;
+    span?: Span;
 } | {
     kind: 'expr';
     expr: HIRExpr;
@@ -309,6 +332,13 @@ export type HIRStmt = {
     kind: 'raw';
     cmd: string;
     span?: Span;
+} | {
+    kind: 'if_let_some';
+    binding: string;
+    init: HIRExpr;
+    then: HIRBlock;
+    else_?: HIRBlock;
+    span?: Span;
 };
 export type HIRBlock = HIRStmt[];
 export interface HIRParam {
@@ -318,11 +348,14 @@ export interface HIRParam {
 }
 export interface HIRFunction {
     name: string;
+    /** Generic type parameter names, e.g. ['T'] for fn foo<T>(...) */
+    typeParams?: string[];
     params: HIRParam[];
     returnType: TypeNode;
     decorators: Decorator[];
     body: HIRBlock;
     isLibraryFn?: boolean;
+    isExported?: boolean;
     span?: Span;
 }
 export interface HIRStructField {