@elaraai/east 0.0.1-beta.27 → 0.0.1-beta.29

package/dist/src/ast_to_ir.js

@@ -1,5 +1,5 @@
 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";
@@ -8,17 +8,17 @@ import { applyTypeParameters, Builtins } from "./builtins.js";
 export class OutOfScopeException extends Error {
     definedLocation;
     constructor(definedLocation) {
-        super(`Variable defined at ${printLocation(definedLocation)} is out of scope here`);
+        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.
 *
@@ -47,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,
             });
@@ -58,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,
             });
@@ -79,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
@@ -90,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,
             });
@@ -113,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,
             });
         }
@@ -122,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) => {
@@ -142,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(expectedType),
                             value: arg_ir,
-                            location: toLocationValue(ast.location),
+                            location: toLocationValues(ast.location),
                         });
                     }
                     return arg_ir;
@@ -156,11 +156,11 @@ 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
@@ -170,24 +170,24 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
         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 };
@@ -197,7 +197,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,
             });
@@ -210,17 +210,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,
             });
@@ -230,7 +230,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,
                 });
@@ -258,7 +258,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             }
             return variant("Function", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                location: toLocationValues(ast.location),
                 parameters,
                 captures: [...captures],
                 body,
@@ -269,7 +269,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,
                 });
@@ -297,7 +297,7 @@ export function ast_to_ir(ast, ctx = { local_ctx: new Map(), parent_ctx: new Map
             }
             return variant("AsyncFunction", {
                 type: toEastTypeValue(ast.type),
-                location: toLocationValue(ast.location),
+                location: toLocationValues(ast.location),
                 parameters,
                 captures: [...captures],
                 body,
@@ -308,19 +308,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;
@@ -329,25 +329,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;
@@ -359,17 +359,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,
             });
         }
@@ -377,17 +377,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;
@@ -398,17 +398,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;
@@ -420,28 +420,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),
                         });
                     }
                     ;
@@ -468,12 +468,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 };
@@ -494,17 +494,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,
             });
@@ -512,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),
+                location: toLocationValues(ast.location),
                 message: ast_to_ir(ast.message, ctx),
             });
         }
@@ -535,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),
+                location: toLocationValues(ast.message.location),
                 mutable: ast.message.mutable, // false...
                 captured: false,
             });
@@ -543,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),
+                location: toLocationValues(ast.stack.location),
                 mutable: ast.stack.mutable, // false...
                 captured: false,
             });
@@ -583,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),
+                    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,
@@ -625,18 +625,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),
             });
         }
@@ -644,7 +644,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 = {
@@ -663,7 +663,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,
@@ -673,13 +673,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,
             });
@@ -687,7 +687,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,
             });
@@ -708,7 +708,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,
@@ -720,13 +720,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,
             });
@@ -747,7 +747,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,
@@ -758,13 +758,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,
             });
@@ -772,7 +772,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,
             });
@@ -793,7 +793,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,
@@ -808,7 +808,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,
                 });
@@ -829,19 +829,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,
             });
@@ -849,7 +849,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),
             });
         }
@@ -860,14 +860,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
@@ -877,32 +877,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),
             });
         }
@@ -913,13 +913,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;