mt-lang 0.3.6 → 0.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d5caebfa149a9d43d576f3cbf1b36b175ce70b28bfe474bc942fc2d11f0f1e8
-  data.tar.gz: bf9f4a30b1cabadbed2b2d276dd29d567e118d008000791eefb2ec0e81f80c4f
+  metadata.gz: 180f49844f839480b6aed67ca33f5aef4532cb0a372dce913699b892fc85c4b1
+  data.tar.gz: f99ec00f1749c5142694ff93211a9745cc1cbd0c53e7a1b311125a53aafedfd0
 SHA512:
-  metadata.gz: 681c1614c3449f16bb71fbb0f9ee7e9ec10420e302602b131c4ed813b087742e7474ff71e9111f5d35cb1e4315eb440c3c85e29d66e8c733159063cbe946ea01
-  data.tar.gz: 6ea9caabdb7407f64d634f6576135df74e614878f81680777062c2e5f64f75278bb56f71bb48406153e40745e2d2b458e99c46193c9c85837c2b28b3b7aca4b4
+  metadata.gz: 8874f3444b514ac33d33949a01d438a5de17139443e618ba2fc282a47fefc9138df686493eb368b116802750a03b844535f881a2ba48c3fae8fbcfbb4062b608
+  data.tar.gz: 0172adf373b345e1b3d40f79c4c0f3e05e2da088053af78b582f258cff87312dd2bac29ba2434bafab09630e13455c7f75ea32cb33a517694206e46a4f2ce95e

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.3.6"
+  VERSION = "0.3.8"
 
   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/control_flow/builder.rb

@@ -137,7 +137,12 @@ module MilkTea
             @graph.add_edge(match_id, next_id)
           else
             stmt.arms.each do |arm|
-              arm_entry = build_block(arm.body, next_id, break_target:, continue_target:)
+              arm_body = if arm.respond_to?(:body)
+                           arm.body
+                         else
+                           [MilkTea::AST::ExpressionStmt.new(expression: arm.value, line: arm.value.respond_to?(:line) ? arm.value.line : nil)]
+                         end
+              arm_entry = build_block(arm_body, next_id, break_target:, continue_target:)
               if arm.binding_name
                 binding_key = declaration_binding_key(arm, arm.binding_name)
                 if binding_key

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?