mt-lang 0.3.17 → 0.3.22

data/lib/milk_tea/core/control_flow/builder.rb

@@ -413,7 +413,8 @@ module MilkTea
           read_identifiers(expression.expression, names, reads_info)
           expression.arms.each do |arm|
             read_identifiers(arm.pattern, names, reads_info)
-            read_identifiers(arm.value, names, reads_info)
+            arm_value = arm.is_a?(AST::MatchExprArm) ? arm.value : arm.body
+            read_identifiers(arm_value, names, reads_info)
           end
         when AST::MatchStmt
           read_identifiers(expression.expression, names, reads_info)

data/lib/milk_tea/core/intrinsics.rb

@@ -45,6 +45,13 @@ module MilkTea
       "with" => :simd_lane_with,
     }.freeze
 
+    SPECIALIZED_RECEIVERS = {
+      "str_buffer" => { predicate: :str_buffer_type?, kinds: STR_BUFFER_METHOD_KINDS },
+      "event"      => { predicate: :event_type?,      kinds: EVENT_METHOD_KINDS },
+      "atomic"     => { predicate: :atomic_type?,     kinds: ATOMIC_METHOD_KINDS },
+      "simd"       => { predicate: :simd_type?,       kinds: SIMD_METHOD_KINDS },
+    }.freeze
+
     def type_ref_from_specialization(expression)
       case expression.callee
       when AST::Identifier

data/lib/milk_tea/core/lexer.rb

@@ -279,43 +279,17 @@ module MilkTea
           break
         end
 
-        if char == "c" && heredoc_start?(line, index, cstring: true)
-          return lex_heredoc(lines, line_index, index, line_number, line_offset, cstring: true)
-        end
-
-        if char == "c" && line[index + 1] == "<" && line[index + 2] == "-" && identifier_start?(line[index + 3])
-          error = LexError.new("expected '<<-' for heredoc string; did you mean 'c<<-#{identifier_start_token(line, index + 3)}'?", line: line_number, column: index + 1, path: @path)
-          if @recovery_errors
-            @recovery_errors << error
-          else
-            raise error
+        if (char == "c" || char == "f")
+          result = dispatch_cf_prefix(char, line, index, line_number, line_offset, lines:, line_index:)
+          if result
+            if result[0] == :return
+              return result[1]
+            else
+              index = result[1]
+              next
+            end
           end
         end
-        if char == "c" && line[index + 1] == '"'
-          result = lex_string(lines, line_index, line, index, line_number, line_offset:, cstring: true)
-          return result.consumed_lines if result.consumed_lines > 1
-
-          index = result.next_index
-          next
-        end
-
-        if char == "f" && heredoc_start?(line, index, format: true)
-          return lex_heredoc(lines, line_index, index, line_number, line_offset, cstring: false, format: true)
-        end
-
-        if char == "f" && line[index + 1] == "<" && line[index + 2] == "-" && identifier_start?(line[index + 3])
-          error = LexError.new("expected '<<-' for heredoc string; did you mean 'f<<-#{identifier_start_token(line, index + 3)}'?", line: line_number, column: index + 1, path: @path)
-          if @recovery_errors
-            @recovery_errors << error
-          else
-            raise error
-          end
-        end
-
-        if char == "f" && line[index + 1] == '"'
-          index = lex_format_string(line, index, line_number, line_offset:)
-          next
-        end
 
         if char == "<" && heredoc_start?(line, index)
           return lex_heredoc(lines, line_index, index, line_number, line_offset, cstring: false)
@@ -391,6 +365,43 @@ module MilkTea
       end
     end
 
+    def dispatch_cf_prefix(char, line, index, line_number, line_offset, lines:, line_index:)
+      return nil unless char == "c" || char == "f"
+
+      is_c = char == "c"
+      is_f = char == "f"
+
+      if heredoc_start?(line, index, cstring: is_c, format: is_f)
+        n = lex_heredoc(lines, line_index, index, line_number, line_offset, cstring: is_c, format: is_f)
+        return [:return, n]
+      end
+
+      if line[index + 1] == "<" && line[index + 2] == "-" && identifier_start?(line[index + 3])
+        error = LexError.new("expected '<<-' for heredoc string; did you mean '#{char}<<-#{identifier_start_token(line, index + 3)}'?", line: line_number, column: index + 1, path: @path)
+        if @recovery_errors
+          @recovery_errors << error
+        else
+          raise error
+        end
+        return nil
+      end
+
+      if line[index + 1] == '"'
+        if is_c
+          string_result = lex_string(lines, line_index, line, index, line_number, line_offset:, cstring: true)
+          if string_result.consumed_lines > 1
+            return [:return, string_result.consumed_lines]
+          end
+          return [:next, string_result.next_index]
+        end
+
+        new_index = lex_format_string(line, index, line_number, line_offset:)
+        return [:next, new_index]
+      end
+
+      nil
+    end
+
     def token(type, lexeme, literal, line, column, start_offset:, end_offset:)
       Token.new(
         type:,

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

@@ -1,5 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "expressions"
+require_relative "loops"
+require_relative "proc"
+require_relative "resolve"
+require_relative "utils"
+require_relative "foreign_cstr"
+require_relative "declarations"
+require_relative "calls"
+
 module MilkTea
   module LowererBlock
     def lower_block(statements, env:, active_defers:, return_type:, loop_flow:, allow_return: true)

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "dyn"
+
 module MilkTea
   module LowererCalls
     def lower_call(expression, env:, type:)

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

@@ -78,7 +78,7 @@ module MilkTea
         end
         IR::AggregateLiteral.new(type:, fields:)
       else
-        IR::IntegerLiteral.new(value: 0, type:)
+        raise LoweringError.new("unsupported const value type #{const_value.class}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
     end
 

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

@@ -1,14 +1,19 @@
 # frozen_string_literal: true
 
+require_relative "resolve"
+require_relative "utils"
+require_relative "block"
+require_relative "async/normalization"
+require_relative "async/lowering"
+
 module MilkTea
   module LowererFunctions
     def lower_functions
       lowered = []
+      cursor = 0
+      declarations = @ctx.ast.declarations
 
-      changed = true
-      while changed
-        changed = false
-
+      while cursor < declarations.length
         expanded_declarations.each do |decl|
           case decl
           when AST::FunctionDef
@@ -21,7 +26,6 @@ module MilkTea
 
                 lowered << lower_function_decl(instance)
                 @artifacts.lowered_function_linkage_names[linkage_name] = true
-                changed = true
               end
             else
               linkage_name = function_binding_c_name(binding, module_name: @ctx.module_name)
@@ -37,7 +41,6 @@ module MilkTea
                   @artifacts.lowered_function_linkage_names[entrypoint.linkage_name] = true
                 end
               end
-              changed = true
             end
           when AST::ExtendingBlock
             receiver_type = resolve_extending_receiver_type(@ctx.analysis, decl.type_name)
@@ -56,7 +59,6 @@ module MilkTea
 
                   lowered << lower_function_decl(instance, receiver_type:)
                   @artifacts.lowered_function_linkage_names[linkage_name] = true
-                  changed = true
                 end
               else
                 linkage_name = function_binding_c_name(binding, module_name: @ctx.module_name, receiver_type:)
@@ -64,11 +66,12 @@ module MilkTea
 
                 lowered << lower_function_decl(binding, receiver_type:)
                 @artifacts.lowered_function_linkage_names[linkage_name] = true
-                changed = true
               end
             end
           end
         end
+
+        cursor = declarations.length
       end
 
       lowered

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

@@ -1506,7 +1506,7 @@ module MilkTea
       case argument
       when AST::TypeRef
         resolve_type_argument_ref(argument, type_params:)
-      when AST::FunctionType, AST::ProcType
+      when AST::FunctionType, AST::ProcType, AST::TupleType
         resolve_type_ref(argument, type_params:)
       when AST::IntegerLiteral, AST::FloatLiteral
         Types::LiteralTypeArg.new(argument.value)
@@ -1518,12 +1518,19 @@ module MilkTea
     def resolve_type_argument_ref(type_ref, type_params:)
       return resolve_type_ref(type_ref, type_params:) unless literal_type_argument_name_candidate?(type_ref)
 
-      resolve_type_ref(type_ref, type_params:)
-    rescue LoweringError => error
+      result = try_resolve_type_ref(type_ref, type_params:)
+      return result if result
+
       literal_type_argument = resolve_named_literal_type_argument(type_ref)
       return literal_type_argument if literal_type_argument
 
-      raise error
+      resolve_type_ref(type_ref, type_params:)
+    end
+
+    def try_resolve_type_ref(type_ref, type_params:)
+      resolve_type_ref(type_ref, type_params:)
+    rescue LoweringError
+      nil
     end
 
     def literal_type_argument_name_candidate?(type_ref)

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

@@ -1,26 +1,20 @@
 # frozen_string_literal: true
 
+require_relative "functions"
+require_relative "resolve"
+require_relative "utils"
+
 module MilkTea
   module LowererScans
     def collect_structs
-      @ctx.ast.declarations.each do |decl|
-        case decl
-        when AST::WhenStmt
-          body = lower_when_chosen_body(decl)
-          body&.each { |nested| collect_struct_from_decl(nested) }
-        when AST::OpaqueDecl
-          @ctx.opaque_types[decl.name] = @ctx.types.fetch(decl.name)
-        when AST::StructDecl
-          @ctx.struct_types[decl.name] = @ctx.types.fetch(decl.name)
-          collect_nested_structs(decl)
-        when AST::UnionDecl
-          @ctx.union_types[decl.name] = @ctx.types.fetch(decl.name)
-        end
-      end
+      @ctx.ast.declarations.each { |decl| collect_one_struct_decl(decl) }
     end
 
-    def collect_struct_from_decl(decl)
+    def collect_one_struct_decl(decl)
       case decl
+      when AST::WhenStmt
+        body = lower_when_chosen_body(decl)
+        body&.each { |nested| collect_one_struct_decl(nested) }
       when AST::OpaqueDecl
         @ctx.opaque_types[decl.name] = @ctx.types.fetch(decl.name)
       when AST::StructDecl
@@ -28,12 +22,13 @@ module MilkTea
         collect_nested_structs(decl)
       when AST::UnionDecl
         @ctx.union_types[decl.name] = @ctx.types.fetch(decl.name)
-      when AST::WhenStmt
-        body = lower_when_chosen_body(decl)
-        body&.each { |nested| collect_struct_from_decl(nested) }
       end
     end
 
+    def collect_struct_from_decl(decl)
+      collect_one_struct_decl(decl)
+    end
+
     def lower_when_chosen_body(decl)
       val = compile_time_const_value(decl.discriminant)
       return nil if val.nil?

data/lib/milk_tea/core/module_binder.rb

@@ -20,19 +20,24 @@ module MilkTea
         when AST::StructDecl, AST::UnionDecl, AST::VariantDecl, AST::EnumDecl, AST::FlagsDecl, AST::OpaqueDecl, AST::TypeAliasDecl
           type_declarations[declaration.name] = declaration
           target = exported_declaration?(analysis, declaration) ? types : private_types
-          target[declaration.name] = analysis.types.fetch(declaration.name)
+          resolved_type = analysis.types[declaration.name]
+          target[declaration.name] = resolved_type if resolved_type
         when AST::InterfaceDecl
           target = exported_declaration?(analysis, declaration) ? interfaces : private_interfaces
-          target[declaration.name] = analysis.interfaces.fetch(declaration.name)
+          resolved_iface = analysis.interfaces[declaration.name]
+          target[declaration.name] = resolved_iface if resolved_iface
         when AST::AttributeDecl
           target = exported_declaration?(analysis, declaration) ? attributes : private_attributes
-          target[declaration.name] = analysis.attributes.fetch(declaration.name)
+          resolved_attr = analysis.attributes[declaration.name]
+          target[declaration.name] = resolved_attr if resolved_attr
         when AST::ConstDecl, AST::VarDecl, AST::EventDecl
           target = exported_declaration?(analysis, declaration) ? values : private_values
-          target[declaration.name] = analysis.values.fetch(declaration.name)
+          resolved_val = analysis.values[declaration.name]
+          target[declaration.name] = resolved_val if resolved_val
         when AST::FunctionDef, AST::ExternFunctionDecl, AST::ForeignFunctionDecl
           target = exported_declaration?(analysis, declaration) ? functions : private_functions
-          target[declaration.name] = analysis.functions.fetch(declaration.name)
+          resolved_func = analysis.functions[declaration.name]
+          target[declaration.name] = resolved_func if resolved_func
         end
       end
 
@@ -136,17 +141,16 @@ module MilkTea
       imported_interface_binding?(interface, analysis.imports)
     end
 
+    BUILTIN_EXPORTABLE_RECEIVER_TYPES = %w[
+      StringView Primitive Vector Matrix Quaternion SoA Simd Span Task Dyn
+    ].map { |n| "Types::#{n}" }.freeze
+
+    def builtin_exportable_receiver?(receiver_type)
+      BUILTIN_EXPORTABLE_RECEIVER_TYPES.any? { |name| receiver_type.class.to_s.end_with?(name.split("::").last) }
+    end
+
     def exported_method_receiver?(receiver_type, analysis, exported_types)
-      return true if receiver_type.is_a?(Types::StringView)
-      return true if receiver_type.is_a?(Types::Primitive)
-      return true if receiver_type.is_a?(Types::Vector)
-      return true if receiver_type.is_a?(Types::Matrix)
-      return true if receiver_type.is_a?(Types::Quaternion)
-      return true if receiver_type.is_a?(Types::SoA)
-      return true if receiver_type.is_a?(Types::Simd)
-      return true if receiver_type.is_a?(Types::Span)
-      return true if receiver_type.is_a?(Types::Task)
-      return true if receiver_type.is_a?(Types::Dyn)
+      return true if builtin_exportable_receiver?(receiver_type)
       return true if exported_types.value?(receiver_type)
       return true if imported_receiver_type?(receiver_type, analysis.imports)
       return exported_method_receiver?(receiver_type.base, analysis, exported_types) if receiver_type.is_a?(Types::Nullable)