mt-lang 0.3.5 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ba5797b3cf3ff504321adf78e281c017a4ca3aa30088f5d472c01fe157f7b4f
-  data.tar.gz: f1b7c0dd477f0e0868e6b3da0fa7f640ace5ef9d53703a7aa8ab89b8907999c9
+  metadata.gz: 3f5f1a4cb47c9822d4aef3caefdd90aca32171fe59775d7906ab9c1485a422cb
+  data.tar.gz: 72e1d25c2082827fd40f723ac4f3b11045391dda39b1f8ef339aa5fac5e57611
 SHA512:
-  metadata.gz: 9db5f6898f03726a69d907b0a5dec9d19a52ac3141e8cfdda443797476d9fc8f7b0e426812288babdbba3f48d270499e49998224a4509705286992bfd117e810
-  data.tar.gz: 5de95e68ce290fa2e3f80e5d595e29dba7d19093f91dcc169c6773a027fe80f3866f38a213713709911aeda767ccd28b30eb3b4765b5d58319997aaec587f414
+  metadata.gz: b6362b05316203c6b8d6e5c48cbfddad6351540096f9bc90580b8903866bb165e202cc654bd083c4e1de8786acb3f74e86ec85bbb020ee0e5c6874b46ef088fb
+  data.tar.gz: 0c7ffb83f660d7d1a30dbbb42713e5e798ff983795590d3e14074346d350f268184de505fc0091c14c975fcc7d141039368e652a2f0540b533575dcf8a097389

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.3.5"
+  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

@@ -33,7 +33,12 @@ module MilkTea
             when IR::NullableSpanIndex
               "#{nullable_span_index_helper_name(expression.receiver_type)}(#{emit_expression(expression.receiver)}, #{emit_expression(expression.index)})"
             when IR::Call
-              raise CBackendError, "array-return call must be materialized before C emission" if array_type?(expression.type)
+              if array_type?(expression.type)
+                location = [@source_path, @current_line && "line #{@current_line}"].compact.join(" ")
+                msg = "array-return call must be materialized before C emission"
+                msg += " (#{location})" unless location.empty?
+                raise CBackendError.new(msg, line: @current_line, path: @source_path)
+              end
 
               emit_call_expression(expression)
             when IR::Unary
@@ -100,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
 
@@ -158,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
 
@@ -403,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

@@ -23,6 +23,10 @@ module MilkTea
             indent = INDENT * level
             aliases = checked_index_aliases_for_statement(statement)
             alias_lines = emit_checked_index_alias_declarations(aliases, indent)
+            if statement.respond_to?(:line) && statement.line
+              @current_line = statement.line
+              @source_path ||= statement.source_path if statement.respond_to?(:source_path) && statement.source_path
+            end
             line_directive = if @emit_line_directives && statement.respond_to?(:line) && statement.line
                                sp = (statement.respond_to?(:source_path) && statement.source_path) || @source_path
                                sp ? ["#line #{statement.line} #{sp.inspect}"] : []
@@ -174,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
 
@@ -497,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
 
@@ -529,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/c_backend.rb

@@ -55,6 +55,8 @@ module MilkTea
       @checked_index_alias_id = 0
       @loop_guard_id = 0
       @emitted_span_type_names = Set.new
+      @source_path = program.source_path
+      @current_line = nil
     end
 
     def emit
@@ -218,10 +220,16 @@ module MilkTea
       end
 
       constants.each do |constant|
+        @current_line = constant.line if constant.line
+        @source_path ||= constant.source_path if constant.source_path
         lines << "#{constant_storage(constant.type)} #{c_declaration(constant.type, constant.linkage_name)} = #{emit_initializer(constant.value)};"
       end
       @program.globals.each do |global|
         next unless emitted_globals.include?(global)
+        if global.respond_to?(:line) && global.line
+          @current_line = global.line
+          @source_path ||= global.source_path if global.respond_to?(:source_path) && global.source_path
+        end
         lines << "#{global_storage(global.type)} #{c_declaration(global.type, global.linkage_name)} = #{emit_initializer(global.value)};"
       end
       lines << "" unless constants.empty? && @program.globals.empty?

data/lib/milk_tea/core/compile_time.rb

@@ -114,7 +114,12 @@ module MilkTea
                        else
                          @checker.instance_variable_get(:@ctx).types
                        end
-              if (type = types[call_expr.callee.name]) && type.is_a?(Types::Struct)
+              callee_name = if call_expr.callee.is_a?(AST::Specialization) && call_expr.callee.callee.respond_to?(:name)
+                              call_expr.callee.callee.name
+                            elsif call_expr.callee.respond_to?(:name)
+                              call_expr.callee.name
+                            end
+              if callee_name && (type = types[callee_name]) && type.is_a?(Types::Struct)
                 fields = {}
                 call_expr.arguments.each do |argument|
                   val = evaluate_expression(argument.value, scopes:)
@@ -123,6 +128,19 @@ module MilkTea
                 end
                 next fields
               end
+
+              if call_expr.callee.is_a?(AST::Specialization) && @checker.respond_to?(:resolve_type_expression)
+                resolved = @checker.send(:resolve_type_expression, call_expr.callee)
+                if resolved && @checker.respond_to?(:array_type?) && @checker.send(:array_type?, resolved)
+                  values = []
+                  call_expr.arguments.each do |argument|
+                    val = evaluate_expression(argument.value, scopes:)
+                    return nil unless val
+                    values << val
+                  end
+                  next values
+                end
+              end
               
               @checker.send(:evaluate_compile_time_const_value, call_expr, scopes:)
             },

data/lib/milk_tea/core/ir.rb

@@ -6,7 +6,9 @@ module MilkTea
       def initialize(module_name:, includes:, constants:, globals:, opaques:, structs:, unions:, enums:, variants:, static_asserts:, functions:, source_path: nil) = super
     end
     Include = Data.define(:header)
-    Constant = Data.define(:name, :linkage_name, :type, :value)
+    Constant = Data.define(:name, :linkage_name, :type, :value, :line, :source_path) do
+      def initialize(name:, linkage_name:, type:, value:, line: nil, source_path: nil) = super
+    end
     Global = Data.define(:name, :linkage_name, :type, :value)
     OpaqueDecl = Data.define(:name, :linkage_name, :forward_declarable, :source_module) do
       def initialize(name:, linkage_name:, forward_declarable:, source_module: nil) = super

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
 
@@ -353,7 +358,8 @@ module MilkTea
         value = lower_static_storage_initializer(decl.value, env:, expected_type: decl.type ? resolve_type_ref(decl.type) : nil)
         type = decl.type ? resolve_type_ref(decl.type) : infer_expression_type(decl.value, env:)
         linkage_name = value_c_name(decl.name)
-        constant = IR::Constant.new(name: decl.name, linkage_name:, type:, value:)
+        constant = IR::Constant.new(name: decl.name, linkage_name:, type:, value:,
+                                    line: decl.line, source_path: @ctx.current_analysis_path)
         @artifacts.emitted_declarations << constant
         []
       end
@@ -450,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 = []
@@ -477,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)
@@ -511,7 +519,7 @@ module MilkTea
         env: local_env,
         expected_type: target.type,
         allow_root_statement_foreign: true,
-        materialize_array_calls: !array_type?(target.type),
+        materialize_array_calls: true,
       )
       lowered.concat(prepared_setup)
       if (foreign_call = foreign_call_info(prepared_value, local_env))
@@ -522,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)
@@ -700,7 +710,7 @@ module MilkTea
           env: local_env,
           expected_type: storage_type,
           allow_root_statement_foreign: true,
-          materialize_array_calls: !array_type?(storage_type),
+          materialize_array_calls: true,
         )
         lowered.concat(prepared_setup)
       end
@@ -712,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)
@@ -926,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?