sorbet-runtime 0.5.6386 → 0.5.6395

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.6386
+  version: 0.5.6395
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-22 00:00:00.000000000 Z
+date: 2021-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -191,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

data/lib/types/profile.rb

@@ -1,31 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module T::Profile
-  SAMPLE_RATE = 101 # 1 out of that many typechecks will be measured
-  class <<self
-    attr_accessor :typecheck_duration
-    attr_accessor :typecheck_samples
-    attr_accessor :typecheck_sample_attempts
-    def typecheck_duration_estimate
-      total_typechecks = typecheck_samples * SAMPLE_RATE + (SAMPLE_RATE - typecheck_sample_attempts)
-      typechecks_measured = typecheck_samples * SAMPLE_RATE
-      if typechecks_measured.positive?
-        typecheck_duration * SAMPLE_RATE * 1.0 * total_typechecks / typechecks_measured
-      else
-        0.0
-      end
-    end
-
-    def typecheck_count_estimate
-      typecheck_samples * SAMPLE_RATE
-    end
-
-    def reset
-      @typecheck_duration = 0
-      @typecheck_samples = 0
-      @typecheck_sample_attempts = SAMPLE_RATE
-    end
-  end
-  self.reset
-end