diff --git a/Library/Homebrew/sorbet/files.yaml b/Library/Homebrew/sorbet/files.yaml
index 6ce5e49baf..a1adf058a8 100644
--- a/Library/Homebrew/sorbet/files.yaml
+++ b/Library/Homebrew/sorbet/files.yaml
@@ -604,6 +604,7 @@ false:
   - ./test/options_spec.rb
   - ./test/os/linux/diagnostic_spec.rb
   - ./test/os/linux/formula_spec.rb
+  - ./test/os/linux/pathname_spec.rb
   - ./test/os/mac/dependency_collector_spec.rb
   - ./test/os/mac/java_requirement_spec.rb
   - ./test/os/mac/keg_spec.rb
diff --git a/Library/Homebrew/sorbet/rbi/gems/bindata@2.4.8.rbi b/Library/Homebrew/sorbet/rbi/gems/bindata@2.4.8.rbi
new file mode 100644
index 0000000000..ec2a9f3d63
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/bindata@2.4.8.rbi
@@ -0,0 +1,1137 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync --exclude json
+
+# typed: true
+
+module BinData
+  extend(::BinData::BitFieldFactory)
+  extend(::BinData::IntFactory)
+
+
+  private
+
+  def trace_message; end
+  def trace_reading(io = _); end
+
+  def self.trace_message; end
+  def self.trace_reading(io = _); end
+end
+
+module BinData::AcceptedParametersPlugin
+  def accepted_parameters; end
+  def default_parameter(*args); end
+  def default_parameters(*args); end
+  def mandatory_parameter(*args); end
+  def mandatory_parameters(*args); end
+  def mutually_exclusive_parameters(*args); end
+  def optional_parameter(*args); end
+  def optional_parameters(*args); end
+end
+
+class BinData::AcceptedParametersPlugin::AcceptedParameters
+  def initialize(ancestor_parameters = _); end
+
+  def all; end
+  def default(args = _); end
+  def mandatory(*args); end
+  def mutually_exclusive(*args); end
+  def optional(*args); end
+
+  private
+
+  def ensure_valid_names(names); end
+  def to_syms(args); end
+
+  def self.invalid_parameter_names; end
+end
+
+class BinData::Array < ::BinData::Base
+  include(::Enumerable)
+  extend(::BinData::DSLMixin)
+
+  def <<(*args); end
+  def [](arg1, arg2 = _); end
+  def []=(index, value); end
+  def assign(array); end
+  def at(index); end
+  def clear?; end
+  def concat(array); end
+  def debug_name_of(child); end
+  def do_num_bytes; end
+  def do_write(io); end
+  def each; end
+  def empty?; end
+  def find_index(obj); end
+  def find_index_of(obj); end
+  def first(n = _); end
+  def index(obj); end
+  def initialize_instance; end
+  def initialize_shared_instance; end
+  def insert(index, *objs); end
+  def last(n = _); end
+  def length; end
+  def offset_of(child); end
+  def push(*args); end
+  def size; end
+  def slice(arg1, arg2 = _); end
+  def snapshot; end
+  def to_ary; end
+  def unshift(*args); end
+
+  private
+
+  def append_new_element; end
+  def elements; end
+  def extend_array(max_index); end
+  def new_element; end
+  def slice_index(index); end
+  def slice_range(range); end
+  def slice_start_length(start, length); end
+  def sum_num_bytes_below_index(index); end
+  def sum_num_bytes_for_all_elements; end
+end
+
+class BinData::ArrayArgProcessor < ::BinData::BaseArgProcessor
+  def sanitize_parameters!(obj_class, params); end
+end
+
+class BinData::Base
+  include(::BinData::Framework)
+  include(::BinData::RegisterNamePlugin)
+  extend(::BinData::AcceptedParametersPlugin)
+
+  def initialize(*args); end
+
+  def ==(other); end
+  def =~(other); end
+  def abs_offset; end
+  def base_respond_to?(*_); end
+  def clear; end
+  def debug_name; end
+  def eval_parameter(key, overrides = _); 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 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 to_binary_s(&block); end
+  def to_hex(&block); end
+  def to_s; end
+  def write(io, &block); end
+
+  protected
+
+  def parent=(_); end
+
+  private
+
+  def binary_string(str); end
+  def extract_args(args); end
+  def initialize_without_warning(*args); end
+  def reading?; end
+  def start_read; end
+  def top_level; end
+  def top_level_get(sym); end
+  def top_level_set(sym, value); end
+
+  def self.arg_processor(name = _); end
+  def self.auto_call_delayed_io; end
+  def self.bindata_name; end
+  def self.inherited(subclass); end
+  def self.read(io, *args, &block); end
+end
+
+module BinData::Base::AutoCallDelayedIO
+  def initialize_shared_instance; end
+  def num_bytes; end
+  def read(io); end
+  def write(io, *_); end
+end
+
+class BinData::BaseArgProcessor
+  def extract_args(obj_class, obj_args); end
+  def sanitize_parameters!(obj_class, obj_params); end
+  def separate_args(_obj_class, obj_args); end
+end
+
+class BinData::BasePrimitive < ::BinData::Base
+  def <=>(other); end
+  def assign(val); end
+  def clear?; end
+  def do_num_bytes; end
+  def do_read(io); end
+  def do_read_with_hook(io); end
+  def do_write(io); end
+  def eql?(other); end
+  def hash; end
+  def initialize_instance; end
+  def initialize_shared_instance; end
+  def method_missing(symbol, *args, &block); end
+  def respond_to?(symbol, include_private = _); end
+  def snapshot; end
+  def trace_value; end
+  def value; end
+  def value=(val); end
+
+  private
+
+  def _value; end
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+
+  def self.bit_aligned; end
+  def self.inherited(subclass); end
+  def self.turn_off_tracing; end
+  def self.turn_on_tracing; end
+end
+
+module BinData::BasePrimitive::AssertPlugin
+  def assert!; end
+  def assign(val); end
+  def do_read(io); end
+end
+
+module BinData::BasePrimitive::AssertedValuePlugin
+  def _value; end
+  def assert!; end
+  def assert_value(current_value); end
+  def assign(val); end
+  def do_read(io); end
+end
+
+module BinData::BasePrimitive::InitialValuePlugin
+  def _value; end
+end
+
+module BinData::BasePrimitive::ValuePlugin
+  def _value; end
+  def assign(val); end
+end
+
+class BinData::Bit < ::BinData::BasePrimitive
+  def assign(val); end
+  def bit_aligned?; end
+  def do_num_bytes; end
+  def do_write(io); end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+end
+
+module BinData::BitAligned
+  def bit_aligned?; end
+  def do_num_bytes; end
+  def do_write(io); end
+  def read_and_return_value(io); end
+end
+
+class BinData::BitAligned::BitAlignedIO
+  def initialize(io); end
+
+  def readbytes(n); end
+end
+
+module BinData::BitField
+  def self.create_clamp_code(nbits, signed); end
+  def self.create_do_num_bytes_code(nbits); end
+  def self.create_dynamic_clamp_code(signed); end
+  def self.create_fixed_clamp_code(nbits, signed); end
+  def self.create_int2uint_code(nbits, signed); end
+  def self.create_nbits_code(nbits); end
+  def self.create_params_code(nbits); end
+  def self.create_uint2int_code(nbits, signed); end
+  def self.define_class(name, nbits, endian, signed = _); end
+  def self.define_methods(bit_class, nbits, endian, signed); end
+end
+
+module BinData::BitFieldFactory
+  def const_missing(name); end
+end
+
+class BinData::BitLe < ::BinData::BasePrimitive
+  def assign(val); end
+  def bit_aligned?; end
+  def do_num_bytes; end
+  def do_write(io); end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+end
+
+class BinData::Buffer < ::BinData::Base
+  extend(::BinData::DSLMixin)
+
+  def assign(val); end
+  def clear?; end
+  def do_num_bytes; end
+  def do_read(io); end
+  def do_write(io); end
+  def initialize_instance; end
+  def method_missing(symbol, *args, &block); end
+  def raw_num_bytes; end
+  def respond_to?(symbol, include_private = _); end
+  def snapshot; end
+end
+
+class BinData::BufferArgProcessor < ::BinData::BaseArgProcessor
+  include(::BinData::MultiFieldArgSeparator)
+
+  def sanitize_parameters!(obj_class, params); end
+end
+
+module BinData::ByteAlignPlugin
+  def align_obj?(obj); end
+  def bytes_to_align(obj, rel_offset); end
+  def do_read(io); end
+  def do_write(io); end
+  def sum_num_bytes_below_index(index); end
+end
+
+class BinData::Choice < ::BinData::Base
+  extend(::BinData::DSLMixin)
+
+  def assign(*args); end
+  def clear?(*args); end
+  def do_num_bytes(*args); end
+  def do_read(*args); end
+  def do_read_with_hook(io); end
+  def do_write(*args); end
+  def initialize_instance; end
+  def initialize_shared_instance; end
+  def method_missing(symbol, *args, &block); end
+  def respond_to?(symbol, include_private = _); end
+  def selection; end
+  def snapshot(*args); end
+  def trace_selection; end
+
+  private
+
+  def current_choice; end
+  def instantiate_choice(selection); end
+
+  def self.turn_off_tracing; end
+  def self.turn_on_tracing; end
+end
+
+class BinData::ChoiceArgProcessor < ::BinData::BaseArgProcessor
+  def sanitize_parameters!(obj_class, params); end
+
+  private
+
+  def choices_as_hash(choices); end
+  def ensure_valid_keys(choices); end
+  def key_array_by_index(array); end
+end
+
+module BinData::CopyOnChangePlugin
+  def copy_previous_value(obj); end
+  def current_choice; end
+  def get_previous_choice(selection); end
+  def remember_current_selection(selection); end
+end
+
+class BinData::CountBytesRemaining < ::BinData::BasePrimitive
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+module BinData::DSLMixin
+  def dsl_parser(parser_type = _); 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
+  def self.create_subclasses_with_endian(bnl_class); end
+  def self.delegate_field_creation(bnl_class); end
+  def self.fixup_subclass_hierarchy(bnl_class); end
+  def self.handle(bnl_class); end
+  def self.make_class_abstract(bnl_class); end
+  def self.obj_attribute(obj, attr); end
+  def self.override_new_in_class(bnl_class); end
+end
+
+class BinData::DSLMixin::DSLFieldParser
+  def initialize(hints, symbol, *args, &block); end
+
+  def name; end
+  def name_from_field_declaration(args); end
+  def params; end
+  def params_from_args(args); end
+  def params_from_block(&block); end
+  def params_from_field_declaration(args, &block); end
+  def type; end
+end
+
+class BinData::DSLMixin::DSLFieldValidator
+  def initialize(the_class, parser); end
+
+  def all_or_none_names_failed?(name); end
+  def duplicate_name?(name); end
+  def ensure_valid_name(name); end
+  def fields; end
+  def malformed_name?(name); end
+  def must_have_a_name_failed?(name); end
+  def must_not_have_a_name_failed?(name); end
+  def name_is_reserved?(name); end
+  def name_shadows_method?(name); end
+  def option?(opt); end
+  def validate_field(name); end
+end
+
+class BinData::DSLMixin::DSLParser
+  def initialize(the_class, parser_type); end
+
+  def dsl_params; end
+  def endian(endian = _); end
+  def fields; end
+  def hide(*args); end
+  def method_missing(*args, &block); end
+  def parser_type; end
+  def search_prefix(*args); end
+
+  private
+
+  def append_field(type, name, params); end
+  def dsl_raise(exception, msg); end
+  def ensure_hints; end
+  def fields?; end
+  def hints; end
+  def option?(opt); end
+  def parent_attribute(attr, default = _); end
+  def parent_fields; end
+  def parse_and_append_field(*args, &block); end
+  def parser_abilities; end
+  def set_endian(endian); end
+  def to_choice_params(key); end
+  def to_object_params(key); end
+  def to_struct_params(*unused); end
+  def valid_endian?(endian); end
+end
+
+class BinData::DelayedIO < ::BinData::Base
+  extend(::BinData::DSLMixin)
+
+  def abs_offset; end
+  def abs_offset=(offset); end
+  def assign(val); end
+  def clear?; end
+  def do_num_bytes; end
+  def do_read(io); end
+  def do_write(io); end
+  def initialize_instance; end
+  def method_missing(symbol, *args, &block); end
+  def num_bytes; end
+  def read_now!; end
+  def rel_offset; end
+  def respond_to?(symbol, include_private = _); end
+  def snapshot; end
+  def write_now!; end
+end
+
+class BinData::DelayedIoArgProcessor < ::BinData::BaseArgProcessor
+  include(::BinData::MultiFieldArgSeparator)
+
+  def sanitize_parameters!(obj_class, params); end
+end
+
+class BinData::DoubleBe < ::BinData::BasePrimitive
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+class BinData::DoubleLe < ::BinData::BasePrimitive
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+class BinData::FloatBe < ::BinData::BasePrimitive
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+class BinData::FloatLe < ::BinData::BasePrimitive
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+module BinData::FloatingPoint
+  def self.create_num_bytes_code(precision); end
+  def self.create_read_code(precision, endian); end
+  def self.create_to_binary_s_code(precision, endian); end
+  def self.define_methods(float_class, precision, endian); end
+end
+
+module BinData::Framework
+  def assign(val); end
+  def bit_aligned?; end
+  def clear?; end
+  def debug_name_of(child); end
+  def offset_of(child); end
+  def snapshot; end
+
+  protected
+
+  def do_num_bytes; end
+  def do_read(io); end
+  def do_write(io); end
+  def initialize_instance; end
+  def initialize_shared_instance; end
+end
+
+module BinData::IO
+  def self.create_string_io(str = _); end
+end
+
+module BinData::IO::Common
+  def initialize(io); end
+
+
+  private
+
+  def buffer_limited_n(n); end
+  def seek(n); end
+  def seekable?; end
+  def with_buffer_common(n); end
+end
+
+module BinData::IO::Common::SeekableStream
+  def num_bytes_remaining; end
+  def with_readahead; end
+
+  private
+
+  def offset_raw; end
+  def read_raw(n); end
+  def seek_raw(n); end
+  def stream_init; end
+  def write_raw(data); end
+end
+
+module BinData::IO::Common::UnSeekableStream
+  def num_bytes_remaining; end
+  def offset_raw; end
+  def with_readahead; end
+
+  private
+
+  def read_raw(n); end
+  def read_raw_with_readahead(n); end
+  def seek_raw(n); end
+  def stream_init; end
+  def write_raw(data); end
+end
+
+class BinData::IO::Read
+  include(::BinData::IO::Common)
+
+  def initialize(io); end
+
+  def offset; end
+  def read_all_bytes; end
+  def readbits(nbits, endian); end
+  def readbytes(n); end
+  def reset_read_bits; end
+  def seekbytes(n); end
+  def with_buffer(n); end
+
+  private
+
+  def accumulate_big_endian_bits; end
+  def accumulate_little_endian_bits; end
+  def mask(nbits); end
+  def read(n = _); end
+  def read_big_endian_bits(nbits); end
+  def read_little_endian_bits(nbits); end
+end
+
+class BinData::IO::Write
+  include(::BinData::IO::Common)
+
+  def initialize(io); end
+
+  def flush; end
+  def flushbits; end
+  def offset; end
+  def seekbytes(n); end
+  def with_buffer(n); end
+  def writebits(val, nbits, endian); end
+  def writebytes(str); end
+
+  private
+
+  def mask(nbits); end
+  def write(data); end
+  def write_big_endian_bits(val, nbits); end
+  def write_little_endian_bits(val, nbits); end
+end
+
+module BinData::InitialLengthPlugin
+  def do_read(io); end
+  def elements; end
+end
+
+module BinData::Int
+  def self.define_class(name, nbits, endian, signed); end
+  def self.define_methods(int_class, nbits, endian, signed); end
+end
+
+class BinData::Int32be < ::BinData::BasePrimitive
+  def assign(val); end
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+class BinData::Int32le < ::BinData::BasePrimitive
+  def assign(val); end
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+class BinData::Int64be < ::BinData::BasePrimitive
+  def assign(val); end
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+class BinData::Int64le < ::BinData::BasePrimitive
+  def assign(val); end
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+class BinData::Int8 < ::BinData::BasePrimitive
+  def assign(val); end
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+module BinData::IntFactory
+  def const_missing(name); end
+end
+
+class BinData::LazyEvaluator
+  def initialize(obj); end
+
+  def index; end
+  def lazy_eval(val, overrides = _); end
+  def method_missing(symbol, *args); end
+  def parent; end
+
+  private
+
+  def callable?(obj); end
+  def eval_symbol_in_parent_context(symbol, args); end
+  def recursively_eval(val, args); end
+  def resolve_symbol_in_parent_context(symbol, args); end
+end
+
+module BinData::MultiFieldArgSeparator
+  def field_names_in_parameters?(obj_class, parameters); end
+  def parameters_is_value?(obj_class, value, parameters); end
+  def separate_args(obj_class, obj_args); end
+end
+
+class BinData::Primitive < ::BinData::BasePrimitive
+  extend(::BinData::DSLMixin)
+
+  def assign(val); end
+  def debug_name_of(child); end
+  def do_num_bytes; end
+  def do_write(io); end
+  def initialize_instance; end
+  def method_missing(symbol, *args, &block); end
+  def respond_to?(symbol, include_private = _); end
+
+  private
+
+  def get; end
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def set(v); end
+
+  def self.bit_aligned; end
+end
+
+class BinData::PrimitiveArgProcessor < ::BinData::BaseArgProcessor
+  def sanitize_parameters!(obj_class, params); end
+end
+
+module BinData::ReadUntilEOFPlugin
+  def do_read(io); end
+end
+
+module BinData::ReadUntilPlugin
+  def do_read(io); end
+end
+
+class BinData::Record < ::BinData::Struct
+  extend(::BinData::DSLMixin)
+
+  def self.inherited(subclass); end
+end
+
+class BinData::RecordArgProcessor < ::BinData::StructArgProcessor
+  include(::BinData::MultiFieldArgSeparator)
+
+  def sanitize_parameters!(obj_class, params); end
+end
+
+module BinData::RegisterNamePlugin
+  def initialize_shared_instance; end
+
+  def self.included(base); end
+end
+
+BinData::RegisteredClasses = T.let(T.unsafe(nil), BinData::Registry)
+
+class BinData::Registry
+  def initialize; end
+
+  def lookup(name, hints = _); end
+  def register(name, class_to_register); end
+  def underscore_name(name); end
+  def unregister(name); end
+
+  private
+
+  def name_with_endian(name, endian); end
+  def name_with_prefix(name, prefix); end
+  def normalize_name(name, hints); end
+  def register_dynamic_class(name); end
+  def registered?(name); end
+  def warn_if_name_is_already_registered(name, class_to_register); end
+end
+
+class BinData::Rest < ::BinData::BasePrimitive
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+class BinData::ResumeByteAlignment < ::BinData::Base
+  def assign(val); end
+  def clear?; end
+  def do_num_bytes; end
+  def do_read(io); end
+  def do_write(io); end
+  def snapshot; end
+end
+
+class BinData::SanitizedBigEndian < ::BinData::SanitizedParameter
+  def endian; end
+end
+
+class BinData::SanitizedChoices < ::BinData::SanitizedParameter
+  def initialize(choices, hints); end
+
+  def [](key); end
+end
+
+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 name; end
+  def name_as_sym; end
+  def prototype; end
+end
+
+class BinData::SanitizedFields < ::BinData::SanitizedParameter
+  include(::Enumerable)
+
+  def initialize(hints, base_fields = _); end
+
+  def [](idx); end
+  def add_field(type, name, params); end
+  def all_field_names_blank?; end
+  def any_field_has_parameter?(parameter); end
+  def each(&block); end
+  def empty?; end
+  def field_name?(name); end
+  def field_names; end
+  def length; end
+  def no_field_names_blank?; end
+  def raw_fields; end
+end
+
+class BinData::SanitizedLittleEndian < ::BinData::SanitizedParameter
+  def endian; end
+end
+
+class BinData::SanitizedParameter
+end
+
+class BinData::SanitizedParameters < ::Hash
+  def initialize(parameters, the_class, hints); end
+
+  def create_sanitized_params(params, the_class); end
+  def has_at_least_one_of?(*keys); end
+  def has_parameter?(_); end
+  def hints; end
+  def must_be_integer(*keys); end
+  def rename_parameter(old_key, new_key); end
+  def sanitize(key, &block); end
+  def sanitize_choices(key, &block); end
+  def sanitize_endian(key); end
+  def sanitize_fields(key, &block); end
+  def sanitize_object_prototype(key); end
+  def warn_replacement_parameter(bad_key, suggested_key); end
+
+  private
+
+  def create_sanitized_choices(choices); end
+  def create_sanitized_endian(endian); end
+  def create_sanitized_fields; end
+  def create_sanitized_object_prototype(obj_type, obj_params); end
+  def ensure_mandatory_parameters_exist; end
+  def ensure_mutual_exclusion_of_parameters; end
+  def ensure_no_nil_values; end
+  def merge_default_parameters!; end
+  def needs_sanitizing?(key); end
+  def sanitize!; end
+
+  def self.sanitize(parameters, the_class); end
+end
+
+BinData::SanitizedParameters::BIG_ENDIAN = T.let(T.unsafe(nil), BinData::SanitizedBigEndian)
+
+BinData::SanitizedParameters::LITTLE_ENDIAN = T.let(T.unsafe(nil), BinData::SanitizedLittleEndian)
+
+class BinData::SanitizedPrototype < ::BinData::SanitizedParameter
+  def initialize(obj_type, obj_params, hints); end
+
+  def has_parameter?(param); end
+  def instantiate(value = _, parent = _); end
+end
+
+class BinData::Sbit < ::BinData::BasePrimitive
+  def assign(val); end
+  def bit_aligned?; end
+  def do_num_bytes; end
+  def do_write(io); end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+end
+
+class BinData::SbitLe < ::BinData::BasePrimitive
+  def assign(val); end
+  def bit_aligned?; end
+  def do_num_bytes; end
+  def do_write(io); end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+end
+
+class BinData::Skip < ::BinData::BasePrimitive
+  def initialize_shared_instance; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+class BinData::SkipArgProcessor < ::BinData::BaseArgProcessor
+  def sanitize_parameters!(obj_class, params); end
+end
+
+module BinData::SkipLengthPlugin
+  def skip_length; end
+end
+
+module BinData::SkipToAbsOffsetPlugin
+  def skip_length; end
+end
+
+module BinData::SkipUntilValidPlugin
+  def read_and_return_value(io); end
+  def skip_length; end
+end
+
+class BinData::String < ::BinData::BasePrimitive
+  def assign(val); end
+  def initialize_shared_instance; end
+  def snapshot; end
+
+  private
+
+  def clamp_to_length(str); end
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def trim_padding(str); end
+  def value_to_binary_string(val); end
+end
+
+class BinData::StringArgProcessor < ::BinData::BaseArgProcessor
+  def sanitize_parameters!(obj_class, params); end
+
+  private
+
+  def sanitized_pad_byte(byte); end
+end
+
+class BinData::Stringz < ::BinData::BasePrimitive
+  def assign(val); end
+  def snapshot; end
+
+  private
+
+  def append_zero_byte_if_needed!(str); end
+  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 truncate_after_first_zero_byte!(str); end
+  def value_to_binary_string(val); end
+end
+
+class BinData::Struct < ::BinData::Base
+  def [](key); end
+  def []=(key, value); end
+  def assign(val); end
+  def clear; end
+  def clear?; end
+  def debug_name_of(child); end
+  def do_num_bytes; end
+  def do_read(io); end
+  def do_write(io); end
+  def each_pair; end
+  def field_names(include_hidden = _); end
+  def has_key?(key); end
+  def initialize_instance; end
+  def initialize_shared_instance; end
+  def key?(key); end
+  def offset_of(child); end
+  def snapshot; end
+
+  private
+
+  def as_stringified_hash(val); end
+  def assign_fields(val); end
+  def base_field_name(name); end
+  def define_field_accessors; end
+  def define_field_accessors_for(name, index); end
+  def find_index_of(obj); end
+  def find_obj_for_name(name); end
+  def include_obj?(obj); end
+  def instantiate_all_objs; end
+  def instantiate_obj_at(index); end
+  def sum_num_bytes_below_index(index); end
+  def sum_num_bytes_for_all_fields; end
+
+  def self.inherited(subclass); end
+end
+
+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
+end
+
+class BinData::StructArgProcessor < ::BinData::BaseArgProcessor
+  def sanitize_parameters!(obj_class, params); end
+
+  private
+
+  def ensure_field_names_are_valid(obj_class, field_names); end
+  def hidden_field_names(hidden); end
+  def sanitize_endian(params); end
+  def sanitize_fields(obj_class, params); end
+  def sanitize_hide(params); end
+  def sanitize_search_prefix(params); end
+  def sanitized_field_names(sanitized_fields); end
+end
+
+class BinData::Tracer
+  def initialize(io); end
+
+  def trace(msg); end
+  def trace_obj(obj_name, val); end
+end
+
+class BinData::Uint16be < ::BinData::BasePrimitive
+  def assign(val); end
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+class BinData::Uint16le < ::BinData::BasePrimitive
+  def assign(val); end
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+class BinData::Uint32be < ::BinData::BasePrimitive
+  def assign(val); end
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+class BinData::Uint32le < ::BinData::BasePrimitive
+  def assign(val); end
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+class BinData::Uint64be < ::BinData::BasePrimitive
+  def assign(val); end
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+class BinData::Uint64le < ::BinData::BasePrimitive
+  def assign(val); end
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+class BinData::Uint8 < ::BinData::BasePrimitive
+  def assign(val); end
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+class BinData::Uint8Array < ::BinData::BasePrimitive
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+class BinData::Uint8ArrayArgProcessor < ::BinData::BaseArgProcessor
+  def sanitize_parameters!(obj_class, params); end
+end
+
+class BinData::UnRegisteredTypeError < ::StandardError
+end
+
+BinData::VERSION = T.let(T.unsafe(nil), String)
+
+class BinData::ValidityError < ::StandardError
+end
+
+class BinData::Virtual < ::BinData::BasePrimitive
+  def do_num_bytes; end
+  def do_read(io); end
+  def do_write(io); end
+  def sensible_default; end
+end
+
+module BinData::WarnNoReadLengthPlugin
+  def read_and_return_value(io); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/elftools@1.1.2.rbi b/Library/Homebrew/sorbet/rbi/gems/elftools@1.1.2.rbi
new file mode 100644
index 0000000000..5f2e51557d
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/elftools@1.1.2.rbi
@@ -0,0 +1,724 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync --exclude json
+
+# typed: true
+
+module ELFTools
+end
+
+module ELFTools::Constants
+  include(::ELFTools::Constants::DF)
+  include(::ELFTools::Constants::DT)
+  include(::ELFTools::Constants::EM)
+  include(::ELFTools::Constants::ET)
+  include(::ELFTools::Constants::PT)
+  include(::ELFTools::Constants::SHT)
+  include(::ELFTools::Constants::STB)
+  include(::ELFTools::Constants::STT)
+end
+
+module ELFTools::Constants::DF
+end
+
+ELFTools::Constants::DF::DF_1_CONFALT = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_DIRECT = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_DISPRELDNE = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_DISPRELPND = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_EDITED = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_ENDFILTEE = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_GLOBAL = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_GLOBAUDIT = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_GROUP = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_IGNMULDEF = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_INITFIRST = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_INTERPOSE = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_LOADFLTR = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_NODEFLIB = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_NODELETE = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_NODIRECT = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_NODUMP = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_NOHDR = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_NOKSYMS = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_NOOPEN = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_NORELOC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_NOW = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_ORIGIN = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_SINGLETON = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_SYMINTPOSE = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_1_TRANS = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_BIND_NOW = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_ORIGIN = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_STATIC_TLS = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_SYMBOLIC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DF::DF_TEXTREL = T.let(T.unsafe(nil), Integer)
+
+module ELFTools::Constants::DT
+end
+
+ELFTools::Constants::DT::DT_ADDRRNGHI = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_ADDRRNGLO = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_BIND_NOW = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_DEBUG = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_ENCODING = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_FINI = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_FINI_ARRAY = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_FINI_ARRAYSZ = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_FLAGS = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_FLAGS_1 = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_GNU_HASH = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_HASH = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_HIOS = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_HIPROC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_INIT = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_INIT_ARRAY = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_INIT_ARRAYSZ = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_JMPREL = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_LOOS = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_LOPROC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_NEEDED = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_NULL = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_PLTGOT = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_PLTREL = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_PLTRELSZ = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_REL = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_RELA = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_RELACOUNT = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_RELAENT = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_RELASZ = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_RELCOUNT = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_RELENT = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_RELSZ = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_RPATH = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_RUNPATH = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_SONAME = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_STRSZ = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_STRTAB = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_SYMBOLIC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_SYMENT = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_SYMTAB = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_TEXTREL = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_VALRNGHI = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_VALRNGLO = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_VERDEF = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_VERDEFNUM = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::DT::DT_VERNEED = T.let(T.unsafe(nil), Integer)
+
+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
+end
+
+ELFTools::Constants::EM::EM_386 = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_486 = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_68K = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_860 = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_88K = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_AARCH64 = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_ALPHA = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_ALTERA_NIOS2 = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_ARM = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_AVR32 = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_BLACKFIN = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_BPF = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_CRIS = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_CYGNUS_M32R = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_CYGNUS_MN10300 = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_FRV = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_H8_300 = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_IA_64 = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_M32 = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_M32R = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_MICROBLAZE = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_MIPS = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_MIPS_RS3_LE = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_MIPS_RS4_BE = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_MN10300 = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_NONE = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_OPENRISC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_PARISC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_PPC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_PPC64 = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_S390 = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_S390_OLD = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_SH = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_SPARC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_SPARC32PLUS = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_SPARCV9 = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_SPU = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_TILEGX = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::EM::EM_TILEPRO = T.let(T.unsafe(nil), Integer)
+
+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
+end
+
+ELFTools::Constants::ET::ET_CORE = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::ET::ET_DYN = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::ET::ET_EXEC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::ET::ET_NONE = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::ET::ET_REL = T.let(T.unsafe(nil), Integer)
+
+module ELFTools::Constants::PT
+end
+
+ELFTools::Constants::PT::PT_DYNAMIC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::PT::PT_GNU_EH_FRAME = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::PT::PT_GNU_RELRO = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::PT::PT_GNU_STACK = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::PT::PT_HIOS = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::PT::PT_HIPROC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::PT::PT_INTERP = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::PT::PT_LOAD = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::PT::PT_LOOS = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::PT::PT_LOPROC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::PT::PT_NOTE = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::PT::PT_NULL = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::PT::PT_PHDR = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::PT::PT_SHLIB = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::PT::PT_TLS = T.let(T.unsafe(nil), Integer)
+
+module ELFTools::Constants::SHT
+end
+
+ELFTools::Constants::SHT::SHT_DYNAMIC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::SHT::SHT_DYNSYM = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::SHT::SHT_HASH = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::SHT::SHT_HIPROC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::SHT::SHT_HIUSER = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::SHT::SHT_LOPROC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::SHT::SHT_LOUSER = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::SHT::SHT_NOBITS = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::SHT::SHT_NOTE = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::SHT::SHT_NULL = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::SHT::SHT_PROGBITS = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::SHT::SHT_REL = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::SHT::SHT_RELA = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::SHT::SHT_SHLIB = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::SHT::SHT_STRTAB = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::SHT::SHT_SYMTAB = T.let(T.unsafe(nil), Integer)
+
+module ELFTools::Constants::STB
+end
+
+ELFTools::Constants::STB::STB_GLOBAL = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STB::STB_GNU_UNIQUE = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STB::STB_HIOS = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STB::STB_HIPROC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STB::STB_LOCAL = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STB::STB_LOOS = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STB::STB_LOPROC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STB::STB_NUM = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STB::STB_WEAK = T.let(T.unsafe(nil), Integer)
+
+module ELFTools::Constants::STT
+end
+
+ELFTools::Constants::STT::STT_ARM_TFUNC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STT::STT_COMMON = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STT::STT_FILE = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STT::STT_FUNC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STT::STT_GNU_IFUNC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STT::STT_HIOS = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STT::STT_HIPROC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STT::STT_LOOS = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STT::STT_LOPROC = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STT::STT_NOTYPE = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STT::STT_NUM = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STT::STT_OBJECT = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STT::STT_SECTION = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STT::STT_SPARC_REGISTER = T.let(T.unsafe(nil), Integer)
+
+ELFTools::Constants::STT::STT_TLS = T.let(T.unsafe(nil), Integer)
+
+module ELFTools::Dynamic
+  def each_tags(&block); end
+  def tag_at(n); end
+  def tag_by_type(type); end
+  def tags; end
+  def tags_by_type(type); end
+
+  private
+
+  def endian; end
+  def str_offset; end
+end
+
+class ELFTools::Dynamic::Tag
+  def initialize(header, stream, str_offset); end
+
+  def header; end
+  def name; end
+  def name?; end
+  def stream; end
+  def value; end
+end
+
+ELFTools::Dynamic::Tag::TYPE_WITH_NAME = T.let(T.unsafe(nil), Array)
+
+class ELFTools::ELFClassError < ::ELFTools::ELFError
+end
+
+class ELFTools::ELFDataError < ::ELFTools::ELFError
+end
+
+class ELFTools::ELFError < ::StandardError
+end
+
+class ELFTools::ELFFile
+  def initialize(stream); end
+
+  def build_id; end
+  def each_sections(&block); end
+  def each_segments(&block); end
+  def elf_class; end
+  def elf_type; end
+  def endian; end
+  def header; end
+  def machine; end
+  def num_sections; end
+  def num_segments; end
+  def offset_from_vma(vma, size = _); end
+  def patches; end
+  def save(filename); end
+  def section_at(n); end
+  def section_by_name(name); end
+  def sections; end
+  def sections_by_type(type, &block); end
+  def segment_at(n); end
+  def segment_by_type(type); end
+  def segments; end
+  def segments_by_type(type, &block); end
+  def stream; end
+  def strtab_section; end
+
+  private
+
+  def create_section(n); end
+  def create_segment(n); end
+  def identify; end
+  def loaded_headers; end
+end
+
+class ELFTools::ELFMagicError < ::ELFTools::ELFError
+end
+
+class ELFTools::LazyArray
+  def initialize(size, &block); end
+
+  def [](i); end
+end
+
+module ELFTools::Note
+  def each_notes; end
+  def notes; end
+
+  private
+
+  def create_note(cur); end
+  def endian; end
+end
+
+class ELFTools::Note::Note
+  def initialize(header, stream, offset); end
+
+  def desc; end
+  def description; end
+  def header; end
+  def name; end
+  def offset; end
+  def stream; end
+end
+
+ELFTools::Note::SIZE_OF_NHDR = T.let(T.unsafe(nil), Integer)
+
+class ELFTools::Relocation
+  def initialize(header, stream); end
+
+  def header; end
+  def r_info_sym; end
+  def r_info_type; end
+  def stream; end
+  def symbol_index; end
+  def type; end
+
+  private
+
+  def mask_bit; end
+end
+
+module ELFTools::Sections
+end
+
+class ELFTools::Sections::DynamicSection < ::ELFTools::Sections::Section
+  include(::ELFTools::Dynamic)
+
+  def tag_start; end
+end
+
+class ELFTools::Sections::NoteSection < ::ELFTools::Sections::Section
+  include(::ELFTools::Note)
+
+  def note_start; end
+  def note_total_size; end
+end
+
+class ELFTools::Sections::NullSection < ::ELFTools::Sections::Section
+  def null?; end
+end
+
+class ELFTools::Sections::RelocationSection < ::ELFTools::Sections::Section
+  def each_relocations(&block); end
+  def num_relocations; end
+  def rela?; end
+  def relocation_at(n); end
+  def relocations; end
+
+  private
+
+  def create_relocation(n); end
+end
+
+class ELFTools::Sections::Section
+  def initialize(header, stream, offset_from_vma: _, strtab: _, **_kwargs); end
+
+  def data; end
+  def header; end
+  def name; end
+  def null?; end
+  def stream; end
+  def type; end
+
+  def self.create(header, stream, *args, **kwargs); end
+end
+
+class ELFTools::Sections::StrTabSection < ::ELFTools::Sections::Section
+  def name_at(offset); end
+end
+
+class ELFTools::Sections::SymTabSection < ::ELFTools::Sections::Section
+  def initialize(header, stream, section_at: _, **_kwargs); end
+
+  def each_symbols(&block); end
+  def num_symbols; end
+  def symbol_at(n); end
+  def symbol_by_name(name); end
+  def symbols; end
+  def symstr; end
+
+  private
+
+  def create_symbol(n); end
+end
+
+class ELFTools::Sections::Symbol
+  def initialize(header, stream, symstr: _); end
+
+  def header; end
+  def name; end
+  def stream; end
+end
+
+module ELFTools::Segments
+end
+
+class ELFTools::Segments::DynamicSegment < ::ELFTools::Segments::Segment
+  include(::ELFTools::Dynamic)
+
+  def tag_start; end
+end
+
+class ELFTools::Segments::InterpSegment < ::ELFTools::Segments::Segment
+  def interp_name; end
+end
+
+class ELFTools::Segments::LoadSegment < ::ELFTools::Segments::Segment
+  def file_head; end
+  def file_tail; end
+  def mem_head; end
+  def mem_size; end
+  def mem_tail; end
+  def offset_in?(offset, size = _); end
+  def offset_to_vma(offset); end
+  def size; end
+  def vma_in?(vma, size = _); end
+  def vma_to_offset(vma); end
+end
+
+class ELFTools::Segments::NoteSegment < ::ELFTools::Segments::Segment
+  include(::ELFTools::Note)
+
+  def note_start; end
+  def note_total_size; end
+end
+
+class ELFTools::Segments::Segment
+  def initialize(header, stream, offset_from_vma: _); end
+
+  def data; end
+  def executable?; end
+  def header; end
+  def readable?; end
+  def stream; end
+  def type; end
+  def writable?; end
+
+  def self.create(header, stream, *args, **kwargs); end
+end
+
+module ELFTools::Structs
+end
+
+class ELFTools::Structs::ELF32_Phdr < ::ELFTools::Structs::ELFStruct
+  def self.inherited(subclass); end
+  def self.new(*args); end
+end
+
+class ELFTools::Structs::ELF32_sym < ::ELFTools::Structs::ELFStruct
+  def self.inherited(subclass); end
+  def self.new(*args); end
+end
+
+class ELFTools::Structs::ELF64_Phdr < ::ELFTools::Structs::ELFStruct
+  def self.inherited(subclass); end
+  def self.new(*args); end
+end
+
+class ELFTools::Structs::ELF64_sym < ::ELFTools::Structs::ELFStruct
+  def self.inherited(subclass); end
+  def self.new(*args); end
+end
+
+class ELFTools::Structs::ELFStruct < ::BinData::Record
+  def elf_class; end
+  def elf_class=(_); end
+  def offset; end
+  def offset=(_); end
+  def patches; end
+
+  def self.inherited(subclass); end
+  def self.new(*args); end
+  def self.pack(val, bytes); end
+  def self.self_endian; 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
+  def self.new(*args); end
+end
+
+class ELFTools::Structs::ELF_Ehdr < ::ELFTools::Structs::ELFStruct
+  def self.inherited(subclass); end
+  def self.new(*args); end
+end
+
+class ELFTools::Structs::ELF_Nhdr < ::ELFTools::Structs::ELFStruct
+  def self.inherited(subclass); end
+  def self.new(*args); 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
+  def self.new(*args); end
+end
+
+class ELFTools::Structs::ELF_Rela < ::ELFTools::Structs::ELFStruct
+  def self.inherited(subclass); end
+  def self.new(*args); end
+end
+
+class ELFTools::Structs::ELF_Shdr < ::ELFTools::Structs::ELFStruct
+  def self.inherited(subclass); end
+  def self.new(*args); end
+end
+
+ELFTools::Structs::ELF_sym = T.let(T.unsafe(nil), Hash)
+
+module ELFTools::Util
+  extend(::ELFTools::Util::ClassMethods)
+end
+
+module ELFTools::Util::ClassMethods
+  def align(num, bit); end
+  def cstring(stream, offset); end
+  def select_by_type(enum, type); end
+  def to_constant(mod, val); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/i18n@1.8.4.rbi b/Library/Homebrew/sorbet/rbi/gems/i18n@1.8.5.rbi
similarity index 100%
rename from Library/Homebrew/sorbet/rbi/gems/i18n@1.8.4.rbi
rename to Library/Homebrew/sorbet/rbi/gems/i18n@1.8.5.rbi
diff --git a/Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.0.0.rbi b/Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.1.0.rbi
similarity index 98%
rename from Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.0.0.rbi
rename to Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.1.0.rbi
index af1353e250..4a2558461a 100644
--- a/Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.0.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.1.0.rbi
@@ -1,5 +1,5 @@
 # This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca sync
+#   tapioca sync --exclude json
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/patchelf@1.1.1.rbi b/Library/Homebrew/sorbet/rbi/gems/patchelf@1.1.1.rbi
new file mode 100644
index 0000000000..be883d2256
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/patchelf@1.1.1.rbi
@@ -0,0 +1,134 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync --exclude json
+
+# typed: true
+
+module PatchELF
+end
+
+module PatchELF::Helper
+
+  private
+
+  def aligndown(val, align = _); end
+  def alignup(val, align = _); end
+  def color_enabled?; end
+  def colorize(str, type); end
+
+  def self.aligndown(val, align = _); end
+  def self.alignup(val, align = _); end
+  def self.color_enabled?; end
+  def self.colorize(str, type); end
+end
+
+PatchELF::Helper::COLOR_CODE = T.let(T.unsafe(nil), Hash)
+
+PatchELF::Helper::PAGE_SIZE = T.let(T.unsafe(nil), Integer)
+
+module PatchELF::Logger
+
+  private
+
+  def error(msg); end
+  def info(msg); end
+  def warn(msg); end
+
+  def self.error(msg); end
+  def self.info(msg); end
+  def self.warn(msg); end
+end
+
+class PatchELF::MM
+  def initialize(elf); end
+
+  def dispatch!; end
+  def extend_size; end
+  def extended?; end
+  def extended_offset(off); end
+  def malloc(size, &block); end
+  def threshold; end
+
+  private
+
+  def abnormal_elf(msg); end
+  def extend_backward(seg, size = _); end
+  def extend_forward(seg, size = _); end
+  def fgap_method; end
+  def find_gap(check_sz: _); end
+  def invoke_callbacks(seg, start); end
+  def load_segments; end
+  def mgap_method; end
+  def new_load_method; end
+  def shift_attributes; end
+  def writable?(seg); end
+end
+
+class PatchELF::MissingSegmentError < ::PatchELF::PatchError
+end
+
+class PatchELF::MissingTagError < ::PatchELF::PatchError
+end
+
+class PatchELF::PatchError < ::ELFTools::ELFError
+end
+
+class PatchELF::Patcher
+  def initialize(filename, logging: _); end
+
+  def add_needed(need); end
+  def elf; end
+  def interpreter; end
+  def interpreter=(interp); end
+  def needed; end
+  def needed=(needs); end
+  def remove_needed(need); end
+  def replace_needed(src, tar); end
+  def rpath; end
+  def rpath=(rpath); end
+  def runpath; end
+  def runpath=(runpath); end
+  def save(out_file = _); end
+  def soname; end
+  def soname=(name); end
+  def use_rpath!; end
+
+  private
+
+  def dirty?; end
+  def dynamic_or_log; end
+  def interpreter_; end
+  def log_or_raise(msg, exception = _); end
+  def needed_; end
+  def runpath_(rpath_sym = _); end
+  def soname_; end
+  def tag_name_or_log(type, log_msg); end
+end
+
+class PatchELF::Saver
+  def initialize(in_file, out_file, set); end
+
+  def in_file; end
+  def out_file; end
+  def save!; end
+
+  private
+
+  def dynamic; end
+  def expand_dynamic!; end
+  def inline_patch(off, str); end
+  def lazy_dyn(sym); end
+  def malloc_strtab!; end
+  def patch_dynamic; end
+  def patch_interpreter; end
+  def patch_needed; end
+  def patch_out(out_file); end
+  def patch_runpath(sym = _); end
+  def patch_soname; end
+  def reg_str_table(str, &block); end
+  def section_header(name); end
+  def strtab_string; end
+end
+
+PatchELF::Saver::IGNORE = T.let(T.unsafe(nil), Integer)
+
+PatchELF::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
index 644e2b74c5..555e26f550 100644
--- a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
+++ b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
@@ -6840,6 +6840,130 @@ module Docile
   def self.dsl_eval_with_block_return(dsl, *args, &block); end
 end
 
+module ELFTools
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class ELFTools::Structs::ELF32_PhdrBe
+end
+
+class ELFTools::Structs::ELF32_PhdrBe
+end
+
+class ELFTools::Structs::ELF32_PhdrLe
+end
+
+class ELFTools::Structs::ELF32_PhdrLe
+end
+
+class ELFTools::Structs::ELF32_symBe
+end
+
+class ELFTools::Structs::ELF32_symBe
+end
+
+class ELFTools::Structs::ELF32_symLe
+end
+
+class ELFTools::Structs::ELF32_symLe
+end
+
+class ELFTools::Structs::ELF64_PhdrBe
+end
+
+class ELFTools::Structs::ELF64_PhdrBe
+end
+
+class ELFTools::Structs::ELF64_PhdrLe
+end
+
+class ELFTools::Structs::ELF64_PhdrLe
+end
+
+class ELFTools::Structs::ELF64_symBe
+end
+
+class ELFTools::Structs::ELF64_symBe
+end
+
+class ELFTools::Structs::ELF64_symLe
+end
+
+class ELFTools::Structs::ELF64_symLe
+end
+
+class ELFTools::Structs::ELF_DynBe
+end
+
+class ELFTools::Structs::ELF_DynBe
+end
+
+class ELFTools::Structs::ELF_DynLe
+end
+
+class ELFTools::Structs::ELF_DynLe
+end
+
+class ELFTools::Structs::ELF_EhdrBe
+end
+
+class ELFTools::Structs::ELF_EhdrBe
+end
+
+class ELFTools::Structs::ELF_EhdrLe
+end
+
+class ELFTools::Structs::ELF_EhdrLe
+end
+
+class ELFTools::Structs::ELF_NhdrBe
+end
+
+class ELFTools::Structs::ELF_NhdrBe
+end
+
+class ELFTools::Structs::ELF_NhdrLe
+end
+
+class ELFTools::Structs::ELF_NhdrLe
+end
+
+class ELFTools::Structs::ELF_RelBe
+end
+
+class ELFTools::Structs::ELF_RelBe
+end
+
+class ELFTools::Structs::ELF_RelLe
+end
+
+class ELFTools::Structs::ELF_RelLe
+end
+
+class ELFTools::Structs::ELF_RelaBe
+end
+
+class ELFTools::Structs::ELF_RelaBe
+end
+
+class ELFTools::Structs::ELF_RelaLe
+end
+
+class ELFTools::Structs::ELF_RelaLe
+end
+
+class ELFTools::Structs::ELF_ShdrBe
+end
+
+class ELFTools::Structs::ELF_ShdrBe
+end
+
+class ELFTools::Structs::ELF_ShdrLe
+end
+
+class ELFTools::Structs::ELF_ShdrLe
+end
+
 class ERB
   def def_method(mod, methodname, fname=T.unsafe(nil)); end
 
diff --git a/Library/Homebrew/sorbet/rbi/homebrew.rbi b/Library/Homebrew/sorbet/rbi/homebrew.rbi
index f7b19cedc1..a92dcd0165 100644
--- a/Library/Homebrew/sorbet/rbi/homebrew.rbi
+++ b/Library/Homebrew/sorbet/rbi/homebrew.rbi
@@ -8,6 +8,10 @@ module Homebrew::Help
   include Kernel
 end
 
+module Homebrew::Fetch
+  def args; end
+end
+
 module Language::Perl::Shebang
   include Kernel
 end