steep 0.27.0 → 0.28.0

data/lib/steep/interface/substitution.rb

@@ -90,20 +90,32 @@ module Steep
 
       def except(vars)
         self.class.new(
-          dictionary: dictionary.reject {|k, _| vars.include?(k) },
+          dictionary: dictionary,
           instance_type: instance_type,
           module_type: module_type,
           self_type: self_type
-        )
+        ).except!(vars)
       end
 
-      def merge!(s)
+      def except!(vars)
+        vars.each do |var|
+          dictionary.delete(var)
+        end
+
+        self
+      end
+
+      def merge!(s, overwrite: false)
         dictionary.transform_values! {|ty| ty.subst(s) }
         dictionary.merge!(s.dictionary) do |key, a, b|
           if a == b
             a
           else
-            raise "Duplicated key on merge!: #{key}, #{a}, #{b}"
+            if overwrite
+              b
+            else
+              raise "Duplicated key on merge!: #{key}, #{a}, #{b} (#{self})"
+            end
           end
         end
 

data/lib/steep/project/completion_provider.rb

@@ -234,7 +234,7 @@ module Steep
                      when AST::Types::Name::Instance
                        type_name = subtyping.factory.type_name_1(type.name)
                        subtyping.factory.definition_builder.build_instance(type_name)
-                     when AST::Types::Name::Class, AST::Types::Name::Module
+                     when AST::Types::Name::Singleton
                        type_name = subtyping.factory.type_name_1(type.name)
                        subtyping.factory.definition_builder.build_singleton(type_name)
                      when AST::Types::Name::Interface

data/lib/steep/project/hover_content.rb

@@ -92,7 +92,7 @@ module Steep
                                                 method_definition
                                               ]
                                             end
-                                          when AST::Types::Name::Class
+                                          when AST::Types::Name::Singleton
                                             method_definition = method_definition_for(factory, receiver_type.name, singleton_method: method_name)
                                             if method_definition&.defined_in
                                               owner_name = factory.type_name(method_definition.defined_in)

data/lib/steep/server/base_worker.rb

@@ -40,6 +40,7 @@ module Steep
               case request[:method]
               when "shutdown"
                 @shutdown = true
+                writer.write(id: request[:id], result: nil)
               when "exit"
                 break
               else

data/lib/steep/server/code_worker.rb

@@ -139,6 +139,8 @@ module Steep
       end
 
       def handle_job(job)
+        sleep 0.1
+
         path, version, target = job
         if !version || target_files[path] == version
           typecheck_file(path, target)

data/lib/steep/server/master.rb

@@ -23,7 +23,7 @@ module Steep
         @signature_worker = signature_worker
         @code_workers = code_workers
         @worker_to_paths = {}
-        @shutdown = false
+        @shutdown_request_id = nil
       end
 
       def start
@@ -60,7 +60,14 @@ module Steep
         end
 
         while job = queue.pop
-          writer.write(job) unless @shutdown
+          if @shutdown_request_id
+            if job[:id] == @shutdown_request_id
+              writer.write(job)
+              break
+            end
+          else
+            writer.write(job)
+          end
         end
 
         writer.io.close
@@ -155,7 +162,7 @@ module Steep
 
         when "shutdown"
           queue << { id: id, result: nil }
-          @shutdown = true
+          @shutdown_request_id = id
 
         when "exit"
           queue << nil

data/lib/steep/source.rb

@@ -38,7 +38,7 @@ module Steep
     end
 
     def self.parser
-      ::Parser::Ruby25.new(Builder.new).tap do |parser|
+      ::Parser::Ruby27.new(Builder.new).tap do |parser|
         parser.diagnostics.all_errors_are_fatal = true
         parser.diagnostics.ignore_warnings = true
       end
@@ -60,7 +60,7 @@ module Steep
       _, comments, _ = yield_self do
         buffer = ::Parser::Source::Buffer.new(path.to_s)
         buffer.source = source_code
-        parser = ::Parser::Ruby25.new
+        parser = ::Parser::Ruby27.new
 
         parser.tokenize(buffer)
       end

data/lib/steep/subtyping/check.rb

@@ -42,9 +42,8 @@ module Steep
               )
             end
           when RBS::Definition::Ancestor::Singleton
-            AST::Types::Name::Class.new(
+            AST::Types::Name::Singleton.new(
               name: name,
-              constructor: nil,
               location: nil
             )
           end
@@ -78,9 +77,8 @@ module Steep
               )
             end
           when RBS::Definition::Ancestor::Singleton
-            AST::Types::Name::Class.new(
+            AST::Types::Name::Singleton.new(
               name: name,
-              constructor: nil,
               location: nil
             )
           end
@@ -180,6 +178,14 @@ module Steep
               constraints: constraints
             )
 
+          when relation.super_type.is_a?(AST::Types::Var) && constraints.unknown?(relation.super_type.name)
+            constraints.add(relation.super_type.name, sub_type: relation.sub_type)
+            success(constraints: constraints)
+
+          when relation.sub_type.is_a?(AST::Types::Var) && constraints.unknown?(relation.sub_type.name)
+            constraints.add(relation.sub_type.name, super_type: relation.super_type)
+            success(constraints: constraints)
+
           when relation.sub_type.is_a?(AST::Types::Union)
             results = relation.sub_type.types.map do |sub_type|
               check(Relation.new(sub_type: sub_type, super_type: relation.super_type),
@@ -232,14 +238,6 @@ module Steep
               results.find(&:failure?)
             end
 
-          when relation.super_type.is_a?(AST::Types::Var) && constraints.unknown?(relation.super_type.name)
-            constraints.add(relation.super_type.name, sub_type: relation.sub_type)
-            success(constraints: constraints)
-
-          when relation.sub_type.is_a?(AST::Types::Var) && constraints.unknown?(relation.sub_type.name)
-            constraints.add(relation.sub_type.name, super_type: relation.super_type)
-            success(constraints: constraints)
-
           when relation.super_type.is_a?(AST::Types::Var) || relation.sub_type.is_a?(AST::Types::Var)
             failure(error: Result::Failure::UnknownPairError.new(relation: relation),
                     trace: trace)
@@ -266,7 +264,7 @@ module Steep
               possible_sub_types = case relation.sub_type
                                    when AST::Types::Name::Instance
                                      instance_super_types(relation.sub_type.name, args: relation.sub_type.args)
-                                   when AST::Types::Name::Class
+                                   when AST::Types::Name::Singleton
                                      singleton_super_types(relation.sub_type.name)
                                    else
                                      []
@@ -399,7 +397,7 @@ module Steep
         case type
         when AST::Types::Name::Instance
           factory.definition_builder.build_instance(type_name)
-        when AST::Types::Name::Class
+        when AST::Types::Name::Singleton
           factory.definition_builder.build_singleton(type_name)
         when AST::Types::Name::Interface
           factory.definition_builder.build_interface(type_name)
@@ -484,11 +482,7 @@ module Steep
           if sub_type.name == super_type.name && sub_type.args.size == super_type.args.size
             sub_type.args.zip(super_type.args)
           end
-        when sub_type.is_a?(AST::Types::Name::Class) && super_type.is_a?(AST::Types::Name::Class)
-          if sub_type.name == super_type.name
-            []
-          end
-        when sub_type.is_a?(AST::Types::Name::Module) && super_type.is_a?(AST::Types::Name::Module)
+        when sub_type.is_a?(AST::Types::Name::Singleton) && super_type.is_a?(AST::Types::Name::Singleton)
           if sub_type.name == super_type.name
             []
           end
@@ -535,29 +529,24 @@ module Steep
 
       def check_method(name, sub_method, super_method, self_type:, assumption:, trace:, constraints:)
         trace.method name, sub_method, super_method do
-          case
-          when sub_method.overload? && super_method.overload?
-            super_method.types.map do |super_type|
-              sub_method.types.map do |sub_type|
-                check_generic_method_type name,
-                                          sub_type,
-                                          super_type,
-                                          self_type: self_type,
-                                          assumption: assumption,
-                                          trace: trace,
-                                          constraints: constraints
-              end.yield_self do |results|
-                results.find(&:success?) || results[0]
-              end
+          super_method.method_types.map do |super_type|
+            sub_method.method_types.map do |sub_type|
+              check_generic_method_type name,
+                                        sub_type,
+                                        super_type,
+                                        self_type: self_type,
+                                        assumption: assumption,
+                                        trace: trace,
+                                        constraints: constraints
             end.yield_self do |results|
-              if results.all?(&:success?) || sub_method.incompatible?
-                success constraints: constraints
-              else
-                results.select(&:failure?).last
-              end
+              results.find(&:success?) || results[0]
+            end
+          end.yield_self do |results|
+            if results.all?(&:success?)
+              success constraints: constraints
+            else
+              results.select(&:failure?).last
             end
-          else
-            raise "aaaaaaaaaaaaaa"
           end
         end
       end

data/lib/steep/type_construction.rb

@@ -113,6 +113,7 @@ module Steep
     end
 
     def check_relation(sub_type:, super_type:, constraints: Subtyping::Constraints.empty)
+      Steep.logger.debug { "check_relation: self:#{self_type} |- #{sub_type} <: #{super_type}" }
       checker.check(Subtyping::Relation.new(sub_type: sub_type, super_type: super_type), self_type: self_type, constraints: constraints)
     end
 
@@ -286,7 +287,6 @@ module Steep
 
         instance_type = AST::Types::Intersection.build(
           types: [
-            AST::Types::Name::Instance.new(name: module_name, args: module_args),
             AST::Builtin::Object.instance_type,
             *module_entry.self_types.map {|module_self|
               type = case
@@ -304,11 +304,12 @@ module Steep
                        )
                      end
               checker.factory.type(type)
-            }
+            },
+            AST::Types::Name::Instance.new(name: module_name, args: module_args)
           ].compact
         )
 
-        module_type = AST::Types::Name::Class.new(name: module_name, constructor: nil)
+        module_type = AST::Types::Name::Singleton.new(name: module_name)
       end
 
       if annots.instance_type
@@ -379,7 +380,7 @@ module Steep
         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: nil)
+        module_type = AST::Types::Name::Singleton.new(name: class_name)
       end
 
       if annots.instance_type
@@ -443,18 +444,26 @@ module Steep
                       end
 
       module_type = case instance_type
-                    when AST::Types::Name::Class
-                      AST::Builtin::Class.instance_type
-                    when AST::Types::Name::Module
-                      AST::Builtin::Module.instance_type
+                    when AST::Types::Name::Singleton
+                      type_name = checker.factory.type_name_1(instance_type.name)
+
+                      case checker.factory.env.class_decls[type_name]
+                      when RBS::Environment::ModuleEntry
+                        AST::Builtin::Module.instance_type
+                      when RBS::Environment::ClassEntry
+                        AST::Builtin::Class.instance_type
+                      else
+                        raise
+                      end
+
                     when AST::Types::Name::Instance
-                      instance_type.to_class(constructor: nil)
+                      instance_type.to_module
                     else
-                      raise "Unexpected type for sclass node: #{type}"
+                      return
                     end
 
       instance_definition = case instance_type
-                            when AST::Types::Name::Class, AST::Types::Name::Module
+                            when AST::Types::Name::Singleton
                               type_name = checker.factory.type_name_1(instance_type.name)
                               checker.factory.definition_builder.build_singleton(type_name)
                             when AST::Types::Name::Instance
@@ -463,7 +472,7 @@ module Steep
                             end
 
       module_definition = case module_type
-                          when AST::Types::Name::Class, AST::Types::Name::Module
+                          when AST::Types::Name::Singleton
                             type_name = checker.factory.type_name_1(instance_type.name)
                             checker.factory.definition_builder.build_singleton(type_name)
                           else
@@ -638,7 +647,10 @@ module Steep
             when :__skip__
               add_typing(node, type: AST::Builtin.any_type)
             else
-              hint ||= context.lvar_env.declared_types[name]&.type
+              if !hint || hint.is_a?(AST::Types::Void)
+                hint = context.lvar_env.declared_types[name]&.type
+              end
+
               rhs_result = synthesize(rhs, hint: hint)
 
               constr = rhs_result.constr.update_lvar_env do |lvar_env|
@@ -683,8 +695,8 @@ module Steep
           yield_self do
             if self_class?(node)
               module_type = expand_alias(module_context.module_type)
-              type = if module_type.is_a?(AST::Types::Name::Class)
-                       AST::Types::Name::Class.new(name: module_type.name, constructor: method_context.constructor)
+              type = if module_type.is_a?(AST::Types::Name::Singleton)
+                       AST::Types::Name::Singleton.new(name: module_type.name)
                      else
                        module_type
                      end
@@ -699,8 +711,8 @@ module Steep
           yield_self do
             pair = if self_class?(node)
                      module_type = expand_alias(module_context.module_type)
-                     type = if module_type.is_a?(AST::Types::Name::Class)
-                              AST::Types::Name::Class.new(name: module_type.name, constructor: method_context.constructor)
+                     type = if module_type.is_a?(AST::Types::Name::Singleton)
+                              AST::Types::Name::Singleton.new(name: module_type.name)
                             else
                               module_type
                             end
@@ -777,11 +789,10 @@ module Steep
                   synthesize(child)
                 end
 
-                super_method = Interface::Interface::Combination.overload(
-                  method_context.super_method.method_types.map {|method_type|
+                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)
-                  },
-                  incompatible: false
+                  }
                 )
                 args = TypeInference::SendArgs.from_nodes(node.children.dup)
 
@@ -879,7 +890,7 @@ module Steep
                          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
+                         when AST::Types::Name::Singleton
                            name = checker.factory.type_name_1(self_type.name)
                            checker.factory.definition_builder.build_singleton(name)
                          end
@@ -1034,12 +1045,13 @@ module Steep
             var = node.children[0]
             rhs = node.children[1]
 
-            type = context.lvar_env[var.name]
+            var_type = context.lvar_env[var.name]
+            node_type, constr = synthesize(rhs, hint: var_type)
 
-            node_type, constr = synthesize(rhs, hint: type)
+            type = AST::Types::Union.build(types: [var_type, node_type])
 
             constr_ = constr.update_lvar_env do |env|
-              env.assign(var.name, node: node, type: node_type) do |declared_type, type, result|
+              env.assign(var.name, node: node, type: type) do |declared_type, type, result|
                 typing.add_error(
                   Errors::IncompatibleAssignment.new(node: node,
                                                      lhs_type: declared_type,
@@ -1049,7 +1061,7 @@ module Steep
               end
             end
 
-            add_typing(node, type: constr_.context.lvar_env[var.name], constr: constr_)
+            add_typing(node, type: type, constr: constr_)
           end
 
         when :restarg
@@ -1229,6 +1241,17 @@ module Steep
             type, constr = synthesize(node.children[0])
             constructor = constr.for_sclass(node, type)
 
+            unless constructor
+              typing.add_error(
+                Errors::UnsupportedSyntax.new(
+                  node: node,
+                  message: "sclass receiver must be instance type or singleton type, but type given `#{type}`"
+                )
+              )
+              constr.add_typing(node, type: AST::Builtin.nil_type)
+              return
+            end
+
             constructor.typing.add_context_for_node(node, context: constructor.context)
             constructor.typing.add_context_for_body(node, context: constructor.context)
 
@@ -1240,7 +1263,7 @@ module Steep
               end
             end
 
-            add_typing(node, type: AST::Builtin.nil_type)
+            constr.add_typing(node, type: AST::Builtin.nil_type)
           end
 
         when :self
@@ -1509,38 +1532,53 @@ module Steep
                 test_types << expand_alias(type)
               end
 
-              if body
-                if var_names && var_types && test_types.all? {|ty| ty.is_a?(AST::Types::Name::Class) }
-                  var_types_in_body = test_types.flat_map do |test_type|
-                    filtered_types = var_types.select do |var_type|
-                      var_type.is_a?(AST::Types::Name::Base) && var_type.name == test_type.name
-                    end
-                    if filtered_types.empty?
-                      to_instance_type(test_type)
-                    else
-                      filtered_types
-                    end
+              if var_names && var_types && test_types.all? {|ty| ty.is_a?(AST::Types::Name::Singleton) }
+                var_types_in_body = test_types.flat_map do |test_type|
+                  filtered_types = var_types.select do |var_type|
+                    var_type.is_a?(AST::Types::Name::Base) && var_type.name == test_type.name
                   end
-
-                  var_types.reject! do |type|
-                    var_types_in_body.any? do |test_type|
-                      type.is_a?(AST::Types::Name::Base) && test_type.name == type.name
-                    end
+                  if filtered_types.empty?
+                    to_instance_type(test_type)
+                  else
+                    filtered_types
                   end
+                end
 
-                  var_type_in_body = union_type(*var_types_in_body)
-                  type_case_override = var_names.each.with_object({}) do |var_name, hash|
-                    hash[var_name] = var_type_in_body
+                var_types.reject! do |type|
+                  var_types_in_body.any? do |test_type|
+                    type.is_a?(AST::Types::Name::Base) && test_type.name == type.name
                   end
+                end
 
+                var_type_in_body = union_type(*var_types_in_body)
+                type_case_override = var_names.each.with_object({}) do |var_name, hash|
+                  hash[var_name] = var_type_in_body
+                end
+
+                if body
                   branch_pairs << clause_constr
                                     .for_branch(body, type_case_override: type_case_override)
                                     .synthesize(body, hint: hint)
                 else
-                  branch_pairs << clause_constr.synthesize(body, hint: hint)
+                  branch_pairs << Pair.new(type: AST::Builtin.nil_type, constr: clause_constr)
                 end
               else
-                branch_pairs << Pair.new(type: AST::Builtin.nil_type, constr: clause_constr)
+                logic = TypeInference::Logic.new(subtyping: checker)
+
+                truthys, falseys = logic.nodes(node: ::AST::Node.new(:begin, tests))
+                truthy_env, _ = logic.environments(truthy_vars: truthys.vars,
+                                                   falsey_vars: falseys.vars,
+                                                   lvar_env: clause_constr.context.lvar_env)
+
+                if body
+                  branch_pairs << constr
+                                    .update_lvar_env { truthy_env }
+                                    .for_branch(body)
+                                    .tap {|constr| typing.add_context_for_node(body, context: constr.context) }
+                                    .synthesize(body, hint: hint)
+                else
+                  branch_pairs << Pair.new(type: AST::Builtin.nil_type, constr: clause_constr)
+                end
               end
             end
 
@@ -1620,7 +1658,7 @@ module Steep
                 instance_types = exn_types.map do |type|
                   type = expand_alias(type)
                   case
-                  when type.is_a?(AST::Types::Name::Class)
+                  when type.is_a?(AST::Types::Name::Singleton)
                     to_instance_type(type)
                   else
                     AST::Builtin.any_type
@@ -1687,7 +1725,7 @@ module Steep
                          AST::Types::Any.new
                        else
                          each = checker.factory.interface(collection_type, private: true).methods[:each]
-                         method_type = (each&.types || []).find {|type| type.block && type.block.type.params.first_param }
+                         method_type = (each&.method_types || []).find {|type| type.block && type.block.type.params.first_param }
                          method_type&.yield_self do |method_type|
                            method_type.block.type.params.first_param&.type
                          end
@@ -1779,9 +1817,22 @@ module Steep
           end
 
         when :irange, :erange
-          types = node.children.map {|n| synthesize(n).type }
-          type = AST::Builtin::Range.instance_type(union_type(*types))
-          add_typing(node, type: type)
+          begin_node, end_node = node.children
+
+          constr = self
+          begin_type, constr = if begin_node
+                                 constr.synthesize(begin_node)
+                               else
+                                 [AST::Builtin.nil_type, constr]
+                               end
+          end_type, constr = if end_node
+                               constr.synthesize(end_node)
+                             else
+                               [AST::Builtin.nil_type, constr]
+                             end
+
+          type = AST::Builtin::Range.instance_type(union_type(begin_type, end_type))
+          add_typing(node, type: type, constr: constr)
 
         when :regexp
           each_child_node(node) do |child|
@@ -1875,8 +1926,8 @@ module Steep
                 param_type = hint.params.required[0]
                 interface = checker.factory.interface(param_type, private: true)
                 method = interface.methods[value.children[0]]
-                if method&.overload?
-                  return_types = method.types.select {|method_type|
+                if method
+                  return_types = method.method_types.select {|method_type|
                     method_type.params.each_type.count == 0
                   }.map(&:return_type)
 
@@ -2384,139 +2435,68 @@ module Steep
     def type_method_call(node, method_name:, receiver_type:, method:, args:, block_params:, block_body:, topdown_hint:)
       node_range = node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }
 
-      case
-      when method.union?
-        yield_self do
-          results = method.types.map do |method|
+      results = method.method_types.flat_map do |method_type|
+        Steep.logger.tagged method_type.to_s do
+          zips = args.zips(method_type.params, method_type.block&.type)
+
+          zips.map do |arg_pairs|
             typing.new_child(node_range) do |child_typing|
-              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)
-            end
-          end
+              ret = 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
+              )
 
-          if (type, constr, error = results.find {|_, _, error| error })
-            constr.typing.save!
-            [type,
-             update_lvar_env { constr.context.lvar_env },
-             error]
-          else
-            types = results.map(&:first)
+              raise unless ret.is_a?(Array) && ret[1].is_a?(TypeConstruction)
 
-            _, constr, _ = results.first
-            constr.typing.save!
+              result, constr = ret
 
-            [union_type(*types),
-             update_lvar_env { constr.context.lvar_env },
-             nil]
+              [result, constr, method_type]
+            end
           end
         end
+      end
 
-      when method.intersection?
-        yield_self do
-          results = method.types.map do |method|
-            typing.new_child(node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }) do |child_typing|
-              with_new_typing(child_typing).type_method_call(node,
+      unless results.empty?
+        result, constr, method_type = results.find {|result, _, _| !result.is_a?(Errors::Base) } || results.last
+      else
+        method_type = method.method_types.last
+        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
+        else
+          typing.add_error Errors::UnresolvedOverloading.new(node: node,
+                                                             receiver_type: expand_self(receiver_type),
                                                              method_name: method_name,
-                                                             receiver_type: receiver_type,
-                                                             method: method,
-                                                             args: args,
-                                                             block_params: block_params,
-                                                             block_body: block_body,
-                                                             topdown_hint: false)
-            end
-          end
-
-          successes = results.reject {|_, _, error| error }
-          unless successes.empty?
-            types = successes.map(&:first)
-            constr = successes[0][1]
-            constr.typing.save!
-
-            [AST::Types::Intersection.build(types: types),
-             update_lvar_env { constr.context.lvar_env },
-             nil]
-          else
-            type, constr, error = results.first
-            constr.typing.save!
-
-            [type,
-             update_lvar_env { constr.context.lvar_env },
-             error]
-          end
+                                                             method_types: method.method_types)
+          type = AST::Builtin.any_type
         end
 
-      when method.overload?
-        yield_self do
-          results = method.types.flat_map do |method_type|
-            Steep.logger.tagged method_type.to_s do
-              zips = args.zips(method_type.params, method_type.block&.type)
-
-              zips.map do |arg_pairs|
-                typing.new_child(node_range) do |child_typing|
-                  ret = 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
-                  )
-
-                  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
-            method_type = method.types.last
-            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.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,
-             update_lvar_env { constr.context.lvar_env },
-             result]
-          else # Type
-            [result,
-             update_lvar_env { constr.context.lvar_env },
-             nil]
-          end
-        end
+        [type,
+         update_lvar_env { constr.context.lvar_env },
+         result]
+      else # Type
+        [result,
+         update_lvar_env { constr.context.lvar_env },
+         nil]
       end
     end
 
@@ -2703,16 +2683,40 @@ module Steep
         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)
-          block_param_hint = block_params_.params_type(
-            hint: topdown_hint ? method_type.block.type.params : nil
-          )
 
-          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),
-                    constr]
+          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
+                ]
+              end
+            end
           end
         end
 
@@ -3272,7 +3276,7 @@ module Steep
 
     def to_instance_type(type, args: nil)
       args = args || case type
-                     when AST::Types::Name::Class, AST::Types::Name::Module
+                     when AST::Types::Name::Singleton
                        checker.factory.env.class_decls[checker.factory.type_name_1(type.name)].type_params.each.map { AST::Builtin.any_type }
                      else
                        raise "unexpected type to to_instance_type: #{type}"