sorbet-runtime 0.5.5794 → 0.5.5942

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac9a48252c9529d0ca91f96108b141c85388c88180281e5c8a682b16c11a9d5a
-  data.tar.gz: 31dc95eabc00327b1672a8fc142da7dc47f0ee0699fd4112358042248628675b
+  metadata.gz: 4838c21772de1169f412a971cfe59e49fc482bda8de9fb70920fd4bcab5e654f
+  data.tar.gz: 5e27052a663a22e70e5aa3afee7563f43be650946ec4673df2fb246535a28bb6
 SHA512:
-  metadata.gz: 21b1ef4ffdd76365effafe0c6a3eea4b15c1f9c36f2f402a1c8ba382d2f03d89f2202c1b8ac2aa82c315c7471f0989f7501d1888a49f67d401d33d26ac8e4d3a
-  data.tar.gz: 0f4c110725910ae452ea72fe6852538aa1c31cbb576dc242fe3631bd318e3b2bfda7b0fe3b05362584bd53885c9788a4f3eb2d5920d285c1c39ce727fb0ebd14
+  metadata.gz: 87abc9d8a3a9a753d96577a52856c4e04b2dfaaefb1908e696d9882c04a593ab6cdd9112660afa887d57fd3df62dbf99fded5a697b176ac1c043011b3fd43db1
+  data.tar.gz: 6f10e93404924fbf7752eb01786e717d585472df7b2c77aaead247df1d170998ff46b8d3d8e5b51bad6773fc950280ebc3c922651078a249fef2d29929d75aef

data/lib/types/_types.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 # typed: true
 # This is where we define the shortcuts, so we can't use them here
-# rubocop:disable PrisonGuard/UseOpusTypesShortcut
 
 #  _____
 # |_   _|   _ _ __   ___  ___
@@ -26,23 +25,26 @@
 module T
   # T.any(<Type>, <Type>, ...) -- matches any of the types listed
   def self.any(type_a, type_b, *types)
-    T::Types::Union.new([type_a, type_b] + types)
+    type_a = T::Utils.coerce(type_a)
+    type_b = T::Utils.coerce(type_b)
+    types = types.map {|t| T::Utils.coerce(t)} if !types.empty?
+    T::Types::Union::Private::Pool.union_of_types(type_a, type_b, types)
   end
 
   # Shorthand for T.any(type, NilClass)
   def self.nilable(type)
-    T::Types::Union.new([type, NilClass])
+    T::Types::Union::Private::Pool.union_of_types(T::Utils.coerce(type), T::Utils::Nilable::NIL_TYPE)
   end
 
   # Matches any object. In the static checker, T.untyped allows any
   # method calls or operations.
   def self.untyped
-    T::Types::Untyped.new
+    T::Types::Untyped::Private::INSTANCE
   end
 
   # Indicates a function never returns (e.g. "Kernel#raise")
   def self.noreturn
-    T::Types::NoReturn.new
+    T::Types::NoReturn::Private::INSTANCE
   end
 
   # T.all(<Type>, <Type>, ...) -- matches an object that has all of the types listed
@@ -62,12 +64,12 @@ module T
 
   # Matches `self`:
   def self.self_type
-    T::Types::SelfType.new
+    T::Types::SelfType::Private::INSTANCE
   end
 
   # Matches the instance type in a singleton-class context
   def self.attached_class
-    T::Types::AttachedClassType.new
+    T::Types::AttachedClassType::Private::INSTANCE
   end
 
   # Matches any class that subclasses or includes the provided class
@@ -282,4 +284,3 @@ module T
     end
   end
 end
-# rubocop:enable PrisonGuard/UseOpusTypesShortcut

data/lib/types/configuration.rb

@@ -248,7 +248,7 @@ module T::Configuration
   end
 
   private_class_method def self.log_info_handler_default(str, extra)
-    puts "#{str}, extra: #{extra}" # rubocop:disable PrisonGuard/NoBarePuts
+    puts "#{str}, extra: #{extra}"
   end
 
   def self.log_info_handler(str, extra)
@@ -282,7 +282,7 @@ module T::Configuration
   end
 
   private_class_method def self.soft_assert_handler_default(str, extra)
-    puts "#{str}, extra: #{extra}" # rubocop:disable PrisonGuard/NoBarePuts
+    puts "#{str}, extra: #{extra}"
   end
 
   def self.soft_assert_handler(str, extra)

data/lib/types/enum.rb

@@ -57,6 +57,17 @@ class T::Enum
     @values
   end
 
+  # This exists for compatibility with the interface of `Hash` & mostly to support
+  # the HashEachMethods Rubocop.
+  sig {params(blk: T.nilable(T.proc.params(arg0: T.attached_class).void)).returns(T.any(T::Enumerator[T.attached_class], T::Array[T.attached_class]))}
+  def self.each_value(&blk)
+    if blk
+      values.each(&blk)
+    else
+      values.each
+    end
+  end
+
   # Convert from serialized value to enum instance
   #
   # Note: It would have been nice to make this method final before people started overriding it.
@@ -88,7 +99,7 @@ class T::Enum
 
   # Note: It would have been nice to make this method final before people started overriding it.
   # @return [Boolean] Does the given serialized value correspond with any of this enum's values.
-  sig {overridable.params(serialized_val: SerializedVal).returns(T::Boolean)}
+  sig {overridable.params(serialized_val: SerializedVal).returns(T::Boolean).checked(:never)}
   def self.has_serialized?(serialized_val)
     if @mapping.nil?
       raise "Attempting to access serialization map of #{self.class} before it has been initialized." \

data/lib/types/generic.rb

@@ -14,10 +14,10 @@ module T::Generic
   end
 
   def type_member(variance=:invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
-    T::Types::TypeMember.new(variance) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+    T::Types::TypeMember.new(variance)
   end
 
   def type_template(variance=:invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
-    T::Types::TypeTemplate.new(variance) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+    T::Types::TypeTemplate.new(variance)
   end
 end

data/lib/types/interface_wrapper.rb

@@ -83,11 +83,11 @@ class T::InterfaceWrapper
     end
   end
 
-  def kind_of?(other) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+  def kind_of?(other)
     is_a?(other)
   end
 
-  def is_a?(other) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+  def is_a?(other)
     if !other.is_a?(Module)
       raise TypeError.new("class or module required")
     end
@@ -99,13 +99,13 @@ class T::InterfaceWrapper
 
   # Prefixed because we're polluting the namespace of the interface we're wrapping, and we don't
   # want anyone else (besides dynamic_cast) calling it.
-  def __target_obj_DO_NOT_USE
+  def __target_obj_DO_NOT_USE # rubocop:disable Naming/MethodName
     @target_obj
   end
 
   # Prefixed because we're polluting the namespace of the interface we're wrapping, and we don't
   # want anyone else (besides wrapped_dynamic_cast) calling it.
-  def __interface_mod_DO_NOT_USE
+  def __interface_mod_DO_NOT_USE # rubocop:disable Naming/MethodName
     @interface_mod
   end
 

data/lib/types/non_forcing_constants.rb

@@ -4,8 +4,11 @@
 module T::NonForcingConstants
   # NOTE: This method is documented on the RBI in Sorbet's payload, so that it
   # shows up in the hover/completion documentation via LSP.
-  T::Sig::WithoutRuntime.sig {params(val: BasicObject, klass: String).returns(T::Boolean)}
-  def self.non_forcing_is_a?(val, klass)
+  T::Sig::WithoutRuntime.sig {params(val: BasicObject, klass: String, package: T.nilable(String)).returns(T::Boolean)}
+  def self.non_forcing_is_a?(val, klass, package: nil)
+    # TODO(gdritter): once we have a runtime implementation of
+    # packages, we'll need to actually handle the `package` argument
+    # here.
     method_name = "T::NonForcingConstants.non_forcing_is_a?"
     if klass.empty?
       raise ArgumentError.new("The string given to `#{method_name}` must not be empty")
@@ -18,7 +21,10 @@ module T::NonForcingConstants
     parts.each do |part|
       if current_klass.nil?
         # First iteration
-        if part != ""
+        if part != "" && package.nil?
+          # if we've supplied a package, we're probably running in
+          # package mode, which means absolute references are
+          # meaningless
           raise ArgumentError.new("The string given to `#{method_name}` must be an absolute constant reference that starts with `::`")
         end
 

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

@@ -12,11 +12,11 @@
 # modules that override the `hash` method with something completely broken.
 module T::Private::Abstract::Data
   def self.get(mod, key)
-    mod.instance_variable_get("@opus_abstract__#{key}") # rubocop:disable PrisonGuard/NoLurkyInstanceVariableAccess
+    mod.instance_variable_get("@opus_abstract__#{key}")
   end
 
   def self.set(mod, key, value)
-    mod.instance_variable_set("@opus_abstract__#{key}", value) # rubocop:disable PrisonGuard/NoLurkyInstanceVariableAccess
+    mod.instance_variable_set("@opus_abstract__#{key}", value)
   end
 
   def self.key?(mod, key)

data/lib/types/private/casts.rb

@@ -2,6 +2,14 @@
 # typed: false
 
 module T::Private
+  # Dynamically confirm that `value` is recursively a valid value of
+  # type `type`, including recursively through collections. Note that
+  # in some cases this runtime check can be very expensive, especially
+  # with large collections of objects.
+  def self.check_type_recursive!(value, type)
+    T::Private::Casts.cast_recursive(value, type, cast_method: "T.check_type_recursive!")
+  end
+
   module Casts
     def self.cast(value, type, cast_method:)
       begin
@@ -18,5 +26,24 @@ module T::Private
         value
       end
     end
+
+    # there's a lot of shared logic with the above one, but factoring
+    # it out like this makes it easier to hopefully one day delete
+    # this one
+    def self.cast_recursive(value, type, cast_method:)
+      begin
+        error = T::Utils.coerce(type).error_message_for_obj_recursive(value)
+        return value unless error
+
+        caller_loc = T.must(caller_locations(2..2)).first
+
+        suffix = "Caller: #{T.must(caller_loc).path}:#{T.must(caller_loc).lineno}"
+
+        raise TypeError.new("#{cast_method}: #{error}\n#{suffix}")
+      rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
+        T::Configuration.inline_type_error_handler(e)
+        value
+      end
+    end
   end
 end

data/lib/types/private/class_utils.rb

@@ -33,16 +33,16 @@ module T::Private::ClassUtils
       if @overwritten
         # The original method was overwritten. Overwrite again to restore it.
         T::Configuration.without_ruby_warnings do
-          @mod.send(:define_method, @old_method.name, @old_method) # rubocop:disable PrisonGuard/UsePublicSend
+          @mod.send(:define_method, @old_method.name, @old_method)
         end
       else
         # The original method was in an ancestor. Restore it by removing the overriding method.
-        @mod.send(:remove_method, @old_method.name) # rubocop:disable PrisonGuard/UsePublicSend
+        @mod.send(:remove_method, @old_method.name)
       end
 
       # Restore the visibility. Note that we need to do this even when we call remove_method
       # above, because the module may have set custom visibility for a method it inherited.
-      @mod.send(@visibility, @old_method.name) # rubocop:disable PrisonGuard/UsePublicSend
+      @mod.send(@visibility, @old_method.name)
 
       nil
     end
@@ -97,13 +97,13 @@ module T::Private::ClassUtils
     overwritten = original_owner == mod
     T::Configuration.without_ruby_warnings do
       T::Private::DeclState.current.without_on_method_added do
-        mod.send(:define_method, name, &blk) # rubocop:disable PrisonGuard/UsePublicSend
+        mod.send(:define_method, name, &blk)
         if blk.arity < 0 && mod.respond_to?(:ruby2_keywords, true)
           mod.send(:ruby2_keywords, name)
         end
       end
     end
-    mod.send(original_visibility, name) # rubocop:disable PrisonGuard/UsePublicSend
+    mod.send(original_visibility, name)
     new_method = mod.instance_method(name)
 
     ReplacedMethod.new(mod, original_method, new_method, overwritten, original_visibility)

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

@@ -72,7 +72,7 @@ module T::Private::Methods
       decl.params = {}
     end
 
-    T::Types::Proc.new(decl.params, decl.returns) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+    T::Types::Proc.new(decl.params, decl.returns)
   end
 
   # See docs at T::Utils.register_forwarder.
@@ -206,22 +206,12 @@ module T::Private::Methods
     # (or unwrap back to the original method).
     new_method = nil
     T::Private::ClassUtils.replace_method(mod, method_name) do |*args, &blk|
-      if !T::Private::Methods.has_sig_block_for_method(new_method)
-        # This should only happen if the user used alias_method to grab a handle
-        # to the original pre-unwound `sig` method. I guess we'll just proxy the
-        # call forever since we don't know who is holding onto this handle to
-        # replace it.
-        new_new_method = mod.instance_method(method_name)
-        if new_method == new_new_method
-          raise "`sig` not present for method `#{method_name}` but you're trying to run it anyways. " \
-          "This should only be executed if you used `alias_method` to grab a handle to a method after `sig`ing it, but that clearly isn't what you are doing. " \
-          "Maybe look to see if an exception was thrown in your `sig` lambda or somehow else your `sig` wasn't actually applied to the method. " \
-          "Contact #dev-productivity if you're really stuck."
-        end
-        return new_new_method.bind(self).call(*args, &blk)
-      end
-
-      method_sig = T::Private::Methods.run_sig_block_for_method(new_method)
+      method_sig = T::Private::Methods.maybe_run_sig_block_for_method(new_method)
+      method_sig ||= T::Private::Methods._handle_missing_method_signature(
+        self,
+        original_method,
+        __callee__,
+      )
 
       # Should be the same logic as CallValidation.wrap_method_if_needed but we
       # don't want that extra layer of indirection in the callstack
@@ -252,6 +242,43 @@ module T::Private::Methods
     end
   end
 
+  def self._handle_missing_method_signature(receiver, original_method, callee)
+    method_sig = T::Private::Methods.signature_for_method(original_method)
+    if !method_sig
+      raise "`sig` not present for method `#{callee}` on #{receiver.inspect} but you're trying to run it anyways. " \
+        "This should only be executed if you used `alias_method` to grab a handle to a method after `sig`ing it, but that clearly isn't what you are doing. " \
+        "Maybe look to see if an exception was thrown in your `sig` lambda or somehow else your `sig` wasn't actually applied to the method."
+    end
+
+    if receiver.class <= original_method.owner
+      receiving_class = receiver.class
+    elsif receiver.singleton_class <= original_method.owner
+      receiving_class = receiver.singleton_class
+    elsif receiver.is_a?(Module) && receiver <= original_method.owner
+      receiving_class = receiver
+    else
+      raise "#{receiver} is not related to #{original_method} - how did we get here?"
+    end
+
+    # Check for a case where `alias` or `alias_method` was called for a
+    # method which had already had a `sig` applied. In that case, we want
+    # to avoid hitting this slow path again, by moving to a faster validator
+    # just like we did or will for the original method.
+    #
+    # If this isn't an `alias` or `alias_method` case, we're probably in the
+    # middle of some metaprogramming using a Method object, e.g. a pattern like
+    # `arr.map(&method(:foo))`. There's nothing really we can do to optimize
+    # that here.
+    receiving_method = receiving_class.instance_method(callee)
+    if receiving_method != original_method && receiving_method.original_name == original_method.name
+      aliasing_mod = receiving_method.owner
+      method_sig = method_sig.as_alias(callee)
+      unwrap_method(aliasing_mod, method_sig, original_method)
+    end
+
+    method_sig
+  end
+
   # Executes the `sig` block, and converts the resulting Declaration
   # to a Signature.
   def self.run_sig(hook_mod, method_name, original_method, declaration_block)
@@ -270,7 +297,7 @@ module T::Private::Methods
         Signature.new_untyped(method: original_method)
       end
 
-    unwrap_method(hook_mod, signature, original_method)
+    unwrap_method(signature.method.owner, signature, original_method)
     signature
   end
 
@@ -284,8 +311,12 @@ module T::Private::Methods
 
   def self.build_sig(hook_mod, method_name, original_method, current_declaration, loc)
     begin
-      # We allow `sig` in the current module's context (normal case) and inside `class << self`
-      if hook_mod != current_declaration.mod && hook_mod.singleton_class != current_declaration.mod
+      # We allow `sig` in the current module's context (normal case) and
+      if hook_mod != current_declaration.mod &&
+          # inside `class << self`, and
+          hook_mod.singleton_class != current_declaration.mod &&
+          # on `self` at the top level of a file
+          current_declaration.mod != TOP_SELF
         raise "A method (#{method_name}) is being added on a different class/module (#{hook_mod}) than the " \
               "last call to `sig` (#{current_declaration.mod}). Make sure each call " \
               "to `sig` is immediately followed by a method definition on the same " \
@@ -322,8 +353,8 @@ module T::Private::Methods
     end
   end
 
-  def self.unwrap_method(hook_mod, signature, original_method)
-    maybe_wrapped_method = CallValidation.wrap_method_if_needed(signature.method.owner, signature, original_method)
+  def self.unwrap_method(mod, signature, original_method)
+    maybe_wrapped_method = CallValidation.wrap_method_if_needed(mod, signature, original_method)
     @signatures_by_method[method_to_key(maybe_wrapped_method)] = signature
   end
 
@@ -435,6 +466,20 @@ module T::Private::Methods
     return if @installed_hooks.include?(mod)
     @installed_hooks << mod
 
+    if mod == TOP_SELF
+      # self at the top-level of a file is weirdly special in Ruby
+      # The Ruby VM on startup creates an `Object.new` and stashes it.
+      # Unlike when we're using sig inside a module, `self` is actually a
+      # normal object, not an instance of Module.
+      #
+      # Thus we can't ask things like mod.singleton_class? (since that's
+      # defined only on Module, not on Object) and even if we could, the places
+      # where we need to install the hooks are special.
+      mod.extend(SingletonMethodHooks) # def self.foo; end (at top level)
+      Object.extend(MethodHooks)       # def foo; end      (at top level)
+      return
+    end
+
     if mod.singleton_class?
       mod.include(SingletonMethodHooks)
     else
@@ -454,7 +499,12 @@ module T::Private::Methods
 
   private_class_method def self.key_to_method(key)
     id, name = key.split("#")
-    obj = ObjectSpace._id2ref(id.to_i) # rubocop:disable PrisonGuard/NoDynamicConstAccess
+    obj = ObjectSpace._id2ref(id.to_i)
     obj.instance_method(name)
   end
 end
+
+# This has to be here, and can't be nested inside `T::Private::Methods`,
+# because the value of `self` depends on lexical (nesting) scope, and we
+# specifically need a reference to the file-level self, i.e. `main:Object`
+T::Private::Methods::TOP_SELF = self

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

@@ -121,6 +121,15 @@ class T::Private::Methods::Signature
     end
   end
 
+  attr_writer :method_name
+  protected :method_name=
+
+  def as_alias(alias_name)
+    new_sig = clone
+    new_sig.method_name = alias_name
+    new_sig
+  end
+
   def arg_count
     @arg_types.length
   end
@@ -146,9 +155,10 @@ class T::Private::Methods::Signature
     # can't) match the definition of the method we're validating. In addition, Ruby has a bug that
     # causes forwarding **kwargs to do the wrong thing: see https://bugs.ruby-lang.org/issues/10708
     # and https://bugs.ruby-lang.org/issues/11860.
-    if (args.length > @req_arg_count) && (!@kwarg_types.empty? || @has_keyrest) && args[-1].is_a?(Hash)
+    args_length = args.length
+    if (args_length > @req_arg_count) && (!@kwarg_types.empty? || @has_keyrest) && args[-1].is_a?(Hash)
       kwargs = args[-1]
-      args = args[0...-1]
+      args_length -= 1
     else
       kwargs = EMPTY_HASH
     end
@@ -156,19 +166,19 @@ class T::Private::Methods::Signature
     arg_types = @arg_types
 
     if @has_rest
-      arg_types += [[@rest_name, @rest_type]] * (args.length - @arg_types.length)
+      arg_types += [[@rest_name, @rest_type]] * (args_length - @arg_types.length)
 
-    elsif (args.length < @req_arg_count) || (args.length > @arg_types.length)
+    elsif (args_length < @req_arg_count) || (args_length > @arg_types.length)
       expected_str = @req_arg_count.to_s
       if @arg_types.length != @req_arg_count
         expected_str += "..#{@arg_types.length}"
       end
-      raise ArgumentError.new("wrong number of arguments (given #{args.length}, expected #{expected_str})")
+      raise ArgumentError.new("wrong number of arguments (given #{args_length}, expected #{expected_str})")
     end
 
     begin
       it = 0
-      while it < args.length
+      while it < args_length
         yield arg_types[it][0], args[it], arg_types[it][1]
         it += 1
       end

data/lib/types/private/sealed.rb

@@ -46,7 +46,7 @@ module T::Private::Sealed
   end
 
   def self.validate_inheritance(this_line, parent, verb)
-    this_file = this_line&.split(':').first
+    this_file = this_line&.split(':')&.first
     decl_file = parent.instance_variable_get(:@sorbet_sealed_module_decl_file)
 
     if !this_file || !decl_file

data/lib/types/private/types/type_alias.rb

@@ -18,6 +18,11 @@ module T::Private::Types
       aliased_type.name
     end
 
+    # @override Base
+    def recursively_valid?(obj)
+      aliased_type.recursively_valid?(obj)
+    end
+
     # @override Base
     def valid?(obj)
       aliased_type.valid?(obj)

data/lib/types/profile.rb

@@ -10,7 +10,11 @@ module T::Profile
     def typecheck_duration_estimate
       total_typechecks = typecheck_samples * SAMPLE_RATE + (SAMPLE_RATE - typecheck_sample_attempts)
       typechecks_measured = typecheck_samples * SAMPLE_RATE
-      typecheck_duration * SAMPLE_RATE * 1.0 * total_typechecks / typechecks_measured
+      if typechecks_measured.positive?
+        typecheck_duration * SAMPLE_RATE * 1.0 * total_typechecks / typechecks_measured
+      else
+        0.0
+      end
     end
 
     def typecheck_count_estimate

data/lib/types/props/constructor.rb

@@ -17,11 +17,16 @@ module T::Props::Constructor::DecoratorMethods
   # checked(:never) - O(runtime object construction)
   sig {params(instance: T::Props::Constructor, hash: T::Hash[Symbol, T.untyped]).returns(Integer).checked(:never)}
   def construct_props_without_defaults(instance, hash)
-    @props_without_defaults&.count do |p, setter_proc|
+    # Use `each_pair` rather than `count` because, as of Ruby 2.6, the latter delegates to Enumerator
+    # and therefore allocates for each entry.
+    result = 0
+    @props_without_defaults&.each_pair do |p, setter_proc|
       begin
         val = hash[p]
         instance.instance_exec(val, &setter_proc)
-        val || hash.key?(p)
+        if val || hash.key?(p)
+          result += 1
+        end
       rescue TypeError, T::Props::InvalidValueError
         if !hash.key?(p)
           raise ArgumentError.new("Missing required prop `#{p}` for class `#{instance.class.name}`")
@@ -29,6 +34,7 @@ module T::Props::Constructor::DecoratorMethods
           raise
         end
       end
-    end || 0
+    end
+    result
   end
 end

data/lib/types/props/decorator.rb

@@ -427,7 +427,7 @@ class T::Props::Decorator
       # TODO(PRIVACYENG-982) Ideally we'd also check for 'password' and possibly
       # other terms, but this interacts badly with ProtoDefinedDocument because
       # the proto syntax currently can't declare "sensitivity: []"
-      if prop_name =~ /\bsecret\b/
+      if /\bsecret\b/.match?(prop_name)
         T::Configuration.hard_assert_handler(
           "#{@class}##{prop_name} has the word 'secret' in its name, but no " \
           "'sensitivity:' annotation. This is probably wrong, because if a " \

data/lib/types/props/generated_code_validation.rb

@@ -170,7 +170,7 @@ module T::Props
 
     private_class_method def self.validate_deserialize_handle_nil(node)
       case node.type
-      when :hash, :array, :str, :sym, :int, :float, :true, :false, :nil, :const
+      when :hash, :array, :str, :sym, :int, :float, :true, :false, :nil, :const # rubocop:disable Lint/BooleanSymbol
         # Primitives and constants are safe
       when :send
         receiver, method, arg = node.children
@@ -209,7 +209,7 @@ module T::Props
       when :const
         # This is ok, because we'll have validated what method has been called
         # if applicable
-      when :hash, :array, :str, :sym, :int, :float, :true, :false, :nil, :self
+      when :hash, :array, :str, :sym, :int, :float, :true, :false, :nil, :self # rubocop:disable Lint/BooleanSymbol
         # Primitives & self are ok
       when :lvar, :arg, :ivar
         # Reading local & instance variables & arguments is ok

data/lib/types/props/plugin.rb

@@ -22,7 +22,7 @@ module T::Props::Plugin
       if plugin.const_defined?('ClassMethods')
         # FIXME: This will break preloading, selective test execution, etc if `mod::ClassMethods`
         # is ever defined in a separate file from `mod`.
-        target.extend(plugin::ClassMethods) # rubocop:disable PrisonGuard/NoDynamicConstAccess
+        target.extend(plugin::ClassMethods)
       end
     end
 
@@ -30,7 +30,7 @@ module T::Props::Plugin
       if plugin.const_defined?('DecoratorMethods')
         # FIXME: This will break preloading, selective test execution, etc if `mod::DecoratorMethods`
         # is ever defined in a separate file from `mod`.
-        target.extend(plugin::DecoratorMethods) # rubocop:disable PrisonGuard/NoDynamicConstAccess
+        target.extend(plugin::DecoratorMethods)
       end
     end
   end

data/lib/types/props/private/setter_factory.rb

@@ -52,7 +52,12 @@ module T::Props
       end
       private_class_method def self.non_nil_proc(prop, accessor_key, non_nil_type, klass, validate)
         proc do |val|
-          if non_nil_type.valid?(val)
+          # this use of recursively_valid? is intentional: unlike for
+          # methods, we want to make sure data at the 'edge'
+          # (e.g. models that go into databases or structs serialized
+          # from disk) are correct, so we use more thorough runtime
+          # checks there
+          if non_nil_type.recursively_valid?(val)
             if validate
               validate.call(prop, val)
             end
@@ -83,7 +88,12 @@ module T::Props
         proc do |val|
           if val.nil?
             instance_variable_set(accessor_key, nil)
-          elsif non_nil_type.valid?(val)
+          # this use of recursively_valid? is intentional: unlike for
+          # methods, we want to make sure data at the 'edge'
+          # (e.g. models that go into databases or structs serialized
+          # from disk) are correct, so we use more thorough runtime
+          # checks there
+          elsif non_nil_type.recursively_valid?(val)
             if validate
               validate.call(prop, val)
             end

data/lib/types/props/serializable.rb

@@ -121,8 +121,8 @@ module T::Props::Serializable
   private def with_existing_hash(changed_props, existing_hash:)
     serialized = existing_hash
     new_val = self.class.from_hash(serialized.merge(recursive_stringify_keys(changed_props)))
-    old_extra = self.instance_variable_get(:@_extra_props) # rubocop:disable PrisonGuard/NoLurkyInstanceVariableAccess
-    new_extra = new_val.instance_variable_get(:@_extra_props) # rubocop:disable PrisonGuard/NoLurkyInstanceVariableAccess
+    old_extra = self.instance_variable_get(:@_extra_props)
+    new_extra = new_val.instance_variable_get(:@_extra_props)
     if old_extra != new_extra
       difference =
         if old_extra

data/lib/types/props/weak_constructor.rb

@@ -30,14 +30,16 @@ module T::Props::WeakConstructor::DecoratorMethods
   # checked(:never) - O(runtime object construction)
   sig {params(instance: T::Props::WeakConstructor, hash: T::Hash[Symbol, T.untyped]).returns(Integer).checked(:never)}
   def construct_props_without_defaults(instance, hash)
-    @props_without_defaults&.count do |p, setter_proc|
+    # Use `each_pair` rather than `count` because, as of Ruby 2.6, the latter delegates to Enumerator
+    # and therefore allocates for each entry.
+    result = 0
+    @props_without_defaults&.each_pair do |p, setter_proc|
       if hash.key?(p)
         instance.instance_exec(hash[p], &setter_proc)
-        true
-      else
-        false
+        result += 1
       end
-    end || 0
+    end
+    result
   end
 
   # Set values for all props that have defaults. Use the default if and only if
@@ -49,14 +51,17 @@ module T::Props::WeakConstructor::DecoratorMethods
   # checked(:never) - O(runtime object construction)
   sig {params(instance: T::Props::WeakConstructor, hash: T::Hash[Symbol, T.untyped]).returns(Integer).checked(:never)}
   def construct_props_with_defaults(instance, hash)
-    @props_with_defaults&.count do |p, default_struct|
+    # Use `each_pair` rather than `count` because, as of Ruby 2.6, the latter delegates to Enumerator
+    # and therefore allocates for each entry.
+    result = 0
+    @props_with_defaults&.each_pair do |p, default_struct|
       if hash.key?(p)
         instance.instance_exec(hash[p], &default_struct.setter_proc)
-        true
+        result += 1
       else
         default_struct.set_default(instance)
-        false
       end
-    end || 0
+    end
+    result
   end
 end

data/lib/types/sig.rb

@@ -7,7 +7,7 @@ module T::Sig
   module WithoutRuntime
     # At runtime, does nothing, but statically it is treated exactly the same
     # as T::Sig#sig. Only use it in cases where you can't use T::Sig#sig.
-    def self.sig(arg0=nil, &blk); end # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+    def self.sig(arg0=nil, &blk); end
 
     original_verbose = $VERBOSE
     $VERBOSE = false
@@ -15,7 +15,7 @@ module T::Sig
     # At runtime, does nothing, but statically it is treated exactly the same
     # as T::Sig#sig. Only use it in cases where you can't use T::Sig#sig.
     T::Sig::WithoutRuntime.sig {params(arg0: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
-    def self.sig(arg0=nil, &blk); end # rubocop:disable PrisonGuard/BanBuiltinMethodOverride, Lint/DuplicateMethods
+    def self.sig(arg0=nil, &blk); end # rubocop:disable Lint/DuplicateMethods
 
     $VERBOSE = original_verbose
   end
@@ -24,7 +24,7 @@ module T::Sig
   # abstract/override/... helpers. See the documentation URL on
   # {T::Helpers}
   T::Sig::WithoutRuntime.sig {params(arg0: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
-  def sig(arg0=nil, &blk) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+  def sig(arg0=nil, &blk)
     T::Private::Methods.declare_sig(self, arg0, &blk)
   end
 end

data/lib/types/types/attached_class.rb

@@ -12,7 +12,7 @@ module T::Types
 
     # @override Base
     def name
-      "AttachedClass"
+      "T.attached_class"
     end
 
     # @override Base
@@ -29,5 +29,9 @@ module T::Types
         false
       end
     end
+
+    module Private
+      INSTANCE = AttachedClassType.new.freeze
+    end
   end
 end

data/lib/types/types/base.rb

@@ -16,6 +16,11 @@ module T::Types
       end
     end
 
+    # this will be redefined in certain subclasses
+    def recursively_valid?(obj)
+      valid?(obj)
+    end
+
     def valid?(obj)
       raise NotImplementedError
     end
@@ -130,6 +135,14 @@ module T::Types
       end
     end
 
+    def error_message_for_obj_recursive(obj)
+      if recursively_valid?(obj)
+        nil
+      else
+        "Expected type #{self.name}, got #{describe_obj(obj)}"
+      end
+    end
+
     def validate!(obj)
       err = error_message_for_obj(obj)
       raise TypeError.new(err) if err

data/lib/types/types/fixed_array.rb

@@ -17,10 +17,36 @@ module T::Types
       "[#{@types.join(', ')}]"
     end
 
+    # @override Base
+    def recursively_valid?(obj)
+      if obj.is_a?(Array) && obj.length == @types.length
+        i = 0
+        while i < @types.length
+          if !@types[i].recursively_valid?(obj[i])
+            return false
+          end
+          i += 1
+        end
+        true
+      else
+        false
+      end
+    end
+
     # @override Base
     def valid?(obj)
-      obj.is_a?(Array) && obj.length == @types.length &&
-        obj.zip(@types).all? {|item, type| type.valid?(item)}
+      if obj.is_a?(Array) && obj.length == @types.length
+        i = 0
+        while i < @types.length
+          if !@types[i].valid?(obj[i])
+            return false
+          end
+          i += 1
+        end
+        true
+      else
+        false
+      end
     end
 
     # @override Base

data/lib/types/types/fixed_hash.rb

@@ -17,17 +17,18 @@ module T::Types
     end
 
     # @override Base
-    def valid?(obj)
+    def recursively_valid?(obj)
       return false unless obj.is_a?(Hash)
+      return false if @types.any? {|key, type| !type.recursively_valid?(obj[key])}
+      return false if obj.any? {|key, _| !@types[key]}
+      true
+    end
 
-      @types.each do |key, type|
-        return false unless type.valid?(obj[key])
-      end
-
-      obj.each_key do |key|
-        return false unless @types[key]
-      end
-
+    # @override Base
+    def valid?(obj)
+      return false unless obj.is_a?(Hash)
+      return false if @types.any? {|key, type| !type.valid?(obj[key])}
+      return false if obj.any? {|key, _| !@types[key]}
       true
     end
 

data/lib/types/types/intersection.rb

@@ -23,6 +23,11 @@ module T::Types
       "T.all(#{@types.map(&:name).sort.join(', ')})"
     end
 
+    # @override Base
+    def recursively_valid?(obj)
+      @types.all? {|type| type.recursively_valid?(obj)}
+    end
+
     # @override Base
     def valid?(obj)
       @types.all? {|type| type.valid?(obj)}

data/lib/types/types/noreturn.rb

@@ -21,5 +21,9 @@ module T::Types
     private def subtype_of_single?(other)
       true
     end
+
+    module Private
+      INSTANCE = NoReturn.new.freeze
+    end
   end
 end

data/lib/types/types/self_type.rb

@@ -27,5 +27,9 @@ module T::Types
           false
       end
     end
+
+    module Private
+      INSTANCE = SelfType.new.freeze
+    end
   end
 end

data/lib/types/types/simple.rb

@@ -12,7 +12,11 @@ module T::Types
 
     # @override Base
     def name
-      @raw_type.name
+      # Memoize to mitigate pathological performance with anonymous modules (https://bugs.ruby-lang.org/issues/11119)
+      #
+      # `name` isn't normally a hot path for types, but it is used in initializing a T::Types::Union,
+      # and so in `T.nilable`, and so in runtime constructions like `x = T.let(nil, T.nilable(Integer))`.
+      @name ||= @raw_type.name.freeze
     end
 
     # @override Base
@@ -29,5 +33,22 @@ module T::Types
         false
       end
     end
+
+    def to_nilable
+      @nilable ||= T::Types::Union.new([self, T::Utils::Nilable::NIL_TYPE])
+    end
+
+    module Private
+      module Pool
+        def self.type_for_module(mod)
+          cached = mod.instance_variable_get(:@__as_sorbet_simple_type)
+          return cached if cached
+
+          type = Simple.new(mod)
+          mod.instance_variable_set(:@__as_sorbet_simple_type, type) unless mod.frozen?
+          type
+        end
+      end
+    end
   end
 end

data/lib/types/types/typed_array.rb

@@ -13,11 +13,16 @@ module T::Types
     end
 
     # @override Base
-    def valid?(obj)
+    def recursively_valid?(obj)
       obj.is_a?(Array) && super
     end
 
-    def new(*args) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Array)
+    end
+
+    def new(*args)
       Array.new(*T.unsafe(args))
     end
 

data/lib/types/types/typed_enumerable.rb

@@ -23,13 +23,18 @@ module T::Types
 
     # @override Base
     def valid?(obj)
+      obj.is_a?(Enumerable)
+    end
+
+    # @override Base
+    def recursively_valid?(obj)
       return false unless obj.is_a?(Enumerable)
       case obj
       when Array
         begin
           it = 0
           while it < obj.count
-            return false unless @type.valid?(obj[it])
+            return false unless @type.recursively_valid?(obj[it])
             it += 1
           end
           return true
@@ -42,8 +47,8 @@ module T::Types
         value_type = types[1]
         obj.each_pair do |key, val|
           # Some objects (I'm looking at you Rack::Utils::HeaderHash) don't
-          # iterate over a [key, value] array, so we can't juse use the @type.valid?(v)
-          return false if !key_type.valid?(key) || !value_type.valid?(val)
+          # iterate over a [key, value] array, so we can't juse use the @type.recursively_valid?(v)
+          return false if !key_type.recursively_valid?(key) || !value_type.recursively_valid?(val)
         end
         return true
       when Enumerator
@@ -54,10 +59,10 @@ module T::Types
         # boundlessness, it does not express a type. For example `(nil...nil)` is not a T::Range[NilClass], its a range
         # of unknown types (T::Range[T.untyped]).
         # Similarly, `(nil...1)` is not a `T::Range[T.nilable(Integer)]`, it's a boundless range of Integer.
-        (obj.begin.nil? || @type.valid?(obj.begin)) && (obj.end.nil? || @type.valid?(obj.end))
+        (obj.begin.nil? || @type.recursively_valid?(obj.begin)) && (obj.end.nil? || @type.recursively_valid?(obj.end))
       when Set
         obj.each do |item|
-          return false unless @type.valid?(item)
+          return false unless @type.recursively_valid?(item)
         end
 
         return true
@@ -144,7 +149,8 @@ module T::Types
         # enumerating the object is a destructive operation and might hang.
         obj.class
       else
-        self.class.new(type_from_instances(obj))
+        # This is a specialized enumerable type, just return the class.
+        Object.instance_method(:class).bind(obj).call
       end
     end
 

data/lib/types/types/typed_enumerator.rb

@@ -15,11 +15,16 @@ module T::Types
     end
 
     # @override Base
-    def valid?(obj)
+    def recursively_valid?(obj)
       obj.is_a?(Enumerator) && super
     end
 
-    def new(*args, &blk) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Enumerator)
+    end
+
+    def new(*args, &blk)
       T.unsafe(Enumerator).new(*args, &blk)
     end
 

data/lib/types/types/typed_hash.rb

@@ -22,12 +22,17 @@ module T::Types
     end
 
     # @override Base
-    def valid?(obj)
+    def recursively_valid?(obj)
       obj.is_a?(Hash) && super
     end
 
-    def new(*args, &blk) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
-      Hash.new(*T.unsafe(args), &blk) # rubocop:disable PrisonGuard/RestrictHashDefaults
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Hash)
+    end
+
+    def new(*args, &blk)
+      Hash.new(*T.unsafe(args), &blk)
     end
 
     class Untyped < TypedHash

data/lib/types/types/typed_range.rb

@@ -15,11 +15,16 @@ module T::Types
     end
 
     # @override Base
-    def valid?(obj)
+    def recursively_valid?(obj)
       obj.is_a?(Range) && super
     end
 
-    def new(*args) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Range)
+    end
+
+    def new(*args)
       T.unsafe(Range).new(*args)
     end
   end

data/lib/types/types/typed_set.rb

@@ -15,11 +15,16 @@ module T::Types
     end
 
     # @override Base
-    def valid?(obj)
+    def recursively_valid?(obj)
       obj.is_a?(Set) && super
     end
 
-    def new(*args) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+    # @override Base
+    def valid?(obj)
+      obj.is_a?(Set)
+    end
+
+    def new(*args)
       Set.new(*T.unsafe(args))
     end
 

data/lib/types/types/union.rb

@@ -43,12 +43,13 @@ module T::Types
     end
 
     # @override Base
-    def valid?(obj)
-      @types.each do |type|
-        return true if type.valid?(obj)
-      end
+    def recursively_valid?(obj)
+      @types.any? {|type| type.recursively_valid?(obj)}
+    end
 
-      false
+    # @override Base
+    def valid?(obj)
+      @types.any? {|type| type.valid?(obj)}
     end
 
     # @override Base
@@ -56,5 +57,35 @@ module T::Types
       raise "This should never be reached if you're going through `subtype_of?` (and you should be)"
     end
 
+    module Private
+      module Pool
+        EMPTY_ARRAY = [].freeze
+        private_constant :EMPTY_ARRAY
+
+        # @param type_a [T::Types::Base]
+        # @param type_b [T::Types::Base]
+        # @param types [Array] optional array of additional T::Types::Base instances
+        def self.union_of_types(type_a, type_b, types=EMPTY_ARRAY)
+          if types.empty?
+            # We aren't guaranteed to detect a simple `T.nilable(<Module>)` type here
+            # in cases where there are duplicate types, nested unions, etc.
+            #
+            # That's ok, because this is an optimization which isn't necessary for
+            # correctness.
+            if type_b == T::Utils::Nilable::NIL_TYPE && type_a.is_a?(T::Types::Simple)
+              type_a.to_nilable
+            elsif type_a == T::Utils::Nilable::NIL_TYPE && type_b.is_a?(T::Types::Simple)
+              type_b.to_nilable
+            else
+              Union.new([type_a, type_b])
+            end
+          else
+            # This can't be a `T.nilable(<Module>)` case unless there are duplicates,
+            # which is possible but unexpected.
+            Union.new([type_a, type_b] + types)
+          end
+        end
+      end
+    end
   end
 end

data/lib/types/types/untyped.rb

@@ -21,5 +21,9 @@ module T::Types
     private def subtype_of_single?(other)
       true
     end
+
+    module Private
+      INSTANCE = Untyped.new.freeze
+    end
   end
 end

data/lib/types/utils.rb

@@ -21,15 +21,15 @@ module T::Utils
     elsif val == ::Range
       T::Range[T.untyped]
     elsif val.is_a?(Module)
-      T::Types::Simple.new(val) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+      T::Types::Simple::Private::Pool.type_for_module(val)
     elsif val.is_a?(::Array)
-      T::Types::FixedArray.new(val) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+      T::Types::FixedArray.new(val)
     elsif val.is_a?(::Hash)
-      T::Types::FixedHash.new(val) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+      T::Types::FixedHash.new(val)
     elsif val.is_a?(T::Private::Methods::DeclBuilder)
       T::Private::Methods.finalize_proc(val.decl)
     elsif val.is_a?(::T::Enum)
-      T::Types::TEnum.new(val) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+      T::Types::TEnum.new(val)
     elsif val.is_a?(::String)
       raise "Invalid String literal for type constraint. Must be an #{T::Types::Base}, a " \
             "class/module, or an array. Got a String with value `#{val}`."
@@ -109,10 +109,10 @@ module T::Utils
 
   # Returns the arity of a method, unwrapping the sig if needed
   def self.arity(method)
-    arity = method.arity # rubocop:disable PrisonGuard/NoArity
+    arity = method.arity
     return arity if arity != -1 || method.is_a?(Proc)
     sig = T::Private::Methods.signature_for_method(method)
-    sig ? sig.method.arity : arity # rubocop:disable PrisonGuard/NoArity
+    sig ? sig.method.arity : arity
   end
 
   # Elide the middle of a string as needed and replace it with an ellipsis.
@@ -162,7 +162,7 @@ module T::Utils
     elsif classes.length > 1
       T::Types::Union.new(classes)
     else
-      T::Types::Simple.new(classes.first)
+      T::Types::Simple::Private::Pool.type_for_module(classes.first)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.5794
+  version: 0.5.5942
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-01 00:00:00.000000000 Z
+date: 2020-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -52,6 +52,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.90.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.90.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -100,14 +128,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: 2.7.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.7.1
+- !ruby/object:Gem::Dependency
+  name: subprocess
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: 1.5.3
 description: Sorbet's runtime type checking component
 email: 
 executables: []