sorbet-runtime 0.5.8993 → 0.5.9103

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9b153e0e894eb0a81121fd2c9a2f52cccf1654a78b6fc72d75eacc10d6ee288
-  data.tar.gz: c09b72a6a28a96d35e9076b206d9019df999659145842f6c2b5ec7d3481e4850
+  metadata.gz: dd50aa97fa3835f75f05ddad407ced4062053e791cb9c246a4ac617cb6e4eeb5
+  data.tar.gz: dd7a5031c72ae5ce3a09324d2b110c343e1409e350c12b1a8bf8a1bf21763c90
 SHA512:
-  metadata.gz: 948194b8718dd728ecaa0668421480103ce052587c6ceebee0ec01818ecf529d0a62715f0c66409ff07594c6ad4c8c0f22a05921129c66cb405f2fe143b46705
-  data.tar.gz: a788eea54fe2321d6060a79ef31ab784b21a6a4e9e15b299600abbe9699e4cc8095eaa69bedbfc07fa5f2a3e3ef959e002562db705050f8882878dbb15b6a14e
+  metadata.gz: fa6efdc3b42d1b42322af825df44bf33c625cc24b2d93f5474887218f686604e8603db6c19afae00c29c6e32e1e1ecceb52a07de68471ec9cf18aea01ab98ef4
+  data.tar.gz: a16780c9665e17e0666d2e2b04a5b60a04a7b02863f111d3a068e2b5c7b32b72334b246b00e76ddfa98d1a64fd78c79fa1467e03d19d80203c0bc5ccacf28b6c

data/lib/sorbet-runtime.rb

@@ -112,3 +112,6 @@ require_relative 'types/struct'
 require_relative 'types/non_forcing_constants'
 
 require_relative 'types/compatibility_patches'
+
+# Sorbet Compiler support module
+require_relative 'types/private/compiler'

data/lib/types/_types.rb

@@ -78,10 +78,8 @@ module T
     T::Types::ClassOf.new(klass)
   end
 
-
   ## 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 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:

data/lib/types/configuration.rb

@@ -112,7 +112,7 @@ module T::Configuration
   # statically, so that methods don't have to guard themselves from being
   # called incorrectly by untyped code.
   #
-  # @param [:never, :tests, :always] default_checked_level
+  # @param [:never, :compiled, :tests, :always] default_checked_level
   def self.default_checked_level=(default_checked_level)
     T::Private::RuntimeLevels.default_checked_level = default_checked_level
   end
@@ -429,10 +429,10 @@ module T::Configuration
   MODULE_NAME = Module.instance_method(:name)
   private_constant :MODULE_NAME
 
-  if T::Configuration::AT_LEAST_RUBY_2_7
-    @default_module_name_mangler = ->(type) {MODULE_NAME.bind_call(type)}
+  @default_module_name_mangler = if T::Configuration::AT_LEAST_RUBY_2_7
+    ->(type) {MODULE_NAME.bind_call(type)}
   else
-    @default_module_name_mangler = ->(type) {MODULE_NAME.bind(type).call}
+    ->(type) {MODULE_NAME.bind(type).call}
   end
 
   @module_name_mangler = nil
@@ -523,6 +523,16 @@ module T::Configuration
     @legacy_t_enum_migration_mode || false
   end
 
+  @prop_freeze_handler = ->(instance, prop_name) {}
+
+  def self.prop_freeze_handler=(handler)
+    @prop_freeze_handler = handler
+  end
+
+  def self.prop_freeze_handler
+    @prop_freeze_handler
+  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

data/lib/types/enum.rb

@@ -134,10 +134,8 @@ class T::Enum
     self.from_serialized(mongo_value)
   end
 
-
   ## Enum instance methods ##
 
-
   sig {returns(T.self_type)}
   def dup
     self
@@ -180,7 +178,6 @@ class T::Enum
     end
   end
 
-
   # NB: Do not call this method. This exists to allow for a safe migration path in places where enum
   # values are compared directly against string values.
   #
@@ -246,10 +243,8 @@ class T::Enum
     )
   end
 
-
   ## Private implementation ##
 
-
   sig {params(serialized_val: SerializedVal).void}
   def initialize(serialized_val=nil)
     raise 'T::Enum is abstract' if self.class == T::Enum
@@ -366,6 +361,6 @@ class T::Enum
 
   sig {params(args: String).returns(T.attached_class)}
   def self._load(args)
-    deserialize(Marshal.load(args))
+    deserialize(Marshal.load(args)) # rubocop:disable Security/MarshalLoad
   end
 end

data/lib/types/private/casts.rb

@@ -2,14 +2,6 @@
 # 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

data/lib/types/private/compiler.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Private
+  module Compiler
+    # If this code ever runs, the caller is running interpreted (or the
+    # compiler didn't see the call to `running_compiled?` statically.)
+    #
+    # The Sorbet Compiler replaces calls to this method unconditionally (no
+    # runtime guards) to return `true` when compiling a file.
+    def self.running_compiled?
+      false
+    end
+
+    # Returns `nil` because the compiler isn't running.
+    #
+    # The Sorbet Compiler replaces calls to this method unconditionally (no
+    # runtime guards) to return a String showing the Sorbet Compiler's version
+    # string.
+    def self.compiler_version
+      nil
+    end
+  end
+end

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

@@ -20,7 +20,7 @@ module T::Private::Methods
   # twice is permitted).  we could do this with two tables, but it seems slightly
   # cleaner with a single table.
   # Effectively T::Hash[Module, T.nilable(Set))]
-  @modules_with_final = Hash.new { |hash, key| hash[key] = nil }
+  @modules_with_final = Hash.new {|hash, key| hash[key] = nil}
   # this stores the old [included, extended] hooks for Module and inherited hook for Class that we override when
   # enabling final checks for when those hooks are called. the 'hooks' here don't have anything to do with the 'hooks'
   # in installed_hooks.
@@ -158,7 +158,7 @@ module T::Private::Methods
 
         definition_file, definition_line = T::Private::Methods.signature_for_method(ancestor.instance_method(method_name)).method.source_location
         is_redefined = target == ancestor
-        caller_loc = caller_locations&.find {|l| !l.to_s.match?(%r{sorbet-runtime[^/]*/lib/}) }
+        caller_loc = caller_locations&.find {|l| !l.to_s.match?(%r{sorbet-runtime[^/]*/lib/})}
         extra_info = "\n"
         if caller_loc
           extra_info = (is_redefined ? "Redefined" : "Overridden") + " here: #{caller_loc.path}:#{caller_loc.lineno}\n"
@@ -456,6 +456,10 @@ module T::Private::Methods
     end
   end
 
+  def self.all_checked_tests_sigs
+    @signatures_by_method.values.select {|sig| sig.check_level == :tests}
+  end
+
   # the module target is adding the methods from the module source to itself. we need to check that for all instance
   # methods M on source, M is not defined on any of target's ancestors.
   def self._hook_impl(target, singleton_class, source)

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

@@ -88,8 +88,8 @@ module T::Private::Methods
       if !decl.checked.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't call .checked multiple times in a signature.")
       end
-      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.")
+      if (level == :never || level == :compiled) && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
+        raise BuilderError.new("You can't use .checked(:#{level}) with .on_failure because .on_failure will have no effect.")
       end
       if !T::Private::RuntimeLevels::LEVELS.include?(level)
         raise BuilderError.new("Invalid `checked` level '#{level}'. Use one of: #{T::Private::RuntimeLevels::LEVELS}.")
@@ -106,8 +106,8 @@ module T::Private::Methods
       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 == :never
-        raise BuilderError.new("You can't use .on_failure with .checked(:never) because .on_failure will have no effect.")
+      if decl.checked == :never || decl.checked == :compiled
+        raise BuilderError.new("You can't use .on_failure with .checked(:#{decl.checked}) because .on_failure will have no effect.")
       end
 
       decl.on_failure = args
@@ -209,7 +209,7 @@ module T::Private::Methods
       end
       if decl.checked.equal?(ARG_NOT_PROVIDED)
         default_checked_level = T::Private::RuntimeLevels.default_checked_level
-        if default_checked_level == :never && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
+        if (default_checked_level == :never || default_checked_level == :compiled) && !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

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

@@ -2,12 +2,24 @@
 # typed: true
 
 module T::Private::Methods::Modes
-  def self.standard; 'standard'; end
-  def self.abstract; 'abstract'; end
-  def self.overridable; 'overridable'; end
-  def self.override; 'override'; end
-  def self.overridable_override; 'overridable_override'; end
-  def self.untyped; 'untyped'; end
+  def self.standard
+    'standard'
+  end
+  def self.abstract
+    'abstract'
+  end
+  def self.overridable
+    'overridable'
+  end
+  def self.override
+    'override'
+  end
+  def self.overridable_override
+    'overridable_override'
+  end
+  def self.untyped
+    'untyped'
+  end
   MODES = [self.standard, self.abstract, self.overridable, self.override, self.overridable_override, self.untyped].freeze
 
   OVERRIDABLE_MODES = [self.override, self.overridable, self.overridable_override, self.untyped, self.abstract].freeze

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

@@ -154,7 +154,6 @@ module T::Private::Methods::SignatureValidation
             "#{base_override_loc_str(signature, super_signature)}"
     end
 
-
     # O(nm), but n and m are tiny here
     extra_req_kwargs = signature.req_kwarg_names - super_signature.req_kwarg_names
     if !extra_req_kwargs.empty?
@@ -174,7 +173,7 @@ module T::Private::Methods::SignatureValidation
     return if signature.override_allow_incompatible
     return if super_signature.mode == Modes.untyped
     return unless [signature, super_signature].all? do |sig|
-      sig.check_level == :always || (sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
+      sig.check_level == :always || sig.check_level == :compiled || (sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
     end
     mode_noun = super_signature.mode == Modes.abstract ? 'implementation' : 'override'
 

data/lib/types/private/runtime_levels.rb

@@ -12,6 +12,9 @@ module T::Private::RuntimeLevels
     # Don't even validate in tests, b/c too expensive,
     # or b/c we fully trust the static typing
     :never,
+    # Validate the sig when the file is using the Sorbet Compiler.
+    # Behaves like :never when interpreted.
+    :compiled,
   ].freeze
 
   @check_tests = false
@@ -31,8 +34,11 @@ module T::Private::RuntimeLevels
 
   def self.enable_checking_in_tests
     if !@check_tests && @wrapped_tests_with_validation
+      all_checked_tests_sigs = T::Private::Methods.all_checked_tests_sigs
+      locations = all_checked_tests_sigs.map {|sig| sig.method.source_location.join(':')}.join("\n- ")
       raise "Toggle `:tests`-level runtime type checking earlier. " \
-        "There are already some methods wrapped with `sig.checked(:tests)`." \
+        "There are already some methods wrapped with `sig.checked(:tests)`:\n" \
+        "- #{locations}"
     end
 
     _toggle_checking_tests(true)

data/lib/types/props/_props.rb

@@ -20,13 +20,23 @@ module T::Props
     extend T::Sig
     extend T::Helpers
 
-    def props; decorator.props; end
-    def plugins; @plugins ||= []; end
+    def props
+      decorator.props
+    end
+    def plugins
+      @plugins ||= []
+    end
 
-    def decorator_class; Decorator; end
+    def decorator_class
+      Decorator
+    end
 
-    def decorator; @decorator ||= decorator_class.new(self); end
-    def reload_decorator!; @decorator = decorator_class.new(self); end
+    def decorator
+      @decorator ||= decorator_class.new(self)
+    end
+    def reload_decorator!
+      @decorator = decorator_class.new(self)
+    end
 
     # @!method self.prop(name, type, opts={})
     #

data/lib/types/props/decorator.rb

@@ -34,11 +34,15 @@ class T::Props::Decorator
   attr_reader :props
 
   sig {returns(T::Array[Symbol])}
-  def all_props; props.keys; end
+  def all_props
+    props.keys
+  end
 
   # checked(:never) - O(prop accesses)
   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
+  def prop_rules(prop)
+    props[prop.to_sym] || raise("No such prop: #{prop.inspect}")
+  end
 
   # checked(:never) - Rules hash is expensive to check
   sig {params(prop: Symbol, rules: Rules).void.checked(:never)}
@@ -78,7 +82,9 @@ class T::Props::Decorator
 
   # checked(:never) - O(prop accesses)
   sig {returns(T.all(Module, T::Props::ClassMethods)).checked(:never)}
-  def decorated_class; @class; end
+  def decorated_class
+    @class
+  end
 
   # Accessors
 

data/lib/types/props/generated_code_validation.rb

@@ -157,7 +157,7 @@ module T::Props
         validate_lack_of_side_effects(try, whitelisted_methods_for_deserialize)
 
         assert_equal(:resbody, rescue_body.type)
-        exceptions, assignment, handler =  rescue_body.children
+        exceptions, assignment, handler = rescue_body.children
         assert_equal(:array, exceptions.type)
         exceptions.children.each {|c| assert_equal(:const, c.type)}
         assert_equal(:lvasgn, assignment.type)

data/lib/types/props/optional.rb

@@ -5,10 +5,8 @@ module T::Props::Optional
   include T::Props::Plugin
 end
 
-
 ##############################################
 
-
 # NB: This must stay in the same file where T::Props::Optional is defined due to
 # T::Props::Decorator#apply_plugin; see https://git.corp.stripe.com/stripe-internal/pay-server/blob/fc7f15593b49875f2d0499ffecfd19798bac05b3/chalk/odm/lib/chalk-odm/document_decorator.rb#L716-L717
 module T::Props::Optional::DecoratorMethods
@@ -27,7 +25,9 @@ module T::Props::Optional::DecoratorMethods
     super || VALID_RULE_KEYS[key]
   end
 
-  def prop_optional?(prop); prop_rules(prop)[:fully_optional]; end
+  def prop_optional?(prop)
+    prop_rules(prop)[:fully_optional]
+  end
 
   def compute_derived_rules(rules)
     rules[:fully_optional] = !T::Props::Utils.need_nil_write_check?(rules)

data/lib/types/props/private/serializer_generator.rb

@@ -74,4 +74,3 @@ module T::Props
     end
   end
 end
-

data/lib/types/props/serializable.rb

@@ -15,7 +15,7 @@ module T::Props::Serializable
   #   exception if this object has mandatory props with missing
   #   values.
   # @return [Hash] A serialization of this object.
-  def serialize(strict=true) # rubocop:disable Style/OptionalBooleanParameter (changing this API is unfortunately not feasible)
+  def serialize(strict=true)
     begin
       h = __t_props_generated_serialize(strict)
     rescue => e
@@ -56,7 +56,7 @@ module T::Props::Serializable
   #  the hash contains keys that do not correspond to any known
   #  props on this instance.
   # @return [void]
-  def deserialize(hash, strict=false) # rubocop:disable Style/OptionalBooleanParameter (changing this API is unfortunately not feasible)
+  def deserialize(hash, strict=false)
     begin
       hash_keys_matching_props = __t_props_generated_deserialize(hash)
     rescue => e
@@ -171,7 +171,6 @@ module T::Props::Serializable
   end
 end
 
-
 ##############################################
 
 # NB: This must stay in the same file where T::Props::Serializable is defined due to
@@ -190,10 +189,14 @@ module T::Props::Serializable::DecoratorMethods
     @class.props.select {|_, v| T::Props::Utils.required_prop?(v)}.keys
   end
 
-  def prop_dont_store?(prop); prop_rules(prop)[:dont_store]; end
-  def prop_by_serialized_forms; @class.prop_by_serialized_forms; end
+  def prop_dont_store?(prop)
+    prop_rules(prop)[:dont_store]
+  end
+  def prop_by_serialized_forms
+    @class.prop_by_serialized_forms
+  end
 
-  def from_hash(hash, strict=false) # rubocop:disable Style/OptionalBooleanParameter (changing this API is unfortunately not feasible)
+  def from_hash(hash, strict=false)
     raise ArgumentError.new("#{hash.inspect} provided to from_hash") if !(hash && hash.is_a?(Hash))
 
     i = @class.allocate
@@ -260,7 +263,7 @@ module T::Props::Serializable::DecoratorMethods
     context = "  #{source_lines[(previous_blank + 1)...next_blank].join("\n  ")}"
     <<~MSG
       Error in #{decorated_class.name}##{generated_method}: #{error.message}
-      at line #{line_num-previous_blank-1} in:
+      at line #{line_num - previous_blank - 1} in:
       #{context}
     MSG
   end
@@ -300,7 +303,7 @@ module T::Props::Serializable::DecoratorMethods
     end
 
     if !rules[:raise_on_nil_write].nil? && rules[:raise_on_nil_write] != true
-        raise ArgumentError.new("The value of `raise_on_nil_write` if specified must be `true` (given: #{rules[:raise_on_nil_write]}).")
+      raise ArgumentError.new("The value of `raise_on_nil_write` if specified must be `true` (given: #{rules[:raise_on_nil_write]}).")
     end
 
     result
@@ -334,21 +337,21 @@ module T::Props::Serializable::DecoratorMethods
   end
 end
 
-
 ##############################################
 
-
 # NB: This must stay in the same file where T::Props::Serializable is defined due to
 # T::Props::Decorator#apply_plugin; see https://git.corp.stripe.com/stripe-internal/pay-server/blob/fc7f15593b49875f2d0499ffecfd19798bac05b3/chalk/odm/lib/chalk-odm/document_decorator.rb#L716-L717
 module T::Props::Serializable::ClassMethods
-  def prop_by_serialized_forms; @prop_by_serialized_forms ||= {}; end
+  def prop_by_serialized_forms
+    @prop_by_serialized_forms ||= {}
+  end
 
   # @!method self.from_hash(hash, strict)
   #
   # Allocate a new instance and call {#deserialize} to load a new
   # object from a hash.
   # @return [Serializable]
-  def from_hash(hash, strict=false) # rubocop:disable Style/OptionalBooleanParameter (changing this API is unfortunately not feasible)
+  def from_hash(hash, strict=false)
     self.decorator.from_hash(hash, strict)
   end
 

data/lib/types/types/fixed_hash.rb

@@ -13,15 +13,7 @@ module T::Types
 
     # @override Base
     def name
-      entries = @types.map do |(k, v)|
-        if Symbol === k && ":#{k}" == k.inspect
-          "#{k}: #{v}"
-        else
-          "#{k.inspect} => #{v}"
-        end
-      end
-
-      "{#{entries.join(', ')}}"
+      serialize_hash(@types)
     end
 
     # @override Base
@@ -59,10 +51,24 @@ module T::Types
     # @override Base
     def describe_obj(obj)
       if obj.is_a?(Hash)
-        "type {#{obj.map {|(k, v)| "#{k}: #{v.class}"}.join(', ')}}"
+        "type #{serialize_hash(obj.transform_values(&:class))}"
       else
         super
       end
     end
+
+    private
+
+    def serialize_hash(hash)
+      entries = hash.map do |(k, v)|
+        if Symbol === k && ":#{k}" == k.inspect
+          "#{k}: #{v}"
+        else
+          "#{k.inspect} => #{v}"
+        end
+      end
+
+      "{#{entries.join(', ')}}"
+    end
   end
 end

data/lib/types/types/self_type.rb

@@ -22,9 +22,9 @@ module T::Types
     private def subtype_of_single?(other)
       case other
       when SelfType
-          true
-        else
-          false
+        true
+      else
+        false
       end
     end
 

data/lib/types/types/simple.rb

@@ -40,8 +40,10 @@ module T::Types
 
     module Private
       module Pool
+        @cache = ObjectSpace::WeakMap.new
+
         def self.type_for_module(mod)
-          cached = mod.instance_variable_get(:@__as_sorbet_type)
+          cached = @cache[mod]
           return cached if cached
 
           type = if mod == ::Array
@@ -60,7 +62,13 @@ module T::Types
             Simple.new(mod)
           end
 
-          mod.instance_variable_set(:@__as_sorbet_type, type) unless mod.frozen?
+          # Unfortunately, we still need to check if the module is frozen,
+          # since WeakMap adds a finalizer to the key that is added
+          # to the map, so that it can clear the map entry when the key is
+          # garbage collected.
+          # For a frozen object, though, adding a finalizer is not a valid
+          # operation, so this still raises if `mod` is frozen.
+          @cache[mod] = type unless mod.frozen?
           type
         end
       end

data/lib/types/utils.rb

@@ -27,6 +27,14 @@ module T::Utils
     end
   end
 
+  # 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
+
   # Returns the set of all methods (public, protected, private) defined on a module or its
   # ancestors, excluding Object and its ancestors. Overrides of methods from Object (and its
   # ancestors) are included.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.8993
+  version: 0.5.9103
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-31 00:00:00.000000000 Z
+date: 2021-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -173,6 +173,7 @@ files:
 - lib/types/private/abstract/validate.rb
 - lib/types/private/casts.rb
 - lib/types/private/class_utils.rb
+- lib/types/private/compiler.rb
 - lib/types/private/decl_state.rb
 - lib/types/private/final.rb
 - lib/types/private/methods/_methods.rb