sorbet-runtime 0.5.11144 → 0.5.11266

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5b21bcb5dabd49853b11434c9845cf1530e7c5b1fa475b93fda398e5b8121bb
-  data.tar.gz: 34af59fbefda1547828f8aa5fc668cf588754d9b8b1ac1221a804ba2840ad99b
+  metadata.gz: 62a1d832c6ab11c77c2604ee4f41e90ce19504ceb77e26a2ac1a1946316c5850
+  data.tar.gz: ef76ff59edbc69784d52817720f36fc38d3705849b4eea653f40b52bf7c4b1dd
 SHA512:
-  metadata.gz: a093baa9c20a21486f6af5bd315bae13c37e59e2581dfff5a8dd6f3e95be0a50222a988358fbc2b7e14f2642d6cc14d6b3f33227d7bf73e03ecaebde1b1cb08d
-  data.tar.gz: d814fc35c1b03fdd2d73639515eb52cd438caa7c6719d647917add140bf9a8432757ee037836eab5011b8e8c677378092225d956452e9f6e3ab063609856d805
+  metadata.gz: e666a6f08ec47051bcd8a7b92320089d1841544c526be65c3cdb17d0a0cea3fd4e2e921e7b389ea52b836c2a076e18346215d2c484b7efbda372cd6dd232dc58
+  data.tar.gz: e44d0e46981e86bd7c5f124ea1a1592d64a44955f9f405e0dcb6a61f02fb03ac4021d13bb9e01f1ac6599d94c9f7521d3164cd98f0b7efe3cc687fcb799fa6cf

data/lib/sorbet-runtime.rb

@@ -19,6 +19,7 @@ module T::Private::Types; end
 require_relative 'types/configuration'
 require_relative 'types/_types'
 require_relative 'types/private/decl_state'
+require_relative 'types/private/caller_utils'
 require_relative 'types/private/class_utils'
 require_relative 'types/private/runtime_levels'
 require_relative 'types/private/methods/_methods'
@@ -73,7 +74,6 @@ require_relative 'types/private/abstract/validate'
 
 # Catch all. Sort of built by `cd extn; find types -type f | grep -v test | sort`
 require_relative 'types/generic'
-require_relative 'types/interface_wrapper'
 require_relative 'types/private/abstract/declare'
 require_relative 'types/private/abstract/hooks'
 require_relative 'types/private/casts'

data/lib/types/compatibility_patches.rb

@@ -38,7 +38,7 @@ if defined? ::RSpec::Mocks
 
         module MethodDoubleExtensions
           def initialize(object, method_name, proxy)
-            if ::Kernel.instance_method(:respond_to?).bind(object).call(method_name, true)
+            if ::Kernel.instance_method(:respond_to?).bind(object).call(method_name, true) # rubocop:disable Performance/BindCall
               method = ::RSpec::Support.method_handle_for(object, method_name)
               T::Private::Methods.maybe_run_sig_block_for_method(method)
             end

data/lib/types/configuration.rb

@@ -451,7 +451,7 @@ module T::Configuration
   @default_module_name_mangler = if T::Configuration::AT_LEAST_RUBY_2_7
     ->(type) {MODULE_NAME.bind_call(type)}
   else
-    ->(type) {MODULE_NAME.bind(type).call}
+    ->(type) {MODULE_NAME.bind(type).call} # rubocop:disable Performance/BindCall
   end
 
   @module_name_mangler = nil

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

@@ -18,7 +18,6 @@ module T::Private::Abstract::Declare
     Abstract::Data.set(mod, :abstract_type, type)
 
     mod.extend(Abstract::Hooks)
-    mod.extend(T::InterfaceWrapper::Helpers)
 
     if mod.is_a?(Class)
       if type == :interface
@@ -35,11 +34,11 @@ module T::Private::Abstract::Declare
       # define_method because of the guard above
 
       mod.send(:define_singleton_method, :new) do |*args, &blk|
-        super(*args, &blk).tap do |result|
-          if result.instance_of?(mod)
-            raise "#{mod} is declared as abstract; it cannot be instantiated"
-          end
+        result = super(*args, &blk)
+        if result.instance_of?(mod)
+          raise "#{mod} is declared as abstract; it cannot be instantiated"
         end
+        result
       end
 
       # Ruby doesn not emit "method redefined" warnings for aliased methods

data/lib/types/private/caller_utils.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+# typed: false
+
+module T::Private::CallerUtils
+  if Thread.respond_to?(:each_caller_location) # RUBY_VERSION >= "3.2"
+    def self.find_caller
+      Thread.each_caller_location do |loc|
+        next if loc.path&.start_with?("<internal:")
+
+        return loc if yield(loc)
+      end
+      nil
+    end
+  else
+    def self.find_caller
+      caller_locations(2).find do |loc|
+        !loc.path&.start_with?("<internal:") && yield(loc)
+      end
+    end
+  end
+end

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

@@ -3,12 +3,17 @@
 
 module T::Private::Methods
   @installed_hooks = {}
-  @signatures_by_method = {}
-  @sig_wrappers = {}
+  if defined?(Concurrent::Hash)
+    @signatures_by_method = Concurrent::Hash.new
+    @sig_wrappers = Concurrent::Hash.new
+  else
+    @signatures_by_method = {}
+    @sig_wrappers = {}
+  end
   @sigs_that_raised = {}
   # stores method names that were declared final without regard for where.
   # enables early rejection of names that we know can't induce final method violations.
-  @was_ever_final_names = {}
+  @was_ever_final_names = {}.compare_by_identity
   # maps from a module's object_id to the set of final methods declared in that module.
   # we also overload entries slightly: if the value is nil, that means that the
   # module has final methods somewhere along its ancestor chain, but does not itself
@@ -20,7 +25,7 @@ module T::Private::Methods
   # twice is permitted).  we could do this with two tables, but it seems slightly
   # cleaner with a single table.
   # Effectively T::Hash[Module, T.nilable(Set))]
-  @modules_with_final = Hash.new {|hash, key| hash[key] = nil}
+  @modules_with_final = Hash.new {|hash, key| hash[key] = nil}.compare_by_identity
   # this stores the old [included, extended] hooks for Module and inherited hook for Class that we override when
   # enabling final checks for when those hooks are called. the 'hooks' here don't have anything to do with the 'hooks'
   # in installed_hooks.
@@ -132,7 +137,7 @@ module T::Private::Methods
     source_ancestors = nil
     # use reverse_each to check farther-up ancestors first, for better error messages.
     target_ancestors.reverse_each do |ancestor|
-      final_methods = @modules_with_final.fetch(ancestor.object_id, nil)
+      final_methods = @modules_with_final.fetch(ancestor, nil)
       # In this case, either ancestor didn't have any final methods anywhere in its
       # ancestor chain, or ancestor did have final methods somewhere in its ancestor
       # chain, but no final methods defined in ancestor itself.  Either way, there
@@ -150,20 +155,20 @@ module T::Private::Methods
             # filter out things without actual final methods just to make sure that
             # the below checks (which should be uncommon) go as quickly as possible.
             source_ancestors.select! do |a|
-              @modules_with_final.fetch(a.object_id, nil)
+              @modules_with_final.fetch(a, nil)
             end
           end
           # final-ness means that there should be no more than one index for which
           # the below block returns true.
           defining_ancestor_idx = source_ancestors.index do |a|
-            @modules_with_final.fetch(a.object_id).include?(method_name)
+            @modules_with_final.fetch(a).include?(method_name)
           end
           next if defining_ancestor_idx && source_ancestors[defining_ancestor_idx] == ancestor
         end
 
         definition_file, definition_line = T::Private::Methods.signature_for_method(ancestor.instance_method(method_name)).method.source_location
         is_redefined = target == ancestor
-        caller_loc = caller_locations.find {|l| !l.to_s.start_with?(SORBET_RUNTIME_LIB_PATH)}
+        caller_loc = T::Private::CallerUtils.find_caller {|loc| !loc.path.to_s.start_with?(SORBET_RUNTIME_LIB_PATH)}
         extra_info = "\n"
         if caller_loc
           extra_info = (is_redefined ? "Redefined" : "Overridden") + " here: #{caller_loc.path}:#{caller_loc.lineno}\n"
@@ -191,13 +196,11 @@ module T::Private::Methods
     end
   end
 
-  def self.add_module_with_final_method(mod, method_name, is_singleton_method)
-    m = is_singleton_method ? mod.singleton_class : mod
-    mid = m.object_id
-    methods = @modules_with_final[mid]
+  def self.add_module_with_final_method(mod, method_name)
+    methods = @modules_with_final[mod]
     if methods.nil?
       methods = {}
-      @modules_with_final[mid] = methods
+      @modules_with_final[mod] = methods
     end
     methods[method_name] = true
     nil
@@ -205,24 +208,23 @@ module T::Private::Methods
 
   def self.note_module_deals_with_final(mod)
     # Side-effectfully initialize the value if it's not already there
-    @modules_with_final[mod.object_id]
-    @modules_with_final[mod.singleton_class.object_id]
+    @modules_with_final[mod]
+    @modules_with_final[mod.singleton_class]
   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)
+  def self._on_method_added(hook_mod, mod, method_name)
     if T::Private::DeclState.current.skip_on_method_added
       return
     end
 
     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)
       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.
-    if @was_ever_final_names.include?(method_name) && @modules_with_final.include?(mod.object_id)
+    if @was_ever_final_names.include?(method_name) && @modules_with_final.include?(mod)
       _check_final_ancestors(mod, mod.ancestors, [method_name], nil)
       # We need to fetch the active declaration again, as _check_final_ancestors
       # may have reset it (see the comment in that method for details).
@@ -276,7 +278,7 @@ module T::Private::Methods
         elsif T::Configuration::AT_LEAST_RUBY_2_7
           original_method.bind_call(self, *args, &blk)
         else
-          original_method.bind(self).call(*args, &blk)
+          original_method.bind(self).call(*args, &blk) # rubocop:disable Performance/BindCall
         end
       end
     end
@@ -287,7 +289,7 @@ module T::Private::Methods
       # 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.
       note_module_deals_with_final(hook_mod)
-      add_module_with_final_method(hook_mod, method_name, is_singleton_method)
+      add_module_with_final_method(mod, method_name)
     end
   end
 
@@ -431,7 +433,7 @@ module T::Private::Methods
     run_sig_block_for_key(method_to_key(method))
   end
 
-  private_class_method def self.run_sig_block_for_key(key)
+  private_class_method def self.run_sig_block_for_key(key, force_type_init: false)
     blk = @sig_wrappers[key]
     if !blk
       sig = @signatures_by_method[key]
@@ -454,14 +456,17 @@ module T::Private::Methods
     end
 
     @sig_wrappers.delete(key)
+
+    sig.force_type_init if force_type_init
+
     sig
   end
 
-  def self.run_all_sig_blocks
+  def self.run_all_sig_blocks(force_type_init: true)
     loop do
       break if @sig_wrappers.empty?
       key, = @sig_wrappers.first
-      run_sig_block_for_key(key)
+      run_sig_block_for_key(key, force_type_init: force_type_init)
     end
   end
 
@@ -474,8 +479,8 @@ module T::Private::Methods
   def self._hook_impl(target, singleton_class, source)
     # we do not need to call add_was_ever_final here, because we have already marked
     # any such methods when source was originally defined.
-    if !@modules_with_final.include?(target.object_id)
-      if !@modules_with_final.include?(source.object_id)
+    if !@modules_with_final.include?(target)
+      if !@modules_with_final.include?(source)
         return
       end
       note_module_deals_with_final(target)
@@ -514,7 +519,7 @@ module T::Private::Methods
         if T::Configuration::AT_LEAST_RUBY_2_7
           old_included.bind_call(self, arg)
         else
-          old_included.bind(self).call(arg)
+          old_included.bind(self).call(arg) # rubocop:disable Performance/BindCall
         end
         ::T::Private::Methods._hook_impl(arg, false, self)
       end
@@ -522,7 +527,7 @@ module T::Private::Methods
         if T::Configuration::AT_LEAST_RUBY_2_7
           old_extended.bind_call(self, arg)
         else
-          old_extended.bind(self).call(arg)
+          old_extended.bind(self).call(arg) # rubocop:disable Performance/BindCall
         end
         ::T::Private::Methods._hook_impl(arg, true, self)
       end
@@ -530,7 +535,7 @@ module T::Private::Methods
         if T::Configuration::AT_LEAST_RUBY_2_7
           old_inherited.bind_call(self, arg)
         else
-          old_inherited.bind(self).call(arg)
+          old_inherited.bind(self).call(arg) # rubocop:disable Performance/BindCall
         end
         ::T::Private::Methods._hook_impl(arg, false, self)
       end
@@ -541,14 +546,14 @@ module T::Private::Methods
   module MethodHooks
     def method_added(name)
       super(name)
-      ::T::Private::Methods._on_method_added(self, name, is_singleton_method: false)
+      ::T::Private::Methods._on_method_added(self, self, name)
     end
   end
 
   module SingletonMethodHooks
     def singleton_method_added(name)
       super(name)
-      ::T::Private::Methods._on_method_added(self, name, is_singleton_method: true)
+      ::T::Private::Methods._on_method_added(self, singleton_class, name)
     end
   end
 

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

@@ -15,8 +15,6 @@ module T::Private::Methods::CallValidation
     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, 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.
         # So, if a super method exists, call it.
         if defined?(super)
@@ -67,14 +65,30 @@ module T::Private::Methods::CallValidation
     simple_method = all_args_are_simple && method_sig.return_type.is_a?(T::Types::Simple)
     simple_procedure = all_args_are_simple && method_sig.return_type.is_a?(T::Private::Types::Void)
 
+    # All the types for which valid? unconditionally returns `true`
+    return_is_ignorable =
+      (method_sig.return_type.equal?(T::Types::Untyped::Private::INSTANCE) ||
+       method_sig.return_type.equal?(T::Types::Anything::Private::INSTANCE) ||
+       method_sig.return_type.equal?(T::Types::AttachedClassType::Private::INSTANCE) ||
+       method_sig.return_type.equal?(T::Types::SelfType::Private::INSTANCE) ||
+       method_sig.return_type.is_a?(T::Types::TypeParameter) ||
+       method_sig.return_type.is_a?(T::Types::TypeVariable) ||
+       (method_sig.return_type.is_a?(T::Types::Simple) && method_sig.return_type.raw_type.equal?(BasicObject)))
+
+    returns_anything_method = all_args_are_simple && return_is_ignorable
+
     T::Configuration.without_ruby_warnings do
       T::Private::DeclState.current.without_on_method_added do
         if simple_method
           create_validator_method_fast(mod, original_method, method_sig, original_visibility)
+        elsif returns_anything_method
+          create_validator_method_skip_return_fast(mod, original_method, method_sig, original_visibility)
         elsif simple_procedure
           create_validator_procedure_fast(mod, original_method, method_sig, original_visibility)
         elsif ok_for_fast_path && method_sig.return_type.is_a?(T::Private::Types::Void)
           create_validator_procedure_medium(mod, original_method, method_sig, original_visibility)
+        elsif ok_for_fast_path && return_is_ignorable
+          create_validator_method_skip_return_medium(mod, original_method, method_sig, original_visibility)
         elsif ok_for_fast_path
           create_validator_method_medium(mod, original_method, method_sig, original_visibility)
         elsif can_skip_block_type