mt-lang 0.3.39 → 0.3.41

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/registry.rb

@@ -41,16 +41,28 @@ module MilkTea
         _intern([:string_view]) { StringView.new }
       end
 
+      # Param signature for intern keys. Parameter#eql? is name-insensitive
+      # (assignability must not depend on parameter names), so arrays of
+      # Parameter objects would conflate fn(value: int) with fn(arg0: int) in
+      # the intern pool. Embedding names here keeps distinct signatures
+      # distinct across independent programs sharing a long-lived pool (the LSP
+      # never resets the registry between checks).
+      def self.param_signature(params)
+        params.map { |p| [p.name, p.type, p.mutable, p.passing_mode, p.boundary_type] }
+      end
+
       def self.function(name, params:, return_type:, receiver_type: nil, receiver_editable: false, variadic: false, external: false)
         params_frozen = params.freeze
-        _intern([:function, name, params_frozen, return_type, receiver_type, receiver_editable, variadic, external]) {
+        param_key = param_signature(params_frozen)
+        _intern([:function, name, param_key, return_type, receiver_type, receiver_editable, variadic, external]) {
           Function.new(name, params: params_frozen, return_type: return_type, receiver_type: receiver_type, receiver_editable: receiver_editable, variadic: variadic, external: external)
         }
       end
 
       def self.proc(params:, return_type:)
         params_frozen = params.freeze
-        _intern([:proc, params_frozen, return_type]) { Proc.new(params: params_frozen, return_type: return_type) }
+        param_key = param_signature(params_frozen)
+        _intern([:proc, param_key, return_type]) { Proc.new(params: params_frozen, return_type: return_type) }
       end
 
       def self.parameter(name, type, mutable: false, passing_mode: :plain, boundary_type: nil)

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

@@ -360,6 +360,8 @@ module MilkTea
         end
 
         def handle_document_diagnostic(params)
+          return { kind: 'full', items: [] } if request_cancelled?(@current_request_id)
+
           uri = params.dig('textDocument', 'uri')
           return { kind: 'full', items: [] } unless uri
 
@@ -404,6 +406,8 @@ module MilkTea
         end
 
         def handle_workspace_diagnostic(params)
+          return { items: [] } if request_cancelled?(@current_request_id)
+
           progress = nil
           if (work_done_token = params['workDoneToken'])
             progress = create_progress_handle(@protocol, work_done_token)
@@ -416,7 +420,13 @@ module MilkTea
           end
 
           all_uris = @workspace.open_document_uris
-          items = all_uris.filter_map do |uri|
+          items = []
+          all_uris.each do |uri|
+            # Coarse cancellation: workspace/diagnostic can iterate many cold
+            # documents (~1s each); bail early when the client cancels so we do
+            # not sink CPU into results that will be discarded.
+            break if request_cancelled?(@current_request_id)
+
             content = @workspace.get_content(uri)
             next if content.empty?
 
@@ -426,10 +436,10 @@ module MilkTea
 
             cached = @workspace_diagnostic_cache[uri]
             if cached && cached[:result_id] == prev_map[uri] && cached[:fingerprint] == fingerprint
-              { uri: uri, kind: 'unchanged', resultId: result_id, items: [], version: nil }
+              items << { uri: uri, kind: 'unchanged', resultId: result_id, items: [], version: nil }
             else
               @workspace_diagnostic_cache[uri] = { result_id: result_id, fingerprint: fingerprint }
-              { uri: uri, kind: 'full', resultId: result_id, items: diagnostics, version: nil }
+              items << { uri: uri, kind: 'full', resultId: result_id, items: diagnostics, version: nil }
             end
           end
 
@@ -443,10 +453,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