steep 0.11.1 → 0.12.0

data/lib/steep/subtyping/constraints.rb

@@ -199,7 +199,7 @@ module Steep
         end
       end
 
-      def solution(checker, variance:, variables:)
+      def solution(checker, variance:, variables:, self_type:)
         vars = []
         types = []
 
@@ -210,7 +210,7 @@ module Steep
               lower_bound = lower_bound(var)
               relation = Relation.new(sub_type: lower_bound, super_type: upper_bound)
 
-              checker.check(relation, constraints: self.class.empty).yield_self do |result|
+              checker.check(relation, self_type: self_type, constraints: self.class.empty).yield_self do |result|
                 if result.success?
                   vars << var
 

data/lib/steep/subtyping/trace.rb

@@ -7,6 +7,29 @@ module Steep
         @array = array
       end
 
+      def interface(sub, sup, &block)
+        push :interface, sub, sup, &block
+      end
+
+      def method(name, sub, sup, &block)
+        push :method, sub, sup, name, &block
+      end
+
+      def method_type(name, sub, sup, &block)
+        push :method_type, sub, sup, name, &block
+      end
+
+      def type(sub, sup, &block)
+        push :type, sub, sup, &block
+      end
+
+      def push(*xs)
+        array << xs
+        yield
+      ensure
+        array.pop
+      end
+
       def add(sup, sub)
         array << [sup, sub]
         yield

data/lib/steep/type_construction.rb

@@ -6,22 +6,20 @@ module Steep
       attr_reader :method_type
       attr_reader :return_type
       attr_reader :constructor
+      attr_reader :super_method
 
-      def initialize(name:, method:, method_type:, return_type:, constructor:)
+      def initialize(name:, method:, method_type:, return_type:, constructor:, super_method:)
         @name = name
         @method = method
         @return_type = return_type
         @method_type = method_type
         @constructor = constructor
+        @super_method = super_method
       end
 
       def block_type
         method_type&.block
       end
-
-      def super_method
-        method&.super_method
-      end
     end
 
     class BlockContext
@@ -51,8 +49,10 @@ module Steep
       attr_reader :implement_name
       attr_reader :current_namespace
       attr_reader :class_name
+      attr_reader :instance_definition
+      attr_reader :module_definition
 
-      def initialize(instance_type:, module_type:, implement_name:, current_namespace:, const_env:, class_name:)
+      def initialize(instance_type:, module_type:, implement_name:, current_namespace:, const_env:, class_name:, instance_definition: nil, module_definition: nil)
         @instance_type = instance_type
         @module_type = module_type
         @defined_instance_methods = Set.new
@@ -61,6 +61,8 @@ module Steep
         @current_namespace = current_namespace
         @const_env = const_env
         @class_name = class_name
+        @instance_definition = instance_definition
+        @module_definition = module_definition
       end
 
       def const_context
@@ -107,8 +109,12 @@ module Steep
       )
     end
 
-    def for_new_method(method_name, node, args:, self_type:)
-      annots = source.annotations(block: node, builder: checker.builder, current_module: current_namespace)
+    def check_relation(sub_type:, super_type:, constraints: Subtyping::Constraints.empty)
+      checker.check(Subtyping::Relation.new(sub_type: sub_type, super_type: super_type), self_type: self_type, constraints: constraints)
+    end
+
+    def for_new_method(method_name, node, args:, self_type:, definition:)
+      annots = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
       type_env = TypeInference::TypeEnv.new(subtyping: checker,
                                             const_env: module_context&.const_env || self.type_env.const_env)
 
@@ -116,151 +122,83 @@ module Steep
         type_env.set(const: name, type: type)
       end
 
-      self_type = expand_alias(annots.self_type || self_type)
-
-      self_interface = self_type && (self_type != AST::Builtin.any_type || nil) && case self_type
-                                                                                   when AST::Types::Name::Instance
-                                                                                     yield_self do
-                                                                                       class_type = AST::Types::Name::Class.new(name: self_type.name, constructor: false)
-                                                                                       checker.resolve_instance(self_type,
-                                                                                                                self_type: self_type,
-                                                                                                                instance_type: self_type,
-                                                                                                                module_type: class_type,
-                                                                                                                with_private: true)
-                                                                                     end
-                                                                                   else
-                                                                                     checker.resolve(self_type)
-                                                                                   end
-      interface_method = self_interface&.yield_self do |interface|
-        interface.methods[method_name]&.yield_self do |method|
-          if self_type.is_a?(AST::Types::Name::Base) && method.type_name == self_type.name
-            method
-          else
-            Interface::Method.new(type_name: self_type,
-                                  name: method_name,
-                                  types: method.types,
-                                  super_method: method,
-                                  attributes: [])
-          end
-        end
-      end
-
-      annotation_method = annotations.method_type(method_name)&.yield_self do |method_type|
-        subst = Interface::Substitution.build([],
-                                              instance_type: module_context&.instance_type || AST::Types::Instance.new,
-                                              module_type: module_context&.module_type || AST::Types::Class.new,
-                                              self_type: self_type)
-        Interface::Method.new(type_name: nil,
-                              name: method_name,
-                              types: [method_type.subst(subst)],
-                              super_method: interface_method&.super_method,
-                              attributes: [])
-      end
-
-      if interface_method && annotation_method
-        interface_types = interface_method.types.map do |method_type|
-          subst = Interface::Substitution.build(method_type.type_params)
-          method_type.instantiate(subst)
-        end
-
-        unknowns = []
-        annotation_types = annotation_method.types.each.with_object([]) do |method_type, array|
-          fresh = method_type.type_params.map {|var| AST::Types::Var.fresh(var) }
-          unknowns.push(*fresh)
-
-          subst = Interface::Substitution.build(method_type.type_params, fresh)
-          array << method_type.instantiate(subst)
-        end
-
-        constraints = Subtyping::Constraints.new(unknowns: unknowns)
-        interface_types.each do |type|
-          constraints.add_var(*type.free_variables.to_a)
-        end
+      definition_method_type = if definition
+                                 definition.methods[method_name]&.yield_self do |method|
+                                   method.method_types
+                                     .map {|method_type| checker.factory.method_type(method_type, self_type: self_type) }
+                                     .select {|method_type| method_type.is_a?(Interface::MethodType) }
+                                     .inject {|t1, t2| t1 + t2}
+                                 end
+                               end
+      annotation_method_type = annotations.method_type(method_name)
 
-        result = checker.check_method(method_name,
-                                      annotation_method.with_types(annotation_types),
-                                      interface_method.with_types(interface_types),
-                                      assumption: Set.new,
-                                      trace: Subtyping::Trace.new,
-                                      constraints: constraints)
+      method_type = annotation_method_type || definition_method_type
 
-        if result.failure?
-          typing.add_error Errors::IncompatibleMethodTypeAnnotation.new(
-            node: node,
-            annotation_method: annotation_method,
-            interface_method: interface_method,
-            result: result
-          )
+      if annots&.return_type && method_type&.return_type
+        check_relation(sub_type: annots.return_type, super_type: method_type.return_type).else do |result|
+          typing.add_error Errors::MethodReturnTypeAnnotationMismatch.new(node: node,
+                                                                          method_type: method_type.return_type,
+                                                                          annotation_type: annots.return_type,
+                                                                          result: result)
         end
       end
 
-      method = annotation_method || interface_method
+      # constructor_method = method&.attributes&.include?(:constructor)
 
-      case
-      when method && method.types.size == 1
-        method_type = method.types.first
-        return_type = method_type.return_type
+      if method_type
         var_types = TypeConstruction.parameter_types(args, method_type)
-        unless TypeConstruction.valid_parameter_env?(var_types, args.reject {|arg| arg.type == :blockarg }, method_type.params)
+        unless TypeConstruction.valid_parameter_env?(var_types, args.reject {|arg| arg.type == :blockarg}, method_type.params)
           typing.add_error Errors::MethodArityMismatch.new(node: node)
         end
-
-        if (block_arg = args.find {|arg| arg.type == :blockarg })
-          if method_type.block
-            block_type = if method_type.block.optional?
-                           AST::Types::Union.build(types: [method_type.block.type, AST::Builtin.nil_type])
-                         else
-                           method_type.block.type
-                         end
-            var_types[block_arg.children[0].name] = block_type
-          end
-        end
-
-      when method
-        typing.add_error Errors::MethodDefinitionWithOverloading.new(node: node, method: method)
-        return_type = union_type(*method.types.map(&:return_type))
-        var_types = {}
-      else
-        var_types = {}
       end
 
-      if annots.return_type && return_type
-        return_type_relation = Subtyping::Relation.new(sub_type: annots.return_type,
-                                                       super_type: return_type)
-        checker.check(return_type_relation, constraints: Subtyping::Constraints.empty).else do |result|
-          typing.add_error Errors::MethodReturnTypeAnnotationMismatch.new(node: node,
-                                                                          method_type: return_type,
-                                                                          annotation_type: annots.return_type,
-                                                                          result: result)
+      if (block_arg = args.find {|arg| arg.type == :blockarg})
+        if method_type&.block
+          block_type = if method_type.block.optional?
+                         AST::Types::Union.build(types: [method_type.block.type, AST::Builtin.nil_type])
+                       else
+                         method_type.block.type
+                       end
+          var_types[block_arg.children[0].name] = block_type
         end
       end
 
-      constructor_method = method&.attributes&.include?(:constructor)
+      super_method = if definition
+                       if (this_method = definition.methods[method_name])
+                         if module_context&.class_name == checker.factory.type_name(this_method.defined_in.name.absolute!)
+                           this_method.super_method
+                         else
+                           this_method
+                         end
+                       end
+                     end
 
       method_context = MethodContext.new(
         name: method_name,
-        method: method,
+        method: definition && definition.methods[method_name],
         method_type: method_type,
-        return_type: annots.return_type || return_type,
-        constructor: constructor_method
+        return_type: annots.return_type || method_type&.return_type || AST::Builtin.any_type,
+        constructor: false,
+        super_method: super_method
       )
 
-      var_types.each do |name, type|
-        type_env.set(lvar: name, type: type)
+      if var_types
+        var_types.each do |name, type|
+          type_env.set(lvar: name, type: type)
+        end
       end
 
-      ivar_types = {}
-      ivar_types.merge!(self_interface.ivars) if self_interface
-      ivar_types.merge!(annots.ivar_types)
-
-      ivar_types.each do |name, type|
-        type_env.set(ivar: name, type: type)
+      if definition
+        definition.instance_variables.each do |name, decl|
+          type_env.set(ivar: name, type: checker.factory.type(decl.type))
+        end
       end
 
       type_env = type_env.with_annotations(
         lvar_types: annots.lvar_types,
         ivar_types: annots.ivar_types,
         const_types: annots.const_types,
+        self_type: annots.self_type || self_type
       )
 
       self.class.new(
@@ -269,7 +207,7 @@ module Steep
         annotations: annots,
         type_env: type_env,
         block_context: nil,
-        self_type: self_type,
+        self_type: annots.self_type || self_type,
         method_context: method_context,
         typing: typing,
         module_context: module_context,
@@ -281,13 +219,13 @@ module Steep
       new_module_name = Names::Module.from_node(node.children.first) or raise "Unexpected module name: #{node.children.first}"
       new_namespace = nested_namespace_for_module(new_module_name)
 
-      annots = source.annotations(block: node, builder: checker.builder, current_module: new_namespace)
+      annots = source.annotations(block: node, factory: checker.factory, current_module: new_namespace)
       module_type = AST::Builtin::Module.instance_type
 
       implement_module_name = yield_self do
         if (annotation = annots.implement_module_annotation)
           absolute_name(annotation.name.name).yield_self do |absolute_name|
-            if checker.builder.signatures.module_name?(absolute_name)
+            if checker.factory.module_name?(absolute_name)
               AST::Annotation::Implements::Module.new(name: absolute_name,
                                                       args: annotation.name.args)
             else
@@ -297,10 +235,11 @@ module Steep
           end
         else
           absolute_name(new_module_name).yield_self do |absolute_name|
-            if checker.builder.signatures.module_name?(absolute_name)
-              signature = checker.builder.signatures.find_module(absolute_name)
+            if checker.factory.module_name?(absolute_name)
+              absolute_name_ = checker.factory.type_name_1(absolute_name)
+              decl = checker.factory.env.find_class(absolute_name_)
               AST::Annotation::Implements::Module.new(name: absolute_name,
-                                                      args: signature.params&.variables || [])
+                                                      args: decl.type_params.each.map(&:name))
             end
           end
         end
@@ -308,22 +247,25 @@ module Steep
 
       if implement_module_name
         module_name = implement_module_name.name
-        module_args = implement_module_name.args.map {|x| AST::Types::Var.new(name: x) }
-
-        abstract = checker.builder.build_module(module_name)
-
-        instance_type = AST::Types::Name::Instance.new(name: module_name, args: module_args)
-
-        unless abstract.supers.empty?
-          instance_type = AST::Types::Intersection.build(
-            types: [instance_type, AST::Builtin::Object.instance_type] + abstract.supers.map {|x| absolute_type(x) }
-          )
-        end
+        module_args = implement_module_name.args.map {|x| AST::Types::Var.new(name: x)}
+
+        type_name_ = checker.factory.type_name_1(implement_module_name.name)
+        module_decl = checker.factory.definition_builder.env.find_class(type_name_)
+        instance_def = checker.factory.definition_builder.build_instance(type_name_)
+        module_def = checker.factory.definition_builder.build_singleton(type_name_)
+
+        instance_type = AST::Types::Intersection.build(
+          types: [
+            AST::Types::Name::Instance.new(name: module_name, args: module_args),
+            AST::Builtin::Object.instance_type,
+            module_decl.self_type&.yield_self {|ty|
+              absolute_type = checker.factory.env.absolute_type(ty, namespace: module_decl.name.absolute!.namespace)
+              checker.factory.type(absolute_type)
+            }
+          ].compact
+        )
 
-        module_type = AST::Types::Intersection.build(types: [
-          AST::Builtin::Module.instance_type,
-          AST::Types::Name::Module.new(name: module_name)
-        ])
+        module_type = AST::Types::Name::Class.new(name: module_name, constructor: nil)
       end
 
       if annots.instance_type
@@ -339,7 +281,7 @@ module Steep
                       else
                         Names::Module.new(name: new_namespace.path.last, namespace: new_namespace.parent)
                       end
-      module_const_env = TypeInference::ConstantEnv.new(builder: checker.builder, context: const_context)
+      module_const_env = TypeInference::ConstantEnv.new(factory: checker.factory, context: const_context)
 
       module_context_ = ModuleContext.new(
         instance_type: instance_type,
@@ -347,13 +289,15 @@ module Steep
         implement_name: implement_module_name,
         current_namespace: new_namespace,
         const_env: module_const_env,
-        class_name: absolute_name(new_module_name)
+        class_name: absolute_name(new_module_name),
+        instance_definition: instance_def,
+        module_definition: module_def
       )
 
       module_type_env = TypeInference::TypeEnv.build(annotations: annots,
                                                      subtyping: checker,
                                                      const_env: module_const_env,
-                                                     signatures: checker.builder.signatures)
+                                                     signatures: checker.factory.env)
 
       self.class.new(
         checker: checker,
@@ -374,12 +318,12 @@ module Steep
       super_class_name = node.children[1] && Names::Module.from_node(node.children[1])
       new_namespace = nested_namespace_for_module(new_class_name)
 
-      annots = source.annotations(block: node, builder: checker.builder, current_module: new_namespace)
+      annots = source.annotations(block: node, factory: checker.factory, current_module: new_namespace)
 
       implement_module_name = yield_self do
         if (annotation = annots.implement_module_annotation)
           absolute_name(annotation.name.name).yield_self do |absolute_name|
-            if checker.builder.signatures.class_name?(absolute_name)
+            if checker.factory.class_name?(absolute_name)
               AST::Annotation::Implements::Module.new(name: absolute_name,
                                                       args: annotation.name.args)
             else
@@ -390,16 +334,17 @@ module Steep
         else
           name = nil
           name ||= absolute_name(new_class_name).yield_self do |absolute_name|
-            absolute_name if checker.builder.signatures.class_name?(absolute_name)
+            absolute_name if checker.factory.class_name?(absolute_name)
           end
           name ||= super_class_name && absolute_name(super_class_name).yield_self do |absolute_name|
-            absolute_name if checker.builder.signatures.class_name?(absolute_name)
+            absolute_name if checker.factory.class_name?(absolute_name)
           end
 
           if name
-            signature = checker.builder.signatures.find_class(name)
+            absolute_name_ = checker.factory.type_name_1(name)
+            decl = checker.factory.env.find_class(absolute_name_)
             AST::Annotation::Implements::Module.new(name: name,
-                                                    args: signature.params&.variables || [])
+                                                    args: decl.type_params.each.map(&:name))
           end
         end
       end
@@ -410,12 +355,22 @@ module Steep
 
       if implement_module_name
         class_name = implement_module_name.name
-        class_args = implement_module_name.args.map {|x| AST::Types::Var.new(name: x) }
+        class_args = implement_module_name.args.map {|x| AST::Types::Var.new(name: x)}
 
-        _ = checker.builder.build_instance(class_name)
+        type_name_ = checker.factory.type_name_1(implement_module_name.name)
+        instance_def = checker.factory.definition_builder.build_instance(type_name_)
+        module_def = checker.factory.definition_builder.build_singleton(type_name_)
 
         instance_type = AST::Types::Name::Instance.new(name: class_name, args: class_args)
-        module_type = AST::Types::Name::Class.new(name: class_name, constructor: true)
+        module_type = AST::Types::Name::Class.new(name: class_name, constructor: nil)
+      end
+
+      if annots.instance_type
+        instance_type = annots.instance_type
+      end
+
+      if annots.module_type
+        module_type = annots.module_type
       end
 
       const_context = if new_namespace.empty?
@@ -423,7 +378,7 @@ module Steep
                       else
                         Names::Module.new(name: new_namespace.path.last, namespace: new_namespace.parent)
                       end
-      class_const_env = TypeInference::ConstantEnv.new(builder: checker.builder, context: const_context)
+      class_const_env = TypeInference::ConstantEnv.new(factory: checker.factory, context: const_context)
 
       module_context = ModuleContext.new(
         instance_type: annots.instance_type || instance_type,
@@ -431,15 +386,16 @@ module Steep
         implement_name: implement_module_name,
         current_namespace: new_namespace,
         const_env: class_const_env,
-        class_name: absolute_name(new_class_name)
+        class_name: absolute_name(new_class_name),
+        module_definition: module_def,
+        instance_definition: instance_def
       )
 
-      class_type_env = TypeInference::TypeEnv.build(
-        annotations: annots,
-        const_env: class_const_env,
-        signatures: checker.builder.signatures,
-        subtyping: checker
-      )
+      class_type_env = TypeInference::TypeEnv.build(annotations: annots,
+                                                    subtyping: checker,
+                                                    const_env: class_const_env,
+                                                    signatures: checker.factory.env)
+
 
       self.class.new(
         checker: checker,
@@ -456,7 +412,7 @@ module Steep
     end
 
     def for_branch(node, truthy_vars: Set.new, type_case_override: nil)
-      annots = source.annotations(block: node, builder: checker.builder, current_module: current_namespace)
+      annots = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
 
       type_env = self.type_env
 
@@ -467,12 +423,12 @@ module Steep
           env[var] = type
         end
       end
-      type_env = type_env.with_annotations(lvar_types: lvar_types) do |var, relation, result|
+      type_env = type_env.with_annotations(lvar_types: lvar_types, self_type: self_type) do |var, relation, result|
         raise "Unexpected annotate failure: #{relation}"
       end
 
       if type_case_override
-        type_env = type_env.with_annotations(lvar_types: type_case_override) do |var, relation, result|
+        type_env = type_env.with_annotations(lvar_types: type_case_override, self_type: self_type) do |var, relation, result|
           typing.add_error(
             Errors::IncompatibleTypeCase.new(node: node,
                                              var_name: var,
@@ -486,7 +442,8 @@ module Steep
         lvar_types: annots.lvar_types,
         ivar_types: annots.ivar_types,
         const_types: annots.const_types,
-        gvar_types: {}
+        gvar_types: {},
+        self_type: self_type
       ) do |var, relation, result|
         typing.add_error(
           Errors::IncompatibleAnnotation.new(node: node,
@@ -585,6 +542,7 @@ module Steep
                      else
                        module_type
                      end
+
               typing.add_typing(node, type)
             else
               type_send(node, send_node: node, block_params: nil, block_body: nil)
@@ -640,38 +598,33 @@ module Steep
             when !lhs_type
               fallback_to_any(node)
             else
-              lhs_interface = checker.resolve(lhs_type)
+              lhs_interface = checker.factory.interface(lhs_type, private: false)
               op_method = lhs_interface.methods[op]
 
               if op_method
                 args = TypeInference::SendArgs.from_nodes([rhs])
-                return_type_or_error = type_method_call(node,
-                                                        receiver_type: lhs_type,
-                                                        method: op_method,
-                                                        args: args,
-                                                        block_params: nil,
-                                                        block_body: nil)
-
-                if return_type_or_error.is_a?(Errors::Base)
-                  typing.add_error return_type_or_error
-                else
-                  result = checker.check(
-                    Subtyping::Relation.new(sub_type: return_type_or_error, super_type: lhs_type),
-                    constraints: Subtyping::Constraints.empty
-                  )
-                  if result.failure?
-                    typing.add_error(
-                      Errors::IncompatibleAssignment.new(
-                        node: node,
-                        lhs_type: lhs_type,
-                        rhs_type: return_type_or_error,
-                        result: result
-                      )
+                return_type, _ = type_method_call(node,
+                                                  receiver_type: lhs_type,
+                                                  method_name: op,
+                                                  method: op_method,
+                                                  args: args,
+                                                  block_params: nil,
+                                                  block_body: nil,
+                                                  topdown_hint: true)
+
+                result = check_relation(sub_type: return_type, super_type: lhs_type)
+                if result.failure?
+                  typing.add_error(
+                    Errors::IncompatibleAssignment.new(
+                      node: node,
+                      lhs_type: lhs_type,
+                      rhs_type: return_type,
+                      result: result
                     )
-                  end
+                  )
                 end
               else
-                typing.add_error Errors::NoMethod.new(node: node, method: op, type: lhs_type)
+                typing.add_error Errors::NoMethod.new(node: node, method: op, type: expand_self(lhs_type))
               end
 
               typing.add_typing(node, lhs_type)
@@ -682,32 +635,35 @@ module Steep
           yield_self do
             if self_type && method_context&.method
               if method_context.super_method
-                each_child_node(node) do |child| synthesize(child) end
+                each_child_node(node) do |child|
+                  synthesize(child)
+                end
 
-                super_method = method_context.super_method
+                super_method = Interface::Interface::Combination.overload(
+                  method_context.super_method.method_types.map {|method_type|
+                    checker.factory.method_type(method_type, self_type: self_type)
+                  },
+                  incompatible: false
+                )
                 args = TypeInference::SendArgs.from_nodes(node.children.dup)
 
-                return_type_or_error = type_method_call(node,
-                                                        receiver_type: self_type,
-                                                        method: super_method,
-                                                        args: args,
-                                                        block_params: nil,
-                                                        block_body: nil)
+                return_type, _ = type_method_call(node,
+                                                  receiver_type: self_type,
+                                                  method_name: method_context.name,
+                                                  method: super_method,
+                                                  args: args,
+                                                  block_params: nil,
+                                                  block_body: nil,
+                                                  topdown_hint: true)
 
-                if return_type_or_error.is_a?(Errors::Base)
-                  fallback_to_any node do
-                    return_type_or_error
-                  end
-                else
-                  typing.add_typing node, return_type_or_error
-                end
+                typing.add_typing node, return_type
               else
                 fallback_to_any node do
                   Errors::UnexpectedSuper.new(node: node, method: method_context.name)
                 end
               end
             else
-              typing.add_typing node, AST::Builtin.any_type
+              fallback_to_any node
             end
           end
 
@@ -725,7 +681,8 @@ module Steep
           new = for_new_method(node.children[0],
                                node,
                                args: node.children[1].children,
-                               self_type: module_context&.instance_type)
+                               self_type: module_context&.instance_type,
+                               definition: module_context&.instance_definition)
 
           each_child_node(node.children[1]) do |arg|
             new.synthesize(arg)
@@ -746,17 +703,14 @@ module Steep
           else
             return_type = expand_alias(new.method_context&.return_type)
             if return_type && !return_type.is_a?(AST::Types::Void)
-              result = checker.check(
-                Subtyping::Relation.new(sub_type: AST::Builtin.nil_type, super_type: return_type),
-                constraints: Subtyping::Constraints.empty
-              )
+              result = check_relation(sub_type: AST::Builtin.nil_type, super_type: return_type)
               if result.failure?
                 typing.add_error(Errors::MethodBodyTypeMismatch.new(node: node,
                                                                     expected: new.method_context&.return_type,
                                                                     actual: AST::Builtin.nil_type,
                                                                     result: result))
               end
-            end            
+            end
           end
 
           if module_context
@@ -767,10 +721,21 @@ module Steep
 
         when :defs
           synthesize(node.children[0]).tap do |self_type|
+            self_type = expand_self(self_type)
+            definition = case self_type
+                         when AST::Types::Name::Instance
+                           name = checker.factory.type_name_1(self_type.name)
+                           checker.factory.definition_builder.build_singleton(name)
+                         when AST::Types::Name::Module, AST::Types::Name::Class
+                           name = checker.factory.type_name_1(self_type.name)
+                           checker.factory.definition_builder.build_singleton(name)
+                         end
+
             new = for_new_method(node.children[1],
                                  node,
                                  args: node.children[2].children,
-                                 self_type: self_type)
+                                 self_type: self_type,
+                                 definition: definition)
 
             each_child_node(node.children[2]) do |arg|
               new.synthesize(arg)
@@ -814,11 +779,7 @@ module Steep
 
               if (ret_type = expand_alias(method_context&.return_type))
                 unless ret_type.is_a?(AST::Types::Void)
-                  result = checker.check(
-                    Subtyping::Relation.new(sub_type: value_type,
-                                            super_type: ret_type),
-                    constraints: Subtyping::Constraints.empty
-                  )
+                  result = check_relation(sub_type: value_type, super_type: ret_type)
 
                   if result.failure?
                     typing.add_error(Errors::ReturnTypeMismatch.new(node: node,
@@ -935,7 +896,7 @@ module Steep
 
         when :int
           yield_self do
-            literal_type = expand_alias(hint) {|hint_| test_literal_type(node.children[0], hint_) }
+            literal_type = expand_alias(hint) {|hint_| test_literal_type(node.children[0], hint_)}
 
             if literal_type
               typing.add_typing(node, literal_type)
@@ -946,7 +907,7 @@ module Steep
 
         when :sym
           yield_self do
-            literal_type = expand_alias(hint) {|hint_| test_literal_type(node.children[0], hint_) }
+            literal_type = expand_alias(hint) {|hint_| test_literal_type(node.children[0], hint_)}
 
             if literal_type
               typing.add_typing(node, literal_type)
@@ -957,7 +918,7 @@ module Steep
 
         when :str
           yield_self do
-            literal_type = expand_alias(hint) {|hint_| test_literal_type(node.children[0], hint_) }
+            literal_type = expand_alias(hint) {|hint_| test_literal_type(node.children[0], hint_)}
 
             if literal_type
               typing.add_typing(node, literal_type)
@@ -1058,11 +1019,7 @@ module Steep
           end
 
         when :self
-          if self_type
-            typing.add_typing(node, self_type)
-          else
-            fallback_to_any node
-          end
+          typing.add_typing node, AST::Types::Self.new
 
         when :const
           const_name = Names::Module.from_node(node)
@@ -1080,7 +1037,7 @@ module Steep
             const_name = Names::Module.from_node(node)
             if const_name
               value_type = synthesize(node.children.last)
-              type = type_env.assign(const: const_name, type: value_type) do |error|
+              type = type_env.assign(const: const_name, type: value_type, self_type: self_type) do |error|
                 case error
                 when Subtyping::Result::Failure
                   const_type = type_env.get(const: const_name)
@@ -1128,13 +1085,17 @@ module Steep
           yield_self do
             if method_context&.method
               if method_context.super_method
-                if method_context.method.incompatible?
-                  typing.add_error Errors::IncompatibleZuper.new(node: node, method: method_context.name)
-                  typing.add_typing node, AST::Builtin.any_type
-                else
-                  types = method_context.super_method.types.map(&:return_type)
-                  typing.add_typing(node, union_type(*types))
-                end
+                types = method_context.super_method.method_types.map {|method_type|
+                  case method_type
+                  when Ruby::Signature::MethodType
+                    checker.factory.method_type(method_type, self_type: self_type).return_type
+                  when :any
+                    AST::Builtin.any_type
+                  else
+                    raise "Unexpected method_type: #{method_type.inspect}"
+                  end
+                }
+                typing.add_typing(node, union_type(*types))
               else
                 typing.add_error(Errors::UnexpectedSuper.new(node: node, method: method_context.name))
                 fallback_to_any node
@@ -1150,11 +1111,8 @@ module Steep
               typing.add_error Errors::FallbackAny.new(node: node) unless hint
 
               array_type = if hint
-                             relation = Subtyping::Relation.new(
-                               sub_type: AST::Builtin::Array.instance_type(AST::Builtin.any_type),
-                               super_type: hint
-                             )
-                             if checker.check(relation, constraints: Subtyping::Constraints.empty).success?
+                             if check_relation(sub_type: AST::Builtin::Array.instance_type(AST::Builtin.any_type),
+                                               super_type: hint).success?
                                hint
                              end
                            end
@@ -1165,14 +1123,13 @@ module Steep
 
               expand_alias(hint) do |hint|
                 is_tuple = hint.is_a?(AST::Types::Tuple)
-                is_tuple &&= node.children.all? {|child| child.type != :splat }
+                is_tuple &&= node.children.all? {|child| child.type != :splat}
                 is_tuple &&= node.children.size >= hint.types.size
                 is_tuple &&= hint.types.map.with_index do |child_type, index|
                   child_node = node.children[index]
                   [synthesize(child_node, hint: child_type), child_type]
                 end.all? do |node_type, hint_type|
-                  relation = Subtyping::Relation.new(sub_type: node_type, super_type: hint_type)
-                  result = checker.check(relation, constraints: Subtyping::Constraints.empty)
+                  result = check_relation(sub_type: node_type, super_type: hint_type)
                   result.success?
                 end
               end
@@ -1288,9 +1245,9 @@ module Steep
                 end
 
                 if (body = clause.children.last)
-                  if var_names && var_types && test_types.all? {|type| type.is_a?(AST::Types::Name::Class) }
+                  if var_names && var_types && test_types.all? {|type| type.is_a?(AST::Types::Name::Class)}
                     var_types_in_body = test_types.flat_map {|test_type|
-                      filtered_types = var_types.select {|var_type| var_type.is_a?(AST::Types::Name::Base) && var_type.name == test_type.name }
+                      filtered_types = var_types.select {|var_type| var_type.is_a?(AST::Types::Name::Base) && var_type.name == test_type.name}
                       if filtered_types.empty?
                         to_instance_type(test_type)
                       else
@@ -1344,10 +1301,8 @@ module Steep
             types = pairs.map(&:first)
             envs = pairs.map(&:last)
 
-            if var_types
-              unless var_types.empty? || whens.last
-                types.push AST::Builtin.nil_type
-              end
+            unless var_types&.empty? || whens.last
+              types.push AST::Builtin.nil_type
             end
 
             type_env.join!(envs.compact)
@@ -1365,7 +1320,7 @@ module Steep
               if exn_classes
                 case exn_classes.type
                 when :array
-                  exn_types = exn_classes.children.map {|child| synthesize(child) }
+                  exn_types = exn_classes.children.map {|child| synthesize(child)}
                 else
                   Steep.logger.error "Unexpected exception list: #{exn_classes.type}"
                 end
@@ -1458,7 +1413,7 @@ module Steep
           end
 
         when :irange, :erange
-          types = node.children.map {|n| synthesize(n) }
+          types = node.children.map {|n| synthesize(n)}
           type = AST::Builtin::Range.instance_type(union_type(*types))
           typing.add_typing(node, type)
 
@@ -1493,20 +1448,18 @@ module Steep
         when :gvasgn
           yield_self do
             name, rhs = node.children
-            type = checker.builder.absolute_type(checker.builder.signatures.find_gvar(name)&.type,
-                                                 current: AST::Namespace.root)
-
-            if type
-              check(rhs, type) do |_, rhs_type, result|
-                typing.add_error(Errors::IncompatibleAssignment.new(node: node,
-                                                                    lhs_type: type,
-                                                                    rhs_type: rhs_type,
-                                                                    result: result))
-              end
-            else
-              synthesize(rhs)
+            type = type_env.get(gvar: name) do
               fallback_to_any node
             end
+
+            check(rhs, type) do |_, rhs_type, result|
+              typing.add_error(Errors::IncompatibleAssignment.new(
+                node: node,
+                lhs_type: type,
+                rhs_type: rhs_type,
+                result: result)
+              )
+            end
           end
 
         when :gvar
@@ -1527,16 +1480,14 @@ module Steep
               if hint.one_arg?
                 # Assumes Symbol#to_proc implementation
                 param_type = hint.params.required[0]
-                interface = checker.resolve(param_type)
+                interface = checker.factory.interface(param_type, private: true)
                 method = interface.methods[value.children[0]]
-                if method
-                  return_types = method.types.flat_map do |method_type|
-                    if method_type.params.each_type.count == 0
-                      [method_type.return_type]
-                    end
-                  end
+                if method&.overload?
+                  return_types = method.types.select {|method_type|
+                    method_type.params.each_type.count == 0
+                  }.map(&:return_type)
 
-                  if return_types.any?
+                  unless return_types.empty?
                     type = AST::Types::Proc.new(params: Interface::Params.empty.update(required: [param_type]),
                                                 return_type: AST::Types::Union.build(types: return_types))
                   end
@@ -1547,6 +1498,7 @@ module Steep
             end
 
             type ||= synthesize(node.children[0], hint: hint)
+
             typing.add_typing node, type
           end
 
@@ -1579,11 +1531,7 @@ module Steep
     def check(node, type, constraints: Subtyping::Constraints.empty)
       type_ = synthesize(node, hint: type)
 
-      result = checker.check(
-        Subtyping::Relation.new(sub_type: type_,
-                                super_type: type),
-        constraints: constraints
-      )
+      result = check_relation(sub_type: type_, super_type: type, constraints: constraints)
       if result.failure?
         yield(type, type_, result)
       end
@@ -1609,7 +1557,7 @@ module Steep
 
     def assign_type_to_variable(var, type, node)
       name = var.name
-      type_env.assign(lvar: name, type: type) do |result|
+      type_env.assign(lvar: name, type: type, self_type: self_type) do |result|
         var_type = type_env.get(lvar: name)
         typing.add_error(Errors::IncompatibleAssignment.new(node: node,
                                                             lhs_type: var_type,
@@ -1620,7 +1568,7 @@ module Steep
 
     def type_ivasgn(name, rhs, node)
       rhs_type = synthesize(rhs, hint: type_env.get(ivar: name) { fallback_to_any(node) })
-      ivar_type = type_env.assign(ivar: name, type: rhs_type) do |error|
+      ivar_type = type_env.assign(ivar: name, type: rhs_type, self_type: self_type) do |error|
         case error
         when Subtyping::Result::Failure
           type = type_env.get(ivar: name)
@@ -1641,7 +1589,7 @@ module Steep
       rhs_type = expand_alias(rhs_original)
 
       case
-      when rhs.type == :array && lhs.children.all? {|a| a.type == :lvasgn || a.type == :ivasgn } && lhs.children.size == rhs.children.size
+      when rhs.type == :array && lhs.children.all? {|a| a.type == :lvasgn || a.type == :ivasgn} && lhs.children.size == rhs.children.size
         pairs = lhs.children.zip(rhs.children)
         pairs.each do |(l, r)|
           case
@@ -1654,14 +1602,14 @@ module Steep
 
         typing.add_typing(node, rhs_type)
 
-      when rhs_type.is_a?(AST::Types::Tuple) && lhs.children.all? {|a| a.type == :lvasgn || a.type == :ivasgn }
+      when rhs_type.is_a?(AST::Types::Tuple) && lhs.children.all? {|a| a.type == :lvasgn || a.type == :ivasgn}
         lhs.children.each.with_index do |asgn, index|
           type = rhs_type.types[index]
 
           case
           when asgn.type == :lvasgn && asgn.children[0].name != :_
             type ||= AST::Builtin.nil_type
-            type_env.assign(lvar: asgn.children[0].name, type: type) do |result|
+            type_env.assign(lvar: asgn.children[0].name, type: type, self_type: self_type) do |result|
               var_type = type_env.get(lvar: asgn.children[0].name)
               typing.add_error(Errors::IncompatibleAssignment.new(node: node,
                                                                   lhs_type: var_type,
@@ -1694,7 +1642,7 @@ module Steep
             assign_type_to_variable(assignment.children.first, element_type, assignment)
           when :ivasgn
             assignment.children.first.yield_self do |ivar|
-              type_env.assign(ivar: ivar, type: element_type) do |error|
+              type_env.assign(ivar: ivar, type: element_type, self_type: self_type) do |error|
                 case error
                 when Subtyping::Result::Failure
                   type = type_env.get(ivar: ivar)
@@ -1713,7 +1661,7 @@ module Steep
         typing.add_typing node, rhs_type
 
       when rhs_type.is_a?(AST::Types::Union) &&
-        rhs_type.types.all? {|type| AST::Builtin::Array.instance_type?(type) }
+        rhs_type.types.all? {|type| AST::Builtin::Array.instance_type?(type)}
 
         types = rhs_type.types.flat_map do |type|
           type.args.first
@@ -1752,7 +1700,7 @@ module Steep
     end
 
     def type_lambda(node, block_params:, block_body:, type_hint:)
-      block_annotations = source.annotations(block: node, builder: checker.builder, current_module: current_namespace)
+      block_annotations = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
       params = TypeInference::BlockParams.from_node(block_params, annotations: block_annotations)
 
       case type_hint
@@ -1766,57 +1714,76 @@ module Steep
                               node_type_hint: nil,
                               block_params: params,
                               block_body: block_body,
-                              block_annotations: block_annotations)
+                              block_annotations: block_annotations,
+                              topdown_hint: true)
 
       typing.add_typing node, block_type
     end
 
     def type_send(node, send_node:, block_params:, block_body:, unwrap: false)
       receiver, method_name, *arguments = send_node.children
-      receiver_type = receiver ? synthesize(receiver) : self_type
+      receiver_type = receiver ? synthesize(receiver) : AST::Types::Self.new
 
       if unwrap
         receiver_type = unwrap(receiver_type)
       end
 
-      return_type = case expand_alias(receiver_type)
+      receiver_type = expand_alias(receiver_type)
+
+      return_type = case receiver_type
                     when AST::Types::Any
                       typing.add_typing node, AST::Builtin.any_type
 
                     when nil
                       fallback_to_any node
 
-                    else
-                      begin
-                        interface = checker.resolve(receiver_type, with_private: !receiver)
-
-                        method = interface.methods[method_name]
-
-                        if method
-                          args = TypeInference::SendArgs.from_nodes(arguments)
-                          return_type_or_error = type_method_call(node,
-                                                                  method: method,
-                                                                  args: args,
-                                                                  block_params: block_params,
-                                                                  block_body: block_body,
-                                                                  receiver_type: receiver_type)
+                    when AST::Types::Void, AST::Types::Bot, AST::Types::Top
+                      fallback_to_any node do
+                        Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
+                      end
 
-                          if return_type_or_error.is_a?(Errors::Base)
+                    else
+                      case expanded_receiver_type = expand_self(receiver_type)
+                      when AST::Types::Self
+                        Steep.logger.error "`self` type cannot be resolved to concrete type"
+                        fallback_to_any node do
+                          Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
+                        end
+                      else
+                        begin
+                          interface = checker.factory.interface(receiver_type,
+                                                                private: !receiver,
+                                                                self_type: expanded_receiver_type)
+
+                          method = interface.methods[method_name]
+
+                          if method
+                            args = TypeInference::SendArgs.from_nodes(arguments)
+                            return_type, _ = type_method_call(node,
+                                                              method: method,
+                                                              method_name: method_name,
+                                                              args: args,
+                                                              block_params: block_params,
+                                                              block_body: block_body,
+                                                              receiver_type: receiver_type,
+                                                              topdown_hint: true)
+
+                            typing.add_typing node, return_type
+                          else
                             fallback_to_any node do
-                              return_type_or_error
+                              Errors::NoMethod.new(node: node, method: method_name, type: expanded_receiver_type)
                             end
-                          else
-                            typing.add_typing node, return_type_or_error
                           end
-                        else
+                        rescue => exn
+                          $stderr.puts exn.inspect
+                          exn.backtrace.each do |t|
+                            $stderr.puts t
+                          end
+
                           fallback_to_any node do
-                            Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
+                            Errors::NoMethod.new(node: node, method: method_name, type: expanded_receiver_type)
                           end
                         end
-                      rescue Subtyping::Check::CannotResolveError
-                        fallback_to_any node do
-                          Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
-                        end
                       end
                     end
 
@@ -1837,7 +1804,7 @@ module Steep
           unless typing.has_type?(block_body)
             block_annotations = source.annotations(block: node, builder: checker.builder, current_module: current_namespace)
             params = TypeInference::BlockParams.from_node(block_params, annotations: block_annotations)
-            pairs = params.each.map {|param| [param, AST::Builtin.any_type] }
+            pairs = params.each.map {|param| [param, AST::Builtin.any_type]}
 
             for_block, _ = for_block(block_annotations: block_annotations,
                                      param_pairs: pairs,
@@ -1899,58 +1866,158 @@ module Steep
       ), return_type]
     end
 
-    def type_method_call(node, receiver_type:, method:, args:, block_params:, block_body:)
-      results = method.types.map do |method_type|
-        Steep.logger.tagged method_type.location&.source do
-          zips = args.zips(method_type.params, method_type.block&.type)
-
-          type_or_error, child_typing = if zips.any?
-                                          zips.map do |arg_pairs|
-                                            child_typing = typing.new_child
-
-                                            result = self.with_new_typing(child_typing).try_method_type(
-                                              node,
-                                              receiver_type: receiver_type,
-                                              method_type: method_type,
-                                              args: args,
-                                              arg_pairs: arg_pairs,
-                                              block_params: block_params,
-                                              block_body: block_body,
-                                              child_typing: child_typing
-                                            )
-
-                                            unless result.is_a?(Errors::Base)
-                                              break [[result, child_typing]]
-                                            end
-
-                                            [result, child_typing]
-                                          end.first
-                                        else
-                                          Steep.logger.debug(node.inspect)
-                                          [
-                                            Errors::IncompatibleArguments.new(node: node, receiver_type: receiver_type, method_type: method_type),
-                                            typing.new_child
-                                          ]
-                                        end
-
-          [child_typing, type_or_error, method_type]
-        end
+    def expand_self(type)
+      if type.is_a?(AST::Types::Self) && self_type
+        self_type
+      else
+        type
       end
+    end
 
-      if (success = results.find {|_, type_or_error| !type_or_error.is_a?(Errors::Base) })
-        child_typing, type, _ = success
-        child_typing.save!
-        type
-      else
-        child_typing, error, method_type = results.first
-        typing.add_error error
-        child_typing.save!
+    def type_method_call(node, method_name:, receiver_type:, method:, args:, block_params:, block_body:, topdown_hint:)
+      case
+      when method.union?
+        yield_self do
+          results = method.types.map do |method|
+            typing.new_child do |child_typing|
+              type, error = with_new_typing(child_typing).type_method_call(node,
+                                                                           method_name: method_name,
+                                                                           receiver_type: receiver_type,
+                                                                           method: method,
+                                                                           args: args,
+                                                                           block_params: block_params,
+                                                                           block_body: block_body,
+                                                                           topdown_hint: false)
+              [
+                type,
+                child_typing,
+                error
+              ]
+            end
+          end
 
-        case method_type.return_type
-        when AST::Types::Var
-          AST::Builtin.any_type
-        else
-          method_type.return_type
+          if (type, typing, error = results.find {|_, _, error| error })
+            typing.save!
+            [type, error]
+          else
+            _, typing, _ = results.first
+            typing.save!
+
+            [union_type(*results.map(&:first)), nil]
+          end
+        end
+
+      when method.intersection?
+        yield_self do
+          results = method.types.map do |method|
+            typing.new_child do |child_typing|
+              type, error = with_new_typing(child_typing).type_method_call(node,
+                                                                           method_name: method_name,
+                                                                           receiver_type: receiver_type,
+                                                                           method: method,
+                                                                           args: args,
+                                                                           block_params: block_params,
+                                                                           block_body: block_body,
+                                                                           topdown_hint: false)
+              [
+                type,
+                child_typing,
+                error
+              ]
+            end
+          end
+
+          successes = results.select {|_, _, error| !error }
+          unless successes.empty?
+            types = successes.map {|type, typing, _| type }
+            typing = successes[0][1]
+            typing.save!
+
+            [AST::Types::Intersection.build(types: types), nil]
+          else
+            type, typing, error = results.first
+            typing.save!
+
+            [type, error]
+          end
+        end
+
+      when method.overload?
+        yield_self do
+          results = method.types.flat_map do |method_type|
+            Steep.logger.tagged method_type.to_s do
+              case method_type
+              when Interface::MethodType
+                zips = args.zips(method_type.params, method_type.block&.type)
+
+                zips.map do |arg_pairs|
+                  typing.new_child do |child_typing|
+                    result = self.with_new_typing(child_typing).try_method_type(
+                      node,
+                      receiver_type: receiver_type,
+                      method_type: method_type,
+                      args: args,
+                      arg_pairs: arg_pairs,
+                      block_params: block_params,
+                      block_body: block_body,
+                      child_typing: child_typing,
+                      topdown_hint: topdown_hint
+                    )
+
+                    [result, child_typing, method_type]
+                  end
+                end
+              when :any
+                typing.new_child do |child_typing|
+                  this = self.with_new_typing(child_typing)
+
+                  args.args.each do |arg|
+                    this.synthesize(arg)
+                  end
+
+                  if block_body
+                    this.synthesize(block_body)
+                  end
+
+                  child_typing.add_typing node, AST::Builtin.any_type
+
+                  [[AST::Builtin.any_type, child_typing, :any]]
+                end
+              end
+            end
+          end
+
+          unless results.empty?
+            result, call_typing, method_type = results.find {|result, _, _| !result.is_a?(Errors::Base) } || results.last
+          else
+            method_type = method.types.last
+            result = Errors::IncompatibleArguments.new(node: node, receiver_type: receiver_type, method_type: method_type)
+            call_typing = typing.new_child
+          end
+          call_typing.save!
+
+          case result
+          when Errors::Base
+            if method.types.size == 1
+              typing.add_error result
+              type = case method_type.return_type
+                     when AST::Types::Var
+                       AST::Builtin.any_type
+                     else
+                       method_type.return_type
+                     end
+            else
+              typing.add_error Errors::UnresolvedOverloading.new(node: node,
+                                                                 receiver_type: expand_self(receiver_type),
+                                                                 method_name: method_name,
+                                                                 method_types: method.types)
+              type = AST::Builtin.any_type
+            end
+
+            [type, result]
+          else # Type
+            [result, nil]
+          end
         end
       end
     end
@@ -2049,7 +2116,7 @@ module Steep
           Steep.logger.warn("Method call with rest keywords type is detected. Rough approximation to be improved.")
 
           value_types = params.required_keywords.values +
-            params.optional_keywords.values.map {|type| AST::Types::Union.build(types: [type, AST::Builtin.nil_type]) } +
+            params.optional_keywords.values.map {|type| AST::Types::Union.build(types: [type, AST::Builtin.nil_type])} +
             [params.rest_keywords]
 
           hash_type = AST::Builtin::Hash.instance_type(
@@ -2070,17 +2137,12 @@ module Steep
 
         node_type = synthesize(node, hint: hash_type)
 
-        relation = Subtyping::Relation.new(
-          sub_type: node_type,
-          super_type: hash_type
-        )
-
-        checker.check(relation, constraints: constraints).else do
+        check_relation(sub_type: node_type, super_type: hash_type).else do
           return Errors::ArgumentTypeMismatch.new(
             node: node,
             receiver_type: receiver_type,
-            expected: relation.super_type,
-            actual: relation.sub_type
+            expected: hash_type,
+            actual: node_type
           )
         end
       end
@@ -2088,8 +2150,8 @@ module Steep
       nil
     end
 
-    def try_method_type(node, receiver_type:, method_type:, args:, arg_pairs:, block_params:, block_body:, child_typing:)
-      fresh_types = method_type.type_params.map {|x| AST::Types::Var.fresh(x) }
+    def try_method_type(node, receiver_type:, method_type:, args:, arg_pairs:, block_params:, block_body:, child_typing:, topdown_hint:)
+      fresh_types = method_type.type_params.map {|x| AST::Types::Var.fresh(x)}
       fresh_vars = Set.new(fresh_types.map(&:name))
       instantiation = Interface::Substitution.build(method_type.type_params, fresh_types)
 
@@ -2122,20 +2184,15 @@ module Steep
                          type = construction.synthesize(arg_node.children[0])
                          child_typing.add_typing(arg_node, type)
                        else
-                         construction.synthesize(arg_node, hint: param_type)
+                         construction.synthesize(arg_node, hint: topdown_hint ? param_type : nil)
                        end
 
-            relation = Subtyping::Relation.new(
-              sub_type: arg_type,
-              super_type: param_type
-            )
-
-            checker.check(relation, constraints: constraints).else do |result|
+            check_relation(sub_type: arg_type, super_type: param_type, constraints: constraints).else do |result|
               return Errors::ArgumentTypeMismatch.new(
                 node: arg_node,
                 receiver_type: receiver_type,
-                expected: relation.super_type,
-                actual: relation.sub_type
+                expected: param_type,
+                actual: arg_type
               )
             end
           else
@@ -2152,16 +2209,15 @@ module Steep
         end
 
         if block_params && method_type.block
-          block_annotations = source.annotations(block: node, builder: checker.builder, current_module: current_namespace)
+          block_annotations = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
           block_params_ = TypeInference::BlockParams.from_node(block_params, annotations: block_annotations)
-          block_param_hint = block_params_.params_type(hint: method_type.block.type.params)
-
-          relation = Subtyping::Relation.new(
-            sub_type: AST::Types::Proc.new(params: block_param_hint, return_type: AST::Types::Any.new),
-            super_type: method_type.block.type
+          block_param_hint = block_params_.params_type(
+            hint: topdown_hint ? method_type.block.type.params : nil
           )
 
-          checker.check(relation, constraints: constraints).else do |result|
+          check_relation(sub_type: AST::Types::Proc.new(params: block_param_hint, return_type: AST::Types::Any.new),
+                         super_type: method_type.block.type,
+                         constraints: constraints).else do |result|
             return Errors::IncompatibleBlockParameters.new(
               node: node,
               method_type: method_type
@@ -2175,22 +2231,22 @@ module Steep
           Steep.logger.debug "Constraints = #{constraints}"
 
           begin
-            method_type.subst(constraints.solution(checker, variance: variance, variables: occurence.params)).yield_self do |method_type|
+            method_type.subst(constraints.solution(checker, self_type: self_type, variance: variance, variables: occurence.params)).yield_self do |method_type|
               block_type = construction.type_block(block_param_hint: method_type.block.type.params,
                                                    block_type_hint: method_type.block.type.return_type,
                                                    node_type_hint: method_type.return_type,
                                                    block_params: block_params_,
                                                    block_body: block_body,
-                                                   block_annotations: block_annotations)
-
-              relation = Subtyping::Relation.new(sub_type: block_type.return_type,
-                                                 super_type: method_type.block.type.return_type)
+                                                   block_annotations: block_annotations,
+                                                   topdown_hint: topdown_hint)
 
-              result = checker.check(relation, constraints: constraints)
+              result = check_relation(sub_type: block_type.return_type,
+                                      super_type: method_type.block.type.return_type,
+                                      constraints: constraints)
 
               case result
               when Subtyping::Result::Success
-                method_type.return_type.subst(constraints.solution(checker, variance: variance, variables: fresh_vars)).yield_self do |ret_type|
+                method_type.return_type.subst(constraints.solution(checker, self_type: self_type, variance: variance, variables: fresh_vars)).yield_self do |ret_type|
                   if block_annotations.break_type
                     AST::Types::Union.new(types: [block_annotations.break_type, ret_type])
                   else
@@ -2217,21 +2273,24 @@ module Steep
 
         when method_type.block && args.block_pass_arg
           begin
-            method_type.subst(constraints.solution(checker, variance: variance, variables: occurence.params)).yield_self do |method_type|
-              block_type = synthesize(args.block_pass_arg, hint: method_type.block.type)
-              relation = Subtyping::Relation.new(sub_type: block_type,
-                                                 super_type: method_type.block.yield_self do |expected_block|
-                                                   if expected_block.optional?
-                                                     AST::Builtin.optional(expected_block.type)
-                                                   else
-                                                     expected_block.type
-                                                   end
-                                                 end)
-              result = checker.check(relation, constraints: constraints)
+            method_type.subst(constraints.solution(checker, self_type: self_type, variance: variance, variables: occurence.params)).yield_self do |method_type|
+              block_type = synthesize(args.block_pass_arg,
+                                      hint: topdown_hint ? method_type.block.type : nil)
+              result = check_relation(
+                sub_type: block_type,
+                super_type: method_type.block.yield_self {|expected_block|
+                  if expected_block.optional?
+                    AST::Builtin.optional(expected_block.type)
+                  else
+                    expected_block.type
+                  end
+                },
+                constraints: constraints
+              )
 
               case result
               when Subtyping::Result::Success
-                method_type.return_type.subst(constraints.solution(checker, variance: variance, variables: fresh_vars))
+                method_type.return_type.subst(constraints.solution(checker, self_type: self_type, variance: variance, variables: fresh_vars))
 
               when Subtyping::Result::Failure
                 Errors::BlockTypeMismatch.new(node: node,
@@ -2252,7 +2311,7 @@ module Steep
 
         when (!method_type.block || method_type.block.optional?) && !block_params && !block_body && !args.block_pass_arg
           # OK, without block
-          method_type.subst(constraints.solution(checker, variance: variance, variables: fresh_vars)).return_type
+          method_type.subst(constraints.solution(checker, variance: variance, variables: fresh_vars, self_type: self_type)).return_type
 
         when !method_type.block && (block_params || args.block_pass_arg)
           Errors::UnexpectedBlockGiven.new(
@@ -2272,7 +2331,7 @@ module Steep
       end
     end
 
-    def type_block(block_param_hint:, block_type_hint:, node_type_hint:, block_params:, block_body:, block_annotations:)
+    def type_block(block_param_hint:, block_type_hint:, node_type_hint:, block_params:, block_body:, block_annotations:, topdown_hint:)
       block_param_pairs = block_param_hint && block_params.zip(block_param_hint)
 
       param_types_hash = {}
@@ -2299,10 +2358,10 @@ module Steep
       end
 
       break_type = if block_annotations.break_type
-                      union_type(node_type_hint, block_annotations.break_type)
-                    else
-                      node_type_hint
-                    end
+                     union_type(node_type_hint, block_annotations.break_type)
+                   else
+                     node_type_hint
+                   end
       Steep.logger.debug("return_type = #{break_type}")
 
       block_context = BlockContext.new(body_type: block_annotations.block_type)
@@ -2338,7 +2397,7 @@ module Steep
                         end
                         body_type
                       else
-                        for_block_body.synthesize(block_body, hint: block_type_hint)
+                        for_block_body.synthesize(block_body, hint: topdown_hint ? block_type_hint : nil)
                       end
       else
         return_type = AST::Builtin.any_type
@@ -2457,22 +2516,14 @@ module Steep
     end
 
     def validate_method_definitions(node, module_name)
-      signature = checker.builder.signatures.find_class_or_module(module_name.name)
-      expected_instance_method_names = Set.new()
-      expected_module_method_names = Set.new
-
-      signature.members.each do |member|
-        case member
-        when AST::Signature::Members::Method
-          if member.instance_method?
-            expected_instance_method_names << member.name
-          end
-          if member.module_method?
-            expected_module_method_names << member.name
-          end
-        when AST::Signature::Members::Attr
-          expected_instance_method_names << member.name
-          expected_instance_method_names << "#{member.name}=".to_sym if member.accessor?
+      expected_instance_method_names = (module_context.instance_definition&.methods || {}).each.with_object(Set[]) do |(name, method), set|
+        if method.implemented_in == module_context.instance_definition.declaration
+          set << name
+        end
+      end
+      expected_module_method_names = (module_context.module_definition&.methods || {}).each.with_object(Set[]) do |(name, method), set|
+        if method.implemented_in == module_context.module_definition.declaration
+          set << name
         end
       end
 
@@ -2570,7 +2621,7 @@ module Steep
                 return false
               end
 
-      !nodes.empty? && nodes.all? {|child| child.type == :class || child.type == :module }
+      !nodes.empty? && nodes.all? {|child| child.type == :class || child.type == :module}
     end
 
     def fallback_any_rec(node)
@@ -2587,7 +2638,7 @@ module Steep
       expand_alias(type) do |expanded|
         case
         when expanded.is_a?(AST::Types::Union)
-          types = expanded.types.reject {|type| type.is_a?(AST::Types::Nil) }
+          types = expanded.types.reject {|type| type.is_a?(AST::Types::Nil)}
           AST::Types::Union.build(types: types)
         else
           type
@@ -2623,18 +2674,27 @@ module Steep
       end
     end
 
-    def expand_alias(type)
-      if type
-        expanded = checker.expand_alias(type)
-      end
+    def deep_expand_alias(type, recursive: Set.new, &block)
+      raise "Recursive type definition: #{type}" if recursive.member?(type)
+
+      ty = case type
+           when AST::Types::Name::Alias
+             deep_expand_alias(expand_alias(type), recursive: recursive << type)
+           else
+             type
+           end
 
       if block_given?
-        yield expanded, type
+        yield ty
       else
-        expanded
+        ty
       end
     end
 
+    def expand_alias(type, &block)
+      checker.factory.expand_alias(type, &block)
+    end
+
     def test_literal_type(literal, hint)
       case hint
       when AST::Types::Literal
@@ -2642,7 +2702,7 @@ module Steep
           hint
         end
       when AST::Types::Union
-        if hint.types.any? {|ty| ty.is_a?(AST::Types::Literal) && ty.value == literal }
+        if hint.types.any? {|ty| ty.is_a?(AST::Types::Literal) && ty.value == literal}
           hint
         end
       end
@@ -2650,10 +2710,7 @@ module Steep
 
     def select_super_type(sub_type, super_type)
       if super_type
-        result = checker.check(
-          Subtyping::Relation.new(sub_type: sub_type, super_type: super_type),
-          constraints: Subtyping::Constraints.empty
-        )
+        result = check_relation(sub_type: sub_type, super_type: super_type)
 
         if result.success?
           super_type
@@ -2671,10 +2728,10 @@ module Steep
 
     def to_instance_type(type, args: nil)
       args = args || case type
-                     when AST::Types::Name::Class
-                       checker.builder.signatures.find_class(type.name).params&.variables || []
-                     when AST::Types::Name::Module
-                       checker.builder.signatures.find_module(type.name).params&.variables || []
+                     when AST::Types::Name::Class, AST::Types::Name::Module
+                       checker.factory.env.find_class(checker.factory.type_name_1(type.name)).type_params.each.map { AST::Builtin.any_type }
+                     else
+                       raise "unexpected type to to_instance_type: #{type}"
                      end
 
       AST::Types::Name::Instance.new(name: type.name, args: args)
@@ -2699,14 +2756,11 @@ module Steep
                             return nil
                           end
 
-              key_hint = AST::Types::Literal.new(value: key_value)
               value_hint = hint.elements[key_value]
-
               value_type = new_construction.synthesize(value, hint: value_hint)
 
               if value_hint
-                relation = Subtyping::Relation.new(sub_type: value_type, super_type: value_hint)
-                if checker.check(relation, constraints: Subtyping::Constraints.empty).success?
+                if check_relation(sub_type: value_type, super_type: value_hint).success?
                   value_type = value_hint
                 end
               end