sorbet-runtime 0.5.10439 → 0.5.11120

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '043696f438ea0a2cfc233bec608d68d026c210142c080ddedb2964952e53e861'
-  data.tar.gz: eb931df988ea8317cf6ca070ce4b340d9742f2fdc95b9f36d796c72e3add5e51
+  metadata.gz: 5a7367e214fde40d68e9647c33185623fd1c0a6ec2328c43ba06036338014225
+  data.tar.gz: ef0bef28019ff3385b8d7a21b73bbeb51a4e7482c3190fcf00112f7b711b7164
 SHA512:
-  metadata.gz: 1063b0900bdd17f4f103544d85fbc9a288536202c18a39b1836087322bdfea659355e0d13f884febed0a1025e30b54a06ca549fd8e2ff212666dd1f5f55c77d9
-  data.tar.gz: 8d0d2808f09d07a6895548106cca2e98baecb5bd6f6eda860cf7cf49b66890d9bdbe1575b105dd0ecf85e3e42fa08ffa480c0d2c90130d7465004ca9d36f49fd
+  metadata.gz: b7411735478f902033b8ba4258ab00f7ed3e2869b1775fc3090d02e455f012850f804a97d3e005f4fe297b9477a24c94d31a300d82307373c0f9c492b89de7b0
+  data.tar.gz: 3b1c758b422685ba62e20070c0fd33274de920a0d8618c58a57b017b84e1e32723106a0e7996b15b0c2ef50fa0bf94f33559dcd88bbbcf01173ddb02949237dd

data/lib/sorbet-runtime.rb

@@ -37,14 +37,15 @@ require_relative 'types/types/fixed_array'
 require_relative 'types/types/fixed_hash'
 require_relative 'types/types/intersection'
 require_relative 'types/types/noreturn'
+require_relative 'types/types/anything'
 require_relative 'types/types/proc'
 require_relative 'types/types/attached_class'
 require_relative 'types/types/self_type'
 require_relative 'types/types/simple'
 require_relative 'types/types/t_enum'
 require_relative 'types/types/type_parameter'
-require_relative 'types/types/typed_array'
 require_relative 'types/types/typed_enumerator'
+require_relative 'types/types/typed_enumerator_chain'
 require_relative 'types/types/typed_enumerator_lazy'
 require_relative 'types/types/typed_hash'
 require_relative 'types/types/typed_range'
@@ -55,6 +56,7 @@ require_relative 'types/private/types/not_typed'
 require_relative 'types/private/types/void'
 require_relative 'types/private/types/string_holder'
 require_relative 'types/private/types/type_alias'
+require_relative 'types/private/types/simple_pair_union'
 
 require_relative 'types/types/type_variable'
 require_relative 'types/types/type_member'
@@ -81,6 +83,10 @@ require_relative 'types/private/retry'
 require_relative 'types/utils'
 require_relative 'types/boolean'
 
+# Depends on types/utils
+require_relative 'types/types/typed_array'
+require_relative 'types/types/typed_class'
+
 # Props dependencies
 require_relative 'types/private/abstract/data'
 require_relative 'types/private/mixins/mixins'

data/lib/types/_types.rb

@@ -47,6 +47,10 @@ module T
     T::Types::NoReturn::Private::INSTANCE
   end
 
+  def self.anything
+    T::Types::Anything::Private::INSTANCE
+  end
+
   # T.all(<Type>, <Type>, ...) -- matches an object that has all of the types listed
   def self.all(type_a, type_b, *types)
     T::Types::Intersection.new([type_a, type_b] + types)
@@ -119,7 +123,7 @@ module T
   #  .returns(T::Array[T.type_parameter(:U)])
   #  def map(&blk); end
   def self.type_parameter(name)
-    T::Types::TypeParameter.new(name)
+    T::Types::TypeParameter.make(name)
   end
 
   # Tells the typechecker that `value` is of type `type`. Use this to get additional checking after
@@ -221,6 +225,34 @@ module T
     end
   end
 
+  # A convenience method to `raise` with a provided error reason when the argument
+  # is `nil` and return it otherwise.
+  #
+  # Intended to be used as:
+  #
+  #   needs_foo(T.must_because(maybe_gives_foo) {"reason_foo_should_not_be_nil"})
+  #
+  # Equivalent to:
+  #
+  #   foo = maybe_gives_foo
+  #   raise "reason_foo_should_not_be_nil" if foo.nil?
+  #   needs_foo(foo)
+  #
+  # Intended to be used to promise sorbet that a given nilable value happens
+  # to contain a non-nil value at this point.
+  #
+  # `sig {params(arg: T.nilable(A), reason_blk: T.proc.returns(String)).returns(A)}`
+  def self.must_because(arg)
+    return arg if arg
+    return arg if arg == false
+
+    begin
+      raise TypeError.new("Unexpected `nil` because #{yield}")
+    rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
+      T::Configuration.inline_type_error_handler(e, {kind: 'T.must_because', value: arg, type: nil})
+    end
+  end
+
   # A way to ask Sorbet to show what type it thinks an expression has.
   # This can be useful for debugging and checking assumptions.
   # In the runtime, merely returns the value passed in.
@@ -251,9 +283,9 @@ module T
   module Array
     def self.[](type)
       if type.is_a?(T::Types::Untyped)
-        T::Types::TypedArray::Untyped.new
+        T::Types::TypedArray::Untyped::Private::INSTANCE
       else
-        T::Types::TypedArray.new(type)
+        T::Types::TypedArray::Private::Pool.type_for_module(type)
       end
     end
   end
@@ -296,6 +328,16 @@ module T
         end
       end
     end
+
+    module Chain
+      def self.[](type)
+        if type.is_a?(T::Types::Untyped)
+          T::Types::TypedEnumeratorChain::Untyped.new
+        else
+          T::Types::TypedEnumeratorChain.new(type)
+        end
+      end
+    end
   end
 
   module Range
@@ -313,4 +355,16 @@ module T
       end
     end
   end
+
+  module Class
+    def self.[](type)
+      if type.is_a?(T::Types::Untyped)
+        T::Types::TypedClass::Untyped::Private::INSTANCE
+      elsif type.is_a?(T::Types::Anything)
+        T::Types::TypedClass::Anything::Private::INSTANCE
+      else
+        T::Types::TypedClass::Private::Pool.type_for_module(type)
+      end
+    end
+  end
 end

data/lib/types/compatibility_patches.rb

@@ -27,8 +27,10 @@ if defined? ::RSpec::Mocks
       module RSpecCompatibility
         module RecorderExtensions
           def observe!(method_name)
-            method = @klass.instance_method(method_name.to_sym)
-            T::Private::Methods.maybe_run_sig_block_for_method(method)
+            if @klass.method_defined?(method_name.to_sym)
+              method = @klass.instance_method(method_name.to_sym)
+              T::Private::Methods.maybe_run_sig_block_for_method(method)
+            end
             super(method_name)
           end
         end

data/lib/types/enum.rb

@@ -357,11 +357,16 @@ class T::Enum
     @fully_initialized = true
   end
 
-  sig {params(child_class: Module).void}
+  sig {params(child_class: T::Class[T.anything]).void}
   def self.inherited(child_class)
     super
 
     raise "Inheriting from children of T::Enum is prohibited" if self != T::Enum
+
+    # "oj" gem JSON support
+    if Object.const_defined?(:Oj)
+      Object.const_get(:Oj).register_odd(child_class, child_class, :try_deserialize, :serialize)
+    end
   end
 
   # Marshal support

data/lib/types/generic.rb

@@ -19,4 +19,6 @@ module T::Generic
   def type_template(variance=:invariant, &blk)
     T::Types::TypeTemplate.new(variance)
   end
+
+  def has_attached_class!(variance=:invariant, &blk); end
 end

data/lib/types/private/abstract/declare.rb

@@ -27,26 +27,27 @@ module T::Private::Abstract::Declare
         raise "Classes can't be interfaces. Use `abstract!` instead of `interface!`."
       end
 
-      if mod.instance_method(:initialize).owner == mod
-        raise "You must call `abstract!` *before* defining an initialize method"
+      if Object.instance_method(:method).bind_call(mod, :new).owner == mod
+        raise "You must call `abstract!` *before* defining a `new` method"
       end
 
       # Don't need to silence warnings via without_ruby_warnings when calling
       # define_method because of the guard above
 
-      mod.send(:define_method, :initialize) do |*args, &blk|
-        if self.class == mod
-          raise "#{mod} is declared as abstract; it cannot be instantiated"
+      mod.send(:define_singleton_method, :new) do |*args, &blk|
+        super(*args, &blk).tap do |result|
+          if result.instance_of?(mod)
+            raise "#{mod} is declared as abstract; it cannot be instantiated"
+          end
         end
-        super(*args, &blk)
       end
 
       # Ruby doesn not emit "method redefined" warnings for aliased methods
       # (more robust than undef_method that would create a small window in which the method doesn't exist)
-      mod.send(:alias_method, :initialize, :initialize)
+      mod.singleton_class.send(:alias_method, :new, :new)
 
-      if mod.respond_to?(:ruby2_keywords, true)
-        mod.send(:ruby2_keywords, :initialize)
+      if mod.singleton_class.respond_to?(:ruby2_keywords, true)
+        mod.singleton_class.send(:ruby2_keywords, :new)
       end
     end
   end

data/lib/types/private/casts.rb

@@ -5,7 +5,10 @@ module T::Private
   module Casts
     def self.cast(value, type, cast_method)
       begin
-        error = T::Utils.coerce(type).error_message_for_obj(value)
+        coerced_type = T::Utils::Private.coerce_and_check_module_types(type, value, true)
+        return value unless coerced_type
+
+        error = coerced_type.error_message_for_obj(value)
         return value unless error
 
         caller_loc = T.must(caller_locations(2..2)).first

data/lib/types/private/class_utils.rb

@@ -91,10 +91,13 @@ module T::Private::ClassUtils
   end
 
   # Replaces a method, either by overwriting it (if it is defined directly on `mod`) or by
-  # overriding it (if it is defined by one of mod's ancestors). Returns a ReplacedMethod instance
-  # on which you can call `bind(...).call(...)` to call the original method, or `restore` to
-  # restore the original method (by overwriting or removing the override).
-  def self.replace_method(mod, name, &blk)
+  # overriding it (if it is defined by one of mod's ancestors).  If `original_only` is
+  # false, returns a ReplacedMethod instance on which you can call `bind(...).call(...)`
+  # to call the original method, or `restore` to restore the original method (by
+  # overwriting or removing the override).
+  #
+  # If `original_only` is true, return the `UnboundMethod` representing the original method.
+  def self.replace_method(mod, name, original_only=false, &blk)
     original_method = mod.instance_method(name)
     original_visibility = visibility_method_name(mod, name)
     original_owner = original_method.owner
@@ -120,8 +123,12 @@ module T::Private::ClassUtils
         def_with_visibility(mod, name, original_visibility, &blk)
       end
     end
-    new_method = mod.instance_method(name)
 
-    ReplacedMethod.new(mod, original_method, new_method, overwritten, original_visibility)
+    if original_only
+      original_method
+    else
+      new_method = mod.instance_method(name)
+      ReplacedMethod.new(mod, original_method, new_method, overwritten, original_visibility)
+    end
   end
 end

data/lib/types/private/methods/_methods.rb

@@ -83,7 +83,7 @@ module T::Private::Methods
       raise "Procs cannot have override/abstract modifiers"
     end
     if decl.mod != PROC_TYPE
-      raise "You are passing a DeclBuilder as a type. Did you accidentally use `self` inside a `sig` block?"
+      raise "You are passing a DeclBuilder as a type. Did you accidentally use `self` inside a `sig` block? Perhaps you wanted the `T.self_type` instead: https://sorbet.org/docs/self-type"
     end
     if decl.returns == ARG_NOT_PROVIDED
       raise "Procs must specify a return type"
@@ -117,6 +117,11 @@ module T::Private::Methods
     @signatures_by_method[key]
   end
 
+  # Fetch the directory name of the file that defines the `T::Private` constant and
+  # add a trailing slash to allow us to match it as a directory prefix.
+  SORBET_RUNTIME_LIB_PATH = File.dirname(T.const_source_location(:Private).first) + File::SEPARATOR
+  private_constant :SORBET_RUNTIME_LIB_PATH
+
   # when target includes a module with instance methods source_method_names, ensure there is zero intersection between
   # the final instance methods of target and source_method_names. so, for every m in source_method_names, check if there
   # is already a method defined on one of target_ancestors with the same name that is final.
@@ -158,7 +163,7 @@ module T::Private::Methods
 
         definition_file, definition_line = T::Private::Methods.signature_for_method(ancestor.instance_method(method_name)).method.source_location
         is_redefined = target == ancestor
-        caller_loc = caller_locations&.find {|l| !l.to_s.match?(%r{sorbet-runtime[^/]*/lib/})}
+        caller_loc = caller_locations.find {|l| !l.to_s.start_with?(SORBET_RUNTIME_LIB_PATH)}
         extra_info = "\n"
         if caller_loc
           extra_info = (is_redefined ? "Redefined" : "Overridden") + " here: #{caller_loc.path}:#{caller_loc.lineno}\n"
@@ -247,7 +252,7 @@ module T::Private::Methods
     # (or unwrap back to the original method).
     key = method_owner_and_name_to_key(mod, method_name)
     unless current_declaration.raw
-      T::Private::ClassUtils.replace_method(mod, method_name) do |*args, &blk|
+      T::Private::ClassUtils.replace_method(mod, method_name, true) do |*args, &blk|
         method_sig = T::Private::Methods.maybe_run_sig_block_for_key(key)
         method_sig ||= T::Private::Methods._handle_missing_method_signature(
           self,
@@ -334,9 +339,11 @@ module T::Private::Methods
         nil
       end
 
+    declaration_block.loc = nil
+
     signature =
       if current_declaration
-        build_sig(hook_mod, method_name, original_method, current_declaration, declaration_block.loc)
+        build_sig(hook_mod, method_name, original_method, current_declaration)
       else
         Signature.new_untyped(method: original_method)
       end
@@ -353,7 +360,7 @@ module T::Private::Methods
       .decl
   end
 
-  def self.build_sig(hook_mod, method_name, original_method, current_declaration, loc)
+  def self.build_sig(hook_mod, method_name, original_method, current_declaration)
     begin
       # We allow `sig` in the current module's context (normal case) and
       if hook_mod != current_declaration.mod &&
@@ -494,19 +501,37 @@ module T::Private::Methods
       return
     end
     if is_enabled
-      @old_hooks.each(&:restore)
+      # A cut-down version of T::Private::ClassUtils::ReplacedMethod#restore, because we
+      # should only be resetting final hooks during tests.
+      T::Configuration.without_ruby_warnings do
+        Module.define_method(:included, @old_hooks[0])
+        Module.define_method(:extended, @old_hooks[1])
+        Class.define_method(:inherited, @old_hooks[2])
+      end
       @old_hooks = nil
     else
-      old_included = T::Private::ClassUtils.replace_method(Module, :included) do |arg|
-        old_included.bind(self).call(arg)
+      old_included = T::Private::ClassUtils.replace_method(Module, :included, true) do |arg|
+        if T::Configuration::AT_LEAST_RUBY_2_7
+          old_included.bind_call(self, arg)
+        else
+          old_included.bind(self).call(arg)
+        end
         ::T::Private::Methods._hook_impl(arg, false, self)
       end
-      old_extended = T::Private::ClassUtils.replace_method(Module, :extended) do |arg|
-        old_extended.bind(self).call(arg)
+      old_extended = T::Private::ClassUtils.replace_method(Module, :extended, true) do |arg|
+        if T::Configuration::AT_LEAST_RUBY_2_7
+          old_extended.bind_call(self, arg)
+        else
+          old_extended.bind(self).call(arg)
+        end
         ::T::Private::Methods._hook_impl(arg, true, self)
       end
-      old_inherited = T::Private::ClassUtils.replace_method(Class, :inherited) do |arg|
-        old_inherited.bind(self).call(arg)
+      old_inherited = T::Private::ClassUtils.replace_method(Class, :inherited, true) do |arg|
+        if T::Configuration::AT_LEAST_RUBY_2_7
+          old_inherited.bind_call(self, arg)
+        else
+          old_inherited.bind(self).call(arg)
+        end
         ::T::Private::Methods._hook_impl(arg, false, self)
       end
       @old_hooks = [old_included, old_extended, old_inherited]

data/lib/types/private/methods/call_validation.rb

@@ -14,7 +14,7 @@ module T::Private::Methods::CallValidation
   def self.wrap_method_if_needed(mod, method_sig, original_method)
     original_visibility = visibility_method_name(mod, method_sig.method_name)
     if method_sig.mode == T::Private::Methods::Modes.abstract
-      T::Private::ClassUtils.replace_method(mod, method_sig.method_name) do |*args, &blk|
+      T::Private::ClassUtils.replace_method(mod, method_sig.method_name, true) do |*args, &blk|
         # TODO: write a cop to ensure that abstract methods have an empty body
         #
         # We allow abstract methods to be implemented by things further down the ancestor chain.
@@ -59,8 +59,9 @@ module T::Private::Methods::CallValidation
 
   def self.create_validator_method(mod, original_method, method_sig, original_visibility)
     has_fixed_arity = method_sig.kwarg_types.empty? && !method_sig.has_rest && !method_sig.has_keyrest &&
-      original_method.parameters.all? {|(kind, _name)| kind == :req}
-    ok_for_fast_path = has_fixed_arity && !method_sig.bind && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
+      original_method.parameters.all? {|(kind, _name)| kind == :req || kind == :block}
+    can_skip_block_type = method_sig.block_type.nil? || method_sig.block_type.valid?(nil)
+    ok_for_fast_path = has_fixed_arity && can_skip_block_type && !method_sig.bind && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
 
     all_args_are_simple = ok_for_fast_path && method_sig.arg_types.all? {|_name, type| type.is_a?(T::Types::Simple)}
     simple_method = all_args_are_simple && method_sig.return_type.is_a?(T::Types::Simple)
@@ -76,6 +77,11 @@ module T::Private::Methods::CallValidation
           create_validator_procedure_medium(mod, original_method, method_sig, original_visibility)
         elsif ok_for_fast_path
           create_validator_method_medium(mod, original_method, method_sig, original_visibility)
+        elsif can_skip_block_type
+          # The Ruby VM already validates that any block passed to a method
+          # must be either `nil` or a `Proc` object, so there's no need to also
+          # have sorbet-runtime check that.
+          create_validator_slow_skip_block_type(mod, original_method, method_sig, original_visibility)
         else
           create_validator_slow(mod, original_method, method_sig, original_visibility)
         end
@@ -84,6 +90,88 @@ module T::Private::Methods::CallValidation
     end
   end
 
+  def self.create_validator_slow_skip_block_type(mod, original_method, method_sig, original_visibility)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |*args, &blk|
+      CallValidation.validate_call_skip_block_type(self, original_method, method_sig, args, blk)
+    end
+  end
+
+  def self.validate_call_skip_block_type(instance, original_method, method_sig, args, blk)
+    # This method is called for every `sig`. It's critical to keep it fast and
+    # reduce number of allocations that happen here.
+
+    if method_sig.bind
+      message = method_sig.bind.error_message_for_obj(instance)
+      if message
+        CallValidation.report_error(
+          method_sig,
+          message,
+          'Bind',
+          nil,
+          method_sig.bind,
+          instance
+        )
+      end
+    end
+
+    # NOTE: We don't bother validating for missing or extra kwargs;
+    # the method call itself will take care of that.
+    method_sig.each_args_value_type(args) do |name, arg, type|
+      message = type.error_message_for_obj(arg)
+      if message
+        CallValidation.report_error(
+          method_sig,
+          message,
+          'Parameter',
+          name,
+          type,
+          arg,
+          caller_offset: 2
+        )
+      end
+    end
+
+    # The original method definition allows passing `nil` for the `&blk`
+    # argument, so we do not have to do any method_sig.block_type type checks
+    # of our own.
+
+    # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+    # PRY note:
+    # this code is sig validation code.
+    # Please issue `finish` to step out of it
+
+    return_value = T::Configuration::AT_LEAST_RUBY_2_7 ? original_method.bind_call(instance, *args, &blk) : original_method.bind(instance).call(*args, &blk)
+
+    # The only type that is allowed to change the return value is `.void`.
+    # It ignores what you returned and changes it to be a private singleton.
+    if method_sig.return_type.is_a?(T::Private::Types::Void)
+      T::Private::Types::Void::VOID
+    else
+      message = method_sig.return_type.error_message_for_obj(return_value)
+      if message
+        CallValidation.report_error(
+          method_sig,
+          message,
+          'Return value',
+          nil,
+          method_sig.return_type,
+          return_value,
+        )
+      end
+      return_value
+    end
+  end
+
   def self.create_validator_slow(mod, original_method, method_sig, original_visibility)
     T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |*args, &blk|
       CallValidation.validate_call(self, original_method, method_sig, args, blk)
@@ -125,8 +213,19 @@ module T::Private::Methods::CallValidation
       end
     end
 
-    if method_sig.block_type
-      message = method_sig.block_type.error_message_for_obj(blk)
+    # The Ruby VM already checks that `&blk` is either a `Proc` type or `nil`:
+    # https://github.com/ruby/ruby/blob/v2_7_6/vm_args.c#L1150-L1154
+    # And `T.proc` types don't (can't) do any runtime arg checking, so we can
+    # save work by simply checking that `blk` is non-nil (if the method allows
+    # `nil` for the block, it would not have used this validate_call path).
+    unless blk
+      # Have to use `&.` here, because it's technically a public API that
+      # people can _always_ call `validate_call` to validate any signature
+      # (i.e., the faster validators are merely optimizations).
+      # In practice, this only affects the first call to the method (before the
+      # optimized validators have a chance to replace the initial, slow
+      # wrapper).
+      message = method_sig.block_type&.error_message_for_obj(blk)
       if message
         CallValidation.report_error(
           method_sig,