sorbet-runtime 0.5.6427 → 0.5.6440

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7132225afab6f9f847d25c97a4b525e3b3160691eb15cfc69c48bbb345725b3f
-  data.tar.gz: 2937bf5f74dab485511ca6ca27cb149ff3fdd15bcc1f7c466ad35400424cbeeb
+  metadata.gz: 82d17038dfef0384936b69a24b7d37c97945f59f68e06d18957342fa64b8da9a
+  data.tar.gz: 123e19aa974da28f5c7cda255ed7ef792dae8bf4d5cb189fd809a652a27acb8b
 SHA512:
-  metadata.gz: 5dcea3f7988da0ccf7d2068eb724415e13197b4a68a37b2f0aa9ce1627d72c6239d9a23c2f1314fff216302a656529a16074cf42f5b6c9d674e671af878907d0
-  data.tar.gz: f79af251532558136042cae0dc0b967fe1178d4aa7544a15265aa97505b487ddc0b4759f065a5ed764bd9fc0964ced99151e2fa5cd96aeb68b7dbfdf6440cc80
+  metadata.gz: f873aeb24b8ec3bccb66a8909f77cd4e5dce30a41a189d63b7ead5fbe3757924e581bab19aec9effa0874d1d73fae91369a3c81127cbcd18c798753d9bbd5949
+  data.tar.gz: 42ffd5ad1aa8bf6fc52335a612eed179691e005bf9afeb7dd38c596bfcc2524ea2f21b1c09bdfce7c3d87d3f383a5a59642ad7eebf8997c1a5a6e57422f0ce29

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

@@ -26,6 +26,8 @@ module T::Private::Methods
   # in installed_hooks.
   @old_hooks = nil
 
+  @declaring_final_method = false
+
   ARG_NOT_PROVIDED = Object.new
   PROC_TYPE = Object.new
 
@@ -180,6 +182,17 @@ module T::Private::Methods
     @modules_with_final[mod.singleton_class]
   end
 
+  # See tests for how to use this.
+  def self._with_declaring_final_method_INTERNAL(&blk)
+    begin
+      prev_value = @declaring_final_method
+      @declaring_final_method = true
+      yield
+    ensure
+      @declaring_final_method = prev_value
+    end
+  end
+
   # Only public because it needs to get called below inside the replace_method blocks below.
   def self._on_method_added(hook_mod, method_name, is_singleton_method: false)
     if T::Private::DeclState.current.skip_on_method_added
@@ -189,7 +202,9 @@ module T::Private::Methods
     current_declaration = T::Private::DeclState.current.active_declaration
     mod = is_singleton_method ? hook_mod.singleton_class : hook_mod
 
-    if T::Private::Final.final_module?(mod) && (current_declaration.nil? || !current_declaration.final)
+    directly_declaring_final_method = @declaring_final_method
+    method_is_final = directly_declaring_final_method || current_declaration&.final
+    if T::Private::Final.final_module?(mod) && !method_is_final
       raise "#{mod} was declared as final but its method `#{method_name}` was not declared as final"
     end
     # Don't compute mod.ancestors if we don't need to bother checking final-ness.
@@ -212,46 +227,49 @@ module T::Private::Methods
       )
     end
 
-    original_method = mod.instance_method(method_name)
-    sig_block = lambda do
-      T::Private::Methods.run_sig(hook_mod, method_name, original_method, current_declaration)
-    end
-
-    # Always replace the original method with this wrapper,
-    # which is called only on the *first* invocation.
-    # This wrapper is very slow, so it will subsequently re-wrap with a much faster wrapper
-    # (or unwrap back to the original method).
-    key = method_owner_and_name_to_key(mod, method_name)
-    T::Private::ClassUtils.replace_method(mod, method_name) 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,
-        original_method,
-        __callee__,
-      )
+    unless directly_declaring_final_method
+      original_method = mod.instance_method(method_name)
+      sig_block = lambda do
+        T::Private::Methods.run_sig(hook_mod, method_name, original_method, current_declaration)
+      end
 
-      # Should be the same logic as CallValidation.wrap_method_if_needed but we
-      # don't want that extra layer of indirection in the callstack
-      if method_sig.mode == T::Private::Methods::Modes.abstract
-        # We're in an interface method, keep going up the chain
-        if defined?(super)
-          super(*args, &blk)
+      # Always replace the original method with this wrapper,
+      # which is called only on the *first* invocation.
+      # This wrapper is very slow, so it will subsequently re-wrap with a much faster wrapper
+      # (or unwrap back to the original method).
+      key = method_owner_and_name_to_key(mod, method_name)
+      T::Private::ClassUtils.replace_method(mod, method_name) 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,
+          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
+        if method_sig.mode == T::Private::Methods::Modes.abstract
+          # We're in an interface method, keep going up the chain
+          if defined?(super)
+            super(*args, &blk)
+          else
+            raise NotImplementedError.new("The method `#{method_sig.method_name}` on #{mod} is declared as `abstract`. It does not have an implementation.")
+          end
+        # Note, this logic is duplicated (intentionally, for micro-perf) at `CallValidation.wrap_method_if_needed`,
+        # make sure to keep changes in sync.
+        elsif method_sig.check_level == :always || (method_sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
+          CallValidation.validate_call(self, original_method, method_sig, args, blk)
+        elsif T::Configuration::AT_LEAST_RUBY_2_7
+          original_method.bind_call(self, *args, &blk)
         else
-          raise NotImplementedError.new("The method `#{method_sig.method_name}` on #{mod} is declared as `abstract`. It does not have an implementation.")
+          original_method.bind(self).call(*args, &blk)
         end
-      # Note, this logic is duplicated (intentionally, for micro-perf) at `CallValidation.wrap_method_if_needed`,
-      # make sure to keep changes in sync.
-      elsif method_sig.check_level == :always || (method_sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
-        CallValidation.validate_call(self, original_method, method_sig, args, blk)
-      elsif T::Configuration::AT_LEAST_RUBY_2_7
-        original_method.bind_call(self, *args, &blk)
-      else
-        original_method.bind(self).call(*args, &blk)
       end
+
+      @sig_wrappers[key] = sig_block
     end
 
-    @sig_wrappers[key] = sig_block
-    if current_declaration.final
+    if method_is_final
       @was_ever_final_names.add(method_name)
       # use hook_mod, not mod, because for example, we want class C to be marked as having final if we def C.foo as
       # final. change this to mod to see some final_method tests fail.

data/lib/types/utils.rb

@@ -79,10 +79,12 @@ module T::Utils
     case type
     when T::Types::Union
       non_nil_types = type.types.reject {|t| t == Nilable::NIL_TYPE}
-      if non_nil_types.length == 1
-        non_nil_types.first
+      return nil if type.types.length == non_nil_types.length
+      case non_nil_types.length
+      when 0 then nil
+      when 1 then non_nil_types.first
       else
-        nil
+        T::Types::Union::Private::Pool.union_of_types(non_nil_types[0], non_nil_types[1], non_nil_types[2..])
       end
     else
       nil

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.6427
+  version: 0.5.6440
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-29 00:00:00.000000000 Z
+date: 2021-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest