sorbet-runtime 0.5.5316 → 0.5.5956

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96ac3f40e289c8880e546f48cc793e4e12461e713ac5a6d5daf9777d91af2774
-  data.tar.gz: 425ccca3f410868f357385eba3bbf0e8cc9cdd4b2cdc252137b0da96b36d5002
+  metadata.gz: 569e1e784f7d9e4c911cc92571704e406dfe981df3285218ae06b245b2e113db
+  data.tar.gz: 2d7b5f9878d6fe05add390255cdfe0dd70c69a77bbd06d5a32a1d02deec7f1b1
 SHA512:
-  metadata.gz: 28df096a88491a837b89157f6b3fb2a779d0e61729e0c9363740a9fa8ddef7d23156f0c910fcc0b9569daba0826dfef9e22441bb82718872923a444c09b9536c
-  data.tar.gz: cae44a94689f106188a491200eccf8b0da90e61ce2b089f79dbf8bcbb0ac4c486c9a10934f3647762aa3c179df677bfeee571665e1154b5929ebb8275ed3d7cf
+  metadata.gz: e93ae059f1d875a26242803edbae96a335a179a3ef2862ad1c2ad9c1729cb8041ec44c8fcd4520a25e33de9ff421a7edd67032579a1d60b6e8d6c649f6b6d0a1
+  data.tar.gz: 8b9b92b336911870b563666c7495b2f5ac52ddb3b2ec805dfcb1fbd48393dbfc63c89dd35c13f18ffeed04b7cdb9ff619591e011cf115975fc5392b6ab01be2b

data/lib/sorbet-runtime.rb

@@ -80,6 +80,7 @@ require_relative 'types/private/abstract/hooks'
 require_relative 'types/private/casts'
 require_relative 'types/private/methods/decl_builder'
 require_relative 'types/private/methods/signature'
+require_relative 'types/private/retry'
 require_relative 'types/utils'
 require_relative 'types/boolean'
 
@@ -92,16 +93,24 @@ require_relative 'types/props/decorator'
 require_relative 'types/props/errors'
 require_relative 'types/props/plugin'
 require_relative 'types/props/utils'
+require_relative 'types/enum'
 # Props that run sigs statically so have to be after all the others :(
 require_relative 'types/props/private/setter_factory'
+require_relative 'types/props/private/apply_default'
+require_relative 'types/props/has_lazily_specialized_methods'
 require_relative 'types/props/optional'
 require_relative 'types/props/weak_constructor'
 require_relative 'types/props/constructor'
 require_relative 'types/props/pretty_printable'
+require_relative 'types/props/private/serde_transform'
+require_relative 'types/props/private/deserializer_generator'
+require_relative 'types/props/private/serializer_generator'
 require_relative 'types/props/serializable'
 require_relative 'types/props/type_validation'
+require_relative 'types/props/private/parser'
+require_relative 'types/props/generated_code_validation'
 
 require_relative 'types/struct'
-require_relative 'types/enum'
+require_relative 'types/non_forcing_constants'
 
 require_relative 'types/compatibility_patches'

data/lib/types/_types.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 # typed: true
 # This is where we define the shortcuts, so we can't use them here
-# rubocop:disable PrisonGuard/UseOpusTypesShortcut
 
 #  _____
 # |_   _|   _ _ __   ___  ___
@@ -26,23 +25,26 @@
 module T
   # T.any(<Type>, <Type>, ...) -- matches any of the types listed
   def self.any(type_a, type_b, *types)
-    T::Types::Union.new([type_a, type_b] + types)
+    type_a = T::Utils.coerce(type_a)
+    type_b = T::Utils.coerce(type_b)
+    types = types.map {|t| T::Utils.coerce(t)} if !types.empty?
+    T::Types::Union::Private::Pool.union_of_types(type_a, type_b, types)
   end
 
   # Shorthand for T.any(type, NilClass)
   def self.nilable(type)
-    T::Types::Union.new([type, NilClass])
+    T::Types::Union::Private::Pool.union_of_types(T::Utils.coerce(type), T::Utils::Nilable::NIL_TYPE)
   end
 
   # Matches any object. In the static checker, T.untyped allows any
   # method calls or operations.
   def self.untyped
-    T::Types::Untyped.new
+    T::Types::Untyped::Private::INSTANCE
   end
 
   # Indicates a function never returns (e.g. "Kernel#raise")
   def self.noreturn
-    T::Types::NoReturn.new
+    T::Types::NoReturn::Private::INSTANCE
   end
 
   # T.all(<Type>, <Type>, ...) -- matches an object that has all of the types listed
@@ -62,12 +64,12 @@ module T
 
   # Matches `self`:
   def self.self_type
-    T::Types::SelfType.new
+    T::Types::SelfType::Private::INSTANCE
   end
 
   # Matches the instance type in a singleton-class context
   def self.attached_class
-    T::Types::AttachedClassType.new
+    T::Types::AttachedClassType::Private::INSTANCE
   end
 
   # Matches any class that subclasses or includes the provided class
@@ -103,7 +105,7 @@ module T
     end
   end
 
-  # References a type paramater which was previously defined with
+  # References a type parameter which was previously defined with
   # `type_parameters`.
   #
   # This is used for generic methods. Example usage:
@@ -282,4 +284,3 @@ module T
     end
   end
 end
-# rubocop:enable PrisonGuard/UseOpusTypesShortcut

data/lib/types/compatibility_patches.rb

@@ -4,7 +4,8 @@
 require_relative 'private/methods/_methods'
 
 # Work around an interaction bug with sorbet-runtime and rspec-mocks,
-# which occurs when using *_any_instance_of and and_call_original.
+# which occurs when using message expectations (*_any_instance_of,
+# expect, allow) and and_call_original.
 #
 # When a sig is defined, sorbet-runtime will replace the sigged method
 # with a wrapper that, upon first invocation, re-wraps the method with a faster
@@ -22,17 +23,73 @@ require_relative 'private/methods/_methods'
 #
 # We work around this by forcing re-wrapping before rspec stores a reference
 # to the method.
-if defined? ::RSpec::Mocks::AnyInstance
+if defined? ::RSpec::Mocks
   module T
     module CompatibilityPatches
-      module RecorderExtensions
-        def observe!(method_name)
-          method = @klass.instance_method(method_name.to_sym)
-          T::Private::Methods.maybe_run_sig_block_for_method(method)
-          super(method_name)
+      module RSpecCompatibility
+        module RecorderExtensions
+          def observe!(method_name)
+            method = @klass.instance_method(method_name.to_sym)
+            T::Private::Methods.maybe_run_sig_block_for_method(method)
+            super(method_name)
+          end
         end
+        ::RSpec::Mocks::AnyInstance::Recorder.prepend(RecorderExtensions) if defined?(::RSpec::Mocks::AnyInstance::Recorder)
+
+        module MethodDoubleExtensions
+          def initialize(object, method_name, proxy)
+            if ::Kernel.instance_method(:respond_to?).bind(object).call(method_name, true)
+              method = ::RSpec::Support.method_handle_for(object, method_name)
+              T::Private::Methods.maybe_run_sig_block_for_method(method)
+            end
+            super(object, method_name, proxy)
+          end
+        end
+        ::RSpec::Mocks::MethodDouble.prepend(MethodDoubleExtensions) if defined?(::RSpec::Mocks::MethodDouble)
+      end
+    end
+  end
+end
+
+# Work around for sorbet-runtime wrapped methods.
+#
+# When a sig is defined, sorbet-runtime will replace the sigged method
+# with a wrapper. Those wrapper methods look like `foo(*args, &blk)`
+# so that wrappers can handle and pass on all the arguments supplied.
+#
+# However, that creates a problem with runtime reflection on the methods,
+# since when a sigged method is introspected, it will always return its
+# `arity` as `-1`, its `parameters` as `[[:rest, :args], [:block, :blk]]`,
+# and its `source_location` as `[<some_file_in_sorbet>, <some_line_number>]`.
+#
+# This might be a problem for some applications that rely on getting the
+# correct information from these methods.
+#
+# This compatibility module, when prepended to the `Method` class, would fix
+# the return values of `arity`, `parameters` and `source_location`.
+#
+# @example
+#   require 'sorbet-runtime'
+#   ::Method.prepend(T::CompatibilityPatches::MethodExtensions)
+module T
+  module CompatibilityPatches
+    module MethodExtensions
+      def arity
+        arity = super
+        return arity if arity != -1 || self.is_a?(Proc)
+        sig = T::Private::Methods.signature_for_method(self)
+        sig ? sig.method.arity : arity
+      end
+
+      def source_location
+        sig = T::Private::Methods.signature_for_method(self)
+        sig ? sig.method.source_location : super
+      end
+
+      def parameters
+        sig = T::Private::Methods.signature_for_method(self)
+        sig ? sig.method.parameters : super
       end
-      ::RSpec::Mocks::AnyInstance::Recorder.prepend(RecorderExtensions)
     end
   end
 end

data/lib/types/configuration.rb

@@ -248,7 +248,7 @@ module T::Configuration
   end
 
   private_class_method def self.log_info_handler_default(str, extra)
-    puts "#{str}, extra: #{extra}" # rubocop:disable PrisonGuard/NoBarePuts
+    puts "#{str}, extra: #{extra}"
   end
 
   def self.log_info_handler(str, extra)
@@ -282,7 +282,7 @@ module T::Configuration
   end
 
   private_class_method def self.soft_assert_handler_default(str, extra)
-    puts "#{str}, extra: #{extra}" # rubocop:disable PrisonGuard/NoBarePuts
+    puts "#{str}, extra: #{extra}"
   end
 
   def self.soft_assert_handler(str, extra)
@@ -336,7 +336,7 @@ module T::Configuration
   #   T::Configuration.scalar_types = ["NilClass", "TrueClass", "FalseClass", ...]
   def self.scalar_types=(values)
     if values.nil?
-      @scalar_tyeps = values
+      @scalar_types = values
     else
       bad_values = values.select {|v| v.class != String}
       unless bad_values.empty?

data/lib/types/enum.rb

@@ -57,6 +57,17 @@ class T::Enum
     @values
   end
 
+  # This exists for compatibility with the interface of `Hash` & mostly to support
+  # the HashEachMethods Rubocop.
+  sig {params(blk: T.nilable(T.proc.params(arg0: T.attached_class).void)).returns(T.any(T::Enumerator[T.attached_class], T::Array[T.attached_class]))}
+  def self.each_value(&blk)
+    if blk
+      values.each(&blk)
+    else
+      values.each
+    end
+  end
+
   # Convert from serialized value to enum instance
   #
   # Note: It would have been nice to make this method final before people started overriding it.
@@ -88,7 +99,7 @@ class T::Enum
 
   # Note: It would have been nice to make this method final before people started overriding it.
   # @return [Boolean] Does the given serialized value correspond with any of this enum's values.
-  sig {overridable.params(serialized_val: SerializedVal).returns(T::Boolean)}
+  sig {overridable.params(serialized_val: SerializedVal).returns(T::Boolean).checked(:never)}
   def self.has_serialized?(serialized_val)
     if @mapping.nil?
       raise "Attempting to access serialization map of #{self.class} before it has been initialized." \
@@ -97,17 +108,8 @@ class T::Enum
     @mapping.include?(serialized_val)
   end
 
-
-  ## T::Props::CustomType
-
-  # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  sig {params(value: T.untyped).returns(T::Boolean).checked(:never)}
-  def self.instance?(value)
-    value.is_a?(self)
-  end
-
   # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  sig {params(instance: T.nilable(T::Enum)).returns(SerializedVal).checked(:never)}
+  sig {override.params(instance: T.nilable(T::Enum)).returns(SerializedVal).checked(:never)}
   def self.serialize(instance)
     # This is needed otherwise if a Chalk::ODM::Document with a property of the shape
     # T::Hash[T.nilable(MyEnum), Integer] and a value that looks like {nil => 0} is
@@ -124,7 +126,7 @@ class T::Enum
   end
 
   # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  sig {params(mongo_value: SerializedVal).returns(T.attached_class).checked(:never)}
+  sig {override.params(mongo_value: SerializedVal).returns(T.attached_class).checked(:never)}
   def self.deserialize(mongo_value)
     if self == T::Enum
       raise "Cannot call T::Enum.deserialize directly. You must call on a specific child class."
@@ -249,7 +251,7 @@ class T::Enum
 
 
   sig {params(serialized_val: SerializedVal).void}
-  private def initialize(serialized_val=nil)
+  def initialize(serialized_val=nil)
     raise 'T::Enum is abstract' if self.class == T::Enum
     if !self.class.started_initializing?
       raise "Must instantiate all enum values of #{self.class} inside 'enums do'."
@@ -261,6 +263,7 @@ class T::Enum
     serialized_val = serialized_val.frozen? ? serialized_val : serialized_val.dup.freeze
     @serialized_val = T.let(serialized_val, T.nilable(SerializedVal))
     @const_name = T.let(nil, T.nilable(Symbol))
+    self.class._register_instance(self)
   end
 
   sig {returns(NilClass).checked(:never)}
@@ -298,6 +301,13 @@ class T::Enum
     @fully_initialized ||= false
   end
 
+  # Maintains the order in which values are defined
+  sig {params(instance: T.untyped).void}
+  def self._register_instance(instance)
+    @values ||= []
+    @values << T.cast(instance, T.attached_class)
+  end
+
   # Entrypoint for allowing people to register new enum values.
   # All enum values must be defined within this block.
   sig {params(blk: T.proc.void).void}
@@ -308,13 +318,14 @@ class T::Enum
 
     @started_initializing = true
 
+    @values = T.let(nil, T.nilable(T::Array[T.attached_class]))
+
     yield
 
-    @values = T.let(nil, T.nilable(T::Array[T.attached_class]))
     @mapping = T.let(nil, T.nilable(T::Hash[SerializedVal, T.attached_class]))
+    @mapping = {}
 
     # Freeze the Enum class and bind the constant names into each of the instances.
-    @mapping = {}
     self.constants(false).each do |const_name|
       instance = self.const_get(const_name, false)
       if !instance.is_a?(self)
@@ -329,8 +340,14 @@ class T::Enum
       end
       @mapping[serialized] = instance
     end
-    @values = @mapping.values.sort.freeze
+    @values.freeze
     @mapping.freeze
+
+    orphaned_instances = T.must(@values) - @mapping.values
+    if !orphaned_instances.empty?
+      raise "Enum values must be assigned to constants: #{orphaned_instances.map {|v| v.instance_variable_get('@serialized_val')}}"
+    end
+
     @fully_initialized = true
   end
 

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,57 @@
+# 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 = ''
+      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

@@ -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/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)