sorbet-runtime 0.5.6295 → 0.5.6483

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, :on_failure, :override_allow_incompatible, :type_parameters)
+  Declaration = Struct.new(:mod, :params, :returns, :bind, :mode, :checked, :finalized, :on_failure, :override_allow_incompatible, :type_parameters, :raw)
 
   class DeclBuilder
     attr_reader :decl
@@ -15,7 +15,7 @@ module T::Private::Methods
       end
     end
 
-    def initialize(mod)
+    def initialize(mod, raw)
       # TODO RUBYPLAT-1278 - with ruby 2.5, use kwargs here
       @decl = Declaration.new(
         mod,
@@ -28,6 +28,7 @@ module T::Private::Methods
         ARG_NOT_PROVIDED, # on_failure
         nil, # override_allow_incompatible
         ARG_NOT_PROVIDED, # type_parameters
+        raw
       )
     end
 

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

@@ -5,7 +5,8 @@ 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, :parameters, :on_failure, :override_allow_incompatible
+              :check_level, :parameters, :on_failure, :override_allow_incompatible,
+              :defined_raw
 
   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.
@@ -32,7 +33,7 @@ class T::Private::Methods::Signature
     )
   end
 
-  def initialize(method:, method_name:, raw_arg_types:, raw_return_type:, bind:, mode:, check_level:, on_failure:, parameters: method.parameters, 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, defined_raw: false)
     @method = method
     @method_name = method_name
     @arg_types = []
@@ -54,6 +55,7 @@ class T::Private::Methods::Signature
     @parameters = parameters
     @on_failure = on_failure
     @override_allow_incompatible = override_allow_incompatible
+    @defined_raw = defined_raw
 
     declared_param_names = raw_arg_types.keys
     # If sig params are declared but there is a single parameter with a missing name

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

@@ -181,7 +181,7 @@ module T::Private::Methods::SignatureValidation
     # arg types must be contravariant
     super_signature.arg_types.zip(signature.arg_types).each_with_index do |((_super_name, super_type), (name, type)), index|
       if !super_type.subtype_of?(type)
-        raise "Incompatible type for arg ##{index + 1} (`#{name}`) in #{mode_noun} of method " \
+        raise "Incompatible type for arg ##{index + 1} (`#{name}`) in signature for #{mode_noun} of method " \
               "`#{signature.method_name}`:\n" \
               "* Base: `#{super_type}` (in #{method_loc_str(super_signature.method)})\n" \
               "* #{mode_noun.capitalize}: `#{type}` (in #{method_loc_str(signature.method)})\n" \
@@ -193,7 +193,7 @@ module T::Private::Methods::SignatureValidation
     super_signature.kwarg_types.each do |name, super_type|
       type = signature.kwarg_types[name]
       if !super_type.subtype_of?(type)
-        raise "Incompatible type for arg `#{name}` in #{mode_noun} of method `#{signature.method_name}`:\n" \
+        raise "Incompatible type for arg `#{name}` in signature for #{mode_noun} of method `#{signature.method_name}`:\n" \
               "* Base: `#{super_type}` (in #{method_loc_str(super_signature.method)})\n" \
               "* #{mode_noun.capitalize}: `#{type}` (in #{method_loc_str(signature.method)})\n" \
               "(The types must be contravariant.)"
@@ -202,7 +202,7 @@ module T::Private::Methods::SignatureValidation
 
     # return types must be covariant
     if !signature.return_type.subtype_of?(super_signature.return_type)
-      raise "Incompatible return type in #{mode_noun} of method `#{signature.method_name}`:\n" \
+      raise "Incompatible return type in signature for #{mode_noun} of method `#{signature.method_name}`:\n" \
             "* Base: `#{super_signature.return_type}` (in #{method_loc_str(super_signature.method)})\n" \
             "* #{mode_noun.capitalize}: `#{signature.return_type}` (in #{method_loc_str(signature.method)})\n" \
             "(The types must be covariant.)"

data/lib/types/props/decorator.rb

@@ -449,8 +449,11 @@ class T::Props::Decorator
 
     @class.send(:define_method, redacted_method) do
       value = self.public_send(prop_name)
-      Chalk::Tools::RedactionUtils.redact_with_directive(
-        value, redaction)
+      handler = T::Configuration.redaction_handler
+      if !handler
+        raise "Using `redaction:` on a prop requires specifying `T::Configuration.redaction_handler`"
+      end
+      handler.call(value, redaction)
     end
   end
 

data/lib/types/props/generated_code_validation.rb

@@ -162,7 +162,16 @@ module T::Props
         exceptions.children.each {|c| assert_equal(:const, c.type)}
         assert_equal(:lvasgn, assignment.type)
         assert_equal([:e], assignment.children)
-        validate_lack_of_side_effects(handler, whitelisted_methods_for_deserialize)
+
+        deserialization_error, val_return = handler.children
+
+        assert_equal(:send, deserialization_error.type)
+        receiver, method, *args = deserialization_error.children
+        assert_equal(nil, receiver)
+        assert_equal(:raise_deserialization_error, method)
+        args.each {|a| validate_lack_of_side_effects(a, whitelisted_methods_for_deserialize)}
+
+        validate_lack_of_side_effects(val_return, whitelisted_methods_for_deserialize)
       else
         validate_lack_of_side_effects(else_body, whitelisted_methods_for_deserialize)
       end
@@ -261,7 +270,7 @@ module T::Props
     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],
+        const: %i[deserialize from_hash deep_clone_object],
       }
     end
   end

data/lib/types/props/has_lazily_specialized_methods.rb

@@ -48,6 +48,11 @@ module T::Props
         @lazily_defined_methods ||= {}
       end
 
+      sig {returns(T::Hash[Symbol, T.untyped]).checked(:never)}
+      private def lazily_defined_vm_methods
+        @lazily_defined_vm_methods ||= {}
+      end
+
       sig {params(name: Symbol).void}
       private def eval_lazily_defined_method!(name)
         if !HasLazilySpecializedMethods.lazy_evaluation_enabled?
@@ -61,6 +66,18 @@ module T::Props
         cls.send(:private, name)
       end
 
+      sig {params(name: Symbol).void}
+      private def eval_lazily_defined_vm_method!(name)
+        if !HasLazilySpecializedMethods.lazy_evaluation_enabled?
+          raise SourceEvaluationDisabled.new
+        end
+
+        lazily_defined_vm_methods.fetch(name).call
+
+        cls = decorated_class
+        cls.send(:private, name)
+      end
+
       sig {params(name: Symbol, blk: T.proc.returns(String)).void}
       private def enqueue_lazy_method_definition!(name, &blk)
         lazily_defined_methods[name] = blk
@@ -76,6 +93,21 @@ module T::Props
         cls.send(:private, name)
       end
 
+      sig {params(name: Symbol, blk: T.untyped).void}
+      private def enqueue_lazy_vm_method_definition!(name, &blk)
+        lazily_defined_vm_methods[name] = blk
+
+        cls = decorated_class
+        cls.send(:define_method, name) do |*args|
+          self.class.decorator.send(:eval_lazily_defined_vm_method!, name)
+          send(name, *args)
+        end
+        if cls.respond_to?(:ruby2_keywords, true)
+          cls.send(:ruby2_keywords, name)
+        end
+        cls.send(:private, name)
+      end
+
       sig {void}
       def eagerly_define_lazy_methods!
         return if lazily_defined_methods.empty?
@@ -87,6 +119,17 @@ module T::Props
         lazily_defined_methods.each_key {|name| cls.send(:private, name)}
         lazily_defined_methods.clear
       end
+
+      sig {void}
+      def eagerly_define_lazy_vm_methods!
+        return if lazily_defined_vm_methods.empty?
+
+        lazily_defined_vm_methods.values.map(&:call)
+
+        cls = decorated_class
+        lazily_defined_vm_methods.each_key {|name| cls.send(:private, name)}
+        lazily_defined_vm_methods.clear
+      end
     end
   end
 end

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

@@ -57,15 +57,10 @@ module T::Props
               begin
                 #{transformation}
               rescue NoMethodError => e
-                T::Configuration.soft_assert_handler(
-                  'Deserialization error (probably unexpected stored type)',
-                  storytime: {
-                    klass: self.class,
-                    prop: #{prop.inspect},
-                    value: val,
-                    error: e.message,
-                    notify: 'djudd'
-                  }
+                raise_deserialization_error(
+                  #{prop.inspect},
+                  val,
+                  e,
                 )
                 val
               end

data/lib/types/props/serializable.rb

@@ -156,6 +156,19 @@ module T::Props::Serializable
     @_required_props_missing_from_deserialize << prop
     nil
   end
+
+  private def raise_deserialization_error(prop_name, value, orig_error)
+    T::Configuration.soft_assert_handler(
+      'Deserialization error (probably unexpected stored type)',
+      storytime: {
+        klass: self.class,
+        prop: prop_name,
+        value: value,
+        error: orig_error.message,
+        notify: 'djudd'
+      }
+    )
+  end
 end
 
 
@@ -201,8 +214,13 @@ module T::Props::Serializable::DecoratorMethods
     rules[:serialized_form] = rules.fetch(:name, prop.to_s)
     res = super
     prop_by_serialized_forms[rules[:serialized_form]] = prop
-    enqueue_lazy_method_definition!(:__t_props_generated_serialize) {generate_serialize_source}
-    enqueue_lazy_method_definition!(:__t_props_generated_deserialize) {generate_deserialize_source}
+    if T::Configuration.use_vm_prop_serde?
+      enqueue_lazy_vm_method_definition!(:__t_props_generated_serialize) {generate_serialize2}
+      enqueue_lazy_vm_method_definition!(:__t_props_generated_deserialize) {generate_deserialize2}
+    else
+      enqueue_lazy_method_definition!(:__t_props_generated_serialize) {generate_serialize_source}
+      enqueue_lazy_method_definition!(:__t_props_generated_deserialize) {generate_deserialize_source}
+    end
     res
   end
 
@@ -217,6 +235,18 @@ module T::Props::Serializable::DecoratorMethods
     )
   end
 
+  private def generate_serialize2
+    T::Props::Private::SerializerGenerator.generate2(decorated_class, props)
+  end
+
+  private def generate_deserialize2
+    T::Props::Private::DeserializerGenerator.generate2(
+      decorated_class,
+      props,
+      props_with_defaults || {},
+    )
+  end
+
   def message_with_generated_source_context(error, generated_method, generate_source_method)
     line_label = error.backtrace.find {|l| l.end_with?("in `#{generated_method}'")}
     return unless line_label

data/lib/types/sig.rb

@@ -25,6 +25,6 @@ module T::Sig
   # {T::Helpers}
   T::Sig::WithoutRuntime.sig {params(arg0: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
   def sig(arg0=nil, &blk)
-    T::Private::Methods.declare_sig(self, arg0, &blk)
+    T::Private::Methods.declare_sig(self, Kernel.caller_locations(1, 1)&.first, arg0, &blk)
   end
 end

data/lib/types/types/fixed_hash.rb

@@ -2,7 +2,7 @@
 # typed: true
 
 module T::Types
-  # Takes a hash of types. Validates each item in an hash using the type in the same position
+  # Takes a hash of types. Validates each item in a hash using the type in the same position
   # in the list.
   class FixedHash < Base
     attr_reader :types
@@ -13,7 +13,15 @@ module T::Types
 
     # @override Base
     def name
-      "{#{@types.map {|(k, v)| "#{k}: #{v}"}.join(', ')}}"
+      entries = @types.map do |(k, v)|
+        if Symbol === k && ":#{k}" == k.inspect
+          "#{k}: #{v}"
+        else
+          "#{k.inspect} => #{v}"
+        end
+      end
+
+      "{#{entries.join(', ')}}"
     end
 
     # @override Base

data/lib/types/types/simple.rb

@@ -41,11 +41,26 @@ module T::Types
     module Private
       module Pool
         def self.type_for_module(mod)
-          cached = mod.instance_variable_get(:@__as_sorbet_simple_type)
+          cached = mod.instance_variable_get(:@__as_sorbet_type)
           return cached if cached
 
-          type = Simple.new(mod)
-          mod.instance_variable_set(:@__as_sorbet_simple_type, type) unless mod.frozen?
+          type = if mod == ::Array
+            T::Array[T.untyped]
+          elsif mod == ::Set
+            T::Set[T.untyped]
+          elsif mod == ::Hash
+            T::Hash[T.untyped, T.untyped]
+          elsif mod == ::Enumerable
+            T::Enumerable[T.untyped]
+          elsif mod == ::Enumerator
+            T::Enumerator[T.untyped]
+          elsif mod == ::Range
+            T::Range[T.untyped]
+          else
+            Simple.new(mod)
+          end
+
+          mod.instance_variable_set(:@__as_sorbet_type, type) unless mod.frozen?
           type
         end
       end

data/lib/types/types/typed_enumerable.rb

@@ -150,7 +150,11 @@ module T::Types
         obj.class
       else
         # This is a specialized enumerable type, just return the class.
-        Object.instance_method(:class).bind(obj).call
+        if T::Configuration::AT_LEAST_RUBY_2_7
+          Object.instance_method(:class).bind_call(obj)
+        else
+          Object.instance_method(:class).bind(obj).call
+        end
       end
     end
 

data/lib/types/types/union.rb

@@ -8,12 +8,12 @@ module T::Types
 
     def initialize(types)
       @types = types.flat_map do |type|
-        type = T::Utils.resolve_alias(type)
+        type = T::Utils.coerce(type)
         if type.is_a?(Union)
           # Simplify nested unions (mostly so `name` returns a nicer value)
           type.types
         else
-          T::Utils.coerce(type)
+          type
         end
       end.uniq
     end

data/lib/types/utils.rb

@@ -8,18 +8,6 @@ module T::Utils
       val.aliased_type
     elsif val.is_a?(T::Types::Base)
       val
-    elsif val == ::Array
-      T::Array[T.untyped]
-    elsif val == ::Set
-      T::Set[T.untyped]
-    elsif val == ::Hash
-      T::Hash[T.untyped, T.untyped]
-    elsif val == ::Enumerable
-      T::Enumerable[T.untyped]
-    elsif val == ::Enumerator
-      T::Enumerator[T.untyped]
-    elsif val == ::Range
-      T::Range[T.untyped]
     elsif val.is_a?(Module)
       T::Types::Simple::Private::Pool.type_for_module(val)
     elsif val.is_a?(::Array)
@@ -52,6 +40,13 @@ module T::Utils
     end.uniq
   end
 
+  # Returns the signature for the `UnboundMethod`, or nil if it's not sig'd
+  #
+  # @example T::Utils.signature_for_method(x.method(:foo))
+  def self.signature_for_method(method)
+    T::Private::Methods.signature_for_method(method)
+  end
+
   # Returns the signature for the instance method on the supplied module, or nil if it's not found or not typed.
   #
   # @example T::Utils.signature_for_instance_method(MyClass, :my_method)
@@ -84,10 +79,12 @@ module T::Utils
     case type
     when T::Types::Union
       non_nil_types = type.types.reject {|t| t == Nilable::NIL_TYPE}
-      if non_nil_types.length == 1
-        non_nil_types.first
+      return nil if type.types.length == non_nil_types.length
+      case non_nil_types.length
+      when 0 then nil
+      when 1 then non_nil_types.first
       else
-        nil
+        T::Types::Union::Private::Pool.union_of_types(non_nil_types[0], non_nil_types[1], non_nil_types[2..-1])
       end
     else
       nil

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.6295
+  version: 0.5.6483
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-23 00:00:00.000000000 Z
+date: 2021-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -177,6 +177,8 @@ files:
 - lib/types/private/final.rb
 - lib/types/private/methods/_methods.rb
 - lib/types/private/methods/call_validation.rb
+- lib/types/private/methods/call_validation_2_6.rb
+- lib/types/private/methods/call_validation_2_7.rb
 - lib/types/private/methods/decl_builder.rb
 - lib/types/private/methods/modes.rb
 - lib/types/private/methods/signature.rb
@@ -189,7 +191,6 @@ files:
 - lib/types/private/types/string_holder.rb
 - lib/types/private/types/type_alias.rb
 - lib/types/private/types/void.rb
-- lib/types/profile.rb
 - lib/types/props/_props.rb
 - lib/types/props/constructor.rb
 - lib/types/props/custom_type.rb
@@ -257,7 +258,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Sorbet runtime