steep 1.1.1 → 1.2.0.pre.1

data/lib/steep/type_construction.rb

@@ -146,7 +146,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, method_decls: Set[]) }
+                                     .map {|method_type| checker.factory.method_type(method_type, method_decls: Set[]) }
                                      .select {|method_type| method_type.is_a?(Interface::MethodType) }
                                      .inject {|t1, t2| t1 + t2}
                                  end
@@ -347,6 +347,8 @@ module Steep
       if implement_module_name
         module_entry = checker.factory.definition_builder.env.class_decls[implement_module_name.name]
 
+        raise unless module_entry.is_a?(RBS::Environment::ModuleEntry)
+
         module_context = module_context.update(
           instance_type: AST::Types::Intersection.build(
             types: [
@@ -534,6 +536,15 @@ module Steep
       end
     end
 
+    def meta_type(type)
+      case type
+      when AST::Types::Name::Instance
+        type.to_module
+      when AST::Types::Name::Singleton
+        AST::Builtin::Class.instance_type
+      end
+    end
+
     def for_sclass(node, type)
       annots = source.annotations(block: node, factory: checker.factory, context: nesting)
 
@@ -605,7 +616,7 @@ module Steep
         block_context: nil,
         module_context: module_context,
         break_context: nil,
-        self_type: module_context.module_type,
+        self_type: meta_type(annots.self_type || type) || AST::Builtin::Class.module_type,
         type_env: type_env,
         call_context: TypeInference::MethodCall::ModuleContext.new(type_name: module_context.class_name),
         variable_context: TypeInference::Context::TypeVariableContext.empty  # Assuming `::Class` and `::Module` don't have type params
@@ -885,14 +896,14 @@ module Steep
                   synthesize(child)
                 end
 
-                super_method = Interface::Interface::Entry.new(
+                super_method = Interface::Shape::Entry.new(
                   method_types: method_context.super_method.method_types.map {|method_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])
+                    checker.factory.method_type(method_type, method_decls: Set[decl])
                   }
                 )
 
@@ -1598,22 +1609,29 @@ module Steep
           end
 
         when :yield
-          if method_context&.method_type
-            if method_context.block_type
-              block_type = method_context.block_type
-              block_type.type.params.flat_unnamed_params.map(&:last).zip(node.children).each do |(type, node)|
-                if node && type
-                  check(node, type) do |_, rhs_type, result|
-                    typing.add_error(
-                      Diagnostic::Ruby::IncompatibleAssignment.new(
-                        node: node,
-                        lhs_type: type,
-                        rhs_type: rhs_type,
-                        result: result
-                      )
-                    )
-                  end
-                end
+          if method_context && method_context.method_type
+            if block_type = method_context.block_type
+              type = AST::Types::Proc.new(
+                type: block_type.type,
+                block: nil,
+                self_type: block_type.self_type
+              )
+              args = TypeInference::SendArgs.new(
+                node: node,
+                arguments: node.children,
+                type: type
+              )
+
+              # @type var errors: Array[Diagnostic::Ruby::Base]
+              errors = []
+              constr = type_check_args(
+                args,
+                Subtyping::Constraints.new(unknowns: []),
+                errors
+              )
+
+              errors.each do |error|
+                typing.add_error(error)
               end
 
               add_typing(node, type: block_type.type.return_type)
@@ -1630,11 +1648,10 @@ 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, method_decls: Set[]).type.return_type
+                  checker.factory.method_type(method_type, method_decls: Set[]).type.return_type
                 }
                 add_typing(node, type: union_type(*types))
               else
-
                 fallback_to_any(node) do
                   Diagnostic::Ruby::UnexpectedSuper.new(node: node, method: method_context.name)
                 end
@@ -1692,7 +1709,7 @@ module Steep
 
             left_type, constr, left_context = synthesize(left_node, hint: hint, condition: true).to_ary
 
-            interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing)
+            interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing, config: builder_config)
             left_truthy_env, left_falsy_env = interpreter.eval(env: left_context.type_env, node: left_node)
 
             if left_type.is_a?(AST::Types::Logic::Env)
@@ -1740,7 +1757,7 @@ module Steep
 
             left_type, constr, left_context = synthesize(left_node, hint: hint, condition: true).to_ary
 
-            interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing)
+            interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing, config: builder_config)
             left_truthy_env, left_falsy_env = interpreter.eval(env: left_context.type_env, node: left_node)
 
             if left_type.is_a?(AST::Types::Logic::Env)
@@ -1787,7 +1804,7 @@ module Steep
             cond, true_clause, false_clause = node.children
 
             cond_type, constr = synthesize(cond, condition: true).to_ary
-            interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: constr.typing)
+            interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: constr.typing, config: builder_config)
             truthy_env, falsy_env = interpreter.eval(env: constr.context.type_env, node: cond)
 
             if true_clause
@@ -1830,7 +1847,7 @@ module Steep
               env.join(*envs)
             end
 
-            node_type = union_type(true_pair&.type || AST::Builtin.nil_type, false_pair&.type || AST::Builtin.nil_type)
+            node_type = union_type_unify(true_pair&.type || AST::Builtin.nil_type, false_pair&.type || AST::Builtin.nil_type)
             add_typing(node, type: node_type, constr: constr)
           end
 
@@ -1839,7 +1856,7 @@ module Steep
             cond, *whens, els = node.children
 
             constr = self
-            interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing)
+            interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing, config: builder_config)
 
             if cond
               branch_results = []
@@ -1971,7 +1988,7 @@ module Steep
               env.join(*envs)
             end
 
-            add_typing(node, type: union_type(*types), constr: constr)
+            add_typing(node, type: union_type_unify(*types), constr: constr)
           end
 
         when :rescue
@@ -2085,16 +2102,19 @@ module Steep
             collection_type, constr, collection_context = synthesize(collection).to_ary
             collection_type = expand_self(collection_type)
 
-            var_type = case collection_type
-                       when AST::Types::Any
-                         AST::Types::Any.new
-                       else
-                         each = calculate_interface(collection_type, private: true).methods[:each]
-                         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
-                       end
+            if collection_type.is_a?(AST::Types::Any)
+              var_type = AST::Builtin.any_type
+            else
+              if each = calculate_interface(collection_type, :each, private: true)
+                if method_type = (each.method_types || []).find {|type| type.block && type.block.type.params.first_param }
+                  if block = method_type.block
+                    if first_param = block.type.params.first_param
+                      var_type = first_param.type
+                    end
+                  end
+                end
+              end
+            end
             var_name = asgn.children[0]
 
             if var_type
@@ -2133,7 +2153,7 @@ module Steep
             cond, body = node.children
             cond_type, constr = synthesize(cond, condition: true).to_ary
 
-            interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing)
+            interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing, config: builder_config)
             truthy_env, falsy_env = interpreter.eval(env: constr.context.type_env, node: cond)
 
             case node.type
@@ -2307,9 +2327,7 @@ module Steep
                 when AST::Types::Any
                   type = AST::Types::Any.new
                 else
-                  interface = calculate_interface(param_type, private: true)
-                  method = interface.methods[value.children[0]]
-                  if method
+                  if method = calculate_interface(param_type, private: true)&.methods&.[](value.children[0])
                     return_types = method.method_types.filter_map do |method_type|
                       if method_type.type.params.optional?
                         method_type.type.return_type
@@ -2325,7 +2343,8 @@ module Steep
                           return_type: return_types[0],
                           location: nil
                         ),
-                        block: nil
+                        block: nil,
+                        self_type: nil
                       )
                     end
                   end
@@ -2337,7 +2356,8 @@ module Steep
               type = AST::Types::Proc.new(
                 type: method_context.method_type.block.type,
                 location: nil,
-                block: nil
+                block: nil,
+                self_type: method_context.method_type.block.self_type
               )
               if method_context.method_type.block.optional?
                 type = AST::Types::Union.build(types: [type, AST::Builtin.nil_type])
@@ -2570,7 +2590,11 @@ module Steep
         type.is_a?(AST::Types::Nil) || (type.is_a?(AST::Types::Literal) && type.value == false)
       end
 
-      truthy_rhs_type = AST::Types::Union.build(types: truthys)
+      truthy_rhs_type = union_type_unify(*truthys)
+      if truthy_rhs_type.is_a?(AST::Types::Union)
+        tup = union_of_tuple_to_tuple_of_union(truthy_rhs_type)
+        truthy_rhs_type = tup if tup
+      end
       optional = !falsys.empty?
 
       if truthy_rhs_type.is_a?(AST::Types::Tuple) || AST::Builtin::Array.instance_type?(truthy_rhs_type) || truthy_rhs_type.is_a?(AST::Types::Any)
@@ -2707,6 +2731,7 @@ module Steep
         params_hint = type_hint.type.params
         return_hint = type_hint.type.return_type
         block_hint = type_hint.block
+        self_hint = type_hint.self_type
       end
 
       block_constr = for_block(
@@ -2716,6 +2741,7 @@ module Steep
         block_type_hint: return_hint,
         block_block_hint: block_hint,
         block_annotations: block_annotations,
+        block_self_hint: self_hint,
         node_type_hint: nil
       )
 
@@ -2730,10 +2756,10 @@ module Steep
           if block_param_type = block_param.type
             case block_param_type
             when AST::Types::Proc
-              Interface::Block.new(type: block_param_type.type, optional: false)
+              Interface::Block.new(type: block_param_type.type, optional: false, self_type: block_param_type.self_type)
             else
               if proc_type = optional_proc?(block_param_type)
-                Interface::Block.new(type: proc_type.type, optional: true)
+                Interface::Block.new(type: proc_type.type, optional: true, self_type: proc_type.self_type)
               else
                 block_constr.typing.add_error(
                   Diagnostic::Ruby::ProcTypeExpected.new(
@@ -2748,7 +2774,8 @@ module Steep
                     return_type: AST::Builtin.any_type,
                     location: nil
                   ),
-                  optional: false
+                  optional: false,
+                  self_type: nil
                 )
               end
             end
@@ -2764,6 +2791,10 @@ module Steep
           block_type_hint: return_hint
         )
 
+        return_type = return_type.subst(
+          Interface::Substitution.build([], [], self_type: block_constr.self_type)
+        )
+
         if expected_block_type = block_constr.block_context.body_type
           type_vars = expected_block_type.free_variables
           subst = Interface::Substitution.build(type_vars, type_vars.map { AST::Builtin.any_type })
@@ -2792,7 +2823,8 @@ module Steep
           return_type: return_type,
           location: nil
         ),
-        block: block
+        block: block,
+        self_type: block_annotations.self_type || self_hint
       )
 
       add_typing node, type: block_type
@@ -2827,7 +2859,7 @@ module Steep
     end
 
     def type_send_interface(node, interface:, receiver:, receiver_type:, method_name:, arguments:, block_params:, block_body:)
-      method = interface.methods[method_name]
+      method = interface&.methods&.[](method_name)
 
       if method
         call, constr = type_method_call(node,
@@ -2872,19 +2904,7 @@ module Steep
             call = call.with_return_type(optional_type)
           end
         else
-          error = Diagnostic::Ruby::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]
-          )
+          errors = []
 
           skips = [receiver]
           skips << node.children[0] if node.type == :block
@@ -2898,8 +2918,24 @@ module Steep
               block_params: TypeInference::BlockParams.from_node(block_params, annotations: block_annotations),
               block_annotations: block_annotations,
               block_body: block_body
-            )
+            ) do |error|
+              errors << error
+            end
           end
+
+          errors << Diagnostic::Ruby::UnresolvedOverloading.new(
+            node: node,
+            receiver_type: interface.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: errors
+          )
         end
 
         constr.add_call(call)
@@ -2939,15 +2975,41 @@ module Steep
             context: context.method_context,
             method_name: method_name,
             receiver_type: receiver_type,
-            error: Diagnostic::Ruby::NoMethod.new(node: node, method: method_name, type: receiver_type)
+            error: Diagnostic::Ruby::NoMethod.new(node: node, method: method_name, type: interface&.type || receiver_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]
+      # @type var constr: TypeConstruction
+
+      case send_node.type
+      when :super, :zsuper
+        receiver = nil
+        method_name = method_context&.name
+        arguments = send_node.children
+
+        if method_name.nil? || method_context&.super_method.nil?
+          return fallback_to_any(send_node) do
+            Diagnostic::Ruby::UnexpectedSuper.new(
+              node: send_node,
+              method: method_context&.name
+            )
+          end
+        end
+
+        recv_type = AST::Types::Self.instance
+        constr = self
+      else
+        receiver, method_name, *arguments = send_node.children
+        if receiver
+          recv_type, constr = synthesize(receiver)
+        else
+          recv_type = AST::Types::Self.instance
+          constr = self
+        end
+      end
 
       if unwrap
         recv_type = unwrap(recv_type)
@@ -2970,16 +3032,14 @@ module Steep
                          )
                        )
 
-                     when AST::Types::Var
-                       if upper_bound = variable_context[receiver_type.name]
-                         interface = calculate_interface(upper_bound, private: false)
-
+                     else
+                       if interface = calculate_interface(receiver_type, private: private)
                          constr.type_send_interface(
                            node,
                            interface: interface,
                            receiver: receiver,
                            receiver_type: receiver_type,
-                           method_name: method_name,
+                            method_name: method_name,
                            arguments: arguments,
                            block_params: block_params,
                            block_body: block_body
@@ -2996,85 +3056,34 @@ module Steep
                            )
                          )
                        end
-                     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: Diagnostic::Ruby::NoMethod.new(node: node, method: method_name, type: receiver_type)
-                         )
-                       )
-
-                     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: Diagnostic::Ruby::NoMethod.new(node: node, method: method_name, type: receiver_type)
-                           )
-                         )
-                       else
-                         interface = calculate_interface(expanded_self,
-                                                         private: private,
-                                                         self_type: AST::Types::Self.new)
-
-                         if send_node.type == :super || send_node.type == :zsuper
-                            method_name = method_context.name
-                            unless method_context.super_method
-                              return fallback_to_any(send_node) do
-                                Diagnostic::Ruby::UnexpectedSuper.new(node: send_node, method: method_name)
-                              end
-                            end
-                         end
-
-                         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 = calculate_interface(receiver_type, private: private, 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)
     end
 
-    def calculate_interface(type, private:, self_type: type)
-      case type
-      when AST::Types::Self
-        type = self_type
-      when AST::Types::Instance
-        type = module_context.instance_type
-      when AST::Types::Class
-        type = module_context.module_type
-      end
+    def builder_config
+      Interface::Builder::Config.new(
+        self_type: self_type,
+        class_type: module_context.module_type,
+        instance_type: module_context.instance_type,
+        variable_bounds: variable_context.upper_bounds
+      )
+    end
+
+    def calculate_interface(type, method_name = nil, private:)
+      shape = checker.builder.shape(
+        type,
+        public_only: !private,
+        config: builder_config
+      )
 
-      checker.factory.interface(type, private: private, self_type: self_type)
+      if method_name
+        if shape
+          shape.methods[method_name]
+        end
+      else
+        shape
+      end
     end
 
     def expand_self(type)
@@ -3219,7 +3228,7 @@ module Steep
     end
 
     def with_child_typing(range:)
-      constr = with_new_typing(typing.new_child(range: range))
+      constr = with_new_typing(typing.new_child(range))
 
       if block_given?
         yield constr
@@ -3271,6 +3280,93 @@ module Steep
       end
     end
 
+    def type_check_args(args, constraints, errors)
+      # @type var constr: TypeConstruction
+      constr = self
+
+      es = args.each do |arg|
+        case arg
+        when TypeInference::SendArgs::PositionalArgs::NodeParamPair
+          _, constr = constr.type_check_argument(
+            arg.node,
+            type: arg.param.type,
+            constraints: constraints,
+            errors: errors
+          )
+
+        when TypeInference::SendArgs::PositionalArgs::NodeTypePair
+          _, constr = bypass_splat(arg.node) do |n|
+            constr.type_check_argument(
+              n,
+              type: arg.node_type,
+              constraints: constraints,
+              report_node: arg.node,
+              errors: errors
+            )
+          end
+
+        when TypeInference::SendArgs::PositionalArgs::UnexpectedArg
+          _, constr = bypass_splat(arg.node) do |n|
+            constr.synthesize(n)
+          end
+
+        when TypeInference::SendArgs::PositionalArgs::SplatArg
+          arg_type, _ =
+            constr
+              .with_child_typing(range: arg.node.loc.expression.begin_pos ... arg.node.loc.expression.end_pos)
+              .try_tuple_type!(arg.node.children[0])
+          arg.type = arg_type
+
+        when TypeInference::SendArgs::PositionalArgs::MissingArg
+          # ignore
+
+        when TypeInference::SendArgs::KeywordArgs::ArgTypePairs
+          arg.pairs.each do |pair|
+            node, type = pair
+            _, constr = bypass_splat(node) do |node|
+              constr.type_check_argument(
+                node,
+                type: type,
+                constraints: constraints,
+                errors: errors
+              )
+            end
+          end
+
+        when TypeInference::SendArgs::KeywordArgs::UnexpectedKeyword
+          if arg.node.type == :pair
+            arg.node.children.each do |nn|
+              _, constr = constr.synthesize(nn)
+            end
+          else
+            _, constr = bypass_splat(arg.node) do |n|
+              constr.synthesize(n)
+            end
+          end
+
+        when TypeInference::SendArgs::KeywordArgs::SplatArg
+          type, _ = bypass_splat(arg.node) do |sp_node|
+            if sp_node.type == :hash
+              pair = constr.type_hash_record(sp_node, nil) and break pair
+            end
+
+            constr.synthesize(sp_node)
+          end
+
+          arg.type = type
+
+        when TypeInference::SendArgs::KeywordArgs::MissingKeyword
+          # ignore
+        else
+          raise arg.inspect
+        end
+      end
+
+      errors.push(*es)
+
+      constr
+    end
+
     def try_method_type(node, receiver_type:, method_name:, method_type:, arguments:, block_params:, block_body:, topdown_hint:)
       type_params, instantiation = Interface::TypeParam.rename(method_type.type_params)
       type_param_names = type_params.map(&:name)
@@ -3307,91 +3403,15 @@ module Steep
       end
 
       checker.push_variable_bounds(upper_bounds) do
+        # @type var errors: Array[Diagnostic::Ruby::Base]
         errors = []
 
-        args = TypeInference::SendArgs.new(node: node, arguments: arguments, method_name: method_name, method_type: method_type)
-        es = args.each do |arg|
-          case arg
-          when TypeInference::SendArgs::PositionalArgs::NodeParamPair
-            _, constr = constr.type_check_argument(
-              arg.node,
-              type: arg.param.type,
-              receiver_type: receiver_type,
-              constraints: constraints,
-              errors: errors
-            )
-
-          when TypeInference::SendArgs::PositionalArgs::NodeTypePair
-            _, constr = bypass_splat(arg.node) do |n|
-              constr.type_check_argument(
-                n,
-                type: arg.node_type,
-                receiver_type: receiver_type,
-                constraints: constraints,
-                report_node: arg.node,
-                errors: errors
-              )
-            end
-
-          when TypeInference::SendArgs::PositionalArgs::UnexpectedArg
-            _, constr = bypass_splat(arg.node) do |n|
-              constr.synthesize(n)
-            end
-
-          when TypeInference::SendArgs::PositionalArgs::SplatArg
-            arg_type, _ = constr
-                            .with_child_typing(range: arg.node.loc.expression.begin_pos ... arg.node.loc.expression.end_pos)
-                            .try_tuple_type!(arg.node.children[0])
-            arg.type = arg_type
-
-          when TypeInference::SendArgs::PositionalArgs::MissingArg
-            # ignore
-
-          when TypeInference::SendArgs::KeywordArgs::ArgTypePairs
-            arg.pairs.each do |node, type|
-              _, constr = bypass_splat(node) do |node|
-                constr.type_check_argument(
-                  node,
-                  type: type,
-                  receiver_type: receiver_type,
-                  constraints: constraints,
-                  errors: errors
-                )
-              end
-            end
-
-          when TypeInference::SendArgs::KeywordArgs::UnexpectedKeyword
-            if arg.node.type == :pair
-              arg.node.children.each do |nn|
-                _, constr = constr.synthesize(nn)
-              end
-            else
-              _, constr = bypass_splat(arg.node) do |n|
-                constr.synthesize(n)
-              end
-            end
-
-          when TypeInference::SendArgs::KeywordArgs::SplatArg
-            type, _ = bypass_splat(arg.node) do |sp_node|
-              if sp_node.type == :hash
-                pair = constr.type_hash_record(sp_node, nil) and break pair
-              end
-
-              constr.synthesize(sp_node)
-            end
-
-            arg.type = type
-
-          when TypeInference::SendArgs::KeywordArgs::MissingKeyword
-            # ignore
-          else
-            raise arg.inspect
-          end
-
-          constr
-        end
-
-        errors.push(*es)
+        args = TypeInference::SendArgs.new(node: node, arguments: arguments, type: method_type)
+        constr = constr.type_check_args(
+          args,
+          constraints,
+          errors
+        )
 
         if block_params
           # block is given
@@ -3400,9 +3420,9 @@ module Steep
 
           if method_type.block
             # Method accepts block
-            pairs = method_type.block && block_params_&.zip(method_type.block.type.params, nil)
+            pairs = block_params_&.zip(method_type.block.type.params, nil, factory: checker.factory)
 
-            if pairs
+            if block_params_ && pairs
               # Block parameters are compatible with the block type
               block_constr = constr.for_block(
                 block_body,
@@ -3411,6 +3431,7 @@ module Steep
                 block_type_hint: method_type.block.type.return_type,
                 block_block_hint: nil,
                 block_annotations: block_annotations,
+                block_self_hint: method_type.block.self_type,
                 node_type_hint: method_type.type.return_type
               )
               block_constr = block_constr.with_new_typing(
@@ -3420,18 +3441,39 @@ module Steep
               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).to_ary
-
-                if param.type
-                  check_relation(sub_type: type, super_type: param.type, constraints: constraints).else do |result|
-                    error = Diagnostic::Ruby::IncompatibleAssignment.new(
-                      node: param.node,
-                      lhs_type: param.type,
-                      rhs_type: type,
-                      result: result
-                    )
-                    errors << error
+                case param
+                when TypeInference::BlockParams::Param
+                  _, block_constr = block_constr.synthesize(param.node, hint: param.type || type).to_ary
+
+                  if param.type
+                    check_relation(sub_type: type, super_type: param.type, constraints: constraints).else do |result|
+                      error = Diagnostic::Ruby::IncompatibleAssignment.new(
+                        node: param.node,
+                        lhs_type: param.type,
+                        rhs_type: type,
+                        result: result
+                      )
+                      errors << error
+                    end
                   end
+                when TypeInference::BlockParams::MultipleParam
+                  param.each_param do |p|
+                    _, block_constr = block_constr.synthesize(p.node, hint: p.type || type).to_ary
+
+                    if p.type
+                      check_relation(sub_type: type, super_type: p.type, constraints: constraints).else do |result|
+                        error = Diagnostic::Ruby::IncompatibleAssignment.new(
+                          node: p.node,
+                          lhs_type: p.type,
+                          rhs_type: type,
+                          result: result
+                        )
+                        errors << error
+                      end
+                    end
+                  end
+
+                  _, block_constr = block_constr.add_typing(param.node, type: type)
                 end
               end
 
@@ -3448,6 +3490,7 @@ module Steep
                 block_constr = block_constr.update_type_env {|env| env.subst(s) }
                 block_constr = block_constr.update_context {|context|
                   context.with(
+                    self_type: method_type.block&.self_type || context.self_type,
                     type_env: context.type_env.subst(s),
                     block_context: context.block_context&.subst(s),
                     break_context: context.break_context&.subst(s)
@@ -3460,6 +3503,18 @@ module Steep
                   block_type_hint: method_type.block.type.return_type
                 )
 
+                if method_type.block && method_type.block.self_type
+                  block_body_type = block_body_type.subst(
+                    Interface::Substitution.build(
+                      [],
+                      [],
+                      self_type: method_type.block.self_type,
+                      module_type: singleton_type(method_type.block.self_type) || AST::Builtin.top_type,
+                      instance_type: instance_type(method_type.block.self_type) || AST::Builtin.top_type
+                    )
+                  )
+                end
+
                 result = check_relation(sub_type: block_body_type,
                                         super_type: method_type.block.type.return_type,
                                         constraints: constraints)
@@ -3657,11 +3712,10 @@ module Steep
       end
     end
 
-    def type_check_argument(node, receiver_type:, type:, constraints:, report_node: node, errors:)
+    def type_check_argument(node, type:, constraints:, report_node: node, errors:)
       check(node, type, constraints: constraints) do |expected, actual, result|
         errors << Diagnostic::Ruby::ArgumentTypeMismatch.new(
             node: report_node,
-            receiver_type: receiver_type,
             expected: expected,
             actual: actual,
             result: result
@@ -3669,14 +3723,19 @@ module Steep
       end
     end
 
-    def type_block_without_hint(node:, block_annotations:, block_params:, block_body:, &block)
+    def type_block_without_hint(node:, block_annotations:, block_params:, block_body:)
       unless block_params
-        typing.add_error(
-          Diagnostic::Ruby::UnsupportedSyntax.new(
-            node: node.children[1],
-            message: "Unsupported block params pattern, probably masgn?"
-          )
-        )
+        Diagnostic::Ruby::UnsupportedSyntax.new(
+          node: node.children[1],
+          message: "Unsupported block params pattern, probably masgn?"
+        ).tap do |error|
+          if block_given?
+            yield error
+          else
+            typing.add_error(error)
+          end
+        end
+
         block_params = TypeInference::BlockParams.new(leading_params: [], optional_params: [], rest_param: nil, trailing_params: [], block_param: nil)
       end
 
@@ -3687,44 +3746,91 @@ module Steep
         block_type_hint: nil,
         block_block_hint: nil,
         block_annotations: block_annotations,
+        block_self_hint: nil,
         node_type_hint: nil
       )
 
       block_constr.typing.add_context_for_body(node, context: block_constr.context)
 
       block_params.params.each do |param|
-        _, block_constr = block_constr.synthesize(param.node, hint: param.type)
+        param.each_param do |param|
+          _, block_constr = block_constr.synthesize(param.node, hint: param.type)
+        end
       end
 
       block_type = block_constr.synthesize_block(node: node, block_type_hint: nil, block_body: block_body)
 
       if expected_block_type = block_constr.block_context.body_type
         block_constr.check_relation(sub_type: block_type, super_type: expected_block_type).else do |result|
-          block_constr.typing.add_error(
-            Diagnostic::Ruby::BlockBodyTypeMismatch.new(
-              node: node,
-              expected: expected_block_type,
-              actual: block_type,
-              result: result
-            )
-          )
+          Diagnostic::Ruby::BlockBodyTypeMismatch.new(
+            node: node,
+            expected: expected_block_type,
+            actual: block_type,
+            result: result
+          ).tap do |error|
+            if block_given?
+              yield error
+            else
+              block_constr.typing.add_error(error)
+            end
+          end
         end
       end
     end
 
-    def for_block(body_node, block_params:, block_param_hint:, block_type_hint:, block_block_hint:, block_annotations:, node_type_hint:)
-      block_param_pairs = block_param_hint && block_params.zip(block_param_hint, block_block_hint)
+    def set_up_block_mlhs_params_env(node, type, hash, &block)
+      if arrayish = try_convert_to_array(type)
+        masgn = TypeInference::MultipleAssignment.new()
+        assignments = masgn.expand(node, arrayish, false) or raise "#{arrayish} is expected to be array-ish"
+        assignments.leading_assignments.each do |pair|
+          node, type = pair
 
+          if node.type == :arg
+            hash[node.children[0]] = type
+          else
+            set_up_block_mlhs_params_env(node, type, hash, &block)
+          end
+        end
+      else
+        yield node, type
+      end
+    end
+
+    def for_block(body_node, block_params:, block_param_hint:, block_type_hint:, block_block_hint:, block_annotations:, node_type_hint:, block_self_hint:)
+      block_param_pairs = block_param_hint && block_params.zip(block_param_hint, block_block_hint, factory: checker.factory)
+
+      # @type var param_types_hash: Hash[Symbol, AST::Types::t]
       param_types_hash = {}
       if block_param_pairs
         block_param_pairs.each do |param, type|
-          var_name = param.var
-          param_types_hash[var_name] = type
+          case param
+          when TypeInference::BlockParams::Param
+            var_name = param.var
+            param_types_hash[var_name] = type
+          when TypeInference::BlockParams::MultipleParam
+            set_up_block_mlhs_params_env(param.node, type, param_types_hash) do |error_node, non_array_type|
+              Steep.logger.fatal { "`#{non_array_type}#to_ary` returns non-array-ish type" }
+              annotation_types = param.variable_types()
+              each_descendant_node(error_node) do |n|
+                if n.type == :arg
+                  name = n.children[0]
+                  param_types_hash[name] = annotation_types[name] || AST::Builtin.any_type
+                end
+              end
+            end
+          end
         end
       else
         block_params.each do |param|
-          var_name = param.var
-          param_types_hash[var_name] = param.type || AST::Builtin.any_type
+          case param
+          when TypeInference::BlockParams::Param
+            var_name = param.var
+            param_types_hash[var_name] = param.type || AST::Builtin.any_type
+          when TypeInference::BlockParams::MultipleParam
+            param.each_param do |p|
+              param_types_hash[p.var] = p.type || AST::Builtin.any_type
+            end
+          end
         end
       end
 
@@ -3742,6 +3848,19 @@ module Steep
       type_env = type_env.merge(local_variable_types: pins)
       type_env = type_env.merge(local_variable_types: param_types)
       type_env = TypeInference::TypeEnvBuilder.new(
+        if self_binding = block_annotations.self_type || block_self_hint
+          definition =
+            case self_binding
+            when AST::Types::Name::Instance
+              checker.factory.definition_builder.build_instance(self_binding.name)
+            when AST::Types::Name::Singleton
+              checker.factory.definition_builder.build_singleton(self_binding.name)
+            end
+
+          if definition
+            TypeInference::TypeEnvBuilder::Command::ImportInstanceVariableDefinition.new(definition, checker.factory)
+          end
+        end,
         TypeInference::TypeEnvBuilder::Command::ImportLocalVariableAnnotations.new(block_annotations).merge!.on_duplicate! do |name, outer_type, inner_type|
           next if outer_type.is_a?(AST::Types::Var) || inner_type.is_a?(AST::Types::Var)
           next unless body_node
@@ -3771,7 +3890,7 @@ module Steep
         next_type: block_context.body_type || AST::Builtin.any_type
       )
 
-      self_type = self.self_type
+      self_type = block_annotations.self_type || block_self_hint || self.self_type
       module_context = self.module_context
 
       if implements = block_annotations.implement_module_annotation
@@ -3828,6 +3947,44 @@ module Steep
       AST::Types::Union.build(types: types)
     end
 
+    def union_type_unify(*types)
+      types.inject do |type1, type2|
+        unless no_subtyping?(sub_type: type1, super_type: type2)
+          next type2
+        end
+
+        unless no_subtyping?(sub_type: type2, super_type: type1)
+          next type1
+        end
+
+        union_type(type1, type2)
+      end
+    end
+
+    def union_of_tuple_to_tuple_of_union(type)
+      if type.types.all? {|ty| ty.is_a?(AST::Types::Tuple) }
+        # @type var tuples: Array[AST::Types::Tuple]
+        tuples = _ = type.types
+
+        max = tuples.map {|tup| tup.types.size }.max or raise
+
+        # @type var tuple_types_array: Array[Array[AST::Types::t]]
+        tuple_types_array = tuples.map do |tup|
+          if tup.types.size == max
+            tup.types
+          else
+            tup.types + Array.new(max - tup.types.size, AST::Builtin.nil_type)
+          end
+        end
+
+        # @type var tuple_elems_array: Array[Array[AST::Types::t]]
+        tuple_elems_array = tuple_types_array.transpose
+        AST::Types::Tuple.new(
+          types: tuple_elems_array.map {|types| union_type_unify(*types) }
+        )
+      end
+    end
+
     def validate_method_definitions(node, module_name)
       module_name_1 = module_name.name
       member_decl_count = checker.factory.env.class_decls[module_name_1].decls.count {|d| d.decl.each_member.count > 0 }
@@ -3946,19 +4103,12 @@ module Steep
     end
 
     def unwrap(type)
-      expand_alias(type) do |expanded|
-        case
-        when expanded.is_a?(AST::Types::Union)
-          types = expanded.types.reject {|type| type.is_a?(AST::Types::Nil)}
-          AST::Types::Union.build(types: types)
-        else
-          type
-        end
-      end
+      truthy, _ = checker.factory.unwrap_optional(type)
+      truthy
     end
 
-    def deep_expand_alias(type, &block)
-      checker.factory.deep_expand_alias(type, &block)
+    def deep_expand_alias(type)
+      checker.factory.deep_expand_alias(type)
     end
 
     def flatten_union(type)
@@ -4030,44 +4180,101 @@ module Steep
       synthesize(node, hint: hint)
     end
 
-    def try_tuple_type(node, hint)
-      if hint
-        if node.children.size != hint.types.size
-          return
-        end
-      end
+    def try_tuple_type(array_node, hint)
+      raise unless array_node.type == :array
 
       constr = self
+      # @type var element_types: Array[AST::Types::t]
       element_types = []
 
-      each_child_node(node).with_index do |child, index|
-        child_hint = if hint
-                       hint.types[index]
-                     end
+      array_node.children.each_with_index do |child, index|
+        return if child.type == :splat
+
+        child_hint =
+          if hint
+            hint.types[index]
+          end
+
         type, constr = constr.synthesize(child, hint: child_hint)
         element_types << type
       end
 
-      constr.add_typing(node, type: AST::Types::Tuple.new(types: element_types))
+      constr.add_typing(array_node, type: AST::Types::Tuple.new(types: element_types))
     end
 
     def try_convert(type, method)
+      if shape = calculate_interface(type, private: false)
+        if entry = shape.methods[method]
+          method_type = entry.method_types.find do |method_type|
+            method_type.type.params.optional?
+          end
+
+          method_type.type.return_type if method_type
+        end
+      end
+    end
+
+    def try_convert_to_array(type)
+      if arrayish = arrayish_type?(type, untyped_is: true) || semantically_arrayish_type?(type)
+        arrayish
+      else
+        if converted = try_convert(type, :to_ary)
+          if arrayish_type?(converted, untyped_is: true) || semantically_arrayish_type?(type)
+            converted
+          end
+        else
+          AST::Types::Tuple.new(types: [type])
+        end
+      end
+    end
+
+    def arrayish_type?(type, untyped_is: false)
       case type
-      when AST::Types::Any, AST::Types::Bot, AST::Types::Top, AST::Types::Var
-        return
+      when AST::Types::Any
+        if untyped_is
+          type
+        end
+      when AST::Types::Name::Instance
+        if AST::Builtin::Array.instance_type?(type)
+          type
+        end
+      when AST::Types::Tuple
+        type
+      when AST::Types::Name::Alias
+        if t = checker.factory.deep_expand_alias(type)
+          arrayish_type?(t)
+        end
       end
+    end
 
-      interface = checker.factory.interface(type, private: false, self_type: self_type)
-      if entry = interface.methods[method]
-        method_type = entry.method_types.find do |method_type|
-          method_type.type.params.optional?
+    def semantically_arrayish_type?(type)
+      union = AST::Types::Union.build(types: flatten_union(type))
+      if union.is_a?(AST::Types::Union)
+        if tuple = union_of_tuple_to_tuple_of_union(union)
+          return tuple
         end
+      end
+
+      var = AST::Types::Var.fresh(:Elem)
+      array = AST::Builtin::Array.instance_type(var)
+      constraints = Subtyping::Constraints.new(unknowns: [])
+      constraints.add_var(var.name)
 
-        method_type.type.return_type if method_type
+      if (result = check_relation(sub_type: type, super_type: array, constraints: constraints)).success?
+        context = Subtyping::Constraints::Context.new(
+          variance: Subtyping::VariableVariance.from_type(union_type(type, var)),
+          self_type: self_type,
+          instance_type: module_context.instance_type,
+          class_type: module_context.module_type
+        )
+        subst = constraints.solution(
+          checker,
+          variables: type.free_variables + [var.name],
+          context: context
+        )
+
+        type.subst(subst)
       end
-    rescue => exn
-      Steep.log_error(exn, message: "Unexpected error when converting #{type.to_s} with #{method}")
-      nil
     end
 
     def try_array_type(node, hint)
@@ -4085,6 +4292,7 @@ module Steep
 
           case
           when AST::Builtin::Array.instance_type?(type)
+            type.is_a?(AST::Types::Name::Instance) or raise
             element_types << type.args[0]
           when type.is_a?(AST::Types::Tuple)
             element_types.push(*type.types)
@@ -4284,5 +4492,56 @@ module Steep
         end
       end
     end
+
+    def type_name(type)
+      case type
+      when AST::Types::Name::Instance, AST::Types::Name::Singleton
+        type.name
+      when AST::Types::Literal
+        type_name(type.back_type)
+      when AST::Types::Tuple
+        AST::Builtin::Array.module_name
+      when AST::Types::Record
+        AST::Builtin::Hash.module_name
+      when AST::Types::Proc
+        AST::Builtin::Proc.module_name
+      when AST::Types::Boolean, AST::Types::Logic::Base
+        nil
+      end
+    end
+
+    def singleton_type(type)
+      case type
+      when AST::Types::Union
+        AST::Types::Union.build(
+          types: type.types.map {|t| singleton_type(t) or return }
+        )
+      when AST::Types::Intersection
+        AST::Types::Intersection.build(
+          types: type.types.map {|t| singleton_type(t) or return }
+        )
+      else
+        if name = type_name(type)
+          AST::Types::Name::Singleton.new(name: name)
+        end
+      end
+    end
+
+    def instance_type(type)
+      case type
+      when AST::Types::Union
+        AST::Types::Union.build(
+          types: type.types.map {|t| instance_type(t) or return }
+        )
+      when AST::Types::Intersection
+        AST::Types::Intersection.build(
+          types: type.types.map {|t| instance_type(t) or return }
+        )
+      else
+        if name = type_name(type)
+          checker.factory.instance_type(name)
+        end
+      end
+    end
   end
 end