Merge pull request #8267 from issyl0/use-latest-sorbet-and-regenerate-tapioca-rbis

Use the latest Sorbet version and regenerate Tapioca RBIs

Library/Homebrew/Gemfile

@@ -13,8 +13,8 @@ gem "rspec-retry", require: false
 gem "rspec-wait", require: false
 gem "rubocop"
 gem "simplecov", require: false
-gem "sorbet", "0.5.5823"
+gem "sorbet"
-gem "sorbet-runtime", "0.5.5823"
+gem "sorbet-runtime"
 gem "tapioca"
 
 # vendored gems

Library/Homebrew/Gemfile.lock

@@ -120,10 +120,10 @@ GEM
       docile (~> 1.1)
       simplecov-html (~> 0.11)
     simplecov-html (0.12.2)
-    sorbet (0.5.5823)
+    sorbet (0.5.5866)
-      sorbet-static (= 0.5.5823)
+      sorbet-static (= 0.5.5866)
-    sorbet-runtime (0.5.5823)
+    sorbet-runtime (0.5.5866)
-    sorbet-static (0.5.5823-universal-darwin-14)
+    sorbet-static (0.5.5866-universal-darwin-14)
     tapioca (0.4.1)
       parlour (>= 2.1.0)
       pry (>= 0.12.2)
@@ -163,8 +163,8 @@ DEPENDENCIES
   rubocop-rspec
   ruby-macho
   simplecov
-  sorbet (= 0.5.5823)
+  sorbet
-  sorbet-runtime (= 0.5.5823)
+  sorbet-runtime
   tapioca
 
 BUNDLED WITH

Library/Homebrew/sorbet/rbi/gems/activesupport@6.0.3.2.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync --exclude json
+# This is an autogenerated file for types exported from the `activesupport` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: false
 

Library/Homebrew/sorbet/rbi/gems/ast@2.4.1.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `ast` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -7,7 +8,7 @@ module AST
 end
 
 class AST::Node
-  def initialize(type, children = _, properties = _); end
+  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
 
   def +(array); end
   def <<(element); end
@@ -19,14 +20,14 @@ class AST::Node
   def dup; end
   def eql?(other); end
   def hash; end
-  def inspect(indent = _); end
+  def inspect(indent = T.unsafe(nil)); end
   def to_a; end
   def to_ast; end
-  def to_s(indent = _); end
+  def to_s(indent = T.unsafe(nil)); end
-  def to_sexp(indent = _); end
+  def to_sexp(indent = T.unsafe(nil)); end
   def to_sexp_array; end
   def type; end
-  def updated(type = _, children = _, properties = _); end
+  def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
 
   protected
 

Library/Homebrew/sorbet/rbi/gems/bindata@2.4.8.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync --exclude json
+# This is an autogenerated file for types exported from the `bindata` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -11,10 +12,12 @@ module BinData
   private
 
   def trace_message; end
-  def trace_reading(io = _); end
+  def trace_reading(io = T.unsafe(nil)); end
 
-  def self.trace_message; end
+  class << self
-  def self.trace_reading(io = _); end
+    def trace_message; end
+    def trace_reading(io = T.unsafe(nil)); end
+  end
 end
 
 module BinData::AcceptedParametersPlugin
@@ -29,10 +32,10 @@ module BinData::AcceptedParametersPlugin
 end
 
 class BinData::AcceptedParametersPlugin::AcceptedParameters
-  def initialize(ancestor_parameters = _); end
+  def initialize(ancestor_parameters = T.unsafe(nil)); end
 
   def all; end
-  def default(args = _); end
+  def default(args = T.unsafe(nil)); end
   def mandatory(*args); end
   def mutually_exclusive(*args); end
   def optional(*args); end
@@ -42,7 +45,9 @@ class BinData::AcceptedParametersPlugin::AcceptedParameters
   def ensure_valid_names(names); end
   def to_syms(args); end
 
-  def self.invalid_parameter_names; end
+  class << self
+    def invalid_parameter_names; end
+  end
 end
 
 class BinData::Array < ::BinData::Base
@@ -50,7 +55,7 @@ class BinData::Array < ::BinData::Base
   extend(::BinData::DSLMixin)
 
   def <<(*args); end
-  def [](arg1, arg2 = _); end
+  def [](arg1, arg2 = T.unsafe(nil)); end
   def []=(index, value); end
   def assign(array); end
   def at(index); end
@@ -63,17 +68,17 @@ class BinData::Array < ::BinData::Base
   def empty?; end
   def find_index(obj); end
   def find_index_of(obj); end
-  def first(n = _); end
+  def first(n = T.unsafe(nil)); end
   def index(obj); end
   def initialize_instance; end
   def initialize_shared_instance; end
   def insert(index, *objs); end
-  def last(n = _); end
+  def last(n = T.unsafe(nil)); end
   def length; end
   def offset_of(child); end
   def push(*args); end
   def size; end
-  def slice(arg1, arg2 = _); end
+  def slice(arg1, arg2 = T.unsafe(nil)); end
   def snapshot; end
   def to_ary; end
   def unshift(*args); end
@@ -108,20 +113,20 @@ class BinData::Base
   def base_respond_to?(*_); end
   def clear; end
   def debug_name; end
-  def eval_parameter(key, overrides = _); end
+  def eval_parameter(key, overrides = T.unsafe(nil)); end
   def get_parameter(key); end
   def has_parameter?(key); end
   def initialize_instance(*args); end
   def initialize_with_warning(*args); end
   def inspect; end
   def lazy_evaluator; end
-  def new(value = _, parent = _); end
+  def new(value = T.unsafe(nil), parent = T.unsafe(nil)); end
   def num_bytes; end
   def parent; end
   def pretty_print(pp); end
   def read(io, &block); end
   def rel_offset; end
-  def safe_respond_to?(symbol, include_private = _); end
+  def safe_respond_to?(symbol, include_private = T.unsafe(nil)); end
   def to_binary_s(&block); end
   def to_hex(&block); end
   def to_s; end
@@ -142,11 +147,18 @@ class BinData::Base
   def top_level_get(sym); end
   def top_level_set(sym, value); end
 
-  def self.arg_processor(name = _); end
+  class << self
-  def self.auto_call_delayed_io; end
+    def arg_processor(name = T.unsafe(nil)); end
-  def self.bindata_name; end
+    def auto_call_delayed_io; end
-  def self.inherited(subclass); end
+    def bindata_name; end
-  def self.read(io, *args, &block); end
+    def inherited(subclass); end
+    def read(io, *args, &block); end
+
+    private
+
+    def register_subclasses; end
+    def unregister_self; end
+  end
 end
 
 module BinData::Base::AutoCallDelayedIO
@@ -175,7 +187,7 @@ class BinData::BasePrimitive < ::BinData::Base
   def initialize_instance; end
   def initialize_shared_instance; end
   def method_missing(symbol, *args, &block); end
-  def respond_to?(symbol, include_private = _); end
+  def respond_to?(symbol, include_private = T.unsafe(nil)); end
   def snapshot; end
   def trace_value; end
   def value; end
@@ -188,10 +200,12 @@ class BinData::BasePrimitive < ::BinData::Base
   def sensible_default; end
   def value_to_binary_string(val); end
 
-  def self.bit_aligned; end
+  class << self
-  def self.inherited(subclass); end
+    def bit_aligned; end
-  def self.turn_off_tracing; end
+    def inherited(subclass); end
-  def self.turn_on_tracing; end
+    def turn_off_tracing; end
+    def turn_on_tracing; end
+  end
 end
 
 module BinData::BasePrimitive::AssertPlugin
@@ -243,16 +257,18 @@ class BinData::BitAligned::BitAlignedIO
 end
 
 module BinData::BitField
-  def self.create_clamp_code(nbits, signed); end
+  class << self
-  def self.create_do_num_bytes_code(nbits); end
+    def create_clamp_code(nbits, signed); end
-  def self.create_dynamic_clamp_code(signed); end
+    def create_do_num_bytes_code(nbits); end
-  def self.create_fixed_clamp_code(nbits, signed); end
+    def create_dynamic_clamp_code(signed); end
-  def self.create_int2uint_code(nbits, signed); end
+    def create_fixed_clamp_code(nbits, signed); end
-  def self.create_nbits_code(nbits); end
+    def create_int2uint_code(nbits, signed); end
-  def self.create_params_code(nbits); end
+    def create_nbits_code(nbits); end
-  def self.create_uint2int_code(nbits, signed); end
+    def create_params_code(nbits); end
-  def self.define_class(name, nbits, endian, signed = _); end
+    def create_uint2int_code(nbits, signed); end
-  def self.define_methods(bit_class, nbits, endian, signed); end
+    def define_class(name, nbits, endian, signed = T.unsafe(nil)); end
+    def define_methods(bit_class, nbits, endian, signed); end
+  end
 end
 
 module BinData::BitFieldFactory
@@ -282,7 +298,7 @@ class BinData::Buffer < ::BinData::Base
   def initialize_instance; end
   def method_missing(symbol, *args, &block); end
   def raw_num_bytes; end
-  def respond_to?(symbol, include_private = _); end
+  def respond_to?(symbol, include_private = T.unsafe(nil)); end
   def snapshot; end
 end
 
@@ -312,7 +328,7 @@ class BinData::Choice < ::BinData::Base
   def initialize_instance; end
   def initialize_shared_instance; end
   def method_missing(symbol, *args, &block); end
-  def respond_to?(symbol, include_private = _); end
+  def respond_to?(symbol, include_private = T.unsafe(nil)); end
   def selection; end
   def snapshot(*args); end
   def trace_selection; end
@@ -322,8 +338,10 @@ class BinData::Choice < ::BinData::Base
   def current_choice; end
   def instantiate_choice(selection); end
 
-  def self.turn_off_tracing; end
+  class << self
-  def self.turn_on_tracing; end
+    def turn_off_tracing; end
+    def turn_on_tracing; end
+  end
 end
 
 class BinData::ChoiceArgProcessor < ::BinData::BaseArgProcessor
@@ -353,21 +371,23 @@ class BinData::CountBytesRemaining < ::BinData::BasePrimitive
 end
 
 module BinData::DSLMixin
-  def dsl_parser(parser_type = _); end
+  def dsl_parser(parser_type = T.unsafe(nil)); end
   def method_missing(symbol, *args, &block); end
   def to_ary; end
   def to_str; end
 end
 
 class BinData::DSLMixin::DSLBigAndLittleEndianHandler
-  def self.class_with_endian(class_name, endian); end
+  class << self
-  def self.create_subclasses_with_endian(bnl_class); end
+    def class_with_endian(class_name, endian); end
-  def self.delegate_field_creation(bnl_class); end
+    def create_subclasses_with_endian(bnl_class); end
-  def self.fixup_subclass_hierarchy(bnl_class); end
+    def delegate_field_creation(bnl_class); end
-  def self.handle(bnl_class); end
+    def fixup_subclass_hierarchy(bnl_class); end
-  def self.make_class_abstract(bnl_class); end
+    def handle(bnl_class); end
-  def self.obj_attribute(obj, attr); end
+    def make_class_abstract(bnl_class); end
-  def self.override_new_in_class(bnl_class); end
+    def obj_attribute(obj, attr); end
+    def override_new_in_class(bnl_class); end
+  end
 end
 
 class BinData::DSLMixin::DSLFieldParser
@@ -402,7 +422,7 @@ class BinData::DSLMixin::DSLParser
   def initialize(the_class, parser_type); end
 
   def dsl_params; end
-  def endian(endian = _); end
+  def endian(endian = T.unsafe(nil)); end
   def fields; end
   def hide(*args); end
   def method_missing(*args, &block); end
@@ -417,7 +437,7 @@ class BinData::DSLMixin::DSLParser
   def fields?; end
   def hints; end
   def option?(opt); end
-  def parent_attribute(attr, default = _); end
+  def parent_attribute(attr, default = T.unsafe(nil)); end
   def parent_fields; end
   def parse_and_append_field(*args, &block); end
   def parser_abilities; end
@@ -443,7 +463,7 @@ class BinData::DelayedIO < ::BinData::Base
   def num_bytes; end
   def read_now!; end
   def rel_offset; end
-  def respond_to?(symbol, include_private = _); end
+  def respond_to?(symbol, include_private = T.unsafe(nil)); end
   def snapshot; end
   def write_now!; end
 end
@@ -495,10 +515,12 @@ class BinData::FloatLe < ::BinData::BasePrimitive
 end
 
 module BinData::FloatingPoint
-  def self.create_num_bytes_code(precision); end
+  class << self
-  def self.create_read_code(precision, endian); end
+    def create_num_bytes_code(precision); end
-  def self.create_to_binary_s_code(precision, endian); end
+    def create_read_code(precision, endian); end
-  def self.define_methods(float_class, precision, endian); end
+    def create_to_binary_s_code(precision, endian); end
+    def define_methods(float_class, precision, endian); end
+  end
 end
 
 module BinData::Framework
@@ -519,7 +541,9 @@ module BinData::Framework
 end
 
 module BinData::IO
-  def self.create_string_io(str = _); end
+  class << self
+    def create_string_io(str = T.unsafe(nil)); end
+  end
 end
 
 module BinData::IO::Common
@@ -579,7 +603,7 @@ class BinData::IO::Read
   def accumulate_big_endian_bits; end
   def accumulate_little_endian_bits; end
   def mask(nbits); end
-  def read(n = _); end
+  def read(n = T.unsafe(nil)); end
   def read_big_endian_bits(nbits); end
   def read_little_endian_bits(nbits); end
 end
@@ -611,8 +635,25 @@ module BinData::InitialLengthPlugin
 end
 
 module BinData::Int
-  def self.define_class(name, nbits, endian, signed); end
+  class << self
-  def self.define_methods(int_class, nbits, endian, signed); end
+    def define_class(name, nbits, endian, signed); end
+    def define_methods(int_class, nbits, endian, signed); end
+
+    private
+
+    def bits_per_word(nbits); end
+    def create_clamp_code(nbits, signed); end
+    def create_int2uint_code(nbits); end
+    def create_raw_read_code(nbits, endian, signed); end
+    def create_read_assemble_code(nbits, endian, signed); end
+    def create_read_code(nbits, endian, signed); end
+    def create_read_unpack_code(nbits, endian, signed); end
+    def create_to_binary_s_code(nbits, endian, signed); end
+    def create_uint2int_code(nbits); end
+    def need_signed_conversion_code?(nbits, signed); end
+    def pack_directive(nbits, endian, signed); end
+    def val_as_packed_words(nbits, endian, signed); end
+  end
 end
 
 class BinData::Int32be < ::BinData::BasePrimitive
@@ -678,7 +719,7 @@ class BinData::LazyEvaluator
   def initialize(obj); end
 
   def index; end
-  def lazy_eval(val, overrides = _); end
+  def lazy_eval(val, overrides = T.unsafe(nil)); end
   def method_missing(symbol, *args); end
   def parent; end
 
@@ -705,7 +746,7 @@ class BinData::Primitive < ::BinData::BasePrimitive
   def do_write(io); end
   def initialize_instance; end
   def method_missing(symbol, *args, &block); end
-  def respond_to?(symbol, include_private = _); end
+  def respond_to?(symbol, include_private = T.unsafe(nil)); end
 
   private
 
@@ -714,7 +755,9 @@ class BinData::Primitive < ::BinData::BasePrimitive
   def sensible_default; end
   def set(v); end
 
-  def self.bit_aligned; end
+  class << self
+    def bit_aligned; end
+  end
 end
 
 class BinData::PrimitiveArgProcessor < ::BinData::BaseArgProcessor
@@ -732,7 +775,9 @@ end
 class BinData::Record < ::BinData::Struct
   extend(::BinData::DSLMixin)
 
-  def self.inherited(subclass); end
+  class << self
+    def inherited(subclass); end
+  end
 end
 
 class BinData::RecordArgProcessor < ::BinData::StructArgProcessor
@@ -744,7 +789,9 @@ end
 module BinData::RegisterNamePlugin
   def initialize_shared_instance; end
 
-  def self.included(base); end
+  class << self
+    def included(base); end
+  end
 end
 
 BinData::RegisteredClasses = T.let(T.unsafe(nil), BinData::Registry)
@@ -752,7 +799,7 @@ BinData::RegisteredClasses = T.let(T.unsafe(nil), BinData::Registry)
 class BinData::Registry
   def initialize; end
 
-  def lookup(name, hints = _); end
+  def lookup(name, hints = T.unsafe(nil)); end
   def register(name, class_to_register); end
   def underscore_name(name); end
   def unregister(name); end
@@ -799,7 +846,7 @@ class BinData::SanitizedField < ::BinData::SanitizedParameter
   def initialize(name, field_type, field_params, hints); end
 
   def has_parameter?(param); end
-  def instantiate(value = _, parent = _); end
+  def instantiate(value = T.unsafe(nil), parent = T.unsafe(nil)); end
   def name; end
   def name_as_sym; end
   def prototype; end
@@ -808,7 +855,7 @@ end
 class BinData::SanitizedFields < ::BinData::SanitizedParameter
   include(::Enumerable)
 
-  def initialize(hints, base_fields = _); end
+  def initialize(hints, base_fields = T.unsafe(nil)); end
 
   def [](idx); end
   def add_field(type, name, params); end
@@ -859,7 +906,9 @@ class BinData::SanitizedParameters < ::Hash
   def needs_sanitizing?(key); end
   def sanitize!; end
 
-  def self.sanitize(parameters, the_class); end
+  class << self
+    def sanitize(parameters, the_class); end
+  end
 end
 
 BinData::SanitizedParameters::BIG_ENDIAN = T.let(T.unsafe(nil), BinData::SanitizedBigEndian)
@@ -870,7 +919,7 @@ class BinData::SanitizedPrototype < ::BinData::SanitizedParameter
   def initialize(obj_type, obj_params, hints); end
 
   def has_parameter?(param); end
-  def instantiate(value = _, parent = _); end
+  def instantiate(value = T.unsafe(nil), parent = T.unsafe(nil)); end
 end
 
 class BinData::Sbit < ::BinData::BasePrimitive
@@ -956,7 +1005,7 @@ class BinData::Stringz < ::BinData::BasePrimitive
   def read_and_return_value(io); end
   def sensible_default; end
   def trim_and_zero_terminate(str); end
-  def trim_to!(str, max_length = _); end
+  def trim_to!(str, max_length = T.unsafe(nil)); end
   def truncate_after_first_zero_byte!(str); end
   def value_to_binary_string(val); end
 end
@@ -972,7 +1021,7 @@ class BinData::Struct < ::BinData::Base
   def do_read(io); end
   def do_write(io); end
   def each_pair; end
-  def field_names(include_hidden = _); end
+  def field_names(include_hidden = T.unsafe(nil)); end
   def has_key?(key); end
   def initialize_instance; end
   def initialize_shared_instance; end
@@ -995,7 +1044,9 @@ class BinData::Struct < ::BinData::Base
   def sum_num_bytes_below_index(index); end
   def sum_num_bytes_for_all_fields; end
 
-  def self.inherited(subclass); end
+  class << self
+    def inherited(subclass); end
+  end
 end
 
 BinData::Struct::RESERVED = T.let(T.unsafe(nil), Hash)
@@ -1003,7 +1054,7 @@ BinData::Struct::RESERVED = T.let(T.unsafe(nil), Hash)
 class BinData::Struct::Snapshot < ::Hash
   def []=(key, value); end
   def method_missing(symbol, *args); end
-  def respond_to?(symbol, include_private = _); end
+  def respond_to?(symbol, include_private = T.unsafe(nil)); end
 end
 
 class BinData::StructArgProcessor < ::BinData::BaseArgProcessor

Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi

@@ -1,15 +1,18 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `byebug` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module Byebug
-  def self.attach; end
+  class << self
-  def self.spawn(host = _, port = _); end
+    def attach; end
+    def spawn(host = T.unsafe(nil), port = T.unsafe(nil)); end
+  end
 end
 
 module Kernel
   def byebug; end
   def debugger; end
-  def remote_byebug(host = _, port = _); end
+  def remote_byebug(host = T.unsafe(nil), port = T.unsafe(nil)); end
 end

Library/Homebrew/sorbet/rbi/gems/codecov@0.2.5.rbi

@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `codecov` gem.
-# Please instead update this file by running `tapioca sync --exclude json`.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `coderay` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/colorize@0.8.1.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync --exclude json
+# This is an autogenerated file for types exported from the `colorize` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/commander@4.5.2.rbi

@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `commander` gem.
-# Please instead update this file by running `tapioca sync --exclude json`.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.3.rbi

@@ -1,19 +1,22 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `connection_pool` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 class ConnectionPool
-  def initialize(options = _, &block); end
+  def initialize(options = T.unsafe(nil), &block); end
 
   def available; end
   def checkin; end
-  def checkout(options = _); end
+  def checkout(options = T.unsafe(nil)); end
   def shutdown(&block); end
   def size; end
-  def with(options = _); end
+  def with(options = T.unsafe(nil)); end
 
-  def self.wrap(options, &block); end
+  class << self
+    def wrap(options, &block); end
+  end
 end
 
 ConnectionPool::DEFAULTS = T.let(T.unsafe(nil), Hash)
@@ -25,24 +28,24 @@ class ConnectionPool::PoolShuttingDownError < ::ConnectionPool::Error
 end
 
 class ConnectionPool::TimedStack
-  def initialize(size = _, &block); end
+  def initialize(size = T.unsafe(nil), &block); end
 
-  def <<(obj, options = _); end
+  def <<(obj, options = T.unsafe(nil)); end
   def empty?; end
   def length; end
   def max; end
-  def pop(timeout = _, options = _); end
+  def pop(timeout = T.unsafe(nil), options = T.unsafe(nil)); end
-  def push(obj, options = _); end
+  def push(obj, options = T.unsafe(nil)); end
   def shutdown(&block); end
 
   private
 
-  def connection_stored?(options = _); end
+  def connection_stored?(options = T.unsafe(nil)); end
   def current_time; end
-  def fetch_connection(options = _); end
+  def fetch_connection(options = T.unsafe(nil)); end
-  def shutdown_connections(options = _); end
+  def shutdown_connections(options = T.unsafe(nil)); end
-  def store_connection(obj, options = _); end
+  def store_connection(obj, options = T.unsafe(nil)); end
-  def try_create(options = _); end
+  def try_create(options = T.unsafe(nil)); end
 end
 
 class ConnectionPool::TimeoutError < ::Timeout::Error
@@ -51,7 +54,7 @@ end
 ConnectionPool::VERSION = T.let(T.unsafe(nil), String)
 
 class ConnectionPool::Wrapper < ::BasicObject
-  def initialize(options = _, &block); end
+  def initialize(options = T.unsafe(nil), &block); end
 
   def method_missing(name, *args, &block); end
   def pool_available; end

Library/Homebrew/sorbet/rbi/gems/diff-lcs@1.4.4.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync --exclude json
+# This is an autogenerated file for types exported from the `diff-lcs` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/docile@1.3.2.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `docile` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `domain_name` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -14,7 +15,7 @@ class DomainName
   def >=(other); end
   def canonical?; end
   def canonical_tld?; end
-  def cookie_domain?(domain, host_only = _); end
+  def cookie_domain?(domain, host_only = T.unsafe(nil)); end
   def domain; end
   def domain_idn; end
   def hostname; end
@@ -30,8 +31,10 @@ class DomainName
   def to_str; end
   def uri_host; end
 
-  def self.etld_data; end
+  class << self
-  def self.normalize(domain); end
+    def etld_data; end
+    def normalize(domain); end
+  end
 end
 
 DomainName::DOT = T.let(T.unsafe(nil), String)
@@ -41,10 +44,12 @@ DomainName::ETLD_DATA = T.let(T.unsafe(nil), Hash)
 DomainName::ETLD_DATA_DATE = T.let(T.unsafe(nil), String)
 
 module DomainName::Punycode
-  def self.decode(string); end
+  class << self
-  def self.decode_hostname(hostname); end
+    def decode(string); end
-  def self.encode(string); end
+    def decode_hostname(hostname); end
-  def self.encode_hostname(hostname); end
+    def encode(string); end
+    def encode_hostname(hostname); end
+  end
 end
 
 class DomainName::Punycode::ArgumentError < ::ArgumentError

Library/Homebrew/sorbet/rbi/gems/elftools@1.1.2.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync --exclude json
+# This is an autogenerated file for types exported from the `elftools` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -184,7 +185,9 @@ ELFTools::Constants::DT::DT_VERNEEDNUM = T.let(T.unsafe(nil), Integer)
 ELFTools::Constants::ELFMAG = T.let(T.unsafe(nil), String)
 
 module ELFTools::Constants::EM
-  def self.mapping(val); end
+  class << self
+    def mapping(val); end
+  end
 end
 
 ELFTools::Constants::EM::EM_386 = T.let(T.unsafe(nil), Integer)
@@ -270,7 +273,9 @@ ELFTools::Constants::EM::EM_TI_C6000 = T.let(T.unsafe(nil), Integer)
 ELFTools::Constants::EM::EM_X86_64 = T.let(T.unsafe(nil), Integer)
 
 module ELFTools::Constants::ET
-  def self.mapping(type); end
+  class << self
+    def mapping(type); end
+  end
 end
 
 ELFTools::Constants::ET::ET_CORE = T.let(T.unsafe(nil), Integer)
@@ -452,7 +457,7 @@ class ELFTools::ELFFile
   def machine; end
   def num_sections; end
   def num_segments; end
-  def offset_from_vma(vma, size = _); end
+  def offset_from_vma(vma, size = T.unsafe(nil)); end
   def patches; end
   def save(filename); end
   def section_at(n); end
@@ -554,7 +559,7 @@ class ELFTools::Sections::RelocationSection < ::ELFTools::Sections::Section
 end
 
 class ELFTools::Sections::Section
-  def initialize(header, stream, offset_from_vma: _, strtab: _, **_kwargs); end
+  def initialize(header, stream, offset_from_vma: T.unsafe(nil), strtab: T.unsafe(nil), **_kwargs); end
 
   def data; end
   def header; end
@@ -563,7 +568,9 @@ class ELFTools::Sections::Section
   def stream; end
   def type; end
 
-  def self.create(header, stream, *args, **kwargs); end
+  class << self
+    def create(header, stream, *args, **kwargs); end
+  end
 end
 
 class ELFTools::Sections::StrTabSection < ::ELFTools::Sections::Section
@@ -571,7 +578,7 @@ class ELFTools::Sections::StrTabSection < ::ELFTools::Sections::Section
 end
 
 class ELFTools::Sections::SymTabSection < ::ELFTools::Sections::Section
-  def initialize(header, stream, section_at: _, **_kwargs); end
+  def initialize(header, stream, section_at: T.unsafe(nil), **_kwargs); end
 
   def each_symbols(&block); end
   def num_symbols; end
@@ -586,7 +593,7 @@ class ELFTools::Sections::SymTabSection < ::ELFTools::Sections::Section
 end
 
 class ELFTools::Sections::Symbol
-  def initialize(header, stream, symstr: _); end
+  def initialize(header, stream, symstr: T.unsafe(nil)); end
 
   def header; end
   def name; end
@@ -612,10 +619,10 @@ class ELFTools::Segments::LoadSegment < ::ELFTools::Segments::Segment
   def mem_head; end
   def mem_size; end
   def mem_tail; end
-  def offset_in?(offset, size = _); end
+  def offset_in?(offset, size = T.unsafe(nil)); end
   def offset_to_vma(offset); end
   def size; end
-  def vma_in?(vma, size = _); end
+  def vma_in?(vma, size = T.unsafe(nil)); end
   def vma_to_offset(vma); end
 end
 
@@ -627,7 +634,7 @@ class ELFTools::Segments::NoteSegment < ::ELFTools::Segments::Segment
 end
 
 class ELFTools::Segments::Segment
-  def initialize(header, stream, offset_from_vma: _); end
+  def initialize(header, stream, offset_from_vma: T.unsafe(nil)); end
 
   def data; end
   def executable?; end
@@ -637,30 +644,40 @@ class ELFTools::Segments::Segment
   def type; end
   def writable?; end
 
-  def self.create(header, stream, *args, **kwargs); end
+  class << self
+    def create(header, stream, *args, **kwargs); end
+  end
 end
 
 module ELFTools::Structs
 end
 
 class ELFTools::Structs::ELF32_Phdr < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
+  class << self
-  def self.new(*args); end
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 class ELFTools::Structs::ELF32_sym < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
+  class << self
-  def self.new(*args); end
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 class ELFTools::Structs::ELF64_Phdr < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
+  class << self
-  def self.new(*args); end
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 class ELFTools::Structs::ELF64_sym < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
+  class << self
-  def self.new(*args); end
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 class ELFTools::Structs::ELFStruct < ::BinData::Record
@@ -670,44 +687,58 @@ class ELFTools::Structs::ELFStruct < ::BinData::Record
   def offset=(_); end
   def patches; end
 
-  def self.inherited(subclass); end
+  class << self
-  def self.new(*args); end
+    def inherited(subclass); end
-  def self.pack(val, bytes); end
+    def new(*args); end
-  def self.self_endian; end
+    def pack(val, bytes); end
+    def self_endian; end
+  end
 end
 
 ELFTools::Structs::ELFStruct::CHOICE_SIZE_T = T.let(T.unsafe(nil), Hash)
 
 class ELFTools::Structs::ELF_Dyn < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
+  class << self
-  def self.new(*args); end
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 class ELFTools::Structs::ELF_Ehdr < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
+  class << self
-  def self.new(*args); end
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 class ELFTools::Structs::ELF_Nhdr < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
+  class << self
-  def self.new(*args); end
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 ELFTools::Structs::ELF_Phdr = T.let(T.unsafe(nil), Hash)
 
 class ELFTools::Structs::ELF_Rel < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
+  class << self
-  def self.new(*args); end
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 class ELFTools::Structs::ELF_Rela < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
+  class << self
-  def self.new(*args); end
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 class ELFTools::Structs::ELF_Shdr < ::ELFTools::Structs::ELFStruct
-  def self.inherited(subclass); end
+  class << self
-  def self.new(*args); end
+    def inherited(subclass); end
+    def new(*args); end
+  end
 end
 
 ELFTools::Structs::ELF_sym = T.let(T.unsafe(nil), Hash)

Library/Homebrew/sorbet/rbi/gems/highline@2.0.3.rbi

@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `highline` gem.
-# Please instead update this file by running `tapioca sync --exclude json`.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `hpricot` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/http-cookie@1.0.3.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `http-cookie` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -29,7 +30,7 @@ class HTTP::Cookie
   def dot_domain; end
   def encode_with(coder); end
   def expire!; end
-  def expired?(time = _); end
+  def expired?(time = T.unsafe(nil)); end
   def expires; end
   def expires=(t); end
   def expires_at; end
@@ -63,9 +64,11 @@ class HTTP::Cookie
   def value=(value); end
   def yaml_initialize(tag, map); end
 
-  def self.cookie_value(cookies); end
+  class << self
-  def self.cookie_value_to_hash(cookie_value); end
+    def cookie_value(cookies); end
-  def self.path_match?(base_path, target_path); end
+    def cookie_value_to_hash(cookie_value); end
+    def path_match?(base_path, target_path); end
+  end
 end
 
 HTTP::Cookie::MAX_COOKIES_PER_DOMAIN = T.let(T.unsafe(nil), Integer)
@@ -77,22 +80,24 @@ HTTP::Cookie::MAX_LENGTH = T.let(T.unsafe(nil), Integer)
 HTTP::Cookie::PERSISTENT_PROPERTIES = T.let(T.unsafe(nil), Array)
 
 class HTTP::Cookie::Scanner < ::StringScanner
-  def initialize(string, logger = _); end
+  def initialize(string, logger = T.unsafe(nil)); end
 
   def parse_cookie_date(s); end
   def scan_cookie; end
   def scan_dquoted; end
   def scan_name; end
-  def scan_name_value(comma_as_separator = _); end
+  def scan_name_value(comma_as_separator = T.unsafe(nil)); end
   def scan_set_cookie; end
-  def scan_value(comma_as_separator = _); end
+  def scan_value(comma_as_separator = T.unsafe(nil)); end
   def skip_wsp; end
 
   private
 
   def tuple_to_time(day_of_month, month, year, time); end
 
-  def self.quote(s); end
+  class << self
+    def quote(s); end
+  end
 end
 
 HTTP::Cookie::Scanner::RE_BAD_CHAR = T.let(T.unsafe(nil), Regexp)
@@ -112,17 +117,17 @@ class HTTP::CookieJar
   include(::Mechanize::CookieJarIMethods)
   include(::Enumerable)
 
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def <<(cookie); end
-  def cleanup(session = _); end
+  def cleanup(session = T.unsafe(nil)); end
   def clear; end
-  def cookies(url = _); end
+  def cookies(url = T.unsafe(nil)); end
   def delete(cookie); end
-  def each(uri = _, &block); end
+  def each(uri = T.unsafe(nil), &block); end
-  def empty?(url = _); end
+  def empty?(url = T.unsafe(nil)); end
   def load(readable, *options); end
-  def parse(set_cookie, origin, options = _); end
+  def parse(set_cookie, origin, options = T.unsafe(nil)); end
   def save(writable, *options); end
   def store; end
 
@@ -131,11 +136,13 @@ class HTTP::CookieJar
   def get_impl(base, value, *args); end
   def initialize_copy(other); end
 
-  def self.const_missing(name); end
+  class << self
+    def const_missing(name); end
+  end
 end
 
 class HTTP::CookieJar::AbstractSaver
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def load(io, jar); end
   def save(io, jar); end
@@ -144,9 +151,11 @@ class HTTP::CookieJar::AbstractSaver
 
   def default_options; end
 
-  def self.class_to_symbol(klass); end
+  class << self
-  def self.implementation(symbol); end
+    def class_to_symbol(klass); end
-  def self.inherited(subclass); end
+    def implementation(symbol); end
+    def inherited(subclass); end
+  end
 end
 
 class HTTP::CookieJar::YAMLSaver < ::HTTP::CookieJar::AbstractSaver
@@ -162,13 +171,13 @@ class HTTP::CookieJar::AbstractStore
   include(::MonitorMixin)
   include(::Enumerable)
 
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def add(cookie); end
-  def cleanup(session = _); end
+  def cleanup(session = T.unsafe(nil)); end
   def clear; end
   def delete(cookie); end
-  def each(uri = _, &block); end
+  def each(uri = T.unsafe(nil), &block); end
   def empty?; end
 
   private
@@ -176,9 +185,11 @@ class HTTP::CookieJar::AbstractStore
   def default_options; end
   def initialize_copy(other); end
 
-  def self.class_to_symbol(klass); end
+  class << self
-  def self.implementation(symbol); end
+    def class_to_symbol(klass); end
-  def self.inherited(subclass); end
+    def implementation(symbol); end
+    def inherited(subclass); end
+  end
 end
 
 class HTTP::CookieJar::CookiestxtSaver < ::HTTP::CookieJar::AbstractSaver
@@ -201,14 +212,14 @@ HTTP::CookieJar::CookiestxtSaver::RE_HTTPONLY_PREFIX = T.let(T.unsafe(nil), Rege
 HTTP::CookieJar::CookiestxtSaver::True = T.let(T.unsafe(nil), String)
 
 class HTTP::CookieJar::HashStore < ::HTTP::CookieJar::AbstractStore
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def add(cookie); end
-  def cleanup(session = _); end
+  def cleanup(session = T.unsafe(nil)); end
   def clear; end
   def default_options; end
   def delete(cookie); end
-  def each(uri = _); end
+  def each(uri = T.unsafe(nil)); end
 
   private
 

Library/Homebrew/sorbet/rbi/gems/i18n@1.8.5.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync --exclude json
+# This is an autogenerated file for types exported from the `i18n` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/mechanize@2.7.6.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `mechanize` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -8,17 +9,17 @@ class HTTP::CookieJar
   include(::Mechanize::CookieJarIMethods)
   include(::Enumerable)
 
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def <<(cookie); end
-  def cleanup(session = _); end
+  def cleanup(session = T.unsafe(nil)); end
   def clear; end
-  def cookies(url = _); end
+  def cookies(url = T.unsafe(nil)); end
   def delete(cookie); end
-  def each(uri = _, &block); end
+  def each(uri = T.unsafe(nil), &block); end
-  def empty?(url = _); end
+  def empty?(url = T.unsafe(nil)); end
   def load(readable, *options); end
-  def parse(set_cookie, origin, options = _); end
+  def parse(set_cookie, origin, options = T.unsafe(nil)); end
   def save(writable, *options); end
   def store; end
 
@@ -27,17 +28,19 @@ class HTTP::CookieJar
   def get_impl(base, value, *args); end
   def initialize_copy(other); end
 
-  def self.const_missing(name); end
+  class << self
+    def const_missing(name); end
+  end
 end
 
 class Mechanize
-  def initialize(connection_name = _); end
+  def initialize(connection_name = T.unsafe(nil)); end
 
-  def add_auth(uri, user, password, realm = _, domain = _); end
+  def add_auth(uri, user, password, realm = T.unsafe(nil), domain = T.unsafe(nil)); end
   def agent; end
-  def auth(user, password, domain = _); end
+  def auth(user, password, domain = T.unsafe(nil)); end
   def back; end
-  def basic_auth(user, password, domain = _); end
+  def basic_auth(user, password, domain = T.unsafe(nil)); end
   def ca_file; end
   def ca_file=(ca_file); end
   def cert; end
@@ -55,8 +58,8 @@ class Mechanize
   def current_page; end
   def default_encoding; end
   def default_encoding=(_); end
-  def delete(uri, query_params = _, headers = _); end
+  def delete(uri, query_params = T.unsafe(nil), headers = T.unsafe(nil)); end
-  def download(uri, io_or_filename, parameters = _, referer = _, headers = _); end
+  def download(uri, io_or_filename, parameters = T.unsafe(nil), referer = T.unsafe(nil), headers = T.unsafe(nil)); end
   def follow_meta_refresh; end
   def follow_meta_refresh=(follow); end
   def follow_meta_refresh_self; end
@@ -65,11 +68,11 @@ class Mechanize
   def follow_redirect?; end
   def force_default_encoding; end
   def force_default_encoding=(_); end
-  def get(uri, parameters = _, referer = _, headers = _); end
+  def get(uri, parameters = T.unsafe(nil), referer = T.unsafe(nil), headers = T.unsafe(nil)); end
   def get_file(url); end
   def gzip_enabled; end
   def gzip_enabled=(enabled); end
-  def head(uri, query_params = _, headers = _); end
+  def head(uri, query_params = T.unsafe(nil), headers = T.unsafe(nil)); end
   def history; end
   def history_added; end
   def history_added=(_); end
@@ -98,7 +101,7 @@ class Mechanize
   def pass; end
   def pass=(pass); end
   def pluggable_parser; end
-  def post(uri, query = _, headers = _); end
+  def post(uri, query = T.unsafe(nil), headers = T.unsafe(nil)); end
   def post_connect_hooks; end
   def pre_connect_hooks; end
   def pretty_print(q); end
@@ -106,7 +109,7 @@ class Mechanize
   def proxy_pass; end
   def proxy_port; end
   def proxy_user; end
-  def put(uri, entity, headers = _); end
+  def put(uri, entity, headers = T.unsafe(nil)); end
   def read_timeout; end
   def read_timeout=(read_timeout); end
   def redirect_ok; end
@@ -115,7 +118,7 @@ class Mechanize
   def redirection_limit=(limit); end
   def request_headers; end
   def request_headers=(request_headers); end
-  def request_with_entity(verb, uri, entity, headers = _); end
+  def request_with_entity(verb, uri, entity, headers = T.unsafe(nil)); end
   def reset; end
   def resolve(link); end
   def retry_change_requests; end
@@ -124,11 +127,11 @@ class Mechanize
   def robots=(enabled); end
   def scheme_handlers; end
   def scheme_handlers=(scheme_handlers); end
-  def set_proxy(address, port, user = _, password = _); end
+  def set_proxy(address, port, user = T.unsafe(nil), password = T.unsafe(nil)); end
   def shutdown; end
   def ssl_version; end
   def ssl_version=(ssl_version); end
-  def submit(form, button = _, headers = _); end
+  def submit(form, button = T.unsafe(nil), headers = T.unsafe(nil)); end
   def transact; end
   def user_agent; end
   def user_agent=(user_agent); end
@@ -145,14 +148,16 @@ class Mechanize
   private
 
   def add_to_history(page); end
-  def post_form(uri, form, headers = _); end
+  def post_form(uri, form, headers = T.unsafe(nil)); end
 
-  def self.html_parser; end
+  class << self
-  def self.html_parser=(_); end
+    def html_parser; end
-  def self.inherited(child); end
+    def html_parser=(_); end
-  def self.log; end
+    def inherited(child); end
-  def self.log=(_); end
+    def log; end
-  def self.start; end
+    def log=(_); end
+    def start; end
+  end
 end
 
 Mechanize::AGENT_ALIASES = T.let(T.unsafe(nil), Hash)
@@ -171,14 +176,14 @@ Mechanize::Cookie = HTTP::Cookie
 module Mechanize::CookieCMethods
   include(::Mechanize::CookieDeprecated)
 
-  def parse(arg1, arg2, arg3 = _, &block); end
+  def parse(arg1, arg2, arg3 = T.unsafe(nil), &block); end
 end
 
 module Mechanize::CookieDeprecated
 
   private
 
-  def __deprecated__(to = _); end
+  def __deprecated__(to = T.unsafe(nil)); end
 end
 
 module Mechanize::CookieIMethods
@@ -195,7 +200,7 @@ end
 module Mechanize::CookieJarIMethods
   include(::Mechanize::CookieDeprecated)
 
-  def add(arg1, arg2 = _); end
+  def add(arg1, arg2 = T.unsafe(nil)); end
   def add!(cookie); end
   def clear!; end
   def dump_cookiestxt(io); end
@@ -205,31 +210,33 @@ module Mechanize::CookieJarIMethods
 end
 
 class Mechanize::DirectorySaver < ::Mechanize::Download
-  def initialize(uri = _, response = _, body_io = _, code = _); end
+  def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body_io = T.unsafe(nil), code = T.unsafe(nil)); end
 
-  def self.decode_filename?; end
+  class << self
-  def self.directory; end
+    def decode_filename?; end
-  def self.overwrite?; end
+    def directory; end
-  def self.save_to(directory, options = _); end
+    def overwrite?; end
+    def save_to(directory, options = T.unsafe(nil)); end
+  end
 end
 
 class Mechanize::Download
   include(::Mechanize::Parser)
 
-  def initialize(uri = _, response = _, body_io = _, code = _); end
+  def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body_io = T.unsafe(nil), code = T.unsafe(nil)); end
 
   def body; end
   def body_io; end
   def content; end
   def filename; end
   def filename=(_); end
-  def save(filename = _); end
+  def save(filename = T.unsafe(nil)); end
-  def save!(filename = _); end
+  def save!(filename = T.unsafe(nil)); end
-  def save_as(filename = _); end
+  def save_as(filename = T.unsafe(nil)); end
 end
 
 module Mechanize::ElementMatcher
-  def elements_with(singular, plural = _); end
+  def elements_with(singular, plural = T.unsafe(nil)); end
 end
 
 class Mechanize::ElementNotFoundError < ::Mechanize::Error
@@ -246,22 +253,24 @@ end
 class Mechanize::File
   include(::Mechanize::Parser)
 
-  def initialize(uri = _, response = _, body = _, code = _); end
+  def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body = T.unsafe(nil), code = T.unsafe(nil)); end
 
   def body; end
   def body=(_); end
   def content; end
   def filename; end
   def filename=(_); end
-  def save(filename = _); end
+  def save(filename = T.unsafe(nil)); end
-  def save!(filename = _); end
+  def save!(filename = T.unsafe(nil)); end
-  def save_as(filename = _); end
+  def save_as(filename = T.unsafe(nil)); end
 end
 
 class Mechanize::FileConnection
   def request(uri, request); end
 
-  def self.new(*a); end
+  class << self
+    def new(*a); end
+  end
 end
 
 class Mechanize::FileRequest
@@ -297,39 +306,39 @@ class Mechanize::FileResponse
 end
 
 class Mechanize::FileSaver < ::Mechanize::Download
-  def initialize(uri = _, response = _, body_io = _, code = _); end
+  def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body_io = T.unsafe(nil), code = T.unsafe(nil)); end
 
   def filename; end
-  def save_as(filename = _); end
+  def save_as(filename = T.unsafe(nil)); end
 end
 
 class Mechanize::Form
   extend(::Forwardable)
   extend(::Mechanize::ElementMatcher)
 
-  def initialize(node, mech = _, page = _); end
+  def initialize(node, mech = T.unsafe(nil), page = T.unsafe(nil)); end
 
   def [](field_name); end
   def []=(field_name, value); end
   def action; end
   def action=(_); end
   def add_button_to_query(button); end
-  def add_field!(field_name, value = _); end
+  def add_field!(field_name, value = T.unsafe(nil)); end
   def at(*args, &block); end
   def at_css(*args, &block); end
   def at_xpath(*args, &block); end
-  def build_query(buttons = _); end
+  def build_query(buttons = T.unsafe(nil)); end
-  def button(criteria = _); end
+  def button(criteria = T.unsafe(nil)); end
-  def button_with(criteria = _); end
+  def button_with(criteria = T.unsafe(nil)); end
-  def button_with!(criteria = _); end
+  def button_with!(criteria = T.unsafe(nil)); end
   def buttons; end
-  def buttons_with(criteria = _); end
+  def buttons_with(criteria = T.unsafe(nil)); end
-  def checkbox(criteria = _); end
+  def checkbox(criteria = T.unsafe(nil)); end
-  def checkbox_with(criteria = _); end
+  def checkbox_with(criteria = T.unsafe(nil)); end
-  def checkbox_with!(criteria = _); end
+  def checkbox_with!(criteria = T.unsafe(nil)); end
   def checkboxes; end
-  def checkboxes_with(criteria = _); end
+  def checkboxes_with(criteria = T.unsafe(nil)); end
-  def click_button(button = _); end
+  def click_button(button = T.unsafe(nil)); end
   def css(*args, &block); end
   def delete_field!(field_name); end
   def dom_class; end
@@ -339,16 +348,16 @@ class Mechanize::Form
   def encoding=(_); end
   def enctype; end
   def enctype=(_); end
-  def field(criteria = _); end
+  def field(criteria = T.unsafe(nil)); end
-  def field_with(criteria = _); end
+  def field_with(criteria = T.unsafe(nil)); end
-  def field_with!(criteria = _); end
+  def field_with!(criteria = T.unsafe(nil)); end
   def fields; end
-  def fields_with(criteria = _); end
+  def fields_with(criteria = T.unsafe(nil)); end
-  def file_upload(criteria = _); end
+  def file_upload(criteria = T.unsafe(nil)); end
-  def file_upload_with(criteria = _); end
+  def file_upload_with(criteria = T.unsafe(nil)); end
-  def file_upload_with!(criteria = _); end
+  def file_upload_with!(criteria = T.unsafe(nil)); end
   def file_uploads; end
-  def file_uploads_with(criteria = _); end
+  def file_uploads_with(criteria = T.unsafe(nil)); end
   def form_node; end
   def has_field?(field_name); end
   def has_key?(field_name); end
@@ -368,24 +377,24 @@ class Mechanize::Form
   def node; end
   def page; end
   def pretty_print(q); end
-  def radiobutton(criteria = _); end
+  def radiobutton(criteria = T.unsafe(nil)); end
-  def radiobutton_with(criteria = _); end
+  def radiobutton_with(criteria = T.unsafe(nil)); end
-  def radiobutton_with!(criteria = _); end
+  def radiobutton_with!(criteria = T.unsafe(nil)); end
   def radiobuttons; end
-  def radiobuttons_with(criteria = _); end
+  def radiobuttons_with(criteria = T.unsafe(nil)); end
   def request_data; end
   def reset; end
   def reset_button?(button_name); end
   def resets; end
   def save_hash_field_order; end
   def search(*args, &block); end
-  def select_buttons(selector, method = _); end
+  def select_buttons(selector, method = T.unsafe(nil)); end
-  def select_checkboxes(selector, method = _); end
+  def select_checkboxes(selector, method = T.unsafe(nil)); end
-  def select_fields(selector, method = _); end
+  def select_fields(selector, method = T.unsafe(nil)); end
-  def select_file_uploads(selector, method = _); end
+  def select_file_uploads(selector, method = T.unsafe(nil)); end
-  def select_radiobuttons(selector, method = _); end
+  def select_radiobuttons(selector, method = T.unsafe(nil)); end
-  def set_fields(fields = _); end
+  def set_fields(fields = T.unsafe(nil)); end
-  def submit(button = _, headers = _); end
+  def submit(button = T.unsafe(nil), headers = T.unsafe(nil)); end
   def submit_button?(button_name); end
   def submits; end
   def text_field?(field_name); end
@@ -397,13 +406,13 @@ class Mechanize::Form
 
   private
 
-  def file_to_multipart(file, buf = _); end
+  def file_to_multipart(file, buf = T.unsafe(nil)); end
   def from_native_charset(str); end
   def mime_value_quote(str); end
-  def param_to_multipart(name, value, buf = _); end
+  def param_to_multipart(name, value, buf = T.unsafe(nil)); end
   def parse; end
   def proc_query(field); end
-  def rand_string(len = _); end
+  def rand_string(len = T.unsafe(nil)); end
 end
 
 class Mechanize::Form::Button < ::Mechanize::Form::Field
@@ -419,7 +428,7 @@ end
 class Mechanize::Form::Field
   extend(::Forwardable)
 
-  def initialize(node, value = _); end
+  def initialize(node, value = T.unsafe(nil)); end
 
   def <=>(other); end
   def at(*args, &block); end
@@ -470,10 +479,10 @@ class Mechanize::Form::ImageButton < ::Mechanize::Form::Button
 end
 
 class Mechanize::Form::Keygen < ::Mechanize::Form::Field
-  def initialize(node, value = _); end
+  def initialize(node, value = T.unsafe(nil)); end
 
   def challenge; end
-  def generate_key(key_size = _); end
+  def generate_key(key_size = T.unsafe(nil)); end
   def key; end
 end
 
@@ -482,16 +491,16 @@ class Mechanize::Form::MultiSelectList < ::Mechanize::Form::Field
 
   def initialize(node); end
 
-  def option(criteria = _); end
+  def option(criteria = T.unsafe(nil)); end
-  def option_with(criteria = _); end
+  def option_with(criteria = T.unsafe(nil)); end
-  def option_with!(criteria = _); end
+  def option_with!(criteria = T.unsafe(nil)); end
   def options; end
   def options=(_); end
-  def options_with(criteria = _); end
+  def options_with(criteria = T.unsafe(nil)); end
   def query_value; end
   def select_all; end
   def select_none; end
-  def select_options(selector, method = _); end
+  def select_options(selector, method = T.unsafe(nil)); end
   def selected_options; end
   def value; end
   def value=(values); end
@@ -565,10 +574,10 @@ class Mechanize::HTTP
 end
 
 class Mechanize::HTTP::Agent
-  def initialize(connection_name = _); end
+  def initialize(connection_name = T.unsafe(nil)); end
 
-  def add_auth(uri, user, password, realm = _, domain = _); end
+  def add_auth(uri, user, password, realm = T.unsafe(nil), domain = T.unsafe(nil)); end
-  def add_default_auth(user, password, domain = _); end
+  def add_default_auth(user, password, domain = T.unsafe(nil)); end
   def allowed_error_codes; end
   def allowed_error_codes=(_); end
   def auth_store; end
@@ -595,7 +604,7 @@ class Mechanize::HTTP::Agent
   def digest_challenges; end
   def disable_keep_alive(request); end
   def enable_gzip(request); end
-  def fetch(uri, method = _, headers = _, params = _, referer = _, redirects = _); end
+  def fetch(uri, method = T.unsafe(nil), headers = T.unsafe(nil), params = T.unsafe(nil), referer = T.unsafe(nil), redirects = T.unsafe(nil)); end
   def follow_meta_refresh; end
   def follow_meta_refresh=(_); end
   def follow_meta_refresh_self; end
@@ -608,12 +617,12 @@ class Mechanize::HTTP::Agent
   def history=(_); end
   def hook_content_encoding(response, uri, response_body_io); end
   def http; end
-  def http_request(uri, method, params = _); end
+  def http_request(uri, method, params = T.unsafe(nil)); end
   def idle_timeout; end
   def idle_timeout=(timeout); end
   def ignore_bad_chunking; end
   def ignore_bad_chunking=(_); end
-  def inflate(compressed, window_bits = _); end
+  def inflate(compressed, window_bits = T.unsafe(nil)); end
   def keep_alive; end
   def keep_alive=(_); end
   def log; end
@@ -639,7 +648,7 @@ class Mechanize::HTTP::Agent
   def redirect_ok=(_); end
   def redirection_limit; end
   def redirection_limit=(_); end
-  def request_add_headers(request, headers = _); end
+  def request_add_headers(request, headers = T.unsafe(nil)); end
   def request_auth(request, uri); end
   def request_auth_digest(request, uri, realm, base_uri, iis); end
   def request_cookies(request, uri); end
@@ -651,7 +660,7 @@ class Mechanize::HTTP::Agent
   def request_referer(request, uri, referer); end
   def request_user_agent(request); end
   def reset; end
-  def resolve(uri, referer = _); end
+  def resolve(uri, referer = T.unsafe(nil)); end
   def resolve_parameters(uri, method, parameters); end
   def response_authenticate(response, page, uri, request, headers, params, referer); end
   def response_content_encoding(response, body_io); end
@@ -660,7 +669,7 @@ class Mechanize::HTTP::Agent
   def response_log(response); end
   def response_parse(response, body_io, uri); end
   def response_read(response, request, uri); end
-  def response_redirect(response, method, page, redirects, headers, referer = _); end
+  def response_redirect(response, method, page, redirects, headers, referer = T.unsafe(nil)); end
   def retry_change_requests; end
   def retry_change_requests=(retri); end
   def robots; end
@@ -674,8 +683,8 @@ class Mechanize::HTTP::Agent
   def save_cookies(uri, set_cookie); end
   def scheme_handlers; end
   def scheme_handlers=(_); end
-  def secure_resolve!(uri, referer = _); end
+  def secure_resolve!(uri, referer = T.unsafe(nil)); end
-  def set_proxy(addr, port = _, user = _, pass = _); end
+  def set_proxy(addr, port = T.unsafe(nil), user = T.unsafe(nil), pass = T.unsafe(nil)); end
   def shutdown; end
   def ssl_version; end
   def ssl_version=(ssl_version); end
@@ -704,10 +713,12 @@ class Mechanize::HTTP::AuthChallenge < ::Struct
   def scheme=(_); end
   def to_s; end
 
-  def self.[](*_); end
+  class << self
-  def self.inspect; end
+    def [](*_); end
-  def self.members; end
+    def inspect; end
-  def self.new(*_); end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class Mechanize::HTTP::AuthRealm
@@ -725,13 +736,13 @@ end
 class Mechanize::HTTP::AuthStore
   def initialize; end
 
-  def add_auth(uri, user, pass, realm = _, domain = _); end
+  def add_auth(uri, user, pass, realm = T.unsafe(nil), domain = T.unsafe(nil)); end
-  def add_default_auth(user, pass, domain = _); end
+  def add_default_auth(user, pass, domain = T.unsafe(nil)); end
   def auth_accounts; end
   def credentials?(uri, challenges); end
   def credentials_for(uri, realm); end
   def default_auth; end
-  def remove_auth(uri, realm = _); end
+  def remove_auth(uri, realm = T.unsafe(nil)); end
 end
 
 class Mechanize::HTTP::ContentDisposition < ::Struct
@@ -750,16 +761,18 @@ class Mechanize::HTTP::ContentDisposition < ::Struct
   def type; end
   def type=(_); end
 
-  def self.[](*_); end
+  class << self
-  def self.inspect; end
+    def [](*_); end
-  def self.members; end
+    def inspect; end
-  def self.new(*_); end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class Mechanize::HTTP::ContentDispositionParser
   def initialize; end
 
-  def parse(content_disposition, header = _); end
+  def parse(content_disposition, header = T.unsafe(nil)); end
   def parse_parameters; end
   def rfc_2045_quoted_string; end
   def rfc_2045_token; end
@@ -768,7 +781,9 @@ class Mechanize::HTTP::ContentDispositionParser
   def scanner=(_); end
   def spaces; end
 
-  def self.parse(content_disposition); end
+  class << self
+    def parse(content_disposition); end
+  end
 end
 
 class Mechanize::HTTP::WWWAuthenticateParser
@@ -793,15 +808,15 @@ class Mechanize::Headers < ::Hash
 end
 
 class Mechanize::History < ::Array
-  def initialize(max_size = _); end
+  def initialize(max_size = T.unsafe(nil)); end
 
-  def <<(page, uri = _); end
+  def <<(page, uri = T.unsafe(nil)); end
   def clear; end
   def inspect; end
   def max_size; end
   def max_size=(_); end
   def pop; end
-  def push(page, uri = _); end
+  def push(page, uri = T.unsafe(nil)); end
   def shift; end
   def visited?(uri); end
   def visited_page(uri); end
@@ -819,55 +834,55 @@ class Mechanize::Page < ::Mechanize::File
   extend(::Forwardable)
   extend(::Mechanize::ElementMatcher)
 
-  def initialize(uri = _, response = _, body = _, code = _, mech = _); end
+  def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body = T.unsafe(nil), code = T.unsafe(nil), mech = T.unsafe(nil)); end
 
   def %(*args, &block); end
   def /(*args, &block); end
   def at(*args, &block); end
   def at_css(*args, &block); end
   def at_xpath(*args, &block); end
-  def base(criteria = _); end
+  def base(criteria = T.unsafe(nil)); end
-  def base_with(criteria = _); end
+  def base_with(criteria = T.unsafe(nil)); end
-  def base_with!(criteria = _); end
+  def base_with!(criteria = T.unsafe(nil)); end
   def bases; end
-  def bases_with(criteria = _); end
+  def bases_with(criteria = T.unsafe(nil)); end
   def canonical_uri; end
   def content_type; end
   def css(*args, &block); end
   def detected_encoding; end
   def encoding; end
   def encoding=(encoding); end
-  def encoding_error?(parser = _); end
+  def encoding_error?(parser = T.unsafe(nil)); end
   def encodings; end
-  def form(criteria = _); end
+  def form(criteria = T.unsafe(nil)); end
-  def form_with(criteria = _); end
+  def form_with(criteria = T.unsafe(nil)); end
-  def form_with!(criteria = _); end
+  def form_with!(criteria = T.unsafe(nil)); end
   def forms; end
-  def forms_with(criteria = _); end
+  def forms_with(criteria = T.unsafe(nil)); end
-  def frame(criteria = _); end
+  def frame(criteria = T.unsafe(nil)); end
-  def frame_with(criteria = _); end
+  def frame_with(criteria = T.unsafe(nil)); end
-  def frame_with!(criteria = _); end
+  def frame_with!(criteria = T.unsafe(nil)); end
   def frames; end
-  def frames_with(criteria = _); end
+  def frames_with(criteria = T.unsafe(nil)); end
-  def iframe(criteria = _); end
+  def iframe(criteria = T.unsafe(nil)); end
-  def iframe_with(criteria = _); end
+  def iframe_with(criteria = T.unsafe(nil)); end
-  def iframe_with!(criteria = _); end
+  def iframe_with!(criteria = T.unsafe(nil)); end
   def iframes; end
-  def iframes_with(criteria = _); end
+  def iframes_with(criteria = T.unsafe(nil)); end
-  def image(criteria = _); end
+  def image(criteria = T.unsafe(nil)); end
   def image_urls; end
-  def image_with(criteria = _); end
+  def image_with(criteria = T.unsafe(nil)); end
-  def image_with!(criteria = _); end
+  def image_with!(criteria = T.unsafe(nil)); end
   def images; end
-  def images_with(criteria = _); end
+  def images_with(criteria = T.unsafe(nil)); end
   def inspect; end
   def labels; end
   def labels_hash; end
-  def link(criteria = _); end
+  def link(criteria = T.unsafe(nil)); end
-  def link_with(criteria = _); end
+  def link_with(criteria = T.unsafe(nil)); end
-  def link_with!(criteria = _); end
+  def link_with!(criteria = T.unsafe(nil)); end
   def links; end
-  def links_with(criteria = _); end
+  def links_with(criteria = T.unsafe(nil)); end
   def mech; end
   def mech=(_); end
   def meta_charset; end
@@ -878,12 +893,12 @@ class Mechanize::Page < ::Mechanize::File
   def response_header_charset; end
   def root; end
   def search(*args, &block); end
-  def select_bases(selector, method = _); end
+  def select_bases(selector, method = T.unsafe(nil)); end
-  def select_forms(selector, method = _); end
+  def select_forms(selector, method = T.unsafe(nil)); end
-  def select_frames(selector, method = _); end
+  def select_frames(selector, method = T.unsafe(nil)); end
-  def select_iframes(selector, method = _); end
+  def select_iframes(selector, method = T.unsafe(nil)); end
-  def select_images(selector, method = _); end
+  def select_images(selector, method = T.unsafe(nil)); end
-  def select_links(selector, method = _); end
+  def select_links(selector, method = T.unsafe(nil)); end
   def title; end
   def xpath(*args, &block); end
 
@@ -891,11 +906,13 @@ class Mechanize::Page < ::Mechanize::File
 
   def html_body; end
 
-  def self.charset(content_type); end
+  class << self
-  def self.charset_from_content_type(content_type); end
+    def charset(content_type); end
-  def self.meta_charset(body); end
+    def charset_from_content_type(content_type); end
-  def self.meta_content_type(body); end
+    def meta_charset(body); end
-  def self.response_header_charset(response); end
+    def meta_content_type(body); end
+    def response_header_charset(response); end
+  end
 end
 
 class Mechanize::Page::Base < ::Mechanize::Page::Link
@@ -921,7 +938,7 @@ class Mechanize::Page::Image
   def dom_class; end
   def dom_id; end
   def extname; end
-  def fetch(parameters = _, referer = _, headers = _); end
+  def fetch(parameters = T.unsafe(nil), referer = T.unsafe(nil), headers = T.unsafe(nil)); end
   def height; end
   def image_referer; end
   def inspect; end
@@ -975,14 +992,16 @@ class Mechanize::Page::Link
 end
 
 class Mechanize::Page::MetaRefresh < ::Mechanize::Page::Link
-  def initialize(node, page, delay, href, link_self = _); end
+  def initialize(node, page, delay, href, link_self = T.unsafe(nil)); end
 
   def delay; end
   def link_self; end
   def noreferrer?; end
 
-  def self.from_node(node, page, uri = _); end
+  class << self
-  def self.parse(content, base_uri = _); end
+    def from_node(node, page, uri = T.unsafe(nil)); end
+    def parse(content, base_uri = T.unsafe(nil)); end
+  end
 end
 
 Mechanize::Page::MetaRefresh::CONTENT_REGEXP = T.let(T.unsafe(nil), Regexp)
@@ -998,7 +1017,7 @@ module Mechanize::Parser
   def code; end
   def code=(_); end
   def each(*args, &block); end
-  def extract_filename(full_path = _); end
+  def extract_filename(full_path = T.unsafe(nil)); end
   def fill_header(response); end
   def find_free_name(filename); end
   def header; end
@@ -1051,7 +1070,7 @@ class Mechanize::RedirectNotGetOrHeadError < ::Mechanize::Error
 end
 
 class Mechanize::ResponseCodeError < ::Mechanize::Error
-  def initialize(page, message = _); end
+  def initialize(page, message = T.unsafe(nil)); end
 
   def inspect; end
   def page; end
@@ -1097,14 +1116,20 @@ class Mechanize::UnsupportedSchemeError < ::Mechanize::Error
 end
 
 class Mechanize::Util
-  def self.build_query_string(parameters, enc = _); end
+  class << self
-  def self.detect_charset(src); end
+    def build_query_string(parameters, enc = T.unsafe(nil)); end
-  def self.each_parameter(parameters, &block); end
+    def detect_charset(src); end
-  def self.from_native_charset(s, code, ignore_encoding_error = _, log = _); end
+    def each_parameter(parameters, &block); end
-  def self.guess_encoding(src); end
+    def from_native_charset(s, code, ignore_encoding_error = T.unsafe(nil), log = T.unsafe(nil)); end
-  def self.html_unescape(s); end
+    def guess_encoding(src); end
-  def self.uri_escape(str, unsafe = _); end
+    def html_unescape(s); end
-  def self.uri_unescape(str); end
+    def uri_escape(str, unsafe = T.unsafe(nil)); end
+    def uri_unescape(str); end
+
+    private
+
+    def each_parameter_1(key, value, &block); end
+  end
 end
 
 Mechanize::Util::DefaultMimeTypes = T.let(T.unsafe(nil), Hash)
@@ -1114,7 +1139,7 @@ Mechanize::VERSION = T.let(T.unsafe(nil), String)
 class Mechanize::XmlFile < ::Mechanize::File
   extend(::Forwardable)
 
-  def initialize(uri = _, response = _, body = _, code = _); end
+  def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body = T.unsafe(nil), code = T.unsafe(nil)); end
 
   def at(*args, &block); end
   def search(*args, &block); end

Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `method_source` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/mime-types-data@3.2020.0512.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `mime-types-data` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -12,9 +13,9 @@ class MIME::Types
 
   def initialize; end
 
-  def [](type_id, complete: _, registered: _); end
+  def [](type_id, complete: T.unsafe(nil), registered: T.unsafe(nil)); end
   def add(*types); end
-  def add_type(type, quiet = _); end
+  def add_type(type, quiet = T.unsafe(nil)); end
   def count; end
   def each; end
   def inspect; end
@@ -29,15 +30,26 @@ class MIME::Types
   def prune_matches(matches, complete, registered); end
   def reindex_extensions!(mime_type); end
 
-  def self.[](type_id, complete: _, registered: _); end
+  class << self
-  def self.add(*types); end
+    def [](type_id, complete: T.unsafe(nil), registered: T.unsafe(nil)); end
-  def self.count; end
+    def add(*types); end
-  def self.each; end
+    def count; end
-  def self.logger; end
+    def each; end
-  def self.logger=(_); end
+    def logger; end
-  def self.new(*_); end
+    def logger=(_); end
-  def self.of(filename); end
+    def new(*_); end
-  def self.type_for(filename); end
+    def of(filename); end
+    def type_for(filename); end
+
+    private
+
+    def __instances__; end
+    def __types__; end
+    def lazy_load?; end
+    def load_default_mime_types(mode = T.unsafe(nil)); end
+    def load_mode; end
+    def reindex_extensions(type); end
+  end
 end
 
 class MIME::Types::Cache < ::Struct
@@ -46,12 +58,14 @@ class MIME::Types::Cache < ::Struct
   def version; end
   def version=(_); end
 
-  def self.[](*_); end
+  class << self
-  def self.inspect; end
+    def [](*_); end
-  def self.load(cache_file = _); end
+    def inspect; end
-  def self.members; end
+    def load(cache_file = T.unsafe(nil)); end
-  def self.new(*_); end
+    def members; end
-  def self.save(types = _, cache_file = _); end
+    def new(*_); end
+    def save(types = T.unsafe(nil), cache_file = T.unsafe(nil)); end
+  end
 end
 
 module MIME::Types::Data

Library/Homebrew/sorbet/rbi/gems/mime-types@3.3.1.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `mime-types` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -26,7 +27,7 @@ class MIME::Type
   def eql?(other); end
   def extensions; end
   def extensions=(value); end
-  def friendly(lang = _); end
+  def friendly(lang = T.unsafe(nil)); end
   def i18n_key; end
   def init_with(coder); end
   def inspect; end
@@ -69,9 +70,15 @@ class MIME::Type
   def xref_url_for_rfc_errata(value); end
   def xref_url_for_template(value); end
 
-  def self.i18n_key(content_type); end
+  class << self
-  def self.match(content_type); end
+    def i18n_key(content_type); end
-  def self.simplified(content_type, remove_x_prefix: _); end
+    def match(content_type); end
+    def simplified(content_type, remove_x_prefix: T.unsafe(nil)); end
+
+    private
+
+    def simplify_matchdata(matchdata, remove_x = T.unsafe(nil), joiner: T.unsafe(nil)); end
+  end
 end
 
 class MIME::Type::Columnar < ::MIME::Type
@@ -121,9 +128,9 @@ class MIME::Types
 
   def initialize; end
 
-  def [](type_id, complete: _, registered: _); end
+  def [](type_id, complete: T.unsafe(nil), registered: T.unsafe(nil)); end
   def add(*types); end
-  def add_type(type, quiet = _); end
+  def add_type(type, quiet = T.unsafe(nil)); end
   def count; end
   def each; end
   def inspect; end
@@ -138,15 +145,26 @@ class MIME::Types
   def prune_matches(matches, complete, registered); end
   def reindex_extensions!(mime_type); end
 
-  def self.[](type_id, complete: _, registered: _); end
+  class << self
-  def self.add(*types); end
+    def [](type_id, complete: T.unsafe(nil), registered: T.unsafe(nil)); end
-  def self.count; end
+    def add(*types); end
-  def self.each; end
+    def count; end
-  def self.logger; end
+    def each; end
-  def self.logger=(_); end
+    def logger; end
-  def self.new(*_); end
+    def logger=(_); end
-  def self.of(filename); end
+    def new(*_); end
-  def self.type_for(filename); end
+    def of(filename); end
+    def type_for(filename); end
+
+    private
+
+    def __instances__; end
+    def __types__; end
+    def lazy_load?; end
+    def load_default_mime_types(mode = T.unsafe(nil)); end
+    def load_mode; end
+    def reindex_extensions(type); end
+  end
 end
 
 class MIME::Types::Cache < ::Struct
@@ -155,12 +173,14 @@ class MIME::Types::Cache < ::Struct
   def version; end
   def version=(_); end
 
-  def self.[](*_); end
+  class << self
-  def self.inspect; end
+    def [](*_); end
-  def self.load(cache_file = _); end
+    def inspect; end
-  def self.members; end
+    def load(cache_file = T.unsafe(nil)); end
-  def self.new(*_); end
+    def members; end
-  def self.save(types = _, cache_file = _); end
+    def new(*_); end
+    def save(types = T.unsafe(nil), cache_file = T.unsafe(nil)); end
+  end
 end
 
 module MIME::Types::Columnar
@@ -169,8 +189,8 @@ module MIME::Types::Columnar
   private
 
   def arr(line); end
-  def dict(line, array: _); end
+  def dict(line, array: T.unsafe(nil)); end
-  def each_file_line(name, lookup = _); end
+  def each_file_line(name, lookup = T.unsafe(nil)); end
   def flag(line); end
   def load_docs; end
   def load_encoding; end
@@ -181,7 +201,9 @@ module MIME::Types::Columnar
   def load_xrefs; end
   def opt(line); end
 
-  def self.extended(obj); end
+  class << self
+    def extended(obj); end
+  end
 end
 
 MIME::Types::Columnar::LOAD_MUTEX = T.let(T.unsafe(nil), Thread::Mutex)
@@ -189,7 +211,7 @@ MIME::Types::Columnar::LOAD_MUTEX = T.let(T.unsafe(nil), Thread::Mutex)
 class MIME::Types::Container
   extend(::Forwardable)
 
-  def initialize(hash = _); end
+  def initialize(hash = T.unsafe(nil)); end
 
   def ==(*args, &block); end
   def [](key); end
@@ -219,10 +241,10 @@ class MIME::Types::Container
 end
 
 class MIME::Types::Loader
-  def initialize(path = _, container = _); end
+  def initialize(path = T.unsafe(nil), container = T.unsafe(nil)); end
 
   def container; end
-  def load(options = _); end
+  def load(options = T.unsafe(nil)); end
   def load_columnar; end
   def load_json; end
   def load_yaml; end
@@ -234,15 +256,21 @@ class MIME::Types::Loader
   def json_path; end
   def yaml_path; end
 
-  def self.load(options = _); end
+  class << self
-  def self.load_from_json(filename); end
+    def load(options = T.unsafe(nil)); end
-  def self.load_from_yaml(filename); end
+    def load_from_json(filename); end
+    def load_from_yaml(filename); end
+
+    private
+
+    def read_file(filename); end
+  end
 end
 
 MIME::Types::VERSION = T.let(T.unsafe(nil), String)
 
 class MIME::Types::WarnLogger < ::Logger
-  def initialize(_one, _two = _, _three = _); end
+  def initialize(_one, _two = T.unsafe(nil), _three = T.unsafe(nil)); end
 end
 
 class MIME::Types::WarnLogger::WarnLogDevice < ::Logger::LogDevice

Library/Homebrew/sorbet/rbi/gems/mini_portile2@2.4.0.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `mini_portile2` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/minitest@5.14.1.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `minitest` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `mustache` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `net-http-digest_auth` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.0.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `net-http-persistent` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/nokogiri@1.10.10.rbi

@@ -1,23 +1,28 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync --exclude json
+# This is an autogenerated file for types exported from the `nokogiri` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module Nokogiri
-  def self.HTML(thing, url = _, encoding = _, options = _, &block); end
+  class << self
-  def self.Slop(*args, &block); end
+    def HTML(thing, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
-  def self.XML(thing, url = _, encoding = _, options = _, &block); end
+    def Slop(*args, &block); end
-  def self.XSLT(stylesheet, modules = _); end
+    def XML(thing, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
-  def self.install_default_aliases; end
+    def XSLT(stylesheet, modules = T.unsafe(nil)); end
-  def self.jruby?; end
+    def install_default_aliases; end
-  def self.make(input = _, opts = _, &blk); end
+    def jruby?; end
-  def self.parse(string, url = _, encoding = _, options = _); end
+    def make(input = T.unsafe(nil), opts = T.unsafe(nil), &blk); end
-  def self.uses_libxml?; end
+    def parse(string, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
+    def uses_libxml?; end
+  end
 end
 
 module Nokogiri::CSS
-  def self.parse(selector); end
+  class << self
-  def self.xpath_for(selector, options = _); end
+    def parse(selector); end
+    def xpath_for(selector, options = T.unsafe(nil)); end
+  end
 end
 
 class Nokogiri::CSS::Node
@@ -27,7 +32,7 @@ class Nokogiri::CSS::Node
   def find_by_type(types); end
   def to_a; end
   def to_type; end
-  def to_xpath(prefix = _, visitor = _); end
+  def to_xpath(prefix = T.unsafe(nil), visitor = T.unsafe(nil)); end
   def type; end
   def type=(_); end
   def value; end
@@ -37,7 +42,7 @@ end
 Nokogiri::CSS::Node::ALLOW_COMBINATOR_ON_SELF = T.let(T.unsafe(nil), Array)
 
 class Nokogiri::CSS::Parser < ::Racc::Parser
-  def initialize(namespaces = _); end
+  def initialize(namespaces = T.unsafe(nil)); end
 
   def _reduce_1(val, _values, result); end
   def _reduce_11(val, _values, result); end
@@ -101,17 +106,19 @@ class Nokogiri::CSS::Parser < ::Racc::Parser
   def parse(string); end
   def unescape_css_identifier(identifier); end
   def unescape_css_string(str); end
-  def xpath_for(string, options = _); end
+  def xpath_for(string, options = T.unsafe(nil)); end
 
-  def self.[](string); end
+  class << self
-  def self.[]=(string, value); end
+    def [](string); end
-  def self.cache_on; end
+    def []=(string, value); end
-  def self.cache_on=(_); end
+    def cache_on; end
-  def self.cache_on?; end
+    def cache_on=(_); end
-  def self.clear_cache; end
+    def cache_on?; end
-  def self.parse(selector); end
+    def clear_cache; end
-  def self.set_cache(_); end
+    def parse(selector); end
-  def self.without_cache(&block); end
+    def set_cache(_); end
+    def without_cache(&block); end
+  end
 end
 
 Nokogiri::CSS::Parser::Racc_arg = T.let(T.unsafe(nil), Array)
@@ -158,7 +165,7 @@ class Nokogiri::CSS::XPathVisitor
   private
 
   def is_of_type_pseudo_class?(node); end
-  def nth(node, options = _); end
+  def nth(node, options = T.unsafe(nil)); end
   def read_a_and_positive_b(values); end
 end
 
@@ -170,7 +177,7 @@ module Nokogiri::Decorators::Slop
 
   private
 
-  def respond_to_missing?(name, include_private = _); end
+  def respond_to_missing?(name, include_private = T.unsafe(nil)); end
 end
 
 Nokogiri::Decorators::Slop::XPATH_PREFIX = T.let(T.unsafe(nil), String)
@@ -178,15 +185,19 @@ Nokogiri::Decorators::Slop::XPATH_PREFIX = T.let(T.unsafe(nil), String)
 class Nokogiri::EncodingHandler
   def name; end
 
-  def self.[](_); end
+  class << self
-  def self.alias(_, _); end
+    def [](_); end
-  def self.clear_aliases!; end
+    def alias(_, _); end
-  def self.delete(_); end
+    def clear_aliases!; end
+    def delete(_); end
+  end
 end
 
 module Nokogiri::HTML
-  def self.fragment(string, encoding = _); end
+  class << self
-  def self.parse(thing, url = _, encoding = _, options = _, &block); end
+    def fragment(string, encoding = T.unsafe(nil)); end
+    def parse(thing, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
+  end
 end
 
 class Nokogiri::HTML::Builder < ::Nokogiri::XML::Builder
@@ -194,13 +205,13 @@ class Nokogiri::HTML::Builder < ::Nokogiri::XML::Builder
 end
 
 class Nokogiri::HTML::Document < ::Nokogiri::XML::Document
-  def fragment(tags = _); end
+  def fragment(tags = T.unsafe(nil)); end
   def meta_encoding; end
   def meta_encoding=(encoding); end
-  def meta_robots(custom_name = _); end
+  def meta_robots(custom_name = T.unsafe(nil)); end
-  def nofollow?(custom_name = _); end
+  def nofollow?(custom_name = T.unsafe(nil)); end
-  def noindex?(custom_name = _); end
+  def noindex?(custom_name = T.unsafe(nil)); end
-  def serialize(options = _); end
+  def serialize(options = T.unsafe(nil)); end
   def title; end
   def title=(text); end
   def type; end
@@ -211,10 +222,12 @@ class Nokogiri::HTML::Document < ::Nokogiri::XML::Document
   def parse_meta_robots(custom_name); end
   def set_metadata_element(element); end
 
-  def self.new(*_); end
+  class << self
-  def self.parse(string_or_io, url = _, encoding = _, options = _); end
+    def new(*_); end
-  def self.read_io(_, _, _, _); end
+    def parse(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
-  def self.read_memory(_, _, _, _); end
+    def read_io(_, _, _, _); end
+    def read_memory(_, _, _, _); end
+  end
 end
 
 class Nokogiri::HTML::Document::EncodingFound < ::StandardError
@@ -229,28 +242,32 @@ class Nokogiri::HTML::Document::EncodingReader
   def encoding_found; end
   def read(len); end
 
-  def self.detect_encoding(chunk); end
+  class << self
-  def self.detect_encoding_for_jruby_without_fix(chunk); end
+    def detect_encoding(chunk); end
-  def self.is_jruby_without_fix?; end
+    def detect_encoding_for_jruby_without_fix(chunk); end
+    def is_jruby_without_fix?; end
+  end
 end
 
 class Nokogiri::HTML::Document::EncodingReader::JumpSAXHandler < ::Nokogiri::HTML::Document::EncodingReader::SAXHandler
   def initialize(jumptag); end
 
-  def start_element(name, attrs = _); end
+  def start_element(name, attrs = T.unsafe(nil)); end
 end
 
 class Nokogiri::HTML::Document::EncodingReader::SAXHandler < ::Nokogiri::XML::SAX::Document
   def initialize; end
 
   def encoding; end
-  def start_element(name, attrs = _); end
+  def start_element(name, attrs = T.unsafe(nil)); end
 end
 
 class Nokogiri::HTML::DocumentFragment < ::Nokogiri::XML::DocumentFragment
-  def initialize(document, tags = _, ctx = _); end
+  def initialize(document, tags = T.unsafe(nil), ctx = T.unsafe(nil)); end
 
-  def self.parse(tags, encoding = _); end
+  class << self
+    def parse(tags, encoding = T.unsafe(nil)); end
+  end
 end
 
 class Nokogiri::HTML::ElementDescription
@@ -275,7 +292,9 @@ class Nokogiri::HTML::ElementDescription
 
   def default_desc; end
 
-  def self.[](_); end
+  class << self
+    def [](_); end
+  end
 end
 
 Nokogiri::HTML::ElementDescription::ACTION_ATTR = T.let(T.unsafe(nil), Array)
@@ -510,27 +529,29 @@ module Nokogiri::HTML::SAX
 end
 
 class Nokogiri::HTML::SAX::Parser < ::Nokogiri::XML::SAX::Parser
-  def parse_file(filename, encoding = _); end
+  def parse_file(filename, encoding = T.unsafe(nil)); end
-  def parse_io(io, encoding = _); end
+  def parse_io(io, encoding = T.unsafe(nil)); end
-  def parse_memory(data, encoding = _); end
+  def parse_memory(data, encoding = T.unsafe(nil)); end
 end
 
 class Nokogiri::HTML::SAX::ParserContext < ::Nokogiri::XML::SAX::ParserContext
   def parse_with(_); end
 
-  def self.file(_, _); end
+  class << self
-  def self.memory(_, _); end
+    def file(_, _); end
-  def self.new(thing, encoding = _); end
+    def memory(_, _); end
+    def new(thing, encoding = T.unsafe(nil)); end
+  end
 end
 
 class Nokogiri::HTML::SAX::PushParser < ::Nokogiri::XML::SAX::PushParser
-  def initialize(doc = _, file_name = _, encoding = _); end
+  def initialize(doc = T.unsafe(nil), file_name = T.unsafe(nil), encoding = T.unsafe(nil)); end
 
-  def <<(chunk, last_chunk = _); end
+  def <<(chunk, last_chunk = T.unsafe(nil)); end
   def document; end
   def document=(_); end
   def finish; end
-  def write(chunk, last_chunk = _); end
+  def write(chunk, last_chunk = T.unsafe(nil)); end
 
   private
 
@@ -573,15 +594,19 @@ class Nokogiri::VersionInfo
   def to_markdown; end
   def warnings; end
 
-  def self.instance; end
+  class << self
+    def instance; end
+  end
 end
 
 module Nokogiri::XML
-  def self.Reader(string_or_io, url = _, encoding = _, options = _); end
+  class << self
-  def self.RelaxNG(string_or_io); end
+    def Reader(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
-  def self.Schema(string_or_io); end
+    def RelaxNG(string_or_io); end
-  def self.fragment(string); end
+    def Schema(string_or_io); end
-  def self.parse(thing, url = _, encoding = _, options = _, &block); end
+    def fragment(string); end
+    def parse(thing, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
+  end
 end
 
 class Nokogiri::XML::Attr < ::Nokogiri::XML::Node
@@ -594,7 +619,9 @@ class Nokogiri::XML::Attr < ::Nokogiri::XML::Node
 
   def inspect_attributes; end
 
-  def self.new(*_); end
+  class << self
+    def new(*_); end
+  end
 end
 
 class Nokogiri::XML::AttributeDecl < ::Nokogiri::XML::Node
@@ -605,7 +632,7 @@ class Nokogiri::XML::AttributeDecl < ::Nokogiri::XML::Node
 end
 
 class Nokogiri::XML::Builder
-  def initialize(options = _, root = _, &block); end
+  def initialize(options = T.unsafe(nil), root = T.unsafe(nil), &block); end
 
   def <<(string); end
   def [](ns); end
@@ -627,7 +654,9 @@ class Nokogiri::XML::Builder
 
   def insert(node, &block); end
 
-  def self.with(root, &block); end
+  class << self
+    def with(root, &block); end
+  end
 end
 
 class Nokogiri::XML::Builder::NodeBuilder
@@ -641,7 +670,9 @@ end
 class Nokogiri::XML::CDATA < ::Nokogiri::XML::Text
   def name; end
 
-  def self.new(*_); end
+  class << self
+    def new(*_); end
+  end
 end
 
 class Nokogiri::XML::CharacterData < ::Nokogiri::XML::Node
@@ -649,7 +680,9 @@ class Nokogiri::XML::CharacterData < ::Nokogiri::XML::Node
 end
 
 class Nokogiri::XML::Comment < ::Nokogiri::XML::CharacterData
-  def self.new(*_); end
+  class << self
+    def new(*_); end
+  end
 end
 
 class Nokogiri::XML::DTD < ::Nokogiri::XML::Node
@@ -687,7 +720,7 @@ class Nokogiri::XML::Document < ::Nokogiri::XML::Node
   def encoding=(_); end
   def errors; end
   def errors=(_); end
-  def fragment(tags = _); end
+  def fragment(tags = T.unsafe(nil)); end
   def name; end
   def namespaces; end
   def remove_namespaces!; end
@@ -704,12 +737,14 @@ class Nokogiri::XML::Document < ::Nokogiri::XML::Node
 
   def inspect_attributes; end
 
-  def self.empty_doc?(string_or_io); end
+  class << self
-  def self.new(*_); end
+    def empty_doc?(string_or_io); end
-  def self.parse(string_or_io, url = _, encoding = _, options = _); end
+    def new(*_); end
-  def self.read_io(_, _, _, _); end
+    def parse(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
-  def self.read_memory(_, _, _, _); end
+    def read_io(_, _, _, _); end
-  def self.wrap(document); end
+    def read_memory(_, _, _, _); end
+    def wrap(document); end
+  end
 end
 
 Nokogiri::XML::Document::IMPLIED_XPATH_CONTEXTS = T.let(T.unsafe(nil), Array)
@@ -721,7 +756,7 @@ Nokogiri::XML::Document::NCNAME_RE = T.let(T.unsafe(nil), Regexp)
 Nokogiri::XML::Document::NCNAME_START_CHAR = T.let(T.unsafe(nil), String)
 
 class Nokogiri::XML::DocumentFragment < ::Nokogiri::XML::Node
-  def initialize(document, tags = _, ctx = _); end
+  def initialize(document, tags = T.unsafe(nil), ctx = T.unsafe(nil)); end
 
   def css(*args); end
   def dup; end
@@ -740,8 +775,10 @@ class Nokogiri::XML::DocumentFragment < ::Nokogiri::XML::Node
   def coerce(data); end
   def namespace_declarations(ctx); end
 
-  def self.new(*_); end
+  class << self
-  def self.parse(tags); end
+    def new(*_); end
+    def parse(tags); end
+  end
 end
 
 class Nokogiri::XML::Element < ::Nokogiri::XML::Node
@@ -792,7 +829,9 @@ class Nokogiri::XML::EntityDecl < ::Nokogiri::XML::Node
   def original_content; end
   def system_id; end
 
-  def self.new(name, doc, *args); end
+  class << self
+    def new(name, doc, *args); end
+  end
 end
 
 Nokogiri::XML::EntityDecl::EXTERNAL_GENERAL_PARSED = T.let(T.unsafe(nil), Integer)
@@ -811,7 +850,9 @@ class Nokogiri::XML::EntityReference < ::Nokogiri::XML::Node
   def children; end
   def inspect_attributes; end
 
-  def self.new(*_); end
+  class << self
+    def new(*_); end
+  end
 end
 
 class Nokogiri::XML::Namespace
@@ -847,7 +888,7 @@ class Nokogiri::XML::Node
   def add_next_sibling(node_or_tags); end
   def add_previous_sibling(node_or_tags); end
   def after(node_or_tags); end
-  def ancestors(selector = _); end
+  def ancestors(selector = T.unsafe(nil)); end
   def append_class(name); end
   def attr(name); end
   def attribute(_); end
@@ -856,7 +897,7 @@ class Nokogiri::XML::Node
   def attributes; end
   def before(node_or_tags); end
   def blank?; end
-  def canonicalize(mode = _, inclusive_namespaces = _, with_comments = _); end
+  def canonicalize(mode = T.unsafe(nil), inclusive_namespaces = T.unsafe(nil), with_comments = T.unsafe(nil)); end
   def cdata?; end
   def child; end
   def children; end
@@ -873,7 +914,7 @@ class Nokogiri::XML::Node
   def default_namespace=(url); end
   def delete(name); end
   def description; end
-  def do_xinclude(options = _); end
+  def do_xinclude(options = T.unsafe(nil)); end
   def document; end
   def document?; end
   def dup(*_); end
@@ -919,7 +960,7 @@ class Nokogiri::XML::Node
   def node_type; end
   def parent; end
   def parent=(parent_node); end
-  def parse(string_or_io, options = _); end
+  def parse(string_or_io, options = T.unsafe(nil)); end
   def path; end
   def pointer_id; end
   def prepend_child(node_or_tags); end
@@ -931,27 +972,27 @@ class Nokogiri::XML::Node
   def read_only?; end
   def remove; end
   def remove_attribute(name); end
-  def remove_class(name = _); end
+  def remove_class(name = T.unsafe(nil)); end
   def replace(node_or_tags); end
   def serialize(*args, &block); end
   def set_attribute(name, value); end
   def swap(node_or_tags); end
   def text; end
   def text?; end
-  def to_html(options = _); end
+  def to_html(options = T.unsafe(nil)); end
   def to_s; end
   def to_str; end
-  def to_xhtml(options = _); end
+  def to_xhtml(options = T.unsafe(nil)); end
-  def to_xml(options = _); end
+  def to_xml(options = T.unsafe(nil)); end
   def traverse(&block); end
   def type; end
   def unlink; end
   def values; end
   def wrap(html); end
-  def write_html_to(io, options = _); end
+  def write_html_to(io, options = T.unsafe(nil)); end
   def write_to(io, *options); end
-  def write_xhtml_to(io, options = _); end
+  def write_xhtml_to(io, options = T.unsafe(nil)); end
-  def write_xml_to(io, options = _); end
+  def write_xml_to(io, options = T.unsafe(nil)); end
   def xml?; end
 
   private
@@ -975,7 +1016,9 @@ class Nokogiri::XML::Node
   def to_format(save_option, options); end
   def write_format_to(save_option, io, options); end
 
-  def self.new(*_); end
+  class << self
+    def new(*_); end
+  end
 end
 
 Nokogiri::XML::Node::ATTRIBUTE_DECL = T.let(T.unsafe(nil), Integer)
@@ -1017,7 +1060,7 @@ Nokogiri::XML::Node::NOTATION_NODE = T.let(T.unsafe(nil), Integer)
 Nokogiri::XML::Node::PI_NODE = T.let(T.unsafe(nil), Integer)
 
 class Nokogiri::XML::Node::SaveOptions
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def as_html; end
   def as_html?; end
@@ -1073,7 +1116,7 @@ class Nokogiri::XML::NodeSet
   include(::Nokogiri::XML::Searchable)
   include(::Enumerable)
 
-  def initialize(document, list = _); end
+  def initialize(document, list = T.unsafe(nil)); end
 
   def %(*args); end
   def &(_); end
@@ -1087,8 +1130,8 @@ class Nokogiri::XML::NodeSet
   def after(datum); end
   def append_class(name); end
   def at(*args); end
-  def attr(key, value = _, &block); end
+  def attr(key, value = T.unsafe(nil), &block); end
-  def attribute(key, value = _, &block); end
+  def attribute(key, value = T.unsafe(nil), &block); end
   def before(datum); end
   def children; end
   def clone; end
@@ -1100,9 +1143,9 @@ class Nokogiri::XML::NodeSet
   def each; end
   def empty?; end
   def filter(expr); end
-  def first(n = _); end
+  def first(n = T.unsafe(nil)); end
   def include?(_); end
-  def index(node = _); end
+  def index(node = T.unsafe(nil)); end
   def inner_html(*args); end
   def inner_text; end
   def inspect; end
@@ -1113,9 +1156,9 @@ class Nokogiri::XML::NodeSet
   def remove; end
   def remove_attr(name); end
   def remove_attribute(name); end
-  def remove_class(name = _); end
+  def remove_class(name = T.unsafe(nil)); end
   def reverse; end
-  def set(key, value = _, &block); end
+  def set(key, value = T.unsafe(nil), &block); end
   def shift; end
   def size; end
   def slice(*_); end
@@ -1151,7 +1194,7 @@ module Nokogiri::XML::PP::Node
 end
 
 class Nokogiri::XML::ParseOptions
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def compact; end
   def compact?; end
@@ -1276,13 +1319,15 @@ Nokogiri::XML::ParseOptions::XINCLUDE = T.let(T.unsafe(nil), Integer)
 class Nokogiri::XML::ProcessingInstruction < ::Nokogiri::XML::Node
   def initialize(document, name, content); end
 
-  def self.new(*_); end
+  class << self
+    def new(*_); end
+  end
 end
 
 class Nokogiri::XML::Reader
   include(::Enumerable)
 
-  def initialize(source, url = _, encoding = _); end
+  def initialize(source, url = T.unsafe(nil), encoding = T.unsafe(nil)); end
 
   def attribute(_); end
   def attribute_at(_); end
@@ -1319,8 +1364,10 @@ class Nokogiri::XML::Reader
 
   def attr_nodes; end
 
-  def self.from_io(*_); end
+  class << self
-  def self.from_memory(*_); end
+    def from_io(*_); end
+    def from_memory(*_); end
+  end
 end
 
 Nokogiri::XML::Reader::TYPE_ATTRIBUTE = T.let(T.unsafe(nil), Integer)
@@ -1365,8 +1412,10 @@ class Nokogiri::XML::RelaxNG < ::Nokogiri::XML::Schema
 
   def validate_document(_); end
 
-  def self.from_document(_); end
+  class << self
-  def self.read_memory(_); end
+    def from_document(_); end
+    def read_memory(_); end
+  end
 end
 
 module Nokogiri::XML::SAX
@@ -1378,18 +1427,18 @@ class Nokogiri::XML::SAX::Document
   def comment(string); end
   def end_document; end
   def end_element(name); end
-  def end_element_namespace(name, prefix = _, uri = _); end
+  def end_element_namespace(name, prefix = T.unsafe(nil), uri = T.unsafe(nil)); end
   def error(string); end
   def processing_instruction(name, content); end
   def start_document; end
-  def start_element(name, attrs = _); end
+  def start_element(name, attrs = T.unsafe(nil)); end
-  def start_element_namespace(name, attrs = _, prefix = _, uri = _, ns = _); end
+  def start_element_namespace(name, attrs = T.unsafe(nil), prefix = T.unsafe(nil), uri = T.unsafe(nil), ns = T.unsafe(nil)); end
   def warning(string); end
   def xmldecl(version, encoding, standalone); end
 end
 
 class Nokogiri::XML::SAX::Parser
-  def initialize(doc = _, encoding = _); end
+  def initialize(doc = T.unsafe(nil), encoding = T.unsafe(nil)); end
 
   def document; end
   def document=(_); end
@@ -1397,7 +1446,7 @@ class Nokogiri::XML::SAX::Parser
   def encoding=(_); end
   def parse(thing, &block); end
   def parse_file(filename); end
-  def parse_io(io, encoding = _); end
+  def parse_io(io, encoding = T.unsafe(nil)); end
   def parse_memory(data); end
 
   private
@@ -1419,16 +1468,18 @@ class Nokogiri::XML::SAX::ParserContext
   def replace_entities; end
   def replace_entities=(_); end
 
-  def self.file(_); end
+  class << self
-  def self.io(_, _); end
+    def file(_); end
-  def self.memory(_); end
+    def io(_, _); end
-  def self.new(thing, encoding = _); end
+    def memory(_); end
+    def new(thing, encoding = T.unsafe(nil)); end
+  end
 end
 
 class Nokogiri::XML::SAX::PushParser
-  def initialize(doc = _, file_name = _, encoding = _); end
+  def initialize(doc = T.unsafe(nil), file_name = T.unsafe(nil), encoding = T.unsafe(nil)); end
 
-  def <<(chunk, last_chunk = _); end
+  def <<(chunk, last_chunk = T.unsafe(nil)); end
   def document; end
   def document=(_); end
   def finish; end
@@ -1436,7 +1487,7 @@ class Nokogiri::XML::SAX::PushParser
   def options=(_); end
   def replace_entities; end
   def replace_entities=(_); end
-  def write(chunk, last_chunk = _); end
+  def write(chunk, last_chunk = T.unsafe(nil)); end
 
   private
 
@@ -1455,9 +1506,11 @@ class Nokogiri::XML::Schema
   def validate_document(_); end
   def validate_file(_); end
 
-  def self.from_document(_); end
+  class << self
-  def self.new(string_or_io); end
+    def from_document(_); end
-  def self.read_memory(_); end
+    def new(string_or_io); end
+    def read_memory(_); end
+  end
 end
 
 module Nokogiri::XML::Searchable
@@ -1509,7 +1562,9 @@ end
 class Nokogiri::XML::Text < ::Nokogiri::XML::CharacterData
   def content=(string); end
 
-  def self.new(*_); end
+  class << self
+    def new(*_); end
+  end
 end
 
 Nokogiri::XML::XML_C14N_1_0 = T.let(T.unsafe(nil), Integer)
@@ -1533,19 +1588,25 @@ class Nokogiri::XML::XPathContext
   def register_ns(_, _); end
   def register_variable(_, _); end
 
-  def self.new(_); end
+  class << self
+    def new(_); end
+  end
 end
 
 module Nokogiri::XSLT
-  def self.parse(string, modules = _); end
+  class << self
-  def self.quote_params(params); end
+    def parse(string, modules = T.unsafe(nil)); end
-  def self.register(_, _); end
+    def quote_params(params); end
+    def register(_, _); end
+  end
 end
 
 class Nokogiri::XSLT::Stylesheet
-  def apply_to(document, params = _); end
+  def apply_to(document, params = T.unsafe(nil)); end
   def serialize(_); end
   def transform(*_); end
 
-  def self.parse_stylesheet_doc(_); end
+  class << self
+    def parse_stylesheet_doc(_); end
+  end
 end

Library/Homebrew/sorbet/rbi/gems/ntlm-http@0.1.1.rbi

@@ -1,24 +1,27 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `ntlm-http` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module Net::NTLM
-  def self.apply_des(plain, keys); end
+  class << self
-  def self.decode_utf16le(str); end
+    def apply_des(plain, keys); end
-  def self.encode_utf16le(str); end
+    def decode_utf16le(str); end
-  def self.gen_keys(str); end
+    def encode_utf16le(str); end
-  def self.lm_hash(password); end
+    def gen_keys(str); end
-  def self.lm_response(arg); end
+    def lm_hash(password); end
-  def self.lmv2_response(arg, opt = _); end
+    def lm_response(arg); end
-  def self.ntlm2_session(arg, opt = _); end
+    def lmv2_response(arg, opt = T.unsafe(nil)); end
-  def self.ntlm_hash(password, opt = _); end
+    def ntlm2_session(arg, opt = T.unsafe(nil)); end
-  def self.ntlm_response(arg); end
+    def ntlm_hash(password, opt = T.unsafe(nil)); end
-  def self.ntlmv2_hash(user, password, target, opt = _); end
+    def ntlm_response(arg); end
-  def self.ntlmv2_response(arg, opt = _); end
+    def ntlmv2_hash(user, password, target, opt = T.unsafe(nil)); end
-  def self.pack_int64le(val); end
+    def ntlmv2_response(arg, opt = T.unsafe(nil)); end
-  def self.split7(str); end
+    def pack_int64le(val); end
-  def self.swap16(str); end
+    def split7(str); end
+    def swap16(str); end
+  end
 end
 
 class Net::NTLM::Blob < ::Net::NTLM::FieldSet
@@ -37,7 +40,9 @@ class Net::NTLM::Blob < ::Net::NTLM::FieldSet
   def unknown2; end
   def unknown2=(val); end
 
-  def self.inherited(subclass); end
+  class << self
+    def inherited(subclass); end
+  end
 end
 
 class Net::NTLM::Field
@@ -57,40 +62,47 @@ class Net::NTLM::FieldSet
   def []=(name, val); end
   def disable(name); end
   def enable(name); end
-  def parse(str, offset = _); end
+  def parse(str, offset = T.unsafe(nil)); end
   def serialize; end
   def size; end
 
-  def self.define(&block); end
+  class << self
-  def self.int16LE(name, opts); end
+    def define(&block); end
-  def self.int32LE(name, opts); end
+    def int16LE(name, opts); end
-  def self.int64LE(name, opts); end
+    def int32LE(name, opts); end
-  def self.names; end
+    def int64LE(name, opts); end
-  def self.opts; end
+    def names; end
-  def self.prototypes; end
+    def opts; end
-  def self.security_buffer(name, opts); end
+    def prototypes; end
-  def self.string(name, opts); end
+    def security_buffer(name, opts); end
-  def self.types; end
+    def string(name, opts); end
+    def types; end
+
+    private
+
+    def add_field(name, type, opts); end
+    def define_accessor(name); end
+  end
 end
 
 class Net::NTLM::Int16LE < ::Net::NTLM::Field
   def initialize(opt); end
 
-  def parse(str, offset = _); end
+  def parse(str, offset = T.unsafe(nil)); end
   def serialize; end
 end
 
 class Net::NTLM::Int32LE < ::Net::NTLM::Field
   def initialize(opt); end
 
-  def parse(str, offset = _); end
+  def parse(str, offset = T.unsafe(nil)); end
   def serialize; end
 end
 
 class Net::NTLM::Int64LE < ::Net::NTLM::Field
   def initialize(opt); end
 
-  def parse(str, offset = _); end
+  def parse(str, offset = T.unsafe(nil)); end
   def serialize; end
 end
 
@@ -111,8 +123,10 @@ class Net::NTLM::Message < ::Net::NTLM::FieldSet
   def deflag; end
   def security_buffers; end
 
-  def self.decode64(str); end
+  class << self
-  def self.parse(str); end
+    def decode64(str); end
+    def parse(str); end
+  end
 end
 
 class Net::NTLM::Message::Type0 < ::Net::NTLM::Message
@@ -121,7 +135,9 @@ class Net::NTLM::Message::Type0 < ::Net::NTLM::Message
   def type; end
   def type=(val); end
 
-  def self.inherited(subclass); end
+  class << self
+    def inherited(subclass); end
+  end
 end
 
 class Net::NTLM::Message::Type1 < ::Net::NTLM::Message
@@ -139,8 +155,10 @@ class Net::NTLM::Message::Type1 < ::Net::NTLM::Message
   def workstation; end
   def workstation=(val); end
 
-  def self.inherited(subclass); end
+  class << self
-  def self.parse(str); end
+    def inherited(subclass); end
+    def parse(str); end
+  end
 end
 
 class Net::NTLM::Message::Type2 < ::Net::NTLM::Message
@@ -153,7 +171,7 @@ class Net::NTLM::Message::Type2 < ::Net::NTLM::Message
   def padding; end
   def padding=(val); end
   def parse(str); end
-  def response(arg, opt = _); end
+  def response(arg, opt = T.unsafe(nil)); end
   def sign; end
   def sign=(val); end
   def target_info; end
@@ -163,8 +181,10 @@ class Net::NTLM::Message::Type2 < ::Net::NTLM::Message
   def type; end
   def type=(val); end
 
-  def self.inherited(subclass); end
+  class << self
-  def self.parse(str); end
+    def inherited(subclass); end
+    def parse(str); end
+  end
 end
 
 class Net::NTLM::Message::Type3 < ::Net::NTLM::Message
@@ -187,9 +207,11 @@ class Net::NTLM::Message::Type3 < ::Net::NTLM::Message
   def workstation; end
   def workstation=(val); end
 
-  def self.create(arg, opt = _); end
+  class << self
-  def self.inherited(subclass); end
+    def create(arg, opt = T.unsafe(nil)); end
-  def self.parse(str); end
+    def inherited(subclass); end
+    def parse(str); end
+  end
 end
 
 class Net::NTLM::SecurityBuffer < ::Net::NTLM::FieldSet
@@ -204,18 +226,20 @@ class Net::NTLM::SecurityBuffer < ::Net::NTLM::FieldSet
   def length=(val); end
   def offset; end
   def offset=(val); end
-  def parse(str, offset = _); end
+  def parse(str, offset = T.unsafe(nil)); end
   def serialize; end
   def value; end
   def value=(val); end
 
-  def self.inherited(subclass); end
+  class << self
+    def inherited(subclass); end
+  end
 end
 
 class Net::NTLM::String < ::Net::NTLM::Field
   def initialize(opts); end
 
-  def parse(str, offset = _); end
+  def parse(str, offset = T.unsafe(nil)); end
   def serialize; end
   def value=(val); end
 end

Library/Homebrew/sorbet/rbi/gems/parallel@1.19.2.rbi

@@ -1,22 +1,40 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync --exclude json
+# This is an autogenerated file for types exported from the `parallel` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module Parallel
   extend(::Parallel::ProcessorCount)
 
-  def self.all?(*args, &block); end
+  class << self
-  def self.any?(*args, &block); end
+    def all?(*args, &block); end
-  def self.each(array, options = _, &block); end
+    def any?(*args, &block); end
-  def self.each_with_index(array, options = _, &block); end
+    def each(array, options = T.unsafe(nil), &block); end
-  def self.flat_map(*args, &block); end
+    def each_with_index(array, options = T.unsafe(nil), &block); end
-  def self.in_processes(options = _, &block); end
+    def flat_map(*args, &block); end
-  def self.in_threads(options = _); end
+    def in_processes(options = T.unsafe(nil), &block); end
-  def self.map(source, options = _, &block); end
+    def in_threads(options = T.unsafe(nil)); end
-  def self.map_with_index(array, options = _, &block); end
+    def map(source, options = T.unsafe(nil), &block); end
-  def self.worker_number; end
+    def map_with_index(array, options = T.unsafe(nil), &block); end
-  def self.worker_number=(worker_num); end
+    def worker_number; end
+    def worker_number=(worker_num); end
+
+    private
+
+    def add_progress_bar!(job_factory, options); end
+    def call_with_index(item, index, options, &block); end
+    def create_workers(job_factory, options, &block); end
+    def extract_count_from_options(options); end
+    def handle_exception(exception, results); end
+    def process_incoming_jobs(read, write, job_factory, options, &block); end
+    def replace_worker(job_factory, workers, i, options, blk); end
+    def with_instrumentation(item, index, options); end
+    def work_direct(job_factory, options, &block); end
+    def work_in_processes(job_factory, options, &blk); end
+    def work_in_threads(job_factory, options, &block); end
+    def worker(job_factory, options, &block); end
+  end
 end
 
 class Parallel::Break < ::StandardError
@@ -62,8 +80,15 @@ class Parallel::UndumpableException < ::StandardError
 end
 
 class Parallel::UserInterruptHandler
-  def self.kill(thing); end
+  class << self
-  def self.kill_on_ctrl_c(pids, options); end
+    def kill(thing); end
+    def kill_on_ctrl_c(pids, options); end
+
+    private
+
+    def restore_interrupt(old, signal); end
+    def trap_interrupt(signal); end
+  end
 end
 
 Parallel::UserInterruptHandler::INTERRUPT_SIGNAL = T.let(T.unsafe(nil), Symbol)

Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.1.0.rbi

@@ -1,22 +1,25 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync --exclude json
+# This is an autogenerated file for types exported from the `parallel_tests` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module ParallelTests
-  def self.bundler_enabled?; end
+  class << self
-  def self.delta; end
+    def bundler_enabled?; end
-  def self.determine_number_of_processes(count); end
+    def delta; end
-  def self.first_process?; end
+    def determine_number_of_processes(count); end
-  def self.last_process?; end
+    def first_process?; end
-  def self.now; end
+    def last_process?; end
-  def self.number_of_running_processes; end
+    def now; end
-  def self.pid_file_path; end
+    def number_of_running_processes; end
-  def self.pids; end
+    def pid_file_path; end
-  def self.stop_all_processes; end
+    def pids; end
-  def self.wait_for_other_processes_to_finish; end
+    def stop_all_processes; end
-  def self.with_pid_file; end
+    def wait_for_other_processes_to_finish; end
-  def self.with_ruby_binary(command); end
+    def with_pid_file; end
+    def with_ruby_binary(command); end
+  end
 end
 
 class ParallelTests::CLI
@@ -49,9 +52,21 @@ class ParallelTests::CLI
 end
 
 class ParallelTests::Grouper
-  def self.by_scenarios(tests, num_groups, options = _); end
+  class << self
-  def self.by_steps(tests, num_groups, options); end
+    def by_scenarios(tests, num_groups, options = T.unsafe(nil)); end
-  def self.in_even_groups_by_size(items, num_groups, options = _); end
+    def by_steps(tests, num_groups, options); end
+    def in_even_groups_by_size(items, num_groups, options = T.unsafe(nil)); end
+
+    private
+
+    def add_to_group(group, item, size); end
+    def group_by_features_with_steps(tests, options); end
+    def group_by_scenarios(tests, options = T.unsafe(nil)); end
+    def group_features_by_size(items, groups_to_fill); end
+    def items_to_group(items); end
+    def largest_first(files); end
+    def smallest_group(groups); end
+  end
 end
 
 class ParallelTests::Pids

Library/Homebrew/sorbet/rbi/gems/parlour@4.0.1.rbi

@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `parlour` gem.
-# Please instead update this file by running `tapioca sync --exclude json`.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/parser@2.7.1.4.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync --exclude json
+# This is an autogenerated file for types exported from the `parser` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -133,7 +134,7 @@ class Parser::AST::Processor < ::AST::Processor
 end
 
 class Parser::Base < ::Racc::Parser
-  def initialize(builder = _); end
+  def initialize(builder = T.unsafe(nil)); end
 
   def builder; end
   def context; end
@@ -147,20 +148,26 @@ class Parser::Base < ::Racc::Parser
   def reset; end
   def source_buffer; end
   def static_env; end
-  def tokenize(source_buffer, recover = _); end
+  def tokenize(source_buffer, recover = T.unsafe(nil)); end
 
   private
 
   def check_kwarg_name(name_t); end
-  def diagnostic(level, reason, arguments, location_t, highlights_ts = _); end
+  def diagnostic(level, reason, arguments, location_t, highlights_ts = T.unsafe(nil)); end
   def next_token; end
   def on_error(error_token_id, error_value, value_stack); end
 
-  def self.default_parser; end
+  class << self
-  def self.parse(string, file = _, line = _); end
+    def default_parser; end
-  def self.parse_file(filename); end
+    def parse(string, file = T.unsafe(nil), line = T.unsafe(nil)); end
-  def self.parse_file_with_comments(filename); end
+    def parse_file(filename); end
-  def self.parse_with_comments(string, file = _, line = _); end
+    def parse_file_with_comments(filename); end
+    def parse_with_comments(string, file = T.unsafe(nil), line = T.unsafe(nil)); end
+
+    private
+
+    def setup_source_buffer(file, line, string, encoding); end
+  end
 end
 
 module Parser::Builders
@@ -176,7 +183,7 @@ class Parser::Builders::Default
   def alias(alias_t, to, from); end
   def arg(name_t); end
   def arg_expr(expr); end
-  def args(begin_t, args, end_t, check_args = _); end
+  def args(begin_t, args, end_t, check_args = T.unsafe(nil)); end
   def array(begin_t, elements, end_t); end
   def array_pattern(lbrack_t, elements, rbrack_t); end
   def assign(lhs, eql_t, rhs); end
@@ -185,7 +192,7 @@ class Parser::Builders::Default
   def attr_asgn(receiver, dot_t, selector_t); end
   def back_ref(token); end
   def begin(begin_t, body, end_t); end
-  def begin_body(compound_stmt, rescue_bodies = _, else_t = _, else_ = _, ensure_t = _, ensure_ = _); end
+  def begin_body(compound_stmt, rescue_bodies = T.unsafe(nil), else_t = T.unsafe(nil), else_ = T.unsafe(nil), ensure_t = T.unsafe(nil), ensure_ = T.unsafe(nil)); end
   def begin_keyword(begin_t, body, end_t); end
   def binary_op(receiver, operator_t, arg); end
   def block(method_call, begin_t, args, body, end_t); end
@@ -193,7 +200,7 @@ class Parser::Builders::Default
   def blockarg(amper_t, name_t); end
   def blockarg_expr(amper_t, expr); end
   def call_lambda(lambda_t); end
-  def call_method(receiver, dot_t, selector_t, lparen_t = _, args = _, rparen_t = _); end
+  def call_method(receiver, dot_t, selector_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end
   def call_type_for_dot(dot_t); end
   def case(case_t, expr, when_bodies, else_t, else_body, end_t); end
   def case_match(case_t, expr, in_bodies, else_t, else_body, end_t); end
@@ -235,11 +242,11 @@ class Parser::Builders::Default
   def index_asgn(receiver, lbrack_t, indexes, rbrack_t); end
   def integer(integer_t); end
   def ivar(token); end
-  def keyword_cmd(type, keyword_t, lparen_t = _, args = _, rparen_t = _); end
+  def keyword_cmd(type, keyword_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end
   def kwarg(name_t); end
   def kwnilarg(dstar_t, nil_t); end
   def kwoptarg(name_t, value); end
-  def kwrestarg(dstar_t, name_t = _); end
+  def kwrestarg(dstar_t, name_t = T.unsafe(nil)); end
   def kwsplat(dstar_t, arg); end
   def logical_op(type, lhs, op_t, rhs); end
   def loop(type, keyword_t, cond, do_t, body, end_t); end
@@ -252,18 +259,18 @@ class Parser::Builders::Default
   def match_nil_pattern(dstar_t, nil_t); end
   def match_op(receiver, match_t, arg); end
   def match_pair(label_type, label, value); end
-  def match_rest(star_t, name_t = _); end
+  def match_rest(star_t, name_t = T.unsafe(nil)); end
   def match_var(name_t); end
   def match_with_trailing_comma(match, comma_t); end
   def multi_assign(lhs, eql_t, rhs); end
   def multi_lhs(begin_t, items, end_t); end
   def multi_rassign(lhs, assoc_t, rhs); end
   def nil(nil_t); end
-  def not_op(not_t, begin_t = _, receiver = _, end_t = _); end
+  def not_op(not_t, begin_t = T.unsafe(nil), receiver = T.unsafe(nil), end_t = T.unsafe(nil)); end
   def nth_ref(token); end
   def numargs(max_numparam); end
   def objc_kwarg(kwname_t, assoc_t, name_t); end
-  def objc_restarg(star_t, name = _); end
+  def objc_restarg(star_t, name = T.unsafe(nil)); end
   def objc_varargs(pair, rest_of_varargs); end
   def op_assign(lhs, op_t, rhs); end
   def optarg(name_t, eql_t, value); end
@@ -284,11 +291,11 @@ class Parser::Builders::Default
   def regexp_compose(begin_t, parts, end_t, options); end
   def regexp_options(regopt_t); end
   def rescue_body(rescue_t, exc_list, assoc_t, exc_var, then_t, compound_stmt); end
-  def restarg(star_t, name_t = _); end
+  def restarg(star_t, name_t = T.unsafe(nil)); end
-  def restarg_expr(star_t, expr = _); end
+  def restarg_expr(star_t, expr = T.unsafe(nil)); end
   def self(token); end
   def shadowarg(name_t); end
-  def splat(star_t, arg = _); end
+  def splat(star_t, arg = T.unsafe(nil)); end
   def string(string_t); end
   def string_compose(begin_t, parts, end_t); end
   def string_internal(string_t); end
@@ -310,13 +317,13 @@ class Parser::Builders::Default
   private
 
   def arg_name_collides?(this_name, that_name); end
-  def arg_prefix_map(op_t, name_t = _); end
+  def arg_prefix_map(op_t, name_t = T.unsafe(nil)); end
   def binary_op_map(left_e, op_t, right_e); end
   def block_map(receiver_l, begin_t, end_t); end
   def check_assignment_to_numparam(node); end
   def check_condition(cond); end
-  def check_duplicate_arg(this_arg, map = _); end
+  def check_duplicate_arg(this_arg, map = T.unsafe(nil)); end
-  def check_duplicate_args(args, map = _); end
+  def check_duplicate_args(args, map = T.unsafe(nil)); end
   def check_duplicate_pattern_key(name, loc); end
   def check_duplicate_pattern_variable(name, loc); end
   def check_lvar_name(name, loc); end
@@ -326,7 +333,7 @@ class Parser::Builders::Default
   def constant_map(scope, colon2_t, name_t); end
   def definition_map(keyword_t, operator_t, name_t, end_t); end
   def delimited_string_map(string_t); end
-  def diagnostic(type, reason, arguments, location, highlights = _); end
+  def diagnostic(type, reason, arguments, location, highlights = T.unsafe(nil)); end
   def eh_keyword_map(compstmt_e, keyword_t, body_es, else_t, else_e); end
   def endless_definition_map(keyword_t, operator_t, name_t, assignment_t, body_e); end
   def expr_map(loc); end
@@ -336,7 +343,7 @@ class Parser::Builders::Default
   def join_exprs(left_expr, right_expr); end
   def keyword_map(keyword_t, begin_t, args, end_t); end
   def keyword_mod_map(pre_e, keyword_t, post_e); end
-  def kwarg_map(name_t, value_e = _); end
+  def kwarg_map(name_t, value_e = T.unsafe(nil)); end
   def loc(token); end
   def module_definition_map(keyword_t, name_e, operator_t, end_t); end
   def n(type, children, source_map); end
@@ -350,7 +357,7 @@ class Parser::Builders::Default
   def rescue_body_map(keyword_t, exc_list_e, assoc_t, exc_var_e, then_t, compstmt_e); end
   def send_binary_op_map(lhs_e, selector_t, rhs_e); end
   def send_index_map(receiver_e, lbrack_t, rbrack_t); end
-  def send_map(receiver_e, dot_t, selector_t, begin_t = _, args = _, end_t = _); end
+  def send_map(receiver_e, dot_t, selector_t, begin_t = T.unsafe(nil), args = T.unsafe(nil), end_t = T.unsafe(nil)); end
   def send_unary_op_map(selector_t, arg_e); end
   def static_regexp(parts, options); end
   def static_regexp_node(node); end
@@ -359,26 +366,28 @@ class Parser::Builders::Default
   def string_value(token); end
   def ternary_map(begin_e, question_t, mid_e, colon_t, end_e); end
   def token_map(token); end
-  def unary_op_map(op_t, arg_e = _); end
+  def unary_op_map(op_t, arg_e = T.unsafe(nil)); end
   def unquoted_map(token); end
   def validate_definee(definee); end
   def value(token); end
   def var_send_map(variable_e); end
   def variable_map(name_t); end
 
-  def self.emit_arg_inside_procarg0; end
+  class << self
-  def self.emit_arg_inside_procarg0=(_); end
+    def emit_arg_inside_procarg0; end
-  def self.emit_encoding; end
+    def emit_arg_inside_procarg0=(_); end
-  def self.emit_encoding=(_); end
+    def emit_encoding; end
-  def self.emit_forward_arg; end
+    def emit_encoding=(_); end
-  def self.emit_forward_arg=(_); end
+    def emit_forward_arg; end
-  def self.emit_index; end
+    def emit_forward_arg=(_); end
-  def self.emit_index=(_); end
+    def emit_index; end
-  def self.emit_lambda; end
+    def emit_index=(_); end
-  def self.emit_lambda=(_); end
+    def emit_lambda; end
-  def self.emit_procarg0; end
+    def emit_lambda=(_); end
-  def self.emit_procarg0=(_); end
+    def emit_procarg0; end
-  def self.modernize; end
+    def emit_procarg0=(_); end
+    def modernize; end
+  end
 end
 
 class Parser::ClobberingError < ::RuntimeError
@@ -418,7 +427,7 @@ module Parser::Deprecation
 end
 
 class Parser::Diagnostic
-  def initialize(level, reason, arguments, location, highlights = _); end
+  def initialize(level, reason, arguments, location, highlights = T.unsafe(nil)); end
 
   def arguments; end
   def highlights; end
@@ -432,11 +441,11 @@ class Parser::Diagnostic
 
   def first_line_only(range); end
   def last_line_only(range); end
-  def render_line(range, ellipsis = _, range_end = _); end
+  def render_line(range, ellipsis = T.unsafe(nil), range_end = T.unsafe(nil)); end
 end
 
 class Parser::Diagnostic::Engine
-  def initialize(consumer = _); end
+  def initialize(consumer = T.unsafe(nil)); end
 
   def all_errors_are_fatal; end
   def all_errors_are_fatal=(_); end
@@ -480,7 +489,7 @@ class Parser::Lexer
   def pop_cond; end
   def push_cmdarg; end
   def push_cond; end
-  def reset(reset_state = _); end
+  def reset(reset_state = T.unsafe(nil)); end
   def source_buffer; end
   def source_buffer=(source_buffer); end
   def state; end
@@ -493,74 +502,97 @@ class Parser::Lexer
   protected
 
   def arg_or_cmdarg(cmd_state); end
-  def diagnostic(type, reason, arguments = _, location = _, highlights = _); end
+  def diagnostic(type, reason, arguments = T.unsafe(nil), location = T.unsafe(nil), highlights = T.unsafe(nil)); end
-  def emit(type, value = _, s = _, e = _); end
+  def emit(type, value = T.unsafe(nil), s = T.unsafe(nil), e = T.unsafe(nil)); end
-  def emit_comment(s = _, e = _); end
+  def emit_comment(s = T.unsafe(nil), e = T.unsafe(nil)); end
-  def emit_do(do_block = _); end
+  def emit_do(do_block = T.unsafe(nil)); end
-  def emit_table(table, s = _, e = _); end
+  def emit_table(table, s = T.unsafe(nil), e = T.unsafe(nil)); end
   def encode_escape(ord); end
   def eof_codepoint?(point); end
   def literal; end
   def next_state_for_literal(literal); end
   def pop_literal; end
   def push_literal(*args); end
-  def range(s = _, e = _); end
+  def range(s = T.unsafe(nil), e = T.unsafe(nil)); end
   def stack_pop; end
-  def tok(s = _, e = _); end
+  def tok(s = T.unsafe(nil), e = T.unsafe(nil)); end
   def version?(*versions); end
 
-  def self.lex_en_expr_arg; end
+  class << self
-  def self.lex_en_expr_arg=(_); end
+    def lex_en_expr_arg; end
-  def self.lex_en_expr_beg; end
+    def lex_en_expr_arg=(_); end
-  def self.lex_en_expr_beg=(_); end
+    def lex_en_expr_beg; end
-  def self.lex_en_expr_cmdarg; end
+    def lex_en_expr_beg=(_); end
-  def self.lex_en_expr_cmdarg=(_); end
+    def lex_en_expr_cmdarg; end
-  def self.lex_en_expr_dot; end
+    def lex_en_expr_cmdarg=(_); end
-  def self.lex_en_expr_dot=(_); end
+    def lex_en_expr_dot; end
-  def self.lex_en_expr_end; end
+    def lex_en_expr_dot=(_); end
-  def self.lex_en_expr_end=(_); end
+    def lex_en_expr_end; end
-  def self.lex_en_expr_endarg; end
+    def lex_en_expr_end=(_); end
-  def self.lex_en_expr_endarg=(_); end
+    def lex_en_expr_endarg; end
-  def self.lex_en_expr_endfn; end
+    def lex_en_expr_endarg=(_); end
-  def self.lex_en_expr_endfn=(_); end
+    def lex_en_expr_endfn; end
-  def self.lex_en_expr_fname; end
+    def lex_en_expr_endfn=(_); end
-  def self.lex_en_expr_fname=(_); end
+    def lex_en_expr_fname; end
-  def self.lex_en_expr_labelarg; end
+    def lex_en_expr_fname=(_); end
-  def self.lex_en_expr_labelarg=(_); end
+    def lex_en_expr_labelarg; end
-  def self.lex_en_expr_mid; end
+    def lex_en_expr_labelarg=(_); end
-  def self.lex_en_expr_mid=(_); end
+    def lex_en_expr_mid; end
-  def self.lex_en_expr_value; end
+    def lex_en_expr_mid=(_); end
-  def self.lex_en_expr_value=(_); end
+    def lex_en_expr_value; end
-  def self.lex_en_expr_variable; end
+    def lex_en_expr_value=(_); end
-  def self.lex_en_expr_variable=(_); end
+    def lex_en_expr_variable; end
-  def self.lex_en_interp_backslash_delimited; end
+    def lex_en_expr_variable=(_); end
-  def self.lex_en_interp_backslash_delimited=(_); end
+    def lex_en_interp_backslash_delimited; end
-  def self.lex_en_interp_backslash_delimited_words; end
+    def lex_en_interp_backslash_delimited=(_); end
-  def self.lex_en_interp_backslash_delimited_words=(_); end
+    def lex_en_interp_backslash_delimited_words; end
-  def self.lex_en_interp_string; end
+    def lex_en_interp_backslash_delimited_words=(_); end
-  def self.lex_en_interp_string=(_); end
+    def lex_en_interp_string; end
-  def self.lex_en_interp_words; end
+    def lex_en_interp_string=(_); end
-  def self.lex_en_interp_words=(_); end
+    def lex_en_interp_words; end
-  def self.lex_en_leading_dot; end
+    def lex_en_interp_words=(_); end
-  def self.lex_en_leading_dot=(_); end
+    def lex_en_leading_dot; end
-  def self.lex_en_line_begin; end
+    def lex_en_leading_dot=(_); end
-  def self.lex_en_line_begin=(_); end
+    def lex_en_line_begin; end
-  def self.lex_en_line_comment; end
+    def lex_en_line_begin=(_); end
-  def self.lex_en_line_comment=(_); end
+    def lex_en_line_comment; end
-  def self.lex_en_plain_backslash_delimited; end
+    def lex_en_line_comment=(_); end
-  def self.lex_en_plain_backslash_delimited=(_); end
+    def lex_en_plain_backslash_delimited; end
-  def self.lex_en_plain_backslash_delimited_words; end
+    def lex_en_plain_backslash_delimited=(_); end
-  def self.lex_en_plain_backslash_delimited_words=(_); end
+    def lex_en_plain_backslash_delimited_words; end
-  def self.lex_en_plain_string; end
+    def lex_en_plain_backslash_delimited_words=(_); end
-  def self.lex_en_plain_string=(_); end
+    def lex_en_plain_string; end
-  def self.lex_en_plain_words; end
+    def lex_en_plain_string=(_); end
-  def self.lex_en_plain_words=(_); end
+    def lex_en_plain_words; end
-  def self.lex_en_regexp_modifiers; end
+    def lex_en_plain_words=(_); end
-  def self.lex_en_regexp_modifiers=(_); end
+    def lex_en_regexp_modifiers; end
-  def self.lex_error; end
+    def lex_en_regexp_modifiers=(_); end
-  def self.lex_error=(_); end
+    def lex_error; end
-  def self.lex_start; end
+    def lex_error=(_); end
-  def self.lex_start=(_); end
+    def lex_start; end
+    def lex_start=(_); end
+
+    private
+
+    def _lex_eof_trans; end
+    def _lex_eof_trans=(_); end
+    def _lex_from_state_actions; end
+    def _lex_from_state_actions=(_); end
+    def _lex_index_offsets; end
+    def _lex_index_offsets=(_); end
+    def _lex_indicies; end
+    def _lex_indicies=(_); end
+    def _lex_key_spans; end
+    def _lex_key_spans=(_); end
+    def _lex_to_state_actions; end
+    def _lex_to_state_actions=(_); end
+    def _lex_trans_actions; end
+    def _lex_trans_actions=(_); end
+    def _lex_trans_keys; end
+    def _lex_trans_keys=(_); end
+    def _lex_trans_targs; end
+    def _lex_trans_targs=(_); end
+  end
 end
 
 class Parser::Lexer::Dedenter
@@ -581,7 +613,7 @@ Parser::Lexer::KEYWORDS_BEGIN = T.let(T.unsafe(nil), Hash)
 Parser::Lexer::LEX_STATES = T.let(T.unsafe(nil), Hash)
 
 class Parser::Lexer::Literal
-  def initialize(lexer, str_type, delimiter, str_s, heredoc_e = _, indent = _, dedent_body = _, label_allowed = _); end
+  def initialize(lexer, str_type, delimiter, str_s, heredoc_e = T.unsafe(nil), indent = T.unsafe(nil), dedent_body = T.unsafe(nil), label_allowed = T.unsafe(nil)); end
 
   def backslash_delimited?; end
   def dedent_level; end
@@ -595,7 +627,7 @@ class Parser::Lexer::Literal
   def infer_indent_level(line); end
   def interpolate?; end
   def munge_escape?(character); end
-  def nest_and_try_closing(delimiter, ts, te, lookahead = _); end
+  def nest_and_try_closing(delimiter, ts, te, lookahead = T.unsafe(nil)); end
   def plain_heredoc?; end
   def regexp?; end
   def saved_herebody_s; end
@@ -659,7 +691,9 @@ class Parser::MaxNumparamStack
 end
 
 module Parser::Messages
-  def self.compile(reason, arguments); end
+  class << self
+    def compile(reason, arguments); end
+  end
 end
 
 module Parser::Meta
@@ -687,7 +721,7 @@ module Parser::Source
 end
 
 class Parser::Source::Buffer
-  def initialize(name, first_line = _, source: _); end
+  def initialize(name, first_line = T.unsafe(nil), source: T.unsafe(nil)); end
 
   def column_for_position(position); end
   def decompose_position(position); end
@@ -710,8 +744,10 @@ class Parser::Source::Buffer
   def line_begins; end
   def line_for(position); end
 
-  def self.recognize_encoding(string); end
+  class << self
-  def self.reencode_string(input); end
+    def recognize_encoding(string); end
+    def reencode_string(input); end
+  end
 end
 
 Parser::Source::Buffer::ENCODING_RE = T.let(T.unsafe(nil), Regexp)
@@ -728,8 +764,10 @@ class Parser::Source::Comment
   def text; end
   def type; end
 
-  def self.associate(ast, comments); end
+  class << self
-  def self.associate_locations(ast, comments); end
+    def associate(ast, comments); end
+    def associate_locations(ast, comments); end
+  end
 end
 
 class Parser::Source::Comment::Associator
@@ -913,7 +951,7 @@ class Parser::Source::Map::Ternary < ::Parser::Source::Map
 end
 
 class Parser::Source::Map::Variable < ::Parser::Source::Map
-  def initialize(name_l, expression_l = _); end
+  def initialize(name_l, expression_l = T.unsafe(nil)); end
 
   def name; end
   def operator; end
@@ -926,11 +964,12 @@ end
 
 class Parser::Source::Range
   include(::Comparable)
+  include(::RuboCop::AST::Ext::Range)
 
   def initialize(source_buffer, begin_pos, end_pos); end
 
   def <=>(other); end
-  def adjust(begin_pos: _, end_pos: _); end
+  def adjust(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end
   def begin; end
   def begin_pos; end
   def column; end
@@ -962,7 +1001,7 @@ class Parser::Source::Range
   def to_a; end
   def to_range; end
   def to_s; end
-  def with(begin_pos: _, end_pos: _); end
+  def with(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end
 end
 
 class Parser::Source::Rewriter
@@ -1012,7 +1051,7 @@ end
 class Parser::Source::Rewriter::Action
   include(::Comparable)
 
-  def initialize(range, replacement = _, allow_multiple_insertions = _, order = _); end
+  def initialize(range, replacement = T.unsafe(nil), allow_multiple_insertions = T.unsafe(nil), order = T.unsafe(nil)); end
 
   def <=>(other); end
   def allow_multiple_insertions; end
@@ -1028,13 +1067,13 @@ Parser::Source::Rewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String)
 class Parser::Source::TreeRewriter
   extend(::Parser::Deprecation)
 
-  def initialize(source_buffer, crossing_deletions: _, different_replacements: _, swallowed_insertions: _); end
+  def initialize(source_buffer, crossing_deletions: T.unsafe(nil), different_replacements: T.unsafe(nil), swallowed_insertions: T.unsafe(nil)); end
 
   def as_nested_actions; end
   def as_replacements; end
   def diagnostics; end
   def empty?; end
-  def import!(foreign_rewriter, offset: _); end
+  def import!(foreign_rewriter, offset: T.unsafe(nil)); end
   def in_transaction?; end
   def insert_after(range, content); end
   def insert_after_multi(range, text); end
@@ -1059,13 +1098,13 @@ class Parser::Source::TreeRewriter
   def check_range_validity(range); end
   def combine(range, attributes); end
   def enforce_policy(event); end
-  def trigger_policy(event, range: _, conflict: _, **arguments); end
+  def trigger_policy(event, range: T.unsafe(nil), conflict: T.unsafe(nil), **arguments); end
 end
 
 Parser::Source::TreeRewriter::ACTIONS = T.let(T.unsafe(nil), Array)
 
 class Parser::Source::TreeRewriter::Action
-  def initialize(range, enforcer, insert_before: _, replacement: _, insert_after: _, children: _); end
+  def initialize(range, enforcer, insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil), children: T.unsafe(nil)); end
 
   def combine(action); end
   def contract; end
@@ -1082,7 +1121,7 @@ class Parser::Source::TreeRewriter::Action
   protected
 
   def analyse_hierarchy(action); end
-  def bsearch_child_index(from = _); end
+  def bsearch_child_index(from = T.unsafe(nil)); end
   def call_enforcer_for_merge(action); end
   def check_fusible(action, *fusible); end
   def children; end
@@ -1092,7 +1131,7 @@ class Parser::Source::TreeRewriter::Action
   def merge(action); end
   def place_in_hierarchy(action); end
   def swallow(children); end
-  def with(range: _, enforcer: _, children: _, insert_before: _, replacement: _, insert_after: _); end
+  def with(range: T.unsafe(nil), enforcer: T.unsafe(nil), children: T.unsafe(nil), insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil)); end
 end
 
 Parser::Source::TreeRewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String)

Library/Homebrew/sorbet/rbi/gems/patchelf@1.2.0.rbi

@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `patchelf` gem.
-# Please instead update this file by running `tapioca sync --exclude json`.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/plist@3.5.0.rbi

@@ -1,29 +1,34 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `plist` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module Plist
-  def self.parse_xml(filename_or_xml); end
+  class << self
+    def parse_xml(filename_or_xml); end
+  end
 end
 
 module Plist::Emit
-  def save_plist(filename, options = _); end
+  def save_plist(filename, options = T.unsafe(nil)); end
-  def to_plist(envelope = _, options = _); end
+  def to_plist(envelope = T.unsafe(nil), options = T.unsafe(nil)); end
 
-  def self.comment(content); end
+  class << self
-  def self.dump(obj, envelope = _, options = _); end
+    def comment(content); end
-  def self.element_type(item); end
+    def dump(obj, envelope = T.unsafe(nil), options = T.unsafe(nil)); end
-  def self.plist_node(element, options = _); end
+    def element_type(item); end
-  def self.save_plist(obj, filename, options = _); end
+    def plist_node(element, options = T.unsafe(nil)); end
-  def self.tag(type, contents = _, options = _, &block); end
+    def save_plist(obj, filename, options = T.unsafe(nil)); end
-  def self.wrap(contents); end
+    def tag(type, contents = T.unsafe(nil), options = T.unsafe(nil), &block); end
+    def wrap(contents); end
+  end
 end
 
 Plist::Emit::DEFAULT_INDENT = T.let(T.unsafe(nil), String)
 
 class Plist::Emit::IndentedString
-  def initialize(str = _); end
+  def initialize(str = T.unsafe(nil)); end
 
   def <<(val); end
   def indent_string; end
@@ -94,8 +99,10 @@ class Plist::PTag
   def text=(_); end
   def to_ruby; end
 
-  def self.inherited(sub_class); end
+  class << self
-  def self.mappings; end
+    def inherited(sub_class); end
+    def mappings; end
+  end
 end
 
 class Plist::PTrue < ::Plist::PTag

Library/Homebrew/sorbet/rbi/gems/pry@0.13.1.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `pry` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/rainbow@3.0.0.rbi

@@ -1,21 +1,26 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `rainbow` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module Rainbow
-  def self.enabled; end
+  class << self
-  def self.enabled=(value); end
+    def enabled; end
-  def self.global; end
+    def enabled=(value); end
-  def self.new; end
+    def global; end
-  def self.uncolor(string); end
+    def new; end
+    def uncolor(string); end
+  end
 end
 
 class Rainbow::Color
   def ground; end
 
-  def self.build(ground, values); end
+  class << self
-  def self.parse_hex_color(hex); end
+    def build(ground, values); end
+    def parse_hex_color(hex); end
+  end
 end
 
 class Rainbow::Color::Indexed < ::Rainbow::Color
@@ -28,8 +33,10 @@ end
 class Rainbow::Color::Named < ::Rainbow::Color::Indexed
   def initialize(ground, name); end
 
-  def self.color_names; end
+  class << self
-  def self.valid_names; end
+    def color_names; end
+    def valid_names; end
+  end
 end
 
 Rainbow::Color::Named::NAMES = T.let(T.unsafe(nil), Hash)
@@ -46,7 +53,9 @@ class Rainbow::Color::RGB < ::Rainbow::Color::Indexed
 
   def code_from_rgb; end
 
-  def self.to_ansi_domain(value); end
+  class << self
+    def to_ansi_domain(value); end
+  end
 end
 
 class Rainbow::Color::X11Named < ::Rainbow::Color::RGB
@@ -54,8 +63,10 @@ class Rainbow::Color::X11Named < ::Rainbow::Color::RGB
 
   def initialize(ground, name); end
 
-  def self.color_names; end
+  class << self
-  def self.valid_names; end
+    def color_names; end
+    def valid_names; end
+  end
 end
 
 class Rainbow::NullPresenter < ::String
@@ -124,12 +135,14 @@ end
 Rainbow::Presenter::TERM_EFFECTS = T.let(T.unsafe(nil), Hash)
 
 class Rainbow::StringUtils
-  def self.uncolor(string); end
+  class << self
-  def self.wrap_with_sgr(string, codes); end
+    def uncolor(string); end
+    def wrap_with_sgr(string, codes); end
+  end
 end
 
 class Rainbow::Wrapper
-  def initialize(enabled = _); end
+  def initialize(enabled = T.unsafe(nil)); end
 
   def enabled; end
   def enabled=(_); end

Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.1.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `rdiscount` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/regexp_parser@1.7.1.rbi

@@ -1,10 +1,13 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `regexp_parser` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module Regexp::Expression
-  def self.parsed(exp); end
+  class << self
+    def parsed(exp); end
+  end
 end
 
 class Regexp::Expression::Alternation < ::Regexp::Expression::SequenceOperation
@@ -87,7 +90,7 @@ class Regexp::Expression::Backreference::Base < ::Regexp::Expression::Base
 end
 
 class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backreference::Base
-  def initialize(token, options = _); end
+  def initialize(token, options = T.unsafe(nil)); end
 
   def name; end
   def reference; end
@@ -97,13 +100,13 @@ class Regexp::Expression::Backreference::NameCall < ::Regexp::Expression::Backre
 end
 
 class Regexp::Expression::Backreference::NameRecursionLevel < ::Regexp::Expression::Backreference::Name
-  def initialize(token, options = _); end
+  def initialize(token, options = T.unsafe(nil)); end
 
   def recursion_level; end
 end
 
 class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backreference::Base
-  def initialize(token, options = _); end
+  def initialize(token, options = T.unsafe(nil)); end
 
   def number; end
   def reference; end
@@ -116,7 +119,7 @@ class Regexp::Expression::Backreference::NumberCallRelative < ::Regexp::Expressi
 end
 
 class Regexp::Expression::Backreference::NumberRecursionLevel < ::Regexp::Expression::Backreference::Number
-  def initialize(token, options = _); end
+  def initialize(token, options = T.unsafe(nil)); end
 
   def recursion_level; end
 end
@@ -128,9 +131,9 @@ class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::
 end
 
 class Regexp::Expression::Base
-  def initialize(token, options = _); end
+  def initialize(token, options = T.unsafe(nil)); end
 
-  def =~(string, offset = _); end
+  def =~(string, offset = T.unsafe(nil)); end
   def a?; end
   def ascii_classes?; end
   def attributes; end
@@ -146,19 +149,19 @@ class Regexp::Expression::Base
   def greedy?; end
   def i?; end
   def ignore_case?; end
-  def is?(test_token, test_type = _); end
+  def is?(test_token, test_type = T.unsafe(nil)); end
   def lazy?; end
   def level; end
   def level=(_); end
   def m?; end
-  def match(string, offset = _); end
+  def match(string, offset = T.unsafe(nil)); end
   def match?(string); end
   def matches?(string); end
   def multiline?; end
   def nesting_level; end
   def nesting_level=(_); end
   def offset; end
-  def one_of?(scope, top = _); end
+  def one_of?(scope, top = T.unsafe(nil)); end
   def options; end
   def options=(_); end
   def possessive?; end
@@ -166,21 +169,21 @@ class Regexp::Expression::Base
   def quantifier; end
   def quantifier=(_); end
   def quantifier_affix(expression_format); end
-  def quantify(token, text, min = _, max = _, mode = _); end
+  def quantify(token, text, min = T.unsafe(nil), max = T.unsafe(nil), mode = T.unsafe(nil)); end
   def quantity; end
   def reluctant?; end
   def repetitions; end
   def set_level; end
   def set_level=(_); end
   def starts_at; end
-  def strfre(format = _, indent_offset = _, index = _); end
+  def strfre(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end
-  def strfregexp(format = _, indent_offset = _, index = _); end
+  def strfregexp(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end
   def terminal?; end
   def text; end
   def text=(_); end
   def to_h; end
-  def to_re(format = _); end
+  def to_re(format = T.unsafe(nil)); end
-  def to_s(format = _); end
+  def to_s(format = T.unsafe(nil)); end
   def token; end
   def token=(_); end
   def ts; end
@@ -199,7 +202,7 @@ class Regexp::Expression::Base
 end
 
 class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
-  def initialize(token, options = _); end
+  def initialize(token, options = T.unsafe(nil)); end
 
   def close; end
   def closed; end
@@ -211,7 +214,7 @@ class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
   def negative; end
   def negative=(_); end
   def negative?; end
-  def to_s(format = _); end
+  def to_s(format = T.unsafe(nil)); end
 end
 
 class Regexp::Expression::CharacterSet::IntersectedSequence < ::Regexp::Expression::Sequence
@@ -229,7 +232,7 @@ class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpress
   def complete?; end
   def match_length; end
   def starts_at; end
-  def to_s(_format = _); end
+  def to_s(_format = T.unsafe(nil)); end
   def ts; end
 end
 
@@ -291,8 +294,8 @@ end
 
 class Regexp::Expression::Conditional::Expression < ::Regexp::Expression::Subexpression
   def <<(exp); end
-  def add_sequence(active_opts = _); end
+  def add_sequence(active_opts = T.unsafe(nil)); end
-  def branch(active_opts = _); end
+  def branch(active_opts = T.unsafe(nil)); end
   def branches; end
   def condition; end
   def condition=(exp); end
@@ -300,7 +303,7 @@ class Regexp::Expression::Conditional::Expression < ::Regexp::Expression::Subexp
   def reference; end
   def referenced_expression; end
   def referenced_expression=(_); end
-  def to_s(format = _); end
+  def to_s(format = T.unsafe(nil)); end
 end
 
 class Regexp::Expression::Conditional::TooManyBranches < ::StandardError
@@ -385,7 +388,7 @@ end
 
 class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base
   def match_length; end
-  def quantify(token, text, min = _, max = _, mode = _); end
+  def quantify(token, text, min = T.unsafe(nil), max = T.unsafe(nil), mode = T.unsafe(nil)); end
 end
 
 module Regexp::Expression::Group
@@ -401,7 +404,7 @@ end
 class Regexp::Expression::Group::Base < ::Regexp::Expression::Subexpression
   def capturing?; end
   def comment?; end
-  def to_s(format = _); end
+  def to_s(format = T.unsafe(nil)); end
 end
 
 class Regexp::Expression::Group::Capture < ::Regexp::Expression::Group::Base
@@ -415,11 +418,11 @@ end
 
 class Regexp::Expression::Group::Comment < ::Regexp::Expression::Group::Base
   def comment?; end
-  def to_s(_format = _); end
+  def to_s(_format = T.unsafe(nil)); end
 end
 
 class Regexp::Expression::Group::Named < ::Regexp::Expression::Group::Capture
-  def initialize(token, options = _); end
+  def initialize(token, options = T.unsafe(nil)); end
 
   def identifier; end
   def name; end
@@ -482,62 +485,66 @@ Regexp::Expression::Quantifier::MODES = T.let(T.unsafe(nil), Array)
 class Regexp::Expression::Root < ::Regexp::Expression::Subexpression
   def initialize(*args); end
 
-  def self.build(options = _); end
+  class << self
-  def self.build_token; end
+    def build(options = T.unsafe(nil)); end
+    def build_token; end
+  end
 end
 
 class Regexp::Expression::Sequence < ::Regexp::Expression::Subexpression
   def initialize(*args); end
 
-  def quantify(token, text, min = _, max = _, mode = _); end
+  def quantify(token, text, min = T.unsafe(nil), max = T.unsafe(nil), mode = T.unsafe(nil)); end
   def starts_at; end
   def ts; end
 
-  def self.add_to(subexpression, params = _, active_opts = _); end
+  class << self
-  def self.at_levels(level, set_level, conditional_level); end
+    def add_to(subexpression, params = T.unsafe(nil), active_opts = T.unsafe(nil)); end
+    def at_levels(level, set_level, conditional_level); end
+  end
 end
 
 class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpression
   def <<(exp); end
-  def add_sequence(active_opts = _); end
+  def add_sequence(active_opts = T.unsafe(nil)); end
   def operands; end
   def operator; end
   def sequences; end
   def starts_at; end
-  def to_s(format = _); end
+  def to_s(format = T.unsafe(nil)); end
   def ts; end
 end
 
 class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
   include(::Enumerable)
 
-  def initialize(token, options = _); end
+  def initialize(token, options = T.unsafe(nil)); end
 
   def <<(exp); end
   def [](*args, &block); end
   def at(*args, &block); end
   def dig(*indices); end
   def each(*args, &block); end
-  def each_expression(include_self = _, &block); end
+  def each_expression(include_self = T.unsafe(nil), &block); end
   def empty?(*args, &block); end
   def expressions; end
   def expressions=(_); end
   def fetch(*args, &block); end
-  def flat_map(include_self = _, &block); end
+  def flat_map(include_self = T.unsafe(nil), &block); end
   def index(*args, &block); end
   def inner_match_length; end
   def join(*args, &block); end
   def last(*args, &block); end
   def length(*args, &block); end
   def match_length; end
-  def strfre_tree(format = _, include_self = _, separator = _); end
+  def strfre_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
-  def strfregexp_tree(format = _, include_self = _, separator = _); end
+  def strfregexp_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
   def te; end
   def to_h; end
-  def to_s(format = _); end
+  def to_s(format = T.unsafe(nil)); end
-  def traverse(include_self = _, &block); end
+  def traverse(include_self = T.unsafe(nil), &block); end
   def values_at(*args, &block); end
-  def walk(include_self = _, &block); end
+  def walk(include_self = T.unsafe(nil), &block); end
 
   private
 
@@ -787,7 +794,7 @@ class Regexp::Expression::WhiteSpace < ::Regexp::Expression::FreeSpace
 end
 
 class Regexp::Lexer
-  def lex(input, syntax = _, &block); end
+  def lex(input, syntax = T.unsafe(nil), &block); end
 
   private
 
@@ -807,8 +814,10 @@ class Regexp::Lexer
   def tokens; end
   def tokens=(_); end
 
-  def self.lex(input, syntax = _, &block); end
+  class << self
-  def self.scan(input, syntax = _, &block); end
+    def lex(input, syntax = T.unsafe(nil), &block); end
+    def scan(input, syntax = T.unsafe(nil), &block); end
+  end
 end
 
 Regexp::Lexer::CLOSING_TOKENS = T.let(T.unsafe(nil), Array)
@@ -818,9 +827,9 @@ Regexp::Lexer::OPENING_TOKENS = T.let(T.unsafe(nil), Array)
 class Regexp::MatchLength
   include(::Enumerable)
 
-  def initialize(exp, opts = _); end
+  def initialize(exp, opts = T.unsafe(nil)); end
 
-  def each(opts = _); end
+  def each(opts = T.unsafe(nil)); end
   def endless_each(&block); end
   def fixed?; end
   def include?(length); end
@@ -846,7 +855,9 @@ class Regexp::MatchLength
   def reify=(_); end
   def test_regexp; end
 
-  def self.of(obj); end
+  class << self
+    def of(obj); end
+  end
 end
 
 class Regexp::Parser
@@ -854,7 +865,7 @@ class Regexp::Parser
   include(::Regexp::Syntax)
   include(::Regexp::Expression::UnicodeProperty)
 
-  def parse(input, syntax = _, &block); end
+  def parse(input, syntax = T.unsafe(nil), &block); end
 
   private
 
@@ -909,7 +920,9 @@ class Regexp::Parser
   def type(token); end
   def update_transplanted_subtree(exp, new_parent); end
 
-  def self.parse(input, syntax = _, &block); end
+  class << self
+    def parse(input, syntax = T.unsafe(nil), &block); end
+  end
 end
 
 Regexp::Parser::ENC_FLAGS = T.let(T.unsafe(nil), Array)
@@ -956,14 +969,16 @@ class Regexp::Scanner
   def set_depth=(_); end
   def spacing_stack; end
   def spacing_stack=(_); end
-  def text(data, ts, te, soff = _); end
+  def text(data, ts, te, soff = T.unsafe(nil)); end
   def tokens; end
   def tokens=(_); end
   def validation_error(type, what, reason); end
 
-  def self.long_prop_map; end
+  class << self
-  def self.scan(input_object, &block); end
+    def long_prop_map; end
-  def self.short_prop_map; end
+    def scan(input_object, &block); end
+    def short_prop_map; end
+  end
 end
 
 class Regexp::Scanner::InvalidBackrefError < ::Regexp::Scanner::ValidationError
@@ -979,13 +994,13 @@ class Regexp::Scanner::InvalidGroupOption < ::Regexp::Scanner::ValidationError
 end
 
 class Regexp::Scanner::InvalidSequenceError < ::Regexp::Scanner::ValidationError
-  def initialize(what = _, where = _); end
+  def initialize(what = T.unsafe(nil), where = T.unsafe(nil)); end
 end
 
 Regexp::Scanner::PROP_MAPS_DIR = T.let(T.unsafe(nil), String)
 
 class Regexp::Scanner::PrematureEndError < ::Regexp::Scanner::ScannerError
-  def initialize(where = _); end
+  def initialize(where = T.unsafe(nil)); end
 end
 
 class Regexp::Scanner::ScannerError < ::StandardError
@@ -1014,16 +1029,18 @@ module Regexp::Syntax
   def version_const_name(version_string); end
   def warn_if_future_version(const_name); end
 
-  def self.comparable_version(name); end
+  class << self
-  def self.const_missing(const_name); end
+    def comparable_version(name); end
-  def self.fallback_version_class(version); end
+    def const_missing(const_name); end
-  def self.inherit_from_version(parent_version, new_version); end
+    def fallback_version_class(version); end
-  def self.new(name); end
+    def inherit_from_version(parent_version, new_version); end
-  def self.specified_versions; end
+    def new(name); end
-  def self.supported?(name); end
+    def specified_versions; end
-  def self.version_class(version); end
+    def supported?(name); end
-  def self.version_const_name(version_string); end
+    def version_class(version); end
-  def self.warn_if_future_version(const_name); end
+    def version_const_name(version_string); end
+    def warn_if_future_version(const_name); end
+  end
 end
 
 class Regexp::Syntax::Any < ::Regexp::Syntax::Base
@@ -1050,7 +1067,9 @@ class Regexp::Syntax::Base
   def normalize_backref(type, token); end
   def normalize_group(type, token); end
 
-  def self.inspect; end
+  class << self
+    def inspect; end
+  end
 end
 
 class Regexp::Syntax::InvalidVersionNameError < ::SyntaxError
@@ -1500,8 +1519,10 @@ class Regexp::Token < ::Struct
   def type; end
   def type=(_); end
 
-  def self.[](*_); end
+  class << self
-  def self.inspect; end
+    def [](*_); end
-  def self.members; end
+    def inspect; end
-  def self.new(*_); end
+    def members; end
+    def new(*_); end
+  end
 end

Library/Homebrew/sorbet/rbi/gems/rexml@3.2.4.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `rexml` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -43,7 +44,7 @@ class REXML::AttlistDecl < ::REXML::Child
   def element_name; end
   def include?(key); end
   def node_type; end
-  def write(out, indent = _); end
+  def write(out, indent = T.unsafe(nil)); end
 end
 
 class REXML::Attribute
@@ -51,7 +52,7 @@ class REXML::Attribute
   include(::REXML::XMLTokens)
   include(::REXML::Namespace)
 
-  def initialize(first, second = _, parent = _); end
+  def initialize(first, second = T.unsafe(nil), parent = T.unsafe(nil)); end
 
   def ==(other); end
   def clone; end
@@ -60,7 +61,7 @@ class REXML::Attribute
   def element=(element); end
   def hash; end
   def inspect; end
-  def namespace(arg = _); end
+  def namespace(arg = T.unsafe(nil)); end
   def node_type; end
   def normalized=(_); end
   def prefix; end
@@ -68,7 +69,7 @@ class REXML::Attribute
   def to_s; end
   def to_string; end
   def value; end
-  def write(output, indent = _); end
+  def write(output, indent = T.unsafe(nil)); end
   def xpath; end
 end
 
@@ -93,18 +94,18 @@ class REXML::Attributes < ::Hash
 end
 
 class REXML::CData < ::REXML::Text
-  def initialize(first, whitespace = _, parent = _); end
+  def initialize(first, whitespace = T.unsafe(nil), parent = T.unsafe(nil)); end
 
   def clone; end
   def to_s; end
   def value; end
-  def write(output = _, indent = _, transitive = _, ie_hack = _); end
+  def write(output = T.unsafe(nil), indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
 end
 
 class REXML::Child
   include(::REXML::Node)
 
-  def initialize(parent = _); end
+  def initialize(parent = T.unsafe(nil)); end
 
   def bytes; end
   def document; end
@@ -121,7 +122,7 @@ end
 class REXML::Comment < ::REXML::Child
   include(::Comparable)
 
-  def initialize(first, second = _); end
+  def initialize(first, second = T.unsafe(nil)); end
 
   def <=>(other); end
   def ==(other); end
@@ -130,7 +131,7 @@ class REXML::Comment < ::REXML::Child
   def string; end
   def string=(_); end
   def to_s; end
-  def write(output, indent = _, transitive = _, ie_hack = _); end
+  def write(output, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
 end
 
 class REXML::Declaration < ::REXML::Child
@@ -143,7 +144,7 @@ end
 class REXML::DocType < ::REXML::Parent
   include(::REXML::XMLTokens)
 
-  def initialize(first, parent = _); end
+  def initialize(first, parent = T.unsafe(nil)); end
 
   def add(child); end
   def attribute_of(element, attribute); end
@@ -160,7 +161,7 @@ class REXML::DocType < ::REXML::Parent
   def notations; end
   def public; end
   def system; end
-  def write(output, indent = _, transitive = _, ie_hack = _); end
+  def write(output, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
 
   private
 
@@ -168,11 +169,11 @@ class REXML::DocType < ::REXML::Parent
 end
 
 class REXML::Document < ::REXML::Element
-  def initialize(source = _, context = _); end
+  def initialize(source = T.unsafe(nil), context = T.unsafe(nil)); end
 
   def <<(child); end
   def add(child); end
-  def add_element(arg = _, arg2 = _); end
+  def add_element(arg = T.unsafe(nil), arg2 = T.unsafe(nil)); end
   def clone; end
   def doctype; end
   def document; end
@@ -192,26 +193,28 @@ class REXML::Document < ::REXML::Element
 
   def build(source); end
 
-  def self.entity_expansion_limit; end
+  class << self
-  def self.entity_expansion_limit=(val); end
+    def entity_expansion_limit; end
-  def self.entity_expansion_text_limit; end
+    def entity_expansion_limit=(val); end
-  def self.entity_expansion_text_limit=(val); end
+    def entity_expansion_text_limit; end
-  def self.parse_stream(source, listener); end
+    def entity_expansion_text_limit=(val); end
+    def parse_stream(source, listener); end
+  end
 end
 
 class REXML::Element < ::REXML::Parent
   include(::REXML::XMLTokens)
   include(::REXML::Namespace)
 
-  def initialize(arg = _, parent = _, context = _); end
+  def initialize(arg = T.unsafe(nil), parent = T.unsafe(nil), context = T.unsafe(nil)); end
 
   def [](name_or_index); end
-  def add_attribute(key, value = _); end
+  def add_attribute(key, value = T.unsafe(nil)); end
   def add_attributes(hash); end
-  def add_element(element, attrs = _); end
+  def add_element(element, attrs = T.unsafe(nil)); end
-  def add_namespace(prefix, uri = _); end
+  def add_namespace(prefix, uri = T.unsafe(nil)); end
   def add_text(text); end
-  def attribute(name, namespace = _); end
+  def attribute(name, namespace = T.unsafe(nil)); end
   def attributes; end
   def cdatas; end
   def clone; end
@@ -220,21 +223,21 @@ class REXML::Element < ::REXML::Parent
   def context=(_); end
   def delete_attribute(key); end
   def delete_element(element); end
-  def delete_namespace(namespace = _); end
+  def delete_namespace(namespace = T.unsafe(nil)); end
   def document; end
-  def each_element(xpath = _, &block); end
+  def each_element(xpath = T.unsafe(nil), &block); end
-  def each_element_with_attribute(key, value = _, max = _, name = _, &block); end
+  def each_element_with_attribute(key, value = T.unsafe(nil), max = T.unsafe(nil), name = T.unsafe(nil), &block); end
-  def each_element_with_text(text = _, max = _, name = _, &block); end
+  def each_element_with_text(text = T.unsafe(nil), max = T.unsafe(nil), name = T.unsafe(nil), &block); end
   def elements; end
   def get_elements(xpath); end
-  def get_text(path = _); end
+  def get_text(path = T.unsafe(nil)); end
   def has_attributes?; end
   def has_elements?; end
   def has_text?; end
   def ignore_whitespace_nodes; end
   def inspect; end
   def instructions; end
-  def namespace(prefix = _); end
+  def namespace(prefix = T.unsafe(nil)); end
   def namespaces; end
   def next_element; end
   def node_type; end
@@ -243,17 +246,17 @@ class REXML::Element < ::REXML::Parent
   def raw; end
   def root; end
   def root_node; end
-  def text(path = _); end
+  def text(path = T.unsafe(nil)); end
   def text=(text); end
   def texts; end
   def whitespace; end
-  def write(output = _, indent = _, transitive = _, ie_hack = _); end
+  def write(output = T.unsafe(nil), indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
   def xpath; end
 
   private
 
   def __to_xpath_helper(node); end
-  def each_with_something(test, max = _, name = _); end
+  def each_with_something(test, max = T.unsafe(nil), name = T.unsafe(nil)); end
 end
 
 class REXML::Elements
@@ -261,19 +264,19 @@ class REXML::Elements
 
   def initialize(parent); end
 
-  def <<(element = _); end
+  def <<(element = T.unsafe(nil)); end
-  def [](index, name = _); end
+  def [](index, name = T.unsafe(nil)); end
   def []=(index, element); end
-  def add(element = _); end
+  def add(element = T.unsafe(nil)); end
-  def collect(xpath = _); end
+  def collect(xpath = T.unsafe(nil)); end
   def delete(element); end
   def delete_all(xpath); end
-  def each(xpath = _); end
+  def each(xpath = T.unsafe(nil)); end
   def empty?; end
   def index(element); end
-  def inject(xpath = _, initial = _); end
+  def inject(xpath = T.unsafe(nil), initial = T.unsafe(nil)); end
   def size; end
-  def to_a(xpath = _); end
+  def to_a(xpath = T.unsafe(nil)); end
 
   private
 
@@ -294,7 +297,7 @@ end
 class REXML::Entity < ::REXML::Child
   include(::REXML::XMLTokens)
 
-  def initialize(stream, value = _, parent = _, reference = _); end
+  def initialize(stream, value = T.unsafe(nil), parent = T.unsafe(nil), reference = T.unsafe(nil)); end
 
   def external; end
   def name; end
@@ -305,9 +308,11 @@ class REXML::Entity < ::REXML::Child
   def to_s; end
   def unnormalized; end
   def value; end
-  def write(out, indent = _); end
+  def write(out, indent = T.unsafe(nil)); end
 
-  def self.matches?(string); end
+  class << self
+    def matches?(string); end
+  end
 end
 
 class REXML::ExternalEntity < ::REXML::Child
@@ -318,7 +323,7 @@ class REXML::ExternalEntity < ::REXML::Child
 end
 
 class REXML::Formatters::Default
-  def initialize(ie_hack = _); end
+  def initialize(ie_hack = T.unsafe(nil)); end
 
   def write(node, output); end
 
@@ -333,7 +338,7 @@ class REXML::Formatters::Default
 end
 
 class REXML::Formatters::Pretty < ::REXML::Formatters::Default
-  def initialize(indentation = _, ie_hack = _); end
+  def initialize(indentation = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
 
   def compact; end
   def compact=(_); end
@@ -350,20 +355,20 @@ class REXML::Formatters::Pretty < ::REXML::Formatters::Default
 
   private
 
-  def indent_text(string, level = _, style = _, indentfirstline = _); end
+  def indent_text(string, level = T.unsafe(nil), style = T.unsafe(nil), indentfirstline = T.unsafe(nil)); end
   def wrap(string, width); end
 end
 
 class REXML::IOSource < ::REXML::Source
-  def initialize(arg, block_size = _, encoding = _); end
+  def initialize(arg, block_size = T.unsafe(nil), encoding = T.unsafe(nil)); end
 
   def consume(pattern); end
   def current_line; end
   def empty?; end
-  def match(pattern, cons = _); end
+  def match(pattern, cons = T.unsafe(nil)); end
   def position; end
   def read; end
-  def scan(pattern, cons = _); end
+  def scan(pattern, cons = T.unsafe(nil)); end
 
   private
 
@@ -372,7 +377,7 @@ class REXML::IOSource < ::REXML::Source
 end
 
 class REXML::Instruction < ::REXML::Child
-  def initialize(target, content = _); end
+  def initialize(target, content = T.unsafe(nil)); end
 
   def ==(other); end
   def clone; end
@@ -382,7 +387,7 @@ class REXML::Instruction < ::REXML::Child
   def node_type; end
   def target; end
   def target=(_); end
-  def write(writer, indent = _, transitive = _, ie_hack = _); end
+  def write(writer, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
 end
 
 class REXML::NotationDecl < ::REXML::Child
@@ -394,13 +399,13 @@ class REXML::NotationDecl < ::REXML::Child
   def system; end
   def system=(_); end
   def to_s; end
-  def write(output, indent = _); end
+  def write(output, indent = T.unsafe(nil)); end
 end
 
 class REXML::Output
   include(::REXML::Encoding)
 
-  def initialize(real_IO, encd = _); end
+  def initialize(real_IO, encd = T.unsafe(nil)); end
 
   def <<(content); end
   def encoding; end
@@ -410,7 +415,7 @@ end
 class REXML::Parent < ::REXML::Child
   include(::Enumerable)
 
-  def initialize(parent = _); end
+  def initialize(parent = T.unsafe(nil)); end
 
   def <<(object); end
   def [](index); end
@@ -437,7 +442,7 @@ class REXML::Parent < ::REXML::Child
 end
 
 class REXML::ParseException < ::RuntimeError
-  def initialize(message, source = _, parser = _, exception = _); end
+  def initialize(message, source = T.unsafe(nil), parser = T.unsafe(nil), exception = T.unsafe(nil)); end
 
   def context; end
   def continued_exception; end
@@ -458,13 +463,13 @@ class REXML::Parsers::BaseParser
   def empty?; end
   def entity(reference, entities); end
   def has_next?; end
-  def normalize(input, entities = _, entity_filter = _); end
+  def normalize(input, entities = T.unsafe(nil), entity_filter = T.unsafe(nil)); end
-  def peek(depth = _); end
+  def peek(depth = T.unsafe(nil)); end
   def position; end
   def pull; end
   def source; end
   def stream=(source); end
-  def unnormalize(string, entities = _, filter = _); end
+  def unnormalize(string, entities = T.unsafe(nil), filter = T.unsafe(nil)); end
   def unshift(token); end
 
   private
@@ -487,7 +492,7 @@ class REXML::Parsers::StreamParser
 end
 
 class REXML::Parsers::TreeParser
-  def initialize(source, build_context = _); end
+  def initialize(source, build_context = T.unsafe(nil)); end
 
   def add_listener(listener); end
   def parse; end
@@ -532,7 +537,7 @@ REXML::Parsers::XPathParser::PREFIX_WILDCARD = T.let(T.unsafe(nil), Regexp)
 class REXML::Source
   include(::REXML::Encoding)
 
-  def initialize(arg, encoding = _); end
+  def initialize(arg, encoding = T.unsafe(nil)); end
 
   def buffer; end
   def consume(pattern); end
@@ -541,12 +546,12 @@ class REXML::Source
   def encoding; end
   def encoding=(enc); end
   def line; end
-  def match(pattern, cons = _); end
+  def match(pattern, cons = T.unsafe(nil)); end
   def match_to(char, pattern); end
   def match_to_consume(char, pattern); end
   def position; end
   def read; end
-  def scan(pattern, cons = _); end
+  def scan(pattern, cons = T.unsafe(nil)); end
 
   private
 
@@ -557,14 +562,14 @@ end
 class REXML::Text < ::REXML::Child
   include(::Comparable)
 
-  def initialize(arg, respect_whitespace = _, parent = _, raw = _, entity_filter = _, illegal = _); end
+  def initialize(arg, respect_whitespace = T.unsafe(nil), parent = T.unsafe(nil), raw = T.unsafe(nil), entity_filter = T.unsafe(nil), illegal = T.unsafe(nil)); end
 
   def <<(to_append); end
   def <=>(other); end
   def clone; end
   def doctype; end
   def empty?; end
-  def indent_text(string, level = _, style = _, indentfirstline = _); end
+  def indent_text(string, level = T.unsafe(nil), style = T.unsafe(nil), indentfirstline = T.unsafe(nil)); end
   def inspect; end
   def node_type; end
   def parent=(parent); end
@@ -573,8 +578,8 @@ class REXML::Text < ::REXML::Child
   def to_s; end
   def value; end
   def value=(val); end
-  def wrap(string, width, addnewline = _); end
+  def wrap(string, width, addnewline = T.unsafe(nil)); end
-  def write(writer, indent = _, transitive = _, ie_hack = _); end
+  def write(writer, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
   def write_with_substitution(out, input); end
   def xpath; end
 
@@ -582,17 +587,19 @@ class REXML::Text < ::REXML::Child
 
   def clear_cache; end
 
-  def self.check(string, pattern, doctype); end
+  class << self
-  def self.expand(ref, doctype, filter); end
+    def check(string, pattern, doctype); end
-  def self.normalize(input, doctype = _, entity_filter = _); end
+    def expand(ref, doctype, filter); end
-  def self.read_with_substitution(input, illegal = _); end
+    def normalize(input, doctype = T.unsafe(nil), entity_filter = T.unsafe(nil)); end
-  def self.unnormalize(string, doctype = _, filter = _, illegal = _); end
+    def read_with_substitution(input, illegal = T.unsafe(nil)); end
+    def unnormalize(string, doctype = T.unsafe(nil), filter = T.unsafe(nil), illegal = T.unsafe(nil)); end
+  end
 end
 
 class REXML::XMLDecl < ::REXML::Child
   include(::REXML::Encoding)
 
-  def initialize(version = _, encoding = _, standalone = _); end
+  def initialize(version = T.unsafe(nil), encoding = T.unsafe(nil), standalone = T.unsafe(nil)); end
 
   def ==(other); end
   def clone; end
@@ -607,7 +614,7 @@ class REXML::XMLDecl < ::REXML::Child
   def standalone=(_); end
   def version; end
   def version=(_); end
-  def write(writer, indent = _, transitive = _, ie_hack = _); end
+  def write(writer, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
   def writeencoding; end
   def writethis; end
   def xmldecl(version, encoding, standalone); end
@@ -616,11 +623,13 @@ class REXML::XMLDecl < ::REXML::Child
 
   def content(enc); end
 
-  def self.default; end
+  class << self
+    def default; end
+  end
 end
 
 class REXML::XPathNode
-  def initialize(node, context = _); end
+  def initialize(node, context = T.unsafe(nil)); end
 
   def context; end
   def position; end
@@ -630,16 +639,16 @@ end
 class REXML::XPathParser
   include(::REXML::XMLTokens)
 
-  def initialize(strict: _); end
+  def initialize(strict: T.unsafe(nil)); end
 
   def []=(variable_name, value); end
   def first(path_stack, node); end
   def get_first(path, nodeset); end
   def match(path_stack, nodeset); end
-  def namespaces=(namespaces = _); end
+  def namespaces=(namespaces = T.unsafe(nil)); end
   def parse(path, nodeset); end
   def predicate(path, nodeset); end
-  def variables=(vars = _); end
+  def variables=(vars = T.unsafe(nil)); end
 
   private
 
@@ -651,20 +660,20 @@ class REXML::XPathParser
   def enter(tag, *args); end
   def equality_relational_compare(set1, op, set2); end
   def evaluate_predicate(expression, nodesets); end
-  def expr(path_stack, nodeset, context = _); end
+  def expr(path_stack, nodeset, context = T.unsafe(nil)); end
   def filter_nodeset(nodeset); end
   def following(node); end
   def following_node_of(node); end
   def get_namespace(node, prefix); end
   def leave(tag, *args); end
   def next_sibling_node(node); end
-  def node_test(path_stack, nodesets, any_type: _); end
+  def node_test(path_stack, nodesets, any_type: T.unsafe(nil)); end
   def norm(b); end
   def normalize_compare_values(a, operator, b); end
   def preceding(node); end
   def preceding_node_of(node); end
   def sort(array_of_nodes, order); end
-  def step(path_stack, any_type: _, order: _); end
+  def step(path_stack, any_type: T.unsafe(nil), order: T.unsafe(nil)); end
   def strict?; end
   def trace(*args); end
   def unnode(nodeset); end

Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `ronn` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/rspec-expectations@3.9.2.rbi

@@ -1,18 +1,21 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `rspec-expectations` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module RSpec::Expectations
-  def self.configuration; end
+  class << self
-  def self.differ; end
+    def configuration; end
-  def self.fail_with(message, expected = _, actual = _); end
+    def differ; end
+    def fail_with(message, expected = T.unsafe(nil), actual = T.unsafe(nil)); end
+  end
 end
 
 class RSpec::Expectations::BlockExpectationTarget < ::RSpec::Expectations::ExpectationTarget
-  def not_to(matcher, message = _, &block); end
+  def not_to(matcher, message = T.unsafe(nil), &block); end
-  def to(matcher, message = _, &block); end
+  def to(matcher, message = T.unsafe(nil), &block); end
-  def to_not(matcher, message = _, &block); end
+  def to_not(matcher, message = T.unsafe(nil), &block); end
 
   private
 
@@ -37,7 +40,9 @@ class RSpec::Expectations::BlockSnippetExtractor
   def source; end
   def source_location; end
 
-  def self.try_extracting_single_line_body_of(proc, method_name); end
+  class << self
+    def try_extracting_single_line_body_of(proc, method_name); end
+  end
 end
 
 class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError < ::RSpec::Expectations::BlockSnippetExtractor::Error
@@ -62,10 +67,12 @@ class RSpec::Expectations::BlockSnippetExtractor::BlockLocator < ::Struct
   def method_ident_node; end
   def method_ident_node?(node); end
 
-  def self.[](*_); end
+  class << self
-  def self.inspect; end
+    def [](*_); end
-  def self.members; end
+    def inspect; end
-  def self.new(*_); end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < ::Struct
@@ -101,10 +108,12 @@ class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < ::Struct
   def pending_tokens; end
   def pipe_token?(token); end
 
-  def self.[](*_); end
+  class << self
-  def self.inspect; end
+    def [](*_); end
-  def self.members; end
+    def inspect; end
-  def self.new(*_); end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Expectations::BlockSnippetExtractor::Error < ::StandardError
@@ -136,14 +145,18 @@ end
 RSpec::Expectations::Configuration::FALSE_POSITIVE_BEHAVIOURS = T.let(T.unsafe(nil), Hash)
 
 module RSpec::Expectations::Configuration::NullBacktraceFormatter
-  def self.format_backtrace(backtrace); end
+  class << self
+    def format_backtrace(backtrace); end
+  end
 end
 
 module RSpec::Expectations::ExpectationHelper
-  def self.check_message(msg); end
+  class << self
-  def self.handle_failure(matcher, message, failure_message_method); end
+    def check_message(msg); end
-  def self.modern_matcher_from(matcher); end
+    def handle_failure(matcher, message, failure_message_method); end
-  def self.with_matcher(handler, matcher, message); end
+    def modern_matcher_from(matcher); end
+    def with_matcher(handler, matcher, message); end
+  end
 end
 
 class RSpec::Expectations::ExpectationNotMetError < ::Exception
@@ -156,13 +169,15 @@ class RSpec::Expectations::ExpectationTarget
 
   def target; end
 
-  def self.for(value, block); end
+  class << self
+    def for(value, block); end
+  end
 end
 
 module RSpec::Expectations::ExpectationTarget::InstanceMethods
-  def not_to(matcher = _, message = _, &block); end
+  def not_to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
-  def to(matcher = _, message = _, &block); end
+  def to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
-  def to_not(matcher = _, message = _, &block); end
+  def to_not(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
 
   private
 
@@ -193,21 +208,27 @@ RSpec::Expectations::LegacyMacherAdapter = RSpec::Expectations::LegacyMatcherAda
 class RSpec::Expectations::LegacyMatcherAdapter < ::RSpec::Matchers::MatcherDelegator
   def initialize(matcher); end
 
-  def self.wrap(matcher); end
+  class << self
+    def wrap(matcher); end
+  end
 end
 
 class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 < ::RSpec::Expectations::LegacyMatcherAdapter
   def failure_message; end
   def failure_message_when_negated; end
 
-  def self.interface_matches?(matcher); end
+  class << self
+    def interface_matches?(matcher); end
+  end
 end
 
 class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 < ::RSpec::Expectations::LegacyMatcherAdapter
   def failure_message; end
   def failure_message_when_negated; end
 
-  def self.interface_matches?(matcher); end
+  class << self
+    def interface_matches?(matcher); end
+  end
 end
 
 class RSpec::Expectations::MultipleExpectationsNotMetError < ::RSpec::Expectations::ExpectationNotMetError
@@ -237,18 +258,22 @@ class RSpec::Expectations::MultipleExpectationsNotMetError < ::RSpec::Expectatio
 end
 
 class RSpec::Expectations::NegativeExpectationHandler
-  def self.does_not_match?(matcher, actual, &block); end
+  class << self
-  def self.handle_matcher(actual, initial_matcher, message = _, &block); end
+    def does_not_match?(matcher, actual, &block); end
-  def self.opposite_should_method; end
+    def handle_matcher(actual, initial_matcher, message = T.unsafe(nil), &block); end
-  def self.should_method; end
+    def opposite_should_method; end
-  def self.verb; end
+    def should_method; end
+    def verb; end
+  end
 end
 
 class RSpec::Expectations::PositiveExpectationHandler
-  def self.handle_matcher(actual, initial_matcher, message = _, &block); end
+  class << self
-  def self.opposite_should_method; end
+    def handle_matcher(actual, initial_matcher, message = T.unsafe(nil), &block); end
-  def self.should_method; end
+    def opposite_should_method; end
-  def self.verb; end
+    def should_method; end
+    def verb; end
+  end
 end
 
 module RSpec::Expectations::Syntax
@@ -256,24 +281,26 @@ module RSpec::Expectations::Syntax
   private
 
   def default_should_host; end
-  def disable_expect(syntax_host = _); end
+  def disable_expect(syntax_host = T.unsafe(nil)); end
-  def disable_should(syntax_host = _); end
+  def disable_should(syntax_host = T.unsafe(nil)); end
-  def enable_expect(syntax_host = _); end
+  def enable_expect(syntax_host = T.unsafe(nil)); end
-  def enable_should(syntax_host = _); end
+  def enable_should(syntax_host = T.unsafe(nil)); end
-  def expect_enabled?(syntax_host = _); end
+  def expect_enabled?(syntax_host = T.unsafe(nil)); end
-  def should_enabled?(syntax_host = _); end
+  def should_enabled?(syntax_host = T.unsafe(nil)); end
   def warn_about_should!; end
   def warn_about_should_unless_configured(method_name); end
 
-  def self.default_should_host; end
+  class << self
-  def self.disable_expect(syntax_host = _); end
+    def default_should_host; end
-  def self.disable_should(syntax_host = _); end
+    def disable_expect(syntax_host = T.unsafe(nil)); end
-  def self.enable_expect(syntax_host = _); end
+    def disable_should(syntax_host = T.unsafe(nil)); end
-  def self.enable_should(syntax_host = _); end
+    def enable_expect(syntax_host = T.unsafe(nil)); end
-  def self.expect_enabled?(syntax_host = _); end
+    def enable_should(syntax_host = T.unsafe(nil)); end
-  def self.should_enabled?(syntax_host = _); end
+    def expect_enabled?(syntax_host = T.unsafe(nil)); end
-  def self.warn_about_should!; end
+    def should_enabled?(syntax_host = T.unsafe(nil)); end
-  def self.warn_about_should_unless_configured(method_name); end
+    def warn_about_should!; end
+    def warn_about_should_unless_configured(method_name); end
+  end
 end
 
 module RSpec::Expectations::Version
@@ -310,7 +337,7 @@ module RSpec::Matchers
   def a_value(*args, &block); end
   def a_value_between(*args, &block); end
   def a_value_within(*args, &block); end
-  def aggregate_failures(label = _, metadata = _, &block); end
+  def aggregate_failures(label = T.unsafe(nil), metadata = T.unsafe(nil), &block); end
   def all(expected); end
   def an_instance_of(*args, &block); end
   def an_object_eq_to(*args, &block); end
@@ -334,7 +361,7 @@ module RSpec::Matchers
   def be_nil; end
   def be_truthy; end
   def be_within(delta); end
-  def change(receiver = _, message = _, &block); end
+  def change(receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
   def changing(*args, &block); end
   def contain_exactly(*items); end
   def containing_exactly(*args, &block); end
@@ -350,7 +377,7 @@ module RSpec::Matchers
   def equal_to(*args, &block); end
   def exist(*args); end
   def existing(*args, &block); end
-  def expect(value = _, &block); end
+  def expect(value = T.unsafe(nil), &block); end
   def have_attributes(expected); end
   def having_attributes(*args, &block); end
   def include(*expected); end
@@ -359,17 +386,17 @@ module RSpec::Matchers
   def match_array(items); end
   def match_regex(*args, &block); end
   def matching(*args, &block); end
-  def output(expected = _); end
+  def output(expected = T.unsafe(nil)); end
-  def raise_error(error = _, message = _, &block); end
+  def raise_error(error = T.unsafe(nil), message = T.unsafe(nil), &block); end
-  def raise_exception(error = _, message = _, &block); end
+  def raise_exception(error = T.unsafe(nil), message = T.unsafe(nil), &block); end
   def raising(*args, &block); end
   def respond_to(*names); end
   def responding_to(*args, &block); end
-  def satisfy(description = _, &block); end
+  def satisfy(description = T.unsafe(nil), &block); end
   def satisfying(*args, &block); end
   def start_with(*expected); end
   def starting_with(*args, &block); end
-  def throw_symbol(expected_symbol = _, expected_arg = _); end
+  def throw_symbol(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end
   def throwing(*args, &block); end
   def within(*args, &block); end
   def yield_control; end
@@ -386,17 +413,19 @@ module RSpec::Matchers
   def method_missing(method, *args, &block); end
   def respond_to_missing?(method, *_); end
 
-  def self.alias_matcher(*args, &block); end
+  class << self
-  def self.clear_generated_description; end
+    def alias_matcher(*args, &block); end
-  def self.configuration; end
+    def clear_generated_description; end
-  def self.generated_description; end
+    def configuration; end
-  def self.is_a_describable_matcher?(obj); end
+    def generated_description; end
-  def self.is_a_matcher?(obj); end
+    def is_a_describable_matcher?(obj); end
-  def self.last_description; end
+    def is_a_matcher?(obj); end
-  def self.last_expectation_handler; end
+    def last_description; end
-  def self.last_expectation_handler=(_); end
+    def last_expectation_handler; end
-  def self.last_matcher; end
+    def last_expectation_handler=(_); end
-  def self.last_matcher=(_); end
+    def last_matcher; end
+    def last_matcher=(_); end
+  end
 end
 
 class RSpec::Matchers::AliasedMatcher < ::RSpec::Matchers::MatcherDelegator
@@ -454,7 +483,7 @@ class RSpec::Matchers::BuiltIn::BaseMatcher
   include(::RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting)
   include(::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages)
 
-  def initialize(expected = _); end
+  def initialize(expected = T.unsafe(nil)); end
 
   def actual; end
   def actual_formatted; end
@@ -475,14 +504,22 @@ class RSpec::Matchers::BuiltIn::BaseMatcher
 
   def assert_ivars(*expected_ivars); end
 
-  def self.matcher_name; end
+  class << self
+    def matcher_name; end
+
+    private
+
+    def underscore(camel_cased_word); end
+  end
 end
 
 module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
   def failure_message; end
   def failure_message_when_negated; end
 
-  def self.has_default_failure_messages?(matcher); end
+  class << self
+    def has_default_failure_messages?(matcher); end
+  end
 end
 
 module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
@@ -491,7 +528,9 @@ module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
 
   def improve_hash_formatting(inspect_string); end
 
-  def self.improve_hash_formatting(inspect_string); end
+  class << self
+    def improve_hash_formatting(inspect_string); end
+  end
 end
 
 RSpec::Matchers::BuiltIn::BaseMatcher::UNDEFINED = T.let(T.unsafe(nil), Object)
@@ -628,7 +667,7 @@ class RSpec::Matchers::BuiltIn::BeWithin < ::RSpec::Matchers::BuiltIn::BaseMatch
 end
 
 class RSpec::Matchers::BuiltIn::Change < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(receiver = _, message = _, &block); end
+  def initialize(receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
 
   def by(expected_delta); end
   def by_at_least(minimum); end
@@ -700,7 +739,9 @@ class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator
   def inner_matcher_block(outer_args); end
   def order_block_matchers; end
 
-  def self.matcher_expects_call_stack_jump?(matcher); end
+  class << self
+    def matcher_expects_call_stack_jump?(matcher); end
+  end
 end
 
 class RSpec::Matchers::BuiltIn::Compound::Or < ::RSpec::Matchers::BuiltIn::Compound
@@ -728,14 +769,14 @@ class RSpec::Matchers::BuiltIn::ContainExactly < ::RSpec::Matchers::BuiltIn::Bas
   def actual_collection_line; end
   def best_solution; end
   def convert_actual_to_an_array; end
-  def describe_collection(collection, surface_descriptions = _); end
+  def describe_collection(collection, surface_descriptions = T.unsafe(nil)); end
   def expected_collection_line; end
   def extra_elements_line; end
   def extra_items; end
   def generate_failure_message; end
   def match(_expected, _actual); end
   def match_when_sorted?; end
-  def message_line(prefix, collection, surface_descriptions = _); end
+  def message_line(prefix, collection, surface_descriptions = T.unsafe(nil)); end
   def missing_elements_line; end
   def missing_items; end
   def pairings_maximizer; end
@@ -760,7 +801,9 @@ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer
 end
 
 class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution
-  def self.worse_than?(_other); end
+  class << self
+    def worse_than?(_other); end
+  end
 end
 
 class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < ::Struct
@@ -778,10 +821,12 @@ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < ::
   def unmatched_item_count; end
   def worse_than?(other); end
 
-  def self.[](*_); end
+  class << self
-  def self.inspect; end
+    def [](*_); end
-  def self.members; end
+    def inspect; end
-  def self.new(*_); end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Matchers::BuiltIn::Cover < ::RSpec::Matchers::BuiltIn::BaseMatcher
@@ -969,11 +1014,13 @@ class RSpec::Matchers::BuiltIn::OperatorMatcher
   def eval_match(actual, operator, expected); end
   def has_non_generic_implementation_of?(op); end
 
-  def self.get(klass, operator); end
+  class << self
-  def self.register(klass, operator, matcher); end
+    def get(klass, operator); end
-  def self.registry; end
+    def register(klass, operator, matcher); end
-  def self.unregister(klass, operator); end
+    def registry; end
-  def self.use_custom_matcher_or_delegate(operator); end
+    def unregister(klass, operator); end
+    def use_custom_matcher_or_delegate(operator); end
+  end
 end
 
 class RSpec::Matchers::BuiltIn::Output < ::RSpec::Matchers::BuiltIn::BaseMatcher
@@ -1006,14 +1053,14 @@ end
 class RSpec::Matchers::BuiltIn::RaiseError
   include(::RSpec::Matchers::Composable)
 
-  def initialize(expected_error_or_message = _, expected_message = _, &block); end
+  def initialize(expected_error_or_message = T.unsafe(nil), expected_message = T.unsafe(nil), &block); end
 
   def description; end
   def does_not_match?(given_proc); end
   def expects_call_stack_jump?; end
   def failure_message; end
   def failure_message_when_negated; end
-  def matches?(given_proc, negative_expectation = _, &block); end
+  def matches?(given_proc, negative_expectation = T.unsafe(nil), &block); end
   def supports_block_expectations?; end
   def with_message(expected_message); end
 
@@ -1070,7 +1117,7 @@ class RSpec::Matchers::BuiltIn::RespondTo < ::RSpec::Matchers::BuiltIn::BaseMatc
 end
 
 class RSpec::Matchers::BuiltIn::Satisfy < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(description = _, &block); end
+  def initialize(description = T.unsafe(nil), &block); end
 
   def description; end
   def failure_message; end
@@ -1094,7 +1141,7 @@ end
 class RSpec::Matchers::BuiltIn::ThrowSymbol
   include(::RSpec::Matchers::Composable)
 
-  def initialize(expected_symbol = _, expected_arg = _); end
+  def initialize(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end
 
   def description; end
   def does_not_match?(given_proc); end
@@ -1108,7 +1155,7 @@ class RSpec::Matchers::BuiltIn::ThrowSymbol
 
   def actual_result; end
   def caught; end
-  def expected(symbol_desc = _); end
+  def expected(symbol_desc = T.unsafe(nil)); end
   def throw_description(symbol, arg); end
 end
 
@@ -1202,9 +1249,11 @@ module RSpec::Matchers::Composable
   def values_match?(expected, actual); end
   def with_matchers_cloned(object); end
 
-  def self.should_enumerate?(item); end
+  class << self
-  def self.surface_descriptions_in(item); end
+    def should_enumerate?(item); end
-  def self.unreadable_io?(object); end
+    def surface_descriptions_in(item); end
+    def unreadable_io?(object); end
+  end
 end
 
 class RSpec::Matchers::Composable::DescribableItem < ::Struct
@@ -1213,14 +1262,16 @@ class RSpec::Matchers::Composable::DescribableItem < ::Struct
   def item=(_); end
   def pretty_print(pp); end
 
-  def self.[](*_); end
+  class << self
-  def self.inspect; end
+    def [](*_); end
-  def self.members; end
+    def inspect; end
-  def self.new(*_); end
+    def members; end
+    def new(*_); end
+  end
 end
 
 module RSpec::Matchers::DSL
-  def alias_matcher(new_name, old_name, options = _, &description_override); end
+  def alias_matcher(new_name, old_name, options = T.unsafe(nil), &description_override); end
   def define(name, &declarations); end
   def define_negated_matcher(negated_name, base_name, &description_override); end
   def matcher(name, &declarations); end
@@ -1249,9 +1300,9 @@ module RSpec::Matchers::DSL::Macros
   def diffable; end
   def failure_message(&definition); end
   def failure_message_when_negated(&definition); end
-  def match(options = _, &match_block); end
+  def match(options = T.unsafe(nil), &match_block); end
-  def match_unless_raises(expected_exception = _, &match_block); end
+  def match_unless_raises(expected_exception = T.unsafe(nil), &match_block); end
-  def match_when_negated(options = _, &match_block); end
+  def match_when_negated(options = T.unsafe(nil), &match_block); end
   def supports_block_expectations; end
 
   private
@@ -1291,14 +1342,16 @@ class RSpec::Matchers::DSL::Matcher
 
   def actual_arg_for(block); end
   def method_missing(method, *args, &block); end
-  def respond_to_missing?(method, include_private = _); end
+  def respond_to_missing?(method, include_private = T.unsafe(nil)); end
 end
 
 RSpec::Matchers::DYNAMIC_MATCHER_REGEX = T.let(T.unsafe(nil), Regexp)
 
 module RSpec::Matchers::EnglishPhrasing
-  def self.list(obj); end
+  class << self
-  def self.split_words(sym); end
+    def list(obj); end
+    def split_words(sym); end
+  end
 end
 
 class RSpec::Matchers::ExpectedsForMultipleDiffs
@@ -1310,8 +1363,15 @@ class RSpec::Matchers::ExpectedsForMultipleDiffs
 
   def diffs(differ, actual); end
 
-  def self.for_many_matchers(matchers); end
+  class << self
-  def self.from(expected); end
+    def for_many_matchers(matchers); end
+    def from(expected); end
+
+    private
+
+    def diff_label_for(matcher); end
+    def truncated(description); end
+  end
 end
 
 RSpec::Matchers::ExpectedsForMultipleDiffs::DEFAULT_DIFF_LABEL = T.let(T.unsafe(nil), String)
@@ -1331,7 +1391,7 @@ class RSpec::Matchers::MatcherDelegator
   private
 
   def initialize_copy(other); end
-  def respond_to_missing?(name, include_all = _); end
+  def respond_to_missing?(name, include_all = T.unsafe(nil)); end
 end
 
 module RSpec::Matchers::BuiltIn::BeHelpers
@@ -1346,13 +1406,17 @@ module RSpec::Matchers::BuiltIn::BeHelpers
 end
 
 module RSpec::Matchers::BuiltIn::CaptureStderr
-  def self.capture(block); end
+  class << self
-  def self.name; end
+    def capture(block); end
+    def name; end
+  end
 end
 
 module RSpec::Matchers::BuiltIn::CaptureStdout
-  def self.capture(block); end
+  class << self
-  def self.name; end
+    def capture(block); end
+    def name; end
+  end
 end
 
 class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < ::Struct
@@ -1360,7 +1424,7 @@ class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < ::Struct
 end
 
 class RSpec::Matchers::BuiltIn::ChangeDetails
-  def initialize(matcher_name, receiver = _, message = _, &block); end
+  def initialize(matcher_name, receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
 
   def actual_after; end
   def actual_delta; end
@@ -1413,8 +1477,10 @@ class RSpec::Matchers::BuiltIn::ChangeToValue < ::RSpec::Matchers::BuiltIn::Spec
 end
 
 module RSpec::Matchers::BuiltIn::NullCapture
-  def self.capture(_block); end
+  class << self
-  def self.name; end
+    def capture(_block); end
+    def name; end
+  end
 end
 
 class RSpec::Matchers::BuiltIn::ReliableMatchData
@@ -1478,5 +1544,7 @@ class RSpec::Matchers::BuiltIn::YieldProbe
   def yielded_args=(_); end
   def yielded_once?(matcher_name); end
 
-  def self.probe(block, &callback); end
+  class << self
+    def probe(block, &callback); end
+  end
 end

Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `rspec-its` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/rspec-mocks@3.9.1.rbi

@@ -1,18 +1,21 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `rspec-mocks` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 module RSpec::Mocks
-  def self.allow_message(subject, message, opts = _, &block); end
+  class << self
-  def self.configuration; end
+    def allow_message(subject, message, opts = T.unsafe(nil), &block); end
-  def self.error_generator; end
+    def configuration; end
-  def self.expect_message(subject, message, opts = _, &block); end
+    def error_generator; end
-  def self.setup; end
+    def expect_message(subject, message, opts = T.unsafe(nil), &block); end
-  def self.space; end
+    def setup; end
-  def self.teardown; end
+    def space; end
-  def self.verify; end
+    def teardown; end
-  def self.with_temporary_scope; end
+    def verify; end
+    def with_temporary_scope; end
+  end
 end
 
 class RSpec::Mocks::AllowanceTarget < ::RSpec::Mocks::TargetBase
@@ -53,7 +56,9 @@ class RSpec::Mocks::AndYieldImplementation
 end
 
 module RSpec::Mocks::AnyInstance
-  def self.error_generator; end
+  class << self
+    def error_generator; end
+  end
 end
 
 class RSpec::Mocks::AnyInstance::Chain
@@ -94,7 +99,9 @@ module RSpec::Mocks::AnyInstance::Chain::Customizations
   def twice(*args, &block); end
   def with(*args, &block); end
 
-  def self.record(method_name); end
+  class << self
+    def record(method_name); end
+  end
 end
 
 class RSpec::Mocks::AnyInstance::ErrorGenerator < ::RSpec::Mocks::ErrorGenerator
@@ -133,7 +140,7 @@ class RSpec::Mocks::AnyInstance::FluentInterfaceProxy
 
   private
 
-  def respond_to_missing?(method_name, include_private = _); end
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
 end
 
 class RSpec::Mocks::AnyInstance::MessageChains
@@ -289,7 +296,9 @@ module RSpec::Mocks::ArgumentMatchers
   def kind_of(klass); end
   def no_args; end
 
-  def self.anythingize_lonely_keys(*args); end
+  class << self
+    def anythingize_lonely_keys(*args); end
+  end
 end
 
 class RSpec::Mocks::ArgumentMatchers::AnyArgMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher
@@ -372,7 +381,9 @@ end
 RSpec::Mocks::ArgumentMatchers::NoArgsMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::NoArgsMatcher)
 
 class RSpec::Mocks::ArgumentMatchers::SingletonMatcher
-  def self.inherited(subklass); end
+  class << self
+    def inherited(subklass); end
+  end
 end
 
 class RSpec::Mocks::CallbackInvocationStrategy
@@ -385,7 +396,9 @@ end
 class RSpec::Mocks::ClassNewMethodReference < ::RSpec::Mocks::ObjectMethodReference
   def with_signature; end
 
-  def self.applies_to?(method_name); end
+  class << self
+    def applies_to?(method_name); end
+  end
 end
 
 class RSpec::Mocks::ClassVerifyingDouble < ::Module
@@ -440,17 +453,21 @@ class RSpec::Mocks::Constant
   def valid_name=(_); end
   def valid_name?; end
 
-  def self.original(name); end
+  class << self
-  def self.unmutated(name); end
+    def original(name); end
+    def unmutated(name); end
+  end
 end
 
 class RSpec::Mocks::ConstantMutator
   extend(::RSpec::Support::RecursiveConstMethods)
 
-  def self.hide(constant_name); end
+  class << self
-  def self.mutate(mutator); end
+    def hide(constant_name); end
-  def self.raise_on_invalid_const; end
+    def mutate(mutator); end
-  def self.stub(constant_name, value, options = _); end
+    def raise_on_invalid_const; end
+    def stub(constant_name, value, options = T.unsafe(nil)); end
+  end
 end
 
 class RSpec::Mocks::ConstantMutator::BaseMutator
@@ -508,19 +525,19 @@ class RSpec::Mocks::Double
 end
 
 class RSpec::Mocks::ErrorGenerator
-  def initialize(target = _); end
+  def initialize(target = T.unsafe(nil)); end
 
   def default_error_message(expectation, expected_args, actual_args); end
   def describe_expectation(verb, message, expected_received_count, _actual_received_count, args); end
   def expectation_on_nil_message(method_name); end
-  def intro(unwrapped = _); end
+  def intro(unwrapped = T.unsafe(nil)); end
-  def method_call_args_description(args, generic_prefix = _, matcher_prefix = _); end
+  def method_call_args_description(args, generic_prefix = T.unsafe(nil), matcher_prefix = T.unsafe(nil)); end
   def opts; end
   def opts=(_); end
   def raise_already_invoked_error(message, calling_customization); end
   def raise_cant_constrain_count_for_negated_have_received_error(count_constraint); end
   def raise_double_negation_error(wrapped_expression); end
-  def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, args, backtrace_line = _, source_id = _); end
+  def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, args, backtrace_line = T.unsafe(nil), source_id = T.unsafe(nil)); end
   def raise_expectation_on_mocked_method(method); end
   def raise_expectation_on_nil_error(method_name); end
   def raise_expectation_on_unstubbed_method(method); end
@@ -533,8 +550,8 @@ class RSpec::Mocks::ErrorGenerator
   def raise_non_public_error(method_name, visibility); end
   def raise_only_valid_on_a_partial_double(method); end
   def raise_out_of_order_error(message); end
-  def raise_similar_message_args_error(expectation, args_for_multiple_calls, backtrace_line = _); end
+  def raise_similar_message_args_error(expectation, args_for_multiple_calls, backtrace_line = T.unsafe(nil)); end
-  def raise_unexpected_message_args_error(expectation, args_for_multiple_calls, source_id = _); end
+  def raise_unexpected_message_args_error(expectation, args_for_multiple_calls, source_id = T.unsafe(nil)); end
   def raise_unexpected_message_error(message, args); end
   def raise_unimplemented_error(doubled_module, method_name, object); end
   def raise_verifying_double_not_defined_error(ref); end
@@ -542,9 +559,9 @@ class RSpec::Mocks::ErrorGenerator
 
   private
 
-  def __raise(message, backtrace_line = _, source_id = _); end
+  def __raise(message, backtrace_line = T.unsafe(nil), source_id = T.unsafe(nil)); end
   def arg_list(args); end
-  def count_message(count, expectation_count_type = _); end
+  def count_message(count, expectation_count_type = T.unsafe(nil)); end
   def diff_message(expected_args, actual_args); end
   def differ; end
   def error_message(expectation, args_for_multiple_calls); end
@@ -584,13 +601,15 @@ module RSpec::Mocks::ExampleMethods
   def receive_message_chain(*messages, &block); end
   def receive_messages(message_return_value_hash); end
   def spy(*args); end
-  def stub_const(constant_name, value, options = _); end
+  def stub_const(constant_name, value, options = T.unsafe(nil)); end
   def without_partial_double_verification; end
 
-  def self.declare_double(type, *args); end
+  class << self
-  def self.declare_verifying_double(type, ref, *args); end
+    def declare_double(type, *args); end
-  def self.extended(object); end
+    def declare_verifying_double(type, ref, *args); end
-  def self.included(klass); end
+    def extended(object); end
+    def included(klass); end
+  end
 end
 
 module RSpec::Mocks::ExampleMethods::ExpectHost
@@ -603,7 +622,9 @@ class RSpec::Mocks::ExpectChain < ::RSpec::Mocks::MessageChain
 
   def expectation(object, message, &return_block); end
 
-  def self.expect_chain_on(object, *chain, &blk); end
+  class << self
+    def expect_chain_on(object, *chain, &blk); end
+  end
 end
 
 class RSpec::Mocks::ExpectationTarget < ::RSpec::Mocks::TargetBase
@@ -662,7 +683,7 @@ class RSpec::Mocks::InstanceMethodStasher
   private
 
   def method_defined_directly_on_klass?; end
-  def method_defined_on_klass?(klass = _); end
+  def method_defined_on_klass?(klass = T.unsafe(nil)); end
   def method_owned_by_klass?; end
 end
 
@@ -674,8 +695,10 @@ class RSpec::Mocks::InstanceVerifyingDouble
 end
 
 class RSpec::Mocks::MarshalExtension
-  def self.patch!; end
+  class << self
-  def self.unpatch!; end
+    def patch!; end
+    def unpatch!; end
+  end
 end
 
 module RSpec::Mocks::Matchers
@@ -714,7 +737,7 @@ class RSpec::Mocks::Matchers::HaveReceived
   def apply_constraints_to(expectation); end
   def capture_failure_message; end
   def count_constraint; end
-  def disallow(type, reason = _); end
+  def disallow(type, reason = T.unsafe(nil)); end
   def ensure_count_unconstrained; end
   def expect; end
   def expected_messages_received_in_order?; end
@@ -855,7 +878,7 @@ class RSpec::Mocks::MessageExpectation
 end
 
 module RSpec::Mocks::MessageExpectation::ImplementationDetails
-  def initialize(error_generator, expectation_ordering, expected_from, method_double, type = _, opts = _, &implementation_block); end
+  def initialize(error_generator, expectation_ordering, expected_from, method_double, type = T.unsafe(nil), opts = T.unsafe(nil), &implementation_block); end
 
   def actual_received_count_matters?; end
   def additional_expected_calls; end
@@ -922,7 +945,7 @@ class RSpec::Mocks::MethodDouble
   def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation); end
   def add_simple_expectation(method_name, response, error_generator, backtrace_line); end
   def add_simple_stub(method_name, response); end
-  def add_stub(error_generator, expectation_ordering, expected_from, opts = _, &implementation); end
+  def add_stub(error_generator, expectation_ordering, expected_from, opts = T.unsafe(nil), &implementation); end
   def build_expectation(error_generator, expectation_ordering); end
   def clear; end
   def configure_method; end
@@ -943,7 +966,7 @@ class RSpec::Mocks::MethodDouble
   def restore_original_method; end
   def restore_original_visibility; end
   def save_original_implementation_callable!; end
-  def setup_simple_method_double(method_name, response, collection, error_generator = _, backtrace_line = _); end
+  def setup_simple_method_double(method_name, response, collection, error_generator = T.unsafe(nil), backtrace_line = T.unsafe(nil)); end
   def show_frozen_warning; end
   def stubs; end
   def verify; end
@@ -973,10 +996,12 @@ class RSpec::Mocks::MethodReference
 
   def original_method; end
 
-  def self.for(object_reference, method_name); end
+  class << self
-  def self.instance_method_visibility_for(klass, method_name); end
+    def for(object_reference, method_name); end
-  def self.method_defined_at_any_visibility?(klass, method_name); end
+    def instance_method_visibility_for(klass, method_name); end
-  def self.method_visibility_for(object, method_name); end
+    def method_defined_at_any_visibility?(klass, method_name); end
+    def method_visibility_for(object, method_name); end
+  end
 end
 
 class RSpec::Mocks::MockExpectationAlreadyInvokedError < ::Exception
@@ -1028,11 +1053,20 @@ class RSpec::Mocks::ObjectMethodReference < ::RSpec::Mocks::MethodReference
   def method_implemented?(object); end
   def visibility_from(object); end
 
-  def self.for(object_reference, method_name); end
+  class << self
+    def for(object_reference, method_name); end
+  end
 end
 
 class RSpec::Mocks::ObjectReference
-  def self.for(object_module_or_name, allow_direct_object_refs = _); end
+  class << self
+    def for(object_module_or_name, allow_direct_object_refs = T.unsafe(nil)); end
+
+    private
+
+    def anonymous_module?(mod); end
+    def name_of(mod); end
+  end
 end
 
 RSpec::Mocks::ObjectReference::MODULE_NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod)
@@ -1047,7 +1081,7 @@ module RSpec::Mocks::ObjectVerifyingDoubleMethods
   include(::RSpec::Mocks::TestDouble)
   include(::RSpec::Mocks::VerifyingDouble)
 
-  def as_stubbed_const(options = _); end
+  def as_stubbed_const(options = T.unsafe(nil)); end
 
   private
 
@@ -1108,12 +1142,12 @@ class RSpec::Mocks::PartialDoubleProxy < ::RSpec::Mocks::Proxy
 end
 
 class RSpec::Mocks::Proxy
-  def initialize(object, order_group, options = _); end
+  def initialize(object, order_group, options = T.unsafe(nil)); end
 
-  def add_message_expectation(method_name, opts = _, &block); end
+  def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end
   def add_simple_expectation(method_name, response, location); end
   def add_simple_stub(method_name, response); end
-  def add_stub(method_name, opts = _, &implementation); end
+  def add_stub(method_name, opts = T.unsafe(nil), &implementation); end
   def as_null_object; end
   def build_expectation(method_name); end
   def check_for_unexpected_arguments(expectation); end
@@ -1146,7 +1180,9 @@ class RSpec::Mocks::Proxy
   def find_matching_method_stub(method_name, *args); end
   def method_double_for(message); end
 
-  def self.prepended_modules_of(klass); end
+  class << self
+    def prepended_modules_of(klass); end
+  end
 end
 
 RSpec::Mocks::Proxy::DEFAULT_MESSAGE_EXPECTATION_OPTS = T.let(T.unsafe(nil), Hash)
@@ -1160,17 +1196,19 @@ class RSpec::Mocks::Proxy::SpecificMessage < ::Struct
   def object; end
   def object=(_); end
 
-  def self.[](*_); end
+  class << self
-  def self.inspect; end
+    def [](*_); end
-  def self.members; end
+    def inspect; end
-  def self.new(*_); end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Mocks::ProxyForNil < ::RSpec::Mocks::PartialDoubleProxy
   def initialize(order_group); end
 
-  def add_message_expectation(method_name, opts = _, &block); end
+  def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end
-  def add_stub(method_name, opts = _, &implementation); end
+  def add_stub(method_name, opts = T.unsafe(nil), &implementation); end
   def disallow_expectations; end
   def disallow_expectations=(_); end
   def warn_about_expectations; end
@@ -1202,7 +1240,7 @@ class RSpec::Mocks::RootSpace
 end
 
 class RSpec::Mocks::SimpleMessageExpectation
-  def initialize(message, response, error_generator, backtrace_line = _); end
+  def initialize(message, response, error_generator, backtrace_line = T.unsafe(nil)); end
 
   def called_max_times?; end
   def invoke(*_); end
@@ -1216,7 +1254,7 @@ class RSpec::Mocks::Space
 
   def any_instance_mutex; end
   def any_instance_proxy_for(klass); end
-  def any_instance_recorder_for(klass, only_return_existing = _); end
+  def any_instance_recorder_for(klass, only_return_existing = T.unsafe(nil)); end
   def any_instance_recorders; end
   def any_instance_recorders_from_ancestry_of(object); end
   def constant_mutator_for(name); end
@@ -1248,19 +1286,23 @@ class RSpec::Mocks::StubChain < ::RSpec::Mocks::MessageChain
 
   def expectation(object, message, &return_block); end
 
-  def self.stub_chain_on(object, *chain, &blk); end
+  class << self
+    def stub_chain_on(object, *chain, &blk); end
+  end
 end
 
 module RSpec::Mocks::Syntax
-  def self.default_should_syntax_host; end
+  class << self
-  def self.disable_expect(syntax_host = _); end
+    def default_should_syntax_host; end
-  def self.disable_should(syntax_host = _); end
+    def disable_expect(syntax_host = T.unsafe(nil)); end
-  def self.enable_expect(syntax_host = _); end
+    def disable_should(syntax_host = T.unsafe(nil)); end
-  def self.enable_should(syntax_host = _); end
+    def enable_expect(syntax_host = T.unsafe(nil)); end
-  def self.expect_enabled?(syntax_host = _); end
+    def enable_should(syntax_host = T.unsafe(nil)); end
-  def self.should_enabled?(syntax_host = _); end
+    def expect_enabled?(syntax_host = T.unsafe(nil)); end
-  def self.warn_about_should!; end
+    def should_enabled?(syntax_host = T.unsafe(nil)); end
-  def self.warn_unless_should_configured(method_name, replacement = _); end
+    def warn_about_should!; end
+    def warn_unless_should_configured(method_name, replacement = T.unsafe(nil)); end
+  end
 end
 
 class RSpec::Mocks::TargetBase
@@ -1271,7 +1313,7 @@ class RSpec::Mocks::TargetBase
 end
 
 module RSpec::Mocks::TargetDelegationClassMethods
-  def delegate_not_to(matcher_method, options = _); end
+  def delegate_not_to(matcher_method, options = T.unsafe(nil)); end
   def delegate_to(matcher_method); end
   def disallow_negation(method_name); end
 end
@@ -1288,7 +1330,7 @@ module RSpec::Mocks::TargetDelegationInstanceMethods
 end
 
 module RSpec::Mocks::TestDouble
-  def initialize(name = _, stubs = _); end
+  def initialize(name = T.unsafe(nil), stubs = T.unsafe(nil)); end
 
   def ==(other); end
   def __build_mock_proxy_unless_expired(order_group); end
@@ -1297,7 +1339,7 @@ module RSpec::Mocks::TestDouble
   def freeze; end
   def inspect; end
   def null_object?; end
-  def respond_to?(message, incl_private = _); end
+  def respond_to?(message, incl_private = T.unsafe(nil)); end
   def to_s; end
 
   private
@@ -1311,7 +1353,15 @@ module RSpec::Mocks::TestDouble
 end
 
 module RSpec::Mocks::TestDoubleFormatter
-  def self.format(dbl, unwrap = _); end
+  class << self
+    def format(dbl, unwrap = T.unsafe(nil)); end
+
+    private
+
+    def name_desc(dbl); end
+    def type_desc(dbl); end
+    def verified_module_desc(dbl); end
+  end
 end
 
 class RSpec::Mocks::TestDoubleProxy < ::RSpec::Mocks::Proxy
@@ -1326,13 +1376,15 @@ module RSpec::Mocks::VerifyingDouble
 
   def __send__(name, *args, &block); end
   def method_missing(message, *args, &block); end
-  def respond_to?(message, include_private = _); end
+  def respond_to?(message, include_private = T.unsafe(nil)); end
   def send(name, *args, &block); end
 end
 
 module RSpec::Mocks::VerifyingDouble::SilentIO
-  def self.method_missing(*_); end
+  class << self
-  def self.respond_to?(*_); end
+    def method_missing(*_); end
+    def respond_to?(*_); end
+  end
 end
 
 class RSpec::Mocks::VerifyingDoubleNotDefinedError < ::StandardError
@@ -1348,7 +1400,9 @@ class RSpec::Mocks::VerifyingExistingMethodDouble < ::RSpec::Mocks::VerifyingMet
   def unimplemented?; end
   def with_signature; end
 
-  def self.for(object, method_name, proxy); end
+  class << self
+    def for(object, method_name, proxy); end
+  end
 end
 
 class RSpec::Mocks::VerifyingMessageExpectation < ::RSpec::Mocks::MessageExpectation
@@ -1380,7 +1434,7 @@ end
 class RSpec::Mocks::VerifyingPartialDoubleProxy < ::RSpec::Mocks::PartialDoubleProxy
   include(::RSpec::Mocks::VerifyingProxyMethods)
 
-  def initialize(object, expectation_ordering, optional_callback_invocation_strategy = _); end
+  def initialize(object, expectation_ordering, optional_callback_invocation_strategy = T.unsafe(nil)); end
 
   def ensure_implemented(_method_name); end
   def method_reference; end
@@ -1397,9 +1451,9 @@ class RSpec::Mocks::VerifyingProxy < ::RSpec::Mocks::TestDoubleProxy
 end
 
 module RSpec::Mocks::VerifyingProxyMethods
-  def add_message_expectation(method_name, opts = _, &block); end
+  def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end
   def add_simple_stub(method_name, *args); end
-  def add_stub(method_name, opts = _, &implementation); end
+  def add_stub(method_name, opts = T.unsafe(nil), &implementation); end
   def ensure_implemented(method_name); end
   def ensure_publicly_implemented(method_name, _object); end
 end

Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `rspec-retry` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/rspec-support@3.9.3.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `rspec-support` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -7,30 +8,34 @@ module RSpec
   extend(::RSpec::Support::Warnings)
   extend(::RSpec::Core::Warnings)
 
-  def self.clear_examples; end
+  class << self
-  def self.configuration; end
+    def clear_examples; end
-  def self.configuration=(_); end
+    def configuration; end
-  def self.configure; end
+    def configuration=(_); end
-  def self.const_missing(name); end
+    def configure; end
-  def self.context(*args, &example_group_block); end
+    def const_missing(name); end
-  def self.current_example; end
+    def context(*args, &example_group_block); end
-  def self.current_example=(example); end
+    def current_example; end
-  def self.describe(*args, &example_group_block); end
+    def current_example=(example); end
-  def self.example_group(*args, &example_group_block); end
+    def describe(*args, &example_group_block); end
-  def self.fcontext(*args, &example_group_block); end
+    def example_group(*args, &example_group_block); end
-  def self.fdescribe(*args, &example_group_block); end
+    def fcontext(*args, &example_group_block); end
-  def self.reset; end
+    def fdescribe(*args, &example_group_block); end
-  def self.shared_context(name, *args, &block); end
+    def reset; end
-  def self.shared_examples(name, *args, &block); end
+    def shared_context(name, *args, &block); end
-  def self.shared_examples_for(name, *args, &block); end
+    def shared_examples(name, *args, &block); end
-  def self.world; end
+    def shared_examples_for(name, *args, &block); end
-  def self.world=(_); end
+    def world; end
-  def self.xcontext(*args, &example_group_block); end
+    def world=(_); end
-  def self.xdescribe(*args, &example_group_block); end
+    def xcontext(*args, &example_group_block); end
+    def xdescribe(*args, &example_group_block); end
+  end
 end
 
 class RSpec::CallerFilter
-  def self.first_non_rspec_line(skip_frames = _, increment = _); end
+  class << self
+    def first_non_rspec_line(skip_frames = T.unsafe(nil), increment = T.unsafe(nil)); end
+  end
 end
 
 RSpec::CallerFilter::ADDITIONAL_TOP_LEVEL_FILES = T.let(T.unsafe(nil), Array)
@@ -46,30 +51,34 @@ RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
 RSpec::SharedContext = RSpec::Core::SharedContext
 
 module RSpec::Support
-  def self.class_of(object); end
+  class << self
-  def self.define_optimized_require_for_rspec(lib, &require_relative); end
+    def class_of(object); end
-  def self.deregister_matcher_definition(&block); end
+    def define_optimized_require_for_rspec(lib, &require_relative); end
-  def self.failure_notifier; end
+    def deregister_matcher_definition(&block); end
-  def self.failure_notifier=(callable); end
+    def failure_notifier; end
-  def self.is_a_matcher?(object); end
+    def failure_notifier=(callable); end
-  def self.matcher_definitions; end
+    def is_a_matcher?(object); end
-  def self.method_handle_for(object, method_name); end
+    def matcher_definitions; end
-  def self.notify_failure(failure, options = _); end
+    def method_handle_for(object, method_name); end
-  def self.register_matcher_definition(&block); end
+    def notify_failure(failure, options = T.unsafe(nil)); end
-  def self.require_rspec_core(f); end
+    def register_matcher_definition(&block); end
-  def self.require_rspec_expectations(f); end
+    def require_rspec_core(f); end
-  def self.require_rspec_matchers(f); end
+    def require_rspec_expectations(f); end
-  def self.require_rspec_mocks(f); end
+    def require_rspec_matchers(f); end
-  def self.require_rspec_support(f); end
+    def require_rspec_mocks(f); end
-  def self.rspec_description_for_object(object); end
+    def require_rspec_support(f); end
-  def self.thread_local_data; end
+    def rspec_description_for_object(object); end
-  def self.warning_notifier; end
+    def thread_local_data; end
-  def self.warning_notifier=(_); end
+    def warning_notifier; end
-  def self.with_failure_notifier(callable); end
+    def warning_notifier=(_); end
+    def with_failure_notifier(callable); end
+  end
 end
 
 module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
-  def self.===(exception); end
+  class << self
+    def ===(exception); end
+  end
 end
 
 RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue::AVOID_RESCUING = T.let(T.unsafe(nil), Array)
@@ -93,7 +102,7 @@ RSpec::Support::DEFAULT_FAILURE_NOTIFIER = T.let(T.unsafe(nil), Proc)
 RSpec::Support::DEFAULT_WARNING_NOTIFIER = T.let(T.unsafe(nil), Proc)
 
 class RSpec::Support::Differ
-  def initialize(opts = _); end
+  def initialize(opts = T.unsafe(nil)); end
 
   def color?; end
   def diff(actual, expected); end
@@ -127,11 +136,19 @@ class RSpec::Support::Differ
 end
 
 class RSpec::Support::DirectoryMaker
-  def self.mkdir_p(path); end
+  class << self
+    def mkdir_p(path); end
+
+    private
+
+    def directory_exists?(dirname); end
+    def generate_path(stack, part); end
+    def generate_stack(path); end
+  end
 end
 
 class RSpec::Support::EncodedString
-  def initialize(string, encoding = _); end
+  def initialize(string, encoding = T.unsafe(nil)); end
 
   def <<(string); end
   def ==(*args, &block); end
@@ -150,7 +167,9 @@ class RSpec::Support::EncodedString
   def matching_encoding(string); end
   def remove_invalid_bytes(string); end
 
-  def self.pick_encoding(source_a, source_b); end
+  class << self
+    def pick_encoding(source_a, source_b); end
+  end
 end
 
 RSpec::Support::EncodedString::REPLACE = T.let(T.unsafe(nil), String)
@@ -160,7 +179,14 @@ RSpec::Support::EncodedString::US_ASCII = T.let(T.unsafe(nil), String)
 RSpec::Support::EncodedString::UTF_8 = T.let(T.unsafe(nil), String)
 
 module RSpec::Support::FuzzyMatcher
-  def self.values_match?(expected, actual); end
+  class << self
+    def values_match?(expected, actual); end
+
+    private
+
+    def arrays_match?(expected_list, actual_list); end
+    def hashes_match?(expected_hash, actual_hash); end
+  end
 end
 
 RSpec::Support::KERNEL_METHOD_METHOD = T.let(T.unsafe(nil), UnboundMethod)
@@ -186,7 +212,7 @@ class RSpec::Support::MethodSignature
   def initialize(method); end
 
   def arbitrary_kw_args?; end
-  def classify_arity(arity = _); end
+  def classify_arity(arity = T.unsafe(nil)); end
   def classify_parameters; end
   def could_contain_kw_args?(args); end
   def description; end
@@ -199,7 +225,7 @@ class RSpec::Support::MethodSignature
   def optional_kw_args; end
   def required_kw_args; end
   def unlimited_args?; end
-  def valid_non_kw_args?(positional_arg_count, optional_max_arg_count = _); end
+  def valid_non_kw_args?(positional_arg_count, optional_max_arg_count = T.unsafe(nil)); end
 end
 
 RSpec::Support::MethodSignature::INFINITY = T.let(T.unsafe(nil), Float)
@@ -221,7 +247,7 @@ class RSpec::Support::MethodSignatureExpectation
 end
 
 class RSpec::Support::MethodSignatureVerifier
-  def initialize(signature, args = _); end
+  def initialize(signature, args = T.unsafe(nil)); end
 
   def error_message; end
   def kw_args; end
@@ -242,7 +268,9 @@ class RSpec::Support::MethodSignatureVerifier
 end
 
 class RSpec::Support::Mutex < ::Thread::Mutex
-  def self.new; end
+  class << self
+    def new; end
+  end
 end
 
 RSpec::Support::Mutex::NEW_MUTEX_METHOD = T.let(T.unsafe(nil), Method)
@@ -254,12 +282,14 @@ module RSpec::Support::OS
   def windows?; end
   def windows_file_path?; end
 
-  def self.windows?; end
+  class << self
-  def self.windows_file_path?; end
+    def windows?; end
+    def windows_file_path?; end
+  end
 end
 
 class RSpec::Support::ObjectFormatter
-  def initialize(max_formatted_output_length = _); end
+  def initialize(max_formatted_output_length = T.unsafe(nil)); end
 
   def format(object); end
   def max_formatted_output_length; end
@@ -276,9 +306,11 @@ class RSpec::Support::ObjectFormatter
 
   def truncate_string(str, start_index, end_index); end
 
-  def self.default_instance; end
+  class << self
-  def self.format(object); end
+    def default_instance; end
-  def self.prepare_for_inspection(object); end
+    def format(object); end
+    def prepare_for_inspection(object); end
+  end
 end
 
 class RSpec::Support::ObjectFormatter::BaseInspector < ::Struct
@@ -289,23 +321,29 @@ class RSpec::Support::ObjectFormatter::BaseInspector < ::Struct
   def object=(_); end
   def pretty_print(pp); end
 
-  def self.[](*_); end
+  class << self
-  def self.can_inspect?(_object); end
+    def [](*_); end
-  def self.inspect; end
+    def can_inspect?(_object); end
-  def self.members; end
+    def inspect; end
-  def self.new(*_); end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Support::ObjectFormatter::BigDecimalInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
   def inspect; end
 
-  def self.can_inspect?(object); end
+  class << self
+    def can_inspect?(object); end
+  end
 end
 
 class RSpec::Support::ObjectFormatter::DateTimeInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
   def inspect; end
 
-  def self.can_inspect?(object); end
+  class << self
+    def can_inspect?(object); end
+  end
 end
 
 RSpec::Support::ObjectFormatter::DateTimeInspector::FORMAT = T.let(T.unsafe(nil), String)
@@ -313,13 +351,17 @@ RSpec::Support::ObjectFormatter::DateTimeInspector::FORMAT = T.let(T.unsafe(nil)
 class RSpec::Support::ObjectFormatter::DelegatorInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
   def inspect; end
 
-  def self.can_inspect?(object); end
+  class << self
+    def can_inspect?(object); end
+  end
 end
 
 class RSpec::Support::ObjectFormatter::DescribableMatcherInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
   def inspect; end
 
-  def self.can_inspect?(object); end
+  class << self
+    def can_inspect?(object); end
+  end
 end
 
 RSpec::Support::ObjectFormatter::ELLIPSIS = T.let(T.unsafe(nil), String)
@@ -332,22 +374,28 @@ class RSpec::Support::ObjectFormatter::InspectableItem < ::Struct
   def text; end
   def text=(_); end
 
-  def self.[](*_); end
+  class << self
-  def self.inspect; end
+    def [](*_); end
-  def self.members; end
+    def inspect; end
-  def self.new(*_); end
+    def members; end
+    def new(*_); end
+  end
 end
 
 class RSpec::Support::ObjectFormatter::InspectableObjectInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
   def inspect; end
 
-  def self.can_inspect?(object); end
+  class << self
+    def can_inspect?(object); end
+  end
 end
 
 class RSpec::Support::ObjectFormatter::TimeInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
   def inspect; end
 
-  def self.can_inspect?(object); end
+  class << self
+    def can_inspect?(object); end
+  end
 end
 
 RSpec::Support::ObjectFormatter::TimeInspector::FORMAT = T.let(T.unsafe(nil), String)
@@ -357,7 +405,9 @@ class RSpec::Support::ObjectFormatter::UninspectableObjectInspector < ::RSpec::S
   def klass; end
   def native_object_id; end
 
-  def self.can_inspect?(object); end
+  class << self
+    def can_inspect?(object); end
+  end
 end
 
 RSpec::Support::ObjectFormatter::UninspectableObjectInspector::OBJECT_ID_FORMAT = T.let(T.unsafe(nil), String)
@@ -394,13 +444,15 @@ module RSpec::Support::Ruby
   def rbx?; end
   def truffleruby?; end
 
-  def self.jruby?; end
+  class << self
-  def self.jruby_9000?; end
+    def jruby?; end
-  def self.jruby_version; end
+    def jruby_9000?; end
-  def self.mri?; end
+    def jruby_version; end
-  def self.non_mri?; end
+    def mri?; end
-  def self.rbx?; end
+    def non_mri?; end
-  def self.truffleruby?; end
+    def rbx?; end
+    def truffleruby?; end
+  end
 end
 
 module RSpec::Support::RubyFeatures
@@ -419,17 +471,19 @@ module RSpec::Support::RubyFeatures
   def supports_rebinding_module_methods?; end
   def supports_taint?; end
 
-  def self.caller_locations_supported?; end
+  class << self
-  def self.fork_supported?; end
+    def caller_locations_supported?; end
-  def self.kw_args_supported?; end
+    def fork_supported?; end
-  def self.module_prepends_supported?; end
+    def kw_args_supported?; end
-  def self.module_refinement_supported?; end
+    def module_prepends_supported?; end
-  def self.optional_and_splat_args_supported?; end
+    def module_refinement_supported?; end
-  def self.required_kw_args_supported?; end
+    def optional_and_splat_args_supported?; end
-  def self.ripper_supported?; end
+    def required_kw_args_supported?; end
-  def self.supports_exception_cause?; end
+    def ripper_supported?; end
-  def self.supports_rebinding_module_methods?; end
+    def supports_exception_cause?; end
-  def self.supports_taint?; end
+    def supports_rebinding_module_methods?; end
+    def supports_taint?; end
+  end
 end
 
 RSpec::Support::StrictSignatureVerifier = RSpec::Support::MethodSignatureVerifier
@@ -440,10 +494,10 @@ end
 RSpec::Support::Version::STRING = T.let(T.unsafe(nil), String)
 
 module RSpec::Support::Warnings
-  def deprecate(deprecated, options = _); end
+  def deprecate(deprecated, options = T.unsafe(nil)); end
-  def warn_deprecation(message, options = _); end
+  def warn_deprecation(message, options = T.unsafe(nil)); end
-  def warn_with(message, options = _); end
+  def warn_with(message, options = T.unsafe(nil)); end
-  def warning(text, options = _); end
+  def warning(text, options = T.unsafe(nil)); end
 end
 
 module RSpec::Support::WithKeywordsWhenNeeded
@@ -452,7 +506,9 @@ module RSpec::Support::WithKeywordsWhenNeeded
 
   def class_exec(klass, *args, &block); end
 
-  def self.class_exec(klass, *args, &block); end
+  class << self
+    def class_exec(klass, *args, &block); end
+  end
 end
 
 class RSpec::Support::HunkGenerator

Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `rspec-wait` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/rspec@3.9.0.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `rspec` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -7,26 +8,28 @@ module RSpec
   extend(::RSpec::Support::Warnings)
   extend(::RSpec::Core::Warnings)
 
-  def self.clear_examples; end
+  class << self
-  def self.configuration; end
+    def clear_examples; end
-  def self.configuration=(_); end
+    def configuration; end
-  def self.configure; end
+    def configuration=(_); end
-  def self.const_missing(name); end
+    def configure; end
-  def self.context(*args, &example_group_block); end
+    def const_missing(name); end
-  def self.current_example; end
+    def context(*args, &example_group_block); end
-  def self.current_example=(example); end
+    def current_example; end
-  def self.describe(*args, &example_group_block); end
+    def current_example=(example); end
-  def self.example_group(*args, &example_group_block); end
+    def describe(*args, &example_group_block); end
-  def self.fcontext(*args, &example_group_block); end
+    def example_group(*args, &example_group_block); end
-  def self.fdescribe(*args, &example_group_block); end
+    def fcontext(*args, &example_group_block); end
-  def self.reset; end
+    def fdescribe(*args, &example_group_block); end
-  def self.shared_context(name, *args, &block); end
+    def reset; end
-  def self.shared_examples(name, *args, &block); end
+    def shared_context(name, *args, &block); end
-  def self.shared_examples_for(name, *args, &block); end
+    def shared_examples(name, *args, &block); end
-  def self.world; end
+    def shared_examples_for(name, *args, &block); end
-  def self.world=(_); end
+    def world; end
-  def self.xcontext(*args, &example_group_block); end
+    def world=(_); end
-  def self.xdescribe(*args, &example_group_block); end
+    def xcontext(*args, &example_group_block); end
+    def xdescribe(*args, &example_group_block); end
+  end
 end
 
 RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)

Library/Homebrew/sorbet/rbi/gems/rubocop-ast@0.3.0.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync --exclude json
+# This is an autogenerated file for types exported from the `rubocop-ast` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -31,7 +32,7 @@ end
 class RuboCop::AST::ArrayNode < ::RuboCop::AST::Node
   def bracketed?; end
   def each_value(&block); end
-  def percent_literal?(type = _); end
+  def percent_literal?(type = T.unsafe(nil)); end
   def square_brackets?; end
   def values; end
 end
@@ -70,11 +71,8 @@ end
 RuboCop::AST::BlockNode::VOID_CONTEXT_METHODS = T.let(T.unsafe(nil), Array)
 
 class RuboCop::AST::BreakNode < ::RuboCop::AST::Node
-  include(::RuboCop::AST::MethodIdentifierPredicates)
-  include(::RuboCop::AST::MethodDispatchNode)
   include(::RuboCop::AST::ParameterizedNode)
-
+  include(::RuboCop::AST::ParameterizedNode::WrappedArguments)
-  def arguments; end
 end
 
 class RuboCop::AST::Builder < ::Parser::Builders::Default
@@ -91,7 +89,7 @@ RuboCop::AST::Builder::NODE_MAP = T.let(T.unsafe(nil), Hash)
 class RuboCop::AST::CaseMatchNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::ConditionalNode)
 
-  def each_in_pattern; end
+  def each_in_pattern(&block); end
   def else?; end
   def else_branch; end
   def in_pattern_branches; end
@@ -101,7 +99,8 @@ end
 class RuboCop::AST::CaseNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::ConditionalNode)
 
-  def each_when; end
+  def branches; end
+  def each_when(&block); end
   def else?; end
   def else_branch; end
   def keyword; end
@@ -274,6 +273,7 @@ class RuboCop::AST::DefinedNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::MethodIdentifierPredicates)
   include(::RuboCop::AST::MethodDispatchNode)
 
+  def arguments; end
   def node_parts; end
 end
 
@@ -281,7 +281,15 @@ class RuboCop::AST::EnsureNode < ::RuboCop::AST::Node
   def body; end
 end
 
+module RuboCop::AST::Ext
+end
+
+module RuboCop::AST::Ext::Range
+  def line_span(exclude_end: T.unsafe(nil)); end
+end
+
 class RuboCop::AST::FloatNode < ::RuboCop::AST::Node
+  include(::RuboCop::AST::BasicLiteralNode)
   include(::RuboCop::AST::NumericNode)
 end
 
@@ -303,7 +311,7 @@ end
 module RuboCop::AST::HashElementNode
   def delimiter_delta(other); end
   def key; end
-  def key_delta(other, alignment = _); end
+  def key_delta(other, alignment = T.unsafe(nil)); end
   def same_line?(other); end
   def value; end
   def value_delta(other); end
@@ -311,9 +319,9 @@ end
 
 class RuboCop::AST::HashNode < ::RuboCop::AST::Node
   def braces?; end
-  def each_key; end
+  def each_key(&block); end
   def each_pair; end
-  def each_value; end
+  def each_value(&block); end
   def empty?; end
   def keys; end
   def mixed_delimiters?; end
@@ -327,7 +335,7 @@ class RuboCop::AST::IfNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::ModifierNode)
 
   def branches; end
-  def each_branch; end
+  def each_branch(&block); end
   def else?; end
   def else_branch; end
   def elsif?; end
@@ -345,27 +353,36 @@ end
 
 class RuboCop::AST::IndexNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::ParameterizedNode)
+  include(::RuboCop::AST::ParameterizedNode::RestArguments)
   include(::RuboCop::AST::MethodIdentifierPredicates)
   include(::RuboCop::AST::MethodDispatchNode)
 
-  def arguments; end
   def assignment_method?; end
   def attribute_accessor?; end
   def method_name; end
+
+  private
+
+  def first_argument_index; end
 end
 
 class RuboCop::AST::IndexasgnNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::ParameterizedNode)
+  include(::RuboCop::AST::ParameterizedNode::RestArguments)
   include(::RuboCop::AST::MethodIdentifierPredicates)
   include(::RuboCop::AST::MethodDispatchNode)
 
-  def arguments; end
   def assignment_method?; end
   def attribute_accessor?; end
   def method_name; end
+
+  private
+
+  def first_argument_index; end
 end
 
 class RuboCop::AST::IntNode < ::RuboCop::AST::Node
+  include(::RuboCop::AST::BasicLiteralNode)
   include(::RuboCop::AST::NumericNode)
 end
 
@@ -382,15 +399,20 @@ RuboCop::AST::KeywordSplatNode::DOUBLE_SPLAT = T.let(T.unsafe(nil), String)
 
 class RuboCop::AST::LambdaNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::ParameterizedNode)
+  include(::RuboCop::AST::ParameterizedNode::RestArguments)
   include(::RuboCop::AST::MethodIdentifierPredicates)
   include(::RuboCop::AST::MethodDispatchNode)
 
-  def arguments; end
   def assignment_method?; end
   def attribute_accessor?; end
   def lambda?; end
   def lambda_literal?; end
   def method_name; end
+  def receiver; end
+
+  private
+
+  def first_argument_index; end
 end
 
 module RuboCop::AST::MethodDispatchNode
@@ -398,12 +420,11 @@ module RuboCop::AST::MethodDispatchNode
   extend(::RuboCop::AST::NodePattern::Macros)
 
   def access_modifier?; end
-  def adjacent_def_modifier?(node = _); end
+  def adjacent_def_modifier?(node = T.unsafe(nil)); end
-  def arguments; end
   def arithmetic_operation?; end
   def assignment?; end
   def bare_access_modifier?; end
-  def bare_access_modifier_declaration?(node = _); end
+  def bare_access_modifier_declaration?(node = T.unsafe(nil)); end
   def binary_operation?; end
   def block_literal?; end
   def block_node; end
@@ -416,10 +437,10 @@ module RuboCop::AST::MethodDispatchNode
   def lambda?; end
   def lambda_literal?; end
   def macro?; end
-  def macro_scope?(node = _); end
+  def macro_scope?(node = T.unsafe(nil)); end
   def method_name; end
   def non_bare_access_modifier?; end
-  def non_bare_access_modifier_declaration?(node = _); end
+  def non_bare_access_modifier_declaration?(node = T.unsafe(nil)); end
   def receiver; end
   def safe_navigation?; end
   def self_receiver?; end
@@ -487,12 +508,17 @@ class RuboCop::AST::ModuleNode < ::RuboCop::AST::Node
   def identifier; end
 end
 
+class RuboCop::AST::NextNode < ::RuboCop::AST::Node
+  include(::RuboCop::AST::ParameterizedNode)
+  include(::RuboCop::AST::ParameterizedNode::WrappedArguments)
+end
+
 class RuboCop::AST::Node < ::Parser::AST::Node
   include(::RuboCop::AST::Sexp)
   include(::RuboCop::RSpec::Node)
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def initialize(type, children = _, properties = _); end
+  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
 
   def __ENCODING___type?; end
   def __FILE___type?; end
@@ -510,7 +536,7 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def array_pattern_with_tail_type?; end
   def array_type?; end
   def assignment?; end
-  def assignment_or_similar?(node = _); end
+  def assignment_or_similar?(node = T.unsafe(nil)); end
   def back_ref_type?; end
   def basic_conditional?; end
   def basic_literal?; end
@@ -528,8 +554,8 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def cbase_type?; end
   def chained?; end
   def child_nodes; end
-  def class_constructor?(node = _); end
+  def class_constructor?(node = T.unsafe(nil)); end
-  def class_definition?(node = _); end
+  def class_definition?(node = T.unsafe(nil)); end
   def class_type?; end
   def complete!; end
   def complete?; end
@@ -570,7 +596,7 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def forward_arg_type?; end
   def forward_args_type?; end
   def forwarded_args_type?; end
-  def global_const?(node = _, param1); end
+  def global_const?(node = T.unsafe(nil), param1); end
   def guard_clause?; end
   def gvar_type?; end
   def gvasgn_type?; end
@@ -596,8 +622,8 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def kwoptarg_type?; end
   def kwrestarg_type?; end
   def kwsplat_type?; end
-  def lambda?(node = _); end
+  def lambda?(node = T.unsafe(nil)); end
-  def lambda_or_proc?(node = _); end
+  def lambda_or_proc?(node = T.unsafe(nil)); end
   def lambda_type?; end
   def last_line; end
   def line_count; end
@@ -609,19 +635,19 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def match_alt_type?; end
   def match_as_type?; end
   def match_current_line_type?; end
-  def match_guard_clause?(node = _); end
+  def match_guard_clause?(node = T.unsafe(nil)); end
   def match_nil_pattern_type?; end
   def match_rest_type?; end
   def match_var_type?; end
   def match_with_lvasgn_type?; end
   def match_with_trailing_comma_type?; end
   def mlhs_type?; end
-  def module_definition?(node = _); end
+  def module_definition?(node = T.unsafe(nil)); end
   def module_type?; end
   def mrasgn_type?; end
   def multiline?; end
   def mutable_literal?; end
-  def new_class_or_module_block?(node = _); end
+  def new_class_or_module_block?(node = T.unsafe(nil)); end
   def next_type?; end
   def nil_type?; end
   def node_parts; end
@@ -647,13 +673,13 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def post_condition_loop?; end
   def postexe_type?; end
   def preexe_type?; end
-  def proc?(node = _); end
+  def proc?(node = T.unsafe(nil)); end
   def procarg0_type?; end
   def pure?; end
   def range_type?; end
   def rasgn_type?; end
   def rational_type?; end
-  def receiver(node = _); end
+  def receiver(node = T.unsafe(nil)); end
   def recursive_basic_literal?; end
   def recursive_literal?; end
   def redo_type?; end
@@ -679,9 +705,9 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def source_range; end
   def special_keyword?; end
   def splat_type?; end
-  def str_content(node = _); end
+  def str_content(node = T.unsafe(nil)); end
   def str_type?; end
-  def struct_constructor?(node = _); end
+  def struct_constructor?(node = T.unsafe(nil)); end
   def super_type?; end
   def sym_type?; end
   def true_type?; end
@@ -690,7 +716,7 @@ class RuboCop::AST::Node < ::Parser::AST::Node
   def unless_guard_type?; end
   def until_post_type?; end
   def until_type?; end
-  def updated(type = _, children = _, properties = _); end
+  def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
   def value_used?; end
   def variable?; end
   def when_type?; end
@@ -709,7 +735,7 @@ class RuboCop::AST::Node < ::Parser::AST::Node
 
   def begin_value_used?; end
   def case_if_value_used?; end
-  def defined_module0(node = _); end
+  def defined_module0(node = T.unsafe(nil)); end
   def for_value_used?; end
   def parent_module_name_for_block(ancestor); end
   def parent_module_name_for_sclass(sclass_node); end
@@ -771,7 +797,9 @@ class RuboCop::AST::NodePattern
   def pattern; end
   def to_s; end
 
-  def self.descend(element, &block); end
+  class << self
+    def descend(element, &block); end
+  end
 end
 
 class RuboCop::AST::NodePattern::Invalid < ::StandardError
@@ -806,9 +834,9 @@ class RuboCop::AST::PairNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::HashElementNode)
 
   def colon?; end
-  def delimiter(with_spacing = _); end
+  def delimiter(*deprecated, with_spacing: T.unsafe(nil)); end
   def hash_rocket?; end
-  def inverse_delimiter(with_spacing = _); end
+  def inverse_delimiter(*deprecated, with_spacing: T.unsafe(nil)); end
   def value_on_new_line?; end
 end
 
@@ -830,6 +858,21 @@ module RuboCop::AST::ParameterizedNode
   def splat_argument?; end
 end
 
+module RuboCop::AST::ParameterizedNode::RestArguments
+  include(::RuboCop::AST::ParameterizedNode)
+
+  def arguments; end
+  def arguments?; end
+  def first_argument; end
+  def last_argument; end
+end
+
+module RuboCop::AST::ParameterizedNode::WrappedArguments
+  include(::RuboCop::AST::ParameterizedNode)
+
+  def arguments; end
+end
+
 module RuboCop::AST::PredicateOperatorNode
   def logical_operator?; end
   def operator; end
@@ -847,7 +890,7 @@ RuboCop::AST::PredicateOperatorNode::SEMANTIC_OR = T.let(T.unsafe(nil), String)
 class RuboCop::AST::ProcessedSource
   include(::RuboCop::Ext::ProcessedSource)
 
-  def initialize(source, ruby_version, path = _); end
+  def initialize(source, ruby_version, path = T.unsafe(nil)); end
 
   def [](*args); end
   def ast; end
@@ -855,17 +898,19 @@ class RuboCop::AST::ProcessedSource
   def blank?; end
   def buffer; end
   def checksum; end
+  def comment_at_line(line); end
   def commented?(source_range); end
   def comments; end
   def comments_before_line(line); end
   def contains_comment?(source_range); end
   def current_line(token); end
   def diagnostics; end
-  def each_comment; end
+  def each_comment(&block); end
-  def each_token; end
+  def each_comment_in_lines(line_range); end
+  def each_token(&block); end
   def file_path; end
-  def find_comment; end
+  def find_comment(&block); end
-  def find_token; end
+  def find_token(&block); end
   def following_line(token); end
   def line_indentation(line_number); end
   def line_with_comment?(line); end
@@ -881,13 +926,15 @@ class RuboCop::AST::ProcessedSource
 
   private
 
-  def comment_lines; end
+  def comment_index; end
   def create_parser(ruby_version); end
   def parse(source, ruby_version); end
   def parser_class(ruby_version); end
   def tokenize(parser); end
 
-  def self.from_file(path, ruby_version); end
+  class << self
+    def from_file(path, ruby_version); end
+  end
 end
 
 RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME = T.let(T.unsafe(nil), String)
@@ -924,20 +971,9 @@ class RuboCop::AST::ResbodyNode < ::RuboCop::AST::Node
   def exception_variable; end
 end
 
-class RuboCop::AST::RetryNode < ::RuboCop::AST::Node
-  include(::RuboCop::AST::MethodIdentifierPredicates)
-  include(::RuboCop::AST::MethodDispatchNode)
-  include(::RuboCop::AST::ParameterizedNode)
-
-  def arguments; end
-end
-
 class RuboCop::AST::ReturnNode < ::RuboCop::AST::Node
-  include(::RuboCop::AST::MethodIdentifierPredicates)
-  include(::RuboCop::AST::MethodDispatchNode)
   include(::RuboCop::AST::ParameterizedNode)
-
+  include(::RuboCop::AST::ParameterizedNode::WrappedArguments)
-  def arguments; end
 end
 
 class RuboCop::AST::SelfClassNode < ::RuboCop::AST::Node
@@ -947,10 +983,15 @@ end
 
 class RuboCop::AST::SendNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::ParameterizedNode)
+  include(::RuboCop::AST::ParameterizedNode::RestArguments)
   include(::RuboCop::AST::MethodIdentifierPredicates)
   include(::RuboCop::AST::MethodDispatchNode)
 
-  def attribute_accessor?(node = _); end
+  def attribute_accessor?(node = T.unsafe(nil)); end
+
+  private
+
+  def first_argument_index; end
 end
 
 module RuboCop::AST::Sexp
@@ -968,6 +1009,7 @@ class RuboCop::AST::SuperNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::MethodIdentifierPredicates)
   include(::RuboCop::AST::MethodDispatchNode)
 
+  def arguments; end
   def node_parts; end
 end
 
@@ -1004,7 +1046,9 @@ class RuboCop::AST::Token
   def to_s; end
   def type; end
 
-  def self.from_parser_token(parser_token); end
+  class << self
+    def from_parser_token(parser_token); end
+  end
 end
 
 module RuboCop::AST::Traversal
@@ -1156,7 +1200,7 @@ class RuboCop::AST::WhenNode < ::RuboCop::AST::Node
   def body; end
   def branch_index; end
   def conditions; end
-  def each_condition; end
+  def each_condition(&block); end
   def then?; end
 end
 
@@ -1174,6 +1218,7 @@ class RuboCop::AST::YieldNode < ::RuboCop::AST::Node
   include(::RuboCop::AST::MethodIdentifierPredicates)
   include(::RuboCop::AST::MethodDispatchNode)
 
+  def arguments; end
   def node_parts; end
 end
 
@@ -1189,6 +1234,8 @@ RuboCop::AST::NodePattern::Compiler::CAPTURED_REST = T.let(T.unsafe(nil), String
 
 RuboCop::AST::NodePattern::Compiler::CLOSING = T.let(T.unsafe(nil), Regexp)
 
+RuboCop::AST::NodePattern::Compiler::COMMENT = T.let(T.unsafe(nil), Regexp)
+
 RuboCop::AST::NodePattern::Compiler::CONST = T.let(T.unsafe(nil), Regexp)
 
 RuboCop::AST::NodePattern::Compiler::CUR_ELEMENT = T.let(T.unsafe(nil), String)

Library/Homebrew/sorbet/rbi/gems/rubocop-performance@1.7.1.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync --exclude json
+# This is an autogenerated file for types exported from the `rubocop-performance` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -15,7 +16,7 @@ end
 class RuboCop::Cop::Performance::AncestorsInclude < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
-  def ancestors_include_candidate?(node = _); end
+  def ancestors_include_candidate?(node = T.unsafe(nil)); end
   def autocorrect(node); end
   def on_send(node); end
 end
@@ -24,7 +25,7 @@ RuboCop::Cop::Performance::AncestorsInclude::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::BigDecimalWithNumericArgument < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def big_decimal_with_numeric_argument?(node = _); end
+  def big_decimal_with_numeric_argument?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -39,7 +40,7 @@ class RuboCop::Cop::Performance::BindCall < ::RuboCop::Cop::Cop
   extend(::RuboCop::Cop::TargetRubyVersion)
 
   def autocorrect(node); end
-  def bind_with_call_method?(node = _); end
+  def bind_with_call_method?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -52,9 +53,9 @@ end
 RuboCop::Cop::Performance::BindCall::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::Caller < ::RuboCop::Cop::Cop
-  def caller_with_scope_method?(node = _); end
+  def caller_with_scope_method?(node = T.unsafe(nil)); end
   def on_send(node); end
-  def slow_caller?(node = _); end
+  def slow_caller?(node = T.unsafe(nil)); end
 
   private
 
@@ -94,9 +95,9 @@ RuboCop::Cop::Performance::CaseWhenSplat::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::Casecmp < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def downcase_downcase(node = _); end
+  def downcase_downcase(node = T.unsafe(nil)); end
-  def downcase_eq(node = _); end
+  def downcase_eq(node = T.unsafe(nil)); end
-  def eq_downcase(node = _); end
+  def eq_downcase(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -113,7 +114,7 @@ RuboCop::Cop::Performance::Casecmp::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Performance::ChainArrayAllocation < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
-  def flat_map_candidate?(node = _); end
+  def flat_map_candidate?(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -131,9 +132,9 @@ class RuboCop::Cop::Performance::CompareWithBlock < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
   def autocorrect(node); end
-  def compare?(node = _); end
+  def compare?(node = T.unsafe(nil)); end
   def on_block(node); end
-  def replaceable_body?(node = _, param1, param2); end
+  def replaceable_body?(node = T.unsafe(nil), param1, param2); end
 
   private
 
@@ -148,7 +149,7 @@ class RuboCop::Cop::Performance::Count < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
   def autocorrect(node); end
-  def count_candidate?(node = _); end
+  def count_candidate?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -164,7 +165,7 @@ class RuboCop::Cop::Performance::DeletePrefix < ::RuboCop::Cop::Cop
   extend(::RuboCop::Cop::TargetRubyVersion)
 
   def autocorrect(node); end
-  def delete_prefix_candidate?(node = _); end
+  def delete_prefix_candidate?(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -177,7 +178,7 @@ class RuboCop::Cop::Performance::DeleteSuffix < ::RuboCop::Cop::Cop
   extend(::RuboCop::Cop::TargetRubyVersion)
 
   def autocorrect(node); end
-  def delete_suffix_candidate?(node = _); end
+  def delete_suffix_candidate?(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -187,7 +188,7 @@ RuboCop::Cop::Performance::DeleteSuffix::PREFERRED_METHODS = T.let(T.unsafe(nil)
 
 class RuboCop::Cop::Performance::Detect < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def detect_candidate?(node = _); end
+  def detect_candidate?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -204,9 +205,9 @@ RuboCop::Cop::Performance::Detect::REVERSE_MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::DoubleStartEndWith < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def check_with_active_support_aliases(node = _); end
+  def check_with_active_support_aliases(node = T.unsafe(nil)); end
   def on_or(node); end
-  def two_start_end_with_calls(node = _); end
+  def two_start_end_with_calls(node = T.unsafe(nil)); end
 
   private
 
@@ -224,13 +225,13 @@ class RuboCop::Cop::Performance::EndWith < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_match_with_lvasgn(node); end
   def on_send(node); end
-  def redundant_regex?(node = _); end
+  def redundant_regex?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Performance::EndWith::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::FixedSize < ::RuboCop::Cop::Cop
-  def counter(node = _); end
+  def counter(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -249,7 +250,7 @@ class RuboCop::Cop::Performance::FlatMap < ::RuboCop::Cop::Cop
   include(::RuboCop::Cop::RangeHelp)
 
   def autocorrect(node); end
-  def flat_map_candidate?(node = _); end
+  def flat_map_candidate?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -265,7 +266,7 @@ RuboCop::Cop::Performance::FlatMap::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::InefficientHashSearch < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def inefficient_include?(node = _); end
+  def inefficient_include?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -283,8 +284,8 @@ class RuboCop::Cop::Performance::IoReadlines < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_send(node); end
-  def readlines_on_class?(node = _); end
+  def readlines_on_class?(node = T.unsafe(nil)); end
-  def readlines_on_instance?(node = _); end
+  def readlines_on_instance?(node = T.unsafe(nil)); end
 
   private
 
@@ -303,7 +304,7 @@ RuboCop::Cop::Performance::IoReadlines::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::OpenStruct < ::RuboCop::Cop::Cop
   def on_send(node); end
-  def open_struct(node = _); end
+  def open_struct(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Performance::OpenStruct::MSG = T.let(T.unsafe(nil), String)
@@ -311,7 +312,7 @@ RuboCop::Cop::Performance::OpenStruct::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Performance::RangeInclude < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_send(node); end
-  def range_include(node = _); end
+  def range_include(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Performance::RangeInclude::MSG = T.let(T.unsafe(nil), String)
@@ -320,7 +321,7 @@ class RuboCop::Cop::Performance::RedundantBlockCall < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def blockarg_assigned?(node0, param1); end
   def blockarg_calls(node0, param1); end
-  def blockarg_def(node = _); end
+  def blockarg_def(node = T.unsafe(nil)); end
   def on_def(node); end
 
   private
@@ -341,18 +342,18 @@ RuboCop::Cop::Performance::RedundantBlockCall::YIELD = T.let(T.unsafe(nil), Stri
 
 class RuboCop::Cop::Performance::RedundantMatch < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def match_call?(node = _); end
+  def match_call?(node = T.unsafe(nil)); end
   def on_send(node); end
-  def only_truthiness_matters?(node = _); end
+  def only_truthiness_matters?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Performance::RedundantMatch::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::RedundantMerge < ::RuboCop::Cop::Cop
   def autocorrect(node); end
-  def modifier_flow_control?(node = _); end
+  def modifier_flow_control?(node = T.unsafe(nil)); end
   def on_send(node); end
-  def redundant_merge_candidate(node = _); end
+  def redundant_merge_candidate(node = T.unsafe(nil)); end
 
   private
 
@@ -378,7 +379,7 @@ class RuboCop::Cop::Performance::RedundantMerge::EachWithObjectInspector
 
   def initialize(node, receiver); end
 
-  def each_with_object_node(node = _); end
+  def each_with_object_node(node = T.unsafe(nil)); end
   def value_used?; end
 
   private
@@ -413,7 +414,7 @@ class RuboCop::Cop::Performance::RedundantStringChars < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_send(node); end
-  def redundant_chars_call?(node = _); end
+  def redundant_chars_call?(node = T.unsafe(nil)); end
 
   private
 
@@ -433,11 +434,11 @@ RuboCop::Cop::Performance::RedundantStringChars::REPLACEABLE_METHODS = T.let(T.u
 class RuboCop::Cop::Performance::RegexpMatch < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def last_matches(node0); end
-  def match_method?(node = _); end
+  def match_method?(node = T.unsafe(nil)); end
-  def match_node?(node = _); end
+  def match_node?(node = T.unsafe(nil)); end
-  def match_operator?(node = _); end
+  def match_operator?(node = T.unsafe(nil)); end
-  def match_threequals?(node = _); end
+  def match_threequals?(node = T.unsafe(nil)); end
-  def match_with_int_arg_method?(node = _); end
+  def match_with_int_arg_method?(node = T.unsafe(nil)); end
   def match_with_lvasgn?(node); end
   def on_case(node); end
   def on_if(node); end
@@ -446,7 +447,7 @@ class RuboCop::Cop::Performance::RegexpMatch < ::RuboCop::Cop::Cop
   private
 
   def check_condition(cond); end
-  def correct_operator(corrector, recv, arg, oper = _); end
+  def correct_operator(corrector, recv, arg, oper = T.unsafe(nil)); end
   def correction_range(recv, arg); end
   def find_last_match(body, range, scope_root); end
   def last_match_used?(match_node); end
@@ -472,7 +473,7 @@ class RuboCop::Cop::Performance::ReverseEach < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_send(node); end
-  def reverse_each?(node = _); end
+  def reverse_each?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Performance::ReverseEach::MSG = T.let(T.unsafe(nil), String)
@@ -484,7 +485,7 @@ class RuboCop::Cop::Performance::ReverseFirst < ::RuboCop::Cop::Cop
 
   def autocorrect(node); end
   def on_send(node); end
-  def reverse_first_candidate?(node = _); end
+  def reverse_first_candidate?(node = T.unsafe(nil)); end
 
   private
 
@@ -497,10 +498,10 @@ end
 RuboCop::Cop::Performance::ReverseFirst::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::Size < ::RuboCop::Cop::Cop
-  def array?(node = _); end
+  def array?(node = T.unsafe(nil)); end
   def autocorrect(node); end
-  def count?(node = _); end
+  def count?(node = T.unsafe(nil)); end
-  def hash?(node = _); end
+  def hash?(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -523,7 +524,7 @@ RuboCop::Cop::Performance::SortReverse::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Performance::Squeeze < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_send(node); end
-  def squeeze_candidate?(node = _); end
+  def squeeze_candidate?(node = T.unsafe(nil)); end
 
   private
 
@@ -540,7 +541,7 @@ class RuboCop::Cop::Performance::StartWith < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_match_with_lvasgn(node); end
   def on_send(node); end
-  def redundant_regex?(node = _); end
+  def redundant_regex?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Performance::StartWith::MSG = T.let(T.unsafe(nil), String)
@@ -549,7 +550,7 @@ class RuboCop::Cop::Performance::StringInclude < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_match_with_lvasgn(node); end
   def on_send(node); end
-  def redundant_regex?(node = _); end
+  def redundant_regex?(node = T.unsafe(nil)); end
 
   private
 
@@ -564,7 +565,7 @@ class RuboCop::Cop::Performance::StringReplacement < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_send(node); end
   def replace_method(node, first, second, first_param, replacement); end
-  def string_replacement?(node = _); end
+  def string_replacement?(node = T.unsafe(nil)); end
 
   private
 
@@ -595,7 +596,7 @@ class RuboCop::Cop::Performance::TimesMap < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_block(node); end
   def on_send(node); end
-  def times_map_call(node = _); end
+  def times_map_call(node = T.unsafe(nil)); end
 
   private
 
@@ -608,9 +609,9 @@ RuboCop::Cop::Performance::TimesMap::MESSAGE = T.let(T.unsafe(nil), String)
 RuboCop::Cop::Performance::TimesMap::MESSAGE_ONLY_IF = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::Performance::UnfreezeString < ::RuboCop::Cop::Cop
-  def dup_string?(node = _); end
+  def dup_string?(node = T.unsafe(nil)); end
   def on_send(node); end
-  def string_new?(node = _); end
+  def string_new?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Performance::UnfreezeString::MSG = T.let(T.unsafe(nil), String)
@@ -618,7 +619,7 @@ RuboCop::Cop::Performance::UnfreezeString::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::Performance::UriDefaultParser < ::RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_send(node); end
-  def uri_parser_new?(node = _); end
+  def uri_parser_new?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::Performance::UriDefaultParser::MSG = T.let(T.unsafe(nil), String)
@@ -642,8 +643,8 @@ module RuboCop::Cop::SortBlock
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def replaceable_body?(node = _, param1, param2); end
+  def replaceable_body?(node = T.unsafe(nil), param1, param2); end
-  def sort_with_block?(node = _); end
+  def sort_with_block?(node = T.unsafe(nil)); end
 
   private
 
@@ -658,7 +659,9 @@ end
 RuboCop::Performance::CONFIG = T.let(T.unsafe(nil), Hash)
 
 module RuboCop::Performance::Inject
-  def self.defaults!; end
+  class << self
+    def defaults!; end
+  end
 end
 
 module RuboCop::Performance::Version

Library/Homebrew/sorbet/rbi/gems/rubocop-rspec@1.42.0.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync --exclude json
+# This is an autogenerated file for types exported from the `rubocop-rspec` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -39,7 +40,9 @@ class RuboCop::Cop::Layout::ExtraSpacing < ::RuboCop::Cop::Cop
   def ignored_range?(ast, start_pos); end
   def ignored_ranges(ast); end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 RuboCop::Cop::Layout::ExtraSpacing::MSG_UNALIGNED_ASGN = T.let(T.unsafe(nil), String)
@@ -54,7 +57,9 @@ class RuboCop::Cop::RSpec::AlignLeftLetBrace < ::RuboCop::Cop::RSpec::Cop
 
   def on_new_investigation; end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 RuboCop::Cop::RSpec::AlignLeftLetBrace::MSG = T.let(T.unsafe(nil), String)
@@ -64,13 +69,15 @@ class RuboCop::Cop::RSpec::AlignRightLetBrace < ::RuboCop::Cop::RSpec::Cop
 
   def on_new_investigation; end
 
-  def self.autocorrect_incompatible_with; end
+  class << self
+    def autocorrect_incompatible_with; end
+  end
 end
 
 RuboCop::Cop::RSpec::AlignRightLetBrace::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::AnyInstance < ::RuboCop::Cop::RSpec::Cop
-  def disallowed_stub(node = _); end
+  def disallowed_stub(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -78,7 +85,7 @@ RuboCop::Cop::RSpec::AnyInstance::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::AroundBlock < ::RuboCop::Cop::RSpec::Cop
   def find_arg_usage(node0); end
-  def hook(node = _); end
+  def hook(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -92,7 +99,7 @@ RuboCop::Cop::RSpec::AroundBlock::MSG_NO_ARG = T.let(T.unsafe(nil), String)
 RuboCop::Cop::RSpec::AroundBlock::MSG_UNUSED_ARG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::Be < ::RuboCop::Cop::RSpec::Cop
-  def be_without_args(node = _); end
+  def be_without_args(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -101,14 +108,14 @@ RuboCop::Cop::RSpec::Be::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::RSpec::BeEql < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def eql_type_with_identity(node = _); end
+  def eql_type_with_identity(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
 RuboCop::Cop::RSpec::BeEql::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::BeforeAfterAll < ::RuboCop::Cop::RSpec::Cop
-  def before_or_after_all(node = _); end
+  def before_or_after_all(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -120,10 +127,10 @@ end
 class RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def as_is_matcher(node = _); end
+  def as_is_matcher(node = T.unsafe(nil)); end
-  def expectation_set_on_current_path(node = _); end
+  def expectation_set_on_current_path(node = T.unsafe(nil)); end
   def on_send(node); end
-  def regexp_str_matcher(node = _); end
+  def regexp_str_matcher(node = T.unsafe(nil)); end
 
   private
 
@@ -138,10 +145,10 @@ RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation::MSG = T.let(T.unsafe(nil)
 class RuboCop::Cop::RSpec::Capybara::FeatureMethods < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def feature_method(node = _); end
+  def feature_method(node = T.unsafe(nil)); end
   def message(range); end
   def on_block(node); end
-  def spec?(node = _); end
+  def spec?(node = T.unsafe(nil)); end
 
   private
 
@@ -158,8 +165,8 @@ RuboCop::Cop::RSpec::Capybara::FeatureMethods::MSG = T.let(T.unsafe(nil), String
 
 class RuboCop::Cop::RSpec::Capybara::VisibilityMatcher < ::RuboCop::Cop::RSpec::Cop
   def on_send(node); end
-  def visible_false?(node = _); end
+  def visible_false?(node = T.unsafe(nil)); end
-  def visible_true?(node = _); end
+  def visible_true?(node = T.unsafe(nil)); end
 
   private
 
@@ -175,7 +182,7 @@ RuboCop::Cop::RSpec::Capybara::VisibilityMatcher::MSG_TRUE = T.let(T.unsafe(nil)
 class RuboCop::Cop::RSpec::ContextMethod < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def context_method(node = _); end
+  def context_method(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -186,7 +193,7 @@ end
 RuboCop::Cop::RSpec::ContextMethod::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::ContextWording < ::RuboCop::Cop::RSpec::Cop
-  def context_wording(node = _); end
+  def context_wording(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -212,7 +219,9 @@ class RuboCop::Cop::RSpec::Cop < ::RuboCop::Cop::Base
   def rspec_pattern_config; end
   def rspec_pattern_config?; end
 
-  def self.inherited(subclass); end
+  class << self
+    def inherited(subclass); end
+  end
 end
 
 RuboCop::Cop::RSpec::Cop::DEFAULT_CONFIGURATION = T.let(T.unsafe(nil), Hash)
@@ -222,10 +231,10 @@ RuboCop::Cop::RSpec::Cop::DEFAULT_PATTERN_RE = T.let(T.unsafe(nil), Regexp)
 class RuboCop::Cop::RSpec::DescribeClass < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::RSpec::TopLevelDescribe)
 
-  def describe_with_rails_metadata?(node = _); end
+  def describe_with_rails_metadata?(node = T.unsafe(nil)); end
   def on_top_level_describe(node, _); end
-  def rails_metadata?(node = _); end
+  def rails_metadata?(node = T.unsafe(nil)); end
-  def valid_describe?(node = _); end
+  def valid_describe?(node = T.unsafe(nil)); end
 
   private
 
@@ -243,7 +252,7 @@ end
 RuboCop::Cop::RSpec::DescribeMethod::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::DescribeSymbol < ::RuboCop::Cop::RSpec::Cop
-  def describe_symbol?(node = _); end
+  def describe_symbol?(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -253,12 +262,12 @@ class RuboCop::Cop::RSpec::DescribedClass < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def common_instance_exec_closure?(node = _); end
+  def common_instance_exec_closure?(node = T.unsafe(nil)); end
   def contains_described_class?(node0); end
-  def described_constant(node = _); end
+  def described_constant(node = T.unsafe(nil)); end
   def on_block(node); end
-  def rspec_block?(node = _); end
+  def rspec_block?(node = T.unsafe(nil)); end
-  def scope_changing_syntax?(node = _); end
+  def scope_changing_syntax?(node = T.unsafe(nil)); end
 
   private
 
@@ -292,7 +301,7 @@ class RuboCop::Cop::RSpec::Dialect < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_send(node); end
-  def rspec_method?(node = _); end
+  def rspec_method?(node = T.unsafe(nil)); end
 end
 
 RuboCop::Cop::RSpec::Dialect::MSG = T.let(T.unsafe(nil), String)
@@ -313,7 +322,7 @@ class RuboCop::Cop::RSpec::EmptyHook < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def empty_hook?(node = _); end
+  def empty_hook?(node = T.unsafe(nil)); end
   def on_block(node); end
 end
 
@@ -400,7 +409,7 @@ RuboCop::Cop::RSpec::ExampleLength::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::RSpec::ExampleWithoutDescription < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
-  def example_description(node = _); end
+  def example_description(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -416,7 +425,7 @@ RuboCop::Cop::RSpec::ExampleWithoutDescription::MSG_DEFAULT_ARGUMENT = T.let(T.u
 class RuboCop::Cop::RSpec::ExampleWording < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def it_description(node = _); end
+  def it_description(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -440,7 +449,7 @@ RuboCop::Cop::RSpec::ExampleWording::SHOULD_PREFIX = T.let(T.unsafe(nil), Regexp
 class RuboCop::Cop::RSpec::ExpectActual < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def expect_literal(node = _); end
+  def expect_literal(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -463,8 +472,8 @@ class RuboCop::Cop::RSpec::ExpectChange < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def expect_change_with_arguments(node = _); end
+  def expect_change_with_arguments(node = T.unsafe(nil)); end
-  def expect_change_with_block(node = _); end
+  def expect_change_with_block(node = T.unsafe(nil)); end
   def on_block(node); end
   def on_send(node); end
 end
@@ -498,8 +507,8 @@ module RuboCop::Cop::RSpec::ExplicitHelper
   include(::RuboCop::RSpec::Language)
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def predicate_matcher?(node = _); end
+  def predicate_matcher?(node = T.unsafe(nil)); end
-  def predicate_matcher_block?(node = _); end
+  def predicate_matcher_block?(node = T.unsafe(nil)); end
 
   private
 
@@ -523,10 +532,10 @@ end
 class RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def association?(node = _); end
+  def association?(node = T.unsafe(nil)); end
-  def factory_attributes(node = _); end
+  def factory_attributes(node = T.unsafe(nil)); end
   def on_block(node); end
-  def value_matcher(node = _); end
+  def value_matcher(node = T.unsafe(nil)); end
 
   private
 
@@ -548,9 +557,9 @@ class RuboCop::Cop::RSpec::FactoryBot::CreateList < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def factory_call(node = _); end
+  def factory_call(node = T.unsafe(nil)); end
-  def factory_list_call(node = _); end
+  def factory_list_call(node = T.unsafe(nil)); end
-  def n_times_block_without_arg?(node = _); end
+  def n_times_block_without_arg?(node = T.unsafe(nil)); end
   def on_block(node); end
   def on_send(node); end
 
@@ -602,7 +611,7 @@ end
 class RuboCop::Cop::RSpec::FactoryBot::FactoryClassName < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def class_name(node = _); end
+  def class_name(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -639,8 +648,8 @@ end
 RuboCop::Cop::RSpec::FilePath::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::Focus < ::RuboCop::Cop::RSpec::Cop
-  def focused_block?(node = _); end
+  def focused_block?(node = T.unsafe(nil)); end
-  def metadata(node = _); end
+  def metadata(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -657,8 +666,8 @@ class RuboCop::Cop::RSpec::HookArgument < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_block(node); end
-  def scoped_hook(node = _); end
+  def scoped_hook(node = T.unsafe(nil)); end
-  def unscoped_hook(node = _); end
+  def unscoped_hook(node = T.unsafe(nil)); end
 
   private
 
@@ -678,7 +687,7 @@ RuboCop::Cop::RSpec::HookArgument::IMPLICIT_MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::RSpec::HooksBeforeExamples < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def example_or_group?(node = _); end
+  def example_or_group?(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -692,9 +701,9 @@ end
 RuboCop::Cop::RSpec::HooksBeforeExamples::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::ImplicitBlockExpectation < ::RuboCop::Cop::RSpec::Cop
-  def implicit_expect(node = _); end
+  def implicit_expect(node = T.unsafe(nil)); end
-  def lambda?(node = _); end
+  def lambda?(node = T.unsafe(nil)); end
-  def lambda_subject?(node = _); end
+  def lambda_subject?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -710,7 +719,7 @@ class RuboCop::Cop::RSpec::ImplicitExpect < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def implicit_expect(node = _); end
+  def implicit_expect(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -729,7 +738,7 @@ class RuboCop::Cop::RSpec::ImplicitSubject < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def implicit_subject?(node = _); end
+  def implicit_subject?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -745,9 +754,9 @@ module RuboCop::Cop::RSpec::InflectedHelper
   include(::RuboCop::RSpec::Language)
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def be_bool?(node = _); end
+  def be_bool?(node = T.unsafe(nil)); end
-  def be_boolthy?(node = _); end
+  def be_boolthy?(node = T.unsafe(nil)); end
-  def predicate_in_actual?(node = _); end
+  def predicate_in_actual?(node = T.unsafe(nil)); end
 
   private
 
@@ -780,8 +789,8 @@ RuboCop::Cop::RSpec::InstanceSpy::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::RSpec::InstanceVariable < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::RSpec::TopLevelGroup)
 
-  def custom_matcher?(node = _); end
+  def custom_matcher?(node = T.unsafe(nil)); end
-  def dynamic_class?(node = _); end
+  def dynamic_class?(node = T.unsafe(nil)); end
   def ivar_assigned?(node0, param1); end
   def ivar_usage(node0); end
   def on_top_level_group(node); end
@@ -795,7 +804,7 @@ end
 RuboCop::Cop::RSpec::InstanceVariable::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::InvalidPredicateMatcher < ::RuboCop::Cop::RSpec::Cop
-  def invalid_predicate_matcher?(node = _); end
+  def invalid_predicate_matcher?(node = T.unsafe(nil)); end
   def on_send(node); end
 
   private
@@ -809,7 +818,7 @@ class RuboCop::Cop::RSpec::ItBehavesLike < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def example_inclusion_offense(node = _, param1); end
+  def example_inclusion_offense(node = T.unsafe(nil), param1); end
   def on_send(node); end
 
   private
@@ -820,8 +829,8 @@ end
 RuboCop::Cop::RSpec::ItBehavesLike::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::IteratedExpectation < ::RuboCop::Cop::RSpec::Cop
-  def each?(node = _); end
+  def each?(node = T.unsafe(nil)); end
-  def expectation?(node = _, param1); end
+  def expectation?(node = T.unsafe(nil), param1); end
   def on_block(node); end
 
   private
@@ -867,7 +876,7 @@ RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_MODULE = T.let(T.unsafe(nil),
 class RuboCop::Cop::RSpec::LetBeforeExamples < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def example_or_group?(node = _); end
+  def example_or_group?(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -881,8 +890,8 @@ end
 RuboCop::Cop::RSpec::LetBeforeExamples::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::LetSetup < ::RuboCop::Cop::RSpec::Cop
-  def example_or_shared_group_or_including?(node = _); end
+  def example_or_shared_group_or_including?(node = T.unsafe(nil)); end
-  def let_bang(node = _); end
+  def let_bang(node = T.unsafe(nil)); end
   def method_called?(node0, param1); end
   def on_block(node); end
 
@@ -895,7 +904,7 @@ end
 RuboCop::Cop::RSpec::LetSetup::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::MessageChain < ::RuboCop::Cop::RSpec::Cop
-  def message_chain(node = _); end
+  def message_chain(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -904,7 +913,7 @@ RuboCop::Cop::RSpec::MessageChain::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::RSpec::MessageExpectation < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
-  def message_expectation(node = _); end
+  def message_expectation(node = T.unsafe(nil)); end
   def on_send(node); end
   def receive_message?(node0); end
 
@@ -920,7 +929,7 @@ RuboCop::Cop::RSpec::MessageExpectation::SUPPORTED_STYLES = T.let(T.unsafe(nil),
 class RuboCop::Cop::RSpec::MessageSpies < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
 
-  def message_expectation(node = _); end
+  def message_expectation(node = T.unsafe(nil)); end
   def on_send(node); end
   def receive_message(node0); end
 
@@ -954,10 +963,10 @@ RuboCop::Cop::RSpec::MultipleDescribes::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::RSpec::MultipleExpectations < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableMax)
 
-  def aggregate_failures?(node = _); end
+  def aggregate_failures?(node = T.unsafe(nil)); end
-  def aggregate_failures_block?(node = _); end
+  def aggregate_failures_block?(node = T.unsafe(nil)); end
-  def aggregate_failures_present?(node = _); end
+  def aggregate_failures_present?(node = T.unsafe(nil)); end
-  def expect?(node = _); end
+  def expect?(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -990,8 +999,8 @@ RuboCop::Cop::RSpec::MultipleSubjects::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::RSpec::NamedSubject < ::RuboCop::Cop::RSpec::Cop
   def ignored_shared_example?(node); end
   def on_block(node); end
-  def rspec_block?(node = _); end
+  def rspec_block?(node = T.unsafe(nil)); end
-  def shared_example?(node = _); end
+  def shared_example?(node = T.unsafe(nil)); end
   def subject_usage(node0); end
 end
 
@@ -1005,7 +1014,7 @@ class RuboCop::Cop::RSpec::NestedGroups < ::RuboCop::Cop::RSpec::Cop
 
   private
 
-  def find_nested_example_groups(node, nesting: _, &block); end
+  def find_nested_example_groups(node, nesting: T.unsafe(nil), &block); end
   def max_nesting; end
   def max_nesting_config; end
   def message(nesting); end
@@ -1021,7 +1030,7 @@ class RuboCop::Cop::RSpec::NotToNot < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::ConfigurableEnforcedStyle)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def not_to_not_offense(node = _, param1); end
+  def not_to_not_offense(node = T.unsafe(nil), param1); end
   def on_send(node); end
 
   private
@@ -1032,9 +1041,9 @@ end
 RuboCop::Cop::RSpec::NotToNot::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::OverwritingSetup < ::RuboCop::Cop::RSpec::Cop
-  def first_argument_name(node = _); end
+  def first_argument_name(node = T.unsafe(nil)); end
   def on_block(node); end
-  def setup?(node = _); end
+  def setup?(node = T.unsafe(nil)); end
 
   private
 
@@ -1046,10 +1055,10 @@ RuboCop::Cop::RSpec::OverwritingSetup::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::Pending < ::RuboCop::Cop::RSpec::Cop
   def on_send(node); end
-  def pending_block?(node = _); end
+  def pending_block?(node = T.unsafe(nil)); end
-  def skip_or_pending?(node = _); end
+  def skip_or_pending?(node = T.unsafe(nil)); end
-  def skippable?(node = _); end
+  def skippable?(node = T.unsafe(nil)); end
-  def skipped_in_metadata?(node = _); end
+  def skipped_in_metadata?(node = T.unsafe(nil)); end
 
   private
 
@@ -1082,7 +1091,7 @@ class RuboCop::Cop::RSpec::ReceiveCounts < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_send(node); end
-  def receive_counts(node = _); end
+  def receive_counts(node = T.unsafe(nil)); end
   def stub?(node0); end
 
   private
@@ -1131,12 +1140,12 @@ end
 RuboCop::Cop::RSpec::RepeatedExample::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::RepeatedExampleGroupBody < ::RuboCop::Cop::RSpec::Cop
-  def body(node = _); end
+  def body(node = T.unsafe(nil)); end
-  def const_arg(node = _); end
+  def const_arg(node = T.unsafe(nil)); end
-  def metadata(node = _); end
+  def metadata(node = T.unsafe(nil)); end
   def on_begin(node); end
-  def several_example_groups?(node = _); end
+  def several_example_groups?(node = T.unsafe(nil)); end
-  def skip_or_pending?(node = _); end
+  def skip_or_pending?(node = T.unsafe(nil)); end
 
   private
 
@@ -1149,11 +1158,11 @@ end
 RuboCop::Cop::RSpec::RepeatedExampleGroupBody::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::RepeatedExampleGroupDescription < ::RuboCop::Cop::RSpec::Cop
-  def doc_string_and_metadata(node = _); end
+  def doc_string_and_metadata(node = T.unsafe(nil)); end
-  def empty_description?(node = _); end
+  def empty_description?(node = T.unsafe(nil)); end
   def on_begin(node); end
-  def several_example_groups?(node = _); end
+  def several_example_groups?(node = T.unsafe(nil)); end
-  def skip_or_pending?(node = _); end
+  def skip_or_pending?(node = T.unsafe(nil)); end
 
   private
 
@@ -1172,7 +1181,7 @@ class RuboCop::Cop::RSpec::ReturnFromStub < ::RuboCop::Cop::RSpec::Cop
   def contains_stub?(node0); end
   def on_block(node); end
   def on_send(node); end
-  def stub_with_block?(node = _); end
+  def stub_with_block?(node = T.unsafe(nil)); end
 
   private
 
@@ -1243,8 +1252,8 @@ class RuboCop::Cop::RSpec::SharedContext < ::RuboCop::Cop::RSpec::Cop
   def context?(node0); end
   def examples?(node0); end
   def on_block(node); end
-  def shared_context(node = _); end
+  def shared_context(node = T.unsafe(nil)); end
-  def shared_example(node = _); end
+  def shared_example(node = T.unsafe(nil)); end
 
   private
 
@@ -1260,7 +1269,7 @@ class RuboCop::Cop::RSpec::SharedExamples < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
   def on_send(node); end
-  def shared_examples(node = _); end
+  def shared_examples(node = T.unsafe(nil)); end
 end
 
 class RuboCop::Cop::RSpec::SharedExamples::Checker
@@ -1281,9 +1290,9 @@ RuboCop::Cop::RSpec::SharedExamples::Checker::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::RSpec::SingleArgumentMessageChain < ::RuboCop::Cop::RSpec::Cop
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def message_chain(node = _); end
+  def message_chain(node = T.unsafe(nil)); end
   def on_send(node); end
-  def single_key_hash?(node = _); end
+  def single_key_hash?(node = T.unsafe(nil)); end
 
   private
 
@@ -1301,15 +1310,15 @@ RuboCop::Cop::RSpec::SingleArgumentMessageChain::MSG = T.let(T.unsafe(nil), Stri
 class RuboCop::Cop::RSpec::SubjectStub < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::RSpec::TopLevelGroup)
 
-  def message_expectation?(node = _, param1); end
+  def message_expectation?(node = T.unsafe(nil), param1); end
   def message_expectation_matcher?(node0); end
   def on_top_level_group(node); end
-  def subject(node = _); end
+  def subject(node = T.unsafe(nil)); end
 
   private
 
   def find_all_explicit_subjects(node); end
-  def find_subject_expectations(node, subject_names = _, &block); end
+  def find_subject_expectations(node, subject_names = T.unsafe(nil), &block); end
 end
 
 RuboCop::Cop::RSpec::SubjectStub::MSG = T.let(T.unsafe(nil), String)
@@ -1317,7 +1326,7 @@ RuboCop::Cop::RSpec::SubjectStub::MSG = T.let(T.unsafe(nil), String)
 class RuboCop::Cop::RSpec::UnspecifiedException < ::RuboCop::Cop::RSpec::Cop
   def block_with_args?(node); end
   def empty_exception_matcher?(node); end
-  def empty_raise_error_or_exception(node = _); end
+  def empty_raise_error_or_exception(node = T.unsafe(nil)); end
   def on_send(node); end
 end
 
@@ -1355,7 +1364,7 @@ RuboCop::Cop::RSpec::VariableName::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::VerifiedDoubles < ::RuboCop::Cop::RSpec::Cop
   def on_send(node); end
-  def unverified_double(node = _); end
+  def unverified_double(node = T.unsafe(nil)); end
 
   private
 
@@ -1365,8 +1374,8 @@ end
 RuboCop::Cop::RSpec::VerifiedDoubles::MSG = T.let(T.unsafe(nil), String)
 
 class RuboCop::Cop::RSpec::VoidExpect < ::RuboCop::Cop::RSpec::Cop
-  def expect?(node = _); end
+  def expect?(node = T.unsafe(nil)); end
-  def expect_block?(node = _); end
+  def expect_block?(node = T.unsafe(nil)); end
   def on_block(node); end
   def on_send(node); end
 
@@ -1382,8 +1391,8 @@ class RuboCop::Cop::RSpec::Yield < ::RuboCop::Cop::RSpec::Cop
   include(::RuboCop::Cop::RangeHelp)
   extend(::RuboCop::Cop::AutoCorrector)
 
-  def block_arg(node = _); end
+  def block_arg(node = T.unsafe(nil)); end
-  def block_call?(node = _, param1); end
+  def block_call?(node = T.unsafe(nil), param1); end
   def method_on_stub?(node0); end
   def on_block(node); end
 
@@ -1477,9 +1486,9 @@ end
 class RuboCop::RSpec::Example < ::RuboCop::RSpec::Concept
   def definition; end
   def doc_string; end
-  def extract_doc_string(node = _); end
+  def extract_doc_string(node = T.unsafe(nil)); end
-  def extract_implementation(node = _); end
+  def extract_implementation(node = T.unsafe(nil)); end
-  def extract_metadata(node = _); end
+  def extract_metadata(node = T.unsafe(nil)); end
   def implementation; end
   def metadata; end
 end
@@ -1488,7 +1497,7 @@ class RuboCop::RSpec::ExampleGroup < ::RuboCop::RSpec::Concept
   def examples; end
   def hooks; end
   def lets; end
-  def scope_change?(node = _); end
+  def scope_change?(node = T.unsafe(nil)); end
   def subjects; end
 
   private
@@ -1498,8 +1507,10 @@ class RuboCop::RSpec::ExampleGroup < ::RuboCop::RSpec::Concept
 end
 
 module RuboCop::RSpec::FactoryBot
-  def self.attribute_defining_methods; end
+  class << self
-  def self.reserved_methods; end
+    def attribute_defining_methods; end
+    def reserved_methods; end
+  end
 end
 
 module RuboCop::RSpec::FinalEndLocation
@@ -1508,7 +1519,7 @@ end
 
 class RuboCop::RSpec::Hook < ::RuboCop::RSpec::Concept
   def example?; end
-  def extract_metadata(node = _); end
+  def extract_metadata(node = T.unsafe(nil)); end
   def knowable_scope?; end
   def metadata; end
   def name; end
@@ -1524,7 +1535,9 @@ class RuboCop::RSpec::Hook < ::RuboCop::RSpec::Concept
 end
 
 module RuboCop::RSpec::Inject
-  def self.defaults!; end
+  class << self
+    def defaults!; end
+  end
 end
 
 module RuboCop::RSpec::Language
@@ -1588,14 +1601,14 @@ RuboCop::RSpec::Language::Includes::EXAMPLES = T.let(T.unsafe(nil), RuboCop::RSp
 module RuboCop::RSpec::Language::NodePattern
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def example?(node = _); end
+  def example?(node = T.unsafe(nil)); end
-  def example_group?(node = _); end
+  def example_group?(node = T.unsafe(nil)); end
-  def example_group_with_body?(node = _); end
+  def example_group_with_body?(node = T.unsafe(nil)); end
-  def hook?(node = _); end
+  def hook?(node = T.unsafe(nil)); end
-  def let?(node = _); end
+  def let?(node = T.unsafe(nil)); end
-  def shared_group?(node = _); end
+  def shared_group?(node = T.unsafe(nil)); end
-  def spec_group?(node = _); end
+  def spec_group?(node = T.unsafe(nil)); end
-  def subject?(node = _); end
+  def subject?(node = T.unsafe(nil)); end
 end
 
 RuboCop::RSpec::Language::RSPEC = T.let(T.unsafe(nil), String)
@@ -1659,7 +1672,7 @@ module RuboCop::RSpec::TopLevelGroup
   include(::RuboCop::RSpec::Language)
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def example_or_shared_group?(node = _); end
+  def example_or_shared_group?(node = T.unsafe(nil)); end
   def on_block(node); end
 
   private
@@ -1674,7 +1687,7 @@ module RuboCop::RSpec::Variable
   include(::RuboCop::RSpec::Language)
   extend(::RuboCop::AST::NodePattern::Macros)
 
-  def variable_definition?(node = _); end
+  def variable_definition?(node = T.unsafe(nil)); end
 end
 
 module RuboCop::RSpec::Version

Library/Homebrew/sorbet/rbi/gems/ruby-macho@2.2.0.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `ruby-macho` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.10.1.rbi

@@ -1,16 +1,19 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `ruby-progressbar` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 class ProgressBar
-  def self.create(*args); end
+  class << self
+    def create(*args); end
+  end
 end
 
 class ProgressBar::Base
   extend(::Forwardable)
 
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def clear(*args, &block); end
   def decrement; end
@@ -30,14 +33,14 @@ class ProgressBar::Base
   def remainder_mark=(mark); end
   def reset; end
   def resume; end
-  def start(options = _); end
+  def start(options = T.unsafe(nil)); end
   def started?; end
   def stop; end
   def stopped?; end
   def title; end
   def title=(title); end
   def to_h; end
-  def to_s(new_format = _); end
+  def to_s(new_format = T.unsafe(nil)); end
   def total(*args, &block); end
   def total=(new_total); end
 
@@ -72,7 +75,7 @@ module ProgressBar::Calculators
 end
 
 class ProgressBar::Calculators::Length
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def calculate_length; end
   def current_length; end
@@ -98,14 +101,16 @@ class ProgressBar::Calculators::Length
 end
 
 class ProgressBar::Calculators::RunningAverage
-  def self.calculate(current_average, new_value_to_average, smoothing_factor); end
+  class << self
+    def calculate(current_average, new_value_to_average, smoothing_factor); end
+  end
 end
 
 module ProgressBar::Components
 end
 
 class ProgressBar::Components::Bar
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def length; end
   def length=(_); end
@@ -115,7 +120,7 @@ class ProgressBar::Components::Bar
   def progress_mark=(_); end
   def remainder_mark; end
   def remainder_mark=(_); end
-  def to_s(options = _); end
+  def to_s(options = T.unsafe(nil)); end
   def upa_steps; end
   def upa_steps=(_); end
 
@@ -141,7 +146,7 @@ ProgressBar::Components::Bar::DEFAULT_REMAINDER_MARK = T.let(T.unsafe(nil), Stri
 ProgressBar::Components::Bar::DEFAULT_UPA_STEPS = T.let(T.unsafe(nil), Array)
 
 class ProgressBar::Components::Percentage
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def progress; end
   def progress=(_); end
@@ -155,7 +160,7 @@ class ProgressBar::Components::Percentage
 end
 
 class ProgressBar::Components::Rate
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def progress; end
   def progress=(_); end
@@ -172,13 +177,13 @@ class ProgressBar::Components::Rate
 
   def base_rate; end
   def elapsed_seconds; end
-  def rate_of_change(format_string = _); end
+  def rate_of_change(format_string = T.unsafe(nil)); end
   def rate_of_change_with_precision; end
   def scaled_rate; end
 end
 
 class ProgressBar::Components::Time
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def elapsed_with_label; end
   def estimated_with_label; end
@@ -221,7 +226,7 @@ ProgressBar::Components::Time::OOB_UNKNOWN_TIME_TEXT = T.let(T.unsafe(nil), Stri
 ProgressBar::Components::Time::TIME_FORMAT = T.let(T.unsafe(nil), String)
 
 class ProgressBar::Components::Title
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def title; end
   def title=(_); end
@@ -233,7 +238,9 @@ module ProgressBar::Format
 end
 
 class ProgressBar::Format::Formatter
-  def self.process(format_string, max_length, bar); end
+  class << self
+    def process(format_string, max_length, bar); end
+  end
 end
 
 class ProgressBar::Format::Molecule
@@ -243,7 +250,7 @@ class ProgressBar::Format::Molecule
   def full_key; end
   def key; end
   def key=(_); end
-  def lookup_value(environment, length = _); end
+  def lookup_value(environment, length = T.unsafe(nil)); end
   def method_name; end
   def method_name=(_); end
   def non_bar_molecule?; end
@@ -269,12 +276,12 @@ class ProgressBar::InvalidProgressError < ::RuntimeError
 end
 
 class ProgressBar::Output
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def clear_string; end
   def length; end
   def log(string); end
-  def refresh(options = _); end
+  def refresh(options = T.unsafe(nil)); end
   def stream; end
   def stream=(_); end
   def with_refresh; end
@@ -292,7 +299,9 @@ class ProgressBar::Output
 
   def print_and_flush; end
 
-  def self.detect(options = _); end
+  class << self
+    def detect(options = T.unsafe(nil)); end
+  end
 end
 
 ProgressBar::Output::DEFAULT_OUTPUT_STREAM = T.let(T.unsafe(nil), IO)
@@ -328,7 +337,7 @@ end
 ProgressBar::Outputs::Tty::DEFAULT_FORMAT_STRING = T.let(T.unsafe(nil), String)
 
 class ProgressBar::Progress
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def absolute; end
   def decrement; end
@@ -345,7 +354,7 @@ class ProgressBar::Progress
   def running_average=(_); end
   def smoothing; end
   def smoothing=(_); end
-  def start(options = _); end
+  def start(options = T.unsafe(nil)); end
   def starting_position; end
   def starting_position=(_); end
   def total; end
@@ -367,9 +376,9 @@ module ProgressBar::Refinements::Enumerator
 end
 
 class ProgressBar::Throttle
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
-  def choke(options = _); end
+  def choke(options = T.unsafe(nil)); end
   def rate; end
   def rate=(_); end
   def started_at; end
@@ -381,7 +390,7 @@ class ProgressBar::Throttle
 end
 
 class ProgressBar::Time
-  def initialize(time = _); end
+  def initialize(time = T.unsafe(nil)); end
 
   def now; end
   def unmocked_time_method; end
@@ -395,7 +404,7 @@ end
 ProgressBar::Time::TIME_MOCKING_LIBRARY_METHODS = T.let(T.unsafe(nil), Array)
 
 class ProgressBar::Timer
-  def initialize(options = _); end
+  def initialize(options = T.unsafe(nil)); end
 
   def divide_seconds(seconds); end
   def elapsed_seconds; end

Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.12.2.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync --exclude json
+# This is an autogenerated file for types exported from the `simplecov-html` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/simplecov@0.18.5.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync --exclude json
+# This is an autogenerated file for types exported from the `simplecov` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/thor@1.0.1.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `thor` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -10,52 +11,74 @@ class Thor
   extend(::Thor::Base::ClassMethods)
   extend(::Thor::Invocation::ClassMethods)
 
-  def help(command = _, subcommand = _); end
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
 
-  def self.check_unknown_options!(options = _); end
+  class << self
-  def self.check_unknown_options?(config); end
+    def check_unknown_options!(options = T.unsafe(nil)); end
-  def self.command_help(shell, command_name); end
+    def check_unknown_options?(config); end
-  def self.default_command(meth = _); end
+    def command_help(shell, command_name); end
-  def self.default_task(meth = _); end
+    def default_command(meth = T.unsafe(nil)); end
-  def self.deprecation_warning(message); end
+    def default_task(meth = T.unsafe(nil)); end
-  def self.desc(usage, description, options = _); end
+    def deprecation_warning(message); end
-  def self.disable_required_check!(*command_names); end
+    def desc(usage, description, options = T.unsafe(nil)); end
-  def self.disable_required_check?(command); end
+    def disable_required_check!(*command_names); end
-  def self.help(shell, subcommand = _); end
+    def disable_required_check?(command); end
-  def self.long_desc(long_description, options = _); end
+    def help(shell, subcommand = T.unsafe(nil)); end
-  def self.map(mappings = _, **kw); end
+    def long_desc(long_description, options = T.unsafe(nil)); end
-  def self.method_option(name, options = _); end
+    def map(mappings = T.unsafe(nil), **kw); end
-  def self.method_options(options = _); end
+    def method_option(name, options = T.unsafe(nil)); end
-  def self.option(name, options = _); end
+    def method_options(options = T.unsafe(nil)); end
-  def self.options(options = _); end
+    def option(name, options = T.unsafe(nil)); end
-  def self.package_name(name, _ = _); end
+    def options(options = T.unsafe(nil)); end
-  def self.printable_commands(all = _, subcommand = _); end
+    def package_name(name, _ = T.unsafe(nil)); end
-  def self.printable_tasks(all = _, subcommand = _); end
+    def printable_commands(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end
-  def self.register(klass, subcommand_name, usage, description, options = _); end
+    def printable_tasks(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end
-  def self.stop_on_unknown_option!(*command_names); end
+    def register(klass, subcommand_name, usage, description, options = T.unsafe(nil)); end
-  def self.stop_on_unknown_option?(command); end
+    def stop_on_unknown_option!(*command_names); end
-  def self.subcommand(subcommand, subcommand_class); end
+    def stop_on_unknown_option?(command); end
-  def self.subcommand_classes; end
+    def subcommand(subcommand, subcommand_class); end
-  def self.subcommands; end
+    def subcommand_classes; end
-  def self.subtask(subcommand, subcommand_class); end
+    def subcommands; end
-  def self.subtasks; end
+    def subtask(subcommand, subcommand_class); end
-  def self.task_help(shell, command_name); end
+    def subtasks; end
+    def task_help(shell, command_name); end
+
+    protected
+
+    def banner(command, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+    def baseclass; end
+    def create_command(meth); end
+    def create_task(meth); end
+    def disable_required_check; end
+    def dispatch(meth, given_args, given_opts, config); end
+    def dynamic_command_class; end
+    def find_command_possibilities(meth); end
+    def find_task_possibilities(meth); end
+    def initialize_added; end
+    def normalize_command_name(meth); end
+    def normalize_task_name(meth); end
+    def retrieve_command_name(args); end
+    def retrieve_task_name(args); end
+    def stop_on_unknown_option; end
+    def subcommand_help(cmd); end
+    def subtask_help(cmd); end
+  end
 end
 
 module Thor::Actions
   mixes_in_class_methods(::Thor::Actions::ClassMethods)
 
-  def initialize(args = _, options = _, config = _); end
+  def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end
 
   def action(instance); end
   def add_file(destination, *args, &block); end
   def add_link(destination, *args); end
   def append_file(path, *args, &block); end
   def append_to_file(path, *args, &block); end
-  def apply(path, config = _); end
+  def apply(path, config = T.unsafe(nil)); end
   def behavior; end
   def behavior=(_); end
-  def chmod(path, mode, config = _); end
+  def chmod(path, mode, config = T.unsafe(nil)); end
   def comment_lines(path, flag, *args); end
   def copy_file(source, *args, &block); end
   def create_file(destination, *args, &block); end
@@ -63,7 +86,7 @@ module Thor::Actions
   def destination_root; end
   def destination_root=(root); end
   def directory(source, *args, &block); end
-  def empty_directory(destination, config = _); end
+  def empty_directory(destination, config = T.unsafe(nil)); end
   def find_in_source_paths(file); end
   def get(source, *args, &block); end
   def gsub_file(path, flag, *args, &block); end
@@ -72,15 +95,15 @@ module Thor::Actions
   def inject_into_file(destination, *args, &block); end
   def inject_into_module(path, module_name, *args, &block); end
   def insert_into_file(destination, *args, &block); end
-  def inside(dir = _, config = _, &block); end
+  def inside(dir = T.unsafe(nil), config = T.unsafe(nil), &block); end
   def link_file(source, *args); end
   def prepend_file(path, *args, &block); end
   def prepend_to_file(path, *args, &block); end
-  def relative_to_original_destination_root(path, remove_dot = _); end
+  def relative_to_original_destination_root(path, remove_dot = T.unsafe(nil)); end
-  def remove_dir(path, config = _); end
+  def remove_dir(path, config = T.unsafe(nil)); end
-  def remove_file(path, config = _); end
+  def remove_file(path, config = T.unsafe(nil)); end
-  def run(command, config = _); end
+  def run(command, config = T.unsafe(nil)); end
-  def run_ruby_script(command, config = _); end
+  def run_ruby_script(command, config = T.unsafe(nil)); end
   def source_paths; end
   def template(source, *args, &block); end
   def thor(command, *args); end
@@ -97,24 +120,26 @@ module Thor::Actions
   def concat(string); end
   def output_buffer; end
   def output_buffer=(_); end
-  def with_output_buffer(buf = _); end
+  def with_output_buffer(buf = T.unsafe(nil)); end
 
-  def self.included(base); end
+  class << self
+    def included(base); end
+  end
 end
 
 class Thor::Actions::CapturableERB < ::ERB
-  def set_eoutvar(compiler, eoutvar = _); end
+  def set_eoutvar(compiler, eoutvar = T.unsafe(nil)); end
 end
 
 module Thor::Actions::ClassMethods
   def add_runtime_options!; end
   def source_paths; end
   def source_paths_for_search; end
-  def source_root(path = _); end
+  def source_root(path = T.unsafe(nil)); end
 end
 
 class Thor::Actions::CreateFile < ::Thor::Actions::EmptyDirectory
-  def initialize(base, destination, data, config = _); end
+  def initialize(base, destination, data, config = T.unsafe(nil)); end
 
   def data; end
   def identical?; end
@@ -136,7 +161,7 @@ class Thor::Actions::CreateLink < ::Thor::Actions::CreateFile
 end
 
 class Thor::Actions::Directory < ::Thor::Actions::EmptyDirectory
-  def initialize(base, source, destination = _, config = _, &block); end
+  def initialize(base, source, destination = T.unsafe(nil), config = T.unsafe(nil), &block); end
 
   def invoke!; end
   def revoke!; end
@@ -150,7 +175,7 @@ class Thor::Actions::Directory < ::Thor::Actions::EmptyDirectory
 end
 
 class Thor::Actions::EmptyDirectory
-  def initialize(base, destination, config = _); end
+  def initialize(base, destination, config = T.unsafe(nil)); end
 
   def base; end
   def config; end
@@ -184,7 +209,7 @@ class Thor::Actions::InjectIntoFile < ::Thor::Actions::EmptyDirectory
   protected
 
   def replace!(regexp, string, force); end
-  def say_status(behavior, warning: _, color: _); end
+  def say_status(behavior, warning: T.unsafe(nil), color: T.unsafe(nil)); end
 end
 
 Thor::Actions::WARNINGS = T.let(T.unsafe(nil), Hash)
@@ -195,7 +220,7 @@ end
 Thor::AmbiguousTaskError = Thor::AmbiguousCommandError
 
 class Thor::Argument
-  def initialize(name, options = _); end
+  def initialize(name, options = T.unsafe(nil)); end
 
   def banner; end
   def default; end
@@ -219,7 +244,7 @@ end
 Thor::Argument::VALID_TYPES = T.let(T.unsafe(nil), Array)
 
 class Thor::Arguments
-  def initialize(arguments = _); end
+  def initialize(arguments = T.unsafe(nil)); end
 
   def parse(args); end
   def remaining; end
@@ -238,8 +263,10 @@ class Thor::Arguments
   def shift; end
   def unshift(arg); end
 
-  def self.parse(*args); end
+  class << self
-  def self.split(args); end
+    def parse(*args); end
+    def split(args); end
+  end
 end
 
 Thor::Arguments::NUMERIC = T.let(T.unsafe(nil), Regexp)
@@ -250,7 +277,7 @@ module Thor::Base
 
   mixes_in_class_methods(::Thor::Base::ClassMethods)
 
-  def initialize(args = _, local_options = _, config = _); end
+  def initialize(args = T.unsafe(nil), local_options = T.unsafe(nil), config = T.unsafe(nil)); end
 
   def args; end
   def args=(_); end
@@ -259,19 +286,21 @@ module Thor::Base
   def parent_options; end
   def parent_options=(_); end
 
-  def self.included(base); end
+  class << self
-  def self.register_klass_file(klass); end
+    def included(base); end
-  def self.shell; end
+    def register_klass_file(klass); end
-  def self.shell=(_); end
+    def shell; end
-  def self.subclass_files; end
+    def shell=(_); end
-  def self.subclasses; end
+    def subclass_files; end
+    def subclasses; end
+  end
 end
 
 module Thor::Base::ClassMethods
   def all_commands; end
   def all_tasks; end
   def allow_incompatible_default_type!; end
-  def argument(name, options = _); end
+  def argument(name, options = T.unsafe(nil)); end
   def arguments; end
   def attr_accessor(*_); end
   def attr_reader(*_); end
@@ -281,16 +310,16 @@ module Thor::Base::ClassMethods
   def check_unknown_options; end
   def check_unknown_options!; end
   def check_unknown_options?(config); end
-  def class_option(name, options = _); end
+  def class_option(name, options = T.unsafe(nil)); end
-  def class_options(options = _); end
+  def class_options(options = T.unsafe(nil)); end
   def commands; end
   def disable_required_check?(command_name); end
   def exit_on_failure?; end
-  def group(name = _); end
+  def group(name = T.unsafe(nil)); end
   def handle_argument_error(command, error, args, arity); end
-  def handle_no_command_error(command, has_namespace = _); end
+  def handle_no_command_error(command, has_namespace = T.unsafe(nil)); end
-  def handle_no_task_error(command, has_namespace = _); end
+  def handle_no_task_error(command, has_namespace = T.unsafe(nil)); end
-  def namespace(name = _); end
+  def namespace(name = T.unsafe(nil)); end
   def no_commands(&block); end
   def no_commands?; end
   def no_commands_context; end
@@ -301,7 +330,7 @@ module Thor::Base::ClassMethods
   def remove_class_option(*names); end
   def remove_command(*names); end
   def remove_task(*names); end
-  def start(given_args = _, config = _); end
+  def start(given_args = T.unsafe(nil), config = T.unsafe(nil)); end
   def stop_on_unknown_option?(command_name); end
   def strict_args_position; end
   def strict_args_position!; end
@@ -314,26 +343,26 @@ module Thor::Base::ClassMethods
   def basename; end
   def build_option(name, options, scope); end
   def build_options(options, scope); end
-  def class_options_help(shell, groups = _); end
+  def class_options_help(shell, groups = T.unsafe(nil)); end
   def create_command(meth); end
   def create_task(meth); end
   def dispatch(command, given_args, given_opts, config); end
   def find_and_refresh_command(name); end
   def find_and_refresh_task(name); end
-  def from_superclass(method, default = _); end
+  def from_superclass(method, default = T.unsafe(nil)); end
   def inherited(klass); end
   def initialize_added; end
   def is_thor_reserved_word?(word, type); end
   def method_added(meth); end
-  def print_options(shell, options, group_name = _); end
+  def print_options(shell, options, group_name = T.unsafe(nil)); end
 end
 
 class Thor::Command < ::Struct
-  def initialize(name, description, long_description, usage, options = _); end
+  def initialize(name, description, long_description, usage, options = T.unsafe(nil)); end
 
-  def formatted_usage(klass, namespace = _, subcommand = _); end
+  def formatted_usage(klass, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end
   def hidden?; end
-  def run(instance, args = _); end
+  def run(instance, args = T.unsafe(nil)); end
 
   protected
 
@@ -358,7 +387,7 @@ module Thor::CoreExt
 end
 
 class Thor::CoreExt::HashWithIndifferentAccess < ::Hash
-  def initialize(hash = _); end
+  def initialize(hash = T.unsafe(nil)); end
 
   def [](key); end
   def []=(key, value); end
@@ -382,9 +411,9 @@ end
 Thor::Correctable = DidYouMean::Correctable
 
 class Thor::DynamicCommand < ::Thor::Command
-  def initialize(name, options = _); end
+  def initialize(name, options = T.unsafe(nil)); end
 
-  def run(instance, args = _); end
+  def run(instance, args = T.unsafe(nil)); end
 end
 
 Thor::DynamicTask = Thor::DynamicCommand
@@ -402,20 +431,32 @@ class Thor::Group
 
   protected
 
-  def _invoke_for_class_method(klass, command = _, *args, &block); end
+  def _invoke_for_class_method(klass, command = T.unsafe(nil), *args, &block); end
 
-  def self.class_options_help(shell, groups = _); end
+  class << self
-  def self.desc(description = _); end
+    def class_options_help(shell, groups = T.unsafe(nil)); end
-  def self.get_options_from_invocations(group_options, base_options); end
+    def desc(description = T.unsafe(nil)); end
-  def self.handle_argument_error(command, error, _args, arity); end
+    def get_options_from_invocations(group_options, base_options); end
-  def self.help(shell); end
+    def handle_argument_error(command, error, _args, arity); end
-  def self.invocation_blocks; end
+    def help(shell); end
-  def self.invocations; end
+    def invocation_blocks; end
-  def self.invoke(*names, &block); end
+    def invocations; end
-  def self.invoke_from_option(*names, &block); end
+    def invoke(*names, &block); end
-  def self.printable_commands(*_); end
+    def invoke_from_option(*names, &block); end
-  def self.printable_tasks(*_); end
+    def printable_commands(*_); end
-  def self.remove_invocation(*names); end
+    def printable_tasks(*_); end
+    def remove_invocation(*names); end
+
+    protected
+
+    def banner; end
+    def baseclass; end
+    def create_command(meth); end
+    def create_task(meth); end
+    def dispatch(command, given_args, given_opts, config); end
+    def self_command; end
+    def self_task; end
+  end
 end
 
 Thor::HELP_MAPPINGS = T.let(T.unsafe(nil), Array)
@@ -429,10 +470,10 @@ Thor::HiddenTask = Thor::HiddenCommand
 module Thor::Invocation
   mixes_in_class_methods(::Thor::Invocation::ClassMethods)
 
-  def initialize(args = _, options = _, config = _, &block); end
+  def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil), &block); end
 
   def current_command_chain; end
-  def invoke(name = _, *args); end
+  def invoke(name = T.unsafe(nil), *args); end
   def invoke_all; end
   def invoke_command(command, *args); end
   def invoke_task(command, *args); end
@@ -441,11 +482,13 @@ module Thor::Invocation
   protected
 
   def _parse_initialization_options(args, opts, config); end
-  def _retrieve_class_and_command(name, sent_command = _); end
+  def _retrieve_class_and_command(name, sent_command = T.unsafe(nil)); end
-  def _retrieve_class_and_task(name, sent_command = _); end
+  def _retrieve_class_and_task(name, sent_command = T.unsafe(nil)); end
   def _shared_configuration; end
 
-  def self.included(base); end
+  class << self
+    def included(base); end
+  end
 end
 
 module Thor::Invocation::ClassMethods
@@ -456,8 +499,10 @@ class Thor::InvocationError < ::Thor::Error
 end
 
 module Thor::LineEditor
-  def self.best_available; end
+  class << self
-  def self.readline(prompt, options = _); end
+    def best_available; end
+    def readline(prompt, options = T.unsafe(nil)); end
+  end
 end
 
 class Thor::LineEditor::Basic
@@ -472,7 +517,9 @@ class Thor::LineEditor::Basic
   def echo?; end
   def get_input; end
 
-  def self.available?; end
+  class << self
+    def available?; end
+  end
 end
 
 class Thor::LineEditor::Readline < ::Thor::LineEditor::Basic
@@ -485,7 +532,9 @@ class Thor::LineEditor::Readline < ::Thor::LineEditor::Basic
   def completion_proc; end
   def use_path_completion?; end
 
-  def self.available?; end
+  class << self
+    def available?; end
+  end
 end
 
 class Thor::LineEditor::Readline::PathCompletion
@@ -522,7 +571,7 @@ class Thor::NoKwargSpellChecker < ::DidYouMean::SpellChecker
 end
 
 class Thor::Option < ::Thor::Argument
-  def initialize(name, options = _); end
+  def initialize(name, options = T.unsafe(nil)); end
 
   def aliases; end
   def array?; end
@@ -536,7 +585,7 @@ class Thor::Option < ::Thor::Argument
   def repeatable; end
   def string?; end
   def switch_name; end
-  def usage(padding = _); end
+  def usage(padding = T.unsafe(nil)); end
 
   protected
 
@@ -546,13 +595,15 @@ class Thor::Option < ::Thor::Argument
   def validate!; end
   def validate_default_type!; end
 
-  def self.parse(key, value); end
+  class << self
+    def parse(key, value); end
+  end
 end
 
 Thor::Option::VALID_TYPES = T.let(T.unsafe(nil), Array)
 
 class Thor::Options < ::Thor::Arguments
-  def initialize(hash_options = _, defaults = _, stop_on_unknown = _, disable_required_check = _); end
+  def initialize(hash_options = T.unsafe(nil), defaults = T.unsafe(nil), stop_on_unknown = T.unsafe(nil), disable_required_check = T.unsafe(nil)); end
 
   def check_unknown!; end
   def parse(args); end
@@ -572,7 +623,9 @@ class Thor::Options < ::Thor::Arguments
   def switch?(arg); end
   def switch_option(arg); end
 
-  def self.to_switches(options); end
+  class << self
+    def to_switches(options); end
+  end
 end
 
 Thor::Options::EQ_RE = T.let(T.unsafe(nil), Regexp)
@@ -594,7 +647,7 @@ module Thor::Sandbox
 end
 
 module Thor::Shell
-  def initialize(args = _, options = _, config = _); end
+  def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end
 
   def ask(*args, &block); end
   def error(*args, &block); end
@@ -625,20 +678,20 @@ class Thor::Shell::Basic
   def base=(_); end
   def error(statement); end
   def file_collision(destination); end
-  def indent(count = _); end
+  def indent(count = T.unsafe(nil)); end
   def mute; end
   def mute?; end
-  def no?(statement, color = _); end
+  def no?(statement, color = T.unsafe(nil)); end
   def padding; end
   def padding=(value); end
   def print_in_columns(array); end
-  def print_table(array, options = _); end
+  def print_table(array, options = T.unsafe(nil)); end
-  def print_wrapped(message, options = _); end
+  def print_wrapped(message, options = T.unsafe(nil)); end
-  def say(message = _, color = _, force_new_line = _); end
+  def say(message = T.unsafe(nil), color = T.unsafe(nil), force_new_line = T.unsafe(nil)); end
-  def say_status(status, message, log_status = _); end
+  def say_status(status, message, log_status = T.unsafe(nil)); end
   def set_color(string, *_); end
   def terminal_width; end
-  def yes?(statement, color = _); end
+  def yes?(statement, color = T.unsafe(nil)); end
 
   protected
 
@@ -716,7 +769,7 @@ Thor::Shell::Color::WHITE = T.let(T.unsafe(nil), String)
 Thor::Shell::Color::YELLOW = T.let(T.unsafe(nil), String)
 
 class Thor::Shell::HTML < ::Thor::Shell::Basic
-  def ask(statement, color = _); end
+  def ask(statement, color = T.unsafe(nil)); end
   def set_color(string, *colors); end
 
   protected
@@ -806,20 +859,22 @@ class Thor::UnknownArgumentError::SpellChecker
 end
 
 module Thor::Util
-  def self.camel_case(str); end
+  class << self
-  def self.escape_globs(path); end
+    def camel_case(str); end
-  def self.escape_html(string); end
+    def escape_globs(path); end
-  def self.find_by_namespace(namespace); end
+    def escape_html(string); end
-  def self.find_class_and_command_by_namespace(namespace, fallback = _); end
+    def find_by_namespace(namespace); end
-  def self.find_class_and_task_by_namespace(namespace, fallback = _); end
+    def find_class_and_command_by_namespace(namespace, fallback = T.unsafe(nil)); end
-  def self.globs_for(path); end
+    def find_class_and_task_by_namespace(namespace, fallback = T.unsafe(nil)); end
-  def self.load_thorfile(path, content = _, debug = _); end
+    def globs_for(path); end
-  def self.namespace_from_thor_class(constant); end
+    def load_thorfile(path, content = T.unsafe(nil), debug = T.unsafe(nil)); end
-  def self.namespaces_in_content(contents, file = _); end
+    def namespace_from_thor_class(constant); end
-  def self.ruby_command; end
+    def namespaces_in_content(contents, file = T.unsafe(nil)); end
-  def self.snake_case(str); end
+    def ruby_command; end
-  def self.thor_classes_in(klass); end
+    def snake_case(str); end
-  def self.thor_root; end
+    def thor_classes_in(klass); end
-  def self.thor_root_glob; end
+    def thor_root; end
-  def self.user_home; end
+    def thor_root_glob; end
+    def user_home; end
+  end
 end

Library/Homebrew/sorbet/rbi/gems/thread_safe@0.3.6.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `thread_safe` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/tzinfo@1.2.7.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `tzinfo` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `unf` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -14,8 +15,10 @@ class UNF::Normalizer
 
   def normalize(_, _); end
 
-  def self.instance; end
+  class << self
-  def self.normalize(string, form); end
+    def instance; end
+    def normalize(string, form); end
+  end
 end
 
 UNF::VERSION = T.let(T.unsafe(nil), String)

Library/Homebrew/sorbet/rbi/gems/unf_ext@0.0.7.7.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `unf_ext` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/gems/unicode-display_width@1.7.0.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `unicode-display_width` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
@@ -7,8 +8,10 @@ module Unicode
 end
 
 module Unicode::DisplayWidth
-  def self.emoji_extra_width_of(string, ambiguous = _, overwrite = _, _ = _); end
+  class << self
-  def self.of(string, ambiguous = _, overwrite = _, options = _); end
+    def emoji_extra_width_of(string, ambiguous = T.unsafe(nil), overwrite = T.unsafe(nil), _ = T.unsafe(nil)); end
+    def of(string, ambiguous = T.unsafe(nil), overwrite = T.unsafe(nil), options = T.unsafe(nil)); end
+  end
 end
 
 Unicode::DisplayWidth::DATA_DIRECTORY = T.let(T.unsafe(nil), String)

Library/Homebrew/sorbet/rbi/gems/webrobots@0.1.2.rbi

@@ -1,16 +1,17 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync
+# This is an autogenerated file for types exported from the `webrobots` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 
 class Nokogiri::HTML::Document < ::Nokogiri::XML::Document
-  def fragment(tags = _); end
+  def fragment(tags = T.unsafe(nil)); end
   def meta_encoding; end
   def meta_encoding=(encoding); end
-  def meta_robots(custom_name = _); end
+  def meta_robots(custom_name = T.unsafe(nil)); end
-  def nofollow?(custom_name = _); end
+  def nofollow?(custom_name = T.unsafe(nil)); end
-  def noindex?(custom_name = _); end
+  def noindex?(custom_name = T.unsafe(nil)); end
-  def serialize(options = _); end
+  def serialize(options = T.unsafe(nil)); end
   def title; end
   def title=(text); end
   def type; end
@@ -21,14 +22,16 @@ class Nokogiri::HTML::Document < ::Nokogiri::XML::Document
   def parse_meta_robots(custom_name); end
   def set_metadata_element(element); end
 
-  def self.new(*_); end
+  class << self
-  def self.parse(string_or_io, url = _, encoding = _, options = _); end
+    def new(*_); end
-  def self.read_io(_, _, _, _); end
+    def parse(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
-  def self.read_memory(_, _, _, _); end
+    def read_io(_, _, _, _); end
+    def read_memory(_, _, _, _); end
+  end
 end
 
 class WebRobots
-  def initialize(user_agent, options = _); end
+  def initialize(user_agent, options = T.unsafe(nil)); end
 
   def allowed?(url); end
   def crawl_delay(url); end
@@ -64,24 +67,26 @@ class WebRobots::ParseError < ::WebRobots::Error
 end
 
 class WebRobots::RobotsTxt
-  def initialize(site, records, options = _); end
+  def initialize(site, records, options = T.unsafe(nil)); end
 
-  def allow?(request_uri, user_agent = _); end
+  def allow?(request_uri, user_agent = T.unsafe(nil)); end
-  def crawl_delay(user_agent = _); end
+  def crawl_delay(user_agent = T.unsafe(nil)); end
   def error; end
   def error!; end
   def error=(_); end
-  def options(user_agent = _); end
+  def options(user_agent = T.unsafe(nil)); end
   def site; end
   def sitemaps; end
   def timestamp; end
 
   private
 
-  def find_record(user_agent = _); end
+  def find_record(user_agent = T.unsafe(nil)); end
-  def target(user_agent = _); end
+  def target(user_agent = T.unsafe(nil)); end
 
-  def self.unfetchable(site, reason, target = _); end
+  class << self
+    def unfetchable(site, reason, target = T.unsafe(nil)); end
+  end
 end
 
 class WebRobots::RobotsTxt::AccessControlLine < ::WebRobots::RobotsTxt::Line
@@ -121,7 +126,7 @@ class WebRobots::RobotsTxt::Line
 end
 
 class WebRobots::RobotsTxt::Parser < ::Racc::Parser
-  def initialize(target, crawl_delay_handler = _); end
+  def initialize(target, crawl_delay_handler = T.unsafe(nil)); end
 
   def _reduce_1(val, _values, result); end
   def _reduce_17(val, _values, result); end

Library/Homebrew/sorbet/rbi/gems/zeitwerk@2.4.0.rbi

@@ -1,5 +1,6 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+# DO NOT EDIT MANUALLY
-#   tapioca sync --exclude json
+# This is an autogenerated file for types exported from the `zeitwerk` gem.
+# Please instead update this file by running `tapioca generate --exclude json`.
 
 # typed: true
 

Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi

@@ -5496,6 +5496,8 @@ class Cask::Cask
 
   def depends_on(&block); end
 
+  def desc(&block); end
+
   def dictionary(&block); end
 
   def font(&block); end
@@ -8090,6 +8092,10 @@ module Homebrew
   MIN_PORT = ::T.let(nil, ::T.untyped)
 end
 
+class Homebrew::CLI::Parser
+  include ::Homebrew::CLI::Parser::Compat
+end
+
 module Homebrew::EnvConfig
   def self.all_proxy(); end
 
@@ -13370,6 +13376,7 @@ class Object
   def to_yaml(options=T.unsafe(nil)); end
   ARGF = ::T.let(nil, ::T.untyped)
   ARGV = ::T.let(nil, ::T.untyped)
+  BUG_REPORTS_URL = ::T.let(nil, ::T.untyped)
   CROSS_COMPILING = ::T.let(nil, ::T.untyped)
   DEPRECATED_OFFICIAL_TAPS = ::T.let(nil, ::T.untyped)
   ENV = ::T.let(nil, ::T.untyped)
@@ -19536,6 +19543,8 @@ class RuboCop::Cask::AST::Stanza
 
   def depends_on?(); end
 
+  def desc?(); end
+
   def dictionary?(); end
 
   def font?(); end
@@ -19613,6 +19622,10 @@ class RuboCop::Cop::Cask::NoDslVersion
   def preferred_header_str(*args, &block); end
 end
 
+module RuboCop::Cop::Cask::OnDescStanza
+  def toplevel_stanzas(*args, &block); end
+end
+
 module RuboCop::Cop::Cask::OnHomepageStanza
   def toplevel_stanzas(*args, &block); end
 end
@@ -21064,6 +21077,7 @@ class SimpleCov::Formatter::Codecov
   CIRCLE = ::T.let(nil, ::T.untyped)
   CODESHIP = ::T.let(nil, ::T.untyped)
   DRONEIO = ::T.let(nil, ::T.untyped)
+  GITHUB = ::T.let(nil, ::T.untyped)
   GITLAB = ::T.let(nil, ::T.untyped)
   HEROKU = ::T.let(nil, ::T.untyped)
   JENKINS = ::T.let(nil, ::T.untyped)
@@ -21995,8 +22009,6 @@ class SystemCommand
   def print_stdout?(); end
 
   def sudo?(); end
-
-  def verbose?(); end
 end
 
 module TZInfo
@@ -22973,42 +22985,6 @@ end
 class Tempfile::Remover
 end
 
-class Thor::Group
-  def self.banner(); end
-
-  def self.self_command(); end
-
-  def self.self_task(); end
-end
-
-class Thor
-  def self.banner(command, namespace=T.unsafe(nil), subcommand=T.unsafe(nil)); end
-
-  def self.disable_required_check(); end
-
-  def self.dispatch(meth, given_args, given_opts, config); end
-
-  def self.dynamic_command_class(); end
-
-  def self.find_command_possibilities(meth); end
-
-  def self.find_task_possibilities(meth); end
-
-  def self.normalize_command_name(meth); end
-
-  def self.normalize_task_name(meth); end
-
-  def self.retrieve_command_name(args); end
-
-  def self.retrieve_task_name(args); end
-
-  def self.stop_on_unknown_option(); end
-
-  def self.subcommand_help(cmd); end
-
-  def self.subtask_help(cmd); end
-end
-
 module ThreadSafe
   NULL = ::T.let(nil, ::T.untyped)
   VERSION = ::T.let(nil, ::T.untyped)