steep 0.31.0 → 0.35.0

data/lib/steep/subtyping/check.rb

@@ -147,7 +147,23 @@ module Steep
             success(constraints: constraints)
 
           when relation.super_type.is_a?(AST::Types::Boolean)
-            success(constraints: constraints)
+            check(
+              Relation.new(sub_type: relation.sub_type, super_type: AST::Types::Union.build(types: [AST::Builtin.true_type, AST::Builtin.false_type])),
+              self_type: self_type,
+              assumption: assumption,
+              trace: trace,
+              constraints: constraints
+            )
+
+          when relation.sub_type.is_a?(AST::Types::Boolean)
+            check(
+              Relation.new(sub_type: AST::Types::Union.build(types: [AST::Builtin.true_type, AST::Builtin.false_type]),
+                           super_type: relation.super_type),
+              self_type: self_type,
+              assumption: assumption,
+              trace: trace,
+              constraints: constraints
+            )
 
           when relation.sub_type.is_a?(AST::Types::Self) && !self_type.is_a?(AST::Types::Self)
             check(
@@ -326,23 +342,21 @@ module Steep
                   constraints: constraints)
 
           when relation.sub_type.is_a?(AST::Types::Record) && relation.super_type.is_a?(AST::Types::Record)
-            if Set.new(relation.sub_type.elements.keys).superset?(Set.new(relation.super_type.elements.keys))
-              keys = relation.super_type.elements.keys
-              type_pairs = keys.map {|key| [relation.sub_type.elements[key], relation.super_type.elements[key]] }
-              results = type_pairs.flat_map do |t1, t2|
-                relation = Relation.new(sub_type: t1, super_type: t2)
-                [check(relation, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints),
-                 check(relation.flip, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)]
-              end
+            keys = relation.super_type.elements.keys
+            relations = keys.map {|key|
+              Relation.new(
+                sub_type: relation.sub_type.elements[key] || AST::Builtin.nil_type,
+                super_type: relation.super_type.elements[key]
+              )
+            }
+            results = relations.map do |relation|
+              check(relation, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)
+            end
 
-              if results.all?(&:success?)
-                success(constraints: constraints)
-              else
-                results.find(&:failure?)
-              end
+            if results.all?(&:success?)
+              success(constraints: constraints)
             else
-              failure(error: Result::Failure::UnknownPairError.new(relation: relation),
-                      trace: trace)
+              results.find(&:failure?)
             end
 
           when relation.sub_type.is_a?(AST::Types::Record) && relation.super_type.is_a?(AST::Types::Name::Base)

data/lib/steep/subtyping/variable_occurrence.rb

@@ -29,6 +29,8 @@ module Steep
             returns << var
           end
         end
+
+        params.subtract(returns)
       end
 
       def each_var(type, &block)

data/lib/steep/type_construction.rb

@@ -131,7 +131,7 @@ module Steep
       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) }
+                                     .map {|method_type| checker.factory.method_type(method_type, self_type: self_type, method_decls: Set[]) }
                                      .select {|method_type| method_type.is_a?(Interface::MethodType) }
                                      .inject {|t1, t2| t1 + t2}
                                  end
@@ -216,6 +216,21 @@ module Steep
 
       lvar_env = lvar_env.annotate(annots)
 
+      call_context = case self_type
+                     when nil
+                       TypeInference::MethodCall::UnknownContext.new()
+                     when AST::Types::Name::Singleton
+                       TypeInference::MethodCall::MethodContext.new(
+                         method_name: SingletonMethodName.new(type_name: module_context.class_name, method_name: method_name)
+                       )
+                     when AST::Types::Name::Instance, AST::Types::Intersection
+                       TypeInference::MethodCall::MethodContext.new(
+                         method_name: InstanceMethodName.new(type_name: module_context.class_name, method_name: method_name)
+                       )
+                     else
+                       raise "Unexpected self_type: #{self_type}"
+                     end
+
       self.class.new(
         checker: checker,
         source: source,
@@ -227,7 +242,8 @@ module Steep
           break_context: nil,
           self_type: annots.self_type || self_type,
           type_env: type_env,
-          lvar_env: lvar_env
+          lvar_env: lvar_env,
+          call_context: call_context
         ),
         typing: typing,
       )
@@ -355,7 +371,8 @@ module Steep
           module_context: module_context_,
           self_type: module_context_.module_type,
           type_env: module_type_env,
-          lvar_env: lvar_env
+          lvar_env: lvar_env,
+          call_context: TypeInference::MethodCall::ModuleContext.new(type_name: module_context_.class_name)
         )
       )
     end
@@ -424,7 +441,8 @@ module Steep
         break_context: nil,
         self_type: module_context.module_type,
         type_env: class_type_env,
-        lvar_env: lvar_env
+        lvar_env: lvar_env,
+        call_context: TypeInference::MethodCall::ModuleContext.new(type_name: module_context.class_name)
       )
 
       self.class.new(
@@ -509,7 +527,8 @@ module Steep
         break_context: nil,
         self_type: module_context.module_type,
         type_env: type_env,
-        lvar_env: lvar_env
+        lvar_env: lvar_env,
+        call_context: TypeInference::MethodCall::ModuleContext.new(type_name: module_context.class_name)
       )
 
       self.class.new(
@@ -608,6 +627,22 @@ module Steep
       Pair.new(type: type, constr: constr)
     end
 
+    def add_call(call)
+      case call
+      when TypeInference::MethodCall::NoMethodError
+        typing.add_error(call.error)
+      when TypeInference::MethodCall::Error
+        call.errors.each do |error|
+          typing.add_error(error)
+        end
+      end
+
+      typing.add_typing(call.node, call.return_type, nil)
+      typing.add_call(call.node, call)
+
+      Pair.new(type: call.return_type, constr: self)
+    end
+
     def synthesize(node, hint: nil)
       Steep.logger.tagged "synthesize:(#{node.location.expression.to_s.split(/:/, 2).last})" do
         Steep.logger.debug node.type
@@ -786,28 +821,33 @@ module Steep
         when :super
           yield_self do
             if self_type && method_context&.method
-              if method_context.super_method
+              if super_def = method_context.super_method
                 each_child_node(node) do |child|
                   synthesize(child)
                 end
 
                 super_method = Interface::Interface::Entry.new(
                   method_types: method_context.super_method.method_types.map {|method_type|
-                    checker.factory.method_type(method_type, self_type: self_type)
+                    decl = TypeInference::MethodCall::MethodDecl.new(
+                      method_name: InstanceMethodName.new(type_name: super_def.implemented_in || super_def.defined_in,
+                                                          method_name: method_context.name),
+                      method_def: super_def
+                    )
+                    checker.factory.method_type(method_type, self_type: self_type, method_decls: Set[decl])
                   }
                 )
                 args = TypeInference::SendArgs.from_nodes(node.children.dup)
 
-                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)
+                call, constr = 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)
 
-                add_typing node, type: return_type
+                constr.add_call(call)
               else
                 fallback_to_any node do
                   Errors::UnexpectedSuper.new(node: node, method: method_context.name)
@@ -1208,7 +1248,13 @@ module Steep
 
         when :class
           yield_self do
-            for_class(node).tap do |constructor|
+            constr = self
+
+            name, sup, _ = node.children
+            _, constr = constr.synthesize(name)
+            _, constr = constr.synthesize(sup) if sup
+
+            constr.for_class(node).tap do |constructor|
               constructor.typing.add_context_for_node(node, context: constructor.context)
               constructor.typing.add_context_for_body(node, context: constructor.context)
 
@@ -1224,6 +1270,11 @@ module Steep
 
         when :module
           yield_self do
+            constr = self
+
+            name, _ = node.children
+            _, constr = constr.synthesize(name)
+
             for_module(node).yield_self do |constructor|
               constructor.typing.add_context_for_node(node, context: constructor.context)
               constructor.typing.add_context_for_body(node, context: constructor.context)
@@ -1271,24 +1322,39 @@ module Steep
         when :self
           add_typing node, type: AST::Types::Self.new
 
+        when :cbase
+          add_typing node, type: AST::Types::Void.new
+
         when :const
-          const_name = module_name_from_node(node)
+          parent = node.children[0]
+          if parent
+            _, constr = synthesize(parent)
+          else
+            constr = self
+          end
+
+          const_name = constr.module_name_from_node(node)
 
           if const_name
             type = type_env.get(const: const_name) do
-              fallback_to_any node
+              constr.fallback_to_any(node)
             end
-            add_typing node, type: type
+            constr.add_typing(node, type: type)
           else
-            fallback_to_any node
+            constr.fallback_to_any(node)
           end
 
         when :casgn
           yield_self do
-            const_name = module_name_from_node(node)
+            constr = self
+
+            parent = node.children[0]
+            _, constr = constr.synthesize(parent) if parent
+            const_name = constr.module_name_from_node(node)
+
             if const_name
               const_type = type_env.get(const: const_name) {}
-              value_type = synthesize(node.children.last, hint: const_type).type
+              value_type, constr = constr.synthesize(node.children.last, hint: const_type)
               type = type_env.assign(const: const_name, type: value_type, self_type: self_type) do |error|
                 case error
                 when Subtyping::Result::Failure
@@ -1302,10 +1368,10 @@ module Steep
                 end
               end
 
-              add_typing(node, type: type)
+              constr.add_typing(node, type: type)
             else
-              synthesize(node.children.last).type
-              fallback_to_any(node)
+              _, constr = constr.synthesize(node.children.last)
+              constr.fallback_to_any(node)
             end
           end
 
@@ -1338,7 +1404,7 @@ module Steep
             if method_context&.method
               if method_context.super_method
                 types = method_context.super_method.method_types.map {|method_type|
-                  checker.factory.method_type(method_type, self_type: self_type).return_type
+                  checker.factory.method_type(method_type, self_type: self_type, method_decls: Set[]).return_type
                 }
                 add_typing(node, type: union_type(*types))
               else
@@ -2029,7 +2095,7 @@ module Steep
           unless pair.is_a?(Pair) && !pair.type.is_a?(Pair)
             # Steep.logger.error { "result = #{pair.inspect}" }
             # Steep.logger.error { "node = #{node.type}" }
-            raise "#synthesize should return an instance of Pair: #{pair.class}"
+            raise "#synthesize should return an instance of Pair: #{pair.class}, node=#{node.inspect}"
           end
         end
       end
@@ -2273,177 +2339,225 @@ module Steep
         return_hint = type_hint.return_type
       end
 
-      block_pair = type_block(node: node,
-                              block_param_hint: params_hint,
-                              block_type_hint: return_hint,
-                              node_type_hint: nil,
-                              block_params: params,
-                              block_body: block_body,
-                              block_annotations: block_annotations,
-                              topdown_hint: true)
+      block_constr = for_block(
+        block_params: params,
+        block_param_hint: params_hint,
+        block_annotations: block_annotations,
+        node_type_hint: nil
+      )
 
-      add_typing node, type: block_pair.type
-    end
+      block_constr.typing.add_context_for_body(node, context: block_constr.context)
 
-    def type_send(node, send_node:, block_params:, block_body:, unwrap: false)
-      receiver, method_name, *arguments = send_node.children
-      receiver_type, constr = receiver ? synthesize(receiver) : [AST::Types::Self.new, self]
+      params.params.each do |param|
+        _, block_constr = block_constr.synthesize(param.node, hint: param.type)
+      end
 
-      if unwrap
-        receiver_type = unwrap(receiver_type)
+      if block_body
+        return_type = block_constr.synthesize_block(
+          node: node,
+          block_body: block_body,
+          topdown_hint: true,
+          block_type_hint: return_hint
+        ) do |error|
+          typing.add_error(error)
+        end
+      else
+        return_type = AST::Builtin.any_type
       end
 
-      receiver_type = expand_alias(receiver_type)
+      block_type = AST::Types::Proc.new(
+        params: params_hint || params.params_type,
+        return_type: return_type
+      )
 
-      type, constr = case receiver_type
-                     when AST::Types::Any
-                       each_child_node(send_node) do |child|
-                         unless child.equal?(receiver)
-                           _, constr = constr.synthesize(child)
-                         end
-                       end
+      add_typing node, type: block_type
+    end
 
-                       add_typing node, type: AST::Builtin.any_type
+    def synthesize_children(node, skips: [])
+      skips = Set.new.compare_by_identity.merge(skips)
 
-                     when nil
-                       fallback_to_any node
+      constr = self
 
-                     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
+      each_child_node(node) do |child|
+        unless skips.include?(child)
+          _, constr = constr.synthesize(child)
+        end
+      end
 
-                     else
-                       case expanded_receiver_type = expand_self(receiver_type)
-                       when AST::Types::Self
-                         Steep.logger.debug { "`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, constr, _ = constr.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)
-
-                             add_typing node, type: return_type, constr: constr
-                           else
-                             fallback_to_any node do
-                               Errors::NoMethod.new(node: node, method: method_name, type: expanded_receiver_type)
-                             end
-                           end
-                         rescue => exn
-                           case exn
-                           when RBS::NoTypeFoundError, RBS::NoMixinFoundError, RBS::NoSuperclassFoundError, RBS::InvalidTypeApplicationError
-                             # ignore known RBS errors.
-                           else
-                             Steep.log_error(exn, message: "Unexpected error in #type_send: #{exn.message} (#{exn.class})")
-                           end
+      constr
+    end
 
-                           fallback_to_any node do
-                             Errors::NoMethod.new(node: node, method: method_name, type: expanded_receiver_type)
-                           end
-                         end
-                       end
-                     end
+    def type_send_interface(node, interface:, receiver:, receiver_type:, method_name:, arguments:, block_params:, block_body:)
+      method = interface.methods[method_name]
 
-      case type
-      when nil, Errors::Base
-        arguments.each do |arg|
-          unless typing.has_type?(arg)
-            if arg.type == :splat
-              type, constr = constr.synthesize(arg.children[0])
-              add_typing(arg, type: AST::Builtin::Array.instance_type(type))
-            else
-              _, constr = constr.synthesize(arg)
+      if method
+        args = TypeInference::SendArgs.from_nodes(arguments)
+        call, constr = 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)
+
+        if call && constr
+          case method_name.to_s
+          when "[]=", /\w=\Z/
+            if typing.has_type?(arguments.last)
+              call = call.with_return_type(typing.type_of(node: arguments.last))
             end
           end
-        end
-
-        if block_body && block_params
-          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]}
+        else
+          error = Errors::UnresolvedOverloading.new(
+            node: node,
+            receiver_type: receiver_type,
+            method_name: method_name,
+            method_types: method.method_types
+          )
+          call = TypeInference::MethodCall::Error.new(
+            node: node,
+            context: context.method_context,
+            method_name: method_name,
+            receiver_type: receiver_type,
+            errors: [error]
+          )
 
-            for_block, _ = constr.for_block(block_annotations: block_annotations,
-                                            param_pairs: pairs,
-                                            method_return_type: AST::Builtin.any_type,
-                                            typing: typing)
+          skips = [receiver]
+          skips << node.children[0] if node.type == :block
 
-            for_block.typing.add_context_for_body(node, context: for_block.context)
+          constr = synthesize_children(node, skips: skips)
+          if block_params
+            block_annotations = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
 
-            for_block.synthesize(block_body)
+            constr.type_block_without_hint(
+              node: node,
+              block_params: TypeInference::BlockParams.from_node(block_params, annotations: block_annotations),
+              block_annotations: block_annotations,
+              block_body: block_body
+            ) do |error|
+              constr.typing.add_error(error)
+            end
           end
         end
+
+        constr.add_call(call)
       else
-        Pair.new(type: type, constr: constr)
+        add_call(
+          TypeInference::MethodCall::NoMethodError.new(
+            node: node,
+            context: context.method_context,
+            method_name: method_name,
+            receiver_type: receiver_type,
+            error: Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
+          )
+        )
       end
     end
 
-    def for_block(block_annotations:, param_pairs:, method_return_type:, typing:)
-      block_type_env = type_env.dup.yield_self do |env|
-        param_pairs.each do |param, type|
-          if param.type
-            env.set(lvar: param.var.name, type: param.type)
-          else
-            env.set(lvar: param.var.name, type: type)
-          end
-        end
+    def type_send(node, send_node:, block_params:, block_body:, unwrap: false)
+      receiver, method_name, *arguments = send_node.children
+      recv_type, constr = receiver ? synthesize(receiver) : [AST::Types::Self.new, self]
 
-        env.with_annotations(
-          lvar_types: block_annotations.lvar_types,
-          ivar_types: block_annotations.ivar_types,
-          const_types: block_annotations.const_types,
-        )
+      if unwrap
+        recv_type = unwrap(recv_type)
       end
 
-      lvar_env = context.lvar_env.pin_assignments.annotate(block_annotations)
+      receiver_type = checker.factory.deep_expand_alias(recv_type)
 
-      return_type = if block_annotations.break_type
-                      union_type(method_return_type, block_annotations.break_type)
-                    else
-                      method_return_type
-                    end
-      Steep.logger.debug("return_type = #{return_type}")
+      type, constr = case receiver_type
+                     when nil
+                       raise
 
-      block_context = TypeInference::Context::BlockContext.new(body_type: block_annotations.block_type)
-      Steep.logger.debug("block_context { body_type: #{block_context.body_type} }")
+                     when AST::Types::Any
+                       constr = constr.synthesize_children(node, skips: [receiver])
+                       constr.add_call(
+                         TypeInference::MethodCall::Untyped.new(
+                           node: node,
+                           context: context.method_context,
+                           method_name: method_name
+                         )
+                       )
 
-      break_context = TypeInference::Context::BreakContext.new(
-        break_type: block_annotations.break_type || method_return_type,
-        next_type: block_annotations.block_type
-      )
-      Steep.logger.debug("break_context { type: #{break_context.break_type} }")
+                     when AST::Types::Void, AST::Types::Bot, AST::Types::Top, AST::Types::Var
+                       constr = constr.synthesize_children(node, skips: [receiver])
+                       constr.add_call(
+                         TypeInference::MethodCall::NoMethodError.new(
+                           node: node,
+                           context: context.method_context,
+                           method_name: method_name,
+                           receiver_type: receiver_type,
+                           error: Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
+                         )
+                       )
 
-      [self.class.new(
-        checker: checker,
-        source: source,
-        annotations: annotations.merge_block_annotations(block_annotations),
-        typing: typing,
-        context: TypeInference::Context.new(
-          block_context: block_context,
-          method_context: method_context,
-          module_context: module_context,
-          break_context: break_context,
-          self_type: block_annotations.self_type || self_type,
-          type_env: block_type_env,
-          lvar_env: lvar_env
+                     when AST::Types::Self
+                       expanded_self = expand_self(receiver_type)
+
+                       if expanded_self.is_a?(AST::Types::Self)
+                         Steep.logger.debug { "`self` type cannot be resolved to concrete type" }
+
+                         constr = constr.synthesize_children(node, skips: [receiver])
+                         constr.add_call(
+                           TypeInference::MethodCall::NoMethodError.new(
+                             node: node,
+                             context: context.method_context,
+                             method_name: method_name,
+                             receiver_type: receiver_type,
+                             error: Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
+                           )
+                         )
+                       else
+                         interface = checker.factory.interface(expanded_self,
+                                                               private: !receiver,
+                                                               self_type: AST::Types::Self.new)
+
+                         constr.type_send_interface(node,
+                                                    interface: interface,
+                                                    receiver: receiver,
+                                                    receiver_type: expanded_self,
+                                                    method_name: method_name,
+                                                    arguments: arguments,
+                                                    block_params: block_params,
+                                                    block_body: block_body)
+                       end
+                     else
+                       interface = checker.factory.interface(receiver_type,
+                                                             private: !receiver,
+                                                             self_type: receiver_type)
+
+                       constr.type_send_interface(node,
+                                                  interface: interface,
+                                                  receiver: receiver,
+                                                  receiver_type: receiver_type,
+                                                  method_name: method_name,
+                                                  arguments: arguments,
+                                                  block_params: block_params,
+                                                  block_body: block_body)
+                     end
+
+      Pair.new(type: type, constr: constr)
+    rescue => exn
+      case exn
+      when RBS::NoTypeFoundError, RBS::NoMixinFoundError, RBS::NoSuperclassFoundError, RBS::InvalidTypeApplicationError
+        # ignore known RBS errors.
+      else
+        Steep.log_error(exn, message: "Unexpected error in #type_send: #{exn.message} (#{exn.class})")
+      end
+
+      error = Errors::UnexpectedError.new(node: node, error: exn)
+
+      type_any_rec(node)
+
+      add_call(
+        TypeInference::MethodCall::Error.new(
+          node: node,
+          context: context.method_context,
+          method_name: method_name,
+          receiver_type: receiver_type,
+          errors: [error]
         )
-      ), return_type]
+      )
     end
 
     def expand_self(type)
@@ -2463,63 +2577,54 @@ module Steep
 
           zips.map do |arg_pairs|
             typing.new_child(node_range) do |child_typing|
-              ret = self.with_new_typing(child_typing).try_method_type(
+              self.with_new_typing(child_typing).try_method_type(
                 node,
                 receiver_type: receiver_type,
+                method_name: method_name,
                 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
               )
-
-              raise unless ret.is_a?(Array) && ret[1].is_a?(TypeConstruction)
-
-              result, constr = ret
-
-              [result, constr, method_type]
             end
           end
         end
       end
 
-      unless results.empty?
-        result, constr, method_type = results.find {|result, _, _| !result.is_a?(Errors::Base) } || results.last
-      else
+      case
+      when results.empty?
         method_type = method.method_types.last
+        all_decls = method.method_types.each.with_object(Set[]) do |method_type, set|
+          set.merge(method_type.method_decls)
+        end
+        error = Errors::IncompatibleArguments.new(node: node, receiver_type: receiver_type, method_type: method_type)
+        call = TypeInference::MethodCall::Error.new(
+          node: node,
+          context: context.method_context,
+          method_name: method_name,
+          receiver_type: receiver_type,
+          return_type: method_type.return_type,
+          errors: [error],
+          method_decls: all_decls
+        )
         constr = self.with_new_typing(typing.new_child(node_range))
-        result = Errors::IncompatibleArguments.new(node: node, receiver_type: receiver_type, method_type: method_type)
-      end
-      constr.typing.save!
-
-      case result
-      when Errors::Base
-        if method.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
+      when (call, constr = results.find {|call, _| call.is_a?(TypeInference::MethodCall::Typed) })
+        # Nop
+      else
+        if results.one?
+          call, constr = results[0]
         else
-          typing.add_error Errors::UnresolvedOverloading.new(node: node,
-                                                             receiver_type: expand_self(receiver_type),
-                                                             method_name: method_name,
-                                                             method_types: method.method_types)
-          type = AST::Builtin.any_type
+          return
         end
-
-        [type,
-         update_lvar_env { constr.context.lvar_env },
-         result]
-      else # Type
-        [result,
-         update_lvar_env { constr.context.lvar_env },
-         nil]
       end
+      constr.typing.save!
+
+      [
+        call,
+        update_lvar_env { constr.context.lvar_env }
+      ]
     end
 
     def check_keyword_arg(receiver_type:, node:, method_type:, constraints:)
@@ -2621,14 +2726,12 @@ module Steep
 
           hash_type = AST::Builtin::Hash.instance_type(
             AST::Builtin::Symbol.instance_type,
-            AST::Types::Union.build(types: value_types,
-                                    location: method_type.location)
+            AST::Types::Union.build(types: value_types)
           )
         else
           hash_elements = params.required_keywords.merge(
             method_type.params.optional_keywords.transform_values do |type|
-              AST::Types::Union.build(types: [type, AST::Builtin.nil_type],
-                                      location: method_type.location)
+              AST::Types::Union.build(types: [type, AST::Builtin.nil_type])
             end
           )
 
@@ -2650,151 +2753,211 @@ module Steep
       nil
     end
 
-    def try_method_type(node, receiver_type:, method_type:, args:, arg_pairs:, block_params:, block_body:, child_typing:, topdown_hint:)
+    def try_method_type(node, receiver_type:, method_name:, method_type:, args:, arg_pairs:, block_params:, block_body:, 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)
 
-      construction = self.class.new(
-        checker: checker,
-        source: source,
-        annotations: annotations,
-        typing: child_typing,
-        context: context
-      )
+      constr = self
 
-      constr = construction
+      method_type = method_type.instantiate(instantiation)
 
-      method_type.instantiate(instantiation).yield_self do |method_type|
-        constraints = Subtyping::Constraints.new(unknowns: fresh_types.map(&:name))
-        variance = Subtyping::VariableVariance.from_method_type(method_type)
-        occurence = Subtyping::VariableOccurence.from_method_type(method_type)
+      constraints = Subtyping::Constraints.new(unknowns: fresh_types.map(&:name))
+      variance = Subtyping::VariableVariance.from_method_type(method_type)
+      occurence = Subtyping::VariableOccurence.from_method_type(method_type)
 
-        arg_pairs.each do |pair|
-          case pair
-          when Array
-            (arg_node, param_type) = pair
-            param_type = param_type.subst(instantiation)
+      errors = []
 
-            arg_type, constr = if arg_node.type == :splat
-                                 constr.synthesize(arg_node.children[0])
-                               else
-                                 constr.synthesize(arg_node, hint: topdown_hint ? param_type : nil)
-                               end
+      arg_pairs.each do |pair|
+        case pair
+        when Array
+          arg_node, param_type = pair
+          param_type = param_type.subst(instantiation)
+
+          arg_type, constr = if arg_node.type == :splat
+                               constr.synthesize(arg_node.children[0])
+                             else
+                               constr.synthesize(arg_node, hint: topdown_hint ? param_type : nil)
+                             end
 
-            check_relation(sub_type: arg_type, super_type: param_type, constraints: constraints).else do |result|
-              return [Errors::ArgumentTypeMismatch.new(node: arg_node,
+          check_relation(sub_type: arg_type, super_type: param_type, constraints: constraints).else do
+            errors << Errors::ArgumentTypeMismatch.new(node: arg_node,
                                                        receiver_type: receiver_type,
                                                        expected: param_type,
-                                                       actual: arg_type),
-                      constr]
-            end
-          else
-            # keyword
-            result = check_keyword_arg(receiver_type: receiver_type,
-                                       node: pair,
-                                       method_type: method_type,
-                                       constraints: constraints)
+                                                       actual: arg_type)
+          end
+        else
+          # keyword
+          result = constr.check_keyword_arg(receiver_type: receiver_type,
+                                            node: pair,
+                                            method_type: method_type,
+                                            constraints: constraints)
 
-            if result.is_a?(Errors::Base)
-              return [result, constr]
-            end
+          if result.is_a?(Errors::Base)
+            errors << result
           end
         end
+      end
 
-        if block_params && method_type.block
-          block_annotations = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
-          block_params_ = TypeInference::BlockParams.from_node(block_params, annotations: block_annotations)
-
-          unless block_params_
-            return [
-              Errors::UnsupportedSyntax.new(
-                node: block_params,
-                message: "Unsupported block params pattern, probably masgn?"
-              ),
-              constr
-            ]
-          end
-
-          pairs = block_params_.zip(method_type.block.type.params)
-
-          unless pairs
-            return [
-              Errors::IncompatibleBlockParameters.new(node: node, method_type: method_type),
-              constr
-            ]
-          end
-
-          pairs.each do |param, type|
-            if param.type
-              check_relation(sub_type: type, super_type: param.type, constraints: constraints).else do |result|
-                return [
-                  Errors::IncompatibleAssignment.new(
-                    node: param.node,
-                    lhs_type: param.type,
-                    rhs_type: type,
-                    result: result
-                  ),
-                  constr
-                ]
+      if block_params
+        # block is given
+        block_annotations = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
+        block_params_ = TypeInference::BlockParams.from_node(block_params, annotations: block_annotations)
+
+        if method_type.block
+          pairs = method_type.block && block_params_&.zip(method_type.block.type.params)
+
+          if pairs
+            begin
+              block_constr = constr.for_block(
+                block_params: block_params_,
+                block_param_hint: method_type.block.type.params,
+                block_annotations: block_annotations,
+                node_type_hint: method_type.return_type
+              )
+              block_constr = block_constr.with_new_typing(
+                block_constr.typing.new_child(
+                  range: block_constr.typing.block_range(node)
+                )
+              )
+
+              block_constr.typing.add_context_for_body(node, context: block_constr.context)
+
+              pairs.each do |param, type|
+                _, block_constr = block_constr.synthesize(param.node, hint: param.type || type)
+
+                if param.type
+                  check_relation(sub_type: type, super_type: param.type, constraints: constraints).else do |result|
+                    error = Errors::IncompatibleAssignment.new(
+                      node: param.node,
+                      lhs_type: param.type,
+                      rhs_type: type,
+                      result: result
+                    )
+                    errors << error
+                  end
+                end
               end
-            end
-          end
-        end
 
-        case
-        when method_type.block && block_params
-          Steep.logger.debug "block is okay: method_type=#{method_type}"
-          Steep.logger.debug "Constraints = #{constraints}"
-
-          begin
-            method_type.subst(constraints.solution(checker, self_type: self_type, variance: variance, variables: occurence.params)).yield_self do |method_type|
-              type, _ = constr.type_block(node: node,
-                                          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,
-                                          topdown_hint: topdown_hint)
-
-              result = check_relation(sub_type: type.return_type,
+              s = constraints.solution(
+                checker,
+                self_type: self_type,
+                variance: variance,
+                variables: method_type.params.free_variables + method_type.block.type.params.free_variables
+              )
+              method_type = method_type.subst(s)
+              block_constr = block_constr.update_lvar_env {|env| env.subst(s) }
+              if block_body
+                block_body_type = block_constr.synthesize_block(
+                  node: node,
+                  block_type_hint: method_type.block.type.return_type,
+                  block_body: block_body,
+                  topdown_hint: topdown_hint
+                ) do |error|
+                  errors << error
+                end
+              else
+                block_body_type = AST::Builtin.nil_type
+              end
+
+              result = check_relation(sub_type: block_body_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, self_type: self_type, variance: variance, variables: fresh_vars)).yield_self do |ret_type|
-                  ty = if block_annotations.break_type
-                         AST::Types::Union.new(types: [block_annotations.break_type, ret_type])
-                       else
-                         ret_type
-                       end
-                  [ty, constr]
+                s = constraints.solution(checker, self_type: self_type, variance: variance, variables: fresh_vars)
+                method_type = method_type.subst(s)
+
+                return_type = method_type.return_type
+                if break_type = block_annotations.break_type
+                  return_type = union_type(break_type, return_type)
                 end
 
               when Subtyping::Result::Failure
-                [Errors::BlockTypeMismatch.new(node: node,
-                                               expected: method_type.block.type,
-                                               actual: type,
-                                               result: result),
-                 constr]
+                block_type = AST::Types::Proc.new(
+                  params: method_type.block.type.params || block_params.params_type,
+                  return_type: block_body_type
+                )
+                errors << Errors::BlockTypeMismatch.new(node: node,
+                                                        expected: method_type.block.type,
+                                                        actual: block_type,
+                                                        result: result)
+
+                return_type = method_type.return_type
+              end
+
+              block_constr.typing.save!
+            rescue Subtyping::Constraints::UnsatisfiableConstraint => exn
+              errors << Errors::UnsatisfiableConstraint.new(
+                node: node,
+                method_type: method_type,
+                var: exn.var,
+                sub_type: exn.sub_type,
+                super_type: exn.super_type,
+                result: exn.result
+              )
+
+              constr.type_block_without_hint(node: node, block_annotations: block_annotations, block_params: block_params_, block_body: block_body) do |error|
+                errors << error
               end
+
+              s = Interface::Substitution.build(method_type.free_variables,
+                                                Array.new(method_type.free_variables.size, AST::Builtin.any_type))
+              method_type = method_type.subst(s)
             end
+          else
+            errors << Errors::UnsupportedSyntax.new(
+              node: block_params,
+              message: "Unsupported block params pattern, probably masgn?"
+            )
+
+            s = constraints.solution(checker, variance: variance, variables: fresh_vars, self_type: self_type)
+            method_type = method_type.subst(s)
+          end
+        else
+          # Block is given but method doesn't accept
+          #
+          constr.type_block_without_hint(node: node, block_annotations: block_annotations, block_params: block_params_, block_body: block_body) do |error|
+            errors << error
+          end
+
+          errors << Errors::UnexpectedBlockGiven.new(
+            node: node,
+            method_type: method_type
+          )
+        end
+      else
+        # block is not given
+        if (!method_type.block || method_type.block.optional?)
+          # Method call without block is allowed
+          unless args.block_pass_arg
+            # OK, without block
+            s = constraints.solution(checker, variance: variance, variables: fresh_vars, self_type: self_type)
+            method_type = method_type.subst(s)
+          else
+            # &block arg is given
+            s = constraints.solution(checker, variance: variance, variables: fresh_vars, self_type: self_type)
+            method_type = method_type.subst(s)
 
-          rescue Subtyping::Constraints::UnsatisfiableConstraint => exn
-            [Errors::UnsatisfiableConstraint.new(node: node,
-                                                 method_type: method_type,
-                                                 var: exn.var,
-                                                 sub_type: exn.sub_type,
-                                                 super_type: exn.super_type,
-                                                 result: exn.result),
-             constr]
+            errors << Errors::UnexpectedBlockGiven.new(
+              node: node,
+              method_type: method_type
+            )
           end
+        else
+          unless args.block_pass_arg
+            # Required block is missing
+            errors << Errors::RequiredBlockMissing.new(
+              node: node,
+              method_type: method_type
+            )
 
-        when method_type.block && args.block_pass_arg
-          begin
-            method_type.subst(constraints.solution(checker, self_type: self_type, variance: variance, variables: occurence.params)).yield_self do |method_type|
+            s = constraints.solution(checker, variance: variance, variables: fresh_vars, self_type: self_type)
+            method_type = method_type.subst(s)
+          else
+            begin
+              method_type = method_type.subst(constraints.solution(checker, self_type: self_type, variance: variance, variables: occurence.params))
               block_type, constr = constr.synthesize(args.block_pass_arg, hint: topdown_hint ? method_type.block.type : nil)
               result = check_relation(
                 sub_type: block_type,
@@ -2808,68 +2971,65 @@ module Steep
                 constraints: constraints
               )
 
-              case result
-              when Subtyping::Result::Success
-                [
-                  method_type.return_type.subst(constraints.solution(checker, self_type: self_type, variance: variance, variables: fresh_vars)),
-                  constr
-                ]
-
-              when Subtyping::Result::Failure
-                [
-                  Errors::BlockTypeMismatch.new(node: node,
-                                                expected: method_type.block.type,
-                                                actual: block_type,
-                                                result: result),
-                  constr
-                ]
+              result.else do |result|
+                errors << Errors::BlockTypeMismatch.new(node: node,
+                                                        expected: method_type.block.type,
+                                                        actual: block_type,
+                                                        result: result)
               end
+
+              method_type = method_type.subst(constraints.solution(checker, self_type: self_type, variance: variance, variables: method_type.free_variables))
             end
+          end
+        end
+      end
 
-          rescue Subtyping::Constraints::UnsatisfiableConstraint => exn
-            [
-              Errors::UnsatisfiableConstraint.new(node: node,
-                                                  method_type: method_type,
-                                                  var: exn.var,
-                                                  sub_type: exn.sub_type,
-                                                  super_type: exn.super_type,
-                                                  result: exn.result),
-              constr
-            ]
-          end
-
-        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, self_type: self_type)).return_type,
-            constr
-          ]
-
-        when !method_type.block && (block_params || args.block_pass_arg)
-          [
-            Errors::UnexpectedBlockGiven.new(
-              node: node,
-              method_type: method_type
-            ),
-            constr
-          ]
+      call = if errors.empty?
+               TypeInference::MethodCall::Typed.new(
+                 node: node,
+                 context: context.method_context,
+                 receiver_type: receiver_type,
+                 method_name: method_name,
+                 actual_method_type: method_type,
+                 return_type: return_type || method_type.return_type,
+                 method_decls: method_type.method_decls
+               )
+             else
+               TypeInference::MethodCall::Error.new(
+                 node: node,
+                 context: context.method_context,
+                 receiver_type: receiver_type,
+                 method_name: method_name,
+                 return_type: return_type || method_type.return_type,
+                 method_decls: method_type.method_decls,
+                 errors: errors
+               )
+             end
+
+      [
+        call,
+        constr
+      ]
+    end
+
+    def type_block_without_hint(node:, block_annotations:, block_params:, block_body:, &block)
+      block_constr = for_block(
+        block_params: block_params,
+        block_param_hint: nil,
+        block_annotations: block_annotations,
+        node_type_hint: nil
+      )
 
-        when method_type.block && !method_type.block.optional? && !block_params && !block_body && !args.block_pass_arg
-          [
-            Errors::RequiredBlockMissing.new(
-              node: node,
-              method_type: method_type
-            ),
-            constr
-          ]
+      block_constr.typing.add_context_for_body(node, context: block_constr.context)
 
-        else
-          raise "Unexpected case condition"
-        end
+      block_params.params.each do |param|
+        _, block_constr = block_constr.synthesize(param.node, hint: param.type)
       end
+
+      block_constr.synthesize_block(node: node, block_type_hint: nil, block_body: block_body, topdown_hint: false, &block)
     end
 
-    def type_block(node:, block_param_hint:, block_type_hint:, node_type_hint:, block_params:, block_body:, block_annotations:, topdown_hint:)
+    def for_block(block_params:, block_param_hint:, block_annotations:, node_type_hint:)
       block_param_pairs = block_param_hint && block_params.zip(block_param_hint)
 
       param_types_hash = {}
@@ -2885,30 +3045,30 @@ module Steep
         end
       end
 
-      lvar_env = context.lvar_env.pin_assignments.yield_self do |env|
-        decls = param_types_hash.each.with_object({}) do |(name, type), hash|
-          hash[name] = TypeInference::LocalVariableTypeEnv::Entry.new(type: type)
-        end
-        env.except(decls.keys).update(assigned_types: decls)
-      end.annotate(block_annotations)
+      decls = param_types_hash.each.with_object({}) do |(name, type), hash|
+        hash[name] = TypeInference::LocalVariableTypeEnv::Entry.new(type: type)
+      end
+      lvar_env = context.lvar_env
+                   .pin_assignments
+                   .except(decls.keys)
+                   .update(assigned_types: decls)
+                   .annotate(block_annotations)
 
       break_type = if block_annotations.break_type
                      union_type(node_type_hint, block_annotations.break_type)
                    else
                      node_type_hint
                    end
-      Steep.logger.debug("return_type = #{break_type}")
-
-      block_context = TypeInference::Context::BlockContext.new(body_type: block_annotations.block_type)
-      Steep.logger.debug("block_context { body_type: #{block_context.body_type} }")
 
+      block_context = TypeInference::Context::BlockContext.new(
+        body_type: block_annotations.block_type
+      )
       break_context = TypeInference::Context::BreakContext.new(
         break_type: break_type,
         next_type: block_context.body_type
       )
-      Steep.logger.debug("break_context { type: #{break_context.break_type} }")
 
-      for_block_body = self.class.new(
+      self.class.new(
         checker: checker,
         source: source,
         annotations: annotations.merge_block_annotations(block_annotations),
@@ -2920,37 +3080,34 @@ module Steep
           break_context: break_context,
           self_type: block_annotations.self_type || self_type,
           type_env: type_env.dup,
-          lvar_env: lvar_env
+          lvar_env: lvar_env,
+          call_context: self.context.call_context
         )
       )
+    end
 
-      for_block_body.typing.add_context_for_body(node, context: for_block_body.context)
-
+    def synthesize_block(node:, block_type_hint:, block_body:, topdown_hint:)
       if block_body
-        body_pair = if (body_type = block_context.body_type)
-                      for_block_body.check(block_body, body_type) do |expected, actual, result|
-                        typing.add_error Errors::BlockTypeMismatch.new(node: block_body,
-                                                                       expected: expected,
-                                                                       actual: actual,
-                                                                       result: result)
-
-                      end
-                    else
-                      for_block_body.synthesize(block_body, hint: topdown_hint ? block_type_hint : nil)
-                    end
+        body_type, _, context =
+          if (body_type = block_context.body_type)
+            check(block_body, body_type) do |expected, actual, result|
+              error = Errors::BlockTypeMismatch.new(node: block_body,
+                                                    expected: expected,
+                                                    actual: actual,
+                                                    result: result)
+              yield(error) if block_given?
+            end
+          else
+            synthesize(block_body, hint: topdown_hint ? block_type_hint : nil)
+          end
 
         range = block_body.loc.expression.end_pos..node.loc.end.begin_pos
-        typing.add_context(range, context: body_pair.context)
+        typing.add_context(range, context: context)
+
+        body_type
       else
-        body_pair = Pair.new(type: AST::Builtin.nil_type, constr: for_block_body)
+        AST::Builtin.nil_type
       end
-
-      body_pair.with(
-        type: AST::Types::Proc.new(
-          params: block_param_hint || block_params.params_type,
-          return_type: body_pair.type
-        )
-      )
     end
 
     def each_child_node(node)
@@ -3070,8 +3227,10 @@ module Steep
         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.type_name
-          set << name
+        if name != :new
+          if method.implemented_in == module_context.module_definition.type_name
+            set << name
+          end
         end
       end
 
@@ -3172,6 +3331,14 @@ module Steep
       !nodes.empty? && nodes.all? {|child| child.type == :class || child.type == :module}
     end
 
+    def type_any_rec(node)
+      add_typing node, type: AST::Builtin.any_type
+
+      each_child_node(node) do |child|
+        type_any_rec(child)
+      end
+    end
+
     def fallback_any_rec(node)
       fallback_to_any(node) unless typing.has_type?(node)
 
@@ -3324,6 +3491,8 @@ module Steep
     end
 
     def try_hash_type(node, hint)
+      hint = expand_alias(hint)
+
       case hint
       when AST::Types::Record
         typing.new_child(node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }) do |child_typing|