sorbet-runtime 0.4.4301 → 0.4.4446

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4caba5123cd2598c381ec8aee684b3ec9d836e82
-  data.tar.gz: 6a9bbf51e25f0228c8cec2f98565af5721227953
+  metadata.gz: 4a800d5e7728111e31a78225eaf32a47c00e3fed
+  data.tar.gz: e8546195bf3b79b86484089e66a78966d8cbc9ef
 SHA512:
-  metadata.gz: c57c3dca97c35bdb4b7bde004ad20e5a78d0e737f7f2a2a78e047d20feb9513fa5ed216ee083a61222c98616f4764e47b5eb16be096fb040630a666adb8d24a9
-  data.tar.gz: e88711e3451d9b31013284f577390aa41a85e1f0ad57d639471a1cb2e83da4e7256ebe4c4a6bd4ca73698fc846058791c57364d39f19011438f065cda53b5c7f
+  metadata.gz: c2cc3a61f53c8073bcbc091bb5a244059714de8ef38d4f101f5d4d626ab928cfd546a504ce6ef77d1a972b824d0fbfaffdbf11f6fd7e85b6ad8f238131fee3d2
+  data.tar.gz: 8db326b0147134aabba33d5500065d5438ed2d362fc86f90ac36c8d53318c228439ace3c4ccb194ec35d8d42991a26a63d0c2ee433867ddbd98ad9710f8abcf6

data/lib/types/_types.rb

@@ -176,21 +176,15 @@ module T
   # Intended to be used to promise sorbet that a given nilable value happens
   # to contain a non-nil value at this point.
   #
-  # sig {params(arg: T.nilable(A), msg: T.nilable(String)).returns(A)}
-  def self.must(arg, msg=nil)
+  # sig {params(arg: T.nilable(A)).returns(A)}
+  def self.must(arg)
+    return arg if arg
+    return arg if arg == false
+
     begin
-      if msg
-        if !T.unsafe(msg).is_a?(String)
-          raise TypeError.new("T.must expects a string as second argument")
-        end
-      else
-        msg = "Passed `nil` into T.must"
-      end
-      raise TypeError.new(msg) if arg.nil?
-      arg
+      raise TypeError.new("Passed `nil` into T.must")
     rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
       T::Private::ErrorHandler.handle_inline_type_error(e)
-      arg
     end
   end
 

data/lib/types/boolean.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module T

data/lib/types/compatibility_patches.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # typed: ignore
 
 require_relative 'private/methods/_methods'

data/lib/types/configuration.rb

@@ -2,6 +2,59 @@
 # frozen_string_literal: true
 
 module T::Configuration
+  # Announces to Sorbet that we are currently in a test environment, so it
+  # should treat any sigs which are marked `.checked(:tests)` as if they were
+  # just a normal sig.
+  #
+  # If this method is not called, sigs marked `.checked(:tests)` will not be
+  # checked. In fact, such methods won't even be wrapped--the runtime will put
+  # back the original method.
+  #
+  # Note: Due to the way sigs are evaluated and methods are wrapped, this
+  # method MUST be called before any code calls `sig`. This method raises if
+  # it has been called too late.
+  def self.enable_checking_for_sigs_marked_checked_tests
+    T::Private::RuntimeLevels.enable_checking_in_tests
+  end
+
+  # Announce to Sorbet that we would like the final checks to be enabled when
+  # including and extending modules. Iff this is not called, then the following
+  # example will not raise an error.
+  #
+  # ```ruby
+  # module M
+  #   extend T::Sig
+  #   sig(:final) {void}
+  #   def foo; end
+  # end
+  # class C
+  #   include M
+  #   def foo; end
+  # end
+  # ```
+  def self.enable_final_checks_for_include_extend
+    T::Private::Methods.set_final_checks_for_include_extend(true)
+  end
+
+  # Undo the effects of a previous call to
+  # `enable_final_checks_for_include_extend`.
+  def self.reset_final_checks_for_include_extend
+    T::Private::Methods.set_final_checks_for_include_extend(false)
+  end
+
+  # Configure the default checked level for a sig with no explicit `.checked`
+  # builder. When unset, the default checked level is `:always`.
+  #
+  # Note: setting this option is potentially dangerous! Sorbet can't check all
+  # code statically. The runtime checks complement the checks that Sorbet does
+  # statically, so that methods don't have to guard themselves from being
+  # called incorrectly by untyped code.
+  #
+  # @param [:never, :tests, :always] default_checked_level
+  def self.default_checked_level=(default_checked_level)
+    T::Private::RuntimeLevels.default_checked_level = default_checked_level
+  end
+
   # Set a handler to handle `TypeError`s raised by any in-line type assertions,
   # including `T.must`, `T.let`, `T.cast`, and `T.assert_type!`.
   #
@@ -84,11 +137,10 @@ module T::Configuration
   # successfully built, but the built sig is incompatible with other sigs in
   # some way.
   #
-  # By default, sig validation errors cause an exception to be raised. One
-  # exception is for `generated` sigs, for which a message will be logged
-  # instead of raising. Setting sig_validation_error_handler to an object that
-  # implements :call (e.g. proc or lambda) allows users to customize the
-  # behavior when a method signature's build fails.
+  # By default, sig validation errors cause an exception to be raised.
+  # Setting sig_validation_error_handler to an object that implements :call
+  # (e.g. proc or lambda) allows users to customize the behavior when a method
+  # signature's build fails.
   #
   # @param [Lambda, Proc, Object, nil] value Proc that handles the error (pass
   #   nil to reset to default behavior)
@@ -116,24 +168,7 @@ module T::Configuration
   end
 
   private_class_method def self.sig_validation_error_handler_default(error, opts)
-    # if this method overrides a generated signature, report that one instead
-    bad_method = opts[:method]
-    if !opts[:declaration].generated
-      super_signature = opts[:super_signature]
-      raise error if !super_signature&.generated
-      bad_method = super_signature.method
-    end
-
-    method_file, method_line = bad_method.source_location
-    T::Configuration.log_info_handler(
-      "SIG-DECLARE-FAILED",
-      {
-        definition_file: method_file,
-        definition_line: method_line,
-        kind: "Delete",
-        message: error.message,
-      },
-    )
+    raise error
   end
 
   def self.sig_validation_error_handler(error, opts)
@@ -147,11 +182,9 @@ module T::Configuration
   # Set a handler for type errors that result from calling a method.
   #
   # By default, errors from calling a method cause an exception to be raised.
-  # One exception is for `generated` sigs, for which a message will be logged
-  # instead of raising. Setting call_validation_error_handler to an object that
-  # implements :call (e.g. proc or lambda) allows users to customize the
-  # behavior when a method is called with invalid parameters, or returns an
-  # invalid value.
+  # Setting call_validation_error_handler to an object that implements :call
+  # (e.g. proc or lambda) allows users to customize the behavior when a method
+  # is called with invalid parameters, or returns an invalid value.
   #
   # @param [Lambda, Proc, Object, nil] value Proc that handles the error
   #   report (pass nil to reset to default behavior)
@@ -180,41 +213,7 @@ module T::Configuration
   end
 
   private_class_method def self.call_validation_error_handler_default(signature, opts)
-    method_file, method_line = signature.method.source_location
-    location = opts[:location]
-    suffix = "Caller: #{location.path}:#{location.lineno}\n" \
-      "Definition: #{method_file}:#{method_line}"
-
-    error_message = "#{opts[:kind]}#{opts[:name] ? " '#{opts[:name]}'" : ''}: #{opts[:message]}\n#{suffix}"
-
-    if signature.generated
-      got = opts[:value].class
-      got = T.unsafe(T::Enumerable[T.untyped]).describe_obj(opts[:value]) if got < Enumerable
-      T::Configuration.log_info_handler(
-        "SIG-CHECK-FAILED",
-        {
-          caller_file: location.path,
-          caller_line: location.lineno,
-          definition_file: method_file,
-          definition_line: method_line,
-          kind: opts[:kind],
-          name: opts[:name],
-          expected: opts[:type].name,
-          got: got,
-        },
-      )
-    elsif signature.soft_notify
-      T::Configuration.soft_assert_handler(
-        "TypeError: #{error_message}",
-        {notify: signature.soft_notify}
-      )
-    else
-      begin
-        raise TypeError.new(error_message)
-      rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
-        T::Private::ErrorHandler.handle_inline_type_error(e)
-      end
-    end
+    raise TypeError.new(opts[:pretty_message])
   end
 
   def self.call_validation_error_handler(signature, opts)
@@ -359,6 +358,26 @@ module T::Configuration
     @scalar_types || @default_scalar_types
   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).
+  #
+  # @yield
+  #
+  def self.without_ruby_warnings
+    if $VERBOSE
+      begin
+        original_verbose = $VERBOSE
+        $VERBOSE = false
+        yield
+      ensure
+        $VERBOSE = original_verbose
+      end
+    else
+      yield
+    end
+  end
+
 
   private_class_method def self.validate_lambda_given!(value)
     if !value.nil? && !value.respond_to?(:call)

data/lib/types/generic.rb

@@ -13,11 +13,11 @@ module T::Generic
     self
   end
 
-  def type_member(variance=:invariant, fixed: nil)
+  def type_member(variance=:invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
     T::Types::TypeMember.new(variance) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
   end
 
-  def type_template(variance=:invariant, fixed: nil)
+  def type_template(variance=:invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
     T::Types::TypeTemplate.new(variance) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
   end
 end

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

@@ -18,10 +18,6 @@ module T::Private::Abstract::Declare
     mod.extend(T::InterfaceWrapper::Helpers)
 
     if mod.is_a?(Class)
-      if mod < T::Struct
-        raise "#{mod.name} is a subclass of T::Struct and cannot be declared abstract"
-      end
-
       if type == :interface
         # Since `interface!` is just `abstract!` with some extra validation, we could technically
         # allow this, but it's unclear there are good use cases, and it might be confusing.
@@ -32,6 +28,9 @@ module T::Private::Abstract::Declare
         raise "You must call `abstract!` *before* defining an initialize method"
       end
 
+      # Don't need to silence warnings via without_ruby_warnings when calling
+      # define_method because of the guard above
+
       mod.send(:define_method, :initialize) do |*args, &blk|
         if self.class == mod
           raise "#{mod} is declared as abstract; it cannot be instantiated"

data/lib/types/private/class_utils.rb

@@ -32,7 +32,9 @@ module T::Private::ClassUtils
 
       if @overwritten
         # The original method was overwritten. Overwrite again to restore it.
-        @mod.send(:define_method, @old_method.name, @old_method) # rubocop:disable PrisonGuard/UsePublicSend
+        T::Configuration.without_ruby_warnings do
+          @mod.send(:define_method, @old_method.name, @old_method) # rubocop:disable PrisonGuard/UsePublicSend
+        end
       else
         # The original method was in an ancestor. Restore it by removing the overriding method.
         @mod.send(:remove_method, @old_method.name) # rubocop:disable PrisonGuard/UsePublicSend
@@ -93,8 +95,10 @@ module T::Private::ClassUtils
     end
 
     overwritten = original_owner == mod
-    mod.send(:define_method, name, &blk) # rubocop:disable PrisonGuard/UsePublicSend
-    mod.send(original_visibility, name) # rubocop:disable PrisonGuard/UsePublicSend
+    T::Configuration.without_ruby_warnings do
+      mod.send(:define_method, name, &blk) # rubocop:disable PrisonGuard/UsePublicSend
+      mod.send(original_visibility, name) # rubocop:disable PrisonGuard/UsePublicSend
+    end
     new_method = mod.instance_method(name)
 
     ReplacedMethod.new(mod, original_method, new_method, overwritten, original_visibility)

data/lib/types/private/decl_state.rb

@@ -11,6 +11,7 @@ class T::Private::DeclState
   end
 
   attr_accessor :active_declaration
+  attr_accessor :skip_next_on_method_added
 
   def reset!
     self.active_declaration = nil

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

@@ -6,23 +6,36 @@ module T::Private::Methods
   @signatures_by_method = {}
   @sig_wrappers = {}
   @sigs_that_raised = {}
+  # the info about whether a method is final is not stored in a DeclBuilder nor a Signature, but instead right here.
+  # this is because final checks are special:
+  # - they are done possibly before any sig block has run.
+  # - they are done even if the method being defined doesn't have a sig.
+  @final_methods = Set.new
+  # if a module directly defines a final method, or includes, extends, or inherits from a module which does so, then it
+  # should be in this set.
+  @modules_with_final = Set.new
+  @old_included_extended = nil
 
   ARG_NOT_PROVIDED = Object.new
   PROC_TYPE = Object.new
 
-  DeclarationBlock = Struct.new(:mod, :loc, :blk)
+  DeclarationBlock = Struct.new(:mod, :loc, :blk, :final)
 
-  def self.declare_sig(mod, &blk)
+  def self.declare_sig(mod, arg, &blk)
     install_hooks(mod)
 
     if T::Private::DeclState.current.active_declaration
-      T::Private::DeclState.current.active_declaration = nil
+      T::Private::DeclState.current.reset!
       raise "You called sig twice without declaring a method inbetween"
     end
 
+    if !arg.nil? && arg != :final
+      raise "Invalid argument to `sig`: #{arg}"
+    end
+
     loc = caller_locations(2, 1).first
 
-    T::Private::DeclState.current.active_declaration = DeclarationBlock.new(mod, loc, blk)
+    T::Private::DeclState.current.active_declaration = DeclarationBlock.new(mod, loc, blk, arg == :final)
 
     nil
   end
@@ -43,8 +56,8 @@ module T::Private::Methods
     if decl.returns == ARG_NOT_PROVIDED
       raise "Procs must specify a return type"
     end
-    if decl.soft_notify != ARG_NOT_PROVIDED
-      raise "Procs cannot use .soft"
+    if decl.on_failure != ARG_NOT_PROVIDED
+      raise "Procs cannot use .on_failure"
     end
 
     if decl.params == ARG_NOT_PROVIDED
@@ -106,15 +119,60 @@ module T::Private::Methods
     @signatures_by_method[key]
   end
 
+  # when target includes a module with instance methods source_method_names, ensure there is zero intersection between
+  # the final instance methods of target and source_method_names. so, for every m in source_method_names, check if there
+  # is already a method defined on one of target_ancestors with the same name that is final.
+  def self._check_final_ancestors(target, target_ancestors, source_method_names)
+    # use reverse_each to check farther-up ancestors first, for better error messages. we could avoid this if we were on
+    # the version of ruby that adds the optional argument to method_defined? that allows you to exclude ancestors.
+    target_ancestors.reverse_each do |ancestor|
+      source_method_names.each do |method_name|
+        # the usage of method_owner_and_name_to_key(ancestor, method_name) instead of
+        # 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))
+          raise(
+            "`#{ancestor.name}##{method_name}` was declared as final and cannot be " +
+            (target == ancestor ? "redefined" : "overridden in `#{target.name}`")
+          )
+        end
+      end
+    end
+  end
+
+  private_class_method def self.add_final_method(method_key)
+    @final_methods.add(method_key)
+  end
+
+  private_class_method def self.final_method?(method_key)
+    @final_methods.include?(method_key)
+  end
+
+  def self.add_module_with_final(mod)
+    @modules_with_final.add(mod)
+  end
+
+  private_class_method def self.module_with_final?(mod)
+    @modules_with_final.include?(mod)
+  end
+
   # Only public because it needs to get called below inside the replace_method blocks below.
   def self._on_method_added(hook_mod, method_name, is_singleton_method: false)
-    current_declaration = T::Private::DeclState.current.active_declaration
-    return if !current_declaration
-    T::Private::DeclState.current.reset!
+    if T::Private::DeclState.current.skip_next_on_method_added
+      T::Private::DeclState.current.skip_next_on_method_added = false
+      return
+    end
 
+    current_declaration = T::Private::DeclState.current.active_declaration
     mod = is_singleton_method ? hook_mod.singleton_class : hook_mod
     original_method = mod.instance_method(method_name)
 
+    _check_final_ancestors(mod, mod.ancestors, [method_name])
+
+    return if current_declaration.nil?
+    T::Private::DeclState.current.reset!
+
     sig_block = lambda do
       T::Private::Methods.run_sig(hook_mod, method_name, original_method, current_declaration)
     end
@@ -161,15 +219,16 @@ module T::Private::Methods
     end
 
     new_method = mod.instance_method(method_name)
-    @sig_wrappers[method_to_key(new_method)] = sig_block
+    key = method_to_key(new_method)
+    @sig_wrappers[key] = sig_block
+    if current_declaration.final
+      add_final_method(key)
+      add_module_with_final(mod)
+    end
   end
 
   def self.sig_error(loc, message)
-    raise(
-      ArgumentError.new(
-        "#{loc.path}:#{loc.lineno}: Error interpreting `sig`:\n  #{message}\n\n"
-      )
-    )
+    raise(ArgumentError.new("#{loc.path}:#{loc.lineno}: Error interpreting `sig`:\n  #{message}\n\n"))
   end
 
   # Executes the `sig` block, and converts the resulting Declaration
@@ -224,7 +283,7 @@ module T::Private::Methods
         bind: current_declaration.bind,
         mode: current_declaration.mode,
         check_level: current_declaration.checked,
-        soft_notify: current_declaration.soft_notify,
+        on_failure: current_declaration.on_failure,
         override_allow_incompatible: current_declaration.override_allow_incompatible,
         generated: current_declaration.generated,
       )
@@ -300,21 +359,51 @@ module T::Private::Methods
     end
   end
 
+  # the module target is adding the methods from the module source to itself. we need to check that for all instance
+  # methods M on source, M is not defined on any of target's ancestors.
+  def self._included_extended_impl(target, target_ancestors, source)
+    if !module_with_final?(target) && !module_with_final?(source)
+      return
+    end
+    add_module_with_final(target)
+    install_hooks(target)
+    _check_final_ancestors(target, target_ancestors - source.ancestors, source.instance_methods)
+  end
+
+  def self.set_final_checks_for_include_extend(enable)
+    is_enabled = @old_included_extended != nil
+    if enable == is_enabled
+      return
+    end
+    if is_enabled
+      @old_included_extended.each(&:restore)
+      @old_included_extended = nil
+    else
+      old_included = T::Private::ClassUtils.replace_method(Module, :included) do |arg|
+        old_included.bind(self).call(arg)
+        ::T::Private::Methods._included_extended_impl(arg, arg.ancestors, self)
+      end
+      old_extended = T::Private::ClassUtils.replace_method(Module, :extended) do |arg|
+        old_extended.bind(self).call(arg)
+        ::T::Private::Methods._included_extended_impl(arg, arg.singleton_class.ancestors, self)
+      end
+      @old_included_extended = [old_included, old_extended]
+    end
+  end
+
   def self.install_hooks(mod)
     return if @installed_hooks.include?(mod)
     @installed_hooks << mod
 
     if mod.singleton_class?
       install_singleton_method_added_hook(mod)
-      install_singleton_method_added_hook(mod.singleton_class)
     else
       original_method = T::Private::ClassUtils.replace_method(mod.singleton_class, :method_added) do |name|
         T::Private::Methods._on_method_added(self, name)
         original_method.bind(self).call(name)
       end
-
-      install_singleton_method_added_hook(mod.singleton_class)
     end
+    install_singleton_method_added_hook(mod.singleton_class)
   end
 
   private_class_method def self.install_singleton_method_added_hook(singleton_klass)
@@ -332,8 +421,13 @@ module T::Private::Methods
     original_singleton_method.bind(attached).call(:singleton_method_added)
   end
 
+  # use this directly if you don't want/need to box up the method into an object to pass to method_to_key.
+  private_class_method def self.method_owner_and_name_to_key(owner, name)
+    "#{owner.object_id}##{name}"
+  end
+
   private_class_method def self.method_to_key(method)
-    "#{method.owner.object_id}##{method.name}"
+    method_owner_and_name_to_key(method.owner, method.name)
   end
 
   private_class_method def self.key_to_method(key)

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

@@ -35,9 +35,11 @@ module T::Private::Methods::CallValidation
     elsif method_sig.check_level == :always || (method_sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
       create_validator_method(mod, original_method, method_sig, original_visibility)
     else
-      # get all the shims out of the way and put back the original method
-      mod.send(:define_method, method_sig.method_name, original_method)
-      mod.send(original_visibility, method_sig.method_name)
+      T::Configuration.without_ruby_warnings do
+        # get all the shims out of the way and put back the original method
+        mod.send(:define_method, method_sig.method_name, original_method)
+        mod.send(original_visibility, method_sig.method_name)
+      end
     end
     # Return the newly created method (or the original one if we didn't replace it)
     mod.instance_method(method_sig.method_name)
@@ -161,18 +163,21 @@ module T::Private::Methods::CallValidation
   end
 
   def self.create_validator_method(mod, original_method, method_sig, original_visibility)
+    T::Private::DeclState.current.skip_next_on_method_added = true
     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)
 
-    if has_fixed_arity && has_simple_method_types && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
-      create_validator_method_fast(mod, original_method, method_sig)
-    elsif has_fixed_arity && has_simple_procedure_types && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
-      create_validator_procedure_fast(mod, original_method, method_sig)
-    else
-      create_validator_slow(mod, original_method, method_sig)
+    T::Configuration.without_ruby_warnings do
+      if has_fixed_arity && has_simple_method_types && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
+        create_validator_method_fast(mod, original_method, method_sig)
+      elsif has_fixed_arity && has_simple_procedure_types && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
+        create_validator_procedure_fast(mod, original_method, method_sig)
+      else
+        create_validator_slow(mod, original_method, method_sig)
+      end
     end
     mod.send(original_visibility, method_sig.method_name)
   end
@@ -1150,10 +1155,16 @@ module T::Private::Methods::CallValidation
   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
+
+    pretty_message = "#{kind}#{name ? " '#{name}'" : ''}: #{error_message}\n" \
+      "Caller: #{caller_loc.path}:#{caller_loc.lineno}\n" \
+      "Definition: #{definition_file}:#{definition_line}"
 
     T::Private::ErrorHandler.handle_call_validation_error(
       method_sig,
       message: error_message,
+      pretty_message: pretty_message,
       kind: kind,
       name: name,
       type: type,