sorbet-runtime 0.5.5942 → 0.5.6198

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4838c21772de1169f412a971cfe59e49fc482bda8de9fb70920fd4bcab5e654f
-  data.tar.gz: 5e27052a663a22e70e5aa3afee7563f43be650946ec4673df2fb246535a28bb6
+  metadata.gz: b9ad14907c264d6ca3dae954f1bf9cdfdff0544411fad7a390fcb424465bf828
+  data.tar.gz: f02410f71f442e62a635881ec386a23911f1cb1a4d4c5eae77693d1a10a0695d
 SHA512:
-  metadata.gz: 87abc9d8a3a9a753d96577a52856c4e04b2dfaaefb1908e696d9882c04a593ab6cdd9112660afa887d57fd3df62dbf99fded5a697b176ac1c043011b3fd43db1
-  data.tar.gz: 6f10e93404924fbf7752eb01786e717d585472df7b2c77aaead247df1d170998ff46b8d3d8e5b51bad6773fc950280ebc3c922651078a249fef2d29929d75aef
+  metadata.gz: 1bb53ba112fb1793b4e138e1a65ed648e2e202af6e8ec79be17b444c11c02a63a7c385b0abb474e38dca78a03ad91f02149ff24b7c5f622f7d1943c4d4c846b1
+  data.tar.gz: bf301214903ea532fb931314c823f68a3017a2de5868f32d074a642664c4cf266864201d9ae4a62573a9713bb888d132cb0aadd23c77aaf628b8d443163bae36

data/lib/sorbet-runtime.rb

@@ -22,7 +22,6 @@ require_relative 'types/configuration'
 require_relative 'types/profile'
 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/runtime_levels'
 require_relative 'types/private/methods/_methods'

data/lib/types/compatibility_patches.rb

@@ -1,8 +1,6 @@
 # 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 message expectations (*_any_instance_of,
 # expect, allow) and and_call_original.

data/lib/types/configuration.rb

@@ -42,6 +42,34 @@ module T::Configuration
     T::Private::Methods.set_final_checks_on_hooks(false)
   end
 
+  @include_value_in_type_errors = true
+  # Whether to include values in TypeError messages.
+  #
+  # Including values is useful for debugging, but can potentially leak
+  # sensitive information to logs.
+  #
+  # @return [T::Boolean]
+  def self.include_value_in_type_errors?
+    @include_value_in_type_errors
+  end
+
+  # Configure if type errors excludes the value of the problematic type.
+  #
+  # The default is to include values in type errors:
+  #   TypeError: Expected type Integer, got String with value "foo"
+  #
+  # When values are excluded from type errors:
+  #   TypeError: Expected type Integer, got String
+  def self.exclude_value_in_type_errors
+    @include_value_in_type_errors = false
+  end
+
+  # Opposite of exclude_value_in_type_errors.
+  # (Including values in type errors is the default)
+  def self.include_value_in_type_errors
+    @include_value_in_type_errors = true
+  end
+
   # Configure the default checked level for a sig with no explicit `.checked`
   # builder. When unset, the default checked level is `:always`.
   #
@@ -338,7 +366,7 @@ module T::Configuration
     if values.nil?
       @scalar_types = values
     else
-      bad_values = values.select {|v| v.class != String}
+      bad_values = values.reject {|v| v.class == String}
       unless bad_values.empty?
         raise ArgumentError.new("Provided values must all be class name strings.")
       end
@@ -347,7 +375,7 @@ module T::Configuration
     end
   end
 
-  @default_scalar_types = Set.new(%w{
+  @default_scalar_types = Set.new(%w[
     NilClass
     TrueClass
     FalseClass
@@ -357,12 +385,33 @@ module T::Configuration
     Symbol
     Time
     T::Enum
-  }).freeze
+  ]).freeze
 
   def self.scalar_types
     @scalar_types || @default_scalar_types
   end
 
+  # Guard against overrides of `name` or `to_s`
+  MODULE_NAME = Module.instance_method(:name)
+  private_constant :MODULE_NAME
+
+  @default_module_name_mangler = ->(type) {MODULE_NAME.bind(type).call}
+  @module_name_mangler = nil
+
+  def self.module_name_mangler
+    @module_name_mangler || @default_module_name_mangler
+  end
+
+  # Set to override the default behavior for converting types
+  #   to names in generated code. Used by the runtime implementation
+  #   associated with `--stripe-packages` mode.
+  #
+  # @param [Lambda, Proc, nil] value Proc that converts a type (Class/Module)
+  #   to a String (pass nil to reset to default behavior)
+  def self.module_name_mangler=(handler)
+    @module_name_mangler = handler
+  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).
@@ -398,7 +447,7 @@ module T::Configuration
   #   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
+    if !@sealed_violation_whitelist.nil?
       raise ArgumentError.new("Cannot overwrite sealed_violation_whitelist after setting it")
     end
 

data/lib/types/enum.rb

@@ -251,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'."
@@ -357,4 +357,15 @@ class T::Enum
 
     raise "Inheriting from children of T::Enum is prohibited" if self != T::Enum
   end
+
+  # Marshal support
+  sig {params(_level: Integer).returns(String)}
+  def _dump(_level)
+    Marshal.dump(serialize)
+  end
+
+  sig {params(args: String).returns(T.attached_class)}
+  def self._load(args)
+    deserialize(Marshal.load(args))
+  end
 end

data/lib/types/non_forcing_constants.rb

@@ -30,28 +30,32 @@ module T::NonForcingConstants
 
         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
+        # if this had a :: prefix, then there's no more loading to
+        # do---skip to the next one
+        next if part == ""
+      end
+
+      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}"
+      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
+      if !Module.===(current_klass)
+        raise ArgumentError.new("#{current_prefix} is not a class or module")
       end
     end
 
-    return current_klass.===(val)
+    current_klass.===(val)
   end
 end

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

@@ -111,16 +111,16 @@ module T::Private::Abstract::Validate
   end
 
   private_class_method def self.describe_method(method, show_owner: true)
-    if method.source_location
-      loc = method.source_location.join(':')
+    loc = if method.source_location
+      method.source_location.join(':')
     else
-      loc = "<unknown location>"
+      "<unknown location>"
     end
 
-    if show_owner
-      owner = " declared in #{method.owner}"
+    owner = if show_owner
+      " declared in #{method.owner}"
     else
-      owner = ""
+      ""
     end
 
     "    * `#{method.name}`#{owner} at #{loc}"

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

@@ -142,7 +142,10 @@ module T::Private::Methods
         # method_to_key(ancestor.instance_method(method_name)) is not (just) an optimization, but also required for
         # correctness, since ancestor.method_defined?(method_name) may return true even if method_name is not defined
         # directly on ancestor but instead an ancestor of ancestor.
-        if ancestor.method_defined?(method_name) && final_method?(method_owner_and_name_to_key(ancestor, method_name))
+        if (ancestor.method_defined?(method_name) ||
+            ancestor.private_method_defined?(method_name) ||
+            ancestor.protected_method_defined?(method_name)) &&
+           final_method?(method_owner_and_name_to_key(ancestor, method_name))
           raise(
             "The method `#{method_name}` on #{ancestor} was declared as final and cannot be " +
             (target == ancestor ? "redefined" : "overridden in #{target}")
@@ -190,7 +193,7 @@ module T::Private::Methods
 
     if method_name == :method_added || method_name == :singleton_method_added
       raise(
-        "Putting a `sig` on `#{method_name}` is not supported" +
+        "Putting a `sig` on `#{method_name}` is not supported" \
         " (sorbet-runtime uses this method internally to perform `sig` validation logic)"
       )
     end
@@ -313,10 +316,10 @@ module T::Private::Methods
     begin
       # We allow `sig` in the current module's context (normal case) and
       if hook_mod != current_declaration.mod &&
-          # inside `class << self`, and
-          hook_mod.singleton_class != current_declaration.mod &&
-          # on `self` at the top level of a file
-          current_declaration.mod != TOP_SELF
+         # inside `class << self`, and
+         hook_mod.singleton_class != current_declaration.mod &&
+         # on `self` at the top level of a file
+         current_declaration.mod != TOP_SELF
         raise "A method (#{method_name}) is being added on a different class/module (#{hook_mod}) than the " \
               "last call to `sig` (#{current_declaration.mod}). Make sure each call " \
               "to `sig` is immediately followed by a method definition on the same " \
@@ -407,7 +410,7 @@ module T::Private::Methods
   def self.run_all_sig_blocks
     loop do
       break if @sig_wrappers.empty?
-      key, _ = @sig_wrappers.first
+      key, = @sig_wrappers.first
       run_sig_block_for_key(key)
     end
   end
@@ -424,7 +427,7 @@ module T::Private::Methods
   end
 
   def self.set_final_checks_on_hooks(enable)
-    is_enabled = @old_hooks != nil
+    is_enabled = !@old_hooks.nil?
     if enable == is_enabled
       return
     end

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

@@ -195,7 +195,7 @@ module T::Private::Methods::CallValidation
       raise "Should have used create_validator_procedure_fast"
     end
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.length == 0
+    if method_sig.arg_types.empty?
       create_validator_method_fast0(mod, original_method, method_sig, method_sig.return_type.raw_type)
     elsif method_sig.arg_types.length == 1
       create_validator_method_fast1(mod, original_method, method_sig, method_sig.return_type.raw_type,
@@ -708,7 +708,7 @@ module T::Private::Methods::CallValidation
 
   def self.create_validator_procedure_fast(mod, original_method, method_sig)
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.length == 0
+    if method_sig.arg_types.empty?
       create_validator_procedure_fast0(mod, original_method, method_sig)
     elsif method_sig.arg_types.length == 1
       create_validator_procedure_fast1(mod, original_method, method_sig,

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

@@ -31,12 +31,15 @@ module T::Private::Methods
       )
     end
 
-    def params(params)
+    def params(**params)
       check_live!
       if !decl.params.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't call .params twice")
       end
 
+      if params.empty?
+        raise BuilderError.new("params expects keyword arguments")
+      end
       decl.params = params
 
       self

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

@@ -8,9 +8,9 @@ module T::Private::Methods::Modes
   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]
+  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]
-  OVERRIDE_MODES = [self.override, self.overridable_override]
+  OVERRIDABLE_MODES = [self.override, self.overridable, self.overridable_override, self.untyped, self.abstract].freeze
+  OVERRIDE_MODES = [self.override, self.overridable_override].freeze
   NON_OVERRIDE_MODES = MODES - OVERRIDE_MODES
 end

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

@@ -28,7 +28,7 @@ class T::Private::Methods::Signature
     )
   end
 
-  def initialize(method:, method_name:, raw_arg_types:, raw_return_type:, bind:, mode:, check_level:, parameters: method.parameters, on_failure:, override_allow_incompatible: false)
+  def initialize(method:, method_name:, raw_arg_types:, raw_return_type:, bind:, mode:, check_level:, on_failure:, parameters: method.parameters, override_allow_incompatible: false)
     @method = method
     @method_name = method_name
     @arg_types = []
@@ -68,6 +68,10 @@ class T::Private::Methods::Signature
       raise "The declaration for `#{method.name}` has extra parameter(s): #{extra_names.join(', ')}"
     end
 
+    if parameters.size != raw_arg_types.size
+      raise "The declaration for `#{method.name}` has arguments with duplicate names"
+    end
+
     parameters.zip(raw_arg_types) do |(param_kind, param_name), (type_name, raw_type)|
       if type_name != param_name
         hint = ""
@@ -194,10 +198,10 @@ class T::Private::Methods::Signature
   end
 
   def method_desc
-    if @method.source_location
-      loc = @method.source_location.join(':')
+    loc = if @method.source_location
+      @method.source_location.join(':')
     else
-      loc = "<unknown location>"
+      "<unknown location>"
     end
     "#{@method} at #{loc}"
   end

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

@@ -100,19 +100,16 @@ module T::Private::Methods::SignatureValidation
       raise "Unexpected mode: #{signature.mode}. Please report to #dev-productivity."
     end
 
+    # Given a singleton class, we can check if it belongs to a
+    # module by looking at its superclass; given `module M`,
+    # `M.singleton_class.superclass == Module`, which is not true
+    # for any class.
     owner = signature.method.owner
     if (signature.mode == Modes.abstract || Modes::OVERRIDABLE_MODES.include?(signature.mode)) &&
-        owner.singleton_class?
-      # Given a singleton class, we can check if it belongs to a
-      # module by looking at its superclass; given `module M`,
-      # `M.singleton_class.superclass == Module`, which is not true
-      # for any class.
-      if owner.superclass == Module
-        raise "Defining an overridable class method (via #{pretty_mode(signature)}) " \
-              "on a module is not allowed. Class methods on " \
-              "modules do not get inherited and thus cannot be overridden. For help, ask in " \
-              "#dev-productivity."
-      end
+        owner.singleton_class? && owner.superclass == Module
+      raise "Defining an overridable class method (via #{pretty_mode(signature)}) " \
+            "on a module is not allowed. Class methods on " \
+            "modules do not get inherited and thus cannot be overridden."
     end
   end
 
@@ -219,10 +216,10 @@ module T::Private::Methods::SignatureValidation
   end
 
   private_class_method def self.method_loc_str(method)
-    if method.source_location
-      loc = method.source_location.join(':')
+    loc = if method.source_location
+      method.source_location.join(':')
     else
-      loc = "<unknown location>"
+      "<unknown location>"
     end
     "#{method.owner} at #{loc}"
   end

data/lib/types/private/sealed.rb

@@ -7,6 +7,11 @@ module T::Private::Sealed
       super
       this_line = Kernel.caller.find {|line| !line.match(/in `inherited'$/)}
       T::Private::Sealed.validate_inheritance(this_line, self, 'inherited')
+      @sorbet_sealed_module_all_subclasses << other
+    end
+
+    def sealed_subclasses
+      @sorbet_sealed_module_all_subclasses
     end
   end
 
@@ -15,12 +20,21 @@ module T::Private::Sealed
       super
       this_line = Kernel.caller.find {|line| !line.match(/in `included'$/)}
       T::Private::Sealed.validate_inheritance(this_line, self, 'included')
+      @sorbet_sealed_module_all_subclasses << other
     end
 
     def extended(other)
       super
       this_line = Kernel.caller.find {|line| !line.match(/in `extended'$/)}
       T::Private::Sealed.validate_inheritance(this_line, self, 'extended')
+      @sorbet_sealed_module_all_subclasses << other
+    end
+
+    def sealed_subclasses
+      # this will freeze the set so that you can never get into a
+      # state where you use the subclasses list and then something
+      # else will add to it
+      @sorbet_sealed_module_all_subclasses.freeze
     end
   end
 
@@ -39,6 +53,7 @@ module T::Private::Sealed
       raise "Couldn't determine declaration file for sealed class."
     end
     mod.instance_variable_set(:@sorbet_sealed_module_decl_file, decl_file)
+    mod.instance_variable_set(:@sorbet_sealed_module_all_subclasses, Set.new)
   end
 
   def self.sealed_module?(mod)
@@ -55,7 +70,7 @@ module T::Private::Sealed
 
     if !this_file.start_with?(decl_file)
       whitelist = T::Configuration.sealed_violation_whitelist
-      if whitelist != nil && whitelist.any? {|pattern| this_file =~ pattern}
+      if !whitelist.nil? && whitelist.any? {|pattern| this_file =~ pattern}
         return
       end
 

data/lib/types/props/decorator.rb

@@ -54,7 +54,7 @@ class T::Props::Decorator
     @props = @props.merge(prop => rules.freeze).freeze
   end
 
-  VALID_RULE_KEYS = T.let(%i{
+  VALID_RULE_KEYS = T.let(%i[
     enum
     foreign
     foreign_hint_only
@@ -68,7 +68,7 @@ class T::Props::Decorator
     extra
     setter_validate
     _tnilable
-  }.map {|k| [k, true]}.to_h.freeze, T::Hash[Symbol, T::Boolean])
+  ].map {|k| [k, true]}.to_h.freeze, T::Hash[Symbol, T::Boolean])
   private_constant :VALID_RULE_KEYS
 
   sig {params(key: Symbol).returns(T::Boolean).checked(:never)}
@@ -153,12 +153,10 @@ class T::Props::Decorator
     val = instance.instance_variable_get(rules[:accessor_key])
     if !val.nil?
       val
+    elsif (d = rules[:ifunset])
+      T::Props::Utils.deep_clone_object(d)
     else
-      if (d = rules[:ifunset])
-        T::Props::Utils.deep_clone_object(d)
-      else
-        nil
-      end
+      nil
     end
   end
 
@@ -219,15 +217,13 @@ class T::Props::Decorator
       raise ArgumentError.new("At least one invalid prop arg supplied in #{self}: #{rules.keys.inspect}")
     end
 
-    if !(rules[:clobber_existing_method!]) && !(rules[:without_accessors])
-      if BANNED_METHOD_NAMES.include?(name.to_sym)
-        raise ArgumentError.new(
-          "#{name} can't be used as a prop in #{@class} because a method with " \
-          "that name already exists (defined by #{@class.instance_method(name).owner} " \
-          "at #{@class.instance_method(name).source_location || '<unknown>'}). " \
-          "(If using this name is unavoidable, try `without_accessors: true`.)"
-        )
-      end
+    if !rules[:clobber_existing_method!] && !rules[:without_accessors] && BANNED_METHOD_NAMES.include?(name.to_sym)
+      raise ArgumentError.new(
+        "#{name} can't be used as a prop in #{@class} because a method with " \
+        "that name already exists (defined by #{@class.instance_method(name).owner} " \
+        "at #{@class.instance_method(name).source_location || '<unknown>'}). " \
+        "(If using this name is unavoidable, try `without_accessors: true`.)"
+      )
     end
 
     extra = rules[:extra]
@@ -238,7 +234,7 @@ class T::Props::Decorator
     nil
   end
 
-  SAFE_NAME = /\A[A-Za-z_][A-Za-z0-9_-]*\z/
+  SAFE_NAME = T.let(/\A[A-Za-z_][A-Za-z0-9_-]*\z/.freeze, Regexp)
 
   # Used to validate both prop names and serialized forms
   sig {params(name: T.any(Symbol, String)).void}
@@ -312,13 +308,12 @@ class T::Props::Decorator
     sensitivity_and_pii = {sensitivity: rules[:sensitivity]}
     if defined?(Opus) && defined?(Opus::Sensitivity) && defined?(Opus::Sensitivity::Utils)
       sensitivity_and_pii = Opus::Sensitivity::Utils.normalize_sensitivity_and_pii_annotation(sensitivity_and_pii)
-    end
-    # We check for Class so this is only applied on concrete
-    # documents/models; We allow mixins containing props to not
-    # specify their PII nature, as long as every class into which they
-    # are ultimately included does.
-    #
-    if defined?(Opus) && defined?(Opus::Sensitivity) && defined?(Opus::Sensitivity::PIIable)
+
+      # We check for Class so this is only applied on concrete
+      # documents/models; We allow mixins containing props to not
+      # specify their PII nature, as long as every class into which they
+      # are ultimately included does.
+      #
       if sensitivity_and_pii[:pii] && @class.is_a?(Class) && !T.unsafe(@class).contains_pii?
         raise ArgumentError.new(
           'Cannot include a pii prop in a class that declares `contains_no_pii`'
@@ -488,7 +483,7 @@ class T::Props::Decorator
     .void
   end
   private def handle_foreign_hint_only_option(prop_name, prop_cls, foreign_hint_only)
-    if ![String, Array].include?(prop_cls) && !(prop_cls.is_a?(T::Props::CustomType))
+    if ![String, Array].include?(prop_cls) && !prop_cls.is_a?(T::Props::CustomType)
       raise ArgumentError.new(
         "`foreign_hint_only` can only be used with String or Array prop types"
       )
@@ -546,10 +541,10 @@ class T::Props::Decorator
         # of the method, optimizing it so this only runs on the first invocation.
         foreign = resolved_foreign
       end
-      if allow_direct_mutation.nil?
-        opts = {}
+      opts = if allow_direct_mutation.nil?
+        {}
       else
-        opts = {allow_direct_mutation: allow_direct_mutation}
+        {allow_direct_mutation: allow_direct_mutation}
       end
 
       T.unsafe(self.class).decorator.foreign_prop_get(self, prop_name, foreign, rules, opts)
@@ -644,25 +639,33 @@ class T::Props::Decorator
       # (b) it's safe because the getter was defined by this file.
       #
       unless rules[:without_accessors]
-        if child.decorator.method(:prop_get).owner != method(:prop_get).owner &&
-            child.instance_method(name).source_location&.first == __FILE__
+        if clobber_getter?(child, name)
           child.send(:define_method, name) do
             T.unsafe(self.class).decorator.prop_get(self, name, rules)
           end
         end
 
-        unless rules[:immutable]
-          if child.decorator.method(:prop_set).owner != method(:prop_set).owner &&
-              child.instance_method("#{name}=").source_location&.first == __FILE__
-            child.send(:define_method, "#{name}=") do |val|
-              T.unsafe(self.class).decorator.prop_set(self, name, val, rules)
-            end
+        if !rules[:immutable] && clobber_setter?(child, name)
+          child.send(:define_method, "#{name}=") do |val|
+            T.unsafe(self.class).decorator.prop_set(self, name, val, rules)
           end
         end
       end
     end
   end
 
+  sig {params(child: T.all(Module, T::Props::ClassMethods), prop: Symbol).returns(T::Boolean).checked(:never)}
+  private def clobber_getter?(child, prop)
+    !!(child.decorator.method(:prop_get).owner != method(:prop_get).owner &&
+       child.instance_method(prop).source_location&.first == __FILE__)
+  end
+
+  sig {params(child: T.all(Module, T::Props::ClassMethods), prop: Symbol).returns(T::Boolean).checked(:never)}
+  private def clobber_setter?(child, prop)
+    !!(child.decorator.method(:prop_set).owner != method(:prop_set).owner &&
+       child.instance_method("#{prop}=").source_location&.first == __FILE__)
+  end
+
   sig {params(mod: Module).void.checked(:never)}
   def plugin(mod)
     decorated_class.plugins << mod

data/lib/types/props/generated_code_validation.rb

@@ -38,7 +38,7 @@ module T::Props
       assert_equal(s(:lvar, :found), ret)
 
       prop_clauses.each_with_index do |clause, i|
-        if i % 2 == 0
+        if i.even?
           validate_deserialize_hash_read(clause)
         else
           validate_deserialize_ivar_set(clause)
@@ -251,17 +251,17 @@ module T::Props
     # Method calls generated by SerdeTransform
     private_class_method def self.whitelisted_methods_for_serialize
       @whitelisted_methods_for_serialize ||= {
-        :lvar => %i{dup map transform_values transform_keys each_with_object nil? []= serialize},
-        :ivar => %i{dup map transform_values transform_keys each_with_object serialize},
-        :const => %i{checked_serialize deep_clone_object},
+        lvar: %i{dup map transform_values transform_keys each_with_object nil? []= serialize},
+        ivar: %i[dup map transform_values transform_keys each_with_object serialize],
+        const: %i[checked_serialize deep_clone_object],
       }
     end
 
     # Method calls generated by SerdeTransform
     private_class_method def self.whitelisted_methods_for_deserialize
       @whitelisted_methods_for_deserialize ||= {
-        :lvar => %i{dup map transform_values transform_keys each_with_object nil? []= to_f},
-        :const => %i{deserialize from_hash deep_clone_object soft_assert_handler},
+        lvar: %i{dup map transform_values transform_keys each_with_object nil? []= to_f},
+        const: %i[deserialize from_hash deep_clone_object soft_assert_handler],
       }
     end
   end

data/lib/types/props/has_lazily_specialized_methods.rb

@@ -84,7 +84,7 @@ module T::Props
 
         cls = decorated_class
         cls.class_eval(source)
-        lazily_defined_methods.keys.each {|name| cls.send(:private, name)}
+        lazily_defined_methods.each_key {|name| cls.send(:private, name)}
         lazily_defined_methods.clear
       end
     end

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

@@ -48,12 +48,12 @@ module T::Props
             SerdeTransform::Mode::DESERIALIZE,
             'val'
           )
-          if transformation
+          transformed_val = if transformation
             # Rescuing exactly NoMethodError is intended as a temporary hack
             # to preserve the semantics from before codegen. More generally
             # we are inconsistent about typechecking on deser and need to decide
             # our strategy here.
-            transformed_val = <<~RUBY
+            <<~RUBY
               begin
                 #{transformation}
               rescue NoMethodError => e
@@ -71,7 +71,7 @@ module T::Props
               end
             RUBY
           else
-            transformed_val = 'val'
+            'val'
           end
 
           nil_handler = generate_nil_handler(

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

@@ -99,20 +99,18 @@ module T::Props
             else
               "#{varname}.nil? ? nil : #{inner}"
             end
-          else
+          elsif type.types.all? {|t| generate(t, mode, varname).nil?}
             # Handle, e.g., T::Boolean
-            if type.types.all? {|t| generate(t, mode, varname).nil?}
-              nil
-            else
-              # We currently deep_clone_object if the type was T.any(Integer, Float).
-              # When we get better support for union types (maybe this specific
-              # union type, because it would be a replacement for
-              # Chalk::ODM::DeprecatedNumemric), we could opt to special case
-              # this union to have no specific serde transform (the only reason
-              # why Float has a special case is because round tripping through
-              # JSON might normalize Floats to Integers)
-              "T::Props::Utils.deep_clone_object(#{varname})"
-            end
+            nil
+          else
+            # We currently deep_clone_object if the type was T.any(Integer, Float).
+            # When we get better support for union types (maybe this specific
+            # union type, because it would be a replacement for
+            # Chalk::ODM::DeprecatedNumemric), we could opt to special case
+            # this union to have no specific serde transform (the only reason
+            # why Float has a special case is because round tripping through
+            # JSON might normalize Floats to Integers)
+            "T::Props::Utils.deep_clone_object(#{varname})"
           end
         when T::Types::Intersection
           dynamic_fallback = "T::Props::Utils.deep_clone_object(#{varname})"
@@ -179,13 +177,9 @@ module T::Props
         end
       end
 
-      # Guard against overrides of `name` or `to_s`
-      MODULE_NAME = T.let(Module.instance_method(:name), UnboundMethod)
-      private_constant :MODULE_NAME
-
       sig {params(type: Module).returns(T.nilable(String)).checked(:never)}
       private_class_method def self.module_name(type)
-        MODULE_NAME.bind(type).call
+        T::Configuration.module_name_mangler.call(type)
       end
     end
   end

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

@@ -58,10 +58,7 @@ module T::Props
           # from disk) are correct, so we use more thorough runtime
           # checks there
           if non_nil_type.recursively_valid?(val)
-            if validate
-              validate.call(prop, val)
-            end
-            instance_variable_set(accessor_key, val)
+            validate&.call(prop, val)
           else
             T::Props::Private::SetterFactory.raise_pretty_error(
               klass,
@@ -69,8 +66,8 @@ module T::Props
               non_nil_type,
               val,
             )
-            instance_variable_set(accessor_key, val)
           end
+          instance_variable_set(accessor_key, val)
         end
       end
 
@@ -94,9 +91,7 @@ module T::Props
           # from disk) are correct, so we use more thorough runtime
           # checks there
           elsif non_nil_type.recursively_valid?(val)
-            if validate
-              validate.call(prop, val)
-            end
+            validate&.call(prop, val)
             instance_variable_set(accessor_key, val)
           else
             T::Props::Private::SetterFactory.raise_pretty_error(

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)
+  def serialize(strict=true) # rubocop:disable Style/OptionalBooleanParameter (changing this API is unfortunately not feasible)
     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)
+  def deserialize(hash, strict=false) # rubocop:disable Style/OptionalBooleanParameter (changing this API is unfortunately not feasible)
     begin
       hash_keys_matching_props = __t_props_generated_deserialize(hash)
     rescue => e
@@ -180,7 +180,7 @@ module T::Props::Serializable::DecoratorMethods
   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)
+  def from_hash(hash, strict=false) # rubocop:disable Style/OptionalBooleanParameter (changing this API is unfortunately not feasible)
     raise ArgumentError.new("#{hash.inspect} provided to from_hash") if !(hash && hash.is_a?(Hash))
 
     i = @class.allocate
@@ -227,7 +227,7 @@ module T::Props::Serializable::DecoratorMethods
     source_lines = self.send(generate_source_method).split("\n")
     previous_blank = source_lines[0...line_num].rindex(&:empty?) || 0
     next_blank = line_num + (source_lines[line_num..-1]&.find_index(&:empty?) || 0)
-    context = "  " + source_lines[(previous_blank + 1)...(next_blank)].join("\n  ")
+    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:
@@ -318,7 +318,7 @@ module T::Props::Serializable::ClassMethods
   # Allocate a new instance and call {#deserialize} to load a new
   # object from a hash.
   # @return [Serializable]
-  def from_hash(hash, strict=false)
+  def from_hash(hash, strict=false) # rubocop:disable Style/OptionalBooleanParameter (changing this API is unfortunately not feasible)
     self.decorator.from_hash(hash, strict)
   end
 

data/lib/types/props/type_validation.rb

@@ -4,7 +4,7 @@
 module T::Props::TypeValidation
   include T::Props::Plugin
 
-  BANNED_TYPES = [Object, BasicObject, Kernel]
+  BANNED_TYPES = [Object, BasicObject, Kernel].freeze
 
   class UnderspecifiedType < ArgumentError; end
 
@@ -13,7 +13,7 @@ module T::Props::TypeValidation
 
     sig {params(key: Symbol).returns(T::Boolean).checked(:never)}
     def valid_rule_key?(key)
-      super || :DEPRECATED_underspecified_type == key
+      super || key == :DEPRECATED_underspecified_type
     end
 
     sig do

data/lib/types/types/base.rb

@@ -119,8 +119,10 @@ module T::Types
         # Default inspect behavior of, eg; `#<Object:0x0...>` is ugly; just print the hash instead, which is more concise/readable.
         if obj.method(:inspect).owner == Kernel
           "type #{obj.class} with hash #{obj.hash}"
-        else
+        elsif T::Configuration.include_value_in_type_errors?
           "type #{obj.class} with value #{T::Utils.string_truncate_middle(obj.inspect, 30, 30)}"
+        else
+          "type #{obj.class}"
         end
       rescue StandardError, SystemStackError
         "type #{obj.class} with unprintable value"

data/lib/types/types/fixed_hash.rb

@@ -8,7 +8,7 @@ module T::Types
     attr_reader :types
 
     def initialize(types)
-      @types = types.each_with_object({}) {|(k, v), h| h[k] = T::Utils.coerce(v)}
+      @types = types.transform_values {|v| T::Utils.coerce(v)}
     end
 
     # @override Base

data/lib/types/types/type_variable.rb

@@ -7,7 +7,7 @@ module T::Types
   class TypeVariable < Base
     attr_reader :variance
 
-    VALID_VARIANCES = [:in, :out, :invariant]
+    VALID_VARIANCES = %i[in out invariant].freeze
 
     def initialize(variance)
       if !VALID_VARIANCES.include?(variance)

data/lib/types/types/typed_enumerable.rb

@@ -37,7 +37,7 @@ module T::Types
             return false unless @type.recursively_valid?(obj[it])
             it += 1
           end
-          return true
+          true
         end
       when Hash
         return false unless @type.is_a?(FixedArray)
@@ -50,10 +50,10 @@ module T::Types
           # iterate over a [key, value] array, so we can't juse use the @type.recursively_valid?(v)
           return false if !key_type.recursively_valid?(key) || !value_type.recursively_valid?(val)
         end
-        return true
+        true
       when Enumerator
         # Enumerators can be unbounded: see `[:foo, :bar].cycle`
-        return true
+        true
       when Range
         # A nil beginning or a nil end does not provide any type information. That is, nil in a range represents
         # boundlessness, it does not express a type. For example `(nil...nil)` is not a T::Range[NilClass], its a range
@@ -65,7 +65,7 @@ module T::Types
           return false unless @type.recursively_valid?(item)
         end
 
-        return true
+        true
       else
         # We don't check the enumerable since it isn't guaranteed to be
         # rewindable (e.g. STDIN) and it may be expensive to enumerate

data/lib/types/utils.rb

@@ -176,7 +176,7 @@ module T::Utils
     def self.get_type_info(prop_type)
       if prop_type.is_a?(T::Types::Union)
         non_nilable_type = T::Utils.unwrap_nilable(prop_type)
-        if non_nilable_type && non_nilable_type.is_a?(T::Types::Simple)
+        if non_nilable_type&.is_a?(T::Types::Simple)
           non_nilable_type = non_nilable_type.raw_type
         end
         TypeInfo.new(true, non_nilable_type)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.5942
+  version: 0.5.6198
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-09 00:00:00.000000000 Z
+date: 2021-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -210,7 +210,6 @@ files:
 - lib/types/props/type_validation.rb
 - lib/types/props/utils.rb
 - lib/types/props/weak_constructor.rb
-- lib/types/runtime_profiled.rb
 - lib/types/sig.rb
 - lib/types/struct.rb
 - lib/types/types/attached_class.rb

data/lib/types/runtime_profiled.rb

@@ -1,24 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-#
-# From the static system, T::Utils::RuntimeProfiled is T.untyped.
-#
-# But from the runtime system, it's a random class (specifically, a class that
-# normal programs currently don't have any instances of).
-#
-# 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.
-#
-# 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.
-#
-# See also: the --suggest-runtime-profiled flag to sorbet.
-#
-
-module T; end
-module T::Utils; end
-class T::Utils::RuntimeProfiled; end