mt-lang 0.3.24 → 0.3.26

data/lib/milk_tea/core/pretty_printer/ast_formatter.rb

@@ -619,7 +619,7 @@ module MilkTea
 
         inline = render_inline_statement(nested)
         return nil unless inline
-        return nil if unsafe_inline_trivia_conflict?(statement, nested)
+        return nil if unsafe_inline_comment_conflict?(statement, nested)
 
         "unsafe: #{inline}"
       end
@@ -652,7 +652,7 @@ module MilkTea
         end
       end
 
-      def unsafe_inline_trivia_conflict?(unsafe_stmt, nested)
+      def unsafe_inline_comment_conflict?(unsafe_stmt, nested)
         unsafe_line = unsafe_stmt.line
         nested_line = nested&.line
         return false unless unsafe_line && nested_line && nested_line > unsafe_line
@@ -774,7 +774,7 @@ module MilkTea
           else_expression = render_expression(expression.else_expression, IF_EXPRESSION_PRECEDENCE)
           wrap("if #{condition}: #{then_expression} else: #{else_expression}", parent_precedence, IF_EXPRESSION_PRECEDENCE)
         when AST::MatchExpr
-          sugared = render_is_expression(expression, parent_precedence)
+          sugared = try_resugar_is_expression(expression, parent_precedence)
           return sugared if sugared
 
           rendered_expression = render_expression(expression.expression, IF_EXPRESSION_PRECEDENCE)
@@ -868,7 +868,7 @@ module MilkTea
       # `expr is Arm` desugars at parse time to `match expr: Arm: true; _: false`;
       # re-sugar that exact shape back to `is` so the formatter round-trips (and a
       # multi-line match does not break when used as a statement condition).
-      def render_is_expression(expression, parent_precedence)
+      def try_resugar_is_expression(expression, parent_precedence)
         arms = expression.arms
         return nil unless arms.length == 2
 
@@ -892,12 +892,12 @@ module MilkTea
       end
 
       def render_postfix(expression)
-        return render_expression(expression, POSTFIX_PRECEDENCE) if postfix_expression?(expression)
+        return render_expression(expression, POSTFIX_PRECEDENCE) if atomic_expression?(expression)
 
         "(#{render_expression(expression)})"
       end
 
-      def postfix_expression?(expression)
+      def atomic_expression?(expression)
         expression.is_a?(AST::Identifier) || expression.is_a?(AST::MemberAccess) || expression.is_a?(AST::IndexAccess) ||
           expression.is_a?(AST::Specialization) || expression.is_a?(AST::Call) ||
           (expression.is_a?(AST::UnaryOp) && expression.operator == "?")

data/lib/milk_tea/core/pretty_printer/ir_formatter.rb

@@ -168,8 +168,8 @@ module MilkTea
             statement.body.each { |nested| emit_statement(nested) }
           end
         when IR::ForStmt
-          init = render_for_clause_statement(statement.init)
-          post = render_for_clause_statement(statement.post)
+          init = render_for_loop_clause(statement.init)
+          post = render_for_loop_clause(statement.post)
           line("for #{init}; #{render_expression(statement.condition)}; #{post}:")
           with_indent do
             statement.body.each { |nested| emit_statement(nested) }
@@ -265,7 +265,7 @@ module MilkTea
         end
       end
 
-      def render_for_clause_statement(statement)
+      def render_for_loop_clause(statement)
         case statement
         when IR::LocalDecl
           "#{statement.linkage_name}: #{statement.type} = #{render_expression(statement.value)}"
@@ -279,12 +279,12 @@ module MilkTea
       end
 
       def render_postfix(expression)
-        return render_expression(expression, POSTFIX_PRECEDENCE) if postfix_expression?(expression)
+        return render_expression(expression, POSTFIX_PRECEDENCE) if atomic_expression?(expression)
 
         "(#{render_expression(expression)})"
       end
 
-      def postfix_expression?(expression)
+      def atomic_expression?(expression)
         expression.is_a?(IR::Name) || expression.is_a?(IR::Member) || expression.is_a?(IR::Index) || expression.is_a?(IR::Call)
       end
 

data/lib/milk_tea/core/semantic_analyzer/analysis_context.rb

@@ -192,13 +192,13 @@ module MilkTea
       end
 
       def validate_async_expression_support!(expression, context:)
-        unsupported_context = unsupported_async_await_context(expression)
+        unsupported_context = unsupported_await_position(expression)
         return unless unsupported_context
 
         raise_sema_error("await in async functions is not supported inside #{unsupported_context} yet")
       end
 
-      def unsupported_async_await_context(expression)
+      def unsupported_await_position(expression)
         nil
       end
 

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

@@ -757,7 +757,7 @@ module MilkTea
         false
       end
 
-      def char_array_removed_text_method?(receiver_type, name)
+      def char_array_text_method_unavailable?(receiver_type, name)
         return unless char_array_text_type?(receiver_type)
 
         name == "as_str" || name == "as_cstr"

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

@@ -397,7 +397,7 @@ module MilkTea
           element_type = array_element_type(field_receiver_type)
           return Types::Registry.span(element_type)
         end
-        if char_array_removed_text_method?(method_receiver_type, expression.member)
+        if char_array_text_method_unavailable?(method_receiver_type, expression.member)
           raise_sema_error("#{method_receiver_type}.#{expression.member} is not available; array[char, N] is raw storage, use str_buffer[N] or an explicit helper")
         end
         if specialized_receiver_method_kind(method_receiver_type, expression.member)
@@ -939,7 +939,7 @@ module MilkTea
           )
 
           check_function_call(callable, expression.arguments, scopes:)
-          validate_specialized_function_body(callable) unless callable.type_arguments.empty?
+          validate_specialized_function_body!(callable) unless callable.type_arguments.empty?
           callable.type.return_type
         when :method
           callable = specialize_function_binding(
@@ -952,7 +952,7 @@ module MilkTea
           raise_sema_error("cannot call editable method #{callable.name} on an immutable receiver") if callable.type.receiver_editable && !assignable_receiver?(receiver, scopes)
 
           check_function_call(callable, expression.arguments, scopes:)
-          validate_specialized_function_body(callable) unless callable.type_arguments.empty?
+          validate_specialized_function_body!(callable) unless callable.type_arguments.empty?
           callable.type.return_type
         when :callable_value
           check_callable_value_call(callable, expression.arguments, scopes:, callee_expression: expression.callee)
@@ -1349,7 +1349,7 @@ module MilkTea
             return [:struct_with, method_receiver_type, callee.receiver]
           end
 
-          if char_array_removed_text_method?(method_receiver_type, callee.member)
+          if char_array_text_method_unavailable?(method_receiver_type, callee.member)
             raise_sema_error("#{method_receiver_type}.#{callee.member} is not available; array[char, N] is raw storage, use str_buffer[N] or an explicit helper")
           end
 

data/lib/milk_tea/core/semantic_analyzer/flow_refinement.rb

@@ -126,7 +126,7 @@ module MilkTea
         # only partially analysed, and functions whose last statement does not
         # record a snapshot).
         if binding.ast.respond_to?(:body) && binding.ast.body
-          body_end = last_ast_line(binding.ast.body)
+          body_end = statement_block_last_line(binding.ast.body)
           end_line = body_end if body_end && body_end > end_line
         end
 
@@ -190,11 +190,11 @@ module MilkTea
         when AST::ErrorBlockStmt
           lines.concat(statement_list_lines(statement.body))
         when AST::LocalDecl
-          lines << expression_end_line(statement.value) if statement.value
+          lines << expression_last_line(statement.value) if statement.value
           lines.concat(statement_list_lines(statement.else_body)) if statement.else_body
         when AST::IfStmt
           statement.branches.each do |branch|
-            lines << expression_end_line(branch.condition)
+            lines << expression_last_line(branch.condition)
             lines.concat(statement_list_lines(branch.body))
           end
           lines.concat(statement_list_lines(statement.else_body)) if statement.else_body
@@ -205,19 +205,19 @@ module MilkTea
             if arm.respond_to?(:body)
               lines.concat(statement_list_lines(arm.body))
             else
-              lines << expression_end_line(arm.value)
+              lines << expression_last_line(arm.value)
             end
           end
         when AST::DeferStmt
           lines.concat(statement_list_lines(statement.body))
         when AST::Assignment
-          lines << expression_end_line(statement.value)
+          lines << expression_last_line(statement.value)
         when AST::ReturnStmt
-          lines << expression_end_line(statement.value)
+          lines << expression_last_line(statement.value)
         when AST::ExpressionStmt
-          lines << expression_end_line(statement.expression)
+          lines << expression_last_line(statement.expression)
         when AST::StaticAssert
-          lines << expression_end_line(statement.condition)
+          lines << expression_last_line(statement.condition)
         end
 
         lines.compact.max
@@ -232,51 +232,51 @@ module MilkTea
         end
       end
 
-      def expression_end_line(node)
+      def expression_last_line(node)
         return nil unless node
 
         lines = [node.line]
 
         case node
         when AST::MemberAccess
-          lines << expression_end_line(node.receiver)
+          lines << expression_last_line(node.receiver)
         when AST::IndexAccess
-          lines << expression_end_line(node.receiver)
-          lines << expression_end_line(node.index)
+          lines << expression_last_line(node.receiver)
+          lines << expression_last_line(node.index)
         when AST::Specialization
-          lines << expression_end_line(node.callee)
+          lines << expression_last_line(node.callee)
         when AST::Call
-          lines << expression_end_line(node.callee)
-          node.arguments.each { |argument| lines << expression_end_line(argument.value) }
+          lines << expression_last_line(node.callee)
+          node.arguments.each { |argument| lines << expression_last_line(argument.value) }
         when AST::Argument
-          lines << expression_end_line(node.value)
+          lines << expression_last_line(node.value)
         when AST::UnaryOp
-          lines << expression_end_line(node.operand)
+          lines << expression_last_line(node.operand)
         when AST::BinaryOp
-          lines << expression_end_line(node.left)
-          lines << expression_end_line(node.right)
+          lines << expression_last_line(node.left)
+          lines << expression_last_line(node.right)
         when AST::IfExpr
-          lines << expression_end_line(node.condition)
-          lines << expression_end_line(node.then_expression)
-          lines << expression_end_line(node.else_expression)
+          lines << expression_last_line(node.condition)
+          lines << expression_last_line(node.then_expression)
+          lines << expression_last_line(node.else_expression)
         when AST::MatchExpr
-          lines << expression_end_line(node.expression)
+          lines << expression_last_line(node.expression)
           node.arms.each do |arm|
-            lines << expression_end_line(arm.pattern)
-            lines << expression_end_line(arm.value)
+            lines << expression_last_line(arm.pattern)
+            lines << expression_last_line(arm.value)
           end
         when AST::AwaitExpr
-          lines << expression_end_line(node.expression)
+          lines << expression_last_line(node.expression)
         when AST::FormatExprPart
-          lines << expression_end_line(node.expression)
+          lines << expression_last_line(node.expression)
         when AST::PrefixCast
-          lines << expression_end_line(node.expression)
+          lines << expression_last_line(node.expression)
         end
 
         lines.compact.max
       end
 
-      def recovered_for_statement(statement)
+      def rebuild_for_statement(statement)
         AST::ForStmt.new(
           bindings: Array(statement.header_bindings),
           iterables: Array(statement.header_iterables),
@@ -364,31 +364,31 @@ module MilkTea
 
       # Returns the highest line number across a list of AST statement nodes,
       # recursing into nested bodies (if/else/match/while/for/defer/unsafe).
-      def last_ast_line(statements)
+      def statement_block_last_line(statements)
         return nil if statements.nil? || statements.empty?
 
         statements.filter_map do |stmt|
           case stmt
           when AST::IfStmt
-            branch_lines = stmt.branches.filter_map { |b| last_ast_line(b.body) }
-            else_lines = last_ast_line(stmt.else_body)
+            branch_lines = stmt.branches.filter_map { |b| statement_block_last_line(b.body) }
+            else_lines = statement_block_last_line(stmt.else_body)
             [stmt.line, *branch_lines, else_lines].compact.max
           when AST::WhileStmt, AST::ForStmt, AST::UnsafeStmt, AST::ErrorBlockStmt
-            [stmt.line, last_ast_line(stmt.body)].compact.max
+            [stmt.line, statement_block_last_line(stmt.body)].compact.max
           when AST::MatchStmt
             arm_lines = stmt.arms.filter_map do |arm|
               if arm.respond_to?(:body)
-                last_ast_line(arm.body)
+                statement_block_last_line(arm.body)
               elsif arm.respond_to?(:value)
                 arm.value.line
               end
             end
             [stmt.line, *arm_lines].compact.max
           when AST::DeferStmt
-            [stmt.line, last_ast_line(stmt.body)].compact.max
+            [stmt.line, statement_block_last_line(stmt.body)].compact.max
           when AST::WhenStmt
-            branch_lines = stmt.branches.filter_map { |b| last_ast_line(b.body) }
-            else_lines = last_ast_line(stmt.else_body)
+            branch_lines = stmt.branches.filter_map { |b| statement_block_last_line(b.body) }
+            else_lines = statement_block_last_line(stmt.else_body)
             [stmt.line, *branch_lines, else_lines].compact.max
           else
             stmt.line

data/lib/milk_tea/core/semantic_analyzer/foreign_functions.rb

@@ -81,7 +81,7 @@ module MilkTea
       end
 
       def foreign_mapping_expression(decl)
-        return decl.mapping unless foreign_mapping_auto_call_shorthand?(decl.mapping)
+        return decl.mapping unless foreign_mapping_implicit_call?(decl.mapping)
 
         AST::Call.new(
           callee: decl.mapping,
@@ -89,14 +89,14 @@ module MilkTea
         )
       end
 
-      def foreign_mapping_auto_call_shorthand?(expression)
+      def foreign_mapping_implicit_call?(expression)
         case expression
         when AST::Identifier
           true
         when AST::MemberAccess
-          foreign_mapping_auto_call_shorthand?(expression.receiver)
+          foreign_mapping_implicit_call?(expression.receiver)
         when AST::Specialization
-          foreign_mapping_auto_call_shorthand?(expression.callee)
+          foreign_mapping_implicit_call?(expression.callee)
         else
           false
         end

data/lib/milk_tea/core/semantic_analyzer/function_binding.rb

@@ -186,7 +186,7 @@ module MilkTea
           external:,
         )
 
-        FunctionBinding.new(
+        Bindings::FunctionBinding.new(
           name: decl.name,
           type: function_type,
           body_params:,
@@ -266,7 +266,7 @@ module MilkTea
       # would silently swallow body errors into @structural_errors.  We
       # temporarily disable collect mode on the owner so the caller receives
       # the SemanticError directly.
-      def validate_specialized_function_body(binding)
+      def validate_specialized_function_body!(binding)
         owner = binding.owner
         prev_collecting = owner.instance_variable_get(:@collecting_errors)
         owner.instance_variable_set(:@collecting_errors, false)
@@ -597,7 +597,7 @@ module MilkTea
       # Scans generic method bodies for assignments to this through a
       # non-editable receiver.  Full body checking is deferred to call-site
       # specialization, but immutable-this violations are type-independent.
-      def check_generic_method_immutable_this(binding, scopes)
+      def check_generic_method_this_mutability(binding, scopes)
         this_binding = scopes.first&.values&.find { |v| v.name == "this" }
         return unless this_binding
         return if this_binding.mutable
@@ -629,7 +629,7 @@ module MilkTea
             start_local_completion_frame(binding, scopes)
             if binding.type_params.any?
               if binding.ast.respond_to?(:body)
-                check_generic_method_immutable_this(binding, scopes)
+                check_generic_method_this_mutability(binding, scopes)
                 check_generic_method_names(binding, scopes)
               end
               return

data/lib/milk_tea/core/semantic_analyzer/generics.rb

@@ -223,7 +223,7 @@ module MilkTea
         body_params = binding.body_params.map { |param| substitute_value_binding(param, substitutions) }
         validate_specialized_function_binding!(binding.name, type, body_params)
 
-        instance = FunctionBinding.new(
+        instance = Bindings::FunctionBinding.new(
           name: binding.name,
           type:,
           body_params:,
@@ -374,7 +374,7 @@ module MilkTea
       end
 
       def substitute_value_binding(binding, substitutions)
-        ValueBinding.new(
+        Bindings::ValueBinding.new(
           id: binding.id,
           name: binding.name,
           storage_type: substitute_type(binding.storage_type, substitutions),
@@ -399,7 +399,7 @@ module MilkTea
       end
 
       def validate_specialized_function_type!(type, function_name:, context:)
-        ValidateSpecializedTypeVisitor.new(
+        Types::ValidateSpecializedTypeVisitor.new(
           function_name:,
           context:,
           on_error: ->(msg) { raise_sema_error(msg) },
@@ -408,7 +408,7 @@ module MilkTea
       end
 
       def substitute_type(type, substitutions)
-        SubstituteTypeVisitor.new(substitutions).apply(type)
+        Types::SubstituteTypeVisitor.new(substitutions).apply(type)
       end
 
       def bitwise_type?(type)

data/lib/milk_tea/core/semantic_analyzer/name_resolution.rb

@@ -1162,7 +1162,7 @@ module MilkTea
       def freeze_scope_bindings(scope)
         frozen_scope = scope.is_a?(FlowScope) ? FlowScope.new : {}
         scope.each do |name, binding|
-          frozen_scope[name] = ValueBinding.new(
+          frozen_scope[name] = Bindings::ValueBinding.new(
             id: binding.id,
             name: binding.name,
             storage_type: binding.storage_type,
@@ -1191,26 +1191,26 @@ module MilkTea
       end
 
       def stored_ref_supported_type?(type, visited = {}, allow_lifetimes: [])
-        visitor = StoredRefSupportedVisitor.new(allow_lifetimes:)
+        visitor = Types::StoredRefSupportedVisitor.new(allow_lifetimes:)
         visitor.visit(type)
         visitor.result?
       end
 
       def contains_callable_ref_type?(type, visited = {})
-        visitor = ContainsCallableRefTypeVisitor.new
+        visitor = Types::ContainsCallableRefTypeVisitor.new
         visitor.visit(type)
         visitor.found?
       end
 
       def contains_proc_type?(type, visited = {})
-        visitor = ContainsProcTypeVisitor.new
+        visitor = Types::ContainsProcTypeVisitor.new
         visitor.visit(type)
         visitor.found?
       end
 
       def proc_storage_supported_type?(type, visited = {})
         return true unless contains_proc_type?(type)
-        visitor = ProcStorageSupportedVisitor.new
+        visitor = Types::ProcStorageSupportedVisitor.new
         visitor.visit(type)
         visitor.result?
       end
@@ -1421,10 +1421,10 @@ module MilkTea
         id ||= allocate_binding_id
         @binding_name_by_id[id] = name
         @binding_type_by_id[id] = flow_type == type ? type : (flow_type || type)
-        ValueBinding.new(id:, name:, storage_type: type, flow_type: flow_type == type ? nil : flow_type, mutable:, kind:, const_value:)
+        Bindings::ValueBinding.new(id:, name:, storage_type: type, flow_type: flow_type == type ? nil : flow_type, mutable:, kind:, const_value:)
       end
 
-      def binding_resolution_snapshot
+      def build_binding_resolution_snapshot
         BindingResolution.new(
           identifier_binding_ids: @identifier_binding_ids.dup.freeze,
           declaration_binding_ids: @declaration_binding_ids.dup.freeze,