mt-lang 0.3.38 → 0.3.40

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