sorbet-runtime 0.4.4331 → 0.4.4398

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 23fe6d1adf71c97852b2e1bd12133d79212b7855
-  data.tar.gz: f4ba79a25eb179f3aeba3a0c758876c363a3dc3c
+  metadata.gz: af4d1867e5caafedef289561e2ad9413bffa3fad
+  data.tar.gz: 5652f7e1c9d2d54b253fcc6d2e5e5330c9c34691
 SHA512:
-  metadata.gz: cec9cff7dcb4ef500914a038bf009180436bdecb607d6eedbf2c6692a6267360f8b0c48e90b5cd70c0b667761d6ad2db4e8e583bdd40bdb16043bc1122d45e23
-  data.tar.gz: b9dda89def4e0ea5e5dd33e4393b93999a8226f788a9080a5ffbd689df880990ec290e01c843fcf7eee336c6ec466984811cb0d32abc21cad03fe2a635bd6880
+  metadata.gz: 430f858624d11168a7a5a7109115fc02d26bb919e4d14aa1bb94018abf88276d143a7550e23f320ce135be24d283dc70198d250a568339da9cb2a02ad94dfbbb
+  data.tar.gz: 1f1e4cdaba1209536d9cc5da0ef766f841c80a50963146f11dcda2374beaa62835dd79ce5d8c2d6093f354d176bbac42f34d03067b9adf23d391f50e553e329e

data/lib/types/_types.rb

@@ -176,21 +176,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
     end
   end
 

data/lib/types/configuration.rb

@@ -17,6 +17,19 @@ module T::Configuration
     T::Private::RuntimeLevels.enable_checking_in_tests
   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!`.
   #
@@ -175,14 +188,7 @@ 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]
-
-    error_message = "#{opts[:kind]}#{opts[:name] ? " '#{opts[:name]}'" : ''}: #{opts[:message]}\n" \
-      "Caller: #{location.path}:#{location.lineno}\n" \
-      "Definition: #{method_file}:#{method_line}"
-
-    raise TypeError.new(error_message)
+    raise TypeError.new(opts[:pretty_message])
   end
 
   def self.call_validation_error_handler(signature, opts)

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

@@ -43,8 +43,8 @@ module T::Private::Methods
     if decl.returns == ARG_NOT_PROVIDED
       raise "Procs must specify a return type"
     end
-    if decl.soft_notify != ARG_NOT_PROVIDED
-      raise "Procs cannot use .soft"
+    if decl.on_failure != ARG_NOT_PROVIDED
+      raise "Procs cannot use .on_failure"
     end
 
     if decl.params == ARG_NOT_PROVIDED
@@ -224,7 +224,7 @@ module T::Private::Methods
         bind: current_declaration.bind,
         mode: current_declaration.mode,
         check_level: current_declaration.checked,
-        soft_notify: current_declaration.soft_notify,
+        on_failure: current_declaration.on_failure,
         override_allow_incompatible: current_declaration.override_allow_incompatible,
         generated: current_declaration.generated,
       )

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

@@ -1150,10 +1150,16 @@ module T::Private::Methods::CallValidation
   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
+
+    pretty_message = "#{kind}#{name ? " '#{name}'" : ''}: #{error_message}\n" \
+      "Caller: #{caller_loc.path}:#{caller_loc.lineno}\n" \
+      "Definition: #{definition_file}:#{definition_line}"
 
     T::Private::ErrorHandler.handle_call_validation_error(
       method_sig,
       message: error_message,
+      pretty_message: pretty_message,
       kind: kind,
       name: name,
       type: type,

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

@@ -2,7 +2,7 @@
 # typed: true
 
 module T::Private::Methods
-  Declaration = Struct.new(:mod, :params, :returns, :bind, :mode, :checked, :finalized, :soft_notify, :override_allow_incompatible, :type_parameters, :generated)
+  Declaration = Struct.new(:mod, :params, :returns, :bind, :mode, :checked, :finalized, :on_failure, :override_allow_incompatible, :type_parameters, :generated)
 
   class DeclBuilder
     attr_reader :decl
@@ -25,7 +25,7 @@ module T::Private::Methods
         Modes.standard, # mode
         ARG_NOT_PROVIDED, # checked
         false, # finalized
-        ARG_NOT_PROVIDED, # soft_notify
+        ARG_NOT_PROVIDED, # on_failure
         nil, # override_allow_incompatible
         ARG_NOT_PROVIDED, # type_parameters
         ARG_NOT_PROVIDED, # generated
@@ -80,16 +80,13 @@ module T::Private::Methods
     end
 
     def checked(level)
-      if T.unsafe(true)
-        raise "The .checked API is unstable, so we don't want it used until we redesign it. To change Sorbet's runtime behavior, see https://sorbet.org/docs/tconfiguration"
-      end
       check_live!
 
       if !decl.checked.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't call .checked multiple times in a signature.")
       end
-      if !decl.soft_notify.equal?(ARG_NOT_PROVIDED)
-        raise BuilderError.new("You can't use .checked with .soft.")
+      if level == :never && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
+        raise BuilderError.new("You can't use .checked(:never) with .on_failure because .on_failure will have no effect.")
       end
       if !decl.generated.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't use .checked with .generated.")
@@ -103,37 +100,25 @@ module T::Private::Methods
       self
     end
 
-    def soft(notify:)
-      if T.unsafe(true)
-        raise "The .soft API is unstable, so we don't want it used until we redesign it. To change Sorbet's runtime behavior, see https://sorbet.org/docs/tconfiguration"
-      end
+    def on_failure(*args)
       check_live!
 
-      if !decl.soft_notify.equal?(ARG_NOT_PROVIDED)
-        raise BuilderError.new("You can't call .soft multiple times in a signature.")
+      if !decl.on_failure.equal?(ARG_NOT_PROVIDED)
+        raise BuilderError.new("You can't call .on_failure multiple times in a signature.")
       end
-      if !decl.checked.equal?(ARG_NOT_PROVIDED)
-        raise BuilderError.new("You can't use .soft with .checked.")
+      if decl.checked == :never
+        raise BuilderError.new("You can't use .on_failure with .checked(:never) because .on_failure will have no effect.")
       end
       if !decl.generated.equal?(ARG_NOT_PROVIDED)
-        raise BuilderError.new("You can't use .soft with .generated.")
+        raise BuilderError.new("You can't use .on_failure with .generated.")
       end
 
-      # TODO consider validating that :notify is a project that sentry knows about,
-      # as per https://git.corp.stripe.com/stripe-internal/pay-server/blob/master/lib/event/job/sentry_job.rb#L125
-      if !notify || notify == ''
-        raise BuilderError.new("You can't provide an empty notify to .soft().")
-      end
-
-      decl.soft_notify = notify
+      decl.on_failure = args
 
       self
     end
 
     def generated
-      if T.unsafe(true)
-        raise "The .generated API is unstable, so we don't want it used until we redesign it. To change Sorbet's runtime behavior, see https://sorbet.org/docs/tconfiguration"
-      end
       check_live!
 
       if !decl.generated.equal?(ARG_NOT_PROVIDED)
@@ -142,8 +127,8 @@ module T::Private::Methods
       if !decl.checked.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't use .generated with .checked.")
       end
-      if !decl.soft_notify.equal?(ARG_NOT_PROVIDED)
-        raise BuilderError.new("You can't use .generated with .soft.")
+      if !decl.on_failure.equal?(ARG_NOT_PROVIDED)
+        raise BuilderError.new("You can't use .generated with .on_failure.")
       end
 
       decl.generated = true
@@ -252,10 +237,14 @@ module T::Private::Methods
         decl.bind = nil
       end
       if decl.checked.equal?(ARG_NOT_PROVIDED)
-        decl.checked = :always
-      end
-      if decl.soft_notify.equal?(ARG_NOT_PROVIDED)
-        decl.soft_notify = nil
+        default_checked_level = T::Private::RuntimeLevels.default_checked_level
+        if default_checked_level == :never && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
+          raise BuilderError.new("To use .on_failure you must additionally call .checked(:tests) or .checked(:always), otherwise, the .on_failure has no effect.")
+        end
+        decl.checked = default_checked_level
+      end
+      if decl.on_failure.equal?(ARG_NOT_PROVIDED)
+        decl.on_failure = nil
       end
       if decl.generated.equal?(ARG_NOT_PROVIDED)
         decl.generated = false

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

@@ -5,7 +5,7 @@ class T::Private::Methods::Signature
   attr_reader :method, :method_name, :arg_types, :kwarg_types, :block_type, :block_name,
               :rest_type, :rest_name, :keyrest_type, :keyrest_name, :bind,
               :return_type, :mode, :req_arg_count, :req_kwarg_names, :has_rest, :has_keyrest,
-              :check_level, :generated, :parameters, :soft_notify, :override_allow_incompatible, :ever_failed
+              :check_level, :generated, :parameters, :on_failure, :override_allow_incompatible, :ever_failed
 
   def self.new_untyped(method:, mode: T::Private::Methods::Modes.untyped, parameters: method.parameters)
     # Using `Untyped` ensures we'll get an error if we ever try validation on these.
@@ -24,7 +24,7 @@ class T::Private::Methods::Signature
       mode: mode,
       check_level: :never,
       parameters: parameters,
-      soft_notify: nil,
+      on_failure: nil,
     )
   end
 
@@ -32,7 +32,7 @@ class T::Private::Methods::Signature
     @ever_failed = true
   end
 
-  def initialize(method:, method_name:, raw_arg_types:, raw_return_type:, bind:, mode:, check_level:, parameters: method.parameters, soft_notify:, generated: false, override_allow_incompatible: false)
+  def initialize(method:, method_name:, raw_arg_types:, raw_return_type:, bind:, mode:, check_level:, parameters: method.parameters, on_failure:, generated: false, override_allow_incompatible: false)
     @method = method
     @method_name = method_name
     @arg_types = []
@@ -52,7 +52,7 @@ class T::Private::Methods::Signature
     @has_rest = false
     @has_keyrest = false
     @parameters = parameters
-    @soft_notify = soft_notify
+    @on_failure = on_failure
     @override_allow_incompatible = override_allow_incompatible
     @generated = generated
     @ever_failed = false

data/lib/types/private/runtime_levels.rb

@@ -17,6 +17,9 @@ module T::Private::RuntimeLevels
   @check_tests = false
   @wrapped_tests_with_validation = false
 
+  @has_read_default_checked_level = false
+  @default_checked_level = :always
+
   def self.check_tests?
     # Assume that this code path means that some `sig.checked(:tests)`
     # has been wrapped (or not wrapped) already, which is a trapdoor
@@ -35,6 +38,18 @@ module T::Private::RuntimeLevels
     _toggle_checking_tests(true)
   end
 
+  def self.default_checked_level
+    @has_read_default_checked_level = true
+    @default_checked_level
+  end
+
+  def self.default_checked_level=(default_checked_level)
+    if @has_read_default_checked_level
+      raise "Set the default checked level earlier. There are already some methods whose sig blocks have evaluated which would not be affected by the new default."
+    end
+    @default_checked_level = default_checked_level
+  end
+
   def self._toggle_checking_tests(checked)
     @check_tests = checked
   end

data/lib/types/props/decorator.rb

@@ -18,7 +18,7 @@ class T::Props::Decorator
 
   class NoRulesError < StandardError; end
 
-  sig {params(klass: DecoratedClass).void}
+  T::Sig::WithoutRuntime.sig {params(klass: DecoratedClass).void}
   def initialize(klass)
     @class = klass
     klass.plugins.each do |mod|
@@ -27,7 +27,7 @@ class T::Props::Decorator
   end
 
   # prop stuff
-  sig {returns(T::Hash[Symbol, Rules])}
+  sig {returns(T::Hash[Symbol, Rules]).checked(:never)}
   def props
     @props ||= {}.freeze
   end
@@ -44,7 +44,7 @@ class T::Props::Decorator
   sig {returns(T::Array[Symbol])}
   def all_props; props.keys; end
 
-  sig {params(prop: T.any(Symbol, String)).returns(Rules)}
+  sig {params(prop: T.any(Symbol, String)).returns(Rules).checked(:never)}
   def prop_rules(prop); props[prop.to_sym] || raise("No such prop: #{prop.inspect}"); end
 
   sig {params(prop: Symbol, rules: Rules).void}
@@ -80,7 +80,7 @@ class T::Props::Decorator
     }
   end
 
-  sig {returns(DecoratedClass)}
+  sig {returns(DecoratedClass).checked(:never)}
   def decorated_class; @class; end
 
   # Accessors
@@ -94,6 +94,7 @@ class T::Props::Decorator
       rules: T.nilable(Rules)
     )
     .returns(T.untyped)
+    .checked(:never)
   end
   def get(instance, prop, rules=props[prop.to_sym])
     # For backwards compatibility, fall back to reconstructing the accessor key
@@ -111,6 +112,7 @@ class T::Props::Decorator
       rules: T.nilable(Rules)
     )
     .void
+    .checked(:never)
   end
   def set(instance, prop, value, rules=props[prop.to_sym])
     # For backwards compatibility, fall back to reconstructing the accessor key
@@ -119,7 +121,7 @@ class T::Props::Decorator
   end
 
   # Use this to validate that a value will validate for a given prop. Useful for knowing whether a value can be set on a model without setting it.
-  sig {params(prop: Symbol, val: T.untyped).void}
+  sig {params(prop: Symbol, val: T.untyped).void.checked(:never)}
   def validate_prop_value(prop, val)
     # This implements a 'public api' on document so that we don't allow callers to pass in rules
     # Rules seem like an implementation detail so it seems good to now allow people to specify them manually.
@@ -127,7 +129,7 @@ class T::Props::Decorator
   end
 
   # Passing in rules here is purely a performance optimization.
-  sig {params(prop: Symbol, val: T.untyped, rules: Rules).void}
+  sig {params(prop: Symbol, val: T.untyped, rules: Rules).void.checked(:never)}
   private def check_prop_type(prop, val, rules=prop_rules(prop))
     type_object = rules.fetch(:type_object)
     type = rules.fetch(:type)
@@ -173,6 +175,7 @@ class T::Props::Decorator
       rules: T.nilable(Rules)
     )
     .void
+    .checked(:never)
   end
   def prop_set(instance, prop, val, rules=prop_rules(prop))
     check_prop_type(prop, val, T.must(rules))
@@ -188,6 +191,7 @@ class T::Props::Decorator
       rules: T.nilable(Rules)
     )
     .returns(T.untyped)
+    .checked(:never)
   end
   def prop_get(instance, prop, rules=props[prop.to_sym])
     val = get(instance, prop, rules)
@@ -222,6 +226,7 @@ class T::Props::Decorator
       opts: Hash
     )
     .returns(T.untyped)
+    .checked(:never)
   end
   def foreign_prop_get(instance, prop, foreign_class, rules=props[prop.to_sym], opts={})
     return if !(value = prop_get(instance, prop, rules))
@@ -325,7 +330,6 @@ class T::Props::Decorator
     .void
   end
   def prop_defined(name, cls, rules={})
-    # TODO(jerry): Create similar soft assertions against false
     if rules[:optional] == true
       T::Configuration.hard_assert_handler(
         'Use of `optional: true` is deprecated, please use `T.nilable(...)` instead.',
@@ -776,7 +780,7 @@ class T::Props::Decorator
   #
   # This gets called when a module or class that extends T::Props gets included, extended,
   # prepended, or inherited.
-  sig {params(child: DecoratedClass).void}
+  T::Sig::WithoutRuntime.sig {params(child: DecoratedClass).void}
   def model_inherited(child)
     child.extend(T::Props::ClassMethods)
     child.plugins.concat(decorated_class.plugins)
@@ -797,7 +801,7 @@ class T::Props::Decorator
     end
   end
 
-  sig {params(mod: Module).void}
+  T::Sig::WithoutRuntime.sig {params(mod: Module).void}
   def plugin(mod)
     decorated_class.plugins << mod
     Private.apply_class_methods(mod, decorated_class)

data/lib/types/props/pretty_printable.rb

@@ -70,6 +70,7 @@ module T::Props::PrettyPrintable
     sig do
       params(instance: T::Props::PrettyPrintable, prop: Symbol, multiline: T::Boolean, indent: String)
       .returns(String)
+      .checked(:never)
     end
     private def inspect_prop_value(instance, prop, multiline:, indent:)
       val = T.unsafe(self).get(instance, prop)

data/lib/types/runtime_profiled.rb

@@ -2,35 +2,23 @@
 # frozen_string_literal: true
 
 #
-# Hey there!
+# From the static system, T::Utils::RuntimeProfiled is T.untyped.
 #
-# T::Utils::Runtime is just a random class. Chances are[^1] it's not a class
-# that your variables are instances of, which means that using it in a type
-# signature will always create a type error.
+# But from the runtime system, it's a random class (specifically, a class that
+# normal programs currently don't have any instances of).
 #
-# At first, it doesn't seem like a good thing to have a type that's sole
-# purpose is to cause type errors. The trick is that within the ruby-types
-# team, we only use T::Utils::RuntimeProfiled within 'generated' sigs.
+# Thus, T::Utils::RuntimeProfiled can be used to introduce runtime-only type
+# errors. This seems like a bad idea, but it's not. It can be used to gather
+# runtime type information from running code via a custom T::Configuration
+# handler.
 #
-# Unlike normal sigs, generated sigs never raise at runtime. They also log the
-# actual, observed type on type error to a central location. We're using these
-# observed types to refine and expand our type coverage in pay-server.
+# This process has only ever been used at Stripe, and is likely to have rough
+# edges. If you've managed to find your way here and you're curious to try it,
+# please chat with us on Slack. There are no docs.
 #
-# What does this all mean for you?
-#
-# - If you were just curious, that's it! Leave the sig as is, and carry on.
-# - If you wanted to replace this sig with a better, hand-authored one:
-#
-#   1. Remove 'generated' from the sig.
-#   2. Update the sig to your liking
-#
-# Questions? :portal-to: => #ruby-types
-#
-# [^1]: Unless you happen to be calling T::Utils::RuntimeProfiled.new directly...
+# See also: the --suggest-runtime-profiled flag to sorbet.
 #
 
 module T; end
 module T::Utils; end
-# Sorbet guesses this type instead of T.untyped when passed --suggest-runtime-profiled
-
 class T::Utils::RuntimeProfiled; end

data/lib/types/utils.rb

@@ -74,26 +74,6 @@ module T::Utils
     T::Private::Methods.run_all_sig_blocks
   end
 
-  # This can be called in a wholesome test to make sure all the `sig`s are well
-  # formed.
-  def self.validate_sigs
-    exceptions = []
-    run_all_sig_blocks
-    ObjectSpace.each_object(Module) do |mod| # rubocop:disable PrisonGuard/NoDynamicConstAccess
-      begin
-        T::Private::Abstract::Validate.validate_subclass(mod)
-        if T::AbstractUtils.abstract_module?(mod)
-          T::Private::Abstract::Validate.validate_abstract_module(mod)
-        end
-      rescue => e
-        exceptions << e
-      end
-    end
-    if !exceptions.empty?
-      raise "#{exceptions.count} exception thrown during validation:\n\n#{exceptions.map(&:message).sort.join("\n\n")}"
-    end
-  end
-
   # Give a type which is a subclass of T::Types::Base, determines if the type is a simple nilable type (union of NilClass and something else).
   # If so, returns the T::Types::Base of the something else. Otherwise, returns nil.
   def self.unwrap_nilable(type)

metadata

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