mt-lang 0.3.39 → 0.3.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d9af5865fb54b82fbf9169cdf8f8feef652af6a2b84cbd8e63e35f99b33ac08
-  data.tar.gz: 2c5d57827cc19e8de3ee5fff7e576860aa4ae30fa5f7b588eba80c9e95227e02
+  metadata.gz: 3a57605301758f1ff1307cfb5aa7300bb73876be082b9736f853bf14dce18352
+  data.tar.gz: 8d540b3326a74c0a8370d5799b19eadb78f8d579899ffdfed263847bbfa0c367
 SHA512:
-  metadata.gz: 9fc438f51cba2f5a65bd3a8ea3441fb87f26018be991146e060a828b036ba9d5eebde4f5546ce344f276ba68e5f1a99b4fe92b026c839c3f77740b15c108a4eb
-  data.tar.gz: 232a3879248bbd638c7710135047c09dbe4a140758da63c2fc5434df4602750c6459faa3fa843abca99801c6628b963ec747509be17de4c73f408626882dfa22
+  metadata.gz: c7ff36f0b7a609a7c4dbd69264c70ee7dca22201d520753e254609a3009844c23572c578cbdb5802afdd04897559b578f1e539b5c9c6c2a97c64f16f5e286062
+  data.tar.gz: 1987f20a6c919b3c8341a339c6473292bf31866a07ffe1805707153b077a282284686366dd299eeb02e91de23a83eec1b8aaa837fc901eadefe58acf54df07a9

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.3.39"
+  VERSION = "0.3.40"
 
   def self.root
     @root ||= Pathname.new(File.expand_path("../..", __dir__))

data/lib/milk_tea/core/ast.rb

@@ -111,8 +111,8 @@ module MilkTea
     InterfaceDecl = Data.define(:name, :type_params, :methods, :visibility, :line, :column) do
       def initialize(name:, type_params: [], methods:, visibility:, line: nil, column: nil) = super
     end
-    ExtendingBlock = Data.define(:type_name, :methods, :line, :column) do
-      def initialize(type_name:, methods:, line: nil, column: nil) = super
+    ExtendingBlock = Data.define(:type_name, :methods, :line, :column, :inline) do
+      def initialize(type_name:, methods:, line: nil, column: nil, inline: false) = super
     end
     InterfaceMethodDecl = Data.define(:name, :params, :return_type, :kind, :async, :attributes, :line, :column) do
       def initialize(name:, params:, return_type:, kind:, async:, attributes: [], line: nil, column: nil) = super

data/lib/milk_tea/core/bindings/attribute_binding.rb

@@ -2,7 +2,7 @@
 
 module MilkTea
   module Bindings
-    AttributeBinding = Data.define(:name, :targets, :params, :module_name, :builtin, :ast)
+    AttributeBinding = Data.define(:name, :targets, :params, :module_name, :builtin)
     BUILTIN_ATTRIBUTE_NAMES = %w[packed align deprecated test expect_fatal].freeze
 
     def self.builtin_attribute_binding(name, types)
@@ -14,7 +14,6 @@ module MilkTea
           params: [].freeze,
           module_name: nil,
           builtin: true,
-          ast: nil,
         )
       when "align"
         AttributeBinding.new(
@@ -23,7 +22,6 @@ module MilkTea
           params: [Types::Registry.parameter("bytes", types.fetch("ptr_uint"))].freeze,
           module_name: nil,
           builtin: true,
-          ast: nil,
         )
       when "deprecated"
         AttributeBinding.new(
@@ -32,7 +30,6 @@ module MilkTea
           params: [Types::Registry.parameter("message", types.fetch("str"))].freeze,
           module_name: nil,
           builtin: true,
-          ast: nil,
         )
       when "test"
         AttributeBinding.new(
@@ -41,7 +38,6 @@ module MilkTea
           params: [].freeze,
           module_name: nil,
           builtin: true,
-          ast: nil,
         )
       when "expect_fatal"
         AttributeBinding.new(
@@ -50,7 +46,6 @@ module MilkTea
           params: [].freeze,
           module_name: nil,
           builtin: true,
-          ast: nil,
         )
       end
     end

data/lib/milk_tea/core/bindings/module_binding.rb

@@ -2,7 +2,7 @@
 
 module MilkTea
   module Bindings
-    ModuleBinding = Data.define(:name, :types, :type_declarations, :interfaces, :attributes, :attribute_applications, :values, :functions, :methods, :implemented_interfaces, :imports, :private_types, :private_interfaces, :private_attributes, :private_values, :private_functions, :private_methods, :private_implemented_interfaces) do
+    ModuleBinding = Data.define(:name, :types, :type_declarations, :interfaces, :attributes, :attribute_applications, :values, :functions, :methods, :implemented_interfaces, :imports, :private_types, :private_interfaces, :private_attributes, :private_values, :private_functions, :private_methods) do
       def private_type?(name)
         private_types.key?(name)
       end

data/lib/milk_tea/core/intrinsics.rb

@@ -84,5 +84,27 @@ module MilkTea
     def string_literal_cstr_compatibility?(expression, expected_type)
       expression.is_a?(AST::StringLiteral) && !expression.cstring && expected_type == BUILTIN_CSTR
     end
+
+    def current_nested_types
+      @current_nested_types
+    end
+
+    # Resolves the receiver type's short name (self-reference) and its own
+    # nested types as a bare-name scope for method bodies and signatures.
+    def method_receiver_nested_scope(receiver_type)
+      return nil unless receiver_type.respond_to?(:name)
+
+      nested = receiver_type.respond_to?(:nested_types) ? receiver_type.nested_types : nil
+      scope = { receiver_type.name => receiver_type }
+      scope = scope.merge(nested) if nested && !nested.empty?
+      scope
+    end
+
+    # Looks up a bare type name, consulting the active method-receiver nested
+    # scope before the module type namespace so nested types self-reference
+    # by their short name inside their own methods.
+    def lookup_named_type(name)
+      (@current_nested_types && @current_nested_types[name]) || @ctx.types[name]
+    end
   end
-end
+end

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

@@ -118,8 +118,10 @@ module MilkTea
         parameter_setup = []
         previous_type_substitutions = @ctx.current_type_substitutions
         previous_value_type_params = @ctx.current_value_type_params
+        previous_nested_types = @current_nested_types
         @ctx.current_type_substitutions = binding.type_substitutions
         @ctx.current_value_type_params = resolve_value_type_params(decl.type_params)
+        @current_nested_types = method_receiver_nested_scope(binding.declared_receiver_type)
 
         return lower_async_function_decl(binding, receiver_type:) if binding.async
 
@@ -179,6 +181,7 @@ module MilkTea
       ensure
         @ctx.current_type_substitutions = previous_type_substitutions
         @ctx.current_value_type_params = previous_value_type_params
+        @current_nested_types = previous_nested_types
       end
 
       def resolve_value_type_params(type_params)

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

@@ -444,7 +444,7 @@ module MilkTea
           return [:compile_time_builtin, callee.name, nil, compile_time_builtin_function_type(callee.name, arguments, env)]
         end
 
-        type = @ctx.types[callee.name]
+        type = lookup_named_type(callee.name)
         if type.is_a?(Types::Struct) || type.is_a?(Types::StringView) || task_type?(type) || type.is_a?(Types::Vector) || type.is_a?(Types::Matrix) || type.is_a?(Types::Quaternion)
           return [:struct_literal, nil, nil, type]
         end
@@ -606,7 +606,6 @@ module MilkTea
           return [:array_as_span, nil, callee.receiver, Types::Registry.span(array_element_type(field_receiver_type))]
         end
 
-        member_type = field_receiver_type.respond_to?(:field) ? field_receiver_type.field(callee.member) : nil
         member_type = field_receiver_type.respond_to?(:field) ? field_receiver_type.field(callee.member) : nil
         return [:callable_value, nil, nil, member_type, nil] if callable_type?(member_type)
 
@@ -1055,7 +1054,7 @@ module MilkTea
         end
       end
 
-      def type_contains_array_storage?(type, visited = Set.new)
+      def type_contains_array_storage?(type)
         visitor = Types::ContainsArrayStorageVisitor.new
         visitor.visit(type)
         visitor.found?
@@ -1118,62 +1117,6 @@ module MilkTea
         expected_type || null_type
       end
 
-      def common_numeric_type(left_type, right_type)
-        left_type = left_type.backing_type if left_type.is_a?(Types::EnumBase)
-        right_type = right_type.backing_type if right_type.is_a?(Types::EnumBase)
-        return left_type if left_type == right_type
-        return unless left_type.is_a?(Types::Primitive) && right_type.is_a?(Types::Primitive)
-        return unless left_type.numeric? && right_type.numeric?
-
-        return common_integer_type(left_type, right_type) if left_type.integer? && right_type.integer?
-        return wider_float_type(left_type, right_type) if left_type.float? && right_type.float?
-
-        float_type, integer_type = left_type.float? ? [left_type, right_type] : [right_type, left_type]
-        return unless integer_type.integer? && integer_type.fixed_width_integer?
-
-        float_type
-      end
-
-      def common_integer_type(left_type, right_type)
-        left_type = left_type.backing_type if left_type.is_a?(Types::EnumBase)
-        right_type = right_type.backing_type if right_type.is_a?(Types::EnumBase)
-        return left_type if left_type == right_type
-        return unless left_type.is_a?(Types::Primitive) && right_type.is_a?(Types::Primitive)
-        return unless left_type.integer? && right_type.integer?
-        return unless left_type.fixed_width_integer? && right_type.fixed_width_integer?
-
-        # Mirrors the semantic analyzer's rule: same signedness picks the wider
-        # type; mixed signed/unsigned promotes to the narrowest signed type that
-        # holds both operands' full ranges (a strictly-wider signed type covers
-        # an unsigned operand, otherwise widen to the next signed width). Mixing
-        # with a 64-bit unsigned type has no safe signed common type.
-        if left_type.signed_integer? == right_type.signed_integer?
-          return left_type.integer_width >= right_type.integer_width ? left_type : right_type
-        end
-
-        signed_type, unsigned_type = if left_type.signed_integer?
-          [left_type, right_type]
-        else
-          [right_type, left_type]
-        end
-
-        return signed_type if signed_type.integer_width > unsigned_type.integer_width
-
-        signed_type_above_width(unsigned_type.integer_width)
-      end
-
-      def signed_type_above_width(width)
-        case width
-        when 8 then @ctx.types.fetch("short")
-        when 16 then @ctx.types.fetch("int")
-        when 32 then @ctx.types.fetch("long")
-        end
-      end
-
-      def wider_float_type(left_type, right_type)
-        left_type.float_width >= right_type.float_width ? left_type : right_type
-      end
-
       def aggregate_arithmetic_result_type(operator, left_type, right_type)
         if left_type.is_a?(Types::Vector) && right_type.is_a?(Types::Vector) && left_type.name == right_type.name
           return left_type
@@ -1217,7 +1160,7 @@ module MilkTea
         when AST::Identifier
           return current_type_params[expression.name] if current_type_params.key?(expression.name)
 
-          @ctx.types[expression.name]
+          lookup_named_type(expression.name)
         when AST::MemberAccess
           return nil unless expression.receiver.is_a?(AST::Identifier)
 
@@ -1870,10 +1813,6 @@ module MilkTea
         def top_level_function(name)
           @lowerer.instance_variable_get(:@ctx).functions&.[](name)
         end
-
-        def raise_sema_error(message)
-          raise CompileTime::Error, message
-        end
       end
 
       def evaluate_reflection_target_argument(expression, env:)
@@ -2532,7 +2471,7 @@ module MilkTea
                 elsif parts.length == 1 && type_params.key?(parts.first)
                   type_params.fetch(parts.first)
                 elsif parts.length == 1
-                  type = @ctx.types[parts.first]
+                  type = lookup_named_type(parts.first)
                   raise LoweringError.new("unknown type #{parts.first}", line: 0, column: 0, path: @ctx.current_analysis_path) unless type
                   raise LoweringError.new("generic type #{parts.first} requires type arguments", line: 0, column: 0, path: @ctx.current_analysis_path) if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
 

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

@@ -155,18 +155,6 @@ module MilkTea
         receiver_type
       end
 
-      def collection_loop_type(type)
-        super
-      end
-
-      def collection_loop_binding_type(iterable_type, element_type)
-        super
-      end
-
-      def collection_loop_ref_element_type?(type)
-        super
-      end
-
       def collection_loop_item_value(iterable_ref, iterable_type, index_ref, element_type)
         if array_type?(iterable_type)
           IR::Index.new(receiver: iterable_ref, index: index_ref, type: element_type)
@@ -248,11 +236,6 @@ module MilkTea
         raise LoweringError.new("cannot index #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
 
-      def contains_type_var?(type)
-        super
-      end
-
-
       def stored_ref_supported_type?(type, visited = {})
         return true unless type
 

data/lib/milk_tea/core/lowering.rb

@@ -100,7 +100,6 @@ module MilkTea
     include Intrinsics
 
     attr_accessor :bypass_sema_type_cache
-    attr_reader :recorded_expr_types
 
     include Lowering::Scans
     include Lowering::Declarations
@@ -122,6 +121,7 @@ module MilkTea
       @program = program
       @ctx = LoweringContext.new
       @artifacts = Artifacts.new
+      @error_type = Types::Error.new
       @synthetic_proc_counter = 0
       @parallel_for_counter = 0
       @async_binding_counter = 0
@@ -130,7 +130,6 @@ module MilkTea
     end
 
     def lower
-      @recorded_expr_types = {} if @bypass_sema_type_cache
       ir_program, _modules, _synths = lower_and_assemble
       ir_program
     end

data/lib/milk_tea/core/module_binder.rb

@@ -42,7 +42,7 @@ module MilkTea
       end
 
       methods, private_methods = exported_methods(analysis, types)
-      implemented_interfaces, private_implemented_interfaces = exported_interface_implementations(analysis, types, interfaces)
+      implemented_interfaces = exported_interface_implementations(analysis, types, interfaces)
 
       Bindings::ModuleBinding.new(
         name: analysis.module_name,
@@ -62,7 +62,6 @@ module MilkTea
         private_values:,
         private_functions:,
         private_methods:,
-        private_implemented_interfaces:,
       )
     end
 
@@ -102,28 +101,18 @@ module MilkTea
 
     def exported_interface_implementations(analysis, exported_types, exported_interfaces)
       implemented_interfaces = {}
-      private_implemented_interfaces = {}
 
       analysis.implemented_interfaces.each do |receiver_type, interfaces|
-        public_interfaces = []
-        hidden_interfaces = []
-
-        interfaces.each do |interface|
-          visible = exported_method_receiver?(receiver_type, analysis, exported_types) &&
+        public_interfaces = interfaces.select do |interface|
+          exported_method_receiver?(receiver_type, analysis, exported_types) &&
             exported_interface_binding?(interface, analysis, exported_interfaces) &&
             exported_interface_methods?(receiver_type, interface, analysis, exported_types)
-          if visible
-            public_interfaces << interface
-          else
-            hidden_interfaces << interface
-          end
         end
 
         implemented_interfaces[receiver_type] = public_interfaces.freeze unless public_interfaces.empty?
-        private_implemented_interfaces[receiver_type] = hidden_interfaces.freeze unless hidden_interfaces.empty?
       end
 
-      [implemented_interfaces.freeze, private_implemented_interfaces.freeze]
+      implemented_interfaces.freeze
     end
 
     def exported_interface_methods?(receiver_type, interface, analysis, exported_types)

data/lib/milk_tea/core/module_loader.rb

@@ -691,7 +691,6 @@ module MilkTea
           private_values: full_binding.private_values,
           private_functions: full_binding.private_functions,
           private_methods: full_binding.private_methods,
-          private_implemented_interfaces: full_binding.private_implemented_interfaces,
         )
       end
     end
@@ -728,7 +727,6 @@ module MilkTea
         implemented_interfaces: {}, imports: {},
         private_types: {}, private_interfaces: {}, private_attributes: {},
         private_values: {}, private_functions: {}, private_methods: {},
-        private_implemented_interfaces: {},
       )
     end
 

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

@@ -369,10 +369,11 @@ module MilkTea
         AST::AttributeDecl.new(name: name_token.lexeme, targets:, params:, visibility:, line:, column: name_token.column)
       end
 
-      def parse_struct_decl(packed: false, alignment: nil, visibility: :private, attributes: [], inline_methods: true)
+      def parse_struct_decl(packed: false, alignment: nil, visibility: :private, attributes: [], qualified_parts: [])
         line = previous.line
         name_token = consume_name("expected struct name")
         name = name_token.lexeme
+        qualified_name = qualified_parts + [name]
         lifetime_params, type_params = parse_struct_decl_params
         implements = parse_implements_clause
         c_name = parse_optional_c_name
@@ -380,29 +381,33 @@ module MilkTea
         receiver_type_param_names = type_params.map(&:name)
         members = with_type_param_names(receiver_type_param_names) do
           parse_recoverable_block do
-            parse_struct_member
+            parse_struct_member(qualified_name)
           end
         end
         fields = members.filter_map { |kind, member| member if kind == :field }
         events = members.filter_map { |kind, member| member if kind == :event }
         nested_types = members.filter_map { |kind, member| member if kind == :nested_type }
         methods = members.filter_map { |kind, member| member if kind == :method }
+        nested_extending_blocks = members.filter_map { |kind, _, blocks| blocks if kind == :nested_type }.flatten(1)
         struct_decl = AST::StructDecl.new(name:, type_params:, implements:, c_name:, fields:, events:, nested_types:, attributes:, packed:, alignment:, visibility:, lifetime_params:, line:, column: name_token.column)
 
-        if inline_methods && methods.any?
-          type_ref_args = type_params.map do |tp|
-            AST::TypeArgument.new(
-              value: AST::TypeRef.new(name: AST::QualifiedName.new(parts: [tp.name]), arguments: [], nullable: false, line: tp.line, column: tp.column),
-              line: tp.line,
-              column: tp.column,
-            )
-          end
-          type_ref = AST::TypeRef.new(name: AST::QualifiedName.new(parts: [name]), arguments: type_ref_args, nullable: false, line: name_token.line, column: name_token.column)
-          extending_block = AST::ExtendingBlock.new(type_name: type_ref, methods:, line: name_token.line, column: name_token.column)
-          [struct_decl, extending_block]
-        else
-          struct_decl
+        extending_blocks = []
+        extending_blocks << inline_methods_extending_block(qualified_name, type_params, methods, name_token) if methods.any?
+        extending_blocks.concat(nested_extending_blocks)
+
+        extending_blocks.empty? ? struct_decl : [struct_decl, *extending_blocks]
+      end
+
+      def inline_methods_extending_block(qualified_name, type_params, methods, name_token)
+        type_ref_args = type_params.map do |tp|
+          AST::TypeArgument.new(
+            value: AST::TypeRef.new(name: AST::QualifiedName.new(parts: [tp.name]), arguments: [], nullable: false, line: tp.line, column: tp.column),
+            line: tp.line,
+            column: tp.column,
+          )
         end
+        type_ref = AST::TypeRef.new(name: AST::QualifiedName.new(parts: qualified_name), arguments: type_ref_args, nullable: false, line: name_token.line, column: name_token.column)
+        AST::ExtendingBlock.new(type_name: type_ref, methods:, line: name_token.line, column: name_token.column, inline: true)
       end
 
       def parse_struct_decl_params
@@ -459,7 +464,7 @@ module MilkTea
         result
       end
 
-      def parse_struct_member
+      def parse_struct_member(qualified_name)
         field_attributes = parse_attribute_applications
 
         if check_method_start?
@@ -475,7 +480,9 @@ module MilkTea
 
         if check(:struct) && !check_next(:colon)
           advance
-          return [:nested_type, parse_struct_decl(visibility:, attributes: field_attributes, inline_methods: false)]
+          result = parse_struct_decl(visibility:, attributes: field_attributes, qualified_parts: qualified_name)
+          nested_decl, *nested_blocks = result.is_a?(Array) ? result : [result]
+          return [:nested_type, nested_decl, nested_blocks]
         end
 
         raise error(visibility_token, "public is only allowed on struct events") if visibility == :public

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

@@ -129,53 +129,23 @@ module MilkTea
       def validate_async_statement!(statement)
         case statement
         when AST::ErrorBlockStmt
-          if statement.header_expression
-            context = case statement.header_type
-                      when :if then "if conditions"
-                      when :while then "while conditions"
-                      end
-            validate_async_expression_support!(statement.header_expression, context:) if context
-          end
-          if statement.header_type == :for
-            Array(statement.header_iterables).each do |iterable|
-              validate_async_expression_support!(iterable, context: "for iterables")
-            end
-          end
           statement.body.each { |s| validate_async_statement!(s) }
         when AST::ErrorStmt
           nil
         when AST::LocalDecl
-          validate_async_expression_support!(statement.value, context: "local initializer") if statement.value
           statement.else_body&.each { |s| validate_async_statement!(s) }
-        when AST::Assignment
-          validate_async_expression_support!(statement.target, context: "assignment target")
-          validate_async_expression_support!(statement.value, context: "assignment")
-        when AST::ExpressionStmt
-          validate_async_expression_support!(statement.expression, context: "expression statement")
-        when AST::ReturnStmt
-          return unless statement.value
-
-          validate_async_expression_support!(statement.value, context: "return statement")
+        when AST::Assignment, AST::ExpressionStmt, AST::ReturnStmt
+          nil
         when AST::IfStmt
           statement.branches.each do |branch|
-            validate_async_expression_support!(branch.condition, context: "if conditions")
-
             branch.body.each { |s| validate_async_statement!(s) }
           end
           statement.else_body&.each { |s| validate_async_statement!(s) }
         when AST::WhileStmt
-          validate_async_expression_support!(statement.condition, context: "while conditions")
-
           statement.body.each { |s| validate_async_statement!(s) }
         when AST::ForStmt
-          statement.iterables.each do |iterable|
-            validate_async_expression_support!(iterable, context: "for iterables")
-          end
-
           statement.body.each { |s| validate_async_statement!(s) }
         when AST::MatchStmt
-          validate_async_expression_support!(statement.expression, context: "match discriminants")
-
           statement.arms.each { |arm| arm.body.each { |s| validate_async_statement!(s) } }
         when AST::UnsafeStmt
           statement.body.each { |s| validate_async_statement!(s) }
@@ -191,85 +161,6 @@ module MilkTea
         end
       end
 
-      def validate_async_expression_support!(expression, context:)
-        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_await_position(expression)
-        nil
-      end
-
-      def statement_contains_await?(statement)
-        case statement
-        when AST::ErrorBlockStmt
-          (statement.header_expression && expression_contains_await?(statement.header_expression)) ||
-            Array(statement.header_iterables).any? { |iterable| expression_contains_await?(iterable) } ||
-            statements_contain_await?(statement.body)
-        when AST::LocalDecl
-          (statement.value && expression_contains_await?(statement.value)) ||
-            (statement.else_body && statements_contain_await?(statement.else_body))
-        when AST::Assignment
-          expression_contains_await?(statement.target) || expression_contains_await?(statement.value)
-        when AST::IfStmt
-          statement.branches.any? { |branch| expression_contains_await?(branch.condition) || statements_contain_await?(branch.body) } ||
-            (statement.else_body && statements_contain_await?(statement.else_body))
-        when AST::MatchStmt
-          expression_contains_await?(statement.expression) || statement.arms.any? { |arm| expression_contains_await?(arm.pattern) || statements_contain_await?(arm.body) }
-        when AST::UnsafeStmt
-          statements_contain_await?(statement.body)
-        when AST::StaticAssert
-          expression_contains_await?(statement.condition) || expression_contains_await?(statement.message)
-        when AST::ForStmt
-          statement.iterables.any? { |iterable| expression_contains_await?(iterable) } || statements_contain_await?(statement.body)
-        when AST::WhileStmt
-          expression_contains_await?(statement.condition) || statements_contain_await?(statement.body)
-        when AST::ReturnStmt
-          statement.value && expression_contains_await?(statement.value)
-        when AST::DeferStmt
-          statements_contain_await?(statement.body)
-        when AST::ExpressionStmt
-          expression_contains_await?(statement.expression)
-        else
-          false
-        end
-      end
-
-      def statements_contain_await?(statements)
-        statements.any? { |statement| statement_contains_await?(statement) }
-      end
-
-      def expression_contains_await?(expression)
-        case expression
-        when AST::AwaitExpr
-          true
-        when AST::Call, AST::Specialization
-          expression_contains_await?(expression.callee) || expression.arguments.any? { |argument| expression_contains_await?(argument.value) }
-        when AST::UnaryOp
-          expression_contains_await?(expression.operand)
-        when AST::BinaryOp
-          expression_contains_await?(expression.left) || expression_contains_await?(expression.right)
-        when AST::IfExpr
-          expression_contains_await?(expression.condition) || expression_contains_await?(expression.then_expression) || expression_contains_await?(expression.else_expression)
-        when AST::MatchExpr
-          expression_contains_await?(expression.expression) || expression.arms.any? { |arm| expression_contains_await?(arm.pattern) || expression_contains_await?(arm.value) }
-        when AST::UnsafeExpr
-          expression_contains_await?(expression.expression)
-        when AST::PrefixCast
-          expression_contains_await?(expression.expression)
-        when AST::MemberAccess
-          expression_contains_await?(expression.receiver)
-        when AST::IndexAccess
-          expression_contains_await?(expression.receiver) || expression_contains_await?(expression.index)
-        when AST::FormatString
-          expression.parts.any? { |part| part.is_a?(AST::FormatExprPart) && expression_contains_await?(part.expression) }
-        else
-          false
-        end
-      end
-
       def suggest_name(wrong, candidates, max_distance: 2)
         return nil if wrong.nil? || wrong.to_s.empty? || candidates.nil? || candidates.empty?
 

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

@@ -1309,7 +1309,7 @@ module MilkTea
           return [:has_attribute, nil, nil] if callee.name == "has_attribute"
           return [:get, nil, nil] if callee.name == "get"
 
-          type = @ctx.types[callee.name]
+          type = lookup_named_type(callee.name)
           return [:struct, type, nil] if type.is_a?(Types::Struct) || type.is_a?(Types::StringView) || task_type?(type) || type.is_a?(Types::Vector) || type.is_a?(Types::Matrix) || type.is_a?(Types::Quaternion)
           if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
             raise_sema_error("generic type #{callee.name} requires type arguments")
@@ -1396,7 +1396,6 @@ module MilkTea
             return [:array_as_span, field_receiver_type, callee.receiver]
           end
 
-          return [:callable_value, field_receiver_type.field(callee.member), nil] if aggregate_type?(field_receiver_type) && callable_type?(field_receiver_type.field(callee.member))
           return [:callable_value, field_receiver_type.field(callee.member), nil] if aggregate_type?(field_receiver_type) && callable_type?(field_receiver_type.field(callee.member))
 
           if (imported_module = imported_module_with_private_method(method_receiver_type, callee.member))

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

@@ -22,25 +22,31 @@ module MilkTea
             when AST::ExtendingBlock
               dispatch_receiver_type, receiver_type, receiver_type_param_names, receiver_type_param_constraints = resolve_methods_receiver_target(decl.type_name)
 
-              decl.methods.each do |method|
-                begin
-                  binding = with_error_node(method) do
-                    declare_function_binding(
-                      method,
-                      receiver_type:,
-                      declared_receiver_type: receiver_type,
-                      receiver_type_param_names:,
-                      receiver_type_param_constraints:,
-                    )
-                  end
-                  instance_method = receiver_type && method.kind != :static
-                  method_key = instance_method ? binding.name : "static:#{binding.name}"
-                  raise_sema_error("duplicate method #{decl.type_name}.#{binding.name}") if @ctx.methods[dispatch_receiver_type].key?(method_key)
+              previous_nested_types = @current_nested_types
+              @current_nested_types = method_receiver_nested_scope(receiver_type)
+              begin
+                decl.methods.each do |method|
+                  begin
+                    binding = with_error_node(method) do
+                      declare_function_binding(
+                        method,
+                        receiver_type:,
+                        declared_receiver_type: receiver_type,
+                        receiver_type_param_names:,
+                        receiver_type_param_constraints:,
+                      )
+                    end
+                    instance_method = receiver_type && method.kind != :static
+                    method_key = instance_method ? binding.name : "static:#{binding.name}"
+                    raise_sema_error("duplicate method #{decl.type_name}.#{binding.name}") if @ctx.methods[dispatch_receiver_type].key?(method_key)
 
-                  @ctx.methods[dispatch_receiver_type][method_key] = binding
-                rescue SemanticError => e
-                  collect_structural_error(e)
+                    @ctx.methods[dispatch_receiver_type][method_key] = binding
+                  rescue SemanticError => e
+                    collect_structural_error(e)
+                  end
                 end
+              ensure
+                @current_nested_types = previous_nested_types
               end
             end
           end
@@ -604,6 +610,7 @@ module MilkTea
         previous_type_substitutions = @current_type_substitutions
         previous_specialization_owner = @current_specialization_owner
         previous_value_type_params = @current_value_type_params
+        previous_nested_types = @current_nested_types
         started_check = false
         return if binding.external
         return if @checked_function_bindings[binding.object_id]
@@ -614,6 +621,7 @@ module MilkTea
         @current_type_substitutions = binding.type_substitutions
         @current_specialization_owner = binding.specialization_owner
         @current_value_type_params = resolve_value_type_params(binding.ast.type_params)
+        @current_nested_types = method_receiver_nested_scope(binding.declared_receiver_type)
         with_error_node(binding.ast) do
           with_scope(binding.body_params) do |scopes|
             start_local_completion_frame(binding, scopes)
@@ -669,6 +677,7 @@ module MilkTea
         @current_type_substitutions = previous_type_substitutions
         @current_specialization_owner = previous_specialization_owner
         @current_value_type_params = previous_value_type_params
+        @current_nested_types = previous_nested_types
         @checking_function_bindings.delete(binding.object_id)
       end
 

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

@@ -236,7 +236,7 @@ module MilkTea
         end
       end
 
-      def resolve_type_ref(type_ref, type_params: current_type_params, type_param_constraints: current_type_param_constraints, nested_types: nil)
+      def resolve_type_ref(type_ref, type_params: current_type_params, type_param_constraints: current_type_param_constraints, nested_types: current_nested_types)
         base = resolve_non_nullable_type(type_ref, type_params:, type_param_constraints:, nested_types:)
         return base if type_ref.is_a?(AST::FunctionType) || type_ref.is_a?(AST::ProcType) || type_ref.is_a?(AST::TupleType)
 
@@ -247,11 +247,11 @@ module MilkTea
 
       def resolve_non_nullable_type(type_ref, type_params: {}, type_param_constraints: {}, nested_types: nil)
         if type_ref.is_a?(AST::FunctionType)
-          return resolve_function_type_ref(type_ref, type_params:, type_param_constraints:)
+          return resolve_function_type_ref(type_ref, type_params:, type_param_constraints:, nested_types:)
         end
 
         if type_ref.is_a?(AST::ProcType)
-          return resolve_proc_type_ref(type_ref, type_params:, type_param_constraints:)
+          return resolve_proc_type_ref(type_ref, type_params:, type_param_constraints:, nested_types:)
         end
 
         if type_ref.is_a?(AST::DynType)
@@ -259,13 +259,13 @@ module MilkTea
         end
 
         if type_ref.is_a?(AST::TupleType)
-          return resolve_tuple_type_ref(type_ref, type_params:, type_param_constraints:)
+          return resolve_tuple_type_ref(type_ref, type_params:, type_param_constraints:, nested_types:)
         end
 
         parts = type_ref.name.parts
 
         if type_ref.arguments.any?
-          return resolve_generic_instance_type_ref(type_ref, parts, type_params:, type_param_constraints:)
+          return resolve_generic_instance_type_ref(type_ref, parts, type_params:, type_param_constraints:, nested_types:)
         end
 
         if parts.length == 1 && type_ref.lifetime
@@ -279,18 +279,18 @@ module MilkTea
         resolve_multi_part_type_ref(type_ref, parts)
       end
 
-      def resolve_function_type_ref(type_ref, type_params:, type_param_constraints:)
+      def resolve_function_type_ref(type_ref, type_params:, type_param_constraints:, nested_types:)
         params = type_ref.params.map do |param|
-          Types::Registry.parameter(param.name, resolve_type_ref(param.type, type_params:, type_param_constraints:))
+          Types::Registry.parameter(param.name, resolve_type_ref(param.type, type_params:, type_param_constraints:, nested_types:))
         end
-        Types::Registry.function(nil, params:, return_type: resolve_type_ref(type_ref.return_type, type_params:, type_param_constraints:))
+        Types::Registry.function(nil, params:, return_type: resolve_type_ref(type_ref.return_type, type_params:, type_param_constraints:, nested_types:))
       end
 
-      def resolve_proc_type_ref(type_ref, type_params:, type_param_constraints:)
+      def resolve_proc_type_ref(type_ref, type_params:, type_param_constraints:, nested_types:)
         params = type_ref.params.map do |param|
-          Types::Registry.parameter(param.name, resolve_type_ref(param.type, type_params:, type_param_constraints:))
+          Types::Registry.parameter(param.name, resolve_type_ref(param.type, type_params:, type_param_constraints:, nested_types:))
         end
-        Types::Registry.proc(params:, return_type: resolve_type_ref(type_ref.return_type, type_params:, type_param_constraints:))
+        Types::Registry.proc(params:, return_type: resolve_type_ref(type_ref.return_type, type_params:, type_param_constraints:, nested_types:))
       end
 
       def resolve_dyn_type_ref(type_ref)
@@ -302,25 +302,25 @@ module MilkTea
         type
       end
 
-      def resolve_tuple_type_ref(type_ref, type_params:, type_param_constraints:)
+      def resolve_tuple_type_ref(type_ref, type_params:, type_param_constraints:, nested_types:)
         names = []
         element_types = []
         type_ref.element_types.each do |et|
           if et.is_a?(AST::Argument)
             names << et.name
-            element_types << resolve_type_ref(et.value, type_params:, type_param_constraints:)
+            element_types << resolve_type_ref(et.value, type_params:, type_param_constraints:, nested_types:)
           else
             names << nil
-            element_types << resolve_type_ref(et, type_params:, type_param_constraints:)
+            element_types << resolve_type_ref(et, type_params:, type_param_constraints:, nested_types:)
           end
         end
         has_named = names.any?
         Types::Registry.tuple(element_types, field_names: has_named ? names : nil)
       end
 
-      def resolve_generic_instance_type_ref(type_ref, parts, type_params:, type_param_constraints:)
+      def resolve_generic_instance_type_ref(type_ref, parts, type_params:, type_param_constraints:, nested_types:)
         name = parts.join(".")
-        arguments = type_ref.arguments.map { |argument| resolve_type_argument(argument.value, type_params:, type_param_constraints:) }
+        arguments = type_ref.arguments.map { |argument| resolve_type_argument(argument.value, type_params:, type_param_constraints:, nested_types:) }
 
         if name != "ref" && arguments.any? { |argument| contains_ref_type?(argument) && !stored_ref_supported_type?(argument) }
           raise_sema_error("ref types cannot be nested inside #{name}", type_ref)
@@ -434,12 +434,12 @@ module MilkTea
         value.is_a?(Types::Base) ? value : nil
       end
 
-      def resolve_type_argument(argument, type_params: current_type_params, type_param_constraints: current_type_param_constraints)
+      def resolve_type_argument(argument, type_params: current_type_params, type_param_constraints: current_type_param_constraints, nested_types: current_nested_types)
         case argument
         when AST::TypeRef
-          resolve_type_argument_ref(argument, type_params:, type_param_constraints:)
+          resolve_type_argument_ref(argument, type_params:, type_param_constraints:, nested_types:)
         when AST::FunctionType, AST::ProcType, AST::TupleType
-          resolve_type_ref(argument, type_params:, type_param_constraints:)
+          resolve_type_ref(argument, type_params:, type_param_constraints:, nested_types:)
         when AST::IntegerLiteral, AST::FloatLiteral
           Types::LiteralTypeArg.new(argument.value)
         else
@@ -447,20 +447,20 @@ module MilkTea
         end
       end
 
-      def resolve_type_argument_ref(type_ref, type_params:, type_param_constraints:)
-        return resolve_type_ref(type_ref, type_params:, type_param_constraints:) unless literal_type_argument_name_candidate?(type_ref)
+      def resolve_type_argument_ref(type_ref, type_params:, type_param_constraints:, nested_types:)
+        return resolve_type_ref(type_ref, type_params:, type_param_constraints:, nested_types:) unless literal_type_argument_name_candidate?(type_ref)
 
-        result = try_resolve_type_ref(type_ref, type_params:, type_param_constraints:)
+        result = try_resolve_type_ref(type_ref, type_params:, type_param_constraints:, nested_types:)
         return result if result
 
         literal_type_argument = resolve_named_literal_type_argument(type_ref)
         return literal_type_argument if literal_type_argument
 
-        resolve_type_ref(type_ref, type_params:, type_param_constraints:)
+        resolve_type_ref(type_ref, type_params:, type_param_constraints:, nested_types:)
       end
 
-      def try_resolve_type_ref(type_ref, type_params:, type_param_constraints:)
-        resolve_type_ref(type_ref, type_params:, type_param_constraints:)
+      def try_resolve_type_ref(type_ref, type_params:, type_param_constraints:, nested_types:)
+        resolve_type_ref(type_ref, type_params:, type_param_constraints:, nested_types:)
       rescue SemanticError
         nil
       end
@@ -867,10 +867,6 @@ module MilkTea
         Types.pointer_to(type)
       end
 
-      def contains_type_var?(type)
-        super
-      end
-
       def resolve_nested_type_ref(parts)
         current = @ctx.types[parts.first]
         return nil unless current.is_a?(Types::Struct) || current.is_a?(Types::GenericStructDefinition)
@@ -975,18 +971,6 @@ module MilkTea
         nil
       end
 
-      def collection_loop_type(type)
-        super
-      end
-
-      def collection_loop_binding_type(iterable_type, element_type)
-        super
-      end
-
-      def collection_loop_ref_element_type?(type)
-        super
-      end
-
       def iterator_loop_type(type)
         type = referenced_type(type) if ref_type?(type)
         iter_method = lookup_method(type, "iter")
@@ -1091,7 +1075,7 @@ module MilkTea
         when AST::Identifier
           return current_type_params[expression.name] if current_type_params.key?(expression.name)
 
-          @ctx.types[expression.name]
+          lookup_named_type(expression.name)
         when AST::MemberAccess
           return nil unless expression.receiver.is_a?(AST::Identifier)
 

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

@@ -164,65 +164,6 @@ module MilkTea
         backing_type.integer_width == expected_type.integer_width
       end
 
-      def common_numeric_type(left_type, right_type)
-        left_type = left_type.backing_type if left_type.is_a?(Types::EnumBase)
-        right_type = right_type.backing_type if right_type.is_a?(Types::EnumBase)
-        return unless left_type.is_a?(Types::Primitive) && right_type.is_a?(Types::Primitive)
-        return unless left_type.numeric? && right_type.numeric?
-        return left_type if left_type == right_type
-
-        return common_integer_type(left_type, right_type) if left_type.integer? && right_type.integer?
-        return wider_float_type(left_type, right_type) if left_type.float? && right_type.float?
-
-        float_type, integer_type = left_type.float? ? [left_type, right_type] : [right_type, left_type]
-        return unless integer_type.integer? && integer_type.fixed_width_integer?
-
-        float_type
-      end
-
-      def common_integer_type(left_type, right_type)
-        left_type = left_type.backing_type if left_type.is_a?(Types::EnumBase)
-        right_type = right_type.backing_type if right_type.is_a?(Types::EnumBase)
-        return unless left_type.is_a?(Types::Primitive) && right_type.is_a?(Types::Primitive)
-        return unless left_type.integer? && right_type.integer?
-        return left_type if left_type == right_type
-        return unless left_type.fixed_width_integer? && right_type.fixed_width_integer?
-
-        # Same signedness: the wider type wins (both operands are losslessly
-        # assignable to it).
-        if left_type.signed_integer? == right_type.signed_integer?
-          return left_type.integer_width >= right_type.integer_width ? left_type : right_type
-        end
-
-        # Mixed signed/unsigned: promote to the narrowest signed type that holds
-        # both operands' full ranges, mirroring the lossless assignment rule. A
-        # strictly-wider signed type covers an unsigned operand; equal-width or
-        # wider unsigned operands widen to the next signed width. Mixing with a
-        # 64-bit unsigned type has no safe signed common type, so callers fall
-        # back to requiring an explicit cast.
-        signed_type, unsigned_type = if left_type.signed_integer?
-          [left_type, right_type]
-        else
-          [right_type, left_type]
-        end
-
-        return signed_type if signed_type.integer_width > unsigned_type.integer_width
-
-        signed_type_above_width(unsigned_type.integer_width)
-      end
-
-      def signed_type_above_width(width)
-        case width
-        when 8 then @ctx.types.fetch("short")
-        when 16 then @ctx.types.fetch("int")
-        when 32 then @ctx.types.fetch("long")
-        end
-      end
-
-      def wider_float_type(left_type, right_type)
-        left_type.float_width >= right_type.float_width ? left_type : right_type
-      end
-
       def pointer_arithmetic_result(operator, left_type, right_type)
         if pointer_type?(left_type) && integer_type?(right_type)
           require_unsafe!("pointer arithmetic requires unsafe") unless own_type?(left_type)

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

@@ -186,7 +186,6 @@ module MilkTea
           implemented_interfaces: {}, imports: {},
           private_types: {}, private_interfaces: {}, private_attributes: {},
           private_values: {}, private_functions: {}, private_methods: {},
-          private_implemented_interfaces: {},
         )
       end
 
@@ -342,7 +341,6 @@ module MilkTea
               params: params.freeze,
               module_name: @ctx.module_name,
               builtin: false,
-              ast: decl,
             )
           end
         end

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

@@ -650,6 +650,63 @@ module MilkTea
       def array_element_type(type)
         type.arguments.first
       end
+
+      def common_numeric_type(left_type, right_type)
+        left_type = left_type.backing_type if left_type.is_a?(Types::EnumBase)
+        right_type = right_type.backing_type if right_type.is_a?(Types::EnumBase)
+        return unless left_type.is_a?(Types::Primitive) && right_type.is_a?(Types::Primitive)
+        return unless left_type.numeric? && right_type.numeric?
+        return left_type if left_type == right_type
+
+        return common_integer_type(left_type, right_type) if left_type.integer? && right_type.integer?
+        return wider_float_type(left_type, right_type) if left_type.float? && right_type.float?
+
+        float_type, integer_type = left_type.float? ? [left_type, right_type] : [right_type, left_type]
+        return unless integer_type.integer? && integer_type.fixed_width_integer?
+
+        float_type
+      end
+
+      def common_integer_type(left_type, right_type)
+        left_type = left_type.backing_type if left_type.is_a?(Types::EnumBase)
+        right_type = right_type.backing_type if right_type.is_a?(Types::EnumBase)
+        return unless left_type.is_a?(Types::Primitive) && right_type.is_a?(Types::Primitive)
+        return unless left_type.integer? && right_type.integer?
+        return left_type if left_type == right_type
+        return unless left_type.fixed_width_integer? && right_type.fixed_width_integer?
+
+        # Same signedness: the wider type wins. Mixed signed/unsigned: promote to
+        # the narrowest signed type that holds both operands' full ranges. A
+        # strictly-wider signed type covers an unsigned operand; equal-width or
+        # wider unsigned operands widen to the next signed width. Mixing with a
+        # 64-bit unsigned type has no safe signed common type, so callers fall
+        # back to requiring an explicit cast.
+        if left_type.signed_integer? == right_type.signed_integer?
+          return left_type.integer_width >= right_type.integer_width ? left_type : right_type
+        end
+
+        signed_type, unsigned_type = if left_type.signed_integer?
+          [left_type, right_type]
+        else
+          [right_type, left_type]
+        end
+
+        return signed_type if signed_type.integer_width > unsigned_type.integer_width
+
+        signed_type_above_width(unsigned_type.integer_width)
+      end
+
+      def signed_type_above_width(width)
+        case width
+        when 8 then Types::Registry.primitive("short")
+        when 16 then Types::Registry.primitive("int")
+        when 32 then Types::Registry.primitive("long")
+        end
+      end
+
+      def wider_float_type(left_type, right_type)
+        left_type.float_width >= right_type.float_width ? left_type : right_type
+      end
     end
   end
 end

data/lib/milk_tea/core/types.rb

@@ -1712,10 +1712,6 @@ module MilkTea
       GenericInstance.new("ptr", [type])
     end
 
-    def self.integer_type?(type)
-      type.is_a?(Primitive) && %w[int ptr_uint i8 i16 i32 i64 u8 u16 u32 u64].include?(type.name)
-    end
-
     def self.array_type?(type)
       type.is_a?(GenericInstance) && type.name == "array" && type.arguments.length == 2
     end

data/lib/milk_tea/lsp/server/code_actions.rb

@@ -443,10 +443,6 @@ module MilkTea
           { items: [] }
         end
 
-        def refresh_workspace_diagnostics
-          @protocol.write_notification('workspace/diagnostic/refresh', nil)
-        end
-
         def find_match_end_line(lines, match_start_idx)
           return nil if match_start_idx >= lines.length
 

data/lib/milk_tea/tooling/formatter.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "../core"
-require_relative "cst_formatter"
 
 module MilkTea
   class FormatterError < StandardError; end
@@ -49,12 +48,12 @@ module MilkTea
 
     def self.preserve_format(source, path:, profile: nil)
       cst = profile_phase(profile, "format.cst") { build_cst(source, path:) }
-      profile_phase(profile, "format.cst_fmt") { CSTFormatter.format(cst) }
+      profile_phase(profile, "format.cst_fmt") { cst.reconstruct }
     end
 
     def self.tidy_format(source, path:, max_line_length: DEFAULT_MAX_LINE_LENGTH, profile: nil)
       cst = profile_phase(profile, "format.cst") { build_cst(source, path:) }
-      normalized = profile_phase(profile, "format.normalize") { CSTFormatter.format_normalized(cst) }
+      normalized = profile_phase(profile, "format.normalize") { cst.reconstruct_normalized }
       wrapped = profile_phase(profile, "format.wrap") { wrap_long_argument_lists(normalized, max_line_length:, path:) }
       profile_phase(profile, "format.blank_lines") { normalize_blank_lines(wrapped, path:) }
     end

data/lib/milk_tea/tooling/linter/fix_engine.rb

@@ -17,6 +17,7 @@ module MilkTea
         when "redundant-else"         then redundant_else_edits(lines, warning)
         when "redundant-return"       then redundant_return_edits(lines, warning)
         when "redundant-type-annotation" then redundant_type_annotation_edits(lines, warning)
+        when "prefer-inline-methods"  then prefer_inline_methods_edits(lines, warning)
         when "unused-import"          then unused_import_edits(lines, warning)
         when "trailing-list-comma"    then trailing_list_comma_edits(lines, warning)
         else []
@@ -152,6 +153,51 @@ module MilkTea
         [FixEdit.new(start_line: line_idx, start_char: 0, end_line: line_idx + 1, end_char: 0, new_text: "")]
       end
 
+      # Moves the methods of an `extending X:` block inline into the matching
+      # `struct X:` declaration. Only rewrites when the struct immediately
+      # precedes the extending block (blank lines allowed between them); other
+      # layouts are left alone since the move would be non-local.
+      def self.prefer_inline_methods_edits(lines, warning)
+        name = warning.symbol_name
+        return [] unless name && warning.line
+
+        struct_idx = lines.index { |l| l.match?(/\A\s*struct\s+#{Regexp.escape(name)}\b/) }
+        return [] unless struct_idx
+
+        last_member_idx = nil
+        ((struct_idx + 1)...lines.length).each do |i|
+          l = lines[i]
+          break if !l.chomp.empty? && !l.start_with?(" ", "\t")
+
+          last_member_idx = i unless l.chomp.empty?
+        end
+        return [] unless last_member_idx
+
+        ext_start_idx = warning.line - 1
+        return [] unless last_member_idx < ext_start_idx
+
+        ext_end_idx = ext_start_idx
+        ((ext_start_idx + 1)...lines.length).each do |i|
+          l = lines[i]
+          break if !l.chomp.empty? && !l.start_with?(" ", "\t")
+
+          ext_end_idx = i unless l.chomp.empty?
+        end
+
+        method_lines = lines[(ext_start_idx + 1)..ext_end_idx].to_a
+        method_lines.shift while method_lines.first && method_lines.first.chomp.empty?
+        method_lines.pop while method_lines.last && method_lines.last.chomp.empty?
+        return [] if method_lines.empty?
+
+        between = lines[(last_member_idx + 1)...ext_start_idx]
+        return [] unless between.all? { |l| l.chomp.empty? }
+
+        method_text = method_lines.join
+        new_text = "#{lines[last_member_idx].chomp}\n\n#{method_text}"
+
+        [FixEdit.new(start_line: last_member_idx, start_char: 0, end_line: ext_end_idx + 1, end_char: 0, new_text: new_text)]
+      end
+
       def self.unused_import_edits(lines, warning)
         return [] unless warning.line
 

data/lib/milk_tea/tooling/linter/rules.rb

@@ -586,6 +586,38 @@ module MilkTea
       def lvalue_expression?(expression)
         expression.is_a?(AST::Identifier) || expression.is_a?(AST::MemberAccess) || expression.is_a?(AST::IndexAccess)
       end
+      # ── prefer-inline-methods ──────────────────────────────────────────────
+      # Flag `extending X:` blocks whose receiver struct is declared in the same
+      # file, suggesting the methods be written inline inside the struct body
+      # (which desugars to the identical `extending` block).
+
+      def emit_prefer_inline_methods_warnings(source_file)
+        struct_names = source_file.declarations.filter_map { |decl| decl.name if decl.is_a?(AST::StructDecl) }.to_set
+        return if struct_names.empty?
+
+        source_file.declarations.each do |declaration|
+          next unless declaration.is_a?(AST::ExtendingBlock)
+          next if declaration.inline
+
+          parts = declaration.type_name.name.parts
+          next unless parts.length == 1
+          next if declaration.type_name.arguments.any?
+
+          name = parts.first
+          next unless struct_names.include?(name)
+
+          @warnings << Warning.new(
+            path: @path,
+            line: declaration.line,
+            column: declaration.column,
+            length: name.length,
+            code: "prefer-inline-methods",
+            message: "methods on '#{name}' can be written inline inside the struct declaration",
+            severity: :hint,
+            symbol_name: name,
+          )
+        end
+      end
     end
   end
 end

data/lib/milk_tea/tooling/linter.rb

@@ -35,6 +35,7 @@ module MilkTea
       owning-release-double
       prefer-conditional-expression
       prefer-inline-if
+      prefer-inline-methods
       prefer-is-variant
       prefer-let
       prefer-let-else
@@ -69,6 +70,7 @@ module MilkTea
       redundant-ignored-match-binding
       prefer-let-else
       prefer-var-else
+      prefer-inline-methods
       redundant-bool-compare
       redundant-cast
       redundant-else
@@ -95,6 +97,7 @@ module MilkTea
       "redundant-type-annotation" => "Remove redundant type annotation",
       "prefer-let-else" => "Rewrite as let-else",
       "prefer-var-else" => "Rewrite as var-else",
+      "prefer-inline-methods" => "Inline methods into struct",
       "trailing-list-comma" => "Remove trailing list comma",
     }.freeze
     EVENT_STACK_SNAPSHOT_WARNING_THRESHOLD = 128
@@ -771,6 +774,7 @@ module MilkTea
       profile_phase("rule.doc_tag") { emit_doc_tag_warnings(ast) } if full_tier?
       profile_phase("rule.event_capacity") { emit_event_capacity_warnings(ast) }
       profile_phase("rule.trailing_list_comma") { emit_trailing_list_comma_warnings(ast) }
+      profile_phase("rule.prefer_inline_methods") { emit_prefer_inline_methods_warnings(ast) }
       profile_phase("rule.line_too_long") { emit_line_too_long_warnings }
       @warnings
     end

data/lib/milk_tea/tooling.rb

@@ -11,7 +11,6 @@ require_relative "tooling/sexpr_dumper"
 require_relative "tooling/sexpr_parser"
 require_relative "tooling/build"
 require_relative "tooling/run"
-require_relative "tooling/cst_formatter"
 require_relative "tooling/error_formatter"
 require_relative "tooling/formatter"
 require_relative "tooling/linter"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.3.39
+  version: 0.3.40
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -385,7 +385,6 @@ files:
 - lib/milk_tea/tooling/cli/commands/snapshot.rb
 - lib/milk_tea/tooling/cli/commands/test.rb
 - lib/milk_tea/tooling/cli/commands/toolchain.rb
-- lib/milk_tea/tooling/cst_formatter.rb
 - lib/milk_tea/tooling/debug_info_formatter.rb
 - lib/milk_tea/tooling/debug_map.rb
 - lib/milk_tea/tooling/docs_app.rb
@@ -626,7 +625,7 @@ metadata:
   homepage_uri: https://teefan.github.io/mt-lang/
   source_code_uri: https://github.com/teefan/mt-lang
 post_install_message: |
-  Milk Tea 0.3.39 installed!
+  Milk Tea 0.3.40 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH

data/lib/milk_tea/tooling/cst_formatter.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module MilkTea
-  class CSTFormatter
-    def self.format(cst)
-      cst.reconstruct
-    end
-
-    def self.format_normalized(cst)
-      cst.reconstruct_normalized
-    end
-  end
-end