sorbet-runtime 0.4.4667 → 0.5.6189

data/lib/types/generic.rb

@@ -14,10 +14,10 @@ module T::Generic
   end
 
   def type_member(variance=:invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
-    T::Types::TypeMember.new(variance) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+    T::Types::TypeMember.new(variance)
   end
 
   def type_template(variance=:invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
-    T::Types::TypeTemplate.new(variance) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+    T::Types::TypeTemplate.new(variance)
   end
 end

data/lib/types/interface_wrapper.rb

@@ -83,11 +83,11 @@ class T::InterfaceWrapper
     end
   end
 
-  def kind_of?(other) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+  def kind_of?(other)
     is_a?(other)
   end
 
-  def is_a?(other) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+  def is_a?(other)
     if !other.is_a?(Module)
       raise TypeError.new("class or module required")
     end
@@ -99,13 +99,13 @@ class T::InterfaceWrapper
 
   # Prefixed because we're polluting the namespace of the interface we're wrapping, and we don't
   # want anyone else (besides dynamic_cast) calling it.
-  def __target_obj_DO_NOT_USE
+  def __target_obj_DO_NOT_USE # rubocop:disable Naming/MethodName
     @target_obj
   end
 
   # Prefixed because we're polluting the namespace of the interface we're wrapping, and we don't
   # want anyone else (besides wrapped_dynamic_cast) calling it.
-  def __interface_mod_DO_NOT_USE
+  def __interface_mod_DO_NOT_USE # rubocop:disable Naming/MethodName
     @interface_mod
   end
 

data/lib/types/non_forcing_constants.rb

@@ -0,0 +1,61 @@
+# 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, package: T.nilable(String)).returns(T::Boolean)}
+  def self.non_forcing_is_a?(val, klass, package: nil)
+    # TODO(gdritter): once we have a runtime implementation of
+    # packages, we'll need to actually handle the `package` argument
+    # here.
+    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 != "" && package.nil?
+          # if we've supplied a package, we're probably running in
+          # package mode, which means absolute references are
+          # meaningless
+          raise ArgumentError.new("The string given to `#{method_name}` must be an absolute constant reference that starts with `::`")
+        end
+
+        current_klass = Object
+        current_prefix = ''
+
+        # if this had a :: prefix, then there's no more loading to
+        # do---skip to the next one
+        next if part == ""
+      end
+
+      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
+
+    current_klass.===(val)
+  end
+end

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

@@ -12,11 +12,11 @@
 # 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
+    mod.instance_variable_get("@opus_abstract__#{key}")
   end
 
   def self.set(mod, key, value)
-    mod.instance_variable_set("@opus_abstract__#{key}", value) # rubocop:disable PrisonGuard/NoLurkyInstanceVariableAccess
+    mod.instance_variable_set("@opus_abstract__#{key}", value)
   end
 
   def self.key?(mod, key)

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

@@ -40,6 +40,9 @@ module T::Private::Abstract::Declare
         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/validate.rb

@@ -61,7 +61,7 @@ module T::Private::Abstract::Validate
       # In that case, get its untyped signature.
       implementation_signature ||= Methods::Signature.new_untyped(
         method: implementation_method,
-        mode: Methods::Modes.implementation
+        mode: Methods::Modes.override
       )
       SignatureValidation.validate_override_shape(implementation_signature, abstract_signature)
       SignatureValidation.validate_override_types(implementation_signature, abstract_signature)
@@ -111,16 +111,16 @@ module T::Private::Abstract::Validate
   end
 
   private_class_method def self.describe_method(method, show_owner: true)
-    if method.source_location
-      loc = method.source_location.join(':')
+    loc = if method.source_location
+      method.source_location.join(':')
     else
-      loc = "<unknown location>"
+      "<unknown location>"
     end
 
-    if show_owner
-      owner = " declared in #{method.owner}"
+    owner = if show_owner
+      " declared in #{method.owner}"
     else
-      owner = ""
+      ""
     end
 
     "    * `#{method.name}`#{owner} at #{loc}"

data/lib/types/private/casts.rb

@@ -2,6 +2,14 @@
 # typed: false
 
 module T::Private
+  # Dynamically confirm that `value` is recursively a valid value of
+  # type `type`, including recursively through collections. Note that
+  # in some cases this runtime check can be very expensive, especially
+  # with large collections of objects.
+  def self.check_type_recursive!(value, type)
+    T::Private::Casts.cast_recursive(value, type, cast_method: "T.check_type_recursive!")
+  end
+
   module Casts
     def self.cast(value, type, cast_method:)
       begin
@@ -18,5 +26,24 @@ module T::Private
         value
       end
     end
+
+    # there's a lot of shared logic with the above one, but factoring
+    # it out like this makes it easier to hopefully one day delete
+    # this one
+    def self.cast_recursive(value, type, cast_method:)
+      begin
+        error = T::Utils.coerce(type).error_message_for_obj_recursive(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

@@ -33,16 +33,16 @@ module T::Private::ClassUtils
       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
+          @mod.send(:define_method, @old_method.name, @old_method)
         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
+        @mod.send(:remove_method, @old_method.name)
       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
+      @mod.send(@visibility, @old_method.name)
 
       nil
     end
@@ -97,10 +97,13 @@ module T::Private::ClassUtils
     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
+        mod.send(:define_method, name, &blk)
+        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
+    mod.send(original_visibility, name)
     new_method = mod.instance_method(name)
 
     ReplacedMethod.new(mod, original_method, new_method, overwritten, original_visibility)

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

@@ -72,7 +72,7 @@ module T::Private::Methods
       decl.params = {}
     end
 
-    T::Types::Proc.new(decl.params, decl.returns) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+    T::Types::Proc.new(decl.params, decl.returns)
   end
 
   # See docs at T::Utils.register_forwarder.
@@ -142,7 +142,10 @@ module T::Private::Methods
         # 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 ancestor.method_defined?(method_name) && final_method?(method_owner_and_name_to_key(ancestor, method_name))
+        if (ancestor.method_defined?(method_name) ||
+            ancestor.private_method_defined?(method_name) ||
+            ancestor.protected_method_defined?(method_name)) &&
+           final_method?(method_owner_and_name_to_key(ancestor, method_name))
           raise(
             "The method `#{method_name}` on #{ancestor} was declared as final and cannot be " +
             (target == ancestor ? "redefined" : "overridden in #{target}")
@@ -190,7 +193,7 @@ module T::Private::Methods
 
     if method_name == :method_added || method_name == :singleton_method_added
       raise(
-        "Putting a `sig` on `#{method_name}` is not supported" +
+        "Putting a `sig` on `#{method_name}` is not supported" \
         " (sorbet-runtime uses this method internally to perform `sig` validation logic)"
       )
     end
@@ -206,22 +209,12 @@ module T::Private::Methods
     # (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)
+      method_sig = T::Private::Methods.maybe_run_sig_block_for_method(new_method)
+      method_sig ||= T::Private::Methods._handle_missing_method_signature(
+        self,
+        original_method,
+        __callee__,
+      )
 
       # Should be the same logic as CallValidation.wrap_method_if_needed but we
       # don't want that extra layer of indirection in the callstack
@@ -252,6 +245,43 @@ module T::Private::Methods
     end
   end
 
+  def self._handle_missing_method_signature(receiver, original_method, callee)
+    method_sig = T::Private::Methods.signature_for_method(original_method)
+    if !method_sig
+      raise "`sig` not present for method `#{callee}` on #{receiver.inspect} 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."
+    end
+
+    if receiver.class <= original_method.owner
+      receiving_class = receiver.class
+    elsif receiver.singleton_class <= original_method.owner
+      receiving_class = receiver.singleton_class
+    elsif receiver.is_a?(Module) && receiver <= original_method.owner
+      receiving_class = receiver
+    else
+      raise "#{receiver} is not related to #{original_method} - how did we get here?"
+    end
+
+    # Check for a case where `alias` or `alias_method` was called for a
+    # method which had already had a `sig` applied. In that case, we want
+    # to avoid hitting this slow path again, by moving to a faster validator
+    # just like we did or will for the original method.
+    #
+    # If this isn't an `alias` or `alias_method` case, we're probably in the
+    # middle of some metaprogramming using a Method object, e.g. a pattern like
+    # `arr.map(&method(:foo))`. There's nothing really we can do to optimize
+    # that here.
+    receiving_method = receiving_class.instance_method(callee)
+    if receiving_method != original_method && receiving_method.original_name == original_method.name
+      aliasing_mod = receiving_method.owner
+      method_sig = method_sig.as_alias(callee)
+      unwrap_method(aliasing_mod, method_sig, original_method)
+    end
+
+    method_sig
+  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)
@@ -270,7 +300,7 @@ module T::Private::Methods
         Signature.new_untyped(method: original_method)
       end
 
-    unwrap_method(hook_mod, signature, original_method)
+    unwrap_method(signature.method.owner, signature, original_method)
     signature
   end
 
@@ -284,8 +314,12 @@ module T::Private::Methods
 
   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
+      # We allow `sig` in the current module's context (normal case) and
+      if hook_mod != current_declaration.mod &&
+         # inside `class << self`, and
+         hook_mod.singleton_class != current_declaration.mod &&
+         # on `self` at the top level of a file
+         current_declaration.mod != TOP_SELF
         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 " \
@@ -302,7 +336,6 @@ module T::Private::Methods
         check_level: current_declaration.checked,
         on_failure: current_declaration.on_failure,
         override_allow_incompatible: current_declaration.override_allow_incompatible,
-        generated: current_declaration.generated,
       )
 
       SignatureValidation.validate(signature)
@@ -323,8 +356,8 @@ module T::Private::Methods
     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)
+  def self.unwrap_method(mod, signature, original_method)
+    maybe_wrapped_method = CallValidation.wrap_method_if_needed(mod, signature, original_method)
     @signatures_by_method[method_to_key(maybe_wrapped_method)] = signature
   end
 
@@ -377,7 +410,7 @@ module T::Private::Methods
   def self.run_all_sig_blocks
     loop do
       break if @sig_wrappers.empty?
-      key, _ = @sig_wrappers.first
+      key, = @sig_wrappers.first
       run_sig_block_for_key(key)
     end
   end
@@ -394,7 +427,7 @@ module T::Private::Methods
   end
 
   def self.set_final_checks_on_hooks(enable)
-    is_enabled = @old_hooks != nil
+    is_enabled = !@old_hooks.nil?
     if enable == is_enabled
       return
     end
@@ -436,6 +469,20 @@ module T::Private::Methods
     return if @installed_hooks.include?(mod)
     @installed_hooks << mod
 
+    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
+
     if mod.singleton_class?
       mod.include(SingletonMethodHooks)
     else
@@ -455,7 +502,12 @@ module T::Private::Methods
 
   private_class_method def self.key_to_method(key)
     id, name = key.split("#")
-    obj = ObjectSpace._id2ref(id.to_i) # rubocop:disable PrisonGuard/NoDynamicConstAccess
+    obj = ObjectSpace._id2ref(id.to_i)
     obj.instance_method(name)
   end
 end
+
+# This has to be here, and can't be nested inside `T::Private::Methods`,
+# because the value of `self` depends on lexical (nesting) scope, and we
+# specifically need a reference to the file-level self, i.e. `main:Object`
+T::Private::Methods::TOP_SELF = self

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

@@ -51,10 +51,6 @@ module T::Private::Methods::CallValidation
     # This method is called for every `sig`. It's critical to keep it fast and
     # reduce number of allocations that happen here.
 
-    if method_sig.ever_failed && method_sig.generated
-      return original_method.bind(instance).call(*args, &blk)
-    end
-
     T::Profile.typecheck_sample_attempts -= 1
     should_sample = T::Profile.typecheck_sample_attempts == 0
     if should_sample
@@ -189,6 +185,9 @@ module T::Private::Methods::CallValidation
     mod.send(:define_method, method_sig.method_name) do |*args, &blk|
       CallValidation.validate_call(self, original_method, method_sig, args, blk)
     end
+    if mod.respond_to?(:ruby2_keywords, true)
+      mod.send(:ruby2_keywords, method_sig.method_name)
+    end
   end
 
   def self.create_validator_method_fast(mod, original_method, method_sig)
@@ -196,7 +195,7 @@ module T::Private::Methods::CallValidation
       raise "Should have used create_validator_procedure_fast"
     end
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.length == 0
+    if method_sig.arg_types.empty?
       create_validator_method_fast0(mod, original_method, method_sig, method_sig.return_type.raw_type)
     elsif method_sig.arg_types.length == 1
       create_validator_method_fast1(mod, original_method, method_sig, method_sig.return_type.raw_type,
@@ -252,10 +251,6 @@ module T::Private::Methods::CallValidation
         T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
       end
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(&blk)
-      end
-
       # The following line breaks are intentional to show nice pry message
 
 
@@ -303,10 +298,6 @@ module T::Private::Methods::CallValidation
       # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(arg0, &blk)
-      end
-
       T::Profile.typecheck_sample_attempts -= 1
       should_sample = T::Profile.typecheck_sample_attempts == 0
       if should_sample
@@ -392,10 +383,6 @@ module T::Private::Methods::CallValidation
       # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(arg0, arg1, &blk)
-      end
-
       T::Profile.typecheck_sample_attempts -= 1
       should_sample = T::Profile.typecheck_sample_attempts == 0
       if should_sample
@@ -493,10 +480,6 @@ module T::Private::Methods::CallValidation
       # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(arg0, arg1, arg2, &blk)
-      end
-
       T::Profile.typecheck_sample_attempts -= 1
       should_sample = T::Profile.typecheck_sample_attempts == 0
       if should_sample
@@ -607,10 +590,6 @@ module T::Private::Methods::CallValidation
       # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(arg0, arg1, arg2, arg3, &blk)
-      end
-
       T::Profile.typecheck_sample_attempts -= 1
       should_sample = T::Profile.typecheck_sample_attempts == 0
       if should_sample
@@ -729,7 +708,7 @@ module T::Private::Methods::CallValidation
 
   def self.create_validator_procedure_fast(mod, original_method, method_sig)
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.length == 0
+    if method_sig.arg_types.empty?
       create_validator_procedure_fast0(mod, original_method, method_sig)
     elsif method_sig.arg_types.length == 1
       create_validator_procedure_fast1(mod, original_method, method_sig,
@@ -760,10 +739,6 @@ module T::Private::Methods::CallValidation
       # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(&blk)
-      end
-
       T::Profile.typecheck_sample_attempts -= 1
       should_sample = T::Profile.typecheck_sample_attempts == 0
       if should_sample
@@ -817,10 +792,6 @@ module T::Private::Methods::CallValidation
       # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(arg0, &blk)
-      end
-
       T::Profile.typecheck_sample_attempts -= 1
       should_sample = T::Profile.typecheck_sample_attempts == 0
       if should_sample
@@ -884,10 +855,6 @@ module T::Private::Methods::CallValidation
       # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(arg0, arg1, &blk)
-      end
-
       T::Profile.typecheck_sample_attempts -= 1
       should_sample = T::Profile.typecheck_sample_attempts == 0
       if should_sample
@@ -964,10 +931,6 @@ module T::Private::Methods::CallValidation
       # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(arg0, arg1, arg2, &blk)
-      end
-
       T::Profile.typecheck_sample_attempts -= 1
       should_sample = T::Profile.typecheck_sample_attempts == 0
       if should_sample
@@ -1057,10 +1020,6 @@ module T::Private::Methods::CallValidation
       # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(arg0, arg1, arg2, arg3, &blk)
-      end
-
       T::Profile.typecheck_sample_attempts -= 1
       should_sample = T::Profile.typecheck_sample_attempts == 0
       if should_sample
@@ -1156,7 +1115,6 @@ module T::Private::Methods::CallValidation
   end
 
   def self.report_error(method_sig, error_message, kind, name, type, value, caller_offset: 0)
-    method_sig.mark_failed
     caller_loc = T.must(caller_locations(3 + caller_offset, 1))[0]
     definition_file, definition_line = method_sig.method.source_location