sorbet-runtime 0.5.6386 → 0.5.6395

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f43636d0022878d4f29cbae70939ce88678dad66e12157ec0e89b01b069c54bb
-  data.tar.gz: c96e93ca2a2f3dbb31aea372b525dfff900ad460194bf5d2ed5ac51f822a9381
+  metadata.gz: a3f7e712765bc8cf3eb2bb0677e1a9bc7c076ccd0a45ec264dea11fa45a0602b
+  data.tar.gz: aa45bd7ec5aa309fd5431992dd240f0558f37806b721a9f266b544492b34351c
 SHA512:
-  metadata.gz: 043b5548593afb627f357293bc57302ebfa3f9b120af6bfae466cb3fc10b2f5abb948b844aef81c4ca4a1761ee3e090a3c2f1ca66ff0fecd1fd521741c3be4f8
-  data.tar.gz: 4ae533c54e8985fcd218639498f8cbe308689bd792037651e0d03b378f187d01d32fe9198357e20c9215a0cf31d1157aba475432b2777a06debb07473139ee71
+  metadata.gz: a8ce05d54623d9e6961f5af4e8efe72a2be490c847da79719bc4dfbd38b2ddfd49a3ed24341c14b13fff4f3b32c03742788f7ee4b50ab69cf5204b2c86d4d2da
+  data.tar.gz: 421508b1b085f4d3a111a961ae56cbc2afc92c5077fa81c7560c952d92d32458172336e52091b8d1ff1aff7635e592765f526d79e7885bf97a1666a79e9b039b

data/lib/sorbet-runtime.rb

@@ -19,7 +19,6 @@ require 'set'
 
 # These are pre-reqs for almost everything in here.
 require_relative 'types/configuration'
-require_relative 'types/profile'
 require_relative 'types/_types'
 require_relative 'types/private/decl_state'
 require_relative 'types/private/class_utils'

data/lib/types/_types.rb

@@ -147,6 +147,25 @@ module T
     Private::Casts.cast(value, type, cast_method: "T.let")
   end
 
+  # Tells the type checker to treat `self` in the current block as `type`.
+  # Useful for blocks that are captured and executed later with instance_exec.
+  # Use like:
+  #
+  #  seconds = lambda do
+  #    T.bind(self, NewBinding)
+  #    ...
+  #  end
+  #
+  # `T.bind` behaves like `T.cast` in that it is assumed to be true statically.
+  #
+  # If `checked` is true, raises an exception at runtime if the value
+  # doesn't match the type (this is the default).
+  def self.bind(value, type, checked: true)
+    return value unless checked
+
+    Private::Casts.cast(value, type, cast_method: "T.bind")
+  end
+
   # Tells the typechecker to ensure that `value` is of type `type` (if not, the typechecker will
   # fail). Use this for debugging typechecking errors, or to ensure that type information is
   # statically known and being checked appropriately. If `checked` is true, raises an exception at

data/lib/types/configuration.rb

@@ -73,6 +73,27 @@ module T::Configuration
     @include_value_in_type_errors = true
   end
 
+  # Whether to use VM-defined prop serialization/deserialization routines.
+  #
+  # The default is to use runtime codegen inside sorbet-runtime itself.
+  #
+  # @return [T::Boolean]
+  def self.use_vm_prop_serde?
+    @use_vm_prop_serde || false
+  end
+
+  # Enable using VM-defined prop serialization/deserialization routines.
+  #
+  # This method is likely to break things outside of Stripe's systems.
+  def self.enable_vm_prop_serde
+    @use_vm_prop_serde = true
+  end
+
+  # Disable using VM-defined prop serialization/deserialization routines.
+  def self.disable_vm_prop_serde
+    @use_vm_prop_serde = false
+  end
+
   # Configure the default checked level for a sig with no explicit `.checked`
   # builder. When unset, the default checked level is `:always`.
   #

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

@@ -59,16 +59,22 @@ module T::Private::Methods::CallValidation
   def self.create_validator_method(mod, original_method, method_sig, original_visibility)
     has_fixed_arity = method_sig.kwarg_types.empty? && !method_sig.has_rest && !method_sig.has_keyrest &&
       original_method.parameters.all? {|(kind, _name)| kind == :req}
-    all_args_are_simple = method_sig.arg_types.all? {|_name, type| type.is_a?(T::Types::Simple)}
-    has_simple_method_types =  all_args_are_simple && method_sig.return_type.is_a?(T::Types::Simple)
-    has_simple_procedure_types = all_args_are_simple && method_sig.return_type.is_a?(T::Private::Types::Void)
+    ok_for_fast_path = has_fixed_arity && !method_sig.bind && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
+
+    all_args_are_simple = ok_for_fast_path && method_sig.arg_types.all? {|_name, type| type.is_a?(T::Types::Simple)}
+    simple_method = all_args_are_simple && method_sig.return_type.is_a?(T::Types::Simple)
+    simple_procedure = all_args_are_simple && method_sig.return_type.is_a?(T::Private::Types::Void)
 
     T::Configuration.without_ruby_warnings do
       T::Private::DeclState.current.without_on_method_added do
-        if has_fixed_arity && has_simple_method_types && !method_sig.bind && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
+        if simple_method
           create_validator_method_fast(mod, original_method, method_sig)
-        elsif has_fixed_arity && has_simple_procedure_types && !method_sig.bind && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
+        elsif simple_procedure
           create_validator_procedure_fast(mod, original_method, method_sig)
+        elsif ok_for_fast_path && method_sig.return_type.is_a?(T::Private::Types::Void)
+          create_validator_procedure_medium(mod, original_method, method_sig)
+        elsif ok_for_fast_path
+          create_validator_method_medium(mod, original_method, method_sig)
         else
           create_validator_slow(mod, original_method, method_sig)
         end
@@ -90,14 +96,6 @@ module T::Private::Methods::CallValidation
     # This method is called for every `sig`. It's critical to keep it fast and
     # reduce number of allocations that happen here.
 
-    T::Profile.typecheck_sample_attempts -= 1
-    should_sample = T::Profile.typecheck_sample_attempts == 0
-    if should_sample
-      T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-      T::Profile.typecheck_samples += 1
-      t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    end
-
     if method_sig.bind
       message = method_sig.bind.error_message_for_obj(instance)
       if message
@@ -143,10 +141,6 @@ module T::Private::Methods::CallValidation
       end
     end
 
-    if should_sample
-      T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-    end
-
     # The following line breaks are intentional to show nice pry message
 
 
@@ -163,9 +157,6 @@ module T::Private::Methods::CallValidation
     # Please issue `finish` to step out of it
 
     return_value = T::Configuration::AT_LEAST_RUBY_2_7 ? original_method.bind_call(instance, *args, &blk) : original_method.bind(instance).call(*args, &blk)
-    if should_sample
-      t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    end
 
     # The only type that is allowed to change the return value is `.void`.
     # It ignores what you returned and changes it to be a private singleton.
@@ -183,9 +174,6 @@ module T::Private::Methods::CallValidation
           return_value,
         )
       end
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
       return_value
     end
   end

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

@@ -38,21 +38,7 @@ module T::Private::Methods::CallValidation
 
   def self.create_validator_method_fast0(mod, original_method, method_sig, return_type)
     mod.send(:define_method, method_sig.method_name) do |&blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-
       # The following line breaks are intentional to show nice pry message
 
 
@@ -69,10 +55,6 @@ module T::Private::Methods::CallValidation
       # Please issue `finish` to step out of it
 
       return_value = original_method.bind(self).call(&blk)
-      if should_sample
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
       unless return_value.is_a?(return_type)
         message = method_sig.return_type.error_message_for_obj(return_value)
         if message
@@ -87,26 +69,13 @@ module T::Private::Methods::CallValidation
           )
         end
       end
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
       return_value
     end
   end
 
   def self.create_validator_method_fast1(mod, original_method, method_sig, return_type, arg0_type)
     mod.send(:define_method, method_sig.method_name) do |arg0, &blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
       unless arg0.is_a?(arg0_type)
         CallValidation.report_error(
           method_sig,
@@ -119,10 +88,6 @@ module T::Private::Methods::CallValidation
         )
       end
 
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-
       # The following line breaks are intentional to show nice pry message
 
 
@@ -139,10 +104,6 @@ module T::Private::Methods::CallValidation
       # Please issue `finish` to step out of it
 
       return_value = original_method.bind(self).call(arg0, &blk)
-      if should_sample
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
       unless return_value.is_a?(return_type)
         message = method_sig.return_type.error_message_for_obj(return_value)
         if message
@@ -157,26 +118,13 @@ module T::Private::Methods::CallValidation
           )
         end
       end
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
       return_value
     end
   end
 
   def self.create_validator_method_fast2(mod, original_method, method_sig, return_type, arg0_type, arg1_type)
     mod.send(:define_method, method_sig.method_name) do |arg0, arg1, &blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
       unless arg0.is_a?(arg0_type)
         CallValidation.report_error(
           method_sig,
@@ -201,10 +149,6 @@ module T::Private::Methods::CallValidation
         )
       end
 
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-
       # The following line breaks are intentional to show nice pry message
 
 
@@ -221,10 +165,6 @@ module T::Private::Methods::CallValidation
       # Please issue `finish` to step out of it
 
       return_value = original_method.bind(self).call(arg0, arg1, &blk)
-      if should_sample
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
       unless return_value.is_a?(return_type)
         message = method_sig.return_type.error_message_for_obj(return_value)
         if message
@@ -239,26 +179,13 @@ module T::Private::Methods::CallValidation
           )
         end
       end
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
       return_value
     end
   end
 
   def self.create_validator_method_fast3(mod, original_method, method_sig, return_type, arg0_type, arg1_type, arg2_type)
     mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, &blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
       unless arg0.is_a?(arg0_type)
         CallValidation.report_error(
           method_sig,
@@ -295,10 +222,6 @@ module T::Private::Methods::CallValidation
         )
       end
 
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-
       # The following line breaks are intentional to show nice pry message
 
 
@@ -315,10 +238,6 @@ module T::Private::Methods::CallValidation
       # Please issue `finish` to step out of it
 
       return_value = original_method.bind(self).call(arg0, arg1, arg2, &blk)
-      if should_sample
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
       unless return_value.is_a?(return_type)
         message = method_sig.return_type.error_message_for_obj(return_value)
         if message
@@ -333,26 +252,13 @@ module T::Private::Methods::CallValidation
           )
         end
       end
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
       return_value
     end
   end
 
   def self.create_validator_method_fast4(mod, original_method, method_sig, return_type, arg0_type, arg1_type, arg2_type, arg3_type)
     mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, arg3, &blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
       unless arg0.is_a?(arg0_type)
         CallValidation.report_error(
           method_sig,
@@ -401,10 +307,6 @@ module T::Private::Methods::CallValidation
         )
       end
 
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-
       # The following line breaks are intentional to show nice pry message
 
 
@@ -421,10 +323,6 @@ module T::Private::Methods::CallValidation
       # Please issue `finish` to step out of it
 
       return_value = original_method.bind(self).call(arg0, arg1, arg2, arg3, &blk)
-      if should_sample
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
       unless return_value.is_a?(return_type)
         message = method_sig.return_type.error_message_for_obj(return_value)
         if message
@@ -439,9 +337,6 @@ module T::Private::Methods::CallValidation
           )
         end
       end
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
       return_value
     end
   end
@@ -475,21 +370,7 @@ module T::Private::Methods::CallValidation
 
   def self.create_validator_procedure_fast0(mod, original_method, method_sig)
     mod.send(:define_method, method_sig.method_name) do |&blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-
       # The following line breaks are intentional to show nice pry message
 
 
@@ -512,17 +393,7 @@ module T::Private::Methods::CallValidation
 
   def self.create_validator_procedure_fast1(mod, original_method, method_sig, arg0_type)
     mod.send(:define_method, method_sig.method_name) do |arg0, &blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
       unless arg0.is_a?(arg0_type)
         CallValidation.report_error(
           method_sig,
@@ -535,10 +406,6 @@ module T::Private::Methods::CallValidation
         )
       end
 
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-
       # The following line breaks are intentional to show nice pry message
 
 
@@ -561,17 +428,7 @@ module T::Private::Methods::CallValidation
 
   def self.create_validator_procedure_fast2(mod, original_method, method_sig, arg0_type, arg1_type)
     mod.send(:define_method, method_sig.method_name) do |arg0, arg1, &blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
       unless arg0.is_a?(arg0_type)
         CallValidation.report_error(
           method_sig,
@@ -596,10 +453,6 @@ module T::Private::Methods::CallValidation
         )
       end
 
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-
       # The following line breaks are intentional to show nice pry message
 
 
@@ -622,17 +475,7 @@ module T::Private::Methods::CallValidation
 
   def self.create_validator_procedure_fast3(mod, original_method, method_sig, arg0_type, arg1_type, arg2_type)
     mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, &blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
       unless arg0.is_a?(arg0_type)
         CallValidation.report_error(
           method_sig,
@@ -669,10 +512,6 @@ module T::Private::Methods::CallValidation
         )
       end
 
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-
       # The following line breaks are intentional to show nice pry message
 
 
@@ -695,17 +534,7 @@ module T::Private::Methods::CallValidation
 
   def self.create_validator_procedure_fast4(mod, original_method, method_sig, arg0_type, arg1_type, arg2_type, arg3_type)
     mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, arg3, &blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
       unless arg0.is_a?(arg0_type)
         CallValidation.report_error(
           method_sig,
@@ -754,8 +583,601 @@ module T::Private::Methods::CallValidation
         )
       end
 
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, arg1, arg2, arg3, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_method_medium(mod, original_method, method_sig)
+    if method_sig.return_type.is_a?(T::Private::Types::Void)
+      raise 'Should have used create_validator_procedure_medium'
+    end
+    # trampoline to reduce stack frame size
+    if method_sig.arg_types.empty?
+      create_validator_method_medium0(mod, original_method, method_sig, method_sig.return_type)
+    elsif method_sig.arg_types.length == 1
+      create_validator_method_medium1(mod, original_method, method_sig, method_sig.return_type,
+                                    method_sig.arg_types[0][1])
+    elsif method_sig.arg_types.length == 2
+      create_validator_method_medium2(mod, original_method, method_sig, method_sig.return_type,
+                                    method_sig.arg_types[0][1],
+                                    method_sig.arg_types[1][1])
+    elsif method_sig.arg_types.length == 3
+      create_validator_method_medium3(mod, original_method, method_sig, method_sig.return_type,
+                                    method_sig.arg_types[0][1],
+                                    method_sig.arg_types[1][1],
+                                    method_sig.arg_types[2][1])
+    elsif method_sig.arg_types.length == 4
+      create_validator_method_medium4(mod, original_method, method_sig, method_sig.return_type,
+                                    method_sig.arg_types[0][1],
+                                    method_sig.arg_types[1][1],
+                                    method_sig.arg_types[2][1],
+                                    method_sig.arg_types[3][1])
+    else
+      raise 'should not happen'
+    end
+  end
+
+  def self.create_validator_method_medium0(mod, original_method, method_sig, return_type)
+    mod.send(:define_method, method_sig.method_name) do |&blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind(self).call(&blk)
+      unless return_type.valid?(return_value)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_medium1(mod, original_method, method_sig, return_type, arg0_type)
+    mod.send(:define_method, method_sig.method_name) do |arg0, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind(self).call(arg0, &blk)
+      unless return_type.valid?(return_value)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_medium2(mod, original_method, method_sig, return_type, arg0_type, arg1_type)
+    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind(self).call(arg0, arg1, &blk)
+      unless return_type.valid?(return_value)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_medium3(mod, original_method, method_sig, return_type, arg0_type, arg1_type, arg2_type)
+    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2_type.valid?(arg2)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind(self).call(arg0, arg1, arg2, &blk)
+      unless return_type.valid?(return_value)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_medium4(mod, original_method, method_sig, return_type, arg0_type, arg1_type, arg2_type, arg3_type)
+    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, arg3, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2_type.valid?(arg2)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      unless arg3_type.valid?(arg3)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[3][1].error_message_for_obj(arg3),
+          'Parameter',
+          method_sig.arg_types[3][0],
+          arg3_type,
+          arg3,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind(self).call(arg0, arg1, arg2, arg3, &blk)
+      unless return_type.valid?(return_value)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_procedure_medium(mod, original_method, method_sig)
+    # trampoline to reduce stack frame size
+    if method_sig.arg_types.empty?
+      create_validator_procedure_medium0(mod, original_method, method_sig)
+    elsif method_sig.arg_types.length == 1
+      create_validator_procedure_medium1(mod, original_method, method_sig,
+                                    method_sig.arg_types[0][1])
+    elsif method_sig.arg_types.length == 2
+      create_validator_procedure_medium2(mod, original_method, method_sig,
+                                    method_sig.arg_types[0][1],
+                                    method_sig.arg_types[1][1])
+    elsif method_sig.arg_types.length == 3
+      create_validator_procedure_medium3(mod, original_method, method_sig,
+                                    method_sig.arg_types[0][1],
+                                    method_sig.arg_types[1][1],
+                                    method_sig.arg_types[2][1])
+    elsif method_sig.arg_types.length == 4
+      create_validator_procedure_medium4(mod, original_method, method_sig,
+                                    method_sig.arg_types[0][1],
+                                    method_sig.arg_types[1][1],
+                                    method_sig.arg_types[2][1],
+                                    method_sig.arg_types[3][1])
+    else
+      raise 'should not happen'
+    end
+  end
+
+  def self.create_validator_procedure_medium0(mod, original_method, method_sig)
+    mod.send(:define_method, method_sig.method_name) do |&blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(&blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_medium1(mod, original_method, method_sig, arg0_type)
+    mod.send(:define_method, method_sig.method_name) do |arg0, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_medium2(mod, original_method, method_sig, arg0_type, arg1_type)
+    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, arg1, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_medium3(mod, original_method, method_sig, arg0_type, arg1_type, arg2_type)
+    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2_type.valid?(arg2)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, arg1, arg2, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_medium4(mod, original_method, method_sig, arg0_type, arg1_type, arg2_type, arg3_type)
+    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, arg3, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2_type.valid?(arg2)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      unless arg3_type.valid?(arg3)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[3][1].error_message_for_obj(arg3),
+          'Parameter',
+          method_sig.arg_types[3][0],
+          arg3_type,
+          arg3,
+          caller_offset: -1
+        )
       end
 
       # The following line breaks are intentional to show nice pry message