sorbet-runtime 0.4.4788 → 0.5.5400

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31271303dfeb98e19ae3042f9c577f080415b592e005a407be7dab657cae0f77
-  data.tar.gz: 10ebdce3b1e460c9a95b6144e0b0662f98eb77574eb586a1d248c38c91e01b73
+  metadata.gz: f4f9fd0690e5e4161f08d170c0ad34c991b419d7718cb6d3cc3db90036c35387
+  data.tar.gz: acd9cfcc9cca1df5271b927d2dd85ffa0276337276a0df1ee522fe0c55dde9a4
 SHA512:
-  metadata.gz: '0027993a7fa1be8694fd2eb2b0b3c64978430bb6d44b91a54ebd8922cbab1a9b40b4ecab04f8d3331acfded84873e49926b6930be53acbd565f418c34e817484'
-  data.tar.gz: 89c69d15484d2f69df868ab465dc8085c1123adae026b1678c28b268211c0b2eb80ef991af6b930572a2c0113fc8bc165e3aba1138d7af187c1487aa79aa2632
+  metadata.gz: c9935807087e676840c09e8e2c43b4c3bc25639264bb8ed793a0e677fce16742db55a14362a39e701da6e63b130ffa1213717e755a98695db849dc1c5ba9dcd5
+  data.tar.gz: b0ee575a179bb1a6da3a10d3f40a16e27a94f739c28ca47bd174b9f7c854d90e5a5085bea444d715f1dc4fa12ffef98cdc98166c2af962ac06c5ff27dce0f911

data/lib/sorbet-runtime.rb

@@ -24,7 +24,6 @@ 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/error_handler'
 require_relative 'types/private/runtime_levels'
 require_relative 'types/private/methods/_methods'
 require_relative 'types/sig'
@@ -43,9 +42,10 @@ require_relative 'types/types/fixed_hash'
 require_relative 'types/types/intersection'
 require_relative 'types/types/noreturn'
 require_relative 'types/types/proc'
+require_relative 'types/types/attached_class'
 require_relative 'types/types/self_type'
 require_relative 'types/types/simple'
-require_relative 'types/types/opus_enum'
+require_relative 'types/types/t_enum'
 require_relative 'types/types/type_parameter'
 require_relative 'types/types/typed_array'
 require_relative 'types/types/typed_enumerator'
@@ -57,6 +57,7 @@ require_relative 'types/types/untyped'
 require_relative 'types/private/types/not_typed'
 require_relative 'types/private/types/void'
 require_relative 'types/private/types/string_holder'
+require_relative 'types/private/types/type_alias'
 
 require_relative 'types/types/type_variable'
 require_relative 'types/types/type_member'
@@ -91,13 +92,17 @@ require_relative 'types/props/decorator'
 require_relative 'types/props/errors'
 require_relative 'types/props/plugin'
 require_relative 'types/props/utils'
+require_relative 'types/enum'
 # Props that run sigs statically so have to be after all the others :(
+require_relative 'types/props/private/setter_factory'
+require_relative 'types/props/private/apply_default'
 require_relative 'types/props/optional'
 require_relative 'types/props/weak_constructor'
 require_relative 'types/props/constructor'
 require_relative 'types/props/pretty_printable'
 require_relative 'types/props/serializable'
 require_relative 'types/props/type_validation'
+
 require_relative 'types/struct'
 
 require_relative 'types/compatibility_patches'

data/lib/types/_types.rb

@@ -65,6 +65,11 @@ module T
     T::Types::SelfType.new
   end
 
+  # Matches the instance type in a singleton-class context
+  def self.attached_class
+    T::Types::AttachedClassType.new
+  end
+
   # Matches any class that subclasses or includes the provided class
   # or module
   def self.class_of(klass)
@@ -75,11 +80,11 @@ module T
   ## END OF THE METHODS TO PASS TO `sig`.
 
 
-  # Constructs a type alias. Used to create a short name for a larger
-  # type. In Ruby this is just equivalent to assignment, but this is
-  # needed for support by the static checker. Example usage:
+  # Constructs a type alias. Used to create a short name for a larger type. In Ruby this returns a
+  # wrapper that contains a proc that is evaluated to get the underlying type. This syntax however
+  # is needed for support by the static checker. Example usage:
   #
-  #  NilableString = T.type_alias(T.nilable(String))
+  #  NilableString = T.type_alias {T.nilable(String)}
   #
   #  sig {params(arg: NilableString, default: String).returns(String)}
   #  def or_else(arg, default)
@@ -88,8 +93,14 @@ module T
   #
   # The name of the type alias is not preserved; Error messages will
   # be printed with reference to the underlying type.
-  def self.type_alias(type)
-    T::Utils.coerce(type)
+  #
+  # TODO Remove `type` parameter. This was left in to make life easier while migrating.
+  def self.type_alias(type=nil, &blk)
+    if blk
+      T::Private::Types::TypeAlias.new(blk)
+    else
+      T::Utils.coerce(type)
+    end
   end
 
   # References a type paramater which was previously defined with
@@ -270,8 +281,5 @@ module T
       end
     end
   end
-
-  # When mixed into a module, indicates that Sorbet may export the CFG for methods in that module
-  module CFGExport; end
 end
 # rubocop:enable PrisonGuard/UseOpusTypesShortcut

data/lib/types/boolean.rb

@@ -4,5 +4,5 @@
 module T
   # T::Boolean is a type alias helper for the common `T.any(TrueClass, FalseClass)`.
   # Defined separately from _types.rb because it has a dependency on T::Types::Union.
-  Boolean = T.type_alias(T.any(TrueClass, FalseClass))
+  Boolean = T.type_alias {T.any(TrueClass, FalseClass)}
 end

data/lib/types/configuration.rb

@@ -356,6 +356,7 @@ module T::Configuration
     String
     Symbol
     Time
+    T::Enum
   }).freeze
 
   def self.scalar_types
@@ -382,6 +383,42 @@ module T::Configuration
     end
   end
 
+  def self.enable_legacy_t_enum_migration_mode
+    @legacy_t_enum_migration_mode = true
+  end
+  def self.disable_legacy_t_enum_migration_mode
+    @legacy_t_enum_migration_mode = false
+  end
+  def self.legacy_t_enum_migration_mode?
+    @legacy_t_enum_migration_mode || false
+  end
+
+  # @param [Array] sealed_violation_whitelist An array of Regexp to validate
+  #   whether inheriting /including a sealed module outside the defining module
+  #   should be allowed. Useful to whitelist benign violations, like shim files
+  #   generated for an autoloader.
+  def self.sealed_violation_whitelist=(sealed_violation_whitelist)
+    if @sealed_violation_whitelist != nil
+      raise ArgumentError.new("Cannot overwrite sealed_violation_whitelist after setting it")
+    end
+
+    case sealed_violation_whitelist
+    when Array
+      sealed_violation_whitelist.each do |x|
+        case x
+        when Regexp then nil
+        else raise TypeError.new("sealed_violation_whitelist accepts an Array of Regexp")
+        end
+      end
+    else
+      raise TypeError.new("sealed_violation_whitelist= accepts an Array of Regexp")
+    end
+
+    @sealed_violation_whitelist = sealed_violation_whitelist
+  end
+  def self.sealed_violation_whitelist
+    @sealed_violation_whitelist
+  end
 
   private_class_method def self.validate_lambda_given!(value)
     if !value.nil? && !value.respond_to?(:call)

data/lib/types/enum.rb

@@ -0,0 +1,358 @@
+# frozen_string_literal: true
+# typed: strict
+
+# Enumerations allow for type-safe declarations of a fixed set of values.
+#
+# Every value is a singleton instance of the class (i.e. `Suit::SPADE.is_a?(Suit) == true`).
+#
+# Each value has a corresponding serialized value. By default this is the constant's name converted
+# to lowercase (e.g. `Suit::Club.serialize == 'club'`); however a custom value may be passed to the
+# constructor. Enum will `freeze` the serialized value.
+#
+# @example Declaring an Enum:
+#   class Suit < T::Enum
+#     enums do
+#       CLUB = new
+#       SPADE = new
+#       DIAMOND = new
+#       HEART = new
+#     end
+#   end
+#
+# @example Custom serialization value:
+#   class Status < T::Enum
+#     enums do
+#       READY = new('rdy')
+#       ...
+#     end
+#   end
+#
+# @example Accessing values:
+#   Suit::SPADE
+#
+# @example Converting from serialized value to enum instance:
+#   Suit.deserialize('club') == Suit::CLUB
+#
+# @example Using enums in type signatures:
+#   sig {params(suit: Suit).returns(Boolean)}
+#   def is_red?(suit); ...; end
+#
+# WARNING: Enum instances are singletons that are shared among all their users. Their internals
+# should be kept immutable to avoid unpredictable action at a distance.
+class T::Enum
+  extend T::Sig
+  extend T::Props::CustomType
+
+  # TODO(jez) Might want to restrict this, or make subclasses provide this type
+  SerializedVal = T.type_alias {T.untyped}
+  private_constant :SerializedVal
+
+  ## Enum class methods ##
+  sig {returns(T::Array[T.attached_class])}
+  def self.values
+    if @values.nil?
+      raise "Attempting to access values of #{self.class} before it has been initialized." \
+        " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+    end
+    @values
+  end
+
+  # Convert from serialized value to enum instance
+  #
+  # Note: It would have been nice to make this method final before people started overriding it.
+  # Note: Failed CriticalMethodsNoRuntimeTypingTest
+  sig {params(serialized_val: SerializedVal).returns(T.nilable(T.attached_class)).checked(:never)}
+  def self.try_deserialize(serialized_val)
+    if @mapping.nil?
+      raise "Attempting to access serialization map of #{self.class} before it has been initialized." \
+        " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+    end
+    @mapping[serialized_val]
+  end
+
+  # Convert from serialized value to enum instance.
+  #
+  # Note: It would have been nice to make this method final before people started overriding it.
+  # Note: Failed CriticalMethodsNoRuntimeTypingTest
+  #
+  # @return [self]
+  # @raise [KeyError] if serialized value does not match any instance.
+  sig {overridable.params(serialized_val: SerializedVal).returns(T.attached_class).checked(:never)}
+  def self.from_serialized(serialized_val)
+    res = try_deserialize(serialized_val)
+    if res.nil?
+      raise KeyError.new("Enum #{self} key not found: #{serialized_val.inspect}")
+    end
+    res
+  end
+
+  # Note: It would have been nice to make this method final before people started overriding it.
+  # @return [Boolean] Does the given serialized value correspond with any of this enum's values.
+  sig {overridable.params(serialized_val: SerializedVal).returns(T::Boolean)}
+  def self.has_serialized?(serialized_val)
+    if @mapping.nil?
+      raise "Attempting to access serialization map of #{self.class} before it has been initialized." \
+        " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+    end
+    @mapping.include?(serialized_val)
+  end
+
+
+  ## T::Props::CustomType
+
+  # Note: Failed CriticalMethodsNoRuntimeTypingTest
+  sig {params(value: T.untyped).returns(T::Boolean).checked(:never)}
+  def self.instance?(value)
+    value.is_a?(self)
+  end
+
+  # Note: Failed CriticalMethodsNoRuntimeTypingTest
+  sig {params(instance: T.nilable(T::Enum)).returns(SerializedVal).checked(:never)}
+  def self.serialize(instance)
+    # This is needed otherwise if a Chalk::ODM::Document with a property of the shape
+    # T::Hash[T.nilable(MyEnum), Integer] and a value that looks like {nil => 0} is
+    # serialized, we throw the error on L102.
+    return nil if instance.nil?
+
+    if self == T::Enum
+      raise "Cannot call T::Enum.serialize directly. You must call on a specific child class."
+    end
+    if instance.class != self
+      raise "Cannot call #serialize on a value that is not an instance of #{self}."
+    end
+    instance.serialize
+  end
+
+  # Note: Failed CriticalMethodsNoRuntimeTypingTest
+  sig {params(mongo_value: SerializedVal).returns(T.attached_class).checked(:never)}
+  def self.deserialize(mongo_value)
+    if self == T::Enum
+      raise "Cannot call T::Enum.deserialize directly. You must call on a specific child class."
+    end
+    self.from_serialized(mongo_value)
+  end
+
+
+  ## Enum instance methods ##
+
+
+  sig {returns(T.self_type)}
+  def dup
+    self
+  end
+
+  sig {returns(T.self_type).checked(:tests)}
+  def clone
+    self
+  end
+
+  # Note: Failed CriticalMethodsNoRuntimeTypingTest
+  sig {returns(SerializedVal).checked(:never)}
+  def serialize
+    assert_bound!
+    @serialized_val
+  end
+
+  sig {params(args: T.untyped).returns(T.untyped)}
+  def to_json(*args)
+    serialize.to_json(*args)
+  end
+
+  sig {returns(String)}
+  def to_s
+    inspect
+  end
+
+  sig {returns(String)}
+  def inspect
+    "#<#{self.class.name}::#{@const_name || '__UNINITIALIZED__'}>"
+  end
+
+  sig {params(other: BasicObject).returns(T.nilable(Integer))}
+  def <=>(other)
+    case other
+    when self.class
+      self.serialize <=> other.serialize
+    else
+      nil
+    end
+  end
+
+
+  # NB: Do not call this method. This exists to allow for a safe migration path in places where enum
+  # values are compared directly against string values.
+  #
+  # Ruby's string has a weird quirk where `'my_string' == obj` calls obj.==('my_string') if obj
+  # responds to the `to_str` method. It does not actually call `to_str` however.
+  #
+  # See https://ruby-doc.org/core-2.4.0/String.html#method-i-3D-3D
+  sig {returns(String)}
+  def to_str
+    msg = 'Implicit conversion of Enum instances to strings is not allowed. Call #serialize instead.'
+    if T::Configuration.legacy_t_enum_migration_mode?
+      T::Configuration.soft_assert_handler(
+        msg,
+        storytime: {class: self.class.name},
+      )
+      serialize.to_s
+    else
+      raise NoMethodError.new(msg)
+    end
+  end
+
+  sig {params(other: BasicObject).returns(T::Boolean).checked(:never)}
+  def ==(other)
+    case other
+    when String
+      if T::Configuration.legacy_t_enum_migration_mode?
+        comparison_assertion_failed(:==, other)
+        self.serialize == other
+      else
+        false
+      end
+    else
+      super(other)
+    end
+  end
+
+  sig {params(other: BasicObject).returns(T::Boolean).checked(:never)}
+  def ===(other)
+    case other
+    when String
+      if T::Configuration.legacy_t_enum_migration_mode?
+        comparison_assertion_failed(:===, other)
+        self.serialize == other
+      else
+        false
+      end
+    else
+      super(other)
+    end
+  end
+
+  sig {params(method: Symbol, other: T.untyped).void}
+  private def comparison_assertion_failed(method, other)
+    T::Configuration.soft_assert_handler(
+      'Enum to string comparison not allowed. Compare to the Enum instance directly instead. See go/enum-migration',
+      storytime: {
+        class: self.class.name,
+        self: self.inspect,
+        other: other,
+        other_class: other.class.name,
+        method: method,
+      }
+    )
+  end
+
+
+  ## Private implementation ##
+
+
+  sig {params(serialized_val: SerializedVal).void}
+  private 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'."
+    end
+    if self.class.fully_initialized?
+      raise "Cannot instantiate a new enum value of #{self.class} after it has been initialized."
+    end
+
+    serialized_val = serialized_val.frozen? ? serialized_val : serialized_val.dup.freeze
+    @serialized_val = T.let(serialized_val, T.nilable(SerializedVal))
+    @const_name = T.let(nil, T.nilable(Symbol))
+    self.class._register_instance(self)
+  end
+
+  sig {returns(NilClass).checked(:never)}
+  private def assert_bound!
+    if @const_name.nil?
+      raise "Attempting to access Enum value on #{self.class} before it has been initialized." \
+        " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+    end
+  end
+
+  sig {params(const_name: Symbol).void}
+  def _bind_name(const_name)
+    @const_name = const_name
+    @serialized_val = const_to_serialized_val(const_name) if @serialized_val.nil?
+    freeze
+  end
+
+  sig {params(const_name: Symbol).returns(String)}
+  private def const_to_serialized_val(const_name)
+    # Historical note: We convert to lowercase names because the majority of existing calls to
+    # `make_accessible` were arrays of lowercase strings. Doing this conversion allowed for the
+    # least amount of repetition in migrated declarations.
+    const_name.to_s.downcase.freeze
+  end
+
+  sig {returns(T::Boolean)}
+  def self.started_initializing?
+    @started_initializing = T.let(@started_initializing, T.nilable(T::Boolean))
+    @started_initializing ||= false
+  end
+
+  sig {returns(T::Boolean)}
+  def self.fully_initialized?
+    @fully_initialized = T.let(@fully_initialized, T.nilable(T::Boolean))
+    @fully_initialized ||= false
+  end
+
+  # Maintains the order in which values are defined
+  sig {params(instance: T.untyped).void}
+  def self._register_instance(instance)
+    @values ||= []
+    @values << T.cast(instance, T.attached_class)
+  end
+
+  # Entrypoint for allowing people to register new enum values.
+  # All enum values must be defined within this block.
+  sig {params(blk: T.proc.void).void}
+  def self.enums(&blk)
+    raise "enums cannot be defined for T::Enum" if self == T::Enum
+    raise "Enum #{self} was already initialized" if @fully_initialized
+    raise "Enum #{self} is still initializing" if @started_initializing
+
+    @started_initializing = true
+
+    @values = T.let(nil, T.nilable(T::Array[T.attached_class]))
+
+    yield
+
+    @mapping = T.let(nil, T.nilable(T::Hash[SerializedVal, T.attached_class]))
+    @mapping = {}
+
+    # Freeze the Enum class and bind the constant names into each of the instances.
+    self.constants(false).each do |const_name|
+      instance = self.const_get(const_name, false)
+      if !instance.is_a?(self)
+        raise "Invalid constant #{self}::#{const_name} on enum. " \
+          "All constants defined for an enum must be instances itself (e.g. `Foo = new`)."
+      end
+
+      instance._bind_name(const_name)
+      serialized = instance.serialize
+      if @mapping.include?(serialized)
+        raise "Enum values must have unique serializations. Value '#{serialized}' is repeated on #{self}."
+      end
+      @mapping[serialized] = instance
+    end
+    @values.freeze
+    @mapping.freeze
+
+    orphaned_instances = T.must(@values) - @mapping.values
+    if !orphaned_instances.empty?
+      raise "Enum values must be assigned to constants: #{orphaned_instances.map {|v| v.instance_variable_get('@serialized_val')}}"
+    end
+
+    @fully_initialized = true
+  end
+
+  sig {params(child_class: Module).void}
+  def self.inherited(child_class)
+    super
+
+    raise "Inheriting from children of T::Enum is prohibited" if self != T::Enum
+  end
+end

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

@@ -302,7 +302,6 @@ module T::Private::Methods
         check_level: current_declaration.checked,
         on_failure: current_declaration.on_failure,
         override_allow_incompatible: current_declaration.override_allow_incompatible,
-        generated: current_declaration.generated,
       )
 
       SignatureValidation.validate(signature)

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

@@ -51,10 +51,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.
 
-    if method_sig.ever_failed && method_sig.generated
-      return original_method.bind(instance).call(*args, &blk)
-    end
-
     T::Profile.typecheck_sample_attempts -= 1
     should_sample = T::Profile.typecheck_sample_attempts == 0
     if should_sample
@@ -252,10 +248,6 @@ module T::Private::Methods::CallValidation
         T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
       end
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(&blk)
-      end
-
       # The following line breaks are intentional to show nice pry message
 
 
@@ -303,10 +295,6 @@ module T::Private::Methods::CallValidation
       # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(arg0, &blk)
-      end
-
       T::Profile.typecheck_sample_attempts -= 1
       should_sample = T::Profile.typecheck_sample_attempts == 0
       if should_sample
@@ -392,10 +380,6 @@ module T::Private::Methods::CallValidation
       # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(arg0, arg1, &blk)
-      end
-
       T::Profile.typecheck_sample_attempts -= 1
       should_sample = T::Profile.typecheck_sample_attempts == 0
       if should_sample
@@ -493,10 +477,6 @@ module T::Private::Methods::CallValidation
       # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(arg0, arg1, arg2, &blk)
-      end
-
       T::Profile.typecheck_sample_attempts -= 1
       should_sample = T::Profile.typecheck_sample_attempts == 0
       if should_sample
@@ -607,10 +587,6 @@ module T::Private::Methods::CallValidation
       # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(arg0, arg1, arg2, arg3, &blk)
-      end
-
       T::Profile.typecheck_sample_attempts -= 1
       should_sample = T::Profile.typecheck_sample_attempts == 0
       if should_sample
@@ -760,10 +736,6 @@ module T::Private::Methods::CallValidation
       # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(&blk)
-      end
-
       T::Profile.typecheck_sample_attempts -= 1
       should_sample = T::Profile.typecheck_sample_attempts == 0
       if should_sample
@@ -817,10 +789,6 @@ module T::Private::Methods::CallValidation
       # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(arg0, &blk)
-      end
-
       T::Profile.typecheck_sample_attempts -= 1
       should_sample = T::Profile.typecheck_sample_attempts == 0
       if should_sample
@@ -884,10 +852,6 @@ module T::Private::Methods::CallValidation
       # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(arg0, arg1, &blk)
-      end
-
       T::Profile.typecheck_sample_attempts -= 1
       should_sample = T::Profile.typecheck_sample_attempts == 0
       if should_sample
@@ -964,10 +928,6 @@ module T::Private::Methods::CallValidation
       # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(arg0, arg1, arg2, &blk)
-      end
-
       T::Profile.typecheck_sample_attempts -= 1
       should_sample = T::Profile.typecheck_sample_attempts == 0
       if should_sample
@@ -1057,10 +1017,6 @@ module T::Private::Methods::CallValidation
       # reduce number of allocations that happen here.
       # This method is a manually sped-up version of more general code in `validate_call`
 
-      if method_sig.ever_failed && method_sig.generated
-        return original_method.bind(self).call(arg0, arg1, arg2, arg3, &blk)
-      end
-
       T::Profile.typecheck_sample_attempts -= 1
       should_sample = T::Profile.typecheck_sample_attempts == 0
       if should_sample
@@ -1156,7 +1112,6 @@ module T::Private::Methods::CallValidation
   end
 
   def self.report_error(method_sig, error_message, kind, name, type, value, caller_offset: 0)
-    method_sig.mark_failed
     caller_loc = T.must(caller_locations(3 + caller_offset, 1))[0]
     definition_file, definition_line = method_sig.method.source_location