mt-lang 0.3.5 → 0.3.7

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
 

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

@@ -41,7 +41,8 @@ module MilkTea
             value = lower_static_storage_initializer(decl.value, env: empty_env, expected_type: type)
           end
 
-          IR::Constant.new(name: decl.name, linkage_name: value_c_name(decl.name), type:, value:)
+          IR::Constant.new(name: decl.name, linkage_name: value_c_name(decl.name), type:, value:,
+                           line: decl.line, source_path: @ctx.current_analysis_path)
         end
       end
 
@@ -75,7 +76,7 @@ module MilkTea
         when Hash
           fields = const_value.map do |name, field_value|
             field_type = type.field(name)
-            raise LoweringError, "constant struct field #{name} not found in #{type}" unless field_type
+            raise LoweringError.new("constant struct field #{name} not found in #{type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless field_type
             IR::AggregateField.new(name:, value: lower_const_value_literal(field_type, field_value))
           end
           IR::AggregateLiteral.new(type:, fields:)
@@ -130,7 +131,7 @@ module MilkTea
 
       def lower_static_assert(statement, env:)
         condition_value = compile_time_const_value(statement.condition, env:)
-        raise LoweringError, "static_assert condition must lower to a compile-time bool constant" unless condition_value == true || condition_value == false
+        raise LoweringError.new("static_assert condition must lower to a compile-time bool constant", line: 0, column: 0, path: @ctx.current_analysis_path) unless condition_value == true || condition_value == false
 
         IR::StaticAssert.new(
           condition: IR::BooleanLiteral.new(value: condition_value, type: @ctx.types.fetch("bool")),

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

@@ -110,7 +110,8 @@ module MilkTea
 
       interface.methods.each do |method_name, method_binding|
         method_info = @method_definitions[[concrete_type, method_name]]
-        raise LoweringError, "no method #{method_name} for #{concrete_type}" unless method_info
+        raise LoweringError.new("no method #{method_name} for #{concrete_type}",
+          line: 0, column: 0, path: @ctx.current_analysis_path) unless method_info
 
         method_analysis, method_ast = method_info
         method_key = method_ast.kind == :static ? "static:#{method_ast.name}" : method_ast.name

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

@@ -46,7 +46,7 @@ module MilkTea
         when :event_wait
           Types::Registry.function(kind.to_s, params: [], return_type: Types::Registry.task(event_wait_result_type(event_type)))
         else
-          raise LoweringError, "unsupported event method #{kind}"
+          raise LoweringError.new("unsupported event method #{kind}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
       end
 

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

@@ -283,7 +283,7 @@ module MilkTea
                 parameter_type: append_argument_type,
               }
             else
-              raise LoweringError, "unsupported format spec #{part.format_spec.inspect}"
+              raise LoweringError.new("unsupported format spec #{part.format_spec.inspect}", line: 0, column: 0, path: @ctx.current_analysis_path)
             end
           else
             append_plan = format_string_append_plan(value_type, context: "formatted string interpolation of #{value_type}")
@@ -434,7 +434,7 @@ module MilkTea
             capacity: IR::IntegerLiteral.new(value: str_buffer_capacity(lowered_receiver.type), type: @ctx.types.fetch("ptr_uint")),
           }
         else
-          raise LoweringError, "unsupported explicit format sink #{info[:sink_kind]}"
+          raise LoweringError.new("unsupported explicit format sink #{info[:sink_kind]}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
       end
 
@@ -451,7 +451,7 @@ module MilkTea
             ],
           )
         else
-          raise LoweringError, "unsupported explicit format sink #{sink_target[:kind]}"
+          raise LoweringError.new("unsupported explicit format sink #{sink_target[:kind]}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
       end
 
@@ -560,7 +560,7 @@ module MilkTea
             value: offset_value,
           )
         else
-          raise LoweringError, "unsupported explicit format sink #{sink_target[:kind]}"
+          raise LoweringError.new("unsupported explicit format sink #{sink_target[:kind]}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
 
         sink_statements.concat(copied_part_cleanups)
@@ -588,7 +588,7 @@ module MilkTea
             type: @ctx.types.fetch("void"),
           )
         else
-          raise LoweringError, "unsupported explicit format sink #{sink_target[:kind]}"
+          raise LoweringError.new("unsupported explicit format sink #{sink_target[:kind]}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
       end
 
@@ -820,7 +820,7 @@ module MilkTea
         end
 
         if part[:kind] == :custom_expression
-          raise LoweringError, "custom format parts require statement lowering"
+          raise LoweringError.new("custom format parts require statement lowering", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
 
         IR::Call.new(
@@ -837,7 +837,7 @@ module MilkTea
                   when :append
                     part[:format_binding].append_binding
                   else
-                    raise LoweringError, "unsupported custom format hook #{hook}"
+                    raise LoweringError.new("unsupported custom format hook #{hook}", line: 0, column: 0, path: @ctx.current_analysis_path)
                   end
 
         if env
@@ -883,7 +883,7 @@ module MilkTea
           }
         end
 
-        raise LoweringError, "formatted string interpolation supports str, cstr, bool, numeric primitives, integer-backed enums/flags, and types implementing format_len()/append_format(output: ref[std.string.String]), got #{type}"
+        raise LoweringError.new("formatted string interpolation supports str, cstr, bool, numeric primitives, integer-backed enums/flags, and types implementing format_len()/append_format(output: ref[std.string.String]), got #{type}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
 
       def format_string_hex_append_plan(type, uppercase:)
@@ -892,7 +892,7 @@ module MilkTea
         end
 
         unless type.is_a?(Types::Primitive) && type.integer?
-          raise LoweringError, "format spec ':x' and ':X' require integer interpolation, got #{type}"
+          raise LoweringError.new("format spec ':x' and ':X' require integer interpolation, got #{type}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
 
         if type.signed_integer?
@@ -903,7 +903,7 @@ module MilkTea
           return [uppercase ? "append_ulong_hex_upper" : "append_ulong_hex", @ctx.types.fetch("ulong")]
         end
 
-        raise LoweringError, "format spec ':x' and ':X' require integer interpolation, got #{type}"
+        raise LoweringError.new("format spec ':x' and ':X' require integer interpolation, got #{type}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
 
       def format_string_oct_append_plan(type, uppercase:)
@@ -913,7 +913,7 @@ module MilkTea
         end
 
         unless type.is_a?(Types::Primitive) && type.integer?
-          raise LoweringError, "format spec ':o' and ':O' require integer interpolation, got #{type}"
+          raise LoweringError.new("format spec ':o' and ':O' require integer interpolation, got #{type}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
 
         if type.signed_integer?
@@ -924,7 +924,7 @@ module MilkTea
           return ["append_ulong_oct", @ctx.types.fetch("ulong")]
         end
 
-        raise LoweringError, "format spec ':o' and ':O' require integer interpolation, got #{type}"
+        raise LoweringError.new("format spec ':o' and ':O' require integer interpolation, got #{type}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
 
       def format_string_bin_append_plan(type, uppercase:)
@@ -934,7 +934,7 @@ module MilkTea
         end
 
         unless type.is_a?(Types::Primitive) && type.integer?
-          raise LoweringError, "format spec ':b' and ':B' require integer interpolation, got #{type}"
+          raise LoweringError.new("format spec ':b' and ':B' require integer interpolation, got #{type}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
 
         if type.signed_integer?
@@ -945,7 +945,7 @@ module MilkTea
           return ["append_ulong_bin", @ctx.types.fetch("ulong")]
         end
 
-        raise LoweringError, "format spec ':b' and ':B' require integer interpolation, got #{type}"
+        raise LoweringError.new("format spec ':b' and ':B' require integer interpolation, got #{type}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
 
       def mt_format_length_c_name(name)
@@ -1261,7 +1261,7 @@ module MilkTea
       end
 
       def materialize_prepared_expression(setup, value, env:, type:, prefix:)
-        raise LoweringError, "cannot use void expression inline" unless value
+        raise LoweringError.new("cannot use void expression inline", line: 0, column: 0, path: @ctx.current_analysis_path) unless value
 
         if value.is_a?(IR::Name)
           register_prepared_temp!(env, value.name, value.type, pointer: value.pointer)
@@ -1316,7 +1316,7 @@ module MilkTea
 
         case expression
         when AST::AwaitExpr
-          raise LoweringError, "await expressions must be lowered in async statement context"
+          raise LoweringError.new("await expressions must be lowered in async statement context", line: 0, column: 0, path: @ctx.current_analysis_path)
         when AST::IntegerLiteral
           IR::IntegerLiteral.new(value: expression.value, type:)
         when AST::CharLiteral
@@ -1341,7 +1341,7 @@ module MilkTea
         when AST::StringLiteral
           IR::StringLiteral.new(value: expression.value, type:, cstring: expression.cstring)
         when AST::FormatString
-          raise LoweringError, "unprepared format string reached raw lowering; format strings should be materialized before direct lowering"
+          raise LoweringError.new("unprepared format string reached raw lowering; format strings should be materialized before direct lowering", line: 0, column: 0, path: @ctx.current_analysis_path)
         when AST::BooleanLiteral
           IR::BooleanLiteral.new(value: expression.value, type:)
         when AST::NullLiteral
@@ -1352,12 +1352,12 @@ module MilkTea
             lower_bound_identifier(binding, expected_type:)
           elsif @ctx.functions.key?(expression.name)
             function_binding = @ctx.functions.fetch(expression.name)
-            raise LoweringError, "generic function #{expression.name} cannot be used as a value" if function_binding.type_params.any?
-            raise LoweringError, "foreign function #{expression.name} cannot be used as a value" if foreign_function_binding?(function_binding)
+            raise LoweringError.new("generic function #{expression.name} cannot be used as a value", line: 0, column: 0, path: @ctx.current_analysis_path) if function_binding.type_params.any?
+            raise LoweringError.new("foreign function #{expression.name} cannot be used as a value", line: 0, column: 0, path: @ctx.current_analysis_path) if foreign_function_binding?(function_binding)
 
             IR::Name.new(name: function_binding_c_name(function_binding, module_name: @ctx.module_name), type: type, pointer: false)
           else
-            raise LoweringError, "unsupported identifier #{expression.name}"
+            raise LoweringError.new("unsupported identifier #{expression.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
           end
         when AST::MemberAccess
           lower_member_access(expression, env:, type:)
@@ -1373,7 +1373,7 @@ module MilkTea
             IR::Index.new(receiver:, index:, type:)
           end
         when AST::UnaryOp
-          raise LoweringError, "propagation expressions must be prepared before direct lowering" if expression.operator == "?"
+          raise LoweringError.new("propagation expressions must be prepared before direct lowering", line: 0, column: 0, path: @ctx.current_analysis_path) if expression.operator == "?"
 
           operand = lower_expression(expression.operand, env:, expected_type: type)
           expanded = lower_vector_unary_op(expression.operator, operand, type)
@@ -1403,7 +1403,7 @@ module MilkTea
             type:,
           )
         when AST::MatchExpr
-          raise LoweringError, "match expressions must be prepared before direct lowering"
+          raise LoweringError.new("match expressions must be prepared before direct lowering", line: 0, column: 0, path: @ctx.current_analysis_path)
         when AST::UnsafeExpr
           lower_expression(expression.expression, env:, expected_type: type)
         when AST::ProcExpr
@@ -1444,7 +1444,7 @@ module MilkTea
             IR::AggregateLiteral.new(type:, fields:)
           end
         else
-          raise LoweringError, "unsupported expression #{expression.class.name}"
+          raise LoweringError.new("unsupported expression #{expression.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
       end
 
@@ -1466,8 +1466,8 @@ module MilkTea
           imported_module = @ctx.imports.fetch(expression.receiver.name)
           if imported_module.functions.key?(expression.member)
             function_binding = imported_module.functions.fetch(expression.member)
-            raise LoweringError, "generic function #{expression.receiver.name}.#{expression.member} cannot be used as a value" if function_binding.type_params.any?
-            raise LoweringError, "foreign function #{expression.receiver.name}.#{expression.member} cannot be used as a value" if foreign_function_binding?(function_binding)
+            raise LoweringError.new("generic function #{expression.receiver.name}.#{expression.member} cannot be used as a value", line: 0, column: 0, path: @ctx.current_analysis_path) if function_binding.type_params.any?
+            raise LoweringError.new("foreign function #{expression.receiver.name}.#{expression.member} cannot be used as a value", line: 0, column: 0, path: @ctx.current_analysis_path) if foreign_function_binding?(function_binding)
 
             return IR::Name.new(name: function_binding_c_name(function_binding, module_name: imported_module.name), type:, pointer: false)
           end
@@ -1611,7 +1611,7 @@ module MilkTea
 
       def lower_soa_indexed_field_access(soa_base, index_expr, field_name, soa_type, env:, type:)
         field_type = soa_type.fields[field_name]
-        raise LoweringError, "SoA type #{soa_type} has no field #{field_name}" unless field_type
+        raise LoweringError.new("SoA type #{soa_type} has no field #{field_name}", line: 0, column: 0, path: @ctx.current_analysis_path) unless field_type
 
         receiver = lower_expression(soa_base, env:)
         index = lower_expression(index_expr, env:)

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

@@ -65,7 +65,7 @@ module MilkTea
           IR::Name.new(name: items_name, type: items_type, pointer: false),
           pointer_to(boundary_type.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
 
         IR::AggregateLiteral.new(
           type: boundary_type,
@@ -109,7 +109,7 @@ module MilkTea
           item = IR::Member.new(receiver: item, member: "data", type: pointer_to(@ctx.types.fetch("char"))) if item_type == @ctx.types.fetch("str")
 
           converted = foreign_identity_projection_expression(item, boundary_element_type)
-          raise LoweringError, "unsupported foreign boundary mapping #{parameter.type} as #{boundary_type}" unless converted
+          raise LoweringError.new("unsupported foreign boundary mapping #{parameter.type} as #{boundary_type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless converted
 
           converted
         end

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

@@ -107,7 +107,7 @@ module MilkTea
           return imported_module.types.fetch(parts.last)
         end
 
-        raise LoweringError, "unsupported extending target #{type_name}"
+        raise LoweringError.new("unsupported extending target #{type_name}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
 
       def lower_function_decl(binding, receiver_type: nil)

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

@@ -133,7 +133,7 @@ module MilkTea
       def lower_collection_for_stmt(statement, env:, active_defers:, return_type:, allow_return:)
         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], span[T], or an iterable with iter()/next(), got #{iterable_type}" unless element_type
+        raise LoweringError.new("for loop expects start..stop, array[T, N], span[T], or an iterable with iter()/next(), 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)
         binding_type = collection_loop_binding_type(iterable_type, element_type) || element_type
 
@@ -207,7 +207,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:,
@@ -304,7 +304,7 @@ module MilkTea
       def lower_iterator_for_stmt(statement, env:, active_defers:, return_type:, allow_return:)
         iterable_type = infer_expression_type(statement.iterable, env:)
         iterator_info = iterator_loop_info(iterable_type, env:)
-        raise LoweringError, "for loop expects start..stop, array[T, N], span[T], or an iterable with iter()/next(), got #{iterable_type}" unless iterator_info
+        raise LoweringError.new("for loop expects start..stop, array[T, N], span[T], or an iterable with iter()/next(), got #{iterable_type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless iterator_info
 
         iterable_setup, prepared_iterable = prepare_expression_for_inline_lowering(statement.iterable, env:, expected_type: iterable_type)
         iterator_c_name = fresh_c_temp_name(env, "for_iterator")
@@ -809,7 +809,7 @@ module MilkTea
         if captures.empty?
           worker_body = block_body.dup
         else
-          raise LoweringError, "detach with captured variables is not yet supported; use a global function call or module-level variables"
+          raise LoweringError.new("detach with captured variables is not yet supported; use a global function call or module-level variables", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
 
         @artifacts.synthetic_functions << IR::Function.new(
@@ -833,7 +833,7 @@ module MilkTea
 
       def validate_pfor_no_ref_captures!(captures)
         captures.each do |c|
-          raise LoweringError, "cannot capture '#{c.name}' of type ref across thread boundary — ref values are not safe to share across threads" if ref_type?(c.type)
+          raise LoweringError.new("cannot capture '#{c.name}' of type ref across thread boundary — ref values are not safe to share across threads", line: 0, column: 0, path: @ctx.current_analysis_path) if ref_type?(c.type)
         end
       end
 
@@ -844,7 +844,7 @@ module MilkTea
               next if idx == other_idx
               next unless other[:capture_names].include?(name)
 
-              raise LoweringError, "write conflict in parallel block: '#{name}' is written in spawn block #{idx + 1} and accessed in spawn block #{other_idx + 1}"
+              raise LoweringError.new("write conflict in parallel block: '#{name}' is written in spawn block #{idx + 1} and accessed in spawn block #{other_idx + 1}", line: 0, column: 0, path: @ctx.current_analysis_path)
             end
           end
         end

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

@@ -193,7 +193,7 @@ module MilkTea
         when AST::BreakStmt, AST::ContinueStmt, AST::PassStmt
           nil
         else
-          raise LoweringError, "unsupported proc capture statement #{statement.class.name}"
+          raise LoweringError.new("unsupported proc capture statement #{statement.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
       end
 
@@ -248,7 +248,7 @@ module MilkTea
              AST::BooleanLiteral, AST::NullLiteral
           nil
         else
-          raise LoweringError, "unsupported proc capture expression #{expression.class.name}"
+          raise LoweringError.new("unsupported proc capture expression #{expression.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
       end
 
@@ -321,7 +321,7 @@ module MilkTea
         when Types::Nullable
           []
         else
-          raise LoweringError, "unsupported proc lifecycle container #{type.class.name}"
+          raise LoweringError.new("unsupported proc lifecycle container #{type.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
       end