sorbet-runtime 0.6.13244 → 0.6.13245

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 352f00e93850eaf9666fe8a2959835594e53f30717be77305368e05494ad09f3
-  data.tar.gz: 9c433b7af903c36e58535d12bc3b088a108bb3900b3cac1d4ecba30d3cdd346e
+  metadata.gz: 2c95e19aa29070164c0a98a1d6d2dcf47c9ea2a5f12e98296d60c001472c1f01
+  data.tar.gz: cf5b34fe0327d15854d1115dd13ad26d3d687ae7471c36b18e952d3337dae68f
 SHA512:
-  metadata.gz: c764f72cbf8dfa35d6641a3830e9022565207e16bdf669aece0e9f8c459380182dfcc373cc53bc8ce83d96d407f9504c10abd5555849ffbe54c66ac9ad7497ca
-  data.tar.gz: 32fb241d879635f582b49762b7bdb1e08cb2eb3a8006728b62fd84f6b3696ff1d175a17a18a1cfd430e8388342bee02215d89eb3017e3583871dae1a208f65e5
+  metadata.gz: 3927fc9602822bfa8f3ee986f90b26f196d123b89d151bbe8141c7c1528a8246528e3bf2f616d78d60f98b26e7dfe7e769f0adeb336c2125f5f9419c6026ec02
+  data.tar.gz: '014459f5f1cc56477fe4975e239efbff546d5cdf6bd14058c7d3f3a573d494925d8de5cb8aa7be38ff6344dc47dea247baff2574bb814f0312b8403fbee2580c'

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

@@ -51,8 +51,6 @@ module T::Private::Methods
   DeclarationBlock = Struct.new(:mod, :loc, :blk_or_decl, :final)
 
   def self.declare_sig(mod, loc, arg, &blk)
-    install_hooks(mod)
-
     if T::Private::DeclState.current.active_declaration
       T::Private::DeclState.current.reset!
       raise "You called sig twice without declaring a method in between"
@@ -561,24 +559,18 @@ module T::Private::Methods
     end
   end
 
+  # Normally, this should be taken care of by simply `extend T::Sig`.
+  #
+  # But there are a few cases where we actually want the hooks to be "viral"
+  # for final modules and final methods, such that we actually want to forcibly
+  # install the hooks even if they would not have naturally been there via
+  # inheritance.
+  #
+  # As such, we don't have to handle quite as many edge cases as `lib/types/sig.rb` does
   def self.install_hooks(mod)
     return if @installed_hooks.include?(mod)
     @installed_hooks[mod] = true
 
-    if mod == TOP_SELF
-      # self at the top-level of a file is weirdly special in Ruby
-      # The Ruby VM on startup creates an `Object.new` and stashes it.
-      # Unlike when we're using sig inside a module, `self` is actually a
-      # normal object, not an instance of Module.
-      #
-      # Thus we can't ask things like mod.singleton_class? (since that's
-      # defined only on Module, not on Object) and even if we could, the places
-      # where we need to install the hooks are special.
-      mod.extend(SingletonMethodHooks) # def self.foo; end (at top level)
-      Object.extend(MethodHooks)       # def foo; end      (at top level)
-      return
-    end
-
     # See https://github.com/sorbet/sorbet/pull/3964 for an explanation of why this
     # check (which theoretically should not be needed) is actually needed.
     if !mod.is_a?(Module)

data/lib/types/sig.rb

@@ -4,6 +4,77 @@
 # Used as a mixin to any class so that you can call `sig`.
 # Docs at https://sorbet.org/docs/sigs
 module T::Sig
+  include T::Private::Methods::MethodHooks
+  include T::Private::Methods::SingletonMethodHooks
+
+  private_class_method def self.included(other)
+    return unless Module == other
+
+    # Module#method_added is normally a no-op method that does not call
+    # `super` and immediately returns `nil`. This means that `method_added`
+    # methods defined on an ancestor of `Module` are never called, so for
+    # `Module` itself, we need to redefine to call `super` to forward to the
+    # `method_added` defined above and which is already in the hierarchy.
+    #
+    # (`singleton_method_added` is defined on `BasicObject`, so ours does
+    # override that one.)
+    other.prepend(T::Private::Methods::MethodHooks)
+  end
+
+  private_class_method def self.extended(other)
+    if other == T::Private::Methods::TOP_SELF
+      # Methods defined via `def foo; end` at the top-level of a file are
+      # actually defined as private instance methods on `Object`, so we have to
+      # register our `method_added` hook there.
+      #
+      # Methods defined via `def self.foo; end` at the top-level are defined on
+      # a special instance of `Object` called `main` (initialized by the VM on
+      # startup), and putting `extend T::Sig` at the top-level of a file has
+      # the effect of putting `singleton_method_added` on the singleton class
+      # of `main`, which is catches those methods.
+      Object.extend(T::Private::Methods::MethodHooks)
+      return
+    end
+
+    return unless Module.===(other) && other.singleton_class?
+
+    # Given this:
+    #
+    #     class A
+    #       class << self
+    #         extend T::Sig
+    #       end
+    #     end
+    #
+    # The `singleton_method_added` hook will end up defined as if
+    # `A.singleton_class.singleton_class#singleton_method_added`[1], so methods
+    # defined via `def self.` inside the `class << self` will be hooked, but
+    # not "instance" methods, because for better or worse Ruby chooses to call
+    # `A.singleton_method_added` even for `def foo` (an instance method) inside
+    # a `class << self` definition.[2]
+    #
+    # This forces a problem on users: they need `extend T::Sig` to make `sig`
+    # callable at the class body, but they need `include T::Sig` to make sure
+    # that the `singleton_method_added` hook lands on the right place. To
+    # avoid users needing to do that, we define an extra
+    # `singleton_method_added` on the `attached_object` of the singleton
+    # class, aka `A.singleton_method_added`.[3]
+    #
+    # [1] Not actually--it will be in the ancestor chain, but callable on
+    #   values of that type.
+    #
+    # [2] I imagine this is for backwards compatibility in the common case of
+    #   one level of `class << self` nesting, so that people can define a
+    #   single `singleton_method_added` hook and have it fire for `def
+    #   self.foo` methods outside and `def foo` inside.
+    #
+    # [3] Before switching to having the hooks defined eagerly `T::Sig`
+    #   itself, this was done lazily via `include(SingletonMethodHooks)`
+    #   instead of `extend(MethodHooks)` on the first call to `sig` inside
+    #   the `class << self`.
+    other.include(T::Private::Methods::SingletonMethodHooks)
+  end
+
   module WithoutRuntime
     # At runtime, does nothing, but statically it is treated exactly the same
     # as T::Sig#sig. Only use it in cases where you can't use T::Sig#sig.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.6.13244
+  version: 0.6.13245
 platform: ruby
 authors:
 - Stripe