sorbet-runtime 0.5.10891 → 0.5.10898

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7e6942650e54cd39050183984f52dc731e95f4bdd303ffda6ab23323e5ebd5c
-  data.tar.gz: e5eeec1f6e2fa6628f6a81da6201285698f3847dc22e88baae7499c9792e46af
+  metadata.gz: 3e3ab9e95814ef422f4bf43b68d621a4729536f6fa50463e9e2af6aa5faf2e78
+  data.tar.gz: 77e0c25399ad50c72f0a10d159d808284bd137b203d138e4d1c6590d870d7bd8
 SHA512:
-  metadata.gz: b56f40f9db44bf40ef55cafcfa391e24d39ae5a07f8e207854026b138fe7a81fc35e23124219b9f254fba9fa1548aa48ce9eececadb88606a92b5f8bb520ffa6
-  data.tar.gz: 67f83387e862176599bfaf1dc2e3ea73fd9ae0bc326c4d0ede7d3404075e45c6b71df77e4cfd3961b9a1970831d571921fa8825af03eaa77d6fcbef3b0da4818
+  metadata.gz: c9f7595af100b0883fbe66464d3341ebf6b3a60548b027fd381752db21f6e2f9526b6bdb85af89ac7ab98e6209fc8ccdb63962f4bad2fd8d24ff5a05ed3dbdb8
+  data.tar.gz: 9db28918c2cb24a1f16f16059002d590fce54a12c18fd1aad6dc03d503e905b5156fe916a8abeb1d26437194e371cd65637d9bbca52f9f02ff65bf3a7622ca24

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

@@ -252,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,
@@ -501,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.

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

@@ -39,8 +39,6 @@ class T::Private::Methods::Signature
   def initialize(method:, method_name:, raw_arg_types:, raw_return_type:, bind:, mode:, check_level:, on_failure:, parameters: method.parameters, override_allow_incompatible: false, defined_raw: false)
     @method = method
     @method_name = method_name
-    @arg_types = []
-    @kwarg_types = {}
     @block_type = nil
     @block_name = nil
     @rest_type = nil
@@ -51,8 +49,6 @@ class T::Private::Methods::Signature
     @bind = bind ? T::Utils.coerce(bind) : bind
     @mode = mode
     @check_level = check_level
-    @req_arg_count = 0
-    @req_kwarg_names = []
     @has_rest = false
     @has_keyrest = false
     @parameters = parameters
@@ -60,6 +56,12 @@ class T::Private::Methods::Signature
     @override_allow_incompatible = override_allow_incompatible
     @defined_raw = defined_raw
 
+    # Use T.untyped in lieu of T.nilable to try to avoid unnecessary allocations.
+    arg_types = T.let(nil, T.untyped)
+    kwarg_types = T.let(nil, T.untyped)
+    req_arg_count = 0
+    req_kwarg_names = T.let(nil, T.untyped)
+
     # If sig params are declared but there is a single parameter with a missing name
     # **and** the method ends with a "=", assume it is a writer method generated
     # by attr_writer or attr_accessor
@@ -109,7 +111,7 @@ class T::Private::Methods::Signature
 
       case param_kind
       when :req
-        if @arg_types.length > @req_arg_count
+        if (arg_types ? arg_types.length : 0) > req_arg_count
           # Note that this is actually is supported by Ruby, but it would add complexity to
           # support it here, and I'm happy to discourage its use anyway.
           #
@@ -120,14 +122,14 @@ class T::Private::Methods::Signature
           # see this error. The simplest resolution is to rename your method.
           raise "Required params after optional params are not supported in method declarations. Method: #{method_desc}"
         end
-        @arg_types << [param_name, type]
-        @req_arg_count += 1
+        (arg_types ||= []) << [param_name, type]
+        req_arg_count += 1
       when :opt
-        @arg_types << [param_name, type]
+        (arg_types ||= []) << [param_name, type]
       when :key, :keyreq
-        @kwarg_types[param_name] = type
+        (kwarg_types ||= {})[param_name] = type
         if param_kind == :keyreq
-          @req_kwarg_names << param_name
+          (req_kwarg_names ||= []) << param_name
         end
       when :block
         @block_name = param_name
@@ -146,6 +148,11 @@ class T::Private::Methods::Signature
 
       i += 1
     end
+
+    @arg_types = arg_types || EMPTY_LIST
+    @kwarg_types = kwarg_types || EMPTY_HASH
+    @req_arg_count = req_arg_count
+    @req_kwarg_names = req_kwarg_names || EMPTY_LIST
   end
 
   attr_writer :method_name
@@ -238,5 +245,6 @@ class T::Private::Methods::Signature
     "#{@method} at #{loc}"
   end
 
+  EMPTY_LIST = [].freeze
   EMPTY_HASH = {}.freeze
 end

data/lib/types/struct.rb

@@ -10,7 +10,7 @@ end
 class T::Struct < T::InexactStruct
   def self.inherited(subclass)
     super(subclass)
-    T::Private::ClassUtils.replace_method(subclass.singleton_class, :inherited) do |s|
+    T::Private::ClassUtils.replace_method(subclass.singleton_class, :inherited, true) do |s|
       super(s)
       raise "#{self.name} is a subclass of T::Struct and cannot be subclassed"
     end
@@ -23,7 +23,7 @@ class T::ImmutableStruct < T::InexactStruct
   def self.inherited(subclass)
     super(subclass)
 
-    T::Private::ClassUtils.replace_method(subclass.singleton_class, :inherited) do |s|
+    T::Private::ClassUtils.replace_method(subclass.singleton_class, :inherited, true) do |s|
       super(s)
       raise "#{self.name} is a subclass of T::ImmutableStruct and cannot be subclassed"
     end

data/lib/types/types/simple.rb

@@ -4,6 +4,9 @@
 module T::Types
   # Validates that an object belongs to the specified class.
   class Simple < Base
+    NAME_METHOD = Module.instance_method(:name)
+    private_constant(:NAME_METHOD)
+
     attr_reader :raw_type
 
     def initialize(raw_type)
@@ -16,7 +19,7 @@ module T::Types
       #
       # `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
+      @name ||= (NAME_METHOD.bind(@raw_type).call || @raw_type.name).freeze
     end
 
     # overrides Base

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.10891
+  version: 0.5.10898
 platform: ruby
 authors:
 - Stripe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-29 00:00:00.000000000 Z
+date: 2023-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest