sorbet-runtime 0.4.4286 → 0.4.4331

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 58fd1f33f4010ee7ed667a320704eee0b40e9d52
-  data.tar.gz: 957e37e28a0da87dfcff6396623188d571ad1efb
+  metadata.gz: 23fe6d1adf71c97852b2e1bd12133d79212b7855
+  data.tar.gz: f4ba79a25eb179f3aeba3a0c758876c363a3dc3c
 SHA512:
-  metadata.gz: 65b2b394682e14565f1fd12530c128bed0275bf520219e865cedc19c24e03e97dc83931a30649faf3cd1ad4935ca64596e58da8c51b74f9da21287c5b2e1e382
-  data.tar.gz: 618b4fc7577d7b4fef9b0f97843cc1e8dc47a3408e3904e27280b23219491dba9db8b94bd28e38494d653d93e3bf72223e10e443d4d5530e3ba6553964b5615d
+  metadata.gz: cec9cff7dcb4ef500914a038bf009180436bdecb607d6eedbf2c6692a6267360f8b0c48e90b5cd70c0b667761d6ad2db4e8e583bdd40bdb16043bc1122d45e23
+  data.tar.gz: b9dda89def4e0ea5e5dd33e4393b93999a8226f788a9080a5ffbd689df880990ec290e01c843fcf7eee336c6ec466984811cb0d32abc21cad03fe2a635bd6880

data/lib/types/boolean.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module T

data/lib/types/compatibility_patches.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # typed: ignore
 
 require_relative 'private/methods/_methods'

data/lib/types/configuration.rb

@@ -2,6 +2,21 @@
 # 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
+
   # 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!`.
   #
@@ -84,11 +99,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,24 +130,7 @@ 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)
@@ -147,11 +144,9 @@ module T::Configuration
   # 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)
@@ -182,39 +177,12 @@ module T::Configuration
   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}"
+    error_message = "#{opts[:kind]}#{opts[:name] ? " '#{opts[:name]}'" : ''}: #{opts[:message]}\n" \
+      "Caller: #{location.path}:#{location.lineno}\n" \
+      "Definition: #{method_file}:#{method_line}"
 
-    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(error_message)
   end
 
   def self.call_validation_error_handler(signature, opts)

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

@@ -18,10 +18,6 @@ module T::Private::Abstract::Declare
     mod.extend(T::InterfaceWrapper::Helpers)
 
     if mod.is_a?(Class)
-      if mod < T::Struct
-        raise "#{mod.name} is a subclass of T::Struct and cannot be declared abstract"
-      end
-
       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.

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

@@ -306,15 +306,13 @@ module T::Private::Methods
 
     if mod.singleton_class?
       install_singleton_method_added_hook(mod)
-      install_singleton_method_added_hook(mod.singleton_class)
     else
       original_method = T::Private::ClassUtils.replace_method(mod.singleton_class, :method_added) do |name|
         T::Private::Methods._on_method_added(self, name)
         original_method.bind(self).call(name)
       end
-
-      install_singleton_method_added_hook(mod.singleton_class)
     end
+    install_singleton_method_added_hook(mod.singleton_class)
   end
 
   private_class_method def self.install_singleton_method_added_hook(singleton_klass)

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

@@ -11,7 +11,7 @@ module T::Private::Methods::SignatureValidation
       # but in practice, you never call them polymorphically. Conceptually, they're standard
       # methods (this is consistent with how they're treated in other languages, e.g. Java)
       if signature.mode != Modes.standard
-        raise "Constructor methods should always be declared using `sig`."
+        raise "`initialize` should not use `.abstract` or `.implementation` or any other inheritance modifiers."
       end
       return
     end

data/lib/types/props/_props.rb

@@ -87,7 +87,7 @@ module T::Props
     #   hash. This will not affect objects loaded by {.from_hash}.
     # @option rules [Proc] :factory A `Proc` that will be called to
     #   generate an initial value for this prop on {#initialize}, if
-    #   none is providede.
+    #   none is provided.
     # @option rules [T::Boolean] :immutable If true, this prop cannot be
     #   modified after an instance is created or loaded from a hash.
     # @option rules [Class,T::Props::CustomType] :array If set, specifies the

data/lib/types/props/constructor.rb

@@ -10,7 +10,7 @@ module T::Props::Constructor
     decorator.props.each do |prop, rules|
       # It's important to explicitly compare against `true` here; the value can also be :existing or
       # :on_load (which are truthy) but we don't want to treat those as optional in this context.
-      if T::Utils::Props.required_prop?(rules) && !decorator.has_default?(rules) && !hash.key?(prop)
+      if T::Props::Utils.required_prop?(rules) && !decorator.has_default?(rules) && !hash.key?(prop)
         raise ArgumentError.new("Missing required prop `#{prop}` for class `#{self.class}`")
       end
     end

data/lib/types/props/decorator.rb

@@ -149,7 +149,7 @@ class T::Props::Decorator
     # T::Props::CustomType is not a real object based class so that we can not run real type check call.
     # T::Props::CustomType.valid?() is only a helper function call.
     valid =
-      if type.is_a?(T::Props::CustomType) && T::Utils::Props.optional_prop?(rules)
+      if type.is_a?(T::Props::CustomType) && T::Props::Utils.optional_prop?(rules)
         type.valid?(val)
       else
         type_object.valid?(val)
@@ -371,8 +371,8 @@ class T::Props::Decorator
     if T::Utils::Nilable.is_union_with_nilclass(cls)
       # :_tnilable is introduced internally for performance purpose so that clients do not need to call
       # T::Utils::Nilable.is_tnilable(cls) again.
-      # It is strictly internal: clients should always use T::Utils::Props.required_prop?() or
-      # T::Utils::Props.optional_prop?() for checking whether a field is required or optional.
+      # It is strictly internal: clients should always use T::Props::Utils.required_prop?() or
+      # T::Props::Utils.optional_prop?() for checking whether a field is required or optional.
       rules[:_tnilable] = true
     end
 

data/lib/types/props/errors.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 
 module T::Props
   class Error < StandardError; end

data/lib/types/props/optional.rb

@@ -31,8 +31,20 @@ module T::Props::Optional::DecoratorMethods
 
   def prop_optional?(prop); prop_rules(prop)[:fully_optional]; end
 
-  def add_prop_definition(prop, rules)
+  def mutate_prop_backdoor!(prop, key, value)
+    rules = props.fetch(prop)
+    rules = rules.merge(key => value)
+    compute_derived_rules(rules)
+    @props = props.merge(prop => rules.freeze).freeze
+  end
+
+  def compute_derived_rules(rules)
     rules[:fully_optional] = !T::Props::Utils.need_nil_write_check?(rules)
+    rules[:need_nil_read_check] = T::Props::Utils.need_nil_read_check?(rules)
+  end
+
+  def add_prop_definition(prop, rules)
+    compute_derived_rules(rules)
     super
   end
 

data/lib/types/props/serializable.rb

@@ -19,13 +19,12 @@ module T::Props::Serializable
     decorator = self.class.decorator
     h = {}
 
-    decorator.props.keys.each do |prop|
-      rules = decorator.prop_rules(prop)
+    decorator.props.each do |prop, rules|
       hkey = rules[:serialized_form]
 
-      val = decorator.get(self, prop)
+      val = decorator.get(self, prop, rules)
 
-      if strict && val.nil? && T::Props::Utils.need_nil_write_check?(rules)
+      if val.nil? && strict && !rules[:fully_optional]
         # If the prop was already missing during deserialization, that means the application
         # code already had to deal with a nil value, which means we wouldn't be accomplishing
         # much by raising here (other than causing an unnecessary breakage).
@@ -42,40 +41,42 @@ module T::Props::Serializable
       # Don't serialize values that are nil to save space (both the
       # nil value itself and the field name in the serialized BSON
       # document)
-      next if decorator.prop_dont_store?(prop) || val.nil?
-
-      if rules[:type_is_serializable]
-        val = val.serialize(strict)
-      elsif rules[:type_is_array_of_serializable]
-        if (subtype = rules[:serializable_subtype]).is_a?(T::Props::CustomType)
-          val = val.map {|el| el && subtype.serialize(el)}
-        else
-          val = val.map {|el| el && el.serialize(strict)}
-        end
-      elsif rules[:type_is_hash_of_serializable_values] && rules[:type_is_hash_of_custom_type_keys]
-        key_subtype = rules[:serializable_subtype][:keys]
-        value_subtype = rules[:serializable_subtype][:values]
-        if value_subtype.is_a?(T::Props::CustomType)
-          val = val.each_with_object({}) do |(key, value), result|
-            result[key_subtype.serialize(key)] = value && value_subtype.serialize(value)
+      next if rules[:dont_store] || val.nil?
+
+      if rules[:serializable_subtype]
+        if rules[:type_is_serializable]
+          val = val.serialize(strict)
+        elsif rules[:type_is_array_of_serializable]
+          if (subtype = rules[:serializable_subtype]).is_a?(T::Props::CustomType)
+            val = val.map {|el| el && subtype.serialize(el)}
+          else
+            val = val.map {|el| el && el.serialize(strict)}
           end
-        else
+        elsif rules[:type_is_hash_of_serializable_values] && rules[:type_is_hash_of_custom_type_keys]
+          key_subtype = rules[:serializable_subtype][:keys]
+          value_subtype = rules[:serializable_subtype][:values]
+          if value_subtype.is_a?(T::Props::CustomType)
+            val = val.each_with_object({}) do |(key, value), result|
+              result[key_subtype.serialize(key)] = value && value_subtype.serialize(value)
+            end
+          else
+            val = val.each_with_object({}) do |(key, value), result|
+              result[key_subtype.serialize(key)] = value && value.serialize(strict)
+            end
+          end
+        elsif rules[:type_is_hash_of_serializable_values]
+          value_subtype = rules[:serializable_subtype]
+          if value_subtype.is_a?(T::Props::CustomType)
+            val = val.transform_values {|v| v && value_subtype.serialize(v)}
+          else
+            val = val.transform_values {|v| v && v.serialize(strict)}
+          end
+        elsif rules[:type_is_hash_of_custom_type_keys]
+          key_subtype = rules[:serializable_subtype]
           val = val.each_with_object({}) do |(key, value), result|
-            result[key_subtype.serialize(key)] = value && value.serialize(strict)
+            result[key_subtype.serialize(key)] = value
           end
         end
-      elsif rules[:type_is_hash_of_serializable_values]
-        value_subtype = rules[:serializable_subtype]
-        if value_subtype.is_a?(T::Props::CustomType)
-          val = val.transform_values {|v| v && value_subtype.serialize(v)}
-        else
-          val = val.transform_values {|v| v && v.serialize(strict)}
-        end
-      elsif rules[:type_is_hash_of_custom_type_keys]
-        key_subtype = rules[:serializable_subtype]
-        val = val.each_with_object({}) do |(key, value), result|
-          result[key_subtype.serialize(key)] = value
-        end
       elsif rules[:type_is_custom_type]
         val = rules[:type].serialize(val)
 
@@ -88,11 +89,19 @@ module T::Props::Serializable
         end
       end
 
-      h[hkey] = T::Props::Utils.deep_clone_object(val)
+      needs_clone = rules[:type_needs_clone]
+      if needs_clone
+        if needs_clone == :shallow
+          val = val.dup
+        else
+          val = T::Props::Utils.deep_clone_object(val)
+        end
+      end
+
+      h[hkey] = val
     end
 
-    extra_props = decorator.extra_props(self)
-    h.merge!(extra_props) if extra_props
+    h.merge!(@_extra_props) if @_extra_props
 
     h
   end
@@ -116,7 +125,7 @@ module T::Props::Serializable
       hkey = rules[:serialized_form]
       val = hash[hkey]
       if val.nil?
-        if T::Utils::Props.required_prop?(rules)
+        if T::Props::Utils.required_prop?(rules)
           val = decorator.get_default(rules, self.class)
           if val.nil?
             msg = "Tried to deserialize a required prop from a nil value. It's "\
@@ -140,7 +149,7 @@ module T::Props::Serializable
               T::Configuration.hard_assert_handler(msg, storytime: storytime)
             end
           end
-        elsif T::Props::Utils.need_nil_read_check?(rules)
+        elsif rules[:need_nil_read_check]
           self.required_prop_missing_from_deserialize(p)
         end
 
@@ -274,7 +283,7 @@ module T::Props::Serializable::DecoratorMethods
   end
 
   def required_props
-    @class.props.select {|_, v| T::Utils::Props.required_prop?(v)}.keys
+    @class.props.select {|_, v| T::Props::Utils.required_prop?(v)}.keys
   end
 
   def prop_dont_store?(prop); prop_rules(prop)[:dont_store]; end

data/lib/types/props/utils.rb

@@ -44,6 +44,20 @@ module T::Props::Utils
 
   # The prop_rules indicate whether we should check for writing a nil value for the prop/field.
   def self.need_nil_write_check?(prop_rules)
-    need_nil_read_check?(prop_rules) || T::Utils::Props.required_prop?(prop_rules)
+    need_nil_read_check?(prop_rules) || T::Props::Utils.required_prop?(prop_rules)
+  end
+
+  def self.required_prop?(prop_rules)
+    # Clients should never reference :_tnilable as the implementation can change.
+    !prop_rules[:_tnilable]
+  end
+
+  def self.optional_prop?(prop_rules)
+    # Clients should never reference :_tnilable as the implementation can change.
+    !!prop_rules[:_tnilable]
+  end
+
+  def self.merge_serialized_optional_rule(prop_rules)
+    {'_tnilable' => true}.merge(prop_rules.merge('_tnilable' => true))
   end
 end

data/lib/types/runtime_profiled.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 #

data/lib/types/sig.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
-# typed: true
-# rubocop:disable PrisonGuard/NoTopLevelDeclarations, PrisonGuard/PackageMatchesDirectory
+# typed: strict
 
 # Used as a mixin to any class so that you can call `sig`.
 # Docs at https://sorbet.org/docs/sigs
@@ -12,7 +11,7 @@ module T::Sig
 
     # At runtime, does nothing, but statically it is treated exactly the same
     # as T::Sig#sig. Only use it in cases where you can't use T::Sig#sig.
-    T::Sig::WithoutRuntime.sig {params(blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void} # rubocop:disable PrisonGuard/PrivateModule
+    T::Sig::WithoutRuntime.sig {params(blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
     def self.sig(&blk); end # rubocop:disable PrisonGuard/BanBuiltinMethodOverride, Lint/DuplicateMethods
   end
 
@@ -24,5 +23,3 @@ module T::Sig
     T::Private::Methods.declare_sig(self, &blk)
   end
 end
-
-# rubocop:enable PrisonGuard/NoTopLevelDeclarations, PrisonGuard/PackageMatchesDirectory

data/lib/types/types/type_member.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 
 module T::Types
   class TypeMember < TypeVariable

data/lib/types/types/type_template.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 
 module T::Types
   class TypeTemplate < TypeVariable

data/lib/types/utils.rb

@@ -110,10 +110,6 @@ module T::Utils
     end
   end
 
-  def self.DANGER_enable_checking_in_tests
-    T::Private::RuntimeLevels.enable_checking_in_tests
-  end
-
   # Returns the arity of a method, unwrapping the sig if needed
   def self.arity(method)
     arity = method.arity # rubocop:disable PrisonGuard/NoArity
@@ -158,22 +154,6 @@ module T::Utils
     "#{start_part}#{ellipsis}#{end_part}"
   end
 
-  module Props
-    def self.required_prop?(prop_rules)
-      # Clients should never reference :_tnilable as the implementation can change.
-      !prop_rules[:_tnilable]
-    end
-
-    def self.optional_prop?(prop_rules)
-      # Clients should never reference :_tnilable as the implementation can change.
-      !!prop_rules[:_tnilable]
-    end
-
-    def self.merge_serialized_optional_rule(prop_rules)
-      {'_tnilable' => true}.merge(prop_rules.merge('_tnilable' => true))
-    end
-  end
-
   module Nilable
     # :is_union_type, T::Boolean: whether the type is an T::Types::Union type
     # :non_nilable_type, Class: if it is an T.nilable type, the corresponding underlying type; otherwise, nil.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.4.4286
+  version: 0.4.4331
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-21 00:00:00.000000000 Z
+date: 2019-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest