mt-lang 0.3.6 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d5caebfa149a9d43d576f3cbf1b36b175ce70b28bfe474bc942fc2d11f0f1e8
-  data.tar.gz: bf9f4a30b1cabadbed2b2d276dd29d567e118d008000791eefb2ec0e81f80c4f
+  metadata.gz: 3f5f1a4cb47c9822d4aef3caefdd90aca32171fe59775d7906ab9c1485a422cb
+  data.tar.gz: 72e1d25c2082827fd40f723ac4f3b11045391dda39b1f8ef339aa5fac5e57611
 SHA512:
-  metadata.gz: 681c1614c3449f16bb71fbb0f9ee7e9ec10420e302602b131c4ed813b087742e7474ff71e9111f5d35cb1e4315eb440c3c85e29d66e8c733159063cbe946ea01
-  data.tar.gz: 6ea9caabdb7407f64d634f6576135df74e614878f81680777062c2e5f64f75278bb56f71bb48406153e40745e2d2b458e99c46193c9c85837c2b28b3b7aca4b4
+  metadata.gz: b6362b05316203c6b8d6e5c48cbfddad6351540096f9bc90580b8903866bb165e202cc654bd083c4e1de8786acb3f74e86ec85bbb020ee0e5c6874b46ef088fb
+  data.tar.gz: 0c7ffb83f660d7d1a30dbbb42713e5e798ff983795590d3e14074346d350f268184de505fc0091c14c975fcc7d141039368e652a2f0540b533575dcf8a097389

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.3.6"
+  VERSION = "0.3.7"
 
   def self.root
     @root ||= Pathname.new(File.expand_path("../..", __dir__))

data/lib/milk_tea/core/c_backend/aggregate_utils.rb

@@ -32,7 +32,7 @@ module MilkTea
 
             visit = lambda do |aggregate_decl|
               return if visited[aggregate_decl.linkage_name]
-              raise CBackendError, "cyclic aggregate dependency involving #{aggregate_decl.linkage_name}" if visiting[aggregate_decl.linkage_name]
+              raise CBackendError.new("cyclic aggregate dependency involving #{aggregate_decl.linkage_name}", line: 0, column: 0, path: @path) if visiting[aggregate_decl.linkage_name]
 
               visiting[aggregate_decl.linkage_name] = true
               aggregate_decl_dependencies(aggregate_decl).each do |dependency|

data/lib/milk_tea/core/c_backend/expressions.rb

@@ -105,7 +105,7 @@ module MilkTea
             when IR::VariantLiteral
               emit_variant_literal(expression)
             else
-              raise CBackendError, "unsupported IR expression #{expression.class.name}"
+              raise CBackendError.new("unsupported IR expression #{expression.class.name}", line: 0, column: 0, path: @path)
             end
           end
 
@@ -163,7 +163,7 @@ module MilkTea
             when "+", "-" then 9
             when "*", "/", "%" then 10
             else
-              raise CBackendError, "unsupported binary operator #{operator}"
+              raise CBackendError.new("unsupported binary operator #{operator}", line: 0, column: 0, path: @path)
             end
           end
 
@@ -408,7 +408,7 @@ module MilkTea
             end
             return type.field(field_name) if type.respond_to?(:field)
 
-            raise CBackendError, "unsupported aggregate field lookup for #{type}"
+            raise CBackendError.new("unsupported aggregate field lookup for #{type}", line: 0, column: 0, path: @path)
           end
 
           def emit_aggregate_field_initializer(type, field)

data/lib/milk_tea/core/c_backend/statements.rb

@@ -178,7 +178,7 @@ module MilkTea
                 lines
                 end
               else
-                raise CBackendError, "unsupported IR statement #{statement.class.name}"
+                raise CBackendError.new("unsupported IR statement #{statement.class.name}", line: 0, column: 0, path: @path)
               end
             end
 
@@ -501,7 +501,7 @@ module MilkTea
             when IR::CheckedSpanIndex
               "#{checked_span_index_helper_name(expression.receiver_type)}(#{emit_expression(expression.receiver)}, #{emit_expression(expression.index)})"
             else
-              raise CBackendError, "unsupported checked index alias expression #{expression.class.name}"
+              raise CBackendError.new("unsupported checked index alias expression #{expression.class.name}", line: 0, column: 0, path: @path)
             end
           end
 
@@ -533,19 +533,19 @@ module MilkTea
           def emit_for_clause_statement(statement)
             case statement
             when IR::LocalDecl
-              raise CBackendError, "array for-loop init declarations are unsupported" if array_type?(statement.type)
+              raise CBackendError.new("array for-loop init declarations are unsupported", line: 0, column: 0, path: @path) if array_type?(statement.type)
 
               "#{c_declaration(statement.type, statement.linkage_name)} = #{emit_initializer(statement.value)}"
             when IR::Assignment
               if array_type?(statement.target.type) && statement.operator == "="
-                raise CBackendError, "array for-loop assignment clauses are unsupported"
+                raise CBackendError.new("array for-loop assignment clauses are unsupported", line: 0, column: 0, path: @path)
               end
 
               "#{emit_expression(statement.target)} #{statement.operator} #{emit_expression(statement.value)}"
             when IR::ExpressionStmt
               emit_expression(statement.expression)
             else
-              raise CBackendError, "unsupported for-loop clause #{statement.class.name}"
+              raise CBackendError.new("unsupported for-loop clause #{statement.class.name}", line: 0, column: 0, path: @path)
             end
           end
 

data/lib/milk_tea/core/c_backend/type_system.rb

@@ -171,7 +171,7 @@ module MilkTea
             when Types::Handle
               "void*"
             else
-              raise CBackendError, "unsupported C type #{type.class.name}"
+              raise CBackendError.new("unsupported C type #{type.class.name}", line: 0, column: 0, path: @path)
             end
           end
 
@@ -261,33 +261,33 @@ module MilkTea
           def generic_c_type(type)
             case type.name
             when "ptr"
-              raise CBackendError, "ptr requires exactly one type argument" unless type.arguments.length == 1
+              raise CBackendError.new("ptr requires exactly one type argument", line: 0, column: 0, path: @path) unless type.arguments.length == 1
 
               "#{c_type(type.arguments.first)}*"
             when "const_ptr"
-              raise CBackendError, "const_ptr requires exactly one type argument" unless type.arguments.length == 1
+              raise CBackendError.new("const_ptr requires exactly one type argument", line: 0, column: 0, path: @path) unless type.arguments.length == 1
 
               "const #{c_type(type.arguments.first)}*"
             when "own"
-              raise CBackendError, "own requires exactly one type argument" unless type.arguments.length == 1
+              raise CBackendError.new("own requires exactly one type argument", line: 0, column: 0, path: @path) unless type.arguments.length == 1
 
               "#{c_type(type.arguments.first)}*"
             when "ref"
-              raise CBackendError, "ref requires at least one type argument" unless [1, 2].include?(type.arguments.length)
+              raise CBackendError.new("ref requires at least one type argument", line: 0, column: 0, path: @path) unless [1, 2].include?(type.arguments.length)
 
               "#{c_type(type.arguments.length == 1 ? type.arguments.first : type.arguments[1])}*"
             when "array"
-              raise CBackendError, "array requires exactly two type arguments" unless type.arguments.length == 2
+              raise CBackendError.new("array requires exactly two type arguments", line: 0, column: 0, path: @path) unless type.arguments.length == 2
 
               c_type(type.arguments.first)
             when "str_buffer"
-              raise CBackendError, "str_buffer requires exactly one type argument" unless str_buffer_type?(type)
+              raise CBackendError.new("str_buffer requires exactly one type argument", line: 0, column: 0, path: @path) unless str_buffer_type?(type)
 
               str_buffer_type_name(type)
             when "atomic"
               "_Atomic #{c_type(type.arguments.first)}"
             else
-              raise CBackendError, "unsupported generic C type #{type.name}"
+              raise CBackendError.new("unsupported generic C type #{type.name}", line: 0, column: 0, path: @path)
             end
           end
 

data/lib/milk_tea/core/lowering/async/lowering.rb

@@ -119,8 +119,8 @@ module MilkTea
             statement_position: false,
           )
           lowered.concat(setup)
-          raise LoweringError, "foreign call used to initialize #{statement.name} must return a value" if call_type == @ctx.types.fetch("void")
-          raise LoweringError, "consuming foreign calls must return void" unless release_assignments.empty?
+          raise LoweringError.new("foreign call used to initialize #{statement.name} must return a value", line: 0, column: 0, path: @ctx.current_analysis_path) if call_type == @ctx.types.fetch("void")
+          raise LoweringError.new("consuming foreign calls must return void", line: 0, column: 0, path: @ctx.current_analysis_path) unless release_assignments.empty?
 
           lowered << IR::Assignment.new(target:, operator: "=", value:)
           lowered.concat(cleanup_statements)
@@ -307,7 +307,7 @@ module MilkTea
           when AST::StaticAssert
             lowered.concat(lower_static_assert(statement))
           else
-            raise LoweringError, "unsupported async cf statement #{statement.class.name}"
+            raise LoweringError.new("unsupported async cf statement #{statement.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
           end
         end
 
@@ -412,7 +412,7 @@ module MilkTea
       def lower_async_cf_collection_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:)
         iterable_type = infer_expression_type(statement.iterable, env:)
         element_type = collection_loop_type(iterable_type)
-        raise LoweringError, "for loop expects start..stop, array[T, N], or span[T], got #{iterable_type}" unless element_type
+        raise LoweringError.new("for loop expects start..stop, array[T, N], or span[T], got #{iterable_type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless element_type
 
         iterable_setup, prepared_iterable = prepare_expression_for_inline_lowering(statement.iterable, env:, expected_type: iterable_type)
         continue_label = fresh_c_temp_name(env, "loop_continue")
@@ -468,7 +468,7 @@ module MilkTea
           iterable = statement.iterables[index]
           iterable_type = infer_expression_type(iterable, env:)
           element_type = collection_loop_type(iterable_type)
-          raise LoweringError, "parallel for loops expect arrays or spans for each iterable, got #{iterable_type}" unless element_type
+          raise LoweringError.new("parallel for loops expect arrays or spans for each iterable, got #{iterable_type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless element_type
 
           {
             binding:,
@@ -744,7 +744,7 @@ module MilkTea
           when AST::StaticAssert
             lowered << lower_static_assert(statement, env: local_env)
           else
-            raise LoweringError, "unsupported async non-await statement #{statement.class.name}"
+            raise LoweringError.new("unsupported async non-await statement #{statement.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
           end
         end
 
@@ -837,7 +837,7 @@ module MilkTea
       def lower_async_collection_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers: [])
         iterable_type = infer_expression_type(statement.iterable, env:)
         element_type = collection_loop_type(iterable_type)
-        raise LoweringError, "for loop expects start..stop, array[T, N], or span[T], got #{iterable_type}" unless element_type
+        raise LoweringError.new("for loop expects start..stop, array[T, N], or span[T], got #{iterable_type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless element_type
 
         iterable_setup, prepared_iterable = prepare_expression_for_inline_lowering(statement.iterable, env:, expected_type: iterable_type)
         iterable_linkage_name = fresh_c_temp_name(env, "for_items")
@@ -896,7 +896,7 @@ module MilkTea
           iterable = statement.iterables[index]
           iterable_type = infer_expression_type(iterable, env:)
           element_type = collection_loop_type(iterable_type)
-          raise LoweringError, "parallel for loops expect arrays or spans for each iterable, got #{iterable_type}" unless element_type
+          raise LoweringError.new("parallel for loops expect arrays or spans for each iterable, got #{iterable_type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless element_type
 
           {
             binding:,
@@ -998,8 +998,8 @@ module MilkTea
             statement_position: false,
           )
           lowered.concat(setup)
-          raise LoweringError, "foreign call used in assignment must return a value" if call_type == @ctx.types.fetch("void")
-          raise LoweringError, "consuming foreign calls must return void" unless release_assignments.empty?
+          raise LoweringError.new("foreign call used in assignment must return a value", line: 0, column: 0, path: @ctx.current_analysis_path) if call_type == @ctx.types.fetch("void")
+          raise LoweringError.new("consuming foreign calls must return void", line: 0, column: 0, path: @ctx.current_analysis_path) unless release_assignments.empty?
 
           lowered << IR::Assignment.new(target:, operator: statement.operator, value:)
           lowered.concat(cleanup_statements)
@@ -1135,7 +1135,7 @@ module MilkTea
           expected_type: await_info[:task_type],
         )
         lowered.concat(prepared_setup)
-        raise LoweringError, "await does not support foreign task expressions" if foreign_call_info(prepared_task, env)
+        raise LoweringError.new("await does not support foreign task expressions", line: 0, column: 0, path: @ctx.current_analysis_path) if foreign_call_info(prepared_task, env)
 
         task_expr = async_frame_field_expression(frame_expr, await_info[:field_name], await_info[:task_type])
         task_frame_expr = async_task_frame_expression(task_expr, await_info[:task_type])
@@ -1382,7 +1382,7 @@ module MilkTea
           [loop_exit_statement(target, local_defers:, outer_defers:)]
         else
           label = target[:label]
-          raise LoweringError, "structured loop exits with cleanup are unsupported" unless label
+          raise LoweringError.new("structured loop exits with cleanup are unsupported", line: 0, column: 0, path: @ctx.current_analysis_path) unless label
 
           cleanup + [IR::GotoStmt.new(label:)]
         end

data/lib/milk_tea/core/lowering/async/normalization.rb

@@ -166,7 +166,7 @@ module MilkTea
       when AST::BreakStmt, AST::ContinueStmt, AST::StaticAssert, AST::PassStmt
         [statement]
       else
-        raise LoweringError, "unsupported async statement #{statement.class.name}"
+        raise LoweringError.new("unsupported async statement #{statement.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
     end
 
@@ -210,10 +210,10 @@ module MilkTea
           end
           [setup, AST::Call.new(callee: target.callee, arguments: normalized_args)]
         else
-          raise LoweringError, "unsupported assignment target #{target.class.name}"
+          raise LoweringError.new("unsupported assignment target #{target.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
       else
-        raise LoweringError, "unsupported assignment target #{target.class.name}"
+        raise LoweringError.new("unsupported assignment target #{target.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
     end
 
@@ -372,7 +372,7 @@ module MilkTea
         AST::TypeRef.new(name: AST::QualifiedName.new(parts: [type.name]), arguments: [], nullable: false)
       when Types::Nullable
         inner = ast_type_ref_for(type.base)
-        raise LoweringError, "nullable annotation is only valid for named/generic types" unless inner.is_a?(AST::TypeRef)
+        raise LoweringError.new("nullable annotation is only valid for named/generic types", line: 0, column: 0, path: @ctx.current_analysis_path) unless inner.is_a?(AST::TypeRef)
 
         AST::TypeRef.new(name: inner.name, arguments: inner.arguments, nullable: true)
       when Types::GenericInstance
@@ -420,7 +420,7 @@ module MilkTea
           return_type: ast_type_ref_for(type.return_type),
         )
       else
-        raise LoweringError, "unsupported type for AST normalization #{type.class.name}"
+        raise LoweringError.new("unsupported type for AST normalization #{type.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
     end
 

data/lib/milk_tea/core/lowering/async.rb

@@ -8,7 +8,8 @@ module MilkTea
       def build_async_main_entrypoint(binding, _constructor_c_name, async_info)
         task_type = async_info[:task_type]
         signature = root_main_entrypoint_signature(binding)
-        raise LoweringError, "async main entrypoint requires a supported signature" unless signature
+        raise LoweringError.new("async main entrypoint requires a supported signature",
+          line: 0, column: 0, path: @ctx.current_analysis_path) unless signature
 
         params, setup_statements, call_arguments, cleanup_statements = build_root_main_entrypoint_bridge(signature)
         body = []
@@ -229,7 +230,8 @@ module MilkTea
             cleanup,
           ]
         else
-          raise LoweringError, "unsupported root main entrypoint bridge #{signature[:kind]}"
+          raise LoweringError.new("unsupported root main entrypoint bridge #{signature[:kind]}",
+            line: 0, column: 0, path: @ctx.current_analysis_path)
         end
       end
 

data/lib/milk_tea/core/lowering/block.rb

@@ -55,11 +55,13 @@ module MilkTea
           when AST::PassStmt
             nil
           when AST::BreakStmt
-            raise LoweringError, "break must be inside a loop" unless loop_flow
+            raise LoweringError.new("break must be inside a loop",
+              line: statement.line, column: statement.column, path: @ctx.current_analysis_path) unless loop_flow
 
             lowered.concat(lower_loop_exit(loop_flow[:break_target], local_defers, loop_flow[:break_defers]))
           when AST::ContinueStmt
-            raise LoweringError, "continue must be inside a loop" unless loop_flow
+            raise LoweringError.new("continue must be inside a loop",
+              line: statement.line, column: statement.column, path: @ctx.current_analysis_path) unless loop_flow
 
             lowered.concat(lower_loop_exit(loop_flow[:continue_target], local_defers, loop_flow[:continue_defers]))
           when AST::ReturnStmt
@@ -71,7 +73,8 @@ module MilkTea
           when AST::WhenStmt
             lower_block_when_stmt(statement, lowered:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
           else
-            raise LoweringError, "unsupported statement #{statement.class.name}"
+            raise LoweringError.new("unsupported statement #{statement.class.name}",
+              line: statement.line, column: statement.column, path: @ctx.current_analysis_path)
           end
         end
 
@@ -85,7 +88,8 @@ module MilkTea
         captures = proc_capture_entries(expression, env)
         captures.each do |capture|
           if ref_type?(capture[:type]) || contains_ref_type?(capture[:type])
-            raise LoweringError, "proc capture #{capture[:name]} cannot use ref types"
+            raise LoweringError.new("proc capture #{capture[:name]} cannot use ref types",
+              line: expression.line, column: expression.column, path: @ctx.current_analysis_path)
           end
         end
 
@@ -279,7 +283,8 @@ module MilkTea
         when AST::ConstDecl
           lower_emitted_const(decl, env:)
         else
-          raise LoweringError, "emit is not supported for #{decl.class.name}"
+          raise LoweringError.new("emit is not supported for #{decl.class.name}",
+            line: statement.line, column: statement.column, path: @ctx.current_analysis_path)
         end
       end
 
@@ -451,7 +456,8 @@ module MilkTea
     end
 
     def lower_block_return_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, allow_return:)
-      raise LoweringError, "return is not allowed inside defer blocks" unless allow_return
+      raise LoweringError.new("return is not allowed inside defer blocks",
+        line: statement.line, column: statement.column, path: @ctx.current_analysis_path) unless allow_return
 
       value = nil
       prepared_setup = []
@@ -478,7 +484,8 @@ module MilkTea
         contextual_int_to_float: contextual_int_to_float_target?(return_type),
       ) : nil
       if prepared_cleanups.any? && cstr_trackable_type?(return_type)
-        raise LoweringError, "formatted string temporaries cannot be returned as borrowed text; use std.fmt.format(f\"...\") when ownership must escape"
+        raise LoweringError.new("formatted string temporaries cannot be returned as borrowed text; use std.fmt.format(f\"...\") when ownership must escape",
+          line: statement.line, column: statement.column, path: @ctx.current_analysis_path)
       end
 
       prepared_cleanup_list = prepared_cleanups.flat_map(&:itself)
@@ -523,8 +530,10 @@ module MilkTea
           statement_position: false,
         )
         lowered.concat(setup)
-        raise LoweringError, "foreign call used in assignment must return a value" if call_type == @ctx.types.fetch("void")
-        raise LoweringError, "consuming foreign calls must return void" unless release_assignments.empty?
+        raise LoweringError.new("foreign call used in assignment must return a value",
+          line: statement.line, column: statement.column, path: @ctx.current_analysis_path) if call_type == @ctx.types.fetch("void")
+        raise LoweringError.new("consuming foreign calls must return void",
+          line: statement.line, column: statement.column, path: @ctx.current_analysis_path) unless release_assignments.empty?
 
         lowered << IR::Assignment.new(target:, operator: statement.operator, value:)
         lowered.concat(cleanup_statements)
@@ -713,8 +722,10 @@ module MilkTea
           statement_position: false,
         )
         lowered.concat(setup)
-        raise LoweringError, "foreign call used to initialize #{statement.name} must return a value" if call_type == @ctx.types.fetch("void")
-        raise LoweringError, "consuming foreign calls must return void" unless release_assignments.empty?
+        raise LoweringError.new("foreign call used to initialize #{statement.name} must return a value",
+          line: statement.line, column: statement.column, path: @ctx.current_analysis_path) if call_type == @ctx.types.fetch("void")
+        raise LoweringError.new("consuming foreign calls must return void",
+          line: statement.line, column: statement.column, path: @ctx.current_analysis_path) unless release_assignments.empty?
 
         lowered << IR::LocalDecl.new(name: decl_name, linkage_name:, type: storage_type, value:, line: statement.line, source_path: @ctx.current_analysis_path)
         lowered.concat(cleanup_statements)
@@ -927,16 +938,25 @@ module MilkTea
           nested_struct_c_name = nil
           nested_struct_type = nil
           if fields.size == 1 && fields.values.first.is_a?(Types::Struct)
-            nested_struct_type = fields.values.first
-            nested_struct_fields = nested_struct_type.fields
-            single_field_name = fields.keys.first
-            nested_struct_c_name = fresh_c_temp_name(arm_local_env, "match_struct")
-            struct_expr = IR::Member.new(
-              receiver: IR::Name.new(name: payload_c_name, type: payload_type, pointer: false),
-              member: single_field_name,
-              type: nested_struct_type,
-            )
-            arm_body_ir << IR::LocalDecl.new(name: nested_struct_c_name, linkage_name: nested_struct_c_name, type: nested_struct_type, value: struct_expr)
+            native_field = fields.keys.first
+            has_native_reference = arm.pattern.arguments.any? do |arg|
+              next false if !arg.name && arg.value.is_a?(AST::Identifier) && arg.value.name == "_"
+
+              name = arg.name || (arg.value.is_a?(AST::Identifier) ? arg.value.name : nil)
+              name == native_field
+            end
+            unless has_native_reference
+              nested_struct_type = fields.values.first
+              nested_struct_fields = nested_struct_type.fields
+              single_field_name = fields.keys.first
+              nested_struct_c_name = fresh_c_temp_name(arm_local_env, "match_struct")
+              struct_expr = IR::Member.new(
+                receiver: IR::Name.new(name: payload_c_name, type: payload_type, pointer: false),
+                member: single_field_name,
+                type: nested_struct_type,
+              )
+              arm_body_ir << IR::LocalDecl.new(name: nested_struct_c_name, linkage_name: nested_struct_c_name, type: nested_struct_type, value: struct_expr)
+            end
           end
 
           if arm.pattern.is_a?(AST::Call) && !arm.pattern.arguments.empty?

data/lib/milk_tea/core/lowering/calls.rb

@@ -21,7 +21,7 @@ module MilkTea
         case kind
         when :function
           if callee_binding && foreign_function_binding?(callee_binding)
-            raise LoweringError, "consuming foreign calls must be top-level expression statements" if foreign_call_consumes_binding?(callee_binding)
+            raise LoweringError.new("consuming foreign calls must be top-level expression statements", line: 0, column: 0, path: @ctx.current_analysis_path) if foreign_call_consumes_binding?(callee_binding)
 
             return lower_foreign_call_inline(expression, callee_binding, env:, type:)
           end
@@ -287,7 +287,7 @@ module MilkTea
           elsif receiver_type.is_a?(Types::Span)
             IR::NullableSpanIndex.new(receiver:, index:, receiver_type:, type:)
           else
-            raise LoweringError, "get expects an array or span, got #{receiver_type}"
+            raise LoweringError.new("get expects an array or span, got #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
           end
         when :ref_of
           argument = expression.arguments.fetch(0)
@@ -311,7 +311,7 @@ module MilkTea
         when :dyn_method
           lower_dyn_method_call(expression, receiver, callee_type, env:, type:)
         else
-          raise LoweringError, "unsupported call kind #{kind}"
+          raise LoweringError.new("unsupported call kind #{kind}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
       end
 
@@ -488,7 +488,7 @@ module MilkTea
       def lower_foreign_call_components(foreign_call, env:, expected_type:, statement_position:)
         call = foreign_call.fetch(:call)
         binding = foreign_call.fetch(:binding)
-        raise LoweringError, "consuming foreign calls must be top-level expression statements" if foreign_call_consumes_binding?(binding) && !statement_position
+        raise LoweringError.new("consuming foreign calls must be top-level expression statements", line: 0, column: 0, path: @ctx.current_analysis_path) if foreign_call_consumes_binding?(binding) && !statement_position
 
         previous_type_substitutions = @ctx.current_type_substitutions
         @ctx.current_type_substitutions = binding.type_substitutions
@@ -540,7 +540,7 @@ module MilkTea
           return [lowered, nil]
         end
 
-        raise LoweringError, "consuming foreign calls must return void" unless release_assignments.empty?
+        raise LoweringError.new("consuming foreign calls must return void", line: 0, column: 0, path: @ctx.current_analysis_path) unless release_assignments.empty?
 
         if discard_result
           lowered << IR::ExpressionStmt.new(expression: lowered_call)
@@ -583,12 +583,12 @@ module MilkTea
 
           argument = call.arguments.fetch(index)
           unless argument.value.is_a?(AST::Identifier)
-            raise LoweringError, "consuming foreign calls require bare nullable local or parameter bindings"
+            raise LoweringError.new("consuming foreign calls require bare nullable local or parameter bindings", line: 0, column: 0, path: @ctx.current_analysis_path)
           end
 
           lowered_binding = lookup_value(argument.value.name, env)
           unless lowered_binding && lowered_binding[:storage_type].is_a?(Types::Nullable) && lowered_binding[:storage_type].base == parameter.type
-            raise LoweringError, "consuming foreign calls require bare nullable local or parameter bindings"
+            raise LoweringError.new("consuming foreign calls require bare nullable local or parameter bindings", line: 0, column: 0, path: @ctx.current_analysis_path)
           end
 
           lowered_binding.merge(name: argument.value.name)
@@ -757,14 +757,14 @@ module MilkTea
             converted = foreign_identity_projection_expression(lowered_value, parameter.boundary_type)
             return converted if converted
 
-            raise LoweringError, "unsupported foreign boundary mapping #{parameter.type} as #{parameter.boundary_type}"
+            raise LoweringError.new("unsupported foreign boundary mapping #{parameter.type} as #{parameter.boundary_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
           end
         when :in
           lower_foreign_in_argument_value(parameter, argument, env:)
         when :out, :inout
           lower_foreign_pointer_argument_value(parameter, argument, env:)
         else
-          raise LoweringError, "unsupported foreign passing mode #{parameter.passing_mode}"
+          raise LoweringError.new("unsupported foreign passing mode #{parameter.passing_mode}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
       end
 
@@ -779,7 +779,7 @@ module MilkTea
 
         data_expression = IR::Member.new(receiver: lowered_value, member: "data", type: pointer_to(public_element_type))
         converted_data = foreign_identity_projection_expression(data_expression, pointer_to(boundary_element_type))
-        raise LoweringError, "unsupported foreign boundary mapping #{public_type} as #{boundary_type}" unless converted_data
+        raise LoweringError.new("unsupported foreign boundary mapping #{public_type} as #{boundary_type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless converted_data
 
         len_expression = IR::Member.new(receiver: lowered_value, member: "len", type: @ctx.types.fetch("ptr_uint"))
         IR::AggregateLiteral.new(
@@ -799,7 +799,7 @@ module MilkTea
         converted = foreign_identity_projection_expression(address, parameter.boundary_type)
         return converted if converted
 
-        raise LoweringError, "unsupported foreign pointer boundary mapping #{parameter.type} as #{parameter.boundary_type}"
+        raise LoweringError.new("unsupported foreign pointer boundary mapping #{parameter.type} as #{parameter.boundary_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
 
       def foreign_slot_boundary_value_type(type)
@@ -841,7 +841,7 @@ module MilkTea
         converted = foreign_identity_projection_expression(address, parameter.boundary_type)
         return converted if converted
 
-        raise LoweringError, "unsupported foreign in boundary mapping #{parameter.type} as #{parameter.boundary_type}"
+        raise LoweringError.new("unsupported foreign in boundary mapping #{parameter.type} as #{parameter.boundary_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
 
       def lower_foreign_char_pointer_buffer_argument_value(parameter, argument, env:)
@@ -869,7 +869,7 @@ module MilkTea
         converted = foreign_identity_projection_expression(lowered_value, parameter.boundary_type)
         return converted if converted
 
-        raise LoweringError, "unsupported foreign boundary mapping #{public_type} as #{parameter.boundary_type}"
+        raise LoweringError.new("unsupported foreign boundary mapping #{public_type} as #{parameter.boundary_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
 
       def lower_foreign_call_inline(expression, binding, env:, type:)
@@ -888,7 +888,7 @@ module MilkTea
           next unless total_references > 1
           next if duplicable_foreign_argument_expression?(expression.arguments.fetch(index).value)
 
-          raise LoweringError, "foreign call #{binding.name} cannot be used inline because #{param_ast.name} is referenced multiple times in its mapping; use it as a statement, local initializer, assignment, or return expression"
+          raise LoweringError.new("foreign call #{binding.name} cannot be used inline because #{param_ast.name} is referenced multiple times in its mapping; use it as a statement, local initializer, assignment, or return expression", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
 
         binding.ast.params.each_with_index do |param_ast, index|
@@ -896,13 +896,13 @@ module MilkTea
           next unless automatic_foreign_cstr_temp_needed?(parameter, expression.arguments.fetch(index).value, env:) ||
                       automatic_foreign_cstr_list_temp_needed?(parameter, expression.arguments.fetch(index).value, env:)
 
-          raise LoweringError, "foreign call #{binding.name} cannot be used inline because #{param_ast.name} needs temporary foreign text storage; use it as a statement, local initializer, assignment, or return expression"
+          raise LoweringError.new("foreign call #{binding.name} cannot be used inline because #{param_ast.name} needs temporary foreign text storage; use it as a statement, local initializer, assignment, or return expression", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
 
         expression.arguments.drop(binding.type.params.length).each do |argument|
           next unless automatic_variadic_foreign_cstr_temp_needed?(argument.value, env:)
 
-          raise LoweringError, "foreign call #{binding.name} cannot be used inline because a variadic argument needs temporary foreign text storage; use it as a statement, local initializer, assignment, or return expression"
+          raise LoweringError.new("foreign call #{binding.name} cannot be used inline because a variadic argument needs temporary foreign text storage; use it as a statement, local initializer, assignment, or return expression", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
 
         binding.ast.params.each_with_index do |param_ast, index|
@@ -911,7 +911,7 @@ module MilkTea
           next unless parameter.passing_mode == :in
           next if addressable_storage_expression?(foreign_argument_expression(argument))
 
-          raise LoweringError, "foreign call #{binding.name} cannot be used inline because #{param_ast.name} needs temporary in storage; use it as a statement, local initializer, assignment, or return expression"
+          raise LoweringError.new("foreign call #{binding.name} cannot be used inline because #{param_ast.name} needs temporary in storage; use it as a statement, local initializer, assignment, or return expression", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
 
         replacements = {}
@@ -978,7 +978,7 @@ module MilkTea
         )
         return lowered_argument unless temporary_foreign_cstr_expression?(lowered_argument)
 
-        raise LoweringError, "foreign variadic call cannot be used inline because an extra argument needs temporary foreign text storage; use it as a statement, local initializer, assignment, or return expression" unless lowered && cleanup
+        raise LoweringError.new("foreign variadic call cannot be used inline because an extra argument needs temporary foreign text storage; use it as a statement, local initializer, assignment, or return expression", line: 0, column: 0, path: @ctx.current_analysis_path) unless lowered && cleanup
 
         temp_name = fresh_c_temp_name(env, "foreign_arg")
         lowered << IR::LocalDecl.new(
@@ -1128,7 +1128,7 @@ module MilkTea
 
         case kind
         when :function
-          raise LoweringError, "consuming foreign calls must be top-level expression statements" if callee_binding && foreign_function_binding?(callee_binding) && foreign_call_consumes_binding?(callee_binding)
+          raise LoweringError.new("consuming foreign calls must be top-level expression statements", line: 0, column: 0, path: @ctx.current_analysis_path) if callee_binding && foreign_function_binding?(callee_binding) && foreign_call_consumes_binding?(callee_binding)
 
           arguments = expression.arguments.map.with_index do |argument, index|
             expected_arg_type = index < callee_type.params.length ? callee_type.params[index].type : nil
@@ -1301,7 +1301,7 @@ module MilkTea
             )
           end
         else
-          raise LoweringError, "unsupported inline foreign mapping call kind #{kind}"
+          raise LoweringError.new("unsupported inline foreign mapping call kind #{kind}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
       end
 
@@ -1537,9 +1537,9 @@ module MilkTea
 
         if (callable_resolution = resolve_specialized_callable_binding(expression, env:))
           callable_kind, function_binding, = callable_resolution
-          raise LoweringError, "specialized method must be called" if callable_kind == :method
+          raise LoweringError.new("specialized method must be called", line: 0, column: 0, path: @ctx.current_analysis_path) if callable_kind == :method
 
-          raise LoweringError, "foreign function #{function_binding.name} cannot be used as a value" if foreign_function_binding?(function_binding)
+          raise LoweringError.new("foreign function #{function_binding.name} cannot be used as a value", line: 0, column: 0, path: @ctx.current_analysis_path) if foreign_function_binding?(function_binding)
 
           if function_binding.external
             return IR::Name.new(name: external_function_c_name(function_binding), type:, pointer: false)
@@ -1552,9 +1552,9 @@ module MilkTea
           )
         end
 
-        raise LoweringError, "specialization #{expression.callee.name} must be called" if expression.callee.is_a?(AST::Identifier)
+        raise LoweringError.new("specialization #{expression.callee.name} must be called", line: 0, column: 0, path: @ctx.current_analysis_path) if expression.callee.is_a?(AST::Identifier)
 
-        raise LoweringError, "unsupported specialization #{expression.class.name}"
+        raise LoweringError.new("unsupported specialization #{expression.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
 
       def atomic_method_kind(receiver_type, name)
@@ -1602,7 +1602,7 @@ module MilkTea
           arg = lower_contextual_expression(expression.arguments.first.value, env:, expected_type: elem_type)
           IR::Call.new(callee: "__atomic_exchange_n", arguments: [addr, arg, seq_cst], type: elem_type)
         when :atomic_compare_exchange
-          raise LoweringError, "atomic compare_exchange is not yet implemented in the built-in surface; use std.sync.AtomicUint for compare-exchange operations"
+          raise LoweringError.new("atomic compare_exchange is not yet implemented in the built-in surface; use std.sync.AtomicUint for compare-exchange operations", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
       end