@elaraai/east 0.0.1-beta.9 → 1.0.0

package/dist/src/ast_to_ir.js

@@ -1,24 +1,89 @@
-import { printLocationValue } from "./ir.js";
-import { printLocation } from "./location.js";
 import { toEastTypeValue } from "./type_of_type.js";
-import { ArrayType, DictType, FunctionType, isSubtype, isTypeEqual, NeverType, NullType, printType, RefType, SetType, StructType, VariantType } from "./types.js";
+import { ArrayType, DictType, FunctionType, getTypeId, isSubtype, isTypeEqual, NeverType, NullType, printType, RefType, SetType, StructType, VariantType, VectorType, MatrixType } from "./types.js";
 import { variant } from "./containers/variant.js";
 import { applyTypeParameters, Builtins } from "./builtins.js";
 /** @internal An exception throw for the purpose of early loop continue */
 export class OutOfScopeException extends Error {
     definedLocation;
     constructor(definedLocation) {
-        super(`Variable defined at ${printLocation(definedLocation)} is out of scope here`);
+        super(`Variable defined at loc_id ${definedLocation} is out of scope here`);
         this.definedLocation = definedLocation;
     }
 }
-// TODO we should probably redo type checking exhaustively here?
-function toLocationValue(location) {
-    return {
-        filename: location.filename,
-        line: BigInt(location.line),
-        column: BigInt(location.column),
-    };
+/**
+ * Coerce an IR value from `source_type` to `target_type`. When both are
+ * `StructType` or both are `VariantType` AND `value_ir` is the matching
+ * literal shape (a `Struct` / `Variant` IR node), recursively rewrite each
+ * child and rebuild the outer IR with the wider declared type — no outer
+ * `As` wrapper. Otherwise (primitives, variable references, invariant
+ * containers), emit a single outer `As`, matching legacy behaviour.
+ *
+ * Narrow→wide compound widening is only possible for Struct (covariant fields)
+ * and Variant (subset + covariant cases). All mutable-container parameters
+ * (Array/Set/Dict/Vector/Matrix/Ref) are invariant per isSubtypeImpl.
+ *
+ * @internal
+ */
+export function coerce_to(value_ir, source_type, target_type, loc_id, visited) {
+    if (isTypeEqual(source_type, target_type))
+        return value_ir;
+    if (!isSubtype(source_type, target_type)) {
+        throw new Error(`Cannot coerce value of type ${printType(source_type)} to ${printType(target_type)} at loc_id ${loc_id}`);
+    }
+    const sid = getTypeId(source_type);
+    const tid = getTypeId(target_type);
+    const pair_key = `${sid ?? "?"}:${tid ?? "?"}`;
+    if (visited !== undefined && visited.has(pair_key)) {
+        return variant("As", {
+            type: toEastTypeValue(target_type),
+            value: value_ir,
+            loc_id,
+        });
+    }
+    const visited2 = visited ?? new Set();
+    visited2.add(pair_key);
+    let s = source_type;
+    let t = target_type;
+    if (s.type === "Recursive")
+        s = s.node;
+    if (t.type === "Recursive")
+        t = t.node;
+    if (value_ir.type === "Struct" && s.type === "Struct" && t.type === "Struct") {
+        const s_fields = s.fields;
+        const t_fields = t.fields;
+        const new_fields = value_ir.value.fields.map(({ name, value: field_ir }) => {
+            const s_field = s_fields[name];
+            const t_field = t_fields[name];
+            if (s_field === undefined || t_field === undefined) {
+                return { name, value: field_ir };
+            }
+            return { name, value: coerce_to(field_ir, s_field, t_field, loc_id, visited2) };
+        });
+        return variant("Struct", {
+            type: toEastTypeValue(target_type),
+            loc_id: value_ir.value.loc_id,
+            fields: new_fields,
+        });
+    }
+    if (value_ir.type === "Variant" && s.type === "Variant" && t.type === "Variant") {
+        const case_name = value_ir.value.case;
+        const s_case = s.cases[case_name];
+        const t_case = t.cases[case_name];
+        const inner = (s_case !== undefined && t_case !== undefined)
+            ? coerce_to(value_ir.value.value, s_case, t_case, loc_id, visited2)
+            : value_ir.value.value;
+        return variant("Variant", {
+            type: toEastTypeValue(target_type),
+            loc_id: value_ir.value.loc_id,
+            case: case_name,
+            value: inner,
+        });
+    }
+    return variant("As", {
+        type: toEastTypeValue(target_type),
+        value: value_ir,
+        loc_id,
+    });
 }
 /** Perform scope resolution and type checking on `AST`, produce `IR` ready for serialization, compilation or evaluation.
 *
@@ -37,7 +102,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
                     return ir;
                 }
                 else {
-                    throw new OutOfScopeException(ast.location);
+                    throw new OutOfScopeException(ast.loc_id);
                 }
             }
         }
@@ -47,30 +112,22 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             const variable = variant("Variable", {
                 type: toEastTypeValue(ast.variable.type),
                 name: `_${ctx.n_vars}`,
-                location: toLocationValue(ast.variable.location),
+                loc_id: ast.variable.loc_id,
                 mutable: ast.variable.mutable,
                 captured: false,
             });
-            // Insert As node if value type doesn't exactly match variable type
-            // This ensures the IR has exact types everywhere
             if (!isTypeEqual(ast.value.type, ast.variable.type)) {
-                // Validate subtype relationship before inserting As node
-                // This catches type errors early at AST level
                 if (!isSubtype(ast.value.type, ast.variable.type)) {
                     throw new Error(`Cannot initialize variable of type ${printType(ast.variable.type)} ` +
-                        `with value of type ${printType(ast.value.type)} at ${printLocation(ast.location)}`);
+                        `with value of type ${printType(ast.value.type)} at loc_id ${ast.loc_id}`);
                 }
-                value = variant("As", {
-                    type: toEastTypeValue(ast.variable.type),
-                    value,
-                    location: toLocationValue(ast.location),
-                });
+                value = coerce_to(value, ast.value.type, ast.variable.type, ast.loc_id);
             }
             ctx.n_vars += 1;
             ctx.local_ctx.set(ast.variable, variable);
             return variant("Let", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 variable,
                 value,
             });
@@ -79,28 +136,19 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             // Fetch the variable from context
             const variable = ast_to_ir(ast.variable, ctx);
             if (!variable.value.mutable) {
-                throw new Error(`Variable defined const at ${printLocationValue(variable.value.location)} is being reassigned at ${printLocation(ast.location)}`);
+                throw new Error(`Variable defined const at loc_id ${variable.value.loc_id} is being reassigned at loc_id ${ast.loc_id}`);
             }
             let value = ast_to_ir(ast.value, ctx);
-            // Get the variable's type from the IR node
-            const variableType = variable.value.type;
-            // Insert As node if value type doesn't exactly match variable type
-            // This ensures the IR has exact types everywhere
             if (!isTypeEqual(ast.value.type, ast.variable.type)) {
-                // Validate subtype relationship before inserting As node
                 if (!isSubtype(ast.value.type, ast.variable.type)) {
                     throw new Error(`Cannot assign value of type ${printType(ast.value.type)} ` +
-                        `to variable of type ${printType(ast.variable.type)} at ${printLocation(ast.location)}`);
+                        `to variable of type ${printType(ast.variable.type)} at loc_id ${ast.loc_id}`);
                 }
-                value = variant("As", {
-                    type: variableType,
-                    value,
-                    location: toLocationValue(ast.location),
-                });
+                value = coerce_to(value, ast.value.type, ast.variable.type, ast.loc_id);
             }
             return variant("Assign", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 variable,
                 value,
             });
@@ -113,7 +161,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             ctx.n_loops = ctx2.n_loops;
             return variant("Block", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 statements,
             });
         }
@@ -122,33 +170,28 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             const builtin_name = ast.builtin;
             const builtin_def = Builtins[builtin_name];
             if (!builtin_def) {
-                throw new Error(`Unknown builtin function '${builtin_name}' at ${printLocation(ast.location)}`);
+                throw new Error(`Unknown builtin function '${builtin_name}' at loc_id ${ast.loc_id}`);
             }
             if (builtin_def.type_parameters.length !== ast.type_parameters.length) {
-                throw new Error(`Builtin function '${builtin_name}' expected ${builtin_def.type_parameters.length} type parameters, got ${ast.type_parameters.length} at ${printLocation(ast.location)}`);
+                throw new Error(`Builtin function '${builtin_name}' expected ${builtin_def.type_parameters.length} type parameters, got ${ast.type_parameters.length} at loc_id ${ast.loc_id}`);
             }
             const type_map = new Map(builtin_def.type_parameters.map((name, i) => [name, ast.type_parameters[i]]));
             if (ast.arguments.length !== builtin_def.inputs.length) {
-                throw new Error(`Builtin function '${builtin_name}' expected ${builtin_def.inputs.length} arguments, got ${ast.arguments.length} at ${printLocation(ast.location)}`);
+                throw new Error(`Builtin function '${builtin_name}' expected ${builtin_def.inputs.length} arguments, got ${ast.arguments.length} at loc_id ${ast.loc_id}`);
             }
             return variant("Builtin", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 builtin: ast.builtin,
                 type_parameters: ast.type_parameters.map(tp => toEastTypeValue(tp)),
                 arguments: ast.arguments.map((arg, i) => {
                     let arg_ir = ast_to_ir(arg, ctx);
                     const expectedType = applyTypeParameters(builtin_def.inputs[i], type_map, [], []);
-                    // Now check type compatibility
                     if (arg.type.type !== "Never" && !isTypeEqual(arg.type, expectedType)) {
                         if (!isSubtype(arg.type, expectedType)) {
-                            throw new Error(`Builtin ${builtin_name} with type parameters [${ast.type_parameters.map(tp => printType(tp)).join(", ")}] argument ${i} of type ${printType(arg.type)} is not compatible with expected type ${printType(expectedType)} at ${printLocation(ast.location)}`);
+                            throw new Error(`Builtin ${builtin_name} with type parameters [${ast.type_parameters.map(tp => printType(tp)).join(", ")}] argument ${i} of type ${printType(arg.type)} is not compatible with expected type ${printType(expectedType)} at loc_id ${ast.loc_id}`);
                         }
-                        arg_ir = variant("As", {
-                            type: toEastTypeValue(arg.type),
-                            value: arg_ir,
-                            location: toLocationValue(ast.location),
-                        });
+                        arg_ir = coerce_to(arg_ir, arg.type, expectedType, ast.loc_id);
                     }
                     return arg_ir;
                 }),
@@ -156,37 +199,35 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
         }
         else if (ast.ast_type === "Platform") {
             if (ctx.async === false && ast.async === true) {
-                throw new Error(`Async platform call not allowed outside async function at ${printLocation(ast.location)}`);
+                throw new Error(`Async platform call not allowed outside async function at loc_id ${ast.loc_id}`);
             }
             return variant("Platform", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 name: ast.name,
+                type_parameters: ast.type_parameters.map(tp => toEastTypeValue(tp)),
                 arguments: ast.arguments.map(ast => ast_to_ir(ast, ctx)), // type equality handled at Expr/AST level
                 async: ast.async,
+                optional: ast.optional,
             });
         }
         else if (ast.ast_type === "Struct") {
             return variant("Struct", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 fields: Object.entries(ast.fields).map(([name, fieldAst]) => {
                     let value = ast_to_ir(fieldAst, ctx);
                     const expectedType = ast.type.fields[name];
                     if (!expectedType) {
-                        throw new Error(`Struct type does not have field '${name}' at ${printLocation(ast.location)}`);
+                        throw new Error(`Struct type does not have field '${name}' at loc_id ${ast.loc_id}`);
                     }
                     if (!isTypeEqual(fieldAst.type, expectedType)) {
                         if (isSubtype(fieldAst.type, expectedType)) {
-                            value = variant("As", {
-                                type: toEastTypeValue(expectedType),
-                                value,
-                                location: toLocationValue(ast.location),
-                            });
+                            value = coerce_to(value, fieldAst.type, expectedType, ast.loc_id);
                         }
                         else {
                             throw new Error(`Cannot assign field '${name}' of type ${printType(ast.type.fields[name])} ` +
-                                `with value of type ${printType(fieldAst.type)} at ${printLocation(ast.location)}`);
+                                `with value of type ${printType(fieldAst.type)} at loc_id ${ast.loc_id}`);
                         }
                     }
                     return { name, value };
@@ -196,7 +237,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
         else if (ast.ast_type === "GetField") {
             return variant("GetField", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 struct: ast_to_ir(ast.struct, ctx),
                 field: ast.field,
             });
@@ -206,20 +247,16 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             let value = ast_to_ir(ast.value, ctx);
             if (!isTypeEqual(ast.value.type, expectedType)) {
                 if (isSubtype(ast.value.type, expectedType)) {
-                    value = variant("As", {
-                        type: toEastTypeValue(expectedType),
-                        value,
-                        location: toLocationValue(ast.location),
-                    });
+                    value = coerce_to(value, ast.value.type, expectedType, ast.loc_id);
                 }
                 else {
                     throw new Error(`Cannot assign case '${ast.case}' of type ${printType(expectedType)} ` +
-                        `with value of type ${printType(ast.value.type)} at ${printLocation(ast.location)}`);
+                        `with value of type ${printType(ast.value.type)} at loc_id ${ast.loc_id}`);
                 }
             }
             return variant("Variant", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 case: ast.case,
                 value,
             });
@@ -229,7 +266,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
                 const param = variant("Variable", {
                     type: toEastTypeValue(parameter.type),
                     name: `_${ctx.n_vars}`,
-                    location: toLocationValue(parameter.location),
+                    loc_id: parameter.loc_id,
                     mutable: parameter.mutable, // false...
                     captured: false,
                 });
@@ -243,9 +280,21 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             const body = ast_to_ir(ast.body, ctx2);
             ctx.n_vars = ctx2.n_vars;
             ctx.n_loops = ctx2.n_loops;
+            // Propagate captures: if this function captured something from ctx.parent_ctx,
+            // then the enclosing function also needs to capture it
+            for (const capturedVar of captures) {
+                // Check if this variable came from our parent context (not defined locally in enclosing function)
+                for (const [_astVar, ir] of ctx.parent_ctx) {
+                    if (ir === capturedVar) {
+                        // This capture came from an outer scope, so enclosing function must also capture it
+                        ctx.captures.add(capturedVar);
+                        break;
+                    }
+                }
+            }
             return variant("Function", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 parameters,
                 captures: [...captures],
                 body,
@@ -256,7 +305,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
                 const param = variant("Variable", {
                     type: toEastTypeValue(parameter.type),
                     name: `_${ctx.n_vars}`,
-                    location: toLocationValue(parameter.location),
+                    loc_id: parameter.loc_id,
                     mutable: parameter.mutable, // false...
                     captured: false,
                 });
@@ -270,9 +319,21 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             const body = ast_to_ir(ast.body, ctx2);
             ctx.n_vars = ctx2.n_vars;
             ctx.n_loops = ctx2.n_loops;
+            // Propagate captures: if this function captured something from ctx.parent_ctx,
+            // then the enclosing function also needs to capture it
+            for (const capturedVar of captures) {
+                // Check if this variable came from our parent context (not defined locally in enclosing function)
+                for (const [_astVar, ir] of ctx.parent_ctx) {
+                    if (ir === capturedVar) {
+                        // This capture came from an outer scope, so enclosing function must also capture it
+                        ctx.captures.add(capturedVar);
+                        break;
+                    }
+                }
+            }
             return variant("AsyncFunction", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 parameters,
                 captures: [...captures],
                 body,
@@ -283,20 +344,16 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             // TODO - what about widening the result with As?
             return variant("Call", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 function: ast_to_ir(ast.function, ctx),
                 arguments: ast.arguments.map((argument, i) => {
                     let arg = ast_to_ir(argument, ctx);
                     const expectedType = ast.function.type.inputs[i];
                     if (!isTypeEqual(argument.type, expectedType)) {
                         if (!isSubtype(argument.type, expectedType)) {
-                            throw new Error(`Argument ${i} of type ${printType(argument.type)} is not compatible with expected type ${printType(expectedType)} at ${printLocation(ast.location)}`);
+                            throw new Error(`Argument ${i} of type ${printType(argument.type)} is not compatible with expected type ${printType(expectedType)} at loc_id ${ast.loc_id}`);
                         }
-                        arg = variant("As", {
-                            type: toEastTypeValue(expectedType),
-                            value: arg,
-                            location: toLocationValue(ast.location),
-                        });
+                        arg = coerce_to(arg, argument.type, expectedType, ast.loc_id);
                     }
                     return arg;
                 }),
@@ -304,26 +361,22 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
         }
         else if (ast.ast_type === "CallAsync") {
             if (ctx.async === false) {
-                throw new Error(`Async function call not allowed outside async function at ${printLocation(ast.location)}`);
+                throw new Error(`Async function call not allowed outside async function at loc_id ${ast.loc_id}`);
             }
             // TODO - type equality could have been handled at Expr/AST level instead
             // TODO - what about widening the result with As?
             return variant("CallAsync", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 function: ast_to_ir(ast.function, ctx),
                 arguments: ast.arguments.map((argument, i) => {
                     let arg = ast_to_ir(argument, ctx);
                     const expectedType = ast.function.type.inputs[i];
                     if (!isTypeEqual(argument.type, expectedType)) {
                         if (!isSubtype(argument.type, expectedType)) {
-                            throw new Error(`Argument ${i} of type ${printType(argument.type)} is not compatible with expected type ${printType(expectedType)} at ${printLocation(ast.location)}`);
+                            throw new Error(`Argument ${i} of type ${printType(argument.type)} is not compatible with expected type ${printType(expectedType)} at loc_id ${ast.loc_id}`);
                         }
-                        arg = variant("As", {
-                            type: toEastTypeValue(expectedType),
-                            value: arg,
-                            location: toLocationValue(ast.location),
-                        });
+                        arg = coerce_to(arg, argument.type, expectedType, ast.loc_id);
                     }
                     return arg;
                 }),
@@ -334,17 +387,13 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             let value = ast_to_ir(ast.value, ctx);
             if (!isTypeEqual(ast.value.type, valueType)) {
                 if (!isSubtype(ast.value.type, valueType)) {
-                    throw new Error(`Ref value of type ${printType(ast.value.type)} is not compatible with expected type ${printType(valueType)} at ${printLocation(ast.location)}`);
+                    throw new Error(`Ref value of type ${printType(ast.value.type)} is not compatible with expected type ${printType(valueType)} at loc_id ${ast.loc_id}`);
                 }
-                value = variant("As", {
-                    type: toEastTypeValue(valueType),
-                    value,
-                    location: toLocationValue(ast.location),
-                });
+                value = coerce_to(value, ast.value.type, valueType, ast.loc_id);
             }
             return variant("NewRef", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 value,
             });
         }
@@ -352,18 +401,14 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             const valueType = ast.type.value;
             return variant("NewArray", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 values: ast.values.map((v, i) => {
                     let value = ast_to_ir(v, ctx);
                     if (!isTypeEqual(v.type, valueType)) {
                         if (!isSubtype(v.type, valueType)) {
-                            throw new Error(`Array value at entry ${i} of type ${printType(v.type)} is not compatible with expected type ${printType(valueType)} at ${printLocation(ast.location)}`);
+                            throw new Error(`Array value at entry ${i} of type ${printType(v.type)} is not compatible with expected type ${printType(valueType)} at loc_id ${ast.loc_id}`);
                         }
-                        value = variant("As", {
-                            type: toEastTypeValue(valueType),
-                            value,
-                            location: toLocationValue(ast.location),
-                        });
+                        value = coerce_to(value, v.type, valueType, ast.loc_id);
                     }
                     return value;
                 }),
@@ -373,18 +418,14 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             const keyType = ast.type.key;
             return variant("NewSet", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 values: ast.values.map((k, i) => {
                     let key = ast_to_ir(k, ctx);
                     if (!isTypeEqual(k.type, keyType)) {
                         if (!isSubtype(k.type, keyType)) {
-                            throw new Error(`Set key at entry ${i} of type ${printType(k.type)} is not compatible with expected type ${printType(keyType)} at ${printLocation(ast.location)}`);
+                            throw new Error(`Set key at entry ${i} of type ${printType(k.type)} is not compatible with expected type ${printType(keyType)} at loc_id ${ast.loc_id}`);
                         }
-                        key = variant("As", {
-                            type: toEastTypeValue(keyType),
-                            value: key,
-                            location: toLocationValue(ast.location),
-                        });
+                        key = coerce_to(key, k.type, keyType, ast.loc_id);
                     }
                     return key;
                 }),
@@ -395,29 +436,21 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             const valueType = ast.type.value;
             return variant("NewDict", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 values: ast.values.map(([k, v], i) => {
                     let key = ast_to_ir(k, ctx);
                     if (!isTypeEqual(k.type, keyType)) {
                         if (!isSubtype(k.type, keyType)) {
-                            throw new Error(`Dict key at entry ${i} of type ${printType(k.type)} is not compatible with expected type ${printType(keyType)} at ${printLocation(ast.location)}`);
+                            throw new Error(`Dict key at entry ${i} of type ${printType(k.type)} is not compatible with expected type ${printType(keyType)} at loc_id ${ast.loc_id}`);
                         }
-                        key = variant("As", {
-                            type: toEastTypeValue(keyType),
-                            value: key,
-                            location: toLocationValue(ast.location),
-                        });
+                        key = coerce_to(key, k.type, keyType, ast.loc_id);
                     }
                     let value = ast_to_ir(v, ctx);
                     if (!isTypeEqual(v.type, valueType)) {
                         if (!isSubtype(v.type, valueType)) {
-                            throw new Error(`Dict value at entry ${i} of type ${printType(v.type)} is not compatible with expected type ${printType(valueType)} at ${printLocation(ast.location)}`);
+                            throw new Error(`Dict value at entry ${i} of type ${printType(v.type)} is not compatible with expected type ${printType(valueType)} at loc_id ${ast.loc_id}`);
                         }
-                        value = variant("As", {
-                            type: toEastTypeValue(valueType),
-                            value,
-                            location: toLocationValue(ast.location),
-                        });
+                        value = coerce_to(value, v.type, valueType, ast.loc_id);
                     }
                     ;
                     return { key, value };
@@ -443,13 +476,9 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
                 ctx.n_loops = ctx_branch.n_loops;
                 if (branch.body.type.type !== "Never" && !isTypeEqual(branch.body.type, ast.type)) {
                     if (!isSubtype(branch.body.type, ast.type)) {
-                        throw new Error(`If branch body of type ${printType(branch.body.type)} is not compatible with expected type ${printType(ast.type)} at ${printLocation(ast.location)}`);
+                        throw new Error(`If branch body of type ${printType(branch.body.type)} is not compatible with expected type ${printType(ast.type)} at loc_id ${ast.loc_id}`);
                     }
-                    branch_body = variant("As", {
-                        type: toEastTypeValue(ast.type),
-                        value: branch_body,
-                        location: toLocationValue(ast.location),
-                    });
+                    branch_body = coerce_to(branch_body, branch.body.type, ast.type, ast.loc_id);
                 }
                 return { predicate, body: branch_body };
             });
@@ -469,17 +498,13 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             ctx.n_loops = ctx_else.n_loops;
             if (ast.else_body.type.type !== "Never" && !isTypeEqual(ast.else_body.type, ast.type)) {
                 if (!isSubtype(ast.else_body.type, ast.type)) {
-                    throw new Error(`Else branch body of type ${printType(ast.else_body.type)} is not compatible with expected type ${printType(ast.type)} at ${printLocation(ast.location)}`);
+                    throw new Error(`Else branch body of type ${printType(ast.else_body.type)} is not compatible with expected type ${printType(ast.type)} at loc_id ${ast.loc_id}`);
                 }
-                else_body = variant("As", {
-                    type: toEastTypeValue(ast.type),
-                    value: else_body,
-                    location: toLocationValue(ast.location),
-                });
+                else_body = coerce_to(else_body, ast.else_body.type, ast.type, ast.loc_id);
             }
             return variant("IfElse", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 ifs,
                 else_body,
             });
@@ -487,7 +512,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
         else if (ast.ast_type === "Error") {
             return variant("Error", {
                 type: variant("Never", null),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 message: ast_to_ir(ast.message, ctx),
             });
         }
@@ -510,7 +535,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             const message = variant("Variable", {
                 type: toEastTypeValue(ast.message.type),
                 name: `_${ctx.n_vars}`,
-                location: toLocationValue(ast.message.location),
+                loc_id: ast.message.loc_id,
                 mutable: ast.message.mutable, // false...
                 captured: false,
             });
@@ -518,7 +543,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             const stack = variant("Variable", {
                 type: toEastTypeValue(ast.stack.type),
                 name: `_${ctx.n_vars}`,
-                location: toLocationValue(ast.stack.location),
+                loc_id: ast.stack.loc_id,
                 mutable: ast.stack.mutable, // false...
                 captured: false,
             });
@@ -558,13 +583,13 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             else {
                 finally_body = variant("Value", {
                     type: toEastTypeValue(NullType),
-                    location: toLocationValue(ast.location),
+                    loc_id: ast.loc_id,
                     value: variant("Null", null),
                 });
             }
             return variant("TryCatch", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 try_body,
                 catch_body,
                 message,
@@ -600,26 +625,24 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
                 throw new Error(`Unsupported literal value type: ${typeof ast.value} (expected ${printType(ast.type)})`);
             }
             if (type.type !== value.type) {
-                throw new Error(`Literal value type mismatch at ${printLocation(ast.location)}: expected .${type.type} but got .${value.type}`);
+                throw new Error(`Literal value type mismatch at loc_id ${ast.loc_id}: expected .${type.type} but got .${value.type}`);
             }
             return variant("Value", {
                 type,
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 value,
             });
         }
         else if (ast.ast_type === "As") {
-            return variant("As", {
-                type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
-                value: ast_to_ir(ast.value, ctx),
-            });
+            // Explicit $.as: use coerce_to so nested narrow variants in a literal
+            // struct/variant get deep-rewritten just like implicit widening.
+            return coerce_to(ast_to_ir(ast.value, ctx), ast.value.type, ast.type, ast.loc_id);
         }
         else if (ast.ast_type === "While") {
             const predicate = ast_to_ir(ast.predicate, ctx);
             const label = {
                 name: `_${ctx.n_loops}`,
-                location: toLocationValue(ast.label.location),
+                loc_id: ast.label.loc_id,
             };
             ctx.n_loops += 1;
             const ctx2 = {
@@ -638,7 +661,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             ctx.n_loops = ctx2.n_loops;
             return variant("While", {
                 type: variant("Null", null),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 label,
                 predicate,
                 body,
@@ -648,13 +671,13 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             const array = ast_to_ir(ast.array, ctx);
             const label = {
                 name: `_${ctx.n_loops}`,
-                location: toLocationValue(ast.label.location),
+                loc_id: ast.label.loc_id,
             };
             ctx.n_loops += 1;
             const value = variant("Variable", {
                 type: toEastTypeValue(ast.value.type),
                 name: `_${ctx.n_vars}`,
-                location: toLocationValue(ast.value.location),
+                loc_id: ast.value.loc_id,
                 mutable: ast.value.mutable, // false...
                 captured: false,
             });
@@ -662,7 +685,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             const key = variant("Variable", {
                 type: toEastTypeValue(ast.key.type),
                 name: `_${ctx.n_vars}`,
-                location: toLocationValue(ast.key.location),
+                loc_id: ast.key.loc_id,
                 mutable: ast.key.mutable, // false...
                 captured: false,
             });
@@ -683,7 +706,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             ctx.n_loops = ctx2.n_loops;
             return variant("ForArray", {
                 type: variant("Null", null),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 label,
                 key,
                 value,
@@ -695,13 +718,13 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             const set = ast_to_ir(ast.set, ctx);
             const label = {
                 name: `_${ctx.n_loops}`,
-                location: toLocationValue(ast.label.location),
+                loc_id: ast.label.loc_id,
             };
             ctx.n_loops += 1;
             const key = variant("Variable", {
                 type: toEastTypeValue(ast.key.type),
                 name: `_${ctx.n_vars}`,
-                location: toLocationValue(ast.key.location),
+                loc_id: ast.key.loc_id,
                 mutable: ast.key.mutable, // false...
                 captured: false,
             });
@@ -722,7 +745,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             ctx.n_loops = ctx2.n_loops;
             return variant("ForSet", {
                 type: variant("Null", null),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 label,
                 key,
                 set,
@@ -733,13 +756,13 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             const dict = ast_to_ir(ast.dict, ctx);
             const label = {
                 name: `_${ctx.n_loops}`,
-                location: toLocationValue(ast.label.location),
+                loc_id: ast.label.loc_id,
             };
             ctx.n_loops += 1;
             const value = variant("Variable", {
                 type: toEastTypeValue(ast.value.type),
                 name: `_${ctx.n_vars}`,
-                location: toLocationValue(ast.value.location),
+                loc_id: ast.value.loc_id,
                 mutable: ast.value.mutable, // false...
                 captured: false,
             });
@@ -747,7 +770,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             const key = variant("Variable", {
                 type: toEastTypeValue(ast.key.type),
                 name: `_${ctx.n_vars}`,
-                location: toLocationValue(ast.key.location),
+                loc_id: ast.key.loc_id,
                 mutable: ast.key.mutable, // false...
                 captured: false,
             });
@@ -768,7 +791,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             ctx.n_loops = ctx2.n_loops;
             return variant("ForDict", {
                 type: variant("Null", null),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 label,
                 key,
                 value,
@@ -783,7 +806,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
                 const variable = variant("Variable", {
                     type: toEastTypeValue(v.variable.type),
                     name: `_${ctx.n_vars}`,
-                    location: toLocationValue(v.variable.location),
+                    loc_id: v.variable.loc_id,
                     mutable: v.variable.mutable, // false...
                     captured: false,
                 });
@@ -804,19 +827,15 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
                 ctx.n_loops = ctx2.n_loops;
                 if (v.body.type.type !== "Never" && !isTypeEqual(v.body.type, ast.type)) {
                     if (!isSubtype(v.body.type, ast.type)) {
-                        throw new Error(`Match case '${k}' body of type ${printType(v.body.type)} is not compatible with expected type ${printType(ast.type)} at ${printLocation(ast.location)}`);
+                        throw new Error(`Match case '${k}' body of type ${printType(v.body.type)} is not compatible with expected type ${printType(ast.type)} at loc_id ${ast.loc_id}`);
                     }
-                    body = variant("As", {
-                        type: toEastTypeValue(ast.type),
-                        value: body,
-                        location: toLocationValue(ast.location),
-                    });
+                    body = coerce_to(body, v.body.type, ast.type, ast.loc_id);
                 }
                 cases.push({ case: k, variable, body });
             }
             return variant("Match", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 variant: variant_expr,
                 cases,
             });
@@ -824,7 +843,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
         else if (ast.ast_type === "UnwrapRecursive") {
             return variant("UnwrapRecursive", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 value: ast_to_ir(ast.value, ctx),
             });
         }
@@ -835,14 +854,14 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             }
             const existing = ctx.recursiveASTs.has(ast);
             if (existing) {
-                throw new Error(`Circular reference detected when converting AST to IR at ${printLocation(ast.location)}`);
+                throw new Error(`Circular reference detected when converting AST to IR at loc_id ${ast.loc_id}`);
             }
             // Register before recursing (enables cycle detection)
             ctx.recursiveASTs.add(ast);
             // Create WrapRecursive IR node with placeholder
             const wrapIR = variant("WrapRecursive", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 value: ast_to_ir(ast.value, ctx),
             });
             // The user may alias this AST value elsewhere in the tree, just not with a circular reference
@@ -852,35 +871,71 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
         else if (ast.ast_type === "Break") {
             const label = ctx.loop_ctx.get(ast.label);
             if (label === undefined) {
-                throw new Error(`Label defined at ${printLocation(ast.label.location)} is not in scope at break at ${printLocation(ast.location)}`);
+                throw new Error(`Label defined at loc_id ${ast.label.loc_id} is not in scope at break at loc_id ${ast.loc_id}`);
             }
             return variant("Break", {
                 type: variant("Never", null),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 label,
             });
         }
         else if (ast.ast_type === "Continue") {
             const label = ctx.loop_ctx.get(ast.label);
             if (label === undefined) {
-                throw new Error(`Label defined at ${printLocation(ast.label.location)} is not in scope at continue at ${printLocation(ast.location)}`);
+                throw new Error(`Label defined at loc_id ${ast.label.loc_id} is not in scope at continue at loc_id ${ast.loc_id}`);
             }
             return variant("Continue", {
                 type: variant("Never", null),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 label,
             });
         }
         else if (ast.ast_type === "Return") {
             if (!isSubtype(ast.value.type, ctx.output)) {
-                throw new Error(`Attempted to return value of type ${printType(ast.value.type)} at ${printLocation(ast.location)}, but function expected return type of ${printType(ctx.output)}`);
+                throw new Error(`Attempted to return value of type ${printType(ast.value.type)} at loc_id ${ast.loc_id}, but function expected return type of ${printType(ctx.output)}`);
             }
             return variant("Return", {
                 type: variant("Never", null),
-                location: toLocationValue(ast.location),
+                loc_id: ast.loc_id,
                 value: ast_to_ir(ast.value, ctx),
             });
         }
+        else if (ast.ast_type === "NewVector") {
+            const elementType = ast.type.element;
+            return variant("NewVector", {
+                type: toEastTypeValue(ast.type),
+                loc_id: ast.loc_id,
+                values: ast.values.map((v, i) => {
+                    let value = ast_to_ir(v, ctx);
+                    if (!isTypeEqual(v.type, elementType)) {
+                        if (!isSubtype(v.type, elementType)) {
+                            throw new Error(`Vector value at entry ${i} of type ${printType(v.type)} is not compatible with expected type ${printType(elementType)} at loc_id ${ast.loc_id}`);
+                        }
+                        value = coerce_to(value, v.type, elementType, ast.loc_id);
+                    }
+                    return value;
+                }),
+            });
+        }
+        else if (ast.ast_type === "NewMatrix") {
+            const elementType = ast.type.element;
+            return variant("NewMatrix", {
+                type: toEastTypeValue(ast.type),
+                loc_id: ast.loc_id,
+                rows: BigInt(ast.rows),
+                cols: BigInt(ast.cols),
+                values: ast.values.map((v, i) => {
+                    let value = ast_to_ir(v, ctx);
+                    if (!isTypeEqual(v.type, elementType)) {
+                        if (!isSubtype(v.type, elementType)) {
+                            throw new Error(`Matrix value at entry ${i} of type ${printType(v.type)} is not compatible with expected type ${printType(elementType)} at loc_id ${ast.loc_id}`);
+                        }
+                        value = coerce_to(value, v.type, elementType, ast.loc_id);
+                    }
+                    return value;
+                }),
+            });
+        }
         else {
             throw new Error(`Cannot check ${ast.type}`);
         }
@@ -888,13 +943,13 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
     catch (e) {
         if (e instanceof Error) {
             if (ast.ast_type === "Builtin") {
-                e.message += `\n    at ${ast.ast_type} ${ast.builtin} node located at ${printLocation(ast.location)}`;
+                e.message += `\n    at ${ast.ast_type} ${ast.builtin} node located at loc_id ${ast.loc_id}`;
             }
             else if (ast.ast_type === "Platform") {
-                e.message += `\n    at ${ast.ast_type} ${ast.name} node located at ${printLocation(ast.location)}`;
+                e.message += `\n    at ${ast.ast_type} ${ast.name} node located at loc_id ${ast.loc_id}`;
             }
             else {
-                e.message += `\n    at ${ast.ast_type} node located at ${printLocation(ast.location)}`;
+                e.message += `\n    at ${ast.ast_type} node located at loc_id ${ast.loc_id}`;
             }
         }
         throw e;