steep 1.8.0.dev.1 → 1.8.0.pre.1

data/lib/steep/type_construction.rb

@@ -154,7 +154,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, method_decls: Set[]) }
+                                     .map {|method_type| checker.factory.method_type(method_type) }
                                      .select {|method_type| method_type.is_a?(Interface::MethodType) }
                                      .inject {|t1, t2| t1 + t2}
                                  end
@@ -195,11 +195,11 @@ module Steep
       end
 
       method_params =
-      if method_type
-        TypeInference::MethodParams.build(node: node, method_type: method_type)
-      else
-        TypeInference::MethodParams.empty(node: node)
-      end
+        if method_type
+          TypeInference::MethodParams.build(node: node, method_type: method_type)
+        else
+          TypeInference::MethodParams.empty(node: node)
+        end
 
       method_context = TypeInference::Context::MethodContext.new(
         name: method_name,
@@ -405,9 +405,10 @@ module Steep
         type_params = definition.type_params_decl.map do |param|
           Interface::TypeParam.new(
             name: param.name,
-            upper_bound: checker.factory.type_opt(param.upper_bound),
+            upper_bound: checker.factory.type_opt(param.upper_bound_type),
             variance: param.variance,
-            unchecked: param.unchecked?
+            unchecked: param.unchecked?,
+            default_type: checker.factory.type_opt(param.default_type)
           )
         end
         variable_context = TypeInference::Context::TypeVariableContext.new(type_params)
@@ -494,10 +495,11 @@ module Steep
       type_params = definition.type_params_decl.map do |type_param|
         Interface::TypeParam.new(
           name: type_param.name,
-          upper_bound: type_param.upper_bound&.yield_self {|t| checker.factory.type(t) },
+          upper_bound: type_param.upper_bound_type&.yield_self {|t| checker.factory.type(t) },
           variance: type_param.variance,
           unchecked: type_param.unchecked?,
-          location: type_param.location
+          location: type_param.location,
+          default_type: checker.factory.type_opt(type_param.default_type)
         )
       end
       variable_context = TypeInference::Context::TypeVariableContext.new(type_params)
@@ -705,7 +707,7 @@ module Steep
                   if new_pair.constr.context != pair.constr.context
                     # update context
                     range = node.loc.expression.end_pos..end_pos
-                    typing.add_context(range, context: new_pair.constr.context)
+                    typing.cursor_context.set(range, new_pair.constr.context)
                   end
                 end
               end
@@ -878,16 +880,11 @@ module Steep
             if self_type && method_context!.method
               if super_def = method_context!.super_method
                 super_method = Interface::Shape::Entry.new(
+                  method_name: method_context!.name,
                   private_method: true,
-                  method_types: super_def.defs.map {|type_def|
-                    decl = TypeInference::MethodCall::MethodDecl.new(
-                      method_name: InstanceMethodName.new(
-                        type_name: super_def.implemented_in || super_def.defined_in || raise,
-                        method_name: method_context!.name || raise("method context must have a name")
-                      ),
-                      method_def: type_def
-                    )
-                    checker.factory.method_type(type_def.type, method_decls: Set[decl])
+                  overloads: super_def.defs.map {|type_def|
+                    type = checker.factory.method_type(type_def.type)
+                    Interface::Shape::MethodOverload.new(type, [type_def])
                   }
                 )
 
@@ -949,8 +946,8 @@ module Steep
             ) 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.typing.cursor_context.set_node_context(node, new.context)
+              new.typing.cursor_context.set_body_context(node, new.context)
 
               new.method_context!.tap do |method_context|
                 if method_context.method
@@ -1028,7 +1025,7 @@ module Steep
                   # 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)
+                  typing.cursor_context.set(begin_pos..end_pos, body_pair.context)
                 end
               end
 
@@ -1061,8 +1058,8 @@ module Steep
               self_type: self_type,
               definition: definition
             )
-            new.typing.add_context_for_node(node, context: new.context)
-            new.typing.add_context_for_body(node, context: new.context)
+            new.typing.cursor_context.set_node_context(node, new.context)
+            new.typing.cursor_context.set_body_context(node, new.context)
 
             new.method_context!.tap do |method_context|
               if method_context.method
@@ -1375,6 +1372,12 @@ module Steep
         when :float
           add_typing(node, type: AST::Builtin::Float.instance_type)
 
+        when :rational
+          add_typing(node, type: AST::Types::Name::Instance.new(name: TypeName("::Rational"), args: []))
+
+        when :complex
+          add_typing(node, type: AST::Types::Name::Instance.new(name: TypeName("::Complex"), args: []))
+
         when :nil
           add_typing(node, type: AST::Builtin.nil_type)
 
@@ -1420,7 +1423,7 @@ module Steep
           when condition
             add_typing(node, type: ty)
           else
-            add_typing(node, type: AST::Types::Boolean.new)
+            add_typing(node, type: AST::Types::Boolean.instance)
           end
 
         when :hash, :kwargs
@@ -1499,13 +1502,13 @@ module Steep
                 _, constructor = constructor.fallback_to_any(name_node)
               end
 
-              constructor.typing.add_context_for_node(node, context: constructor.context)
-              constructor.typing.add_context_for_body(node, context: constructor.context)
+              constructor.typing.cursor_context.set_node_context(node, constructor.context)
+              constructor.typing.cursor_context.set_body_context(node, constructor.context)
 
               constructor.synthesize(node.children[2]) if node.children[2]
 
               if constructor.module_context&.implement_name && !namespace_module?(node)
-                constructor.validate_method_definitions(node, constructor.module_context.implement_name)
+                constructor.validate_method_definitions(node, constructor.module_context.implement_name || raise)
               end
             end
 
@@ -1538,13 +1541,13 @@ module Steep
                 _, constructor = constructor.fallback_to_any(name_node)
               end
 
-              constructor.typing.add_context_for_node(node, context: constructor.context)
-              constructor.typing.add_context_for_body(node, context: constructor.context)
+              constructor.typing.cursor_context.set_node_context(node, constructor.context)
+              constructor.typing.cursor_context.set_body_context(node, constructor.context)
 
               constructor.synthesize(node.children[1]) if node.children[1]
 
               if constructor.module_context&.implement_name && !namespace_module?(node)
-                constructor.validate_method_definitions(node, constructor.module_context.implement_name)
+                constructor.validate_method_definitions(node, constructor.module_context.implement_name || raise)
               end
             end
 
@@ -1566,8 +1569,8 @@ module Steep
                 return constr.add_typing(node, type: AST::Builtin.nil_type)
               end
 
-              constructor.typing.add_context_for_node(node, context: constructor.context)
-              constructor.typing.add_context_for_body(node, context: constructor.context)
+              constructor.typing.cursor_context.set_node_context(node, constructor.context)
+              constructor.typing.cursor_context.set_body_context(node, constructor.context)
 
               constructor.synthesize(node.children[1]) if node.children[1]
 
@@ -1582,10 +1585,10 @@ module Steep
           end
 
         when :self
-          add_typing node, type: AST::Types::Self.new
+          add_typing node, type: AST::Types::Self.instance
 
         when :cbase
-          add_typing node, type: AST::Types::Void.new
+          add_typing node, type: AST::Types::Void.instance
 
         when :const
           yield_self do
@@ -1677,7 +1680,7 @@ module Steep
             if method_context && method_context.method
               if method_context.super_method
                 types = method_context.super_method.method_types.map {|method_type|
-                  checker.factory.method_type(method_type, method_decls: Set[]).type.return_type
+                  checker.factory.method_type(method_type).type.return_type
                 }
                 add_typing(node, type: union_type(*types))
               else
@@ -1705,13 +1708,11 @@ module Steep
                 add_typing node, type: AST::Builtin::Array.instance_type(AST::Builtin.any_type)
               end
             else
-              node_range = node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }
-
               if hint
                 tuples = select_flatten_types(hint) {|type| type.is_a?(AST::Types::Tuple) } #: Array[AST::Types::Tuple]
                 unless tuples.empty?
                   tuples.each do |tuple|
-                    typing.new_child(node_range) do |child_typing|
+                    typing.new_child() do |child_typing|
                       if pair = with_new_typing(child_typing).try_tuple_type(node, tuple)
                         return pair.with(constr: pair.constr.save_typing)
                       end
@@ -1724,7 +1725,7 @@ module Steep
                 arrays = select_flatten_types(hint) {|type| AST::Builtin::Array.instance_type?(type) } #: Array[AST::Types::Name::Instance]
                 unless arrays.empty?
                   arrays.each do |array|
-                    typing.new_child(node_range) do |child_typing|
+                    typing.new_child() 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?
                         return pair.with(constr: pair.constr.save_typing)
@@ -1754,7 +1755,7 @@ module Steep
             right_type, constr, right_context =
               constr
                 .update_type_env { left_truthy.env }
-                .tap {|constr| typing.add_context_for_node(right_node, context: constr.context) }
+                .tap {|constr| typing.cursor_context.set_node_context(right_node, constr.context) }
                 .for_branch(right_node)
                 .synthesize(right_node, hint: hint, condition: true).to_ary
 
@@ -1777,8 +1778,8 @@ module Steep
               type = union_type(left_falsy.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
+                if check_relation(sub_type: type, super_type: AST::Types::Boolean.instance).success?
+                  type = AST::Types::Boolean.instance
                 end
               end
             end
@@ -1813,7 +1814,7 @@ module Steep
             right_type, constr, right_context =
               constr
                 .update_type_env { left_falsy.env }
-                .tap {|constr| typing.add_context_for_node(right_node, context: constr.context) }
+                .tap {|constr| typing.cursor_context.set_node_context(right_node, constr.context) }
                 .for_branch(right_node)
                 .synthesize(right_node, hint: left_truthy.type, condition: true).to_ary
 
@@ -1835,8 +1836,8 @@ module Steep
               type = union_type(left_truthy.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
+                if check_relation(sub_type: type, super_type: AST::Types::Boolean.instance).success?
+                  type = AST::Types::Boolean.instance
                 end
               end
             end
@@ -1865,7 +1866,7 @@ module Steep
                 constr
                   .update_type_env { truthy.env }
                   .for_branch(true_clause)
-                  .tap {|constr| typing.add_context_for_node(true_clause, context: constr.context) }
+                  .tap {|constr| typing.cursor_context.set_node_context(true_clause, constr.context) }
                   .synthesize(true_clause, hint: hint)
             end
 
@@ -1874,7 +1875,7 @@ module Steep
                 constr
                   .update_type_env { falsy.env }
                   .for_branch(false_clause)
-                  .tap {|constr| typing.add_context_for_node(false_clause, context: constr.context) }
+                  .tap {|constr| typing.cursor_context.set_node_context(false_clause, constr.context) }
                   .synthesize(false_clause, hint: hint)
             end
 
@@ -2004,7 +2005,7 @@ module Steep
                     when_clause_constr
                       .for_branch(body)
                       .update_type_env {|env| env.join(*body_envs) }
-                      .tap {|constr| typing.add_context_for_node(body, context: constr.context) }
+                      .tap {|constr| typing.cursor_context.set_node_context(body, constr.context) }
                       .synthesize(body, hint: hint)
                   else
                     Pair.new(type: AST::Builtin.nil_type, constr: when_clause_constr)
@@ -2106,7 +2107,7 @@ module Steep
               end
 
               if body
-                resbody_construction.typing.add_context_for_node(body, context: resbody_construction.context)
+                resbody_construction.typing.cursor_context.set_node_context(body, resbody_construction.context)
                 resbody_construction.synthesize(body, hint: hint)
               else
                 Pair.new(constr: body_constr, type: AST::Builtin.nil_type)
@@ -2114,7 +2115,7 @@ module Steep
             end
 
             resbody_pairs.select! do |pair|
-              no_subtyping?(sub_type: pair.type, super_type: AST::Types::Bot.new)
+              no_subtyping?(sub_type: pair.type, super_type: AST::Types::Bot.instance)
             end
 
             resbody_types = resbody_pairs.map(&:type)
@@ -2207,7 +2208,7 @@ module Steep
                   type_env.merge(local_variable_types: pins)
                 end
 
-                typing.add_context_for_body(node, context: body_constr.context)
+                typing.cursor_context.set_body_context(node, body_constr.context)
                 _, _, body_context = body_constr.synthesize(body).to_ary
 
                 constr = constr.update_type_env do |env|
@@ -2261,7 +2262,7 @@ module Steep
                 constr
                   .update_type_env { body_env }
                   .for_branch(body, break_context: TypeInference::Context::BreakContext.new(break_type: hint || AST::Builtin.nil_type, next_type: nil))
-                  .tap {|constr| typing.add_context_for_node(body, context: constr.context) }
+                  .tap {|constr| typing.cursor_context.set_node_context(body, constr.context) }
                   .synthesize(body).to_ary
 
               constr = constr.update_type_env {|env| env.join(exit_env, body_constr.context.type_env) }
@@ -2284,7 +2285,7 @@ module Steep
                   .update_type_env {|env| env.merge(local_variable_types: env.pin_local_variables(nil)) }
                   .for_branch(body, break_context: TypeInference::Context::BreakContext.new(break_type: hint || AST::Builtin.nil_type, next_type: nil))
 
-              typing.add_context_for_node(body, context: for_loop.context)
+              typing.cursor_context.set_node_context(body, for_loop.context)
               _, body_constr, body_context = for_loop.synthesize(body)
 
               constr = cond_constr.update_type_env {|env| env.join(env, body_context.type_env) }
@@ -2407,7 +2408,7 @@ module Steep
                     param_type = hint.type.params.required[0]
                     case param_type
                     when AST::Types::Any
-                      type = AST::Types::Any.new
+                      type = AST::Types::Any.instance
                     else
                       if method = calculate_interface(param_type, private: true)&.methods&.[](value_node.children[0])
                         return_types = method.method_types.filter_map do |method_type|
@@ -2450,7 +2451,6 @@ module Steep
               if block_type = method_context!.block_type
                 type = AST::Types::Proc.new(
                   type: block_type.type,
-                  location: nil,
                   block: nil,
                   self_type: block_type.self_type
                 )
@@ -3081,7 +3081,7 @@ module Steep
         node_type_hint: nil
       )
 
-      block_constr.typing.add_context_for_body(node, context: block_constr.context)
+      block_constr.typing.cursor_context.set_body_context(node, block_constr.context)
 
       params.each_single_param do |param|
         _, block_constr = block_constr.synthesize(param.node, hint: param.type)
@@ -3289,7 +3289,11 @@ module Steep
             method_name: method_name,
             method_types: method.method_types
           )
-          decls = method.method_types.each_with_object(Set[]) {|type, decls| decls.merge(type.method_decls) }
+
+          decls =  method.overloads.flat_map do |method_overload|
+            method_overload.method_decls(method_name)
+          end.to_set
+
           call = TypeInference::MethodCall::Error.new(
             node: node,
             context: context.call_context,
@@ -3493,8 +3497,9 @@ module Steep
       ]
     }
 
-    def try_special_method(node, receiver_type:, method_name:, method_type:, arguments:, block_params:, block_body:, hint:)
-      decls = method_type.method_decls
+    def try_special_method(node, receiver_type:, method_name:, method_overload:, arguments:, block_params:, block_body:, hint:)
+      method_type = method_overload.method_type
+      decls = method_overload.method_decls(method_name).to_set
 
       case
       when decl = decls.find {|decl| SPECIAL_METHOD_NAMES[:array_compact].include?(decl.method_name) }
@@ -3567,21 +3572,19 @@ module Steep
     end
 
     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]]
       fails = []
 
-      method.method_types.each do |method_type|
-        Steep.logger.tagged method_type.to_s do
-          typing.new_child(node_range) do |child_typing|
+      method.overloads.each do |overload|
+        Steep.logger.tagged overload.method_type.to_s do
+          typing.new_child() do |child_typing|
             constr = self.with_new_typing(child_typing)
 
             call, constr = constr.try_special_method(
               node,
               receiver_type: receiver_type,
               method_name: method_name,
-              method_type: method_type,
+              method_overload: overload,
               arguments: arguments,
               block_params: block_params,
               block_body: block_body,
@@ -3590,7 +3593,7 @@ module Steep
               node,
               receiver_type: receiver_type,
               method_name: method_name,
-              method_type: method_type,
+              method_overload: overload,
               arguments: arguments,
               block_params: block_params,
               block_body: block_body,
@@ -3642,8 +3645,8 @@ module Steep
       end
     end
 
-    def with_child_typing(range:)
-      constr = with_new_typing(typing.new_child(range))
+    def with_child_typing()
+      constr = with_new_typing(typing.new_child())
 
       if block_given?
         yield constr
@@ -3746,7 +3749,7 @@ module Steep
         when TypeInference::SendArgs::PositionalArgs::SplatArg
           arg_type, _ =
             constr
-              .with_child_typing(range: arg.node.loc.expression.begin_pos ... arg.node.loc.expression.end_pos)
+              .with_child_typing()
               .try_tuple_type!(arg.node.children[0])
           arg.type = arg_type
 
@@ -3828,9 +3831,12 @@ module Steep
       constr
     end
 
-    def try_method_type(node, receiver_type:, method_name:, method_type:, arguments:, block_params:, block_body:, tapp:, hint:)
+    def try_method_type(node, receiver_type:, method_name:, method_overload:, arguments:, block_params:, block_body:, tapp:, hint:)
       constr = self
 
+      method_type = method_overload.method_type
+      decls = method_overload.method_decls(method_name).to_set
+
       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)
@@ -3842,21 +3848,23 @@ module Steep
 
           type_args.each_with_index do |type, index|
             param = method_type.type_params[index]
-            if param.upper_bound
-              if result = no_subtyping?(sub_type: type, super_type: param.upper_bound)
+
+            if upper_bound = param.upper_bound
+              if result = no_subtyping?(sub_type: type.value, super_type: upper_bound)
                 args_ << AST::Builtin.any_type
                 constr.typing.add_error(
                   Diagnostic::Ruby::TypeArgumentMismatchError.new(
-                    type_arg: type,
+                    type_arg: type.value,
                     type_param: param,
-                    result: result
+                    result: result,
+                    location: type.location
                   )
                 )
               else
-                args_ << type
+                args_ << type.value
               end
             else
-              args_ << type
+              args_ << type.value
             end
           end
 
@@ -3866,8 +3874,9 @@ module Steep
             type_args.drop(type_arity).each do |type_arg|
               constr.typing.add_error(
                 Diagnostic::Ruby::UnexpectedTypeArgument.new(
-                  type_arg: type_arg,
-                  method_type: method_type
+                  type_arg: type_arg.value,
+                  method_type: method_type,
+                  location: type_arg.location
                 )
               )
             end
@@ -3877,7 +3886,7 @@ module Steep
             constr.typing.add_error(
               Diagnostic::Ruby::InsufficientTypeArgument.new(
                 node: tapp.node,
-                type_args: type_args,
+                type_args: type_args.map(&:value),
                 method_type: method_type
               )
             )
@@ -3989,10 +3998,10 @@ module Steep
               )
 
               block_constr = block_constr.with_new_typing(
-                block_constr.typing.new_child(block_constr.typing.block_range(node))
+                block_constr.typing.new_child()
               )
 
-              block_constr.typing.add_context_for_body(node, context: block_constr.context)
+              block_constr.typing.cursor_context.set_body_context(node, block_constr.context)
 
               pairs.each do |param, type|
                 case param
@@ -4274,7 +4283,7 @@ module Steep
                    method_name: method_name,
                    actual_method_type: method_type,
                    return_type: return_type || method_type.type.return_type,
-                   method_decls: method_type.method_decls
+                   method_decls: decls
                  )
                else
                  TypeInference::MethodCall::Error.new(
@@ -4283,7 +4292,7 @@ module Steep
                    receiver_type: receiver_type,
                    method_name: method_name,
                    return_type: return_type || method_type.type.return_type,
-                   method_decls: method_type.method_decls,
+                   method_decls: decls,
                    errors: errors
                  )
                end
@@ -4339,7 +4348,7 @@ module Steep
         node_type_hint: nil
       )
 
-      block_constr.typing.add_context_for_body(node, context: block_constr.context)
+      block_constr.typing.cursor_context.set_body_context(node, block_constr.context)
 
       block_params.params.each do |param|
         param.each_param do |param|
@@ -4517,7 +4526,7 @@ module Steep
         body_type, _, context = synthesize(block_body, hint: block_context&.body_type || block_type_hint)
 
         range = block_body.loc.expression.end_pos..node.loc.end.begin_pos
-        typing.add_context(range, context: context)
+        typing.cursor_context.set(range, context)
 
         body_type
       else
@@ -4542,7 +4551,7 @@ module Steep
       types = types.reject {|t| t.is_a?(AST::Types::Bot) }
 
       if types.empty?
-        AST::Types::Bot.new
+        AST::Types::Bot.instance
       else
         types.inject do |type1, type2|
           next type2 if type1.is_a?(AST::Types::Any)
@@ -4712,7 +4721,7 @@ module Steep
     end
 
     def unwrap(type)
-      checker.factory.unwrap_optional(type) || AST::Types::Bot.new
+      checker.factory.unwrap_optional(type) || AST::Types::Bot.instance
     end
 
     def deep_expand_alias(type)
@@ -4759,7 +4768,7 @@ module Steep
         when AST::Types::Any
           nil
         else
-          literal_type = AST::Types::Literal.new(value: literal, location: nil)
+          literal_type = AST::Types::Literal.new(value: literal)
           if check_relation(sub_type: literal_type, super_type: hint).success?
             hint
           end
@@ -4782,9 +4791,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.to_range
-
-          typing.new_child(node_range) do |child_typing|
+          typing.new_child() do |child_typing|
             if pair = with_new_typing(child_typing).try_tuple_type(node, hint)
               return pair.with(constr: pair.constr.save_typing)
             end
@@ -4955,7 +4962,7 @@ module Steep
       each_child_node(hash_node) do |child|
         if child.type == :pair
           case child.children[0].type
-          when :sym, :str, :int
+          when :sym
             key_node = child.children[0] #: Parser::AST::Node
             value_node = child.children[1] #: Parser::AST::Node
 
@@ -4984,7 +4991,7 @@ module Steep
         end
       end
 
-      type = AST::Types::Record.new(elements: elems)
+      type = AST::Types::Record.new(elements: elems, required_keys: record_type&.required_keys || Set.new(elems.keys))
       constr.add_typing(hash_node, type: type)
     end
 
@@ -4992,18 +4999,17 @@ module Steep
       if hint
         hint = deep_expand_alias(hint)
       end
-      range = hash_node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }
 
       case hint
       when AST::Types::Record
-        with_child_typing(range: range) do |constr|
+        with_child_typing() 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|
+        pair = pick_one_of(hint.types) do |type, constr|
           constr.type_hash(hash_node, hint: type)
         end
 
@@ -5069,9 +5075,9 @@ module Steep
       constr.add_typing(hash_node, type: hash_type)
     end
 
-    def pick_one_of(types, range:)
+    def pick_one_of(types)
       types.each do |type|
-        with_child_typing(range: range) do |constr|
+        with_child_typing() do |constr|
           if (type_, constr = yield(type, constr))
             constr.check_relation(sub_type: type_, super_type: type).then do
               constr = constr.save_typing

data/lib/steep/type_inference/block_params.rb

@@ -172,6 +172,9 @@ module Steep
       end
 
       def params_type0(hint:)
+        # @type var leadings: Array[AST::Types::t]
+        # @type var optionals: Array[AST::Types::t]
+
         if hint
           case
           when leading_params.size == hint.required.size
@@ -220,8 +223,8 @@ module Steep
             end
           end
         else
-          leadings = leading_params.map {|param| param.type || AST::Types::Any.new }
-          optionals = optional_params.map {|param| param.type || AST::Types::Any.new }
+          leadings = leading_params.map {|param| param.type || AST::Types::Any.instance }
+          optionals = optional_params.map {|param| param.type || AST::Types::Any.instance }
 
           if rest_param
             if rest_type = rest_param.type
@@ -229,7 +232,7 @@ module Steep
                 rest = array.args.first or raise
               end
             end
-            rest ||= AST::Types::Any.new
+            rest ||= AST::Types::Any.instance
           end
         end
 
@@ -279,7 +282,7 @@ module Steep
               if ty
                 zip << [param, ty]
               else
-                zip << [param, AST::Types::Nil.new]
+                zip << [param, AST::Types::Nil.instance]
               end
             end
 
@@ -288,7 +291,7 @@ module Steep
                 union = AST::Types::Union.build(types: types)
                 zip << [rest_param, AST::Builtin::Array.instance_type(union)]
               else
-                zip << [rest_param, AST::Types::Nil.new]
+                zip << [rest_param, AST::Types::Nil.instance]
               end
             end
           end