sorbet-runtime 0.0.1.pre.prealpha → 0.4.4253

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+# typed: true
+
+# We need to associate data with abstract modules. We could add instance methods to them that
+# access ivars, but those methods will unnecessarily pollute the module namespace, and they'd
+# have access to other private state and methods that they don't actually need. We also need to
+# associate data with arbitrary classes/modules that implement abstract mixins, where we don't
+# control the interface at all. So, we access data via these `get` and `set` methods.
+#
+# Using instance_variable_get/set here is gross, but the alternative is to use a hash keyed on
+# `mod`, and we can't trust that arbitrary modules can be added to those, because there are lurky
+# modules that override the `hash` method with something completely broken.
+module T::Private::Abstract::Data
+  def self.get(mod, key)
+    mod.instance_variable_get("@opus_abstract__#{key}") # rubocop:disable PrisonGuard/NoLurkyInstanceVariableAccess
+  end
+
+  def self.set(mod, key, value)
+    mod.instance_variable_set("@opus_abstract__#{key}", value) # rubocop:disable PrisonGuard/NoLurkyInstanceVariableAccess
+  end
+
+  def self.key?(mod, key)
+    mod.instance_variable_defined?("@opus_abstract__#{key}")
+  end
+
+  # Works like `setdefault` in Python. If key has already been set, return its value. If not,
+  # insert `key` with a value of `default` and return `default`.
+  def self.set_default(mod, key, default)
+    if self.key?(mod, key)
+      self.get(mod, key)
+    else
+      self.set(mod, key, default)
+      default
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Private::Abstract::Declare
+  Abstract = T::Private::Abstract
+  AbstractUtils = T::AbstractUtils
+
+  def self.declare_abstract(mod, type:)
+    if AbstractUtils.abstract_module?(mod)
+      raise "#{mod.name} is already declared as abstract"
+    end
+
+    Abstract::Data.set(mod, :can_have_abstract_methods, true)
+    Abstract::Data.set(mod.singleton_class, :can_have_abstract_methods, true)
+    Abstract::Data.set(mod, :abstract_type, type)
+
+    mod.extend(Abstract::Hooks)
+    mod.extend(T::InterfaceWrapper::Helpers)
+
+    if mod.is_a?(Class)
+      if type == :interface
+        # Since `interface!` is just `abstract!` with some extra validation, we could technically
+        # allow this, but it's unclear there are good use cases, and it might be confusing.
+        raise "Classes can't be interfaces. Use `abstract!` instead of `interface!`."
+      end
+
+      if mod.instance_method(:initialize).owner == mod
+        raise "You must call `abstract!` *before* defining an initialize method"
+      end
+
+      mod.send(:define_method, :initialize) do |*args, &blk|
+        if self.class == mod
+          raise "#{mod} is declared as abstract; it cannot be instantiated"
+        end
+        super(*args, &blk)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Private::Abstract::Hooks
+  # This will become the self.extend_object method on a module that extends Abstract::Hooks.
+  # It gets called when *that* module gets extended in another class/module (similar to the
+  # `extended` hook, but this gets calls before the ancestors of `other` get modified, which
+  # is important for our validation).
+  private def extend_object(other)
+    T::Private::Abstract::Data.set(self, :last_used_by, other)
+    super
+  end
+
+  # This will become the self.append_features method on a module that extends Abstract::Hooks.
+  # It gets called when *that* module gets included in another class/module (similar to the
+  # `included` hook, but this gets calls before the ancestors of `other` get modified, which
+  # is important for our validation).
+  private def append_features(other)
+    T::Private::Abstract::Data.set(self, :last_used_by, other)
+    super
+  end
+
+  # This will become the self.inherited method on a class that extends Abstract::Hooks.
+  # It gets called when *that* class gets inherited by another class.
+  private def inherited(other)
+    super
+    # `self` may not actually be abstract -- it could be a concrete class that inherited from an
+    # abstract class. We only need to check this in `inherited` because, for modules being included
+    # or extended, the concrete ones won't have these hooks at all. This is just an optimization.
+    return if !T::AbstractUtils.abstract_module?(self)
+
+    T::Private::Abstract::Data.set(self, :last_used_by, other)
+  end
+
+  # This will become the self.prepended method on a module that extends Abstract::Hooks.
+  # It will get called when *that* module gets prepended in another class/module.
+  private def prepended(other)
+    # Prepending abstract methods is weird. You'd only be able to override them via other prepended
+    # modules, or in subclasses. Punt until we have a use case.
+    Kernel.raise "Prepending abstract mixins is not currently supported. Please explain your use case " \
+          "to #dev-productivity."
+  end
+end

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Private::Abstract::Validate
+  Abstract = T::Private::Abstract
+  AbstractUtils = T::AbstractUtils
+  Methods = T::Private::Methods
+  SignatureValidation = T::Private::Methods::SignatureValidation
+
+  def self.validate_abstract_module(mod)
+    type = Abstract::Data.get(mod, :abstract_type)
+    validate_interface(mod) if type == :interface
+  end
+
+  # Validates a class/module with an abstract class/module as an ancestor. This must be called
+  # after all methods on `mod` have been defined.
+  def self.validate_subclass(mod)
+    can_have_abstract_methods = !T::Private::Abstract::Data.get(mod, :can_have_abstract_methods)
+    unimplemented_methods = []
+
+    T::AbstractUtils.declared_abstract_methods_for(mod).each do |abstract_method|
+      implementation_method = mod.instance_method(abstract_method.name)
+      if AbstractUtils.abstract_method?(implementation_method)
+        # Note that when we end up here, implementation_method might not be the same as
+        # abstract_method; the latter could've been overridden by another abstract method. In either
+        # case, if we have a concrete definition in an ancestor, that will end up as the effective
+        # implementation (see CallValidation.wrap_method_if_needed), so that's what we'll validate
+        # against.
+        implementation_method = T.unsafe(nil)
+        mod.ancestors.each do |ancestor|
+          if ancestor.instance_methods.include?(abstract_method.name)
+            method = ancestor.instance_method(abstract_method.name)
+            T::Private::Methods.maybe_run_sig_block_for_method(method)
+            if !T::AbstractUtils.abstract_method?(method)
+              implementation_method = method
+              break
+            end
+          end
+        end
+        if !implementation_method
+          # There's no implementation
+          if can_have_abstract_methods
+            unimplemented_methods << describe_method(abstract_method)
+          end
+          next # Nothing to validate
+        end
+      end
+
+      implementation_signature = Methods.signature_for_method(implementation_method)
+      # When a signature exists and the method is defined directly on `mod`, we skip the validation
+      # here, because it will have already been done when the method was defined (by
+      # T::Private::Methods._on_method_added).
+      next if implementation_signature&.owner == mod
+
+      # We validate the remaining cases here: (a) methods defined directly on `mod` without a
+      # signature and (b) methods from ancestors (note that these ancestors can come before or
+      # after the abstract module in the inheritance chain -- the former coming from
+      # walking `mod.ancestors` above).
+      abstract_signature = Methods.signature_for_method(abstract_method)
+      # We allow implementation methods to be defined without a signature.
+      # In that case, get its untyped signature.
+      implementation_signature ||= Methods::Signature.new_untyped(
+        method: implementation_method,
+        mode: Methods::Modes.implementation
+      )
+      SignatureValidation.validate_override_shape(implementation_signature, abstract_signature)
+      SignatureValidation.validate_override_types(implementation_signature, abstract_signature)
+    end
+
+    method_type = mod.singleton_class? ? "class" : "instance"
+    if !unimplemented_methods.empty?
+      raise "Missing implementation for abstract #{method_type} method(s) in #{mod}:\n" \
+            "#{unimplemented_methods.join("\n")}\n" \
+            "If #{mod} is meant to be an abstract class/module, you can call " \
+            "`abstract!` or `interface!`. Otherwise, you must implement the method(s)."
+    end
+  end
+
+  private_class_method def self.validate_interface_all_abstract(mod, method_names)
+    violations = method_names.map do |method_name|
+      method = mod.instance_method(method_name)
+      if !AbstractUtils.abstract_method?(method)
+        describe_method(method, show_owner: false)
+      end
+    end.compact
+
+    if !violations.empty?
+      raise "`#{mod}` is declared as an interface, but the following methods are not declared " \
+            "with `abstract`:\n#{violations.join("\n")}"
+    end
+  end
+
+  private_class_method def self.validate_interface(mod)
+    interface_methods = T::Utils.methods_excluding_object(mod)
+    validate_interface_all_abstract(mod, interface_methods)
+    validate_interface_all_public(mod, interface_methods)
+  end
+
+  private_class_method def self.validate_interface_all_public(mod, method_names)
+    violations = method_names.map do |method_name|
+      if !mod.public_method_defined?(method_name)
+        describe_method(mod.instance_method(method_name), show_owner: false)
+      end
+    end.compact
+
+    if !violations.empty?
+      raise "All methods on an interface must be public. If you intend to have non-public " \
+            "methods, declare your class/module using `abstract!` instead of `interface!`. " \
+            "The following methods on `#{mod}` are not public: \n#{violations.join("\n")}"
+    end
+  end
+
+  private_class_method def self.describe_method(method, show_owner: true)
+    if method.source_location
+      loc = method.source_location.join(':')
+    else
+      loc = "<unknown location>"
+    end
+
+    if show_owner
+      owner = " declared in #{method.owner}"
+    else
+      owner = ""
+    end
+
+    "    * `#{method.name}`#{owner} at #{loc}"
+  end
+end

data/lib/types/private/casts.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+# typed: false
+
+module T::Private
+  module Casts
+    def self.cast(value, type, cast_method:)
+      begin
+        error = T::Utils.coerce(type).error_message_for_obj(value)
+        return value unless error
+
+        caller_loc = T.must(caller_locations(2..2)).first
+
+        suffix = "Caller: #{T.must(caller_loc).path}:#{T.must(caller_loc).lineno}"
+
+        raise TypeError.new("#{cast_method}: #{error}\n#{suffix}")
+      rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
+        T::Private::ErrorHandler.handle_inline_type_error(e)
+        value
+      end
+    end
+  end
+end

data/lib/types/private/class_utils.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+# typed: false
+
+# Cut down version of Chalk::Tools::ClassUtils with only :replace_method functionality.
+# Extracted to a separate namespace so the type system can be used standalone.
+module T::Private::ClassUtils
+  class ReplacedMethod
+    def initialize(mod, old_method, new_method, overwritten, visibility)
+      if old_method.name != new_method.name
+        raise "Method names must match. old=#{old_method.name} new=#{new_method.name}"
+      end
+      @mod = mod
+      @old_method = old_method
+      @new_method = new_method
+      @overwritten = overwritten
+      @name = old_method.name
+      @visibility = visibility
+      @restored = false
+    end
+
+    def restore
+      # The check below would also catch this, but this makes the failure mode much clearer
+      if @restored
+        raise "Method '#{@name}' on '#{@mod}' was already restored"
+      end
+
+      if @mod.instance_method(@name) != @new_method
+        raise "Trying to restore #{@mod}##{@name} but the method has changed since the call to replace_method"
+      end
+
+      @restored = true
+
+      if @overwritten
+        # The original method was overwritten. Overwrite again to restore it.
+        @mod.send(:define_method, @old_method.name, @old_method) # rubocop:disable PrisonGuard/UsePublicSend
+      else
+        # The original method was in an ancestor. Restore it by removing the overriding method.
+        @mod.send(:remove_method, @old_method.name) # rubocop:disable PrisonGuard/UsePublicSend
+      end
+
+      # Restore the visibility. Note that we need to do this even when we call remove_method
+      # above, because the module may have set custom visibility for a method it inherited.
+      @mod.send(@visibility, @old_method.name) # rubocop:disable PrisonGuard/UsePublicSend
+
+      nil
+    end
+
+    def bind(obj)
+      @old_method.bind(obj)
+    end
+
+    def to_s
+      @old_method.to_s
+    end
+  end
+
+  # `name` must be an instance method (for class methods, pass in mod.singleton_class)
+  private_class_method def self.visibility_method_name(mod, name)
+    if mod.public_method_defined?(name)
+      :public
+    elsif mod.protected_method_defined?(name)
+      :protected
+    elsif mod.private_method_defined?(name)
+      :private
+    else
+      raise NameError.new("undefined method `#{name}` for `#{mod}`")
+    end
+  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)
+    original_method = mod.instance_method(name)
+    original_visibility = visibility_method_name(mod, name)
+    original_owner = original_method.owner
+
+    mod.ancestors.each do |ancestor|
+      break if ancestor == mod
+      if ancestor == original_owner
+        # If we get here, that means the method we're trying to replace exists on a *prepended*
+        # mixin, which means in order to supersede it, we'd need to create a method on a new
+        # module that we'd prepend before `ancestor`. The problem with that approach is there'd
+        # be no way to remove that new module after prepending it, so we'd be left with these
+        # empty anonymous modules in the ancestor chain after calling `restore`.
+        #
+        # That's not necessarily a deal breaker, but for now, we're keeping it as unsupported.
+        raise "You're trying to replace `#{name}` on `#{mod}`, but that method exists in a " \
+              "prepended module (#{ancestor}), which we don't currently support. Talk to " \
+              "#dev-productivity for help."
+      end
+    end
+
+    overwritten = original_owner == mod
+    mod.send(:define_method, name, &blk) # rubocop:disable PrisonGuard/UsePublicSend
+    mod.send(original_visibility, name) # rubocop:disable PrisonGuard/UsePublicSend
+    new_method = mod.instance_method(name)
+
+    ReplacedMethod.new(mod, original_method, new_method, overwritten, original_visibility)
+  end
+end

data/lib/types/private/decl_state.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+# typed: true
+
+class T::Private::DeclState
+  def self.current
+    Thread.current[:opus_types__decl_state] ||= self.new
+  end
+
+  def self.current=(other)
+    Thread.current[:opus_types__decl_state] = other
+  end
+
+  attr_accessor :active_declaration
+
+  def reset!
+    self.active_declaration = nil
+  end
+end

data/lib/types/private/error_handler.rb

@@ -0,0 +1,37 @@
+# typed: true
+# frozen_string_literal: true
+
+module T::Private::ErrorHandler
+  # Handle a rescued TypeError. This will pass the TypeError to the
+  # T::Configuration.inline_type_error_handler so that the user can override
+  # error handling if they wish. If no inline_type_error_handler is set, this
+  # method will call handle_inline_type_error_default, which raises the error.
+  def self.handle_inline_type_error(type_error)
+    T::Configuration.inline_type_error_handler(type_error)
+    nil
+  end
+
+  # Handle a sig declaration failure. This allows users to override the behavior
+  # when a sig decl fails. If T::Configuration.sig_builder_error_handler
+  # is unset, this method will call handle_sig_builder_error_default.
+  def self.handle_sig_builder_error(error, location)
+    T::Configuration.sig_builder_error_handler(error, location)
+    nil
+  end
+
+  # Handle a sig build validation failure. This allows users to override the
+  # behavior when a sig build fails. If T::Configuration.sig_validation_error_handler
+  # is unset, this method will call handle_sig_validation_error_default.
+  def self.handle_sig_validation_error(error, opts={})
+    T::Configuration.sig_validation_error_handler(error, opts)
+    nil
+  end
+
+  # Handle a sig call validation failure. This allows users to override the
+  # behavior when a sig call fails. If T::Configuration.call_validation_error_handler
+  # is unset, this method will call handle_call_validation_error_default.
+  def self.handle_call_validation_error(signature, opts={})
+    T::Configuration.call_validation_error_handler(signature, opts)
+    nil
+  end
+end

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

@@ -0,0 +1,344 @@
+# frozen_string_literal: true
+# typed: false
+
+module T::Private::Methods
+  @installed_hooks = Set.new
+  @signatures_by_method = {}
+  @sig_wrappers = {}
+  @sigs_that_raised = {}
+
+  ARG_NOT_PROVIDED = Object.new
+  PROC_TYPE = Object.new
+
+  DeclarationBlock = Struct.new(:mod, :loc, :blk)
+
+  def self.declare_sig(mod, &blk)
+    install_hooks(mod)
+
+    if T::Private::DeclState.current.active_declaration
+      T::Private::DeclState.current.active_declaration = nil
+      raise "You called sig twice without declaring a method inbetween"
+    end
+
+    loc = caller_locations(2, 1).first
+
+    T::Private::DeclState.current.active_declaration = DeclarationBlock.new(mod, loc, blk)
+
+    nil
+  end
+
+  def self.start_proc
+    DeclBuilder.new(PROC_TYPE)
+  end
+
+  def self.finalize_proc(decl)
+    decl.finalized = true
+
+    if decl.mode != Modes.standard
+      raise "Procs cannot have override/abstract modifiers"
+    end
+    if decl.mod != PROC_TYPE
+      raise "You are passing a DeclBuilder as a type. Did you accidentally use `self` inside a `sig` block?"
+    end
+    if decl.returns == ARG_NOT_PROVIDED
+      raise "Procs must specify a return type"
+    end
+    if decl.soft_notify != ARG_NOT_PROVIDED
+      raise "Procs cannot use .soft"
+    end
+
+    if decl.params == ARG_NOT_PROVIDED
+      decl.params = {}
+    end
+
+    T::Types::Proc.new(decl.params, decl.returns) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+  end
+
+  # See docs at T::Utils.register_forwarder.
+  def self.register_forwarder(from_method, to_method, mode: Modes.overridable, remove_first_param: false)
+    # Normalize the method (see comment in signature_for_key).
+    from_method = from_method.owner.instance_method(from_method.name)
+
+    from_key = method_to_key(from_method)
+    maybe_run_sig_block_for_key(from_key)
+    if @signatures_by_method.key?(from_key)
+      raise "#{from_method} already has a method signature"
+    end
+
+    from_params = from_method.parameters
+    if from_params.length != 2 || from_params[0][0] != :rest || from_params[1][0] != :block
+      raise "forwarder methods should take a single splat param and a block param. `#{from_method}` " \
+            "takes these params: #{from_params}. For help, ask #dev-productivity."
+    end
+
+    # If there's already a signature for to_method, we get `parameters` from there, to enable
+    # chained forwarding. NB: we don't use `signature_for_key` here, because the normalization it
+    # does is broken when `to_method` has been clobbered by another method.
+    to_key = method_to_key(to_method)
+    maybe_run_sig_block_for_key(to_key)
+    to_params = @signatures_by_method[to_key]&.parameters || to_method.parameters
+
+    if remove_first_param
+      to_params = to_params[1..-1]
+    end
+
+    # We don't bother trying to preserve any types from to_signature because this won't be
+    # statically analyzed, and the types will just get checked when the forwarding happens.
+    from_signature = Signature.new_untyped(method: from_method, mode: mode, parameters: to_params)
+    @signatures_by_method[from_key] = from_signature
+  end
+
+  # Returns the signature for a method whose definition was preceded by `sig`.
+  #
+  # @param method [UnboundMethod]
+  # @return [T::Private::Methods::Signature]
+  def self.signature_for_method(method)
+    signature_for_key(method_to_key(method))
+  end
+
+  private_class_method def self.signature_for_key(key)
+    maybe_run_sig_block_for_key(key)
+
+    # If a subclass Sub inherits a method `foo` from Base, then
+    # Sub.instance_method(:foo) != Base.instance_method(:foo) even though they resolve to the
+    # same method. Similarly, Foo.method(:bar) != Foo.singleton_class.instance_method(:bar).
+    # So, we always do the look up by the method on the owner (Base in this example).
+    @signatures_by_method[key]
+  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)
+    current_declaration = T::Private::DeclState.current.active_declaration
+    return if !current_declaration
+    T::Private::DeclState.current.reset!
+
+    mod = is_singleton_method ? hook_mod.singleton_class : hook_mod
+    original_method = mod.instance_method(method_name)
+
+    sig_block = lambda do
+      T::Private::Methods.run_sig(hook_mod, method_name, original_method, current_declaration)
+    end
+
+    # Always replace the original method with this wrapper,
+    # which is called only on the *first* invocation.
+    # This wrapper is very slow, so it will subsequently re-wrap with a much faster wrapper
+    # (or unwrap back to the original method).
+    new_method = nil
+    T::Private::ClassUtils.replace_method(mod, method_name) do |*args, &blk|
+      if !T::Private::Methods.has_sig_block_for_method(new_method)
+        # This should only happen if the user used alias_method to grab a handle
+        # to the original pre-unwound `sig` method. I guess we'll just proxy the
+        # call forever since we don't know who is holding onto this handle to
+        # replace it.
+        new_new_method = mod.instance_method(method_name)
+        if new_method == new_new_method
+          raise "`sig` not present for method `#{method_name}` but you're trying to run it anyways. " \
+          "This should only be executed if you used `alias_method` to grab a handle to a method after `sig`ing it, but that clearly isn't what you are doing. " \
+          "Maybe look to see if an exception was thrown in your `sig` lambda or somehow else your `sig` wasn't actually applied to the method. " \
+          "Contact #dev-productivity if you're really stuck."
+        end
+        return new_new_method.bind(self).call(*args, &blk)
+      end
+
+      method_sig = T::Private::Methods.run_sig_block_for_method(new_method)
+
+      # Should be the same logic as CallValidation.wrap_method_if_needed but we
+      # don't want that extra layer of indirection in the callstack
+      if method_sig.mode == T::Private::Methods::Modes.abstract
+        # We're in an interface method, keep going up the chain
+        if defined?(super)
+          super(*args, &blk)
+        else
+          raise NotImplementedError.new("The method `#{method_sig.method_name}` on #{mod} is declared as `abstract`. It does not have an implementation.")
+        end
+      # Note, this logic is duplicated (intentionally, for micro-perf) at `CallValidation.wrap_method_if_needed`,
+      # make sure to keep changes in sync.
+      elsif method_sig.check_level == :always || (method_sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
+        CallValidation.validate_call(self, original_method, method_sig, args, blk)
+      else
+        original_method.bind(self).call(*args, &blk)
+      end
+    end
+
+    new_method = mod.instance_method(method_name)
+    @sig_wrappers[method_to_key(new_method)] = sig_block
+  end
+
+  def self.sig_error(loc, message)
+    raise(
+      ArgumentError.new(
+        "#{loc.path}:#{loc.lineno}: Error interpreting `sig`:\n  #{message}\n\n"
+      )
+    )
+  end
+
+  # Executes the `sig` block, and converts the resulting Declaration
+  # to a Signature.
+  def self.run_sig(hook_mod, method_name, original_method, declaration_block)
+    current_declaration =
+      begin
+        run_builder(declaration_block)
+      rescue DeclBuilder::BuilderError => e
+        T::Private::ErrorHandler.handle_sig_builder_error(e, declaration_block.loc)
+        nil
+      end
+
+    signature =
+      if current_declaration
+        build_sig(hook_mod, method_name, original_method, current_declaration, declaration_block.loc)
+      else
+        Signature.new_untyped(method: original_method)
+      end
+
+    unwrap_method(hook_mod, signature, original_method)
+    signature
+  end
+
+  def self.run_builder(declaration_block)
+    builder = DeclBuilder.new(declaration_block.mod)
+    builder
+      .instance_exec(&declaration_block.blk)
+      .finalize!
+      .decl
+  end
+
+  def self.build_sig(hook_mod, method_name, original_method, current_declaration, loc)
+    begin
+      # We allow `sig` in the current module's context (normal case) and inside `class << self`
+      if hook_mod != current_declaration.mod && hook_mod.singleton_class != current_declaration.mod
+        raise "A method (#{method_name}) is being added on a different class/module (#{hook_mod}) than the " \
+              "last call to `sig` (#{current_declaration.mod}). Make sure each call " \
+              "to `sig` is immediately followed by a method definition on the same " \
+              "class/module."
+      end
+
+      if current_declaration.returns.equal?(ARG_NOT_PROVIDED)
+        sig_error(loc, "You must provide a return type; use the `.returns` or `.void` builder methods. Method: #{original_method}")
+      end
+
+      signature = Signature.new(
+        method: original_method,
+        method_name: method_name,
+        raw_arg_types: current_declaration.params,
+        raw_return_type: current_declaration.returns,
+        bind: current_declaration.bind,
+        mode: current_declaration.mode,
+        check_level: current_declaration.checked,
+        soft_notify: current_declaration.soft_notify,
+        override_allow_incompatible: current_declaration.override_allow_incompatible,
+        generated: current_declaration.generated,
+      )
+
+      SignatureValidation.validate(signature)
+      signature
+    rescue => e
+      super_method = original_method&.super_method
+      super_signature = signature_for_method(super_method) if super_method
+
+      T::Private::ErrorHandler.handle_sig_validation_error(
+        e,
+        method: original_method,
+        declaration: current_declaration,
+        signature: signature,
+        super_signature: super_signature
+      )
+
+      Signature.new_untyped(method: original_method)
+    end
+  end
+
+  def self.unwrap_method(hook_mod, signature, original_method)
+    maybe_wrapped_method = CallValidation.wrap_method_if_needed(signature.method.owner, signature, original_method)
+    @signatures_by_method[method_to_key(maybe_wrapped_method)] = signature
+  end
+
+  def self.has_sig_block_for_method(method)
+    has_sig_block_for_key(method_to_key(method))
+  end
+
+  private_class_method def self.has_sig_block_for_key(key)
+    @sig_wrappers.key?(key)
+  end
+
+  def self.maybe_run_sig_block_for_method(method)
+    maybe_run_sig_block_for_key(method_to_key(method))
+  end
+
+  private_class_method def self.maybe_run_sig_block_for_key(key)
+    run_sig_block_for_key(key) if has_sig_block_for_key(key)
+  end
+
+  def self.run_sig_block_for_method(method)
+    run_sig_block_for_key(method_to_key(method))
+  end
+
+  private_class_method def self.run_sig_block_for_key(key)
+    blk = @sig_wrappers[key]
+    if !blk
+      raise "No `sig` wrapper for #{key_to_method(key)}"
+    end
+
+    begin
+      sig = blk.call
+    rescue
+      @sigs_that_raised[key] = true
+      raise
+    end
+    if @sigs_that_raised[key]
+      raise "A previous invocation of #{key_to_method(key)} raised, and the current one succeeded. Please don't do that."
+    end
+
+    @sig_wrappers.delete(key)
+    sig
+  end
+
+  def self.run_all_sig_blocks
+    loop do
+      break if @sig_wrappers.empty?
+      key, _ = @sig_wrappers.first
+      run_sig_block_for_key(key)
+    end
+  end
+
+  def self.install_hooks(mod)
+    return if @installed_hooks.include?(mod)
+    @installed_hooks << mod
+
+    if mod.singleton_class?
+      install_singleton_method_added_hook(mod)
+      install_singleton_method_added_hook(mod.singleton_class)
+    else
+      original_method = T::Private::ClassUtils.replace_method(mod.singleton_class, :method_added) do |name|
+        T::Private::Methods._on_method_added(self, name)
+        original_method.bind(self).call(name)
+      end
+
+      install_singleton_method_added_hook(mod.singleton_class)
+    end
+  end
+
+  private_class_method def self.install_singleton_method_added_hook(singleton_klass)
+    attached = nil
+    original_singleton_method = T::Private::ClassUtils.replace_method(singleton_klass, :singleton_method_added) do |name|
+      attached = self
+      T::Private::Methods._on_method_added(self, name, is_singleton_method: true)
+      # This will be nil when this gets called for the addition of this method itself. We
+      # call it below to compensate.
+      if original_singleton_method
+        original_singleton_method.bind(self).call(name)
+      end
+    end
+    # See the comment above
+    original_singleton_method.bind(attached).call(:singleton_method_added)
+  end
+
+  private_class_method def self.method_to_key(method)
+    "#{method.owner.object_id}##{method.name}"
+  end
+
+  private_class_method def self.key_to_method(key)
+    id, name = key.split("#")
+    obj = ObjectSpace._id2ref(id.to_i) # rubocop:disable PrisonGuard/NoDynamicConstAccess
+    obj.instance_method(name)
+  end
+end