sorbet-runtime 0.5.6433 → 0.5.6445

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55fd303db2e5ba8a4f2a510dee36f7b073ddf41eaad967068290a37aa753c5a0
-  data.tar.gz: 9044c6c6e0a7e8b8752313d8c44a23c9f641d7d21e82ad14eee8008b72c6d641
+  metadata.gz: 5999d5a042335cfa277db91b0e3b7b9ea5f66c0ddfef8592b8429886fa7cf06d
+  data.tar.gz: 7c7b3d3c218a1828d7c486c6cca2330fbbd7440b6f6a1614f179f1d9efddbcf5
 SHA512:
-  metadata.gz: f9f74a97aeb1ff1405e90a5489ac69baf483b53274aebb3923845483001c6e54f82950e234a55be77ace0e02a85f582b8c4241ea63f2ff1c5fe57e91d58e4039
-  data.tar.gz: aca345482f4070346686130d0b481561eaa0e6649e6d90fe5bdd8c6ee3244fd581acb8d26310e8dbffad36f4db84f5cd6ead6e12ebfead92144eebef147cccb7
+  metadata.gz: 80bbea2a11ee058c257702f00ad49d21bc6b02686c40ee5d0a35bfbe2a3dbdfaf000ee43cc9f5c3d47a165ca2d14f951adcc5f7db3af4c6321881ef33b31217c
+  data.tar.gz: 215755a88a2358f0052c9340798cdf7a6358222c064e3329985a37a6a2e764a2eaf51fa7c032e4a9a8b4b2e01879e219f98255cf39cdc1c72b6879a0bfe181df

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.6433
+  version: 0.5.6445
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-04 00:00:00.000000000 Z
+date: 2021-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest