sorbet-runtime 0.5.6349 → 0.5.6360

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37e5c18902b6bf05fda832dcfae31a46dd3ad7c454c7741f7003924c70e351fc
-  data.tar.gz: fba7a016bdbc64626802d5ccfdc9cf18ac382936ac7c98dc3bb62b610754a8e6
+  metadata.gz: 1d5327aaf5637dd246d494304c3ec3ae7acae6a685154a4cd3ed24d958863fd1
+  data.tar.gz: ed2f2822e62ad53a1aa7ab71adae9bd41881139958810865d860de53cf07a5f1
 SHA512:
-  metadata.gz: 4754a24ac572c182cb80f76c0505e02e61af830e2585cf73b464eba30fe24fc51c9ffeaa2b6ef1ff31a5d3b97e1c70e2d52de6398e924262cbae94e9408334ab
-  data.tar.gz: e7120e72312db83159fdde80db0ca357bf526e69fd7d97d5327623b5d3cc1f0c6d76753c25c1fd8ec52542b087a7e17db94e65a4de8c920efbbcff785cd4cdd2
+  metadata.gz: c5d70069d4a8fdf358ab21ba987c778760f8b0a3282ca79179f71bef19ca0d264612637080aa06f37a36b6df6e18ad532cca25fbc8af171461f13135aff26ee9
+  data.tar.gz: 9770d540b170244d5f68cf3035625c5a8491e192d7b6a864fd0692a960dcc0f39a2f81d8e9fa665e80543b1c558073fd1c7993ab3d573412c2281ca306f396f7

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

@@ -6,22 +6,21 @@ module T::Private::Methods
   @signatures_by_method = {}
   @sig_wrappers = {}
   @sigs_that_raised = {}
-  # the info about whether a method is final is not stored in a DeclBuilder nor a Signature, but instead right here.
-  # this is because final checks are special:
-  # - 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
-  # - includes an non-singleton
-  # - extends an non-singleton
-  # a singleton is the singleton_class of a non-singleton.
-  # modules_with_final is the set of singletons and non-singletons.
-  @modules_with_final = Set.new
+  # maps from modules 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
+  # have any final methods.
+  #
+  # we need the latter information to know whether we need to check along the ancestor
+  # chain for final method violations.  we need the former information because we
+  # care about exactly where a final method is defined (e.g. including the same module
+  # 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 }
   # 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.
@@ -102,71 +101,83 @@ module T::Private::Methods
   #
   # 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)
-    # 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.
+  def self._check_final_ancestors(target, target_ancestors, source_method_names, source)
+    source_ancestors = nil
+    # use reverse_each to check farther-up ancestors first, for better error messages.
     target_ancestors.reverse_each do |ancestor|
-      next if !module_with_final?(ancestor)
+      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
+      # are no final methods to check here, so we can move on to the next ancestor.
+      next unless final_methods
       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
-        # correctness, since ancestor.method_defined?(method_name) may return true even if method_name is not defined
-        # directly on ancestor but instead an ancestor of ancestor.
-        if final_method?(method_owner_and_name_to_key(ancestor, method_name))
-          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.match?(%r{sorbet-runtime[^/]*/lib/}) }
-          extra_info = "\n"
-          if caller_loc
-            extra_info = (is_redefined ? "Redefined" : "Overridden") + " here: #{caller_loc.path}:#{caller_loc.lineno}\n"
+        next unless final_methods.include?(method_name)
+
+        # If we get here, we are defining a method that some ancestor declared as
+        # final.  however, we permit a final method to be defined multiple
+        # times if it is the same final method being defined each time.
+        if source
+          if !source_ancestors
+            source_ancestors = source.ancestors
+            # 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, nil)
+            end
           end
-
-          error_message = "The method `#{method_name}` on #{ancestor} was declared as final and cannot be " +
-                          (is_redefined ? "redefined" : "overridden in #{target}")
-          pretty_message = "#{error_message}\n" \
-                           "Made final here: #{definition_file}:#{definition_line}\n" \
-                           "#{extra_info}"
-
-          begin
-            raise pretty_message
-          rescue => e
-            # sig_validation_error_handler raises by default; on the off chance that
-            # it doesn't raise, we need to ensure that the rest of signature building
-            # sees a consistent state.  This sig failed to validate, so we should get
-            # rid of it.  If we don't do this, errors of the form "You called sig
-            # twice without declaring a method in between" will non-deterministically
-            # crop up in tests.
-            T::Private::DeclState.current.reset!
-            T::Configuration.sig_validation_error_handler(e, {})
+          # 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).include?(method_name)
           end
+          next if defining_ancestor_idx && source_ancestors[defining_ancestor_idx] == ancestor
         end
-      end
-    end
-  end
 
-  private_class_method def self.add_final_method(method_key)
-    @final_methods.add(method_key)
-  end
-
-  private_class_method def self.final_method?(method_key)
-    @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
+        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.match?(%r{sorbet-runtime[^/]*/lib/}) }
+        extra_info = "\n"
+        if caller_loc
+          extra_info = (is_redefined ? "Redefined" : "Overridden") + " here: #{caller_loc.path}:#{caller_loc.lineno}\n"
+        end
 
-  private_class_method def self.was_ever_final?(method_name)
-    @was_ever_final_names.include?(method_name)
+        error_message = "The method `#{method_name}` on #{ancestor} was declared as final and cannot be " +
+                        (is_redefined ? "redefined" : "overridden in #{target}")
+        pretty_message = "#{error_message}\n" \
+                         "Made final here: #{definition_file}:#{definition_line}\n" \
+                         "#{extra_info}"
+
+        begin
+          raise pretty_message
+        rescue => e
+          # sig_validation_error_handler raises by default; on the off chance that
+          # it doesn't raise, we need to ensure that the rest of signature building
+          # sees a consistent state.  This sig failed to validate, so we should get
+          # rid of it.  If we don't do this, errors of the form "You called sig
+          # twice without declaring a method in between" will non-deterministically
+          # crop up in tests.
+          T::Private::DeclState.current.reset!
+          T::Configuration.sig_validation_error_handler(e, {})
+        end
+      end
+    end
   end
 
-  def self.add_module_with_final(mod)
-    @modules_with_final.add(mod)
-    @modules_with_final.add(mod.singleton_class)
+  def self.add_module_with_final_method(mod, method_name, is_singleton_method)
+    m = is_singleton_method ? mod.singleton_class : mod
+    methods = @modules_with_final[m]
+    if methods.nil?
+      methods = Set.new
+      @modules_with_final[m] = methods
+    end
+    methods.add(method_name)
   end
 
-  private_class_method def self.module_with_final?(mod)
-    @modules_with_final.include?(mod)
+  def self.note_module_deals_with_final(mod)
+    # Side-effectfully initialize the value if it's not already there
+    @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.
@@ -182,8 +193,8 @@ module T::Private::Methods
       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?(method_name) && module_with_final?(mod)
-      _check_final_ancestors(mod, mod.ancestors, [method_name])
+    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).
       current_declaration = T::Private::DeclState.current.active_declaration
@@ -241,11 +252,11 @@ module T::Private::Methods
 
     @sig_wrappers[key] = sig_block
     if current_declaration.final
-      add_final_method(key)
-      add_was_ever_final(method_name)
+      @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.
-      add_module_with_final(hook_mod)
+      note_module_deals_with_final(hook_mod)
+      add_module_with_final_method(hook_mod, method_name, is_singleton_method)
     end
   end
 
@@ -423,29 +434,27 @@ 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, 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)
-
-    if !target_was_final
+    if !@modules_with_final.include?(target)
+      if !@modules_with_final.include?(source)
+        return
+      end
+      note_module_deals_with_final(target)
+      install_hooks(target)
       return
     end
 
     methods = source.instance_methods
     methods.select! do |method_name|
-      was_ever_final?(method_name)
+      @was_ever_final_names.include?(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)
+    _check_final_ancestors(target, target_ancestors, methods, source)
   end
 
   def self.set_final_checks_on_hooks(enable)

data/lib/types/types/fixed_hash.rb

@@ -2,7 +2,7 @@
 # typed: true
 
 module T::Types
-  # Takes a hash of types. Validates each item in an hash using the type in the same position
+  # Takes a hash of types. Validates each item in a hash using the type in the same position
   # in the list.
   class FixedHash < Base
     attr_reader :types

metadata

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