sorbet-runtime 0.5.6432 → 0.5.6442

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0ee12af2b28dcd17f0c18edf81bbe9628cecfb58ec5ac2c8342151a8ac1bf99
-  data.tar.gz: f3cce70dbbb1c940987f3c2e0a1f09231f0e05306a9fc1cd97ea6c55a79ce131
+  metadata.gz: 8805689d39483edeab9d97a1235f0eba1fad5e20ffed87ef4c24679e7c832525
+  data.tar.gz: 60c23ac8a2301badb0bfbd0c2d0bb8ddc3c7814616947cad6524d00ec37db1a4
 SHA512:
-  metadata.gz: 6b633d3207446dc37a918eaf63f3925b385ed9e1b53e4460af3d35be7a319fefe3be6677373b45134efb9429fb07bc9cc90c091b603eb452f7fa10c87997e77d
-  data.tar.gz: 0e92d8d4adca81d147fcab425ab9a82ca1b3296c477e7afaa9991e6daa4ad743aeccf965cb79bb3b0705b44119ea03a16024eb766e9d565ce2286fc58496752f
+  metadata.gz: 0a9941b93820e638d900c6f321736a08cd061538c9f3885fb39d8e63ab787373b38d825c3933baa633143e9b4ad9dba747d17d67967e873995a88c091bcb01e3
+  data.tar.gz: 86d69bc3ed1ac34a06a73b170a94e521829faf025d98562f92ce46891eb148cdc78be4aae94c75f364b36cc32a6d5669a5ca0ec6976c187c84150302e9c8fe1d

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