sorbet-runtime 0.6.12984 → 0.6.13286

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34676c45c9ee3121fd2bef3ccd7748843cb9720be11d18d730eefa648ad17fc4
-  data.tar.gz: 59f462975d25a7f566fae4bb3e2ff75b16d348c392b725567ca9bec41cfca997
+  metadata.gz: e2b15b12f019d99d0883d3987d7bd205a368b8646b8c998328967023be62d8a1
+  data.tar.gz: dbed6520ccd76a2ac122f63cfee589811b4ea570d72d994b0c6e1e2391640e8e
 SHA512:
-  metadata.gz: b30613cca7cf091f67f6725fdd878acec5d17d83a2e0beb0ee81c3e8e3d8781c8e5a413d4969ad0fe1dc2dd5f579d87d3cee9c370914f72fb9f68fd972d0d37f
-  data.tar.gz: 4cdb21494e6f932beec12c4c27a872a4301181d3044065e4ce4f725bba7db3bd9f9c83eacdf2b1bc71898a302d1d552144533bb36bfd96b85b03e9529f3e7298
+  metadata.gz: a30b5d79bb6b5ae5dd11b6a82bdec010bb00ba90d386db70a9fa8ff191180e2a264f89243f45674a7db2d6f7c17f6856d6b32e0795cacb6717852c1e2a902c1a
+  data.tar.gz: 69d156afa66059195cbc8cf6d5aad958cfc5132959fc18842716d8df563a4f08788e24fd9a43313ba7e667f4e81c30abed3e1aa03a90ee021d267d9061df9ba3

data/lib/sorbet-runtime.rb

@@ -9,6 +9,7 @@
 module T; end
 module T::Helpers; end
 module T::Private; end
+T::Private::IS_TYPECHECKING = false
 module T::Private::Abstract; end
 module T::Private::Types; end
 

data/lib/types/_types.rb

@@ -342,7 +342,11 @@ module T
 
   module Range
     def self.[](type)
-      T::Types::TypedRange.new(type)
+      if type.is_a?(T::Types::Untyped)
+        T::Types::TypedRange::Untyped.new
+      else
+        T::Types::TypedRange.new(type)
+      end
     end
   end
 

data/lib/types/compatibility_patches.rb

@@ -51,6 +51,48 @@ if defined? ::RSpec::Mocks
   end
 end
 
+# Allow using `sig {...}` on top of a `let`-defined method in an RSpec example group
+if defined? ::RSpec::Core::MemoizedHelpers::ClassMethods
+  module T
+    module CompatibilityPatches
+      module RSpecCompatibility
+        module MemoizedHelpers
+          # `let!`, `subject`, and `subject!` are implemented by dispatching to
+          # `let`, so this should cover those methods too.
+          def let(name, &block)
+            res = T::Private::DeclState.current.without_on_method_added do
+              # Allow the `let`-defined methods to be defined
+              super
+            end
+
+            return res unless T::Private::DeclState.current.active_declaration
+
+            # Force the `sig` to attach to the outer `let`-defined method,
+            # not the one inside the `LetDefinitions` module. Re-running
+            # `define_method` with the method we grab via reflection there
+            # triggers the `method_added`, which allows the active_declaration
+            # to be consumed.
+            #
+            # Unfortunately, this means that the runtime checks are not
+            # memoized (but they never were).
+            #
+            # (An alternative approach of pretending that the `sig` was actually
+            # written inside the `LetDefinitions` module didn't work, because
+            # things like `sig {override}` broke: the `LetDefinitions` module
+            # has no ancestors and thus does not override anything)
+            method = instance_method(name)
+            remove_method(name)
+            define_method(name, method)
+
+            res
+          end
+        end
+        ::RSpec::Core::MemoizedHelpers::ClassMethods.prepend(MemoizedHelpers)
+      end
+    end
+  end
+end
+
 # Work around for sorbet-runtime wrapped methods.
 #
 # When a sig is defined, sorbet-runtime will replace the sigged method

data/lib/types/configuration.rb

@@ -1,5 +1,5 @@
-# typed: true
 # frozen_string_literal: true
+# typed: true
 
 module T::Configuration
   # Announces to Sorbet that we are currently in a test environment, so it

data/lib/types/helpers.rb

@@ -4,8 +4,6 @@
 # Use as a mixin with extend (`extend T::Helpers`).
 # Docs at https://sorbet.org/docs/
 module T::Helpers
-  extend T::Sig
-
   Private = T::Private
 
   ### Class/Module Helpers ###

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

@@ -27,7 +27,7 @@ module T::Private::Abstract::Hooks
     # `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)
+    return if !T::AbstractUtils.abstract_module?(T.unsafe(self))
 
     T::Private::Abstract::Data.set(self, :last_used_by, other)
   end

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

@@ -9,7 +9,7 @@ module T::Private::Abstract::Validate
 
   def self.validate_abstract_module(mod)
     type = Abstract::Data.get(mod, :abstract_type)
-    validate_interface(mod) if type == :interface
+    validate_interface(mod) if :interface == type
   end
 
   # Validates a class/module with an abstract class/module as an ancestor. This must be called
@@ -56,7 +56,7 @@ module T::Private::Abstract::Validate
       # 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)
+      abstract_signature = Methods.signature_for_method(abstract_method) || raise("Method being abstract must imply it has a signature")
       # We allow implementation methods to be defined without a signature.
       # In that case, get its untyped signature.
       implementation_signature ||= Methods::Signature.new_untyped(
@@ -111,8 +111,8 @@ module T::Private::Abstract::Validate
   end
 
   private_class_method def self.describe_method(method, show_owner: true)
-    loc = if method.source_location
-      method.source_location.join(':')
+    loc = if (source_loc = method.source_location)
+      source_loc.join(':')
     else
       "<unknown location>"
     end

data/lib/types/private/casts.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: false
+# typed: true
 
 module T::Private
   module Casts

data/lib/types/private/class_utils.rb

@@ -1,63 +1,16 @@
 # frozen_string_literal: true
-# typed: false
+# typed: true
 
 # 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.
+#
+# Note: the functionality to "restore" a method was removed, because it is no
+# longer being used by sorbet-runtime. Restoring a method requires care--if you
+# need to reintroduce this functionality, consult the git history for how to do
+# it safely.
 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)
-        end
-      else
-        # The original method was in an ancestor. Restore it by removing the overriding method.
-        @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)
-
-      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)
+  def self.visibility_method_name(mod, name)
     if mod.public_method_defined?(name)
       :public
     elsif mod.protected_method_defined?(name)
@@ -65,7 +18,13 @@ module T::Private::ClassUtils
     elsif mod.private_method_defined?(name)
       :private
     else
-      mod.method(name) # Raises
+      # Raises a NameError formatted like the Ruby VM would (the exact text formatting
+      # of these errors changed across Ruby VM versions, in ways that would sometimes
+      # cause tests to fail if they were dependent on hard coding errors).
+      mod.method(name)
+      # This is just to prove to Sorbet that this method raises.
+      # This line should be unreachable in practice due to the above call.
+      raise NameError.new("undefined method `#{name}' for class `#{mod}'")
     end
   end
 
@@ -85,20 +44,26 @@ module T::Private::ClassUtils
       end
 
       if block && block.arity < 0 && respond_to?(:ruby2_keywords, true)
-        ruby2_keywords(name)
+        m = instance_method(name)
+        has_rest = m.parameters.any? { |type, _| type == :rest }
+        has_keywords = m.parameters.any? { |type, _| %i[keyrest keyreq key].include?(type) }
+        ruby2_keywords(name) if has_rest && !has_keywords
       end
     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).  If `original_only` is
-  # false, 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).
+  # 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).
+  #
+  # Takes the `original_method` as a parameter, so it does not return anything.
+  #
+  # Can also avoid `T.let` pinning errors by letting the caller pre-compute the
+  # `original_method`, so it knows that it will always be defined (because it
+  # doesn't know that the block will always run once)
   #
-  # If `original_only` is true, return the `UnboundMethod` representing the original method.
-  def self.replace_method(mod, name, original_only=false, &blk)
-    original_method = mod.instance_method(name)
+  # Does not share code with `replace_method_with_handle`, for performance (do
+  # not want to increase the call stack, as this is a very sensitive code path).
+  def self.replace_method(original_method, mod, name, &blk)
     original_visibility = visibility_method_name(mod, name)
     original_owner = original_method.owner
 
@@ -117,18 +82,12 @@ module T::Private::ClassUtils
       end
     end
 
-    overwritten = original_owner == mod
     T::Configuration.without_ruby_warnings do
       T::Private::DeclState.current.without_on_method_added do
         def_with_visibility(mod, name, original_visibility, &blk)
       end
     end
 
-    if original_only
-      original_method
-    else
-      new_method = mod.instance_method(name)
-      ReplacedMethod.new(mod, original_method, new_method, overwritten, original_visibility)
-    end
+    nil
   end
 end

data/lib/types/private/final.rb

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
-# typed: false
+# typed: true
 
 module T::Private::Final
   module NoInherit
     def inherited(arg)
       super(arg)
-      raise "#{self} was declared as final and cannot be inherited"
+      Kernel.raise "#{self} was declared as final and cannot be inherited"
     end
   end
 
   module NoIncludeExtend
     def included(arg)
       super(arg)
-      raise "#{self} was declared as final and cannot be included"
+      Kernel.raise "#{self} was declared as final and cannot be included"
     end
 
     def extended(arg)
       super(arg)
-      raise "#{self} was declared as final and cannot be extended"
+      Kernel.raise "#{self} was declared as final and cannot be extended"
     end
   end