steep 1.4.0 → 1.5.0.pre.1

data/lib/steep/type_construction.rb

@@ -877,10 +877,6 @@ module Steep
           yield_self do
             if self_type && method_context!.method
               if super_def = method_context!.super_method
-                each_child_node(node) do |child|
-                  synthesize(child)
-                end
-
                 super_method = Interface::Shape::Entry.new(
                   method_types: super_def.defs.map {|type_def|
                     decl = TypeInference::MethodCall::MethodDecl.new(
@@ -902,7 +898,8 @@ module Steep
                   arguments: node.children,
                   block_params: nil,
                   block_body: nil,
-                  tapp: nil
+                  tapp: nil,
+                  hint: hint
                 )
 
                 if call && constr
@@ -927,12 +924,12 @@ module Steep
                   fallback_to_any(node) { error }
                 end
               else
-                fallback_to_any node do
+                type_check_untyped_args(node.children).fallback_to_any(node) do
                   Diagnostic::Ruby::UnexpectedSuper.new(node: node, method: method_context!.name)
                 end
               end
             else
-              fallback_to_any node
+              type_check_untyped_args(node.children).fallback_to_any(node)
             end
           end
 
@@ -949,47 +946,75 @@ module Steep
               self_type: module_context&.instance_type,
               definition: module_context&.instance_definition
             ) do |new|
+              # @type var new: TypeConstruction
+
               new.typing.add_context_for_node(node, context: new.context)
               new.typing.add_context_for_body(node, context: new.context)
 
-              new.method_context.tap do |method_context|
+              new.method_context!.tap do |method_context|
                 if method_context.method
-                  method_name = InstanceMethodName.new(type_name: method_context.method.implemented_in, method_name: name)
-                  new.typing.source_index.add_definition(method: method_name, definition: node)
+                  if owner = method_context.method.implemented_in || method_context.method.defined_in
+                    method_name = InstanceMethodName.new(type_name: owner, method_name: name)
+                    new.typing.source_index.add_definition(method: method_name, definition: node)
+                  end
                 end
               end
 
               new = new.synthesize_children(args_node)
 
               body_pair = if body_node
-                            return_type = expand_alias(new.method_context&.return_type)
-                            if return_type && !return_type.is_a?(AST::Types::Void)
+                            return_type = expand_alias(new.method_context!.return_type)
+                            if !return_type.is_a?(AST::Types::Void)
                               new.check(body_node, return_type) do |_, actual_type, result|
-                                typing.add_error(
-                                  Diagnostic::Ruby::MethodBodyTypeMismatch.new(
-                                    node: node,
-                                    expected: new.method_context&.return_type,
-                                    actual: actual_type,
-                                    result: result
+                                if new.method_context!.attribute_setter?
+                                  typing.add_error(
+                                    Diagnostic::Ruby::SetterBodyTypeMismatch.new(
+                                      node: node,
+                                      expected: new.method_context!.return_type,
+                                      actual: actual_type,
+                                      result: result,
+                                      method_name: new.method_context!.name
+                                    )
                                   )
-                                )
+                                else
+                                  typing.add_error(
+                                    Diagnostic::Ruby::MethodBodyTypeMismatch.new(
+                                      node: node,
+                                      expected: new.method_context!.return_type,
+                                      actual: actual_type,
+                                      result: result
+                                    )
+                                  )
+                                end
                               end
                             else
                               new.synthesize(body_node)
                             end
                           else
-                            return_type = expand_alias(new.method_context&.return_type)
-                            if return_type && !return_type.is_a?(AST::Types::Void)
+                            return_type = expand_alias(new.method_context!.return_type)
+                            if !return_type.is_a?(AST::Types::Void)
                               result = check_relation(sub_type: AST::Builtin.nil_type, super_type: return_type)
                               if result.failure?
-                                typing.add_error(
-                                  Diagnostic::Ruby::MethodBodyTypeMismatch.new(
-                                    node: node,
-                                    expected: new.method_context&.return_type,
-                                    actual: AST::Builtin.nil_type,
-                                    result: result
+                                if new.method_context!.attribute_setter?
+                                  typing.add_error(
+                                    Diagnostic::Ruby::SetterBodyTypeMismatch.new(
+                                      node: node,
+                                      expected: new.method_context!.return_type,
+                                      actual: AST::Builtin.nil_type,
+                                      result: result,
+                                      method_name: new.method_context!.name
+                                    )
+                                  )
+                                else
+                                  typing.add_error(
+                                    Diagnostic::Ruby::MethodBodyTypeMismatch.new(
+                                      node: node,
+                                      expected: new.method_context!.return_type,
+                                      actual: AST::Builtin.nil_type,
+                                      result: result
+                                    )
                                   )
-                                )
+                                end
                               end
                             end
 
@@ -1100,12 +1125,9 @@ module Steep
               return_value_node = node.children[0]
               value_type, constr = synthesize(return_value_node, hint: method_return_type)
             else
-              constr = synthesize_children(node)
-              return_types = node.children.map do |value|
-                constr.typing.type_of(node: value)
-              end
-
-              value_type = AST::Builtin::Array.instance_type(union_type(*return_types))
+              # It returns an array
+              array = node.updated(:array)
+              value_type, constr = synthesize(array, hint: method_return_type)
             end
 
             if method_return_type
@@ -1113,14 +1135,26 @@ module Steep
                 result = constr.check_relation(sub_type: value_type, super_type: method_return_type)
 
                 if result.failure?
-                  typing.add_error(
-                    Diagnostic::Ruby::ReturnTypeMismatch.new(
-                      node: node,
-                      expected: method_return_type,
-                      actual: value_type,
-                      result: result
+                  if method_context.attribute_setter?
+                    typing.add_error(
+                      Diagnostic::Ruby::SetterReturnTypeMismatch.new(
+                        node: node,
+                        method_name: method_context.name,
+                        expected: method_return_type,
+                        actual: value_type,
+                        result: result
+                      )
                     )
-                  )
+                  else
+                    typing.add_error(
+                      Diagnostic::Ruby::ReturnTypeMismatch.new(
+                        node: node,
+                        expected: method_return_type,
+                        actual: value_type,
+                        result: result
+                      )
+                    )
+                  end
                 end
               end
             end
@@ -1408,11 +1442,17 @@ module Steep
             # @type var super_node: Parser::AST::Node?
 
             name_node, super_node, _ = node.children
-            _, constr, class_name = synthesize_constant_decl(name_node, name_node.children[0], name_node.children[1]) do
-              typing.add_error(
-                Diagnostic::Ruby::UnknownConstant.new(node: name_node, name: name_node.children[1]).class!
-              )
+
+            if name_node.type == :const
+              _, constr, class_name = synthesize_constant_decl(name_node, name_node.children[0], name_node.children[1]) do
+                typing.add_error(
+                  Diagnostic::Ruby::UnknownConstant.new(node: name_node, name: name_node.children[1]).class!
+                )
+              end
+            else
+              _, constr = synthesize(name_node)
             end
+
             if class_name
               typing.source_index.add_definition(constant: class_name, definition: name_node)
             end
@@ -1459,8 +1499,13 @@ module Steep
 
             # @type var name_node: Parser::AST::Node
             name_node, _ = node.children
-            _, constr, module_name = synthesize_constant_decl(name_node, name_node.children[0], name_node.children[1]) do
-              typing.add_error Diagnostic::Ruby::UnknownConstant.new(node: name_node, name: name_node.children[1]).module!
+
+            if name_node.type == :const
+              _, constr, module_name = synthesize_constant_decl(name_node, name_node.children[0], name_node.children[1]) do
+                typing.add_error Diagnostic::Ruby::UnknownConstant.new(node: name_node, name: name_node.children[1]).module!
+              end
+            else
+              _, constr = synthesize(name_node)
             end
 
             if module_name
@@ -1677,7 +1722,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, config: builder_config)
-            left_truthy_env, left_falsy_env = interpreter.eval(env: left_context.type_env, node: left_node)
+            left_truthy, left_falsy = interpreter.eval(env: left_context.type_env, node: left_node)
 
             if left_type.is_a?(AST::Types::Logic::Env)
               left_type = left_type.type
@@ -1685,32 +1730,40 @@ module Steep
 
             right_type, constr, right_context =
               constr
-                .update_type_env { left_truthy_env }
+                .update_type_env { left_truthy.env }
                 .tap {|constr| typing.add_context_for_node(right_node, context: constr.context) }
                 .for_branch(right_node)
                 .synthesize(right_node, hint: hint, condition: true).to_ary
 
-            right_truthy_env, right_falsy_env = interpreter.eval(env: right_context.type_env, node: right_node)
+            right_truthy, right_falsy = interpreter.eval(env: right_context.type_env, node: right_node)
 
-            env =
-              if right_type.is_a?(AST::Types::Bot)
-                left_falsy_env
-              else
-                context.type_env.join(left_falsy_env, right_context.type_env)
-              end
+            case
+            when left_truthy.unreachable
+              # Always left_falsy
+              env = left_falsy.env
+              type = left_falsy.type
+            when left_falsy.unreachable
+              # Always left_truthy ==> right
+              env = right_context.type_env
+              type = right_type
+            when right_truthy.unreachable && right_falsy.unreachable
+              env = left_falsy.env
+              type = left_falsy.type
+            else
+              env = context.type_env.join(left_falsy.env, right_context.type_env)
+              type = union_type(left_falsy.type, right_type)
 
-            type =
-              case
-              when check_relation(sub_type: left_type, super_type: AST::Types::Boolean.new).success?
-                union_type(left_type, right_type)
-              else
-                union_type(right_type, AST::Builtin.nil_type)
+              unless type.is_a?(AST::Types::Any)
+                if check_relation(sub_type: type, super_type: AST::Types::Boolean.new).success?
+                  type = AST::Types::Boolean.new
+                end
               end
+            end
 
             if condition
               type = AST::Types::Logic::Env.new(
-                truthy: right_truthy_env,
-                falsy: context.type_env.join(left_falsy_env, right_falsy_env),
+                truthy: right_truthy.env,
+                falsy: context.type_env.join(left_falsy.env, right_falsy.env),
                 type: type
               )
             end
@@ -1725,40 +1778,47 @@ module Steep
             left_type, constr, left_context = synthesize(left_node, hint: hint, condition: true).to_ary
 
             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)
+            left_truthy, left_falsy = interpreter.eval(env: left_context.type_env, node: left_node)
 
             if left_type.is_a?(AST::Types::Logic::Env)
               left_type = left_type.type
             end
-            left_type, _ = checker.factory.unwrap_optional(left_type)
 
             right_type, constr, right_context =
               constr
-                .update_type_env { left_falsy_env }
+                .update_type_env { left_falsy.env }
                 .tap {|constr| typing.add_context_for_node(right_node, context: constr.context) }
                 .for_branch(right_node)
-                .synthesize(right_node, hint: left_type, condition: true).to_ary
+                .synthesize(right_node, hint: left_truthy.type, condition: true).to_ary
 
-            right_truthy_env, right_falsy_env = interpreter.eval(env: left_falsy_env, node: right_node)
+            right_truthy, right_falsy = interpreter.eval(env: left_falsy.env, node: right_node)
 
-            env = if right_type.is_a?(AST::Types::Bot)
-                    left_truthy_env
-                  else
-                    context.type_env.join(left_truthy_env, right_context.type_env)
-                  end
+            case
+            when left_falsy.unreachable
+              env = left_truthy.env
+              type = left_truthy.type
+            when left_truthy.unreachable
+              # Always left_falsy ==> right
+              env = right_context.type_env
+              type = right_type
+            when right_truthy.unreachable && right_falsy.unreachable
+              env = left_truthy.env
+              type = left_truthy.type
+            else
+              env = context.type_env.join(left_truthy.env, right_context.type_env)
+              type = union_type(left_truthy.type, right_type)
 
-            type =
-              case
-              when check_relation(sub_type: left_type, super_type: AST::Builtin.bool_type).success? && !left_type.is_a?(AST::Types::Any)
-                AST::Builtin.bool_type
-              else
-                union_type(left_type, right_type)
+              unless type.is_a?(AST::Types::Any)
+                if check_relation(sub_type: type, super_type: AST::Types::Boolean.new).success?
+                  type = AST::Types::Boolean.new
+                end
               end
+            end
 
             if condition
               type = AST::Types::Logic::Env.new(
-                truthy: context.type_env.join(left_truthy_env, right_truthy_env),
-                falsy: right_falsy_env,
+                truthy: context.type_env.join(left_truthy.env, right_truthy.env),
+                falsy: right_falsy.env,
                 type: type
               )
             end
@@ -1772,12 +1832,12 @@ module Steep
 
             cond_type, constr = synthesize(cond, condition: true).to_ary
             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)
+            truthy, falsy = interpreter.eval(env: constr.context.type_env, node: cond)
 
             if true_clause
               true_pair =
                 constr
-                  .update_type_env { truthy_env }
+                  .update_type_env { truthy.env }
                   .for_branch(true_clause)
                   .tap {|constr| typing.add_context_for_node(true_clause, context: constr.context) }
                   .synthesize(true_clause, hint: hint)
@@ -1786,7 +1846,7 @@ module Steep
             if false_clause
               false_pair =
                 constr
-                  .update_type_env { falsy_env }
+                  .update_type_env { falsy.env }
                   .for_branch(false_clause)
                   .tap {|constr| typing.add_context_for_node(false_clause, context: constr.context) }
                   .synthesize(false_clause, hint: hint)
@@ -1795,25 +1855,49 @@ module Steep
             constr = constr.update_type_env do |env|
               envs = [] #: Array[TypeInference::TypeEnv]
 
-              if true_pair
-                unless true_pair.type.is_a?(AST::Types::Bot)
-                  envs << true_pair.context.type_env
+              unless truthy.unreachable
+                if true_pair
+                  unless true_pair.type.is_a?(AST::Types::Bot)
+                    envs << true_pair.context.type_env
+                  end
+                else
+                  envs << truthy.env
                 end
-              else
-                envs << truthy_env
               end
 
               if false_pair
-                unless false_pair.type.is_a?(AST::Types::Bot)
-                  envs << false_pair.context.type_env
+                unless falsy.unreachable
+                  unless false_pair.type.is_a?(AST::Types::Bot)
+                    envs << false_pair.context.type_env
+                  end
                 end
               else
-                envs << falsy_env
+                envs << falsy.env
               end
 
               env.join(*envs)
             end
 
+            if truthy.unreachable
+              if true_clause
+                typing.add_error(
+                  Diagnostic::Ruby::UnreachableBranch.new(
+                    node: true_clause || node
+                  )
+                )
+              end
+            end
+
+            if falsy.unreachable
+              if false_clause
+                typing.add_error(
+                  Diagnostic::Ruby::UnreachableBranch.new(
+                    node: false_clause || node
+                  )
+                )
+              end
+            end
+
             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
@@ -1832,8 +1916,11 @@ module Steep
 
               cond_type, constr = constr.synthesize(cond)
               _, cond_vars = interpreter.decompose_value(cond)
+              SPECIAL_LVAR_NAMES.each do |name|
+                cond_vars.delete(name)
+              end
 
-              var_name = :"_a#{SecureRandom.base64(4)}"
+              var_name = :"_a#{SecureRandom.alphanumeric(4)}"
               var_cond, value_node = extract_outermost_call(cond, var_name)
               if value_node
                 unless constr.context.type_env[value_node]
@@ -1846,6 +1933,8 @@ module Steep
                 end
               end
 
+              next_branch_reachable = true
+
               when_constr = constr
               whens.each do |clause|
                 # @type var tests: Array[Parser::AST::Node]
@@ -1856,16 +1945,26 @@ module Steep
                 # @type var test_envs: Array[TypeInference::TypeEnv]
                 test_envs = []
 
+                branch_reachable = false
+                false_branch_reachable = false
+
                 tests.each do |test|
                   test_node = test.updated(:send, [test, :===, cond])
                   test_type, test_constr = test_constr.synthesize(test_node, condition: true).to_ary
-                  truthy_env, falsy_env = interpreter.eval(node: test_node, env: test_constr.context.type_env)
+                  truthy, falsy = interpreter.eval(node: test_node, env: test_constr.context.type_env)
+
+                  truthy_env = truthy.env
+                  falsy_env = falsy.env
 
                   test_envs << truthy_env
 
                   test_constr = test_constr.update_type_env { falsy_env }
+
+                  branch_reachable ||= next_branch_reachable && !truthy.unreachable
+                  false_branch_reachable = !falsy.unreachable
                 end
 
+                next_branch_reachable &&= false_branch_reachable
                 body_constr = when_constr.update_type_env {|env| env.join(*test_envs) }
 
                 if body
@@ -1878,6 +1977,12 @@ module Steep
                   branch_results << Pair.new(type: AST::Builtin.nil_type, constr: body_constr)
                 end
 
+                unless branch_reachable
+                  typing.add_error(
+                    Diagnostic::Ruby::UnreachableBranch.new(node: body || clause)
+                  )
+                end
+
                 when_constr = test_constr
               end
 
@@ -1888,7 +1993,11 @@ module Steep
                 end_pos = node.loc.end.begin_pos
                 typing.add_context(begin_pos..end_pos, context: when_constr.context)
 
-                branch_results << when_constr.synthesize(els, hint: hint)
+                else_result = when_constr.synthesize(els, hint: hint)
+
+                if next_branch_reachable
+                  branch_results << else_result
+                end
               end
 
               types = branch_results.map(&:type)
@@ -1899,10 +2008,17 @@ module Steep
               cond_type ||= when_constr.context.type_env[value_node] if value_node
               cond_type ||= typing.type_of(node: node.children[0])
 
-              if cond_type.is_a?(AST::Types::Bot)
+              if !next_branch_reachable
                 # Exhaustive
-                if els
-                  typing.add_error Diagnostic::Ruby::ElseOnExhaustiveCase.new(node: els, type: cond_type)
+                _, _, _, loc = deconstruct_case_node!(node)
+
+                # `else` may present even if it's empty
+                if loc.else
+                  if els
+                    typing.add_error Diagnostic::Ruby::UnreachableBranch.new(node: els)
+                  else
+                    typing.add_error Diagnostic::Ruby::UnreachableBranch.new(node: node, location: loc.else)
+                  end
                 end
               else
                 unless els
@@ -1916,6 +2032,8 @@ module Steep
               condition_constr = constr
               clause_constr = constr
 
+              next_branch_reachable = true
+
               whens.each do |when_clause|
                 when_clause_constr = condition_constr
                 body_envs = [] #: Array[TypeInference::TypeEnv]
@@ -1924,14 +2042,24 @@ module Steep
                 # @type var body: Parser::AST::Node?
                 *tests, body = when_clause.children
 
+                branch_reachable = false
+                false_branch_reachable = false
+
                 tests.each do |test|
                   test_type, condition_constr = condition_constr.synthesize(test, condition: true)
-                  truthy_env, falsy_env = interpreter.eval(env: condition_constr.context.type_env, node: test)
+                  truthy, falsy = interpreter.eval(env: condition_constr.context.type_env, node: test)
+                  truthy_env = truthy.env
+                  falsy_env = falsy.env
 
                   condition_constr = condition_constr.update_type_env { falsy_env }
                   body_envs << truthy_env
+
+                  branch_reachable ||= next_branch_reachable && !truthy.unreachable
+                  false_branch_reachable ||= !falsy.unreachable
                 end
 
+                next_branch_reachable &&= false_branch_reachable
+
                 if body
                   branch_results <<
                     when_clause_constr
@@ -1942,6 +2070,12 @@ module Steep
                 else
                   branch_results << Pair.new(type: AST::Builtin.nil_type, constr: when_clause_constr)
                 end
+
+                unless branch_reachable
+                  typing.add_error(
+                    Diagnostic::Ruby::UnreachableBranch.new(node: body || when_clause)
+                  )
+                end
               end
 
               if els
@@ -2135,7 +2269,9 @@ module Steep
             cond_type, constr = synthesize(cond, condition: true).to_ary
 
             interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing, config: builder_config)
-            truthy_env, falsy_env = interpreter.eval(env: constr.context.type_env, node: cond)
+            truthy, falsy = interpreter.eval(env: constr.context.type_env, node: cond)
+            truthy_env = truthy.env
+            falsy_env = falsy.env
 
             case node.type
             when :while
@@ -2221,8 +2357,11 @@ module Steep
           # ignore
           add_typing(node, type: AST::Builtin.any_type)
 
-        when :nth_ref, :back_ref
-          add_typing(node, type: AST::Builtin::String.instance_type)
+        when :nth_ref
+          add_typing(node, type: union_type(AST::Builtin::String.instance_type, AST::Builtin.nil_type))
+
+        when :back_ref
+          synthesize(node.updated(:gvar), hint: hint)
 
         when :or_asgn, :and_asgn
           yield_self do
@@ -2290,43 +2429,58 @@ module Steep
 
         when :block_pass
           yield_self do
-            value = node.children[0]
+            value_node = node.children[0]
 
-            case
-            when hint.is_a?(AST::Types::Proc) && value && value.type == :sym
-              if hint.one_arg?
-                # Assumes Symbol#to_proc implementation
-                param_type = hint.type.params.required[0]
-                case param_type
-                when AST::Types::Any
-                  type = AST::Types::Any.new
-                else
-                  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
+            constr = self #: TypeConstruction
+
+            if value_node
+              type, constr = synthesize(value_node, hint: hint)
+
+              if hint.is_a?(AST::Types::Proc) && value_node.type == :sym
+                if hint.one_arg?
+                  # Assumes Symbol#to_proc implementation
+                  param_type = hint.type.params.required[0]
+                  case param_type
+                  when AST::Types::Any
+                    type = AST::Types::Any.new
+                  else
+                    if method = calculate_interface(param_type, private: true)&.methods&.[](value_node.children[0])
+                      return_types = method.method_types.filter_map do |method_type|
+                        if method_type.type.params.optional?
+                          method_type.type.return_type
+                        end
                       end
-                    end
 
-                    unless return_types.empty?
-                      type = AST::Types::Proc.new(
-                        type: Interface::Function.new(
-                          params: Interface::Function::Params.empty.with_first_param(
-                            Interface::Function::Params::PositionalParams::Required.new(param_type)
+                      unless return_types.empty?
+                        type = AST::Types::Proc.new(
+                          type: Interface::Function.new(
+                            params: Interface::Function::Params.empty.with_first_param(
+                              Interface::Function::Params::PositionalParams::Required.new(param_type)
+                            ),
+                            return_type: return_types[0],
+                            location: nil
                           ),
-                          return_type: return_types[0],
-                          location: nil
-                        ),
-                        block: nil,
-                        self_type: nil
-                      )
+                          block: nil,
+                          self_type: nil
+                        )
+                      end
                     end
                   end
+                else
+                  Steep.logger.error "Passing multiple args through Symbol#to_proc is not supported yet"
                 end
+              end
+
+              case
+              when type.is_a?(AST::Types::Proc)
+                # nop
+              when AST::Builtin::Proc.instance_type?(type)
+                # nop
               else
-                Steep.logger.error "Passing multiple args through Symbol#to_proc is not supported yet"
+                type = try_convert(type, :to_proc) || type
               end
-            when value == nil
+            else
+              # Anonymous block_pass only happens inside method definition
               if block_type = method_context!.block_type
                 type = AST::Types::Proc.new(
                   type: block_type.type,
@@ -2334,16 +2488,15 @@ module Steep
                   block: nil,
                   self_type: block_type.self_type
                 )
+
                 if block_type.optional?
-                  type = AST::Types::Union.build(types: [type, AST::Builtin.nil_type])
+                  type = union_type(type, AST::Builtin.nil_type)
                 end
               else
                 type = AST::Builtin.nil_type
               end
             end
 
-            type ||= synthesize(value, hint: hint).type
-
             add_typing node, type: type
           end
 
@@ -2435,7 +2588,7 @@ module Steep
             # @type var as_type: AST::Node::TypeAssertion
             asserted_node, as_type = node.children
 
-            if type = as_type.type?(module_context.nesting, checker.factory, [])
+            if type = as_type.type?(module_context.nesting, checker, [])
               actual_type, constr = synthesize(asserted_node, hint: type)
 
               if no_subtyping?(sub_type: type, super_type: actual_type) && no_subtyping?(sub_type: actual_type, super_type: type)
@@ -2517,7 +2670,7 @@ module Steep
 
             add_typing(node, type: type)
           else
-            type_send(node, send_node: node, block_params: nil, block_body: nil, tapp: tapp)
+            type_send(node, send_node: node, block_params: nil, block_body: nil, tapp: tapp, hint: hint)
           end
         end
       when :csend
@@ -2532,7 +2685,7 @@ module Steep
                      end
               add_typing(node, type: type).to_ary
             else
-              type_send(node, send_node: node, block_params: nil, block_body: nil, unwrap: true, tapp: tapp).to_ary
+              type_send(node, send_node: node, block_params: nil, block_body: nil, unwrap: true, tapp: tapp, hint: hint).to_ary
             end
 
           constr
@@ -2546,7 +2699,7 @@ module Steep
             # @type var node: Parser::AST::Node & Parser::AST::_BlockNode
             type_lambda(node, params_node: params, body_node: body, type_hint: hint)
           else
-            type_send(node, send_node: send_node, block_params: params, block_body: body, unwrap: send_node.type == :csend, tapp: tapp)
+            type_send(node, send_node: send_node, block_params: params, block_body: body, unwrap: send_node.type == :csend, tapp: tapp, hint: hint)
           end
         end
       when :numblock
@@ -2565,7 +2718,7 @@ module Steep
             # @type var node: Parser::AST::Node & Parser::AST::_BlockNode
             type_lambda(node, params_node: params, body_node: body, type_hint: hint)
           else
-            type_send(node, send_node: send_node, block_params: params, block_body: body, unwrap: send_node.type == :csend, tapp: tapp)
+            type_send(node, send_node: send_node, block_params: params, block_body: body, unwrap: send_node.type == :csend, tapp: tapp, hint: hint)
           end
         end
       else
@@ -2874,7 +3027,7 @@ module Steep
         if type.types.size == 2
           if type.types.find {|t| t.is_a?(AST::Types::Nil) }
             if proc_type = type.types.find {|t| t.is_a?(AST::Types::Proc) }
-              proc_type
+              proc_type #: AST::Types::Proc
             end
           end
         end
@@ -2885,14 +3038,32 @@ module Steep
       block_annotations = source.annotations(block: node, factory: checker.factory, context: nesting)
       params = TypeInference::BlockParams.from_node(params_node, annotations: block_annotations)
 
-      type_hint = deep_expand_alias(type_hint) if type_hint
+      if type_hint
+        original_hint = type_hint
 
-      case type_hint
-      when AST::Types::Proc
-        params_hint = type_hint.type.params
-        return_hint = type_hint.type.return_type
-        block_hint = type_hint.block
-        self_hint = type_hint.self_type
+        type_hint = deep_expand_alias(type_hint) || type_hint
+
+        procs = flatten_union(type_hint).select do |type|
+          check_relation(sub_type: type, super_type: AST::Builtin::Proc.instance_type).success?
+        end
+
+        proc_instances, proc_types = procs.partition {|type| AST::Builtin::Proc.instance_type?(type) }
+
+        case
+        when !proc_instances.empty? && proc_types.empty?
+          # `::Proc` is given as a hint
+        when proc_types.size == 1
+          # Proc type is given as a hint
+          hint_proc = proc_types[0]  #: AST::Types::Proc
+          params_hint = hint_proc.type.params
+          return_hint = hint_proc.type.return_type
+          block_hint = hint_proc.block
+          self_hint = hint_proc.self_type
+        else
+          typing.add_error(
+            Diagnostic::Ruby::ProcHintIgnored.new(hint_type: original_hint, node: node)
+          )
+        end
       end
 
       block_constr = for_block(
@@ -3028,7 +3199,7 @@ module Steep
       end
     end
 
-    def type_send_interface(node, interface:, receiver:, receiver_type:, method_name:, arguments:, block_params:, block_body:, tapp:)
+    def type_send_interface(node, interface:, receiver:, receiver_type:, method_name:, arguments:, block_params:, block_body:, tapp:, hint:)
       method = interface&.methods&.[](method_name)
 
       if method
@@ -3040,7 +3211,8 @@ module Steep
           block_params: block_params,
           block_body: block_body,
           receiver_type: receiver_type,
-          tapp: tapp
+          tapp: tapp,
+          hint: hint
         )
 
         if call && constr
@@ -3159,17 +3331,17 @@ module Steep
       end
     end
 
-    def type_send(node, send_node:, block_params:, block_body:, unwrap: false, tapp:)
+    def type_send(node, send_node:, block_params:, block_body:, unwrap: false, tapp:, hint:)
       # @type var constr: TypeConstruction
       # @type var receiver: Parser::AST::Node?
 
       case send_node.type
       when :super, :zsuper
         receiver = nil
-        method_name = method_context&.name
+        method_name = method_context!.name
         arguments = send_node.children
 
-        if method_name.nil? || method_context&.super_method.nil?
+        if method_name.nil? || method_context!.super_method.nil?
           return fallback_to_any(send_node) do
             Diagnostic::Ruby::UnexpectedSuper.new(
               node: send_node,
@@ -3241,7 +3413,8 @@ module Steep
               arguments: arguments,
               block_params: block_params,
               block_body: block_body,
-              tapp: tapp
+              tapp: tapp,
+              hint: hint
             )
           else
             constr = constr.synthesize_children(node, skips: [receiver])
@@ -3300,10 +3473,14 @@ module Steep
       ],
       hash_compact: Set[
         MethodName("::Hash#compact")
+      ],
+      lambda: Set[
+        MethodName("::Kernel#lambda"),
+        MethodName("::Kernel.lambda")
       ]
     }
 
-    def try_special_method(node, receiver_type:, method_name:, method_type:, arguments:, block_params:, block_body:)
+    def try_special_method(node, receiver_type:, method_name:, method_type:, arguments:, block_params:, block_body:, hint:)
       decls = method_type.method_decls
 
       case
@@ -3354,12 +3531,29 @@ module Steep
             return [call, constr]
           end
         end
+      when decl = decls.find {|decl| SPECIAL_METHOD_NAMES[:lambda].include?(decl.method_name) }
+        if block_params
+          # @type var node: Parser::AST::Node & Parser::AST::_BlockNode
+          type, constr = type_lambda(node, params_node: block_params, body_node: block_body, type_hint: hint)
+
+          call = TypeInference::MethodCall::Special.new(
+            node: node,
+            context: context.call_context,
+            method_name: decl.method_name.method_name,
+            receiver_type: receiver_type,
+            actual_method_type: method_type.with(type: method_type.type.with(return_type: type)),
+            return_type: type,
+            method_decls: decls
+          )
+
+          return [call, constr]
+        end
       end
 
       nil
     end
 
-    def type_method_call(node, method_name:, receiver_type:, method:, arguments:, block_params:, block_body:, tapp:)
+    def type_method_call(node, method_name:, receiver_type:, method:, arguments:, block_params:, block_body:, tapp:, hint:)
       node_range = node.loc.expression.to_range
 
       # @type var fails: Array[[TypeInference::MethodCall::t, TypeConstruction]]
@@ -3377,7 +3571,8 @@ module Steep
               method_type: method_type,
               arguments: arguments,
               block_params: block_params,
-              block_body: block_body
+              block_body: block_body,
+              hint: hint
             ) || constr.try_method_type(
               node,
               receiver_type: receiver_type,
@@ -3386,7 +3581,8 @@ module Steep
               arguments: arguments,
               block_params: block_params,
               block_body: block_body,
-              tapp: tapp
+              tapp: tapp,
+              hint: hint
             )
 
             if call.is_a?(TypeInference::MethodCall::Typed)
@@ -3473,6 +3669,24 @@ module Steep
       end
     end
 
+    def type_check_untyped_args(arguments)
+      constr = self #: TypeConstruction
+
+      arguments.each do |arg|
+        case arg.type
+        when :splat
+          type, constr = constr.synthesize(arg.children[0])
+          _, constr = constr.add_typing(arg, type: type)
+        when :kwargs
+          _, constr = constr.type_hash_record(arg, nil) || constr.type_hash(arg, hint: nil)
+        else
+          _, constr = constr.synthesize(arg)
+        end
+      end
+
+      constr
+    end
+
     def type_check_args(method_name, args, constraints, errors)
       # @type var constr: TypeConstruction
       constr = self
@@ -3588,10 +3802,10 @@ module Steep
       constr
     end
 
-    def try_method_type(node, receiver_type:, method_name:, method_type:, arguments:, block_params:, block_body:, tapp:)
+    def try_method_type(node, receiver_type:, method_name:, method_type:, arguments:, block_params:, block_body:, tapp:, hint:)
       constr = self
 
-      if tapp && type_args = tapp.types?(module_context.nesting, checker.factory, [])
+      if tapp && type_args = tapp.types?(module_context.nesting, checker, [])
         type_arity = method_type.type_params.size
         type_param_names = method_type.type_params.map(&:name)
 
@@ -3703,12 +3917,29 @@ module Steep
 
         if block_params
           # block is given
+
           # @type var node: Parser::AST::Node & Parser::AST::_BlockNode
 
           block_annotations = source.annotations(block: node, factory: checker.factory, context: nesting)
           block_params_ = TypeInference::BlockParams.from_node(block_params, annotations: block_annotations)
 
           if method_type.block
+            fvs = method_type.type.return_type.free_variables.each.with_object(Set[]) do |var, fvs| #$ Set[Symbol]
+              if var.is_a?(Symbol)
+                fvs << var
+              end
+            end
+
+            if hint && !fvs.empty?
+              if check_relation(sub_type: method_type.type.return_type, super_type: hint, constraints: constraints).success?
+                method_type, solved, s = apply_solution(errors, node: node, method_type: method_type) do
+                  constraints.solution(checker, variables: fvs, context: ccontext)
+                end
+              end
+
+              method_type.block or raise
+            end
+
             # Method accepts block
             pairs = block_params_&.zip(method_type.block.type.params, nil, factory: checker.factory)
 
@@ -3724,6 +3955,7 @@ module Steep
                 block_self_hint: method_type.block.self_type,
                 node_type_hint: method_type.type.return_type
               )
+
               block_constr = block_constr.with_new_typing(
                 block_constr.typing.new_child(block_constr.typing.block_range(node))
               )
@@ -3733,7 +3965,7 @@ module Steep
               pairs.each do |param, type|
                 case param
                 when TypeInference::BlockParams::Param
-                  _, block_constr = block_constr.synthesize(param.node, hint: param.type || type).to_ary
+                  _, block_constr = block_constr.synthesize(param.node, hint: param.type || type)
 
                   if param.type
                     check_relation(sub_type: type, super_type: param.type, constraints: constraints).else do |result|
@@ -3748,7 +3980,7 @@ module Steep
                   end
                 when TypeInference::BlockParams::MultipleParam
                   param.each_param do |p|
-                    _, block_constr = block_constr.synthesize(p.node, hint: p.type || type).to_ary
+                    _, block_constr = block_constr.synthesize(p.node, hint: p.type || type)
 
                     if p.type
                       check_relation(sub_type: type, super_type: p.type, constraints: constraints).else do |result|
@@ -4154,6 +4386,7 @@ module Steep
       pins = context.type_env.pin_local_variables(nil)
 
       type_env = context.type_env
+      type_env = type_env.invalidate_pure_node(Parser::AST::Node.new(:self)) if block_self_hint || block_annotations.self_type
       type_env = type_env.merge(local_variable_types: pins)
       type_env = type_env.merge(local_variable_types: param_types)
       type_env = TypeInference::TypeEnvBuilder.new(
@@ -4419,8 +4652,7 @@ module Steep
     end
 
     def unwrap(type)
-      truthy, _ = checker.factory.unwrap_optional(type)
-      truthy
+      checker.factory.unwrap_optional(type) || AST::Types::Bot.new
     end
 
     def deep_expand_alias(type)
@@ -4490,7 +4722,7 @@ module Steep
     def try_tuple_type!(node, hint: nil)
       if node.type == :array
         if hint.nil? || hint.is_a?(AST::Types::Tuple)
-          node_range = node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }
+          node_range = node.loc.expression.to_range
 
           typing.new_child(node_range) do |child_typing|
             if pair = with_new_typing(child_typing).try_tuple_type(node, hint)
@@ -4510,15 +4742,28 @@ module Steep
       element_types = [] #: Array[AST::Types::t]
 
       array_node.children.each_with_index do |child, index|
-        return if child.type == :splat
-
-        child_hint =
-          if hint
-            hint.types[index]
+        if child.type == :splat
+          type, constr = constr.synthesize(child.children[0])
+          typing.add_typing(child, type, nil)
+          if converted_type = try_convert(type, :to_a)
+            if converted_type.is_a?(AST::Types::Tuple)
+              element_types.push(*converted_type.types)
+            else
+              # The converted_type may be an array, which cannot be used to construct a tuple type
+              return
+            end
+          else
+            element_types << type
           end
+        else
+          child_hint =
+            if hint
+              hint.types[index]
+            end
 
-        type, constr = constr.synthesize(child, hint: child_hint)
-        element_types << type
+          type, constr = constr.synthesize(child, hint: child_hint)
+          element_types << type
+        end
       end
 
       constr.add_typing(array_node, type: AST::Types::Tuple.new(types: element_types))