@elaraai/east 0.0.1-beta.8 → 1.0.0

package/dist/src/analyze.js

@@ -2,7 +2,6 @@
  * Copyright (c) 2025 Elara AI Pty Ltd
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
-import { printLocationValue } from "./ir.js";
 import { isTypeValueEqual, isSubtypeValue, expandTypeValue, toEastTypeValue } from "./type_of_type.js";
 import { printTypeValue } from "./compile.js";
 import { variant } from "./containers/variant.js";
@@ -37,20 +36,30 @@ import { Builtins } from "./builtins.js";
 export function analyzeIR(ir, platformDef, ctx = {}) {
     // Working data for tracking during analysis
     const analysis = new Map();
+    // Pre-populate analysis Map with definedBy nodes from external context.
+    // This is needed when analyzing deserialized functions with captures - the external
+    // context contains variable metadata with definedBy references that need to be in
+    // the analysis Map so nested functions can properly mark them as captured.
+    for (const varName of Object.keys(ctx)) {
+        const varMeta = ctx[varName];
+        if (varMeta?.definedBy && !analysis.has(varMeta.definedBy)) {
+            analysis.set(varMeta.definedBy, { captured: varMeta.captured });
+        }
+    }
     // Build a lookup map for platform functions
     const platformMap = new Map();
     for (const p of platformDef) {
         if (platformMap.has(p.name)) {
             throw new Error(`Duplicate platform function definition for '${p.name}'`);
         }
-        platformMap.set(p.name, { inputs: p.inputs, output: p.output, type: p.type });
+        platformMap.set(p.name, p);
     }
     // Track circular references
     const visiting = new Set();
     function visit(node, ctx, expectedReturnType) {
         // Detect circular IR (we don't cache because we're building new nodes)
         if (visiting.has(node)) {
-            throw new Error(`Circular IR reference detected at ${printLocationValue(node.value.location)}`);
+            throw new Error(`Circular IR reference detected at loc_id ${node.value.loc_id}`);
         }
         visiting.add(node);
         try {
@@ -67,7 +76,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             // Validate that the type matches the value
             if (node.value.type.type !== node.value.value.type) {
                 throw new Error(`Value node expected value of type .${node.value.type.type} ` +
-                    `but got .${node.value.value.type} at ${printLocationValue(node.value.location)}`);
+                    `but got .${node.value.value.type} at loc_id ${node.value.loc_id}`);
             }
             // Value is always sync (literal constant)
             return {
@@ -83,19 +92,19 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             const varMeta = ctx[name];
             // Validate variable is in scope
             if (varMeta === undefined) {
-                throw new Error(`Variable ${name} not in scope at ${printLocationValue(node.value.location)}`);
+                throw new Error(`Variable ${name} not in scope at loc_id ${node.value.loc_id}`);
             }
             // Validate type matches
             if (!isTypeValueEqual(varMeta.type, node.value.type)) {
                 throw new Error(`Variable ${name} has type ${printTypeValue(varMeta.type)} ` +
-                    `but expected ${printTypeValue(node.value.type)} at ${printLocationValue(node.value.location)}`);
+                    `but expected ${printTypeValue(node.value.type)} at loc_id ${node.value.loc_id}`);
             }
             // Validate mutability matches
             if (varMeta.mutable !== node.value.mutable) {
                 throw new Error(`Variable ${name} mutability mismatch: ` +
                     `context has ${varMeta.mutable ? 'mutable' : 'const'} ` +
                     `but IR expects ${node.value.mutable ? 'mutable' : 'const'} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Detect capture: if variable is not in current scope but in parent, mark as captured
             if (!Object.hasOwn(ctx, name)) {
@@ -138,7 +147,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
                     `has type ${printTypeValue(node.value.variable.value.type)} ` +
                     `but value has type ${printTypeValue(valueInfo.value.type)}. ` +
                     `Insert an As node if subtyping is intended. ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Analyze the VariableIR node itself (so it has an entry in the analysis map)
             analysis.set(node.value.variable, {
@@ -168,17 +177,17 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             // Validate variable exists in scope
             if (varMeta === undefined) {
                 throw new Error(`Cannot assign to variable ${varName} which is not in scope ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Validate variable is mutable in IR
             if (!node.value.variable.value.mutable) {
                 throw new Error(`Cannot reassign const variable ${varName} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Validate variable is mutable in context (matches IR)
             if (!varMeta.mutable) {
                 throw new Error(`Cannot reassign variable ${varName} - context says it's const ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Visit the value expression
             const valueInfo = visit(node.value.value, ctx, expectedReturnType);
@@ -189,7 +198,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
                     `Variable ${varName} has type ${printTypeValue(varMeta.type)} ` +
                     `but value has type ${printTypeValue(valueInfo.value.type)}. ` +
                     `Insert an As node if subtyping is intended. ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             isAsync = valueInfo.value.isAsync; // Async if the value expression is async
         }
@@ -214,7 +223,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             if (!isTypeValueEqual(lastType, node.value.type)) {
                 throw new Error(`Block evaluates to type ${printTypeValue(lastType)} ` +
                     `but expected ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Return analyzed Block with analyzed statements
             return {
@@ -233,17 +242,17 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             if (!isSubtypeValue(valueInfo.value.type, node.value.type)) {
                 throw new Error(`Cannot cast value of type ${printTypeValue(valueInfo.value.type)} ` +
                     `to type ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // More thorough checks for "unnecessary" As IR nodes:
             // Cannot cast Never to a value
             if (valueInfo.value.type.type === "Never") {
                 throw new Error(`Cannot cast .Never to type ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             if (isTypeValueEqual(valueInfo.value.type, node.value.type)) {
                 throw new Error(`Unnecessary As node: value is already of type ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             isAsync = valueInfo.value.isAsync; // Propagate async from child
         }
@@ -251,14 +260,57 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             // Look up platform function
             const platformFn = platformMap.get(node.value.name);
             if (!platformFn) {
-                throw new Error(`Platform function '${node.value.name}' not found ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                // Allow missing platforms only if this specific platform function is marked as optional in the IR
+                if (!node.value.optional) {
+                    throw new Error(`Platform function '${node.value.name}' not found ` +
+                        `at loc_id ${node.value.loc_id}`);
+                }
+                // allowMissingPlatform is true - analyze arguments without type validation
+                // and let compile inject a runtime error stub
+                const analyzedArgs = [];
+                for (const arg of node.value.arguments) {
+                    const argAnalyzed = visit(arg, ctx, expectedReturnType);
+                    analyzedArgs.push(argAnalyzed);
+                    if (argAnalyzed.value.isAsync) {
+                        isAsync = true;
+                    }
+                }
+                // Return analyzed Platform node with analyzed arguments (no type validation)
+                return {
+                    ...node,
+                    value: {
+                        ...node.value,
+                        arguments: analyzedArgs,
+                        isAsync,
+                    }
+                };
             }
-            // Validate argument count
-            if (node.value.arguments.length !== platformFn.inputs.length) {
-                throw new Error(`Platform function '${node.value.name}' expects ${platformFn.inputs.length} arguments ` +
+            // Handle generic platform functions
+            const typeParams = node.value.type_parameters ?? [];
+            const expectedTypeParamCount = platformFn.type_parameters?.length ?? 0;
+            if (typeParams.length !== expectedTypeParamCount) {
+                throw new Error(`Platform function '${node.value.name}' expects ${expectedTypeParamCount} ` +
+                    `type parameters, got ${typeParams.length} ` +
+                    `at loc_id ${node.value.loc_id}`);
+            }
+            // Compute concrete input/output types by substituting type parameters
+            let inputTypes;
+            let outputType;
+            if (expectedTypeParamCount > 0 && platformFn.inputsFn && platformFn.outputsFn) {
+                // Generic platform function - use callbacks to compute types
+                inputTypes = platformFn.inputsFn(...typeParams);
+                outputType = platformFn.outputsFn(...typeParams);
+            }
+            else {
+                // Non-generic - use stored concrete types
+                inputTypes = platformFn.inputs;
+                outputType = platformFn.output;
+            }
+            // Validate argument count (now using computed inputTypes)
+            if (node.value.arguments.length !== inputTypes.length) {
+                throw new Error(`Platform function '${node.value.name}' expects ${inputTypes.length} arguments ` +
                     `but got ${node.value.arguments.length} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Visit all arguments, check if any are async, and validate types
             const analyzedArgs = [];
@@ -269,28 +321,28 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
                 if (argAnalyzed.value.isAsync) {
                     isAsync = true;
                 }
-                // Validate argument type exactly matches expected
+                // Validate argument type exactly matches expected (using computed inputTypes)
                 // (Subtyping should be handled by explicit As nodes)
-                const expectedType = platformFn.inputs[i];
+                const expectedType = inputTypes[i];
                 if (argAnalyzed.value.type.type !== "Never" && !isTypeValueEqual(argAnalyzed.value.type, expectedType)) {
                     throw new Error(`Platform function '${node.value.name}' argument ${i + 1} ` +
                         `requires exact type match. ` +
                         `Expected type ${printTypeValue(expectedType)} ` +
                         `but got ${printTypeValue(argAnalyzed.value.type)}. ` +
                         `Insert an As node if subtyping is intended. ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
             }
             // Platform function itself might be async
             if (platformFn.type === 'async') {
                 isAsync = true;
             }
-            // Validate return type matches
-            if (!isTypeValueEqual(node.value.type, platformFn.output)) {
+            // Validate return type matches (using computed outputType)
+            if (!isTypeValueEqual(node.value.type, outputType)) {
                 throw new Error(`Platform function '${node.value.name}' return type ` +
-                    `expected to be ${printTypeValue(platformFn.output)} ` +
+                    `expected to be ${printTypeValue(outputType)} ` +
                     `but IR has ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Return analyzed Platform node with analyzed arguments
             return {
@@ -306,7 +358,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             // Validate it has a Function type
             if (node.value.type.type !== "Function") {
                 throw new Error(`Expected Function type, got ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Create new context for function body
             const fnCtx = {};
@@ -315,27 +367,31 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
                 const outerVar = ctx[captureVar.value.name];
                 if (outerVar === undefined) {
                     throw new Error(`Captured variable ${captureVar.value.name} not in scope ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
                 if (!isTypeValueEqual(outerVar.type, captureVar.value.type)) {
                     throw new Error(`Captured variable ${captureVar.value.name} has type ${printTypeValue(outerVar.type)} ` +
                         `but expected ${printTypeValue(captureVar.value.type)} ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
                 if (outerVar.mutable !== captureVar.value.mutable) {
                     throw new Error(`Captured variable ${captureVar.value.name} mutability mismatch: ` +
                         `context has ${outerVar.mutable ? 'mutable' : 'const'} ` +
                         `but IR expects ${captureVar.value.mutable ? 'mutable' : 'const'} ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
                 // Mark the outer variable as captured (it's being closed over by this function)
+                const wasAlreadyCaptured = outerVar.captured;
                 outerVar.captured = true;
                 const defVarAnalysis = analysis.get(outerVar.definedBy);
-                if (!defVarAnalysis) {
+                if (defVarAnalysis) {
+                    defVarAnalysis.captured = true;
+                }
+                else if (!wasAlreadyCaptured) {
+                    // Only error if this wasn't already marked as captured (from a synthetic/external context)
                     throw new Error(`Internal error: VariableIR node for captured variable ${captureVar.value.name} not analyzed. ` +
                         `This should never happen - all VariableIR nodes should be analyzed when encountered.`);
                 }
-                defVarAnalysis.captured = true;
                 fnCtx[captureVar.value.name] = {
                     type: captureVar.value.type,
                     mutable: captureVar.value.mutable,
@@ -365,7 +421,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             if (bodyInfo.value.type.type !== "Never" && !isTypeValueEqual(bodyInfo.value.type, expectedOutput)) {
                 throw new Error(`Function body returns type ${printTypeValue(bodyInfo.value.type)} ` +
                     `but function signature expects ${printTypeValue(expectedOutput)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Creating a function is sync (it just captures variables at this stage)
             return {
@@ -381,7 +437,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             // Validate it has a Function type
             if (node.value.type.type !== "AsyncFunction") {
                 throw new Error(`Expected AsyncFunction type, got ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Create new context for function body
             const fnCtx = {};
@@ -390,27 +446,31 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
                 const outerVar = ctx[captureVar.value.name];
                 if (outerVar === undefined) {
                     throw new Error(`Captured variable ${captureVar.value.name} not in scope ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
                 if (!isTypeValueEqual(outerVar.type, captureVar.value.type)) {
                     throw new Error(`Captured variable ${captureVar.value.name} has type ${printTypeValue(outerVar.type)} ` +
                         `but expected ${printTypeValue(captureVar.value.type)} ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
                 if (outerVar.mutable !== captureVar.value.mutable) {
                     throw new Error(`Captured variable ${captureVar.value.name} mutability mismatch: ` +
                         `context has ${outerVar.mutable ? 'mutable' : 'const'} ` +
                         `but IR expects ${captureVar.value.mutable ? 'mutable' : 'const'} ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
                 // Mark the outer variable as captured (it's being closed over by this function)
+                const wasAlreadyCaptured = outerVar.captured;
                 outerVar.captured = true;
                 const defVarAnalysis = analysis.get(outerVar.definedBy);
-                if (!defVarAnalysis) {
+                if (defVarAnalysis) {
+                    defVarAnalysis.captured = true;
+                }
+                else if (!wasAlreadyCaptured) {
+                    // Only error if this wasn't already marked as captured (from a synthetic/external context)
                     throw new Error(`Internal error: VariableIR node for captured variable ${captureVar.value.name} not analyzed. ` +
                         `This should never happen - all VariableIR nodes should be analyzed when encountered.`);
                 }
-                defVarAnalysis.captured = true;
                 fnCtx[captureVar.value.name] = {
                     type: captureVar.value.type,
                     mutable: captureVar.value.mutable,
@@ -440,7 +500,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             if (bodyInfo.value.type.type !== "Never" && !isTypeValueEqual(bodyInfo.value.type, expectedOutput)) {
                 throw new Error(`AsyncFunction body returns type ${printTypeValue(bodyInfo.value.type)} ` +
                     `but function signature expects ${printTypeValue(expectedOutput)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Creating a function is sync (it just captures variables at this stage)
             return {
@@ -458,13 +518,13 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             // Validate it's a function type
             if (fnInfo.value.type.type !== "Function") {
                 throw new Error(`Call expects Function type, got ${printTypeValue(fnInfo.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Validate argument count
             if (fnInfo.value.type.value.inputs.length !== node.value.arguments.length) {
                 throw new Error(`Function expects ${fnInfo.value.type.value.inputs.length} arguments, ` +
                     `got ${node.value.arguments.length} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Analyze all arguments
             const analyzedArgs = [];
@@ -482,14 +542,14 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
                         `Expected type ${printTypeValue(expectedType)} ` +
                         `but got ${printTypeValue(argInfo.value.type)}. ` +
                         `Insert an As node if subtyping is intended. ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
             }
             // Validate return type matches
             if (!isTypeValueEqual(node.value.type, fnInfo.value.type.value.output)) {
                 throw new Error(`Function call return type expected to be ${printTypeValue(fnInfo.value.type.value.output)} ` +
                     `but IR has ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Return analyzed Call with analyzed function and arguments
             return {
@@ -510,13 +570,13 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             // Validate it's an async function type
             if (fnInfo.value.type.type !== "AsyncFunction") {
                 throw new Error(`CallAsync expects AsyncFunction type, got ${printTypeValue(fnInfo.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Validate argument count
             if (fnInfo.value.type.value.inputs.length !== node.value.arguments.length) {
                 throw new Error(`Function expects ${fnInfo.value.type.value.inputs.length} arguments, ` +
                     `got ${node.value.arguments.length} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Analyze all arguments
             const analyzedArgs = [];
@@ -531,14 +591,14 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
                         `Expected type ${printTypeValue(expectedType)} ` +
                         `but got ${printTypeValue(argInfo.value.type)}. ` +
                         `Insert an As node if subtyping is intended. ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
             }
             // Validate return type matches
             if (!isTypeValueEqual(node.value.type, fnInfo.value.type.value.output)) {
                 throw new Error(`Function call return type expected to be ${printTypeValue(fnInfo.value.type.value.output)} ` +
                     `but IR has ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Return analyzed Call with analyzed function and arguments
             return {
@@ -559,12 +619,12 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             const builtin = Builtins[builtinName];
             if (!builtin) {
                 throw new Error(`Unknown builtin function '${builtinName}' ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             if (node.value.arguments.length !== builtin.inputs.length) {
                 throw new Error(`Builtin function '${builtinName}' expects ${builtin.inputs.length} arguments, ` +
                     `but got ${node.value.arguments.length} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Visit all arguments
             const analyzedArgs = [];
@@ -588,7 +648,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
         else if (node.type === "Return") {
             // Validate we're inside a function
             if (!expectedReturnType) {
-                throw new Error(`Return statement outside of function at ${printLocationValue(node.value.location)}`);
+                throw new Error(`Return statement outside of function at loc_id ${node.value.loc_id}`);
             }
             // Analyze the return value expression
             const valueInfo = visit(node.value.value, ctx, expectedReturnType);
@@ -596,7 +656,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             if (valueInfo.value.type.type !== "Never" && !isTypeValueEqual(valueInfo.value.type, expectedReturnType)) {
                 throw new Error(`Return statement returns type ${printTypeValue(valueInfo.value.type)} ` +
                     `but function signature expects ${printTypeValue(expectedReturnType)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Return analyzed Return node with analyzed value
             return {
@@ -612,7 +672,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             // Validate type is Ref
             if (node.value.type.type !== "Ref") {
                 throw new Error(`NewRef node must have Ref type, got ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             const elementType = node.value.type.value;
             const valueInfo = visit(node.value.value, ctx, expectedReturnType);
@@ -621,14 +681,14 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             if (valueInfo.value.type.type !== "Never" && !isTypeValueEqual(valueInfo.value.type, elementType)) {
                 throw new Error(`Ref value has type ${printTypeValue(valueInfo.value.type)} ` +
                     `but Ref expects ${printTypeValue(elementType)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
         }
         else if (node.type === "NewArray") {
             // Validate type is Array
             if (node.value.type.type !== "Array") {
                 throw new Error(`NewArray node must have Array type, got ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             const elementType = node.value.type.value;
             isAsync = false;
@@ -643,7 +703,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
                 if (valueInfo.value.type.type !== "Never" && !isTypeValueEqual(valueInfo.value.type, elementType)) {
                     throw new Error(`Array element ${i} has type ${printTypeValue(valueInfo.value.type)} ` +
                         `but array expects ${printTypeValue(elementType)} ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
             }
         }
@@ -651,7 +711,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             // Validate type is Set
             if (node.value.type.type !== "Set") {
                 throw new Error(`NewSet node must have Set type, got ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             const keyType = node.value.type.value;
             isAsync = false;
@@ -666,7 +726,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
                 if (keyInfo.value.type.type !== "Never" && !isTypeValueEqual(keyInfo.value.type, keyType)) {
                     throw new Error(`Set element ${i} has type ${printTypeValue(keyInfo.value.type)} ` +
                         `but set expects ${printTypeValue(keyType)} ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
             }
         }
@@ -674,7 +734,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             // Validate type is Dict
             if (node.value.type.type !== "Dict") {
                 throw new Error(`NewDict node must have Dict type, got ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             const keyType = node.value.type.value.key;
             const valueType = node.value.type.value.value;
@@ -694,13 +754,13 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
                 if (keyInfo.value.type.type !== "Never" && !isTypeValueEqual(keyInfo.value.type, keyType)) {
                     throw new Error(`Dict key ${i} has type ${printTypeValue(keyInfo.value.type)} ` +
                         `but dict expects ${printTypeValue(keyType)} ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
                 // Validate value type exactly matches
                 if (valInfo.value.type.type !== "Never" && !isTypeValueEqual(valInfo.value.type, valueType)) {
                     throw new Error(`Dict value ${i} has type ${printTypeValue(valInfo.value.type)} ` +
                         `but dict expects ${printTypeValue(valueType)} ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
             }
         }
@@ -710,19 +770,19 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             // Validate it's an Array type (not Never)
             if (arrayInfo.value.type.type !== "Array") {
                 throw new Error(`ForArray expects Array type, got ${printTypeValue(arrayInfo.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             const elementType = arrayInfo.value.type.value;
             // Validate key variable is Integer type
             if (node.value.key.value.type.type !== "Integer") {
                 throw new Error(`ForArray key must be Integer type, got ${printTypeValue(node.value.key.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Validate value variable matches array element type
             if (!isTypeValueEqual(node.value.value.value.type, elementType)) {
                 throw new Error(`ForArray value variable has type ${printTypeValue(node.value.value.value.type)} ` +
                     `but array elements have type ${printTypeValue(elementType)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Analyze the key and value VariableIR nodes
             analysis.set(node.value.key, {
@@ -764,14 +824,14 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             // Validate it's a Set type (not Never)
             if (setInfo.value.type.type !== "Set") {
                 throw new Error(`ForSet expects Set type, got ${printTypeValue(setInfo.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             const elementType = setInfo.value.type.value;
             // Validate key variable matches set element type
             if (!isTypeValueEqual(node.value.key.value.type, elementType)) {
                 throw new Error(`ForSet key variable has type ${printTypeValue(node.value.key.value.type)} ` +
                     `but set elements have type ${printTypeValue(elementType)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Analyze the key VariableIR node
             analysis.set(node.value.key, {
@@ -795,7 +855,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             // Validate it's a Dict type (not Never)
             if (dictInfo.value.type.type !== "Dict") {
                 throw new Error(`ForDict expects Dict type, got ${printTypeValue(dictInfo.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             const keyType = dictInfo.value.type.value.key;
             const valueType = dictInfo.value.type.value.value;
@@ -803,13 +863,13 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             if (!isTypeValueEqual(node.value.key.value.type, keyType)) {
                 throw new Error(`ForDict key variable has type ${printTypeValue(node.value.key.value.type)} ` +
                     `but dict keys have type ${printTypeValue(keyType)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Validate value variable matches dict value type
             if (!isTypeValueEqual(node.value.value.value.type, valueType)) {
                 throw new Error(`ForDict value variable has type ${printTypeValue(node.value.value.value.type)} ` +
                     `but dict values have type ${printTypeValue(valueType)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Analyze the key and value VariableIR nodes
             analysis.set(node.value.key, {
@@ -850,7 +910,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
                 }
                 if (predicateInfo.value.type.type !== "Boolean") {
                     throw new Error(`IfElse predicate ${i} must be Boolean type, got ${printTypeValue(predicateInfo.value.type)} ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
                 // Visit branch body and validate type
                 const bodyInfo = visit(branch.body, ctx, expectedReturnType);
@@ -865,7 +925,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
                 if (bodyInfo.value.type.type !== "Never" && !isTypeValueEqual(bodyInfo.value.type, node.value.type)) {
                     throw new Error(`IfElse branch ${i} returns type ${printTypeValue(bodyInfo.value.type)} ` +
                         `but IfElse expects ${printTypeValue(node.value.type)} ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
                 analyzedIfs.push({ predicate: predicateInfo, body: bodyInfo });
             }
@@ -882,18 +942,18 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             if (elseInfo.value.type.type !== "Never" && !isTypeValueEqual(elseInfo.value.type, node.value.type)) {
                 throw new Error(`IfElse else branch returns type ${printTypeValue(elseInfo.value.type)} ` +
                     `but IfElse expects ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // If all branches diverge, IfElse must be Never
             if (allBranchesNever && node.value.type.type !== "Never") {
                 throw new Error(`IfElse has all branches returning Never, so it must have type Never, ` +
                     `but has type ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // If IfElse is Never, all branches must be Never
             if (node.value.type.type === "Never" && !allBranchesNever) {
                 throw new Error(`IfElse has type Never but not all branches diverge ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Return analyzed IfElse with analyzed branches
             return {
@@ -911,7 +971,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             const predicateInfo = visit(node.value.predicate, ctx, expectedReturnType);
             if (predicateInfo.value.type.type !== "Boolean") {
                 throw new Error(`While predicate must be Boolean type, got ${printTypeValue(predicateInfo.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Visit loop body
             const bodyInfo = visit(node.value.body, ctx, expectedReturnType);
@@ -939,7 +999,7 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             const messageInfo = visit(node.value.message, ctx, expectedReturnType);
             if (messageInfo.value.type.type !== "String") {
                 throw new Error(`Error message must be String type, got ${printTypeValue(messageInfo.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Error always has type Never (throws exception, diverges control flow)
             isAsync = messageInfo.value.isAsync; // Error is async if message is async
@@ -950,13 +1010,13 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             // Validate message variable is String type
             if (node.value.message.value.type.type !== "String") {
                 throw new Error(`TryCatch message variable must be String type, got ${printTypeValue(node.value.message.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Validate stack variable is correct type
             const stackType = toEastTypeValue(ArrayType(StructType({ filename: StringType, line: IntegerType, column: IntegerType })));
             if (!isTypeValueEqual(node.value.stack.value.type, stackType)) {
                 throw new Error(`TryCatch stack variable must be ${printTypeValue(stackType)} type, got ${printTypeValue(node.value.stack.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Analyze the message and stack VariableIR nodes
             analysis.set(node.value.message, {
@@ -985,19 +1045,19 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             if (tryInfo.value.type.type !== "Never" && !isTypeValueEqual(tryInfo.value.type, node.value.type)) {
                 throw new Error(`TryCatch try body returns type ${printTypeValue(tryInfo.value.type)} ` +
                     `but TryCatch expects ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             if (catchInfo.value.type.type !== "Never" && !isTypeValueEqual(catchInfo.value.type, node.value.type)) {
                 throw new Error(`TryCatch catch body returns type ${printTypeValue(catchInfo.value.type)} ` +
                     `but TryCatch expects ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // If both bodies diverge, TryCatch must be Never
             const bothNever = tryInfo.value.type.type === "Never" && catchInfo.value.type.type === "Never";
             if (bothNever && node.value.type.type !== "Never") {
                 throw new Error(`TryCatch has both try and catch bodies returning Never, so it must have type Never, ` +
                     `but has type ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Visit finally body
             const finallyInfo = visit(node.value.finally_body, ctx, expectedReturnType);
@@ -1018,14 +1078,14 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             // Validate type is Struct
             if (node.value.type.type !== "Struct") {
                 throw new Error(`Struct node must have Struct type, got ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             const structType = expandTypeValue(node.value.type);
             isAsync = false;
             if (structType.value.length !== node.value.fields.length) {
                 throw new Error(`Struct type has ${structType.value.length} fields but struct value has ` +
                     `${node.value.fields.length} fields ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Visit all field values and validate types
             for (const [i, field] of node.value.fields.entries()) {
@@ -1037,13 +1097,13 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
                 const typeField = structType.value[i];
                 if (typeField.name !== field.name) {
                     throw new Error(`Struct has field ${typeField.name} at position ${i}, but value does not ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
                 // Validate field type exactly matches
                 if (!isTypeValueEqual(fieldInfo.value.type, typeField.type)) {
                     throw new Error(`Struct field ${field.name} has type ${printTypeValue(fieldInfo.value.type)} ` +
                         `but struct type expects ${printTypeValue(typeField.type)} ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
             }
         }
@@ -1053,20 +1113,20 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             // Validate it's a Struct type
             if (structInfo.value.type.type !== "Struct") {
                 throw new Error(`GetField expects Struct type, got ${printTypeValue(structInfo.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Find the field in struct type
             const structType = expandTypeValue(structInfo.value.type);
             const field = structType.value.find(f => f.name === node.value.field);
             if (!field) {
                 throw new Error(`Struct does not have field ${node.value.field} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Validate return type matches field type
             if (!isTypeValueEqual(node.value.type, field.type)) {
                 throw new Error(`GetField result type ${printTypeValue(node.value.type)} ` +
                     `does not match field type ${printTypeValue(field.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             isAsync = structInfo.value.isAsync;
         }
@@ -1076,25 +1136,25 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             // Validate type is Variant
             if (node.value.type.type !== "Variant") {
                 throw new Error(`Variant node must have Variant type, got ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Expand recursive types to get well-formed variant type
             const variantType = expandTypeValue(node.value.type);
             if (variantType.type !== "Variant") {
                 throw new Error(`Expanded Variant type is not Variant, got ${printTypeValue(variantType)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Find the case in variant type
             const caseType = variantType.value.find((c) => c.name === node.value.case);
             if (!caseType) {
                 throw new Error(`Variant type does not have case ${node.value.case} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Validate value type exactly matches case type
             if (!isTypeValueEqual(valueInfo.value.type, caseType.type)) {
                 throw new Error(`Variant case ${node.value.case} value has type ${printTypeValue(valueInfo.value.type)} ` +
                     `but variant type expects ${printTypeValue(caseType.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             isAsync = valueInfo.value.isAsync;
         }
@@ -1104,19 +1164,19 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
             // Validate it's a Variant type
             if (variantInfo.value.type.type !== "Variant") {
                 throw new Error(`Match expects Variant type, got ${printTypeValue(variantInfo.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Expand recursive types to get well-formed variant type
             const variantType = expandTypeValue(variantInfo.value.type);
             if (variantType.type !== "Variant") {
                 throw new Error(`Expanded Match variant type is not Variant, got ${printTypeValue(variantType)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // Validate case count matches
             if (variantType.value.length !== node.value.cases.length) {
                 throw new Error(`Match has ${node.value.cases.length} cases but variant type has ` +
                     `${variantType.value.length} cases ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             isAsync = variantInfo.value.isAsync;
             let allCasesNever = true;
@@ -1126,13 +1186,13 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
                 const typeCase = variantType.value.find((c) => c.name === matchCase.case);
                 if (!typeCase) {
                     throw new Error(`Match has case ${matchCase.case} but variant type does not ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
                 // Validate variable type matches case type
                 if (!isTypeValueEqual(matchCase.variable.value.type, typeCase.type)) {
                     throw new Error(`Match case ${matchCase.case} variable has type ${printTypeValue(matchCase.variable.value.type)} ` +
                         `but variant case has type ${printTypeValue(typeCase.type)} ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
                 // Analyze the variable VariableIR node
                 analysis.set(matchCase.variable, {
@@ -1159,41 +1219,93 @@ export function analyzeIR(ir, platformDef, ctx = {}) {
                 if (bodyInfo.value.type.type !== "Never" && !isTypeValueEqual(bodyInfo.value.type, node.value.type)) {
                     throw new Error(`Match case ${matchCase.case} returns type ${printTypeValue(bodyInfo.value.type)} ` +
                         `but Match expects ${printTypeValue(node.value.type)} ` +
-                        `at ${printLocationValue(node.value.location)}`);
+                        `at loc_id ${node.value.loc_id}`);
                 }
             }
             // If all cases diverge, Match must be Never
             if (allCasesNever && node.value.type.type !== "Never") {
                 throw new Error(`Match has all cases returning Never, so it must have type Never, ` +
                     `but has type ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `at loc_id ${node.value.loc_id}`);
             }
             // isAsync already set from loop above
         }
         else if (node.type === "UnwrapRecursive") {
             // Visit the value expression
             const valueInfo = visit(node.value.value, ctx, expectedReturnType);
-            // Validate result type matches expanded type
-            if (valueInfo.value.type.type !== "Never" && !isTypeValueEqual(node.value.type, valueInfo.value.type)) {
+            // Validate result type matches expanded type.
+            // The value type may be Recursive(wrapper({id, inner})) — unwrap for comparison.
+            const inputType = valueInfo.value.type.type === "Recursive" && valueInfo.value.type.value.type === "wrapper"
+                ? valueInfo.value.type.value.value.inner : valueInfo.value.type;
+            if (inputType.type !== "Never" && !isTypeValueEqual(node.value.type, inputType)) {
                 throw new Error(`UnwrapRecursive result type ${printTypeValue(node.value.type)} ` +
-                    `does not match recursive type ${printTypeValue(valueInfo.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `does not match recursive type ${printTypeValue(inputType)} ` +
+                    `at loc_id ${node.value.loc_id}`);
             }
             isAsync = valueInfo.value.isAsync;
         }
         else if (node.type === "WrapRecursive") {
             // Visit the value expression
             const valueInfo = visit(node.value.value, ctx, expectedReturnType);
-            // Validate value type matches expanded recursive type
-            if (valueInfo.value.type.type !== "Never" && !isTypeValueEqual(valueInfo.value.type, node.value.type)) {
+            // Validate value type matches the inner type of the recursive wrapper.
+            // node.value.type is Recursive(wrapper({id, inner})) — the value has the inner type.
+            const expectedType = node.value.type.type === "Recursive" && node.value.type.value.type === "wrapper"
+                ? node.value.type.value.value.inner : node.value.type;
+            if (valueInfo.value.type.type !== "Never" && !isTypeValueEqual(valueInfo.value.type, expectedType)) {
                 throw new Error(`WrapRecursive value has type ${printTypeValue(valueInfo.value.type)} ` +
-                    `but expects ${printTypeValue(node.value.type)} ` +
-                    `at ${printLocationValue(node.value.location)}`);
+                    `but expects ${printTypeValue(expectedType)} ` +
+                    `at loc_id ${node.value.loc_id}`);
             }
             isAsync = valueInfo.value.isAsync;
         }
+        else if (node.type === "NewVector") {
+            // Validate type is Vector
+            if (node.value.type.type !== "Vector") {
+                throw new Error(`NewVector node must have Vector type, got ${printTypeValue(node.value.type)} ` +
+                    `at loc_id ${node.value.loc_id}`);
+            }
+            const elementType = node.value.type.value;
+            isAsync = false;
+            // Visit all element values and validate types
+            for (let i = 0; i < node.value.values.length; i++) {
+                const valueExpr = node.value.values[i];
+                const valueInfo = visit(valueExpr, ctx, expectedReturnType);
+                if (valueInfo.value.isAsync) {
+                    isAsync = true;
+                }
+                // Validate element type exactly matches
+                if (valueInfo.value.type.type !== "Never" && !isTypeValueEqual(valueInfo.value.type, elementType)) {
+                    throw new Error(`Vector element ${i} has type ${printTypeValue(valueInfo.value.type)} ` +
+                        `but vector expects ${printTypeValue(elementType)} ` +
+                        `at loc_id ${node.value.loc_id}`);
+                }
+            }
+        }
+        else if (node.type === "NewMatrix") {
+            // Validate type is Matrix
+            if (node.value.type.type !== "Matrix") {
+                throw new Error(`NewMatrix node must have Matrix type, got ${printTypeValue(node.value.type)} ` +
+                    `at loc_id ${node.value.loc_id}`);
+            }
+            const elementType = node.value.type.value;
+            isAsync = false;
+            // Visit all element values and validate types
+            for (let i = 0; i < node.value.values.length; i++) {
+                const valueExpr = node.value.values[i];
+                const valueInfo = visit(valueExpr, ctx, expectedReturnType);
+                if (valueInfo.value.isAsync) {
+                    isAsync = true;
+                }
+                // Validate element type exactly matches
+                if (valueInfo.value.type.type !== "Never" && !isTypeValueEqual(valueInfo.value.type, elementType)) {
+                    throw new Error(`Matrix element ${i} has type ${printTypeValue(valueInfo.value.type)} ` +
+                        `but matrix expects ${printTypeValue(elementType)} ` +
+                        `at loc_id ${node.value.loc_id}`);
+                }
+            }
+        }
         else {
-            throw new Error(`Unhandled IR type: ${node.type} at ${printLocationValue(node.value?.location || { file: "unknown", line: 0, column: 0 })}`);
+            throw new Error(`Unhandled IR type: ${node.type} at loc_id ${node.value?.loc_id ?? -1n}`);
         }
         return {
             ...node,