sorbet-runtime 0.4.4301 → 0.5.5794

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4caba5123cd2598c381ec8aee684b3ec9d836e82
-  data.tar.gz: 6a9bbf51e25f0228c8cec2f98565af5721227953
+SHA256:
+  metadata.gz: ac9a48252c9529d0ca91f96108b141c85388c88180281e5c8a682b16c11a9d5a
+  data.tar.gz: 31dc95eabc00327b1672a8fc142da7dc47f0ee0699fd4112358042248628675b
 SHA512:
-  metadata.gz: c57c3dca97c35bdb4b7bde004ad20e5a78d0e737f7f2a2a78e047d20feb9513fa5ed216ee083a61222c98616f4764e47b5eb16be096fb040630a666adb8d24a9
-  data.tar.gz: e88711e3451d9b31013284f577390aa41a85e1f0ad57d639471a1cb2e83da4e7256ebe4c4a6bd4ca73698fc846058791c57364d39f19011438f065cda53b5c7f
+  metadata.gz: 21b1ef4ffdd76365effafe0c6a3eea4b15c1f9c36f2f402a1c8ba382d2f03d89f2202c1b8ac2aa82c315c7471f0989f7501d1888a49f67d401d33d26ac8e4d3a
+  data.tar.gz: 0f4c110725910ae452ea72fe6852538aa1c31cbb576dc242fe3631bd318e3b2bfda7b0fe3b05362584bd53885c9788a4f3eb2d5920d285c1c39ce727fb0ebd14

data/lib/sorbet-runtime.rb

@@ -24,11 +24,12 @@ require_relative 'types/_types'
 require_relative 'types/private/decl_state'
 require_relative 'types/runtime_profiled'
 require_relative 'types/private/class_utils'
-require_relative 'types/private/error_handler'
 require_relative 'types/private/runtime_levels'
 require_relative 'types/private/methods/_methods'
 require_relative 'types/sig'
 require_relative 'types/helpers'
+require_relative 'types/private/final'
+require_relative 'types/private/sealed'
 
 # The types themselves. First base classes
 require_relative 'types/types/base'
@@ -41,8 +42,10 @@ require_relative 'types/types/fixed_hash'
 require_relative 'types/types/intersection'
 require_relative 'types/types/noreturn'
 require_relative 'types/types/proc'
+require_relative 'types/types/attached_class'
 require_relative 'types/types/self_type'
 require_relative 'types/types/simple'
+require_relative 'types/types/t_enum'
 require_relative 'types/types/type_parameter'
 require_relative 'types/types/typed_array'
 require_relative 'types/types/typed_enumerator'
@@ -54,6 +57,7 @@ require_relative 'types/types/untyped'
 require_relative 'types/private/types/not_typed'
 require_relative 'types/private/types/void'
 require_relative 'types/private/types/string_holder'
+require_relative 'types/private/types/type_alias'
 
 require_relative 'types/types/type_variable'
 require_relative 'types/types/type_member'
@@ -76,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'
 
@@ -88,13 +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/non_forcing_constants'
 
 require_relative 'types/compatibility_patches'

data/lib/types/_types.rb

@@ -65,6 +65,11 @@ module T
     T::Types::SelfType.new
   end
 
+  # Matches the instance type in a singleton-class context
+  def self.attached_class
+    T::Types::AttachedClassType.new
+  end
+
   # Matches any class that subclasses or includes the provided class
   # or module
   def self.class_of(klass)
@@ -75,11 +80,11 @@ module T
   ## END OF THE METHODS TO PASS TO `sig`.
 
 
-  # Constructs a type alias. Used to create a short name for a larger
-  # type. In Ruby this is just equivalent to assignment, but this is
-  # needed for support by the static checker. Example usage:
+  # Constructs a type alias. Used to create a short name for a larger type. In Ruby this returns a
+  # wrapper that contains a proc that is evaluated to get the underlying type. This syntax however
+  # is needed for support by the static checker. Example usage:
   #
-  #  NilableString = T.type_alias(T.nilable(String))
+  #  NilableString = T.type_alias {T.nilable(String)}
   #
   #  sig {params(arg: NilableString, default: String).returns(String)}
   #  def or_else(arg, default)
@@ -88,11 +93,17 @@ module T
   #
   # The name of the type alias is not preserved; Error messages will
   # be printed with reference to the underlying type.
-  def self.type_alias(type)
-    T::Utils.coerce(type)
+  #
+  # TODO Remove `type` parameter. This was left in to make life easier while migrating.
+  def self.type_alias(type=nil, &blk)
+    if blk
+      T::Private::Types::TypeAlias.new(blk)
+    else
+      T::Utils.coerce(type)
+    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:
@@ -176,21 +187,15 @@ module T
   # Intended to be used to promise sorbet that a given nilable value happens
   # to contain a non-nil value at this point.
   #
-  # sig {params(arg: T.nilable(A), msg: T.nilable(String)).returns(A)}
-  def self.must(arg, msg=nil)
+  # sig {params(arg: T.nilable(A)).returns(A)}
+  def self.must(arg)
+    return arg if arg
+    return arg if arg == false
+
     begin
-      if msg
-        if !T.unsafe(msg).is_a?(String)
-          raise TypeError.new("T.must expects a string as second argument")
-        end
-      else
-        msg = "Passed `nil` into T.must"
-      end
-      raise TypeError.new(msg) if arg.nil?
-      arg
+      raise TypeError.new("Passed `nil` into T.must")
     rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
-      T::Private::ErrorHandler.handle_inline_type_error(e)
-      arg
+      T::Configuration.inline_type_error_handler(e)
     end
   end
 
@@ -201,29 +206,63 @@ module T
     value
   end
 
+  # A way to ask Sorbet to prove that a certain branch of control flow never
+  # happens. Commonly used to assert that a case or if statement exhausts all
+  # possible cases.
+  def self.absurd(value)
+    msg = "Control flow reached T.absurd."
+
+    case value
+    when Kernel
+      msg += " Got value: #{value}"
+    end
+
+    begin
+      raise TypeError.new(msg)
+    rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
+      T::Configuration.inline_type_error_handler(e)
+    end
+  end
+
   ### Generic classes ###
 
   module Array
     def self.[](type)
-      T::Types::TypedArray.new(type)
+      if type.is_a?(T::Types::Untyped)
+        T::Types::TypedArray::Untyped.new
+      else
+        T::Types::TypedArray.new(type)
+      end
     end
   end
 
   module Hash
     def self.[](keys, values)
-      T::Types::TypedHash.new(keys: keys, values: values)
+      if keys.is_a?(T::Types::Untyped) && values.is_a?(T::Types::Untyped)
+        T::Types::TypedHash::Untyped.new
+      else
+        T::Types::TypedHash.new(keys: keys, values: values)
+      end
     end
   end
 
   module Enumerable
     def self.[](type)
-      T::Types::TypedEnumerable.new(type)
+      if type.is_a?(T::Types::Untyped)
+        T::Types::TypedEnumerable::Untyped.new
+      else
+        T::Types::TypedEnumerable.new(type)
+      end
     end
   end
 
   module Enumerator
     def self.[](type)
-      T::Types::TypedEnumerator.new(type)
+      if type.is_a?(T::Types::Untyped)
+        T::Types::TypedEnumerator::Untyped.new
+      else
+        T::Types::TypedEnumerator.new(type)
+      end
     end
   end
 
@@ -235,11 +274,12 @@ module T
 
   module Set
     def self.[](type)
-      T::Types::TypedSet.new(type)
+      if type.is_a?(T::Types::Untyped)
+        T::Types::TypedSet::Untyped.new
+      else
+        T::Types::TypedSet.new(type)
+      end
     end
   end
-
-  # When mixed into a module, indicates that Sorbet may export the CFG for methods in that module
-  module CFGExport; end
 end
 # rubocop:enable PrisonGuard/UseOpusTypesShortcut

data/lib/types/boolean.rb

@@ -1,8 +1,8 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module T
   # T::Boolean is a type alias helper for the common `T.any(TrueClass, FalseClass)`.
   # Defined separately from _types.rb because it has a dependency on T::Types::Union.
-  Boolean = T.type_alias(T.any(TrueClass, FalseClass))
+  Boolean = T.type_alias {T.any(TrueClass, FalseClass)}
 end

data/lib/types/compatibility_patches.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
 # typed: ignore
 
 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
@@ -21,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

@@ -2,6 +2,59 @@
 # frozen_string_literal: true
 
 module T::Configuration
+  # Announces to Sorbet that we are currently in a test environment, so it
+  # should treat any sigs which are marked `.checked(:tests)` as if they were
+  # just a normal sig.
+  #
+  # If this method is not called, sigs marked `.checked(:tests)` will not be
+  # checked. In fact, such methods won't even be wrapped--the runtime will put
+  # back the original method.
+  #
+  # Note: Due to the way sigs are evaluated and methods are wrapped, this
+  # method MUST be called before any code calls `sig`. This method raises if
+  # it has been called too late.
+  def self.enable_checking_for_sigs_marked_checked_tests
+    T::Private::RuntimeLevels.enable_checking_in_tests
+  end
+
+  # Announce to Sorbet that we would like the final checks to be enabled when
+  # including and extending modules. Iff this is not called, then the following
+  # example will not raise an error.
+  #
+  # ```ruby
+  # module M
+  #   extend T::Sig
+  #   sig(:final) {void}
+  #   def foo; end
+  # end
+  # class C
+  #   include M
+  #   def foo; end
+  # end
+  # ```
+  def self.enable_final_checks_on_hooks
+    T::Private::Methods.set_final_checks_on_hooks(true)
+  end
+
+  # Undo the effects of a previous call to
+  # `enable_final_checks_on_hooks`.
+  def self.reset_final_checks_on_hooks
+    T::Private::Methods.set_final_checks_on_hooks(false)
+  end
+
+  # Configure the default checked level for a sig with no explicit `.checked`
+  # builder. When unset, the default checked level is `:always`.
+  #
+  # Note: setting this option is potentially dangerous! Sorbet can't check all
+  # code statically. The runtime checks complement the checks that Sorbet does
+  # statically, so that methods don't have to guard themselves from being
+  # called incorrectly by untyped code.
+  #
+  # @param [:never, :tests, :always] default_checked_level
+  def self.default_checked_level=(default_checked_level)
+    T::Private::RuntimeLevels.default_checked_level = default_checked_level
+  end
+
   # Set a handler to handle `TypeError`s raised by any in-line type assertions,
   # including `T.must`, `T.let`, `T.cast`, and `T.assert_type!`.
   #
@@ -36,6 +89,7 @@ module T::Configuration
     else
       inline_type_error_handler_default(error)
     end
+    nil
   end
 
   # Set a handler to handle errors that occur when the builder methods in the
@@ -66,7 +120,7 @@ module T::Configuration
   end
 
   private_class_method def self.sig_builder_error_handler_default(error, location)
-    T::Private::Methods.sig_error(location, error.message)
+    raise ArgumentError.new("#{location.path}:#{location.lineno}: Error interpreting `sig`:\n  #{error.message}\n\n")
   end
 
   def self.sig_builder_error_handler(error, location)
@@ -75,6 +129,7 @@ module T::Configuration
     else
       sig_builder_error_handler_default(error, location)
     end
+    nil
   end
 
   # Set a handler to handle sig validation errors.
@@ -84,11 +139,10 @@ module T::Configuration
   # successfully built, but the built sig is incompatible with other sigs in
   # some way.
   #
-  # By default, sig validation errors cause an exception to be raised. One
-  # exception is for `generated` sigs, for which a message will be logged
-  # instead of raising. Setting sig_validation_error_handler to an object that
-  # implements :call (e.g. proc or lambda) allows users to customize the
-  # behavior when a method signature's build fails.
+  # By default, sig validation errors cause an exception to be raised.
+  # Setting sig_validation_error_handler to an object that implements :call
+  # (e.g. proc or lambda) allows users to customize the behavior when a method
+  # signature's build fails.
   #
   # @param [Lambda, Proc, Object, nil] value Proc that handles the error (pass
   #   nil to reset to default behavior)
@@ -116,42 +170,24 @@ module T::Configuration
   end
 
   private_class_method def self.sig_validation_error_handler_default(error, opts)
-    # if this method overrides a generated signature, report that one instead
-    bad_method = opts[:method]
-    if !opts[:declaration].generated
-      super_signature = opts[:super_signature]
-      raise error if !super_signature&.generated
-      bad_method = super_signature.method
-    end
-
-    method_file, method_line = bad_method.source_location
-    T::Configuration.log_info_handler(
-      "SIG-DECLARE-FAILED",
-      {
-        definition_file: method_file,
-        definition_line: method_line,
-        kind: "Delete",
-        message: error.message,
-      },
-    )
+    raise error
   end
 
-  def self.sig_validation_error_handler(error, opts)
+  def self.sig_validation_error_handler(error, opts={})
     if @sig_validation_error_handler
       @sig_validation_error_handler.call(error, opts)
     else
       sig_validation_error_handler_default(error, opts)
     end
+    nil
   end
 
   # Set a handler for type errors that result from calling a method.
   #
   # By default, errors from calling a method cause an exception to be raised.
-  # One exception is for `generated` sigs, for which a message will be logged
-  # instead of raising. Setting call_validation_error_handler to an object that
-  # implements :call (e.g. proc or lambda) allows users to customize the
-  # behavior when a method is called with invalid parameters, or returns an
-  # invalid value.
+  # Setting call_validation_error_handler to an object that implements :call
+  # (e.g. proc or lambda) allows users to customize the behavior when a method
+  # is called with invalid parameters, or returns an invalid value.
   #
   # @param [Lambda, Proc, Object, nil] value Proc that handles the error
   #   report (pass nil to reset to default behavior)
@@ -180,49 +216,16 @@ module T::Configuration
   end
 
   private_class_method def self.call_validation_error_handler_default(signature, opts)
-    method_file, method_line = signature.method.source_location
-    location = opts[:location]
-    suffix = "Caller: #{location.path}:#{location.lineno}\n" \
-      "Definition: #{method_file}:#{method_line}"
-
-    error_message = "#{opts[:kind]}#{opts[:name] ? " '#{opts[:name]}'" : ''}: #{opts[:message]}\n#{suffix}"
-
-    if signature.generated
-      got = opts[:value].class
-      got = T.unsafe(T::Enumerable[T.untyped]).describe_obj(opts[:value]) if got < Enumerable
-      T::Configuration.log_info_handler(
-        "SIG-CHECK-FAILED",
-        {
-          caller_file: location.path,
-          caller_line: location.lineno,
-          definition_file: method_file,
-          definition_line: method_line,
-          kind: opts[:kind],
-          name: opts[:name],
-          expected: opts[:type].name,
-          got: got,
-        },
-      )
-    elsif signature.soft_notify
-      T::Configuration.soft_assert_handler(
-        "TypeError: #{error_message}",
-        {notify: signature.soft_notify}
-      )
-    else
-      begin
-        raise TypeError.new(error_message)
-      rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
-        T::Private::ErrorHandler.handle_inline_type_error(e)
-      end
-    end
+    raise TypeError.new(opts[:pretty_message])
   end
 
-  def self.call_validation_error_handler(signature, opts)
+  def self.call_validation_error_handler(signature, opts={})
     if @call_validation_error_handler
       @call_validation_error_handler.call(signature, opts)
     else
       call_validation_error_handler_default(signature, opts)
     end
+    nil
   end
 
   # Set a handler for logging
@@ -316,7 +319,7 @@ module T::Configuration
     raise str
   end
 
-  def self.hard_assert_handler(str, extra)
+  def self.hard_assert_handler(str, extra={})
     if @hard_assert_handler
       @hard_assert_handler.call(str, extra)
     else
@@ -333,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?
@@ -353,12 +356,69 @@ module T::Configuration
     String
     Symbol
     Time
+    T::Enum
   }).freeze
 
   def self.scalar_types
     @scalar_types || @default_scalar_types
   end
 
+  # Temporarily disable ruby warnings while executing the given block. This is
+  # useful when doing something that would normally cause a warning to be
+  # emitted in Ruby verbose mode ($VERBOSE = true).
+  #
+  # @yield
+  #
+  def self.without_ruby_warnings
+    if $VERBOSE
+      begin
+        original_verbose = $VERBOSE
+        $VERBOSE = false
+        yield
+      ensure
+        $VERBOSE = original_verbose
+      end
+    else
+      yield
+    end
+  end
+
+  def self.enable_legacy_t_enum_migration_mode
+    @legacy_t_enum_migration_mode = true
+  end
+  def self.disable_legacy_t_enum_migration_mode
+    @legacy_t_enum_migration_mode = false
+  end
+  def self.legacy_t_enum_migration_mode?
+    @legacy_t_enum_migration_mode || false
+  end
+
+  # @param [Array] sealed_violation_whitelist An array of Regexp to validate
+  #   whether inheriting /including a sealed module outside the defining module
+  #   should be allowed. Useful to whitelist benign violations, like shim files
+  #   generated for an autoloader.
+  def self.sealed_violation_whitelist=(sealed_violation_whitelist)
+    if @sealed_violation_whitelist != nil
+      raise ArgumentError.new("Cannot overwrite sealed_violation_whitelist after setting it")
+    end
+
+    case sealed_violation_whitelist
+    when Array
+      sealed_violation_whitelist.each do |x|
+        case x
+        when Regexp then nil
+        else raise TypeError.new("sealed_violation_whitelist accepts an Array of Regexp")
+        end
+      end
+    else
+      raise TypeError.new("sealed_violation_whitelist= accepts an Array of Regexp")
+    end
+
+    @sealed_violation_whitelist = sealed_violation_whitelist
+  end
+  def self.sealed_violation_whitelist
+    @sealed_violation_whitelist
+  end
 
   private_class_method def self.validate_lambda_given!(value)
     if !value.nil? && !value.respond_to?(:call)