sorbet-runtime 0.5.5841

data/lib/types/non_forcing_constants.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+# typed: strict
+
+module T::NonForcingConstants
+  # NOTE: This method is documented on the RBI in Sorbet's payload, so that it
+  # shows up in the hover/completion documentation via LSP.
+  T::Sig::WithoutRuntime.sig {params(val: BasicObject, klass: String).returns(T::Boolean)}
+  def self.non_forcing_is_a?(val, klass)
+    method_name = "T::NonForcingConstants.non_forcing_is_a?"
+    if klass.empty?
+      raise ArgumentError.new("The string given to `#{method_name}` must not be empty")
+    end
+
+    current_klass = T.let(nil, T.nilable(Module))
+    current_prefix = T.let(nil, T.nilable(String))
+
+    parts = klass.split('::')
+    parts.each do |part|
+      if current_klass.nil?
+        # First iteration
+        if part != ""
+          raise ArgumentError.new("The string given to `#{method_name}` must be an absolute constant reference that starts with `::`")
+        end
+
+        current_klass = Object
+        current_prefix = ''
+      else
+        if current_klass.autoload?(part)
+          # There's an autoload registered for that constant, which means it's not
+          # yet loaded. `value` can't be an instance of something not yet loaded.
+          return false
+        end
+
+        # Sorbet guarantees that the string is an absolutely resolved name.
+        search_inheritance_chain = false
+        if !current_klass.const_defined?(part, search_inheritance_chain)
+          return false
+        end
+
+        current_klass = current_klass.const_get(part)
+        current_prefix = "#{current_prefix}::#{part}"
+
+        if !Module.===(current_klass)
+          raise ArgumentError.new("#{current_prefix} is not a class or module")
+        end
+      end
+    end
+
+    return current_klass.===(val)
+  end
+end

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,48 @@
+# 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} is already declared as abstract"
+    end
+    if T::Private::Final.final_module?(mod)
+      raise "#{mod} was already declared as final and cannot be 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
+
+      # Don't need to silence warnings via without_ruby_warnings when calling
+      # define_method because of the guard above
+
+      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
+      if mod.respond_to?(:ruby2_keywords, true)
+        mod.send(:ruby2_keywords, :initialize)
+      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.override
+      )
+      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::Configuration.inline_type_error_handler(e)
+        value
+      end
+    end
+  end
+end

data/lib/types/private/class_utils.rb

@@ -0,0 +1,111 @@
+# 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.
+        T::Configuration.without_ruby_warnings do
+          @mod.send(:define_method, @old_method.name, @old_method) # rubocop:disable PrisonGuard/UsePublicSend
+        end
+      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
+    T::Configuration.without_ruby_warnings do
+      T::Private::DeclState.current.without_on_method_added do
+        mod.send(:define_method, name, &blk) # rubocop:disable PrisonGuard/UsePublicSend
+        if blk.arity < 0 && mod.respond_to?(:ruby2_keywords, true)
+          mod.send(:ruby2_keywords, name)
+        end
+      end
+    end
+    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,30 @@
+# 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
+  attr_accessor :skip_on_method_added
+
+  def reset!
+    self.active_declaration = nil
+  end
+
+  def without_on_method_added
+    begin
+      # explicit 'self' is needed here
+      old_value = self.skip_on_method_added
+      self.skip_on_method_added = true
+      yield
+    ensure
+      self.skip_on_method_added = old_value
+    end
+  end
+end