sorbet-runtime 0.5.6322 → 0.5.6338

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6c77d695c5b2ad896c9bf845303e742d41c07c24d55c4aedcfd8f6acb9580dc
-  data.tar.gz: 8cbbe5d304fb8f7742a5785232511c92eb68948490216202a7c6faf1fdf90bc1
+  metadata.gz: 3671ed176f9cf1875148797095dcda29672ad803d5ede745ec3aac0e8ddacd31
+  data.tar.gz: '019c5545c3bdff3a7f1aad4c0eaefdc57f0172a13413aa59236b27da8609e89f'
 SHA512:
-  metadata.gz: aea4d354cc43e0797dd8e651f514f316508806b8d557248a31c5cf21ab651d8537788ad90f635634a684c1183e5066862e1bfef56748b9d722cd8edab8e0a3c3
-  data.tar.gz: 32f1bd879783697530fc548ce7fbf2477a7dc0458e6e3d7904f5f88c3c304f6f148029f2ab16afddc90993c8103bb80ad8d9afeaeb765a0cfe1c97606a864231
+  metadata.gz: 18c9836a43d62d5c73f8c7d4dd402496ed523e6beaa389eda774b207c4aaacb7499f83936f32a8d4efcf72559f0b2a06b341a89bd31aa41ca7168359ecf03462
+  data.tar.gz: da19c72bf63324a8f09ef63b811edba84f84c26bc545025c1ca354e03626c774bbf1fc3ada5051c7393678d056ad10106f73ffdb24a790d14564b9b7ebf10797

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

@@ -11,6 +11,9 @@ module T::Private::Methods
   # - they are done possibly before any sig block has run.
   # - they are done even if the method being defined doesn't have a sig.
   @final_methods = Set.new
+  # 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 = Set.new
   # a non-singleton is a module for which at least one of the following is true:
   # - is declared final
   # - defines a method that is declared final
@@ -96,13 +99,14 @@ module T::Private::Methods
   # when target includes a module with instance methods source_method_names, ensure there is zero intersection between
   # the final instance methods of target and source_method_names. so, for every m in source_method_names, check if there
   # is already a method defined on one of target_ancestors with the same name that is final.
+  #
+  # we assume that source_method_names has already been filtered to only include method
+  # names that were declared final at one point.
   def self._check_final_ancestors(target, target_ancestors, source_method_names)
-    if !module_with_final?(target)
-      return
-    end
     # use reverse_each to check farther-up ancestors first, for better error messages. we could avoid this if we were on
     # the version of ruby that adds the optional argument to method_defined? that allows you to exclude ancestors.
     target_ancestors.reverse_each do |ancestor|
+      next if !module_with_final?(ancestor)
       source_method_names.each do |method_name|
         # the usage of method_owner_and_name_to_key(ancestor, method_name) instead of
         # method_to_key(ancestor.instance_method(method_name)) is not (just) an optimization, but also required for
@@ -148,6 +152,14 @@ module T::Private::Methods
     @final_methods.include?(method_key)
   end
 
+  private_class_method def self.add_was_ever_final(method_name)
+    @was_ever_final_names.add(method_name)
+  end
+
+  private_class_method def self.was_ever_final?(method_name)
+    @was_ever_final_names.include?(method_name)
+  end
+
   def self.add_module_with_final(mod)
     @modules_with_final.add(mod)
     @modules_with_final.add(mod.singleton_class)
@@ -169,7 +181,10 @@ module T::Private::Methods
     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
-    _check_final_ancestors(mod, mod.ancestors, [method_name])
+    # Don't compute mod.ancestors if we don't need to bother checking final-ness.
+    if was_ever_final?(method_name) && module_with_final?(mod)
+      _check_final_ancestors(mod, mod.ancestors, [method_name])
+    end
 
     # We need to fetch the active declaration again, as _check_final_ancestors
     # may have reset it (see the comment in that method for details).
@@ -229,6 +244,7 @@ module T::Private::Methods
     @sig_wrappers[key] = sig_block
     if current_declaration.final
       add_final_method(key)
+      add_was_ever_final(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.
       add_module_with_final(hook_mod)
@@ -407,13 +423,30 @@ module T::Private::Methods
 
   # the module target is adding the methods from the module source to itself. we need to check that for all instance
   # methods M on source, M is not defined on any of target's ancestors.
-  def self._hook_impl(target, target_ancestors, source)
-    if !module_with_final?(target) && !module_with_final?(source)
+  def self._hook_impl(target, singleton_class, source)
+    target_was_final = module_with_final?(target)
+    if !target_was_final && !module_with_final?(source)
       return
     end
+    # we do not need to call add_was_ever_final here, because we have already marked
+    # any such methods when source was originally defined.
     add_module_with_final(target)
     install_hooks(target)
-    _check_final_ancestors(target, target_ancestors - source.ancestors, source.instance_methods)
+
+    if !target_was_final
+      return
+    end
+
+    methods = source.instance_methods
+    methods.select! do |method_name|
+      was_ever_final?(method_name)
+    end
+    if methods.empty?
+      return
+    end
+
+    target_ancestors = singleton_class ? target.singleton_class.ancestors : target.ancestors
+    _check_final_ancestors(target, target_ancestors - source.ancestors, methods)
   end
 
   def self.set_final_checks_on_hooks(enable)
@@ -427,15 +460,15 @@ module T::Private::Methods
     else
       old_included = T::Private::ClassUtils.replace_method(Module, :included) do |arg|
         old_included.bind(self).call(arg)
-        ::T::Private::Methods._hook_impl(arg, arg.ancestors, self)
+        ::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)
-        ::T::Private::Methods._hook_impl(arg, arg.singleton_class.ancestors, self)
+        ::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)
-        ::T::Private::Methods._hook_impl(arg, arg.ancestors, self)
+        ::T::Private::Methods._hook_impl(arg, false, self)
       end
       @old_hooks = [old_included, old_extended, old_inherited]
     end

metadata

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