mt-lang 0.3.24 → 0.3.26

data/lib/milk_tea/core/lowering.rb

@@ -10,11 +10,11 @@
 #   .imports                imported module bindings
 #   .types                  Hash[name → Types::Base]
 #   .interfaces             Hash[name → InterfaceBinding|GenericInterfaceBinding]
-#   .attributes             Hash[name → AttributeBinding]
+#   .attributes             Hash[name → Bindings::AttributeBinding]
 #   .attribute_applications Hash[...]
-#   .values                 Hash[name → ValueBinding]
-#   .functions              Hash[name → FunctionBinding]
-#   .methods                Hash[type → Hash[name → FunctionBinding]]
+#   .values                 Hash[name → Bindings::ValueBinding]
+#   .functions              Hash[name → Bindings::FunctionBinding]
+#   .methods                Hash[type → Hash[name → Bindings::FunctionBinding]]
 #   .implemented_interfaces Hash[type → Set[InterfaceBinding]]
 #   .resolved_expr_types   Hash[expression.object_id → Types::Base]
 #   .uses_parallel_for      bool
@@ -30,7 +30,7 @@ require_relative "lowering/events"
 require_relative "lowering/functions"
 require_relative "lowering/async/analysis"
 require_relative "lowering/async/normalization"
-require_relative "lowering/async/lowering"
+require_relative "lowering/async/async_lowering"
 require_relative "lowering/async/frame_builder"
 require_relative "lowering/block"
 require_relative "lowering/proc"
@@ -61,7 +61,7 @@ module MilkTea
     end
   end
 
-  class Lowering
+  module Lowering
     def self.lower(program)
       lowerer = Lowerer.new(program)
       ir_program, _modules, _synths = lowerer.lower_and_assemble
@@ -90,25 +90,25 @@ module MilkTea
     attr_accessor :bypass_sema_type_cache
     attr_reader :recorded_expr_types
 
-    include LowererScans
-    include LowererDeclarations
-    include LowererEvents
-    include LowererFunctions
-    include LowererAsync
-    include LowererBlock
-    include LowererProc
-    include LowererLoops
-    include LowererExpressions
-    include LowererCalls
-    include LowererForeignCstr
-    include LowererStrBuffer
-    include LowererResolve
-    include LowererDyn
-    include LowererUtils
+    include Lowering::Scans
+    include Lowering::Declarations
+    include Lowering::Events
+    include Lowering::Functions
+    include Lowering::Async
+    include Lowering::Block
+    include Lowering::Proc
+    include Lowering::Loops
+    include Lowering::Expressions
+    include Lowering::Calls
+    include Lowering::ForeignCstr
+    include Lowering::StrBuffer
+    include Lowering::Resolve
+    include Lowering::Dyn
+    include Lowering::Utils
 
     def initialize(program)
       @program = program
-      @ctx = ModuleContext.new
+      @ctx = LoweringContext.new
       @artifacts = Artifacts.new
       @synthetic_proc_counter = 0
       @parallel_for_counter = 0

data/lib/milk_tea/core/module_binder.rb

@@ -44,7 +44,7 @@ module MilkTea
       methods, private_methods = exported_methods(analysis, types)
       implemented_interfaces, private_implemented_interfaces = exported_interface_implementations(analysis, types, interfaces)
 
-      ModuleBinding.new(
+      Bindings::ModuleBinding.new(
         name: analysis.module_name,
         types:,
         type_declarations:,

data/lib/milk_tea/core/module_loader.rb

@@ -651,7 +651,7 @@ module MilkTea
           full_binding.types.reject { |name, _| fw_binding.types.key?(name) }
         )
 
-        @forward_bindings[resolved_path] = ModuleBinding.new(
+        @forward_bindings[resolved_path] = Bindings::ModuleBinding.new(
           name: full_binding.name,
           types: merged_types,
           type_declarations: full_binding.type_declarations,
@@ -699,7 +699,7 @@ module MilkTea
         end
       end
 
-      ModuleBinding.new(
+      Bindings::ModuleBinding.new(
         name: module_name, types:, type_declarations: {},
         interfaces: {}, attributes: {}, attribute_applications: {},
         values: {}, functions: {}, methods: {},

data/lib/milk_tea/core/parser/attributes.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module MilkTea
-  module Parse
+  class Parser
     module Attributes
       def parse_attribute_applications
         attributes = []

data/lib/milk_tea/core/parser/blocks.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module MilkTea
-  module Parse
+  class Parser
     module Blocks
       def parse_block
         consume(:colon, "expected ':' before block")
@@ -51,7 +51,7 @@ module MilkTea
         statements
       end
 
-      def parse_named_block(&block)
+      def parse_recoverable_block(&block)
         consume(:colon, "expected ':' before block")
         consume(:newline, "expected newline before block")
         consume(:indent, "expected indented block")

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module MilkTea
-  module Parse
+  class Parser
     module Declarations
       def parse_import
         line = previous.line
@@ -375,9 +375,9 @@ module MilkTea
         name = name_token.lexeme
         lifetime_params, type_params = parse_struct_decl_params
         implements = parse_implements_clause
-        c_name = parse_optional_explicit_c_name
+        c_name = parse_optional_c_name
         packed, alignment = parse_struct_layout_attributes(attributes) if attributes.any?
-        members = parse_named_block do
+        members = parse_recoverable_block do
           parse_struct_member
         end
         fields = members.filter_map { |kind, member| member if kind == :field }
@@ -462,8 +462,8 @@ module MilkTea
         line = previous.line
         name_token = consume_name("expected union name")
         name = name_token.lexeme
-        c_name = parse_optional_explicit_c_name
-        fields = parse_named_block do
+        c_name = parse_optional_c_name
+        fields = parse_recoverable_block do
                        field_name = consume_name_allowing_keywords("expected field name").lexeme
           consume(:colon, "expected ':' after field name")
           field_type = parse_type_ref
@@ -473,7 +473,7 @@ module MilkTea
         AST::UnionDecl.new(name:, c_name:, fields:, visibility:, attributes:, line:, column: name_token.column)
       end
 
-      def parse_optional_explicit_c_name
+      def parse_optional_c_name
         return nil unless match(:equal)
 
         consume(:cstring, "expected C string literal after '='").literal
@@ -516,7 +516,7 @@ module MilkTea
         name_token = consume_name("expected variant name")
         name = name_token.lexeme
         type_params = parse_declaration_type_params
-        arms = parse_named_block do
+        arms = parse_recoverable_block do
           arm_name = consume_name_allowing_keywords("expected variant arm name").lexeme
           fields = if match(:lparen)
                      parsed = parse_comma_separated_until(:rparen) do
@@ -554,7 +554,7 @@ module MilkTea
         name_token = consume_name("expected interface name")
         name = name_token.lexeme
         type_params = parse_declaration_type_params
-        methods = parse_named_block do
+        methods = parse_recoverable_block do
           method_attributes = parse_attribute_applications
           parse_interface_method_decl(attributes: method_attributes)
         end
@@ -566,7 +566,7 @@ module MilkTea
         type_name = parse_type_ref
         receiver_type_param_names = extending_target_type_param_names(type_name)
         methods = with_type_param_names(receiver_type_param_names) do
-          parse_named_block do
+          parse_recoverable_block do
             method_attributes = parse_attribute_applications
             parse_method_def(attributes: method_attributes)
           end
@@ -588,7 +588,7 @@ module MilkTea
           end
           if value.name.parts.length == 1 && value.arguments.empty? && !value.nullable
             name = value.name.parts.first
-            nested_names << name unless known_type_like_name?(name)
+            nested_names << name unless known_type_context_name?(name)
           end
           nested_names
         when AST::FunctionType, AST::ProcType
@@ -613,7 +613,7 @@ module MilkTea
       end
 
       def parse_method_def(attributes: [])
-        visibility, _visibility_token, async, kind, line, name_token = parse_method_like_decl_head
+        visibility, _visibility_token, async, kind, line, name_token = parse_method_head
         name = name_token.lexeme
         type_params, params, return_type, body = parse_callable_signature
         AST::MethodDef.new(name:, type_params:, params:, return_type:, body:, kind:, visibility:, async:, attributes:, line:, column: name_token.column)
@@ -628,7 +628,7 @@ module MilkTea
       end
 
       def parse_interface_method_decl(attributes: [])
-        visibility, visibility_token, async, kind, line, name_token = parse_method_like_decl_head
+        visibility, visibility_token, async, kind, line, name_token = parse_method_head
         raise error(visibility_token, "public is not allowed on interface methods") if visibility == :public
 
         name = name_token.lexeme
@@ -641,7 +641,7 @@ module MilkTea
         AST::InterfaceMethodDecl.new(name:, params:, return_type:, kind:, async:, attributes:, line:, column: name_token.column)
       end
 
-      def parse_method_like_decl_head
+      def parse_method_head
         visibility, visibility_token = parse_visibility
         async = match(:async)
         kind = parse_method_kind
@@ -679,7 +679,7 @@ module MilkTea
           params = parse_params
           return_type = match(:arrow) ? parse_type_ref : nil
           if allow_body
-            body = parse_block_body_safe
+            body = parse_block_body_with_recovery
           else
             consume_end_of_statement
           end
@@ -688,7 +688,7 @@ module MilkTea
         [type_params, params, return_type, body]
       end
 
-      def parse_block_body_safe
+      def parse_block_body_with_recovery
         parse_block
       rescue ParseError => e
         raise unless @recovery_errors

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module MilkTea
-  module Parse
+  class Parser
     module Expressions
       def parse_expression
         return parse_if_expression if match(:if)
@@ -231,7 +231,7 @@ module MilkTea
 
       def try_parse_prefix_cast_expression
         saved_current = @current
-        return nil unless check_name && known_type_like_name?(peek.lexeme)
+        return nil unless check_name && known_type_context_name?(peek.lexeme)
 
         start_token = peek
         expression = nil
@@ -253,7 +253,7 @@ module MilkTea
         expression = parse_unary
         AST::PrefixCast.new(target_type:, expression:, line: start_token.line, column: start_token.column)
       rescue ParseError => e
-        raise e if parse_diagnostic_hint?(e)
+        raise e if diagnostic_hint_error?(e)
 
         nil
       ensure
@@ -324,7 +324,7 @@ module MilkTea
 
         AST::Specialization.new(callee: expression, arguments:)
       rescue ParseError => e
-        raise e if parse_diagnostic_hint?(e)
+        raise e if diagnostic_hint_error?(e)
 
         @current = saved_current
         nil
@@ -344,7 +344,7 @@ module MilkTea
       end
 
       def parse_call_argument
-        if (check_name || keyword_token?(peek)) && check_next(:equal)
+        if (check_name || keyword?(peek)) && check_next(:equal)
           name = advance.lexeme
           consume(:equal, "expected '=' after named argument name")
           AST::Argument.new(name:, value: parse_expression)
@@ -355,15 +355,15 @@ module MilkTea
 
       def parse_primary
         if match(:size_of)
-          parse_sizeof_expr
+          parse_sizeof_expression
         elsif match(:align_of)
-          parse_alignof_expr
+          parse_alignof_expression
         elsif match(:offset_of)
-          parse_offsetof_expr
+          parse_offsetof_expression
         elsif match(:members_of) || match(:attributes_of) || match(:field_of) || match(:callable_of) || match(:attribute_of) || match(:has_attribute) || match(:attribute_arg) || match(:fields_of)
           AST::Identifier.new(name: previous.lexeme, line: previous.line, column: previous.column)
         elsif match(:proc)
-          parse_proc_expr
+          parse_proc_expression
         elsif match_name
           AST::Identifier.new(name: previous.lexeme, line: previous.line, column: previous.column)
         elsif match(:integer)
@@ -394,7 +394,7 @@ module MilkTea
         elsif match(:lparen)
           line = previous.line
           column = previous.column
-          first = if (check_name || keyword_token?(peek)) && check_next(:equal)
+          first = if (check_name || keyword?(peek)) && check_next(:equal)
                     name_token = advance
                     consume(:equal, "expected '=' after named tuple field")
                     AST::Argument.new(name: name_token.lexeme, value: parse_expression)
@@ -404,7 +404,7 @@ module MilkTea
           if match(:comma)
             elements = [first]
             loop do
-              if (check_name || keyword_token?(peek)) && check_next(:equal)
+              if (check_name || keyword?(peek)) && check_next(:equal)
                 name_token = advance
                 consume(:equal, "expected '=' after named tuple field")
                 value = parse_expression
@@ -421,7 +421,7 @@ module MilkTea
             consume(:rparen, "expected ')' after expression")
             first
           end
-        elsif keyword_token?(peek)
+        elsif keyword?(peek)
           advance
           AST::Identifier.new(name: previous.lexeme, line: previous.line, column: previous.column)
         else
@@ -444,9 +444,9 @@ module MilkTea
         AST::StringLiteral.new(lexeme:, value:, cstring: all_cstring)
       end
 
-      def parse_proc_expr
+      def parse_proc_expression
         consume(:lparen, "expected '(' after proc")
-        params = parse_comma_separated_until(:rparen) { parse_function_type_param }
+        params = parse_comma_separated_until(:rparen) { parse_callable_type_param }
 
         consume(:rparen, "expected ')' after proc parameters")
         consume(:arrow, "expected '->' after proc parameters")
@@ -463,21 +463,21 @@ module MilkTea
         AST::ProcExpr.new(params:, return_type:, body:)
       end
 
-      def parse_sizeof_expr
+      def parse_sizeof_expression
         consume(:lparen, "expected '(' after size_of")
         type = parse_type_ref
         consume(:rparen, "expected ')' after size_of type")
         AST::SizeofExpr.new(type:)
       end
 
-      def parse_alignof_expr
+      def parse_alignof_expression
         consume(:lparen, "expected '(' after align_of")
         type = parse_type_ref
         consume(:rparen, "expected ')' after align_of type")
         AST::AlignofExpr.new(type:)
       end
 
-      def parse_offsetof_expr
+      def parse_offsetof_expression
         consume(:lparen, "expected '(' after offset_of")
         type = parse_type_ref
         consume(:comma, "expected ',' after offset_of type")
@@ -581,7 +581,7 @@ module MilkTea
         expression.is_a?(AST::Identifier) && %w[array reinterpret span zero ptr const_ptr own ref adapt equal hash order simd SoA].include?(expression.name)
       end
 
-      def parse_diagnostic_hint?(error)
+      def diagnostic_hint_error?(error)
         error.message.include?("did you mean T<-expr?")
       end
 
@@ -598,7 +598,7 @@ module MilkTea
 
       def specialization_call_target?(expression, arguments, call_arguments)
         if expression.is_a?(AST::Identifier) && %w[default zero].include?(expression.name) &&
-            !known_type_like_name?(expression.name) && !generic_callable_specialization_target?(expression)
+            !known_type_context_name?(expression.name) && !generic_callable_specialization_target?(expression)
           return false
         end
 
@@ -643,7 +643,7 @@ module MilkTea
         when AST::FunctionType, AST::TupleType
           true
         when AST::TypeRef
-          known_type_like_name?(value.name.parts.first)
+          known_type_context_name?(value.name.parts.first)
         else
           false
         end

data/lib/milk_tea/core/parser/recovery.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module MilkTea
-  module Parse
+  class Parser
     module Recovery
       TOP_LEVEL_RECOVERY_START_TYPES = %i[
         module import at public attribute const var type struct union enum flags variant interface

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module MilkTea
-  module Parse
+  class Parser
     module Statements
       def check_inline_stmt_start?
         return false unless check(:inline)
@@ -363,7 +363,7 @@ module MilkTea
                          binding_token.lexeme
                        end
 
-        if match_arm_expr_form?
+        if match_arm_expression_form?
           consume(:colon, "expected ':' after match expression arm pattern")
           value = parse_expression
           finish_expression_statement(value)
@@ -410,7 +410,7 @@ module MilkTea
         raise
       end
 
-      def match_arm_expr_form?
+      def match_arm_expression_form?
         check(:colon) && @current + 1 < @tokens.length && @tokens[@current + 1].type != :newline
       end
 

data/lib/milk_tea/core/parser/types.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module MilkTea
-  module Parse
+  class Parser
     module Types
       def parse_params(allow_variadic: false)
         parse_parameter_list(allow_variadic:) { parse_param }
@@ -63,7 +63,7 @@ module MilkTea
       end
 
       def parse_foreign_param
-        mode = if foreign_param_qualifier_mode?
+        mode = if foreign_param_mode_start?
                  advance.type
                else
                  :plain
@@ -158,7 +158,7 @@ module MilkTea
 
       def parse_callable_type_ref(keyword:, param_context:)
         consume(:lparen, "expected '(' after #{keyword}")
-        params = parse_comma_separated_until(:rparen) { parse_function_type_param }
+        params = parse_comma_separated_until(:rparen) { parse_callable_type_param }
 
         consume(:rparen, "expected ')' after #{param_context}")
         consume(:arrow, "expected '->' after #{param_context}")
@@ -166,7 +166,7 @@ module MilkTea
         yield params, return_type
       end
 
-      def parse_function_type_param
+      def parse_callable_type_param
         name_token = consume_name_allowing_keywords("expected function type parameter name")
         name = name_token.lexeme
         consume(:colon, "expected ':' after function type parameter name")

data/lib/milk_tea/core/parser.rb

@@ -33,6 +33,24 @@ module MilkTea
     end
   end
 
+  class SyntaxTokenStream
+    def initialize(tokens)
+      @tokens = tokens
+    end
+
+    def [](index)
+      @tokens[index]
+    end
+
+    def length
+      @tokens.length
+    end
+
+    def to_a
+      @tokens
+    end
+  end
+
   class Parser
     ParseRecoveryResult = Data.define(:ast, :errors) do
       def initialize(ast:, errors: []) = super
@@ -40,13 +58,13 @@ module MilkTea
 
     ParseContext = Data.define(:known_type_names, :known_import_aliases, :known_generic_callable_names, :current_type_param_names)
 
-    include Parse::Blocks
-    include Parse::Recovery
-    include Parse::Types
-    include Parse::Attributes
-    include Parse::Expressions
-    include Parse::Declarations
-    include Parse::Statements
+    include Blocks
+    include Recovery
+    include Types
+    include Attributes
+    include Expressions
+    include Declarations
+    include Statements
 
     def self.parse(source = nil, path: nil, tokens: nil)
       token_stream = tokens || Lexer.lex(source, path: path)
@@ -106,7 +124,7 @@ module MilkTea
       directives = []
       declarations = []
 
-      if external_file_header?
+      if at_external_file?
         advance
         module_line = previous.line
         module_kind = :raw_module
@@ -150,7 +168,7 @@ module MilkTea
       AST.assign_node_ids(AST::SourceFile.new(module_name:, module_kind:, imports:, directives:, declarations:, line: module_line))
     end
 
-    def external_file_header?
+    def at_external_file?
       return false unless check(:external)
 
       next_token = @tokens[@current + 1]
@@ -188,7 +206,7 @@ module MilkTea
     end
 
     def consume_name(message)
-      if keyword_token?(peek)
+      if keyword?(peek)
         name_role = message.sub(/\A(?:expected|required)\s+/, "")
         clearer_message = if name_role == message
                             message
@@ -204,14 +222,14 @@ module MilkTea
     def consume_name_allowing_keywords(message)
       if check(:identifier)
         advance
-      elsif keyword_token?(peek)
+      elsif keyword?(peek)
         advance
       else
         raise error(peek, message)
       end
     end
 
-    def keyword_token?(token)
+    def keyword?(token)
       token && Token::KEYWORDS.key?(token.lexeme)
     end
 
@@ -288,7 +306,7 @@ module MilkTea
       items
     end
 
-    def foreign_param_qualifier_mode?
+    def foreign_param_mode_start?
       return false unless %i[out in inout consuming].include?(peek.type)
 
       @tokens[@current + 1]&.type == :identifier
@@ -298,7 +316,7 @@ module MilkTea
       token&.type == :identifier && BUILTIN_ATTRIBUTE_NAME_LEXEMES.include?(token.lexeme)
     end
 
-    def known_type_like_name?(name)
+    def known_type_context_name?(name)
       @known_type_names.key?(name) || @known_import_aliases.key?(name) || @current_type_param_names.include?(name)
     end
 
@@ -348,7 +366,7 @@ module MilkTea
           if depth.zero?
             name_token = @tokens[index + 1]
             type_param_token = @tokens[index + 2]
-            if type_name_token?(name_token) && type_param_token&.type == :lbracket
+            if identifier_token?(name_token) && type_param_token&.type == :lbracket
               @known_generic_callable_names[name_token.lexeme] = true
             end
           end
@@ -356,7 +374,7 @@ module MilkTea
           if depth.zero? && @tokens[index + 1]&.type == :function
             name_token = @tokens[index + 2]
             type_param_token = @tokens[index + 3]
-            if type_name_token?(name_token) && type_param_token&.type == :lbracket
+            if identifier_token?(name_token) && type_param_token&.type == :lbracket
               @known_generic_callable_names[name_token.lexeme] = true
             end
           end
@@ -364,14 +382,14 @@ module MilkTea
           if depth.zero? && @tokens[index + 1]&.type == :function
             name_token = @tokens[index + 2]
             type_param_token = @tokens[index + 3]
-            if type_name_token?(name_token) && type_param_token&.type == :lbracket
+            if identifier_token?(name_token) && type_param_token&.type == :lbracket
               @known_generic_callable_names[name_token.lexeme] = true
             end
           end
         when :struct, :union, :enum, :flags, :opaque, :type, :variant
           if depth.zero?
             name_token = @tokens[index + 1]
-            @known_type_names[name_token.lexeme] = true if type_name_token?(name_token)
+            @known_type_names[name_token.lexeme] = true if identifier_token?(name_token)
           end
         end
 
@@ -387,11 +405,11 @@ module MilkTea
         token = @tokens[cursor]
         if token.type == :as
           alias_token = @tokens[cursor + 1]
-          @known_import_aliases[alias_token.lexeme] = true if type_name_token?(alias_token)
+          @known_import_aliases[alias_token.lexeme] = true if identifier_token?(alias_token)
           return cursor
         end
 
-        last_part = token.lexeme if type_name_token?(token)
+        last_part = token.lexeme if identifier_token?(token)
         cursor += 1
       end
 
@@ -399,7 +417,7 @@ module MilkTea
       cursor
     end
 
-    def type_name_token?(token)
+    def identifier_token?(token)
       token&.type == :identifier
     end