steep 0.44.1 → 0.45.0

data/lib/steep/source.rb

@@ -35,28 +35,25 @@ module Steep
 
       self.emit_lambda = true
       self.emit_procarg0 = true
+      self.emit_kwargs = true
     end
 
-    def self.parser
-      ::Parser::Ruby27.new(Builder.new).tap do |parser|
+    def self.new_parser
+      ::Parser::Ruby30.new(Builder.new).tap do |parser|
         parser.diagnostics.all_errors_are_fatal = true
         parser.diagnostics.ignore_warnings = true
       end
     end
 
     def self.parse(source_code, path:, factory:)
-      buffer = ::Parser::Source::Buffer.new(path.to_s, 1)
-      buffer.source = source_code
-      node = parser.parse(buffer)
+      buffer = ::Parser::Source::Buffer.new(path.to_s, 1, source: source_code)
+      node = new_parser().parse(buffer)
 
       annotations = []
 
       _, comments, _ = yield_self do
-        buffer = ::Parser::Source::Buffer.new(path.to_s)
-        buffer.source = source_code
-        parser = ::Parser::Ruby27.new
-
-        parser.tokenize(buffer)
+        buffer = ::Parser::Source::Buffer.new(path.to_s, 1, source: source_code)
+        new_parser().tokenize(buffer)
       end
 
       buffer = RBS::Buffer.new(name: path, content: source_code)

data/lib/steep/type_construction.rb

@@ -10,10 +10,7 @@ module Steep
       end
 
       def with(type: self.type, constr: self.constr)
-        self.class.new(
-          type: type,
-          constr: constr
-        )
+        self.class.new(type: type, constr: constr)
       end
 
       def +(other)
@@ -162,23 +159,6 @@ module Steep
 
       # constructor_method = method&.attributes&.include?(:constructor)
 
-      if method_type
-        var_types = TypeConstruction.parameter_types(args, method_type.type)
-        unless TypeConstruction.valid_parameter_env?(var_types, args.reject {|arg| arg.type == :blockarg}, method_type.type.params)
-          typing.add_error Diagnostic::Ruby::MethodArityMismatch.new(node: node, method_type: method_type)
-        end
-      end
-
-      if (block_arg = args.find {|arg| arg.type == :blockarg})
-        if method_type&.block
-          block_type = AST::Types::Proc.new(type: method_type.block.type, block: nil)
-          if method_type.block.optional?
-            block_type = AST::Types::Union.build(types: [block_type, AST::Builtin.nil_type])
-          end
-          var_types[block_arg.children[0]] = block_type
-        end
-      end
-
       super_method = if definition
                        if (this_method = definition.methods[method_name])
                          if module_context&.class_name == this_method.defined_in
@@ -219,13 +199,21 @@ module Steep
         class_type: module_context.module_type
       )
 
-      if var_types
-        lvar_env = lvar_env.update(
-          assigned_types: var_types.each.with_object({}) {|(var, type), hash|
-            arg_node = args.find {|arg| arg.children[0] == var }
-            hash[var] = TypeInference::LocalVariableTypeEnv::Entry.new(type: type, nodes: [arg_node].compact)
-          }
-        )
+      method_params =
+        if method_type
+          TypeInference::MethodParams.build(node: node, method_type: method_type)
+        else
+          TypeInference::MethodParams.empty(node: node)
+        end
+
+      method_params.each_param do |param|
+        lvar_env = lvar_env.assign(param.name, type: param.var_type, node: param.node) {
+          raise "Unexpected assignment error: #{param.name}"
+        }
+      end
+
+      method_params.errors.each do |error|
+        typing.add_error error
       end
 
       lvar_env = lvar_env.annotate(annots)
@@ -692,7 +680,7 @@ module Steep
     end
 
     def synthesize(node, hint: nil, condition: false)
-      Steep.logger.tagged "synthesize:(#{node.location.expression.to_s.split(/:/, 2).last})" do
+      Steep.logger.tagged "synthesize:(#{node.location&.yield_self {|loc| loc.expression.to_s.split(/:/, 2).last } || "-"})" do
         Steep.logger.debug node.type
         case node.type
         when :begin, :kwbegin
@@ -732,8 +720,17 @@ module Steep
             when :__skip__
               add_typing(node, type: AST::Builtin.any_type)
             else
-              if !hint || hint.is_a?(AST::Types::Void)
-                hint = context.lvar_env.declared_types[name]&.type
+              if declared_type = context.lvar_env.declared_types[name]&.type
+                case hint
+                when nil
+                  hint = declared_type
+                else
+                  if check_relation(sub_type: declared_type, super_type: hint).success?
+                    # declared_type is compatible with hint and more specific to hint.
+                    # This typically happens when hint is untyped, top, or void.
+                    hint = declared_type
+                  end
+                end
               end
 
               rhs_result = synthesize(rhs, hint: hint)
@@ -751,7 +748,7 @@ module Steep
                 end
               end
 
-              add_typing(node, type: rhs_result.type, constr: constr)
+              constr.add_typing(node, type: rhs_result.type)
             end
           end
 
@@ -888,13 +885,12 @@ module Steep
                     checker.factory.method_type(method_type, self_type: self_type, method_decls: Set[decl])
                   }
                 )
-                args = TypeInference::SendArgs.from_nodes(node.children.dup)
 
                 call, constr = type_method_call(node,
                                                 receiver_type: self_type,
                                                 method_name: method_context.name,
                                                 method: super_method,
-                                                args: args,
+                                                arguments: node.children,
                                                 block_params: nil,
                                                 block_body: nil,
                                                 topdown_hint: true)
@@ -940,6 +936,25 @@ module Steep
             end
           end
 
+        when :numblock
+          yield_self do
+            send_node, max_num, body = node.children
+
+            if max_num == 1
+              arg_nodes = [Parser::AST::Node.new(:procarg0, [:_1])]
+            else
+              arg_nodes = max_num.times.map {|i| Parser::AST::Node.new(:arg, [:"_#{i+1}"]) }
+            end
+
+            params = Parser::AST::Node.new(:args, arg_nodes)
+
+            if send_node.type == :lambda
+              type_lambda(node, block_params: params, block_body: body, type_hint: hint)
+            else
+              type_send(node, send_node: send_node, block_params: params, block_body: body, unwrap: send_node.type == :csend)
+            end
+          end
+
         when :def
           yield_self do
             name, args_node, body_node = node.children
@@ -999,10 +1014,13 @@ module Steep
                         end
 
             if body_node
-              begin_pos = body_node.loc.expression.end_pos
-              end_pos = node.loc.end.begin_pos
-
-              typing.add_context(begin_pos..end_pos, context: body_pair.context)
+              # Add context to ranges from the end of the method body to the beginning of the `end` keyword
+              if node.loc.end
+                # Skip end-less def
+                begin_pos = body_node.loc.expression.end_pos
+                end_pos = node.loc.end.begin_pos
+                typing.add_context(begin_pos..end_pos, context: body_pair.context)
+              end
             end
 
             if module_context
@@ -1143,15 +1161,16 @@ module Steep
                   )
                 end
               else
-                check_relation(sub_type: AST::Builtin.nil_type, super_type: break_type).else do |result|
-                  typing.add_error(
-                    Diagnostic::Ruby::BreakTypeMismatch.new(
-                      node: node,
-                      expected: break_type,
-                      actual: AST::Builtin.nil_type,
-                      result: result
+                unless break_type.is_a?(AST::Types::Bot)
+                  check_relation(sub_type: AST::Builtin.nil_type, super_type: break_type).else do |result|
+                    typing.add_error(
+                      Diagnostic::Ruby::ImplicitBreakValueMismatch.new(
+                        node: node,
+                        jump_type: break_type,
+                        result: result
+                      )
                     )
-                  )
+                  end
                 end
               end
             else
@@ -1363,52 +1382,20 @@ module Steep
             add_typing(node, type: AST::Types::Boolean.new)
           end
 
-        when :hash
-          yield_self do
-            ty = try_hash_type(node, hint) and return ty
-
-            if AST::Builtin::Hash.instance_type?(hint)
-              key_hint = hint.args[0]
-              value_hint = hint.args[1]
-            end
-
-            key_types = []
-            value_types = []
-
-            each_child_node(node) do |child|
-              case child.type
-              when :pair
-                key, value = child.children
-                key_types << synthesize(key, hint: key_hint).type.yield_self do |type|
-                  select_super_type(type, key_hint)
-                end
-                value_types << synthesize(value, hint: value_hint).type.yield_self do |type|
-                  select_super_type(type, value_hint)
-                end
-              when :kwsplat
-                expand_alias(synthesize(child.children[0]).type) do |splat_type, original_type|
-                  if AST::Builtin::Hash.instance_type?(splat_type)
-                    key_types << splat_type.args[0]
-                    value_types << splat_type.args[1]
-                  else
-                    typing.add_error Diagnostic::Ruby::UnexpectedSplat.new(node: child, type: original_type)
-                    key_types << AST::Builtin.any_type
-                    value_types << AST::Builtin.any_type
-                  end
-                end
+        when :hash, :kwargs
+          # :kwargs happens for method calls with keyword argument, but the method doesn't have keyword params.
+          # Conversion from kwargs to hash happens, and this when-clause is to support it.
+          type_hash(node, hint: hint).tap do |pair|
+            if pair.type == AST::Builtin::Hash.instance_type(fill_untyped: true)
+              case hint
+              when AST::Types::Any, AST::Types::Top, AST::Types::Void
+                # ok
+              when hint == pair.type
+                # ok
               else
-                raise "Unexpected non pair: #{child.inspect}" unless child.type == :pair
+                pair.constr.typing.add_error Diagnostic::Ruby::FallbackAny.new(node: node)
               end
             end
-
-            key_type = key_types.empty? ? AST::Builtin.any_type : AST::Types::Union.build(types: key_types)
-            value_type = value_types.empty? ? AST::Builtin.any_type : AST::Types::Union.build(types: value_types)
-
-            if key_types.empty? && value_types.empty? && !hint
-              typing.add_error Diagnostic::Ruby::FallbackAny.new(node: node)
-            end
-
-            add_typing(node, type: AST::Builtin::Hash.instance_type(key_type, value_type))
           end
 
         when :dstr, :xstr
@@ -1683,8 +1670,7 @@ module Steep
                 tuples.each do |tuple|
                   typing.new_child(node_range) do |child_typing|
                     if pair = with_new_typing(child_typing).try_tuple_type(node, tuple)
-                      child_typing.save!
-                      return pair.with(constr: pair.constr.with_new_typing(typing))
+                      return pair.with(constr: pair.constr.save_typing)
                     end
                   end
                 end
@@ -1695,8 +1681,7 @@ module Steep
                   typing.new_child(node_range) do |child_typing|
                     pair = with_new_typing(child_typing).try_array_type(node, array)
                     if pair.constr.check_relation(sub_type: pair.type, super_type: hint).success?
-                      child_typing.save!
-                      return pair.with(constr: pair.constr.with_new_typing(typing))
+                      return pair.with(constr: pair.constr.save_typing)
                     end
                   end
                 end
@@ -2291,7 +2276,9 @@ module Steep
                     unless return_types.empty?
                       type = AST::Types::Proc.new(
                         type: Interface::Function.new(
-                          params: Interface::Function::Params.empty.update(required: [param_type]),
+                          params: Interface::Function::Params.empty.with_first_param(
+                            Interface::Function::Params::PositionalParams::Required.new(param_type)
+                          ),
                           return_type: AST::Types::Union.build(types: return_types),
                           location: nil
                         ),
@@ -2389,6 +2376,7 @@ module Steep
 
         else
           typing.add_error(Diagnostic::Ruby::UnsupportedSyntax.new(node: node))
+          add_typing(node, type: AST::Builtin.any_type)
 
         end.tap do |pair|
           unless pair.is_a?(Pair) && !pair.type.is_a?(Pair)
@@ -2738,11 +2726,10 @@ module Steep
       method = interface.methods[method_name]
 
       if method
-        args = TypeInference::SendArgs.from_nodes(arguments)
         call, constr = type_method_call(node,
                                         method: method,
                                         method_name: method_name,
-                                        args: args,
+                                        arguments: arguments,
                                         block_params: block_params,
                                         block_body: block_body,
                                         receiver_type: receiver_type,
@@ -2922,27 +2909,22 @@ module Steep
       end
     end
 
-    def type_method_call(node, method_name:, receiver_type:, method:, args:, block_params:, block_body:, topdown_hint:)
+    def type_method_call(node, method_name:, receiver_type:, method:, arguments:, block_params:, block_body:, topdown_hint:)
       node_range = node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }
 
-      results = method.method_types.flat_map do |method_type|
+      results = method.method_types.map do |method_type|
         Steep.logger.tagged method_type.to_s do
-          zips = args.zips(method_type.type.params, method_type.block&.type)
-
-          zips.map do |arg_pairs|
-            typing.new_child(node_range) do |child_typing|
-              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,
-                topdown_hint: topdown_hint
-              )
-            end
+          typing.new_child(node_range) do |child_typing|
+            self.with_new_typing(child_typing).try_method_type(
+              node,
+              receiver_type: receiver_type,
+              method_name: method_name,
+              method_type: method_type,
+              arguments: arguments,
+              block_params: block_params,
+              block_body: block_body,
+              topdown_hint: topdown_hint
+            )
           end
         end
       end
@@ -2982,138 +2964,34 @@ module Steep
       ]
     end
 
-    def check_keyword_arg(receiver_type:, node:, method_type:, constraints:)
-      params = method_type.type.params
-
-      case node.type
-      when :hash
-        keyword_hash_type = AST::Builtin::Hash.instance_type(AST::Builtin::Symbol.instance_type,
-                                                             AST::Builtin.any_type)
-        add_typing node, type: keyword_hash_type
-
-        given_keys = Set.new()
-
-        node.children.each do |element|
-          case element.type
-          when :pair
-            key_node, value_node = element.children
-
-            case key_node.type
-            when :sym
-              key_symbol = key_node.children[0]
-              keyword_type = case
-                             when params.required_keywords.key?(key_symbol)
-                               params.required_keywords[key_symbol]
-                             when params.optional_keywords.key?(key_symbol)
-                               AST::Types::Union.build(
-                                 types: [params.optional_keywords[key_symbol],
-                                         AST::Builtin.nil_type]
-                               )
-                             when params.rest_keywords
-                               params.rest_keywords
-                             end
-
-              add_typing key_node, type: AST::Builtin::Symbol.instance_type
-
-              given_keys << key_symbol
-
-              if keyword_type
-                check(value_node, keyword_type, constraints: constraints) do |expected, actual, result|
-                  return Diagnostic::Ruby::IncompatibleAssignment.new(
-                    node: value_node,
-                    lhs_type: expected,
-                    rhs_type: actual,
-                    result: result
-                  )
-                end
-              else
-                synthesize(value_node)
-              end
-
-            else
-              check(key_node, AST::Builtin::Symbol.instance_type, constraints: constraints) do |expected, actual, result|
-                return Diagnostic::Ruby::IncompatibleAssignment.new(
-                  node: key_node,
-                  lhs_type: expected,
-                  rhs_type: actual,
-                  result: result
-                )
-              end
-            end
-
-          when :kwsplat
-            Steep.logger.warn("Keyword arg with kwsplat(**) node are not supported.")
-
-            check(element.children[0], keyword_hash_type, constraints: constraints) do |expected, actual, result|
-              return Diagnostic::Ruby::IncompatibleAssignment.new(
-                node: node,
-                lhs_type: expected,
-                rhs_type: actual,
-                result: result
-              )
-            end
+    def inspect
+      "#<#{self.class}>"
+    end
 
-            given_keys = true
-          end
-        end
+    def with_child_typing(range:)
+      constr = with_new_typing(typing.new_child(range: range))
 
-        case given_keys
-        when Set
-          missing_keywords = Set.new(params.required_keywords.keys) - given_keys
-          unless missing_keywords.empty?
-            return Diagnostic::Ruby::MissingKeyword.new(
-              node: node,
-              missing_keywords: missing_keywords
-            )
-          end
-
-          extra_keywords = given_keys - Set.new(params.required_keywords.keys) - Set.new(params.optional_keywords.keys)
-          if extra_keywords.any? && !params.rest_keywords
-            return Diagnostic::Ruby::UnexpectedKeyword.new(
-              node: node,
-              unexpected_keywords: extra_keywords
-            )
-          end
-        end
+      if block_given?
+        yield constr
       else
-        if params.rest_keywords
-          Steep.logger.warn("Method call with rest keywords type is detected. Rough approximation to be improved.")
-
-          value_types = params.required_keywords.values +
-            params.optional_keywords.values.map {|type| AST::Types::Union.build(types: [type, AST::Builtin.nil_type])} +
-            [params.rest_keywords]
-
-          hash_type = AST::Builtin::Hash.instance_type(
-            AST::Builtin::Symbol.instance_type,
-            AST::Types::Union.build(types: value_types)
-          )
-        else
-          hash_elements = params.required_keywords.merge(
-            params.optional_keywords.transform_values do |type|
-              AST::Types::Union.build(types: [type, AST::Builtin.nil_type])
-            end
-          )
-
-          hash_type = AST::Types::Record.new(elements: hash_elements)
-        end
+        constr
+      end
+    end
 
-        node_type = synthesize(node, hint: hash_type).type
+    # Bypass :splat and :kwsplat
+    def bypass_splat(node)
+      splat = node.type == :splat || node.type == :kwsplat
 
-        check_relation(sub_type: node_type, super_type: hash_type).else do |result|
-          return Diagnostic::Ruby::ArgumentTypeMismatch.new(
-            node: node,
-            receiver_type: receiver_type,
-            expected: hash_type,
-            actual: node_type,
-            result: result
-          )
-        end
+      if splat
+        pair = yield(node.children[0])
+        pair.constr.add_typing(node, type: pair.type)
+        pair
+      else
+        yield node
       end
-
-      nil
     end
 
-    def try_method_type(node, receiver_type:, method_name:, method_type:, args:, arg_pairs:, block_params:, block_body:, topdown_hint:)
+    def try_method_type(node, receiver_type:, method_name:, method_type:, arguments:, 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)
@@ -3128,38 +3006,90 @@ module Steep
 
       errors = []
 
-      arg_pairs.each do |pair|
-        case pair
-        when Array
-          arg_node, param_type = pair
-          param_type = param_type.subst(instantiation)
+      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
+          )
 
-          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
+        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
 
-          check_relation(sub_type: arg_type, super_type: param_type, constraints: constraints).else do |result|
-            errors << Diagnostic::Ruby::ArgumentTypeMismatch.new(node: arg_node,
-                                                                 receiver_type: receiver_type,
-                                                                 expected: param_type,
-                                                                 actual: arg_type,
-                                                                 result: result)
+        when TypeInference::SendArgs::PositionalArgs::UnexpectedArg
+          _, constr = bypass_splat(arg.node) do |n|
+            constr.synthesize(n)
           end
-        else
-          # keyword
-          result = constr.check_keyword_arg(receiver_type: receiver_type,
-                                            node: pair,
-                                            method_type: method_type,
-                                            constraints: constraints)
 
-          if result.is_a?(Diagnostic::Ruby::Base)
-            errors << result
+        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)
+
       if block_params
         # block is given
         block_annotations = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
@@ -3302,108 +3232,105 @@ module Steep
           )
         end
       else
-        # block is not given
-        if !method_type.block
-          # Method doesn't accept blocks
-          unless args.block_pass_arg
-            # OK, without block
-            s = constraints.solution(
+        arg = args.block_pass_arg
+
+        case
+        when arg.compatible?
+          if arg.node
+            subst = constraints.solution(
               checker,
-              variance: variance,
-              variables: fresh_vars,
               self_type: self_type,
               instance_type: module_context.instance_type,
-              class_type: module_context.module_type
+              class_type: module_context.module_type,
+              variance: variance,
+              variables: occurence.params
             )
-            method_type = method_type.subst(s)
-          else
-            # &block arg is given
-            s = constraints.solution(
+
+            block_type = arg.node_type.subst(subst)
+
+            node_type, constr = constr.synthesize(arg.node, hint: block_type)
+            nil_block =
+              constr.check_relation(sub_type: node_type, super_type: AST::Builtin.nil_type).success? &&
+                !node_type.is_a?(AST::Types::Any)
+
+            unless nil_block
+              constr.check_relation(sub_type: node_type, super_type: block_type, constraints: constraints).else do |result|
+                errors << Diagnostic::Ruby::BlockTypeMismatch.new(
+                  node: arg.node,
+                  expected: block_type,
+                  actual: node_type,
+                  result: result
+                )
+              end
+            end
+
+            subst = constraints.solution(
               checker,
-              variance: variance,
-              variables: fresh_vars,
               self_type: self_type,
               instance_type: module_context.instance_type,
-              class_type: module_context.module_type
+              class_type: module_context.module_type,
+              variance: variance,
+              variables: method_type.free_variables
             )
-            method_type = method_type.subst(s)
 
-            type, constr = constr.synthesize(args.block_pass_arg, hint: AST::Builtin.nil_type)
-            type = expand_alias(type)
-            unless type.is_a?(AST::Types::Nil)
-              errors << Diagnostic::Ruby::UnexpectedBlockGiven.new(
-                node: node,
-                method_type: method_type
-              )
-            end
-          end
-        else
-          # Method accepts block
-          if !args.block_pass_arg
-            # Block pass is not given
-            if method_type.block.required?
-              # Required block is missing
+            method_type = method_type.subst(subst)
+
+            if nil_block && arg.block.required?
+              # Passing no block
               errors << Diagnostic::Ruby::RequiredBlockMissing.new(
                 node: node,
                 method_type: method_type
               )
             end
-
-            s = constraints.solution(
+          else
+            subst = constraints.solution(
               checker,
-              variance: variance,
-              variables: fresh_vars,
               self_type: self_type,
               instance_type: module_context.instance_type,
-              class_type: module_context.module_type
+              class_type: module_context.module_type,
+              variance: variance,
+              variables: method_type.free_variables
             )
-            method_type = method_type.subst(s)
-          else
-            begin
-              method_type = method_type.subst(
-                constraints.solution(
-                  checker,
-                  self_type: self_type,
-                  instance_type: module_context.instance_type,
-                  class_type: module_context.module_type,
-                  variance: variance,
-                  variables: occurence.params
-                )
-              )
-              hint_type = if topdown_hint
-                            AST::Types::Proc.new(type: method_type.block.type, block: nil)
-                          end
-              given_block_type, constr = constr.synthesize(args.block_pass_arg, hint: hint_type)
-              method_block_type = method_type.block.yield_self {|expected_block|
-                proc_type = AST::Types::Proc.new(type: expected_block.type, block: nil)
-                if expected_block.optional?
-                  AST::Builtin.optional(proc_type)
-                else
-                  proc_type
-                end
-              }
 
-              result = check_relation(sub_type: given_block_type, super_type: method_block_type, constraints: constraints)
-              result.else do |result|
-                errors << Diagnostic::Ruby::BlockTypeMismatch.new(
-                  node: args.block_pass_arg,
-                  expected: method_block_type,
-                  actual: given_block_type,
-                  result: result
-                )
-              end
+            method_type = method_type.subst(subst)
+          end
 
-              method_type = method_type.subst(
-                constraints.solution(
-                  checker,
-                  self_type: self_type,
-                  instance_type: module_context.instance_type,
-                  class_type: module_context.module_type,
-                  variance: variance,
-                  variables: method_type.free_variables
-                )
-              )
-            end
+        when arg.block_missing?
+          subst = constraints.solution(
+            checker,
+            self_type: self_type,
+            instance_type: module_context.instance_type,
+            class_type: module_context.module_type,
+            variance: variance,
+            variables: method_type.free_variables
+          )
+
+          method_type = method_type.subst(subst)
+
+          errors << Diagnostic::Ruby::RequiredBlockMissing.new(
+            node: node,
+            method_type: method_type
+          )
+
+        when arg.unexpected_block?
+          subst = constraints.solution(
+            checker,
+            self_type: self_type,
+            instance_type: module_context.instance_type,
+            class_type: module_context.module_type,
+            variance: variance,
+            variables: method_type.free_variables
+          )
+
+          method_type = method_type.subst(subst)
+
+          node_type, constr = constr.synthesize(arg.node)
+
+          unless constr.check_relation(sub_type: node_type, super_type: AST::Builtin.nil_type).success?
+            errors << Diagnostic::Ruby::UnexpectedBlockGiven.new(
+              node: node,
+              method_type: method_type
+            )
           end
         end
       end
@@ -3436,6 +3363,18 @@ module Steep
       ]
     end
 
+    def type_check_argument(node, receiver_type:, 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
+          )
+      end
+    end
+
     def type_block_without_hint(node:, block_annotations:, block_params:, block_body:, &block)
       unless block_params
         typing.add_error(
@@ -3576,68 +3515,6 @@ module Steep
       end
     end
 
-    def self.parameter_types(nodes, type)
-      nodes = nodes.dup
-
-      env = {}
-
-      type.params.required.each do |type|
-        a = nodes.first
-        if a&.type == :arg
-          env[a.children.first] = type
-          nodes.shift
-        else
-          break
-        end
-      end
-
-      type.params.optional.each do |type|
-        a = nodes.first
-
-        if a&.type == :optarg
-          env[a.children.first] = type
-          nodes.shift
-        else
-          break
-        end
-      end
-
-      if type.params.rest
-        a = nodes.first
-        if a&.type == :restarg
-          env[a.children.first] = AST::Builtin::Array.instance_type(type.params.rest)
-          nodes.shift
-        end
-      end
-
-      nodes.each do |node|
-        if node.type == :kwarg
-          name = node.children[0]
-          ty = type.params.required_keywords[name]
-          env[name] = ty if ty
-        end
-
-        if node.type == :kwoptarg
-          name = node.children[0]
-          ty = type.params.optional_keywords[name]
-          env[name] = ty if ty
-        end
-
-        if node.type == :kwrestarg
-          ty = type.params.rest_keywords
-          if ty
-            env[node.children[0]] = AST::Builtin::Hash.instance_type(AST::Builtin::Symbol.instance_type, ty)
-          end
-        end
-      end
-
-      env
-    end
-
-    def self.valid_parameter_env?(env, nodes, params)
-      env.size == nodes.size && env.size == params.size
-    end
-
     def current_namespace
       module_context&.current_namespace || AST::Namespace.root
     end
@@ -3745,25 +3622,6 @@ module Steep
       end
     end
 
-    def flatten_const_name(node)
-      path = []
-
-      while node
-        case node.type
-        when :const, :casgn
-          path.unshift(node.children[1])
-          node = node.children[0]
-        when :cbase
-          path.unshift("")
-          break
-        else
-          return nil
-        end
-      end
-
-      path.join("::").to_sym
-    end
-
     def fallback_to_any(node)
       if block_given?
         typing.add_error yield
@@ -3805,16 +3663,6 @@ module Steep
       Pair.new(type: AST::Builtin.any_type, constr: self)
     end
 
-    def fallback_any_rec(node)
-      fallback_to_any(node) unless typing.has_type?(node)
-
-      each_child_node(node) do |child|
-        fallback_any_rec(child)
-      end
-
-      typing.type_of(node: node)
-    end
-
     def unwrap(type)
       expand_alias(type) do |expanded|
         case
@@ -3827,19 +3675,6 @@ module Steep
       end
     end
 
-    def self.value_variables(node)
-      case node&.type
-      when :lvar
-        Set.new([node.children.first])
-      when :lvasgn
-        Set.new([node.children.first]) + value_variables(node.children[1])
-      when :begin
-        value_variables(node.children.last)
-      else
-        Set.new
-      end
-    end
-
     def deep_expand_alias(type, &block)
       checker.factory.deep_expand_alias(type, &block)
     end
@@ -3886,24 +3721,6 @@ module Steep
       end
     end
 
-    def select_super_type(sub_type, super_type)
-      if super_type
-        result = check_relation(sub_type: sub_type, super_type: super_type)
-
-        if result.success?
-          super_type
-        else
-          if block_given?
-            yield result
-          else
-            sub_type
-          end
-        end
-      else
-        sub_type
-      end
-    end
-
     def to_instance_type(type, args: nil)
       args = args || case type
                      when AST::Types::Name::Singleton
@@ -3915,16 +3732,35 @@ module Steep
       AST::Types::Name::Instance.new(name: type.name, args: args)
     end
 
+    def try_tuple_type!(node, hint: nil)
+      if node.type == :array && (hint.nil? || hint.is_a?(AST::Types::Tuple))
+        node_range = node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }
+
+        typing.new_child(node_range) do |child_typing|
+          if pair = with_new_typing(child_typing).try_tuple_type(node, hint)
+            return pair.with(constr: pair.constr.save_typing)
+          end
+        end
+      end
+
+      synthesize(node, hint: hint)
+    end
+
     def try_tuple_type(node, hint)
-      if node.children.size != hint.types.size
-        return
+      if hint
+        if node.children.size != hint.types.size
+          return
+        end
       end
 
       constr = self
       element_types = []
 
       each_child_node(node).with_index do |child, index|
-        type, constr = constr.synthesize(child, hint: hint.types[index])
+        child_hint = if hint
+                       hint.types[index]
+                     end
+        type, constr = constr.synthesize(child, hint: child_hint)
         element_types << type
       end
 
@@ -3956,55 +3792,152 @@ module Steep
       constr.add_typing(node, type: AST::Builtin::Array.instance_type(element_type))
     end
 
-    def try_hash_type(node, hint)
-      hint = expand_alias(hint)
+    # Try to give record type to hash_node.
+    #
+    # Returns nil when it cannot have a record type.
+    # `record_type` can be nil when the keys are not specified.
+    #
+    def type_hash_record(hash_node, record_type)
+      raise unless hash_node.type == :hash
+
+      constr = self
+
+      if record_type
+        elements = record_type.elements.dup
+      else
+        elements = {}
+      end
+
+      elems = {}
+
+      each_child_node(hash_node) do |child|
+        if child.type == :pair
+          case child.children[0].type
+          when :sym, :str, :int
+            key_node = child.children[0]
+            value_node = child.children[1]
+
+            key = key_node.children[0]
+
+            _, constr = constr.synthesize(key_node, hint: AST::Types::Literal.new(value: key))
+            value_type, constr = constr.synthesize(value_node, hint: elements[key])
+
+            elems[key] = value_type
+          else
+            return
+          end
+        else
+          return
+        end
+      end
+
+      type = AST::Types::Record.new(elements: elems)
+      constr.add_typing(hash_node, type: type)
+    end
+
+    # Give hash_node a type based on hint.
+    #
+    # * When hint is Record type, it may have record type.
+    # * When hint is union type, it tries recursively with the union cases.
+    # * Otherwise, it tries to be a hash instance.
+    #
+    def type_hash(hash_node, hint:)
+      hint = deep_expand_alias(hint)
+      range = hash_node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }
 
       case hint
       when AST::Types::Record
-        typing.new_child(node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }) do |child_typing|
-          new_construction = with_new_typing(child_typing)
-          elements = {}
+        with_child_typing(range: range) do |constr|
+          pair = constr.type_hash_record(hash_node, hint)
+          if pair
+            return pair.with(constr: pair.constr.save_typing)
+          end
+        end
+      when AST::Types::Union
+        pair = pick_one_of(hint.types, range: range) do |type, constr|
+          constr.type_hash(hash_node, hint: type)
+        end
 
-          each_child_node(node) do |child|
-            case child.type
-            when :pair
-              key, value = child.children
+        if pair
+          return pair
+        end
+      end
 
-              key_value = case key.type
-                          when :str, :int, :sym
-                            key.children[0]
-                          else
-                            return nil
-                          end
+      key_types = []
+      value_types = []
 
-              value_hint = hint.elements[key_value]
-              value_type = new_construction.synthesize(value, hint: value_hint).type
+      if AST::Builtin::Hash.instance_type?(hint)
+        key_hint, value_hint = hint.args
+      end
 
-              if value_hint
-                if check_relation(sub_type: value_type, super_type: value_hint).success?
-                  value_type = value_hint
-                end
+      hint_hash = AST::Builtin::Hash.instance_type(
+        key_hint || AST::Builtin.any_type,
+        value_hint || AST::Builtin.any_type
+      )
+
+      constr = self
+
+      if hash_node.children.empty?
+        key_types << key_hint if key_hint
+        value_types << value_hint if value_hint
+      else
+        hash_node.children.each do |elem|
+          case elem.type
+          when :pair
+            key_node, value_node = elem.children
+            key_type, constr = constr.synthesize(key_node, hint: key_hint)
+            value_type, constr = constr.synthesize(value_node, hint: value_hint)
+
+            key_types << key_type
+            value_types << value_type
+          when :kwsplat
+            bypass_splat(elem) do |elem_|
+              pair = constr.synthesize(elem_, hint: hint_hash)
+
+              if AST::Builtin::Hash.instance_type?(pair.type)
+                key_types << pair.type.args[0]
+                value_types << pair.type.args[1]
               end
 
-              elements[key_value] = value_type
-            else
-              return nil
+              pair
             end
+          else
+            raise
           end
+        end
+      end
 
-          child_typing.save!
+      key_types.reject! {|ty| ty.is_a?(AST::Types::Any) }
+      value_types.reject! {|ty| ty.is_a?(AST::Types::Any) }
 
-          hash = AST::Types::Record.new(elements: elements)
-          add_typing(node, type: hash)
-        end
-      when AST::Types::Union
-        hint.types.each do |type|
-          if pair = try_hash_type(node, type)
-            return pair
+      key_types << AST::Builtin.any_type if key_types.empty?
+      value_types << AST::Builtin.any_type if value_types.empty?
+
+      hash_type = AST::Builtin::Hash.instance_type(
+        AST::Types::Union.build(types: key_types),
+        AST::Types::Union.build(types: value_types)
+      )
+      constr.add_typing(hash_node, type: hash_type)
+    end
+
+    def pick_one_of(types, range:)
+      types.each do |type|
+        with_child_typing(range: range) do |constr|
+          type_, constr = yield type, constr
+
+          constr.check_relation(sub_type: type_, super_type: type).then do
+            constr = constr.save_typing
+            return Pair.new(type: type, constr: constr)
           end
         end
-        nil
       end
+
+      nil
+    end
+
+    def save_typing
+      typing.save!
+      with_new_typing(typing.parent)
     end
   end
 end