@elaraai/east 0.0.1-beta.3 → 0.0.1-beta.31

package/dist/src/ast_to_ir.js

@@ -1,16 +1,24 @@
 import { printLocationValue } from "./ir.js";
-import { printLocation } from "./location.js";
+import { printLocations } 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 { 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 ${printLocations(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),
-    };
+function toLocationValues(locations) {
+    return locations.map(loc => ({
+        filename: loc.filename,
+        line: BigInt(loc.line),
+        column: BigInt(loc.column),
+    }));
 }
 /** Perform scope resolution and type checking on `AST`, produce `IR` ready for serialization, compilation or evaluation.
 *
@@ -29,7 +37,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
                     return ir;
                 }
                 else {
-                    throw new Error(`Variable defined at ${printLocation(ast.location)} not in scope`);
+                    throw new OutOfScopeException(ast.location);
                 }
             }
         }
@@ -39,7 +47,7 @@ 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),
+                location: toLocationValues(ast.variable.location),
                 mutable: ast.variable.mutable,
                 captured: false,
             });
@@ -50,19 +58,19 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
                 // 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 ${printLocations(ast.location)}`);
                 }
                 value = variant("As", {
                     type: toEastTypeValue(ast.variable.type),
                     value,
-                    location: toLocationValue(ast.location),
+                    location: toLocationValues(ast.location),
                 });
             }
             ctx.n_vars += 1;
             ctx.local_ctx.set(ast.variable, variable);
             return variant("Let", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                location: toLocationValues(ast.location),
                 variable,
                 value,
             });
@@ -71,7 +79,7 @@ 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 ${printLocationValue(variable.value.location)} is being reassigned at ${printLocations(ast.location)}`);
             }
             let value = ast_to_ir(ast.value, ctx);
             // Get the variable's type from the IR node
@@ -82,17 +90,17 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
                 // 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 ${printLocations(ast.location)}`);
                 }
                 value = variant("As", {
                     type: variableType,
                     value,
-                    location: toLocationValue(ast.location),
+                    location: toLocationValues(ast.location),
                 });
             }
             return variant("Assign", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                location: toLocationValues(ast.location),
                 variable,
                 value,
             });
@@ -105,7 +113,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),
+                location: toLocationValues(ast.location),
                 statements,
             });
         }
@@ -114,18 +122,18 @@ 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 ${printLocations(ast.location)}`);
             }
             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 ${printLocations(ast.location)}`);
             }
             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 ${printLocations(ast.location)}`);
             }
             return variant("Builtin", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                location: toLocationValues(ast.location),
                 builtin: ast.builtin,
                 type_parameters: ast.type_parameters.map(tp => toEastTypeValue(tp)),
                 arguments: ast.arguments.map((arg, i) => {
@@ -134,12 +142,12 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new 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 ${printLocations(ast.location)}`);
                         }
                         arg_ir = variant("As", {
-                            type: toEastTypeValue(arg.type),
+                            type: toEastTypeValue(expectedType),
                             value: arg_ir,
-                            location: toLocationValue(ast.location),
+                            location: toLocationValues(ast.location),
                         });
                     }
                     return arg_ir;
@@ -148,37 +156,39 @@ 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 ${printLocations(ast.location)}`);
             }
             return variant("Platform", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                location: toLocationValues(ast.location),
                 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),
+                location: toLocationValues(ast.location),
                 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 ${printLocations(ast.location)}`);
                     }
                     if (!isTypeEqual(fieldAst.type, expectedType)) {
                         if (isSubtype(fieldAst.type, expectedType)) {
                             value = variant("As", {
                                 type: toEastTypeValue(expectedType),
                                 value,
-                                location: toLocationValue(ast.location),
+                                location: toLocationValues(ast.location),
                             });
                         }
                         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 ${printLocations(ast.location)}`);
                         }
                     }
                     return { name, value };
@@ -188,7 +198,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),
+                location: toLocationValues(ast.location),
                 struct: ast_to_ir(ast.struct, ctx),
                 field: ast.field,
             });
@@ -201,17 +211,17 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
                     value = variant("As", {
                         type: toEastTypeValue(expectedType),
                         value,
-                        location: toLocationValue(ast.location),
+                        location: toLocationValues(ast.location),
                     });
                 }
                 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 ${printLocations(ast.location)}`);
                 }
             }
             return variant("Variant", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                location: toLocationValues(ast.location),
                 case: ast.case,
                 value,
             });
@@ -221,7 +231,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),
+                    location: toLocationValues(parameter.location),
                     mutable: parameter.mutable, // false...
                     captured: false,
                 });
@@ -235,9 +245,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),
+                location: toLocationValues(ast.location),
                 parameters,
                 captures: [...captures],
                 body,
@@ -248,7 +270,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),
+                    location: toLocationValues(parameter.location),
                     mutable: parameter.mutable, // false...
                     captured: false,
                 });
@@ -262,9 +284,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),
+                location: toLocationValues(ast.location),
                 parameters,
                 captures: [...captures],
                 body,
@@ -275,19 +309,19 @@ 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),
+                location: toLocationValues(ast.location),
                 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 ${printLocations(ast.location)}`);
                         }
                         arg = variant("As", {
                             type: toEastTypeValue(expectedType),
                             value: arg,
-                            location: toLocationValue(ast.location),
+                            location: toLocationValues(ast.location),
                         });
                     }
                     return arg;
@@ -296,25 +330,25 @@ 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 ${printLocations(ast.location)}`);
             }
             // 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),
+                location: toLocationValues(ast.location),
                 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 ${printLocations(ast.location)}`);
                         }
                         arg = variant("As", {
                             type: toEastTypeValue(expectedType),
                             value: arg,
-                            location: toLocationValue(ast.location),
+                            location: toLocationValues(ast.location),
                         });
                     }
                     return arg;
@@ -326,17 +360,17 @@ 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 ${printLocations(ast.location)}`);
                 }
                 value = variant("As", {
                     type: toEastTypeValue(valueType),
                     value,
-                    location: toLocationValue(ast.location),
+                    location: toLocationValues(ast.location),
                 });
             }
             return variant("NewRef", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                location: toLocationValues(ast.location),
                 value,
             });
         }
@@ -344,17 +378,17 @@ 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),
+                location: toLocationValues(ast.location),
                 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 ${printLocations(ast.location)}`);
                         }
                         value = variant("As", {
                             type: toEastTypeValue(valueType),
                             value,
-                            location: toLocationValue(ast.location),
+                            location: toLocationValues(ast.location),
                         });
                     }
                     return value;
@@ -365,17 +399,17 @@ 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),
+                location: toLocationValues(ast.location),
                 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 ${printLocations(ast.location)}`);
                         }
                         key = variant("As", {
                             type: toEastTypeValue(keyType),
                             value: key,
-                            location: toLocationValue(ast.location),
+                            location: toLocationValues(ast.location),
                         });
                     }
                     return key;
@@ -387,28 +421,28 @@ 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),
+                location: toLocationValues(ast.location),
                 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 ${printLocations(ast.location)}`);
                         }
                         key = variant("As", {
                             type: toEastTypeValue(keyType),
                             value: key,
-                            location: toLocationValue(ast.location),
+                            location: toLocationValues(ast.location),
                         });
                     }
                     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 ${printLocations(ast.location)}`);
                         }
                         value = variant("As", {
                             type: toEastTypeValue(valueType),
                             value,
-                            location: toLocationValue(ast.location),
+                            location: toLocationValues(ast.location),
                         });
                     }
                     ;
@@ -435,12 +469,12 @@ 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 ${printLocations(ast.location)}`);
                     }
                     branch_body = variant("As", {
                         type: toEastTypeValue(ast.type),
                         value: branch_body,
-                        location: toLocationValue(ast.location),
+                        location: toLocationValues(ast.location),
                     });
                 }
                 return { predicate, body: branch_body };
@@ -461,17 +495,17 @@ 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 ${printLocations(ast.location)}`);
                 }
                 else_body = variant("As", {
                     type: toEastTypeValue(ast.type),
                     value: else_body,
-                    location: toLocationValue(ast.location),
+                    location: toLocationValues(ast.location),
                 });
             }
             return variant("IfElse", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                location: toLocationValues(ast.location),
                 ifs,
                 else_body,
             });
@@ -479,7 +513,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),
+                location: toLocationValues(ast.location),
                 message: ast_to_ir(ast.message, ctx),
             });
         }
@@ -502,7 +536,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),
+                location: toLocationValues(ast.message.location),
                 mutable: ast.message.mutable, // false...
                 captured: false,
             });
@@ -510,7 +544,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),
+                location: toLocationValues(ast.stack.location),
                 mutable: ast.stack.mutable, // false...
                 captured: false,
             });
@@ -550,13 +584,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),
+                    location: toLocationValues(ast.location),
                     value: variant("Null", null),
                 });
             }
             return variant("TryCatch", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                location: toLocationValues(ast.location),
                 try_body,
                 catch_body,
                 message,
@@ -592,18 +626,18 @@ 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 ${printLocations(ast.location)}: expected .${type.type} but got .${value.type}`);
             }
             return variant("Value", {
                 type,
-                location: toLocationValue(ast.location),
+                location: toLocationValues(ast.location),
                 value,
             });
         }
         else if (ast.ast_type === "As") {
             return variant("As", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                location: toLocationValues(ast.location),
                 value: ast_to_ir(ast.value, ctx),
             });
         }
@@ -611,7 +645,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             const predicate = ast_to_ir(ast.predicate, ctx);
             const label = {
                 name: `_${ctx.n_loops}`,
-                location: toLocationValue(ast.label.location),
+                location: toLocationValues(ast.label.location),
             };
             ctx.n_loops += 1;
             const ctx2 = {
@@ -630,7 +664,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),
+                location: toLocationValues(ast.location),
                 label,
                 predicate,
                 body,
@@ -640,13 +674,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),
+                location: toLocationValues(ast.label.location),
             };
             ctx.n_loops += 1;
             const value = variant("Variable", {
                 type: toEastTypeValue(ast.value.type),
                 name: `_${ctx.n_vars}`,
-                location: toLocationValue(ast.value.location),
+                location: toLocationValues(ast.value.location),
                 mutable: ast.value.mutable, // false...
                 captured: false,
             });
@@ -654,7 +688,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),
+                location: toLocationValues(ast.key.location),
                 mutable: ast.key.mutable, // false...
                 captured: false,
             });
@@ -675,7 +709,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),
+                location: toLocationValues(ast.location),
                 label,
                 key,
                 value,
@@ -687,13 +721,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),
+                location: toLocationValues(ast.label.location),
             };
             ctx.n_loops += 1;
             const key = variant("Variable", {
                 type: toEastTypeValue(ast.key.type),
                 name: `_${ctx.n_vars}`,
-                location: toLocationValue(ast.key.location),
+                location: toLocationValues(ast.key.location),
                 mutable: ast.key.mutable, // false...
                 captured: false,
             });
@@ -714,7 +748,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),
+                location: toLocationValues(ast.location),
                 label,
                 key,
                 set,
@@ -725,13 +759,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),
+                location: toLocationValues(ast.label.location),
             };
             ctx.n_loops += 1;
             const value = variant("Variable", {
                 type: toEastTypeValue(ast.value.type),
                 name: `_${ctx.n_vars}`,
-                location: toLocationValue(ast.value.location),
+                location: toLocationValues(ast.value.location),
                 mutable: ast.value.mutable, // false...
                 captured: false,
             });
@@ -739,7 +773,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),
+                location: toLocationValues(ast.key.location),
                 mutable: ast.key.mutable, // false...
                 captured: false,
             });
@@ -760,7 +794,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),
+                location: toLocationValues(ast.location),
                 label,
                 key,
                 value,
@@ -775,7 +809,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),
+                    location: toLocationValues(v.variable.location),
                     mutable: v.variable.mutable, // false...
                     captured: false,
                 });
@@ -796,19 +830,19 @@ 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 ${printLocations(ast.location)}`);
                     }
                     body = variant("As", {
                         type: toEastTypeValue(ast.type),
                         value: body,
-                        location: toLocationValue(ast.location),
+                        location: toLocationValues(ast.location),
                     });
                 }
                 cases.push({ case: k, variable, body });
             }
             return variant("Match", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                location: toLocationValues(ast.location),
                 variant: variant_expr,
                 cases,
             });
@@ -816,7 +850,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),
+                location: toLocationValues(ast.location),
                 value: ast_to_ir(ast.value, ctx),
             });
         }
@@ -827,14 +861,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 ${printLocations(ast.location)}`);
             }
             // 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),
+                location: toLocationValues(ast.location),
                 value: ast_to_ir(ast.value, ctx),
             });
             // The user may alias this AST value elsewhere in the tree, just not with a circular reference
@@ -844,32 +878,32 @@ 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 ${printLocations(ast.label.location)} is not in scope at break at ${printLocations(ast.location)}`);
             }
             return variant("Break", {
                 type: variant("Never", null),
-                location: toLocationValue(ast.location),
+                location: toLocationValues(ast.location),
                 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 ${printLocations(ast.label.location)} is not in scope at continue at ${printLocations(ast.location)}`);
             }
             return variant("Continue", {
                 type: variant("Never", null),
-                location: toLocationValue(ast.location),
+                location: toLocationValues(ast.location),
                 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 ${printLocations(ast.location)}, but function expected return type of ${printType(ctx.output)}`);
             }
             return variant("Return", {
                 type: variant("Never", null),
-                location: toLocationValue(ast.location),
+                location: toLocationValues(ast.location),
                 value: ast_to_ir(ast.value, ctx),
             });
         }
@@ -880,13 +914,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 ${printLocations(ast.location)}`;
             }
             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 ${printLocations(ast.location)}`;
             }
             else {
-                e.message += `\n    at ${ast.ast_type} node located at ${printLocation(ast.location)}`;
+                e.message += `\n    at ${ast.ast_type} node located at ${printLocations(ast.location)}`;
             }
         }
         throw e;