Update RBI files for tapioca.

Library/Homebrew/sorbet/rbi/gems/tapioca@0.5.3.rbi

@@ -1,9 +1,9 @@
+# typed: true
+
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `tapioca` gem.
 # Please instead update this file by running `bin/tapioca gem tapioca`.
 
-# typed: true
-
 class ActiveRecordColumnTypeHelper
   def initialize(*args, &blk); end
 
@@ -22,8 +22,86 @@ class ActiveRecordColumnTypeHelper
   def lookup_return_type_of_method(*args, &blk); end
 end
 
+class DynamicMixinCompiler
+  include ::Tapioca::Reflection
+
+  sig { params(constant: Module).void }
+  def initialize(constant); end
+
+  def class_attribute_predicates; end
+
+  sig { returns(T::Array[Symbol]) }
+  def class_attribute_readers; end
+
+  def class_attribute_writers; end
+
+  sig { params(tree: RBI::Tree).void }
+  def compile_class_attributes(tree); end
+
+  sig { params(tree: RBI::Tree).returns([T::Array[Module], T::Array[Module]]) }
+  def compile_mixes_in_class_methods(tree); end
+
+  sig { returns(T::Array[Module]) }
+  def dynamic_extends; end
+
+  def dynamic_includes; end
+
+  sig { returns(T::Boolean) }
+  def empty_attributes?; end
+
+  def instance_attribute_predicates; end
+
+  sig { returns(T::Array[Symbol]) }
+  def instance_attribute_readers; end
+
+  def instance_attribute_writers; end
+end
+
 module RBI; end
 
+class RBI::File
+  sig { params(strictness: T.nilable(String), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(file: RBI::File).void)).void }
+  def initialize(strictness: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { params(node: RBI::Node).void }
+  def <<(node); end
+
+  sig { params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(T::Array[RBI::Comment]) }
+  def comments; end
+
+  def comments=(_arg0); end
+
+  sig { returns(T::Boolean) }
+  def empty?; end
+
+  sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
+  def print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end
+
+  sig { returns(RBI::Tree) }
+  def root; end
+
+  sig { void }
+  def set_empty_body_content; end
+
+  sig { params(command: String, reason: T.nilable(String), display_heading: T::Boolean).void }
+  def set_file_header(command, reason: T.unsafe(nil), display_heading: T.unsafe(nil)); end
+
+  sig { returns(T.nilable(String)) }
+  def strictness; end
+
+  sig { params(indent: Integer, print_locs: T::Boolean).returns(String) }
+  def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end
+
+  sig { void }
+  def transform_rbi!; end
+
+  sig { returns(String) }
+  def transformed_string; end
+end
+
 class RBI::Tree < ::RBI::NodeWithComments
   sig { params(loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Tree).void)).void }
   def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
@@ -137,25 +215,13 @@ module Tapioca
 end
 
 class Tapioca::Cli < ::Thor
-  include ::Thor::Actions
-  extend ::Thor::Actions::ClassMethods
-
   def __print_version; end
   def dsl(*constants); end
   def gem(*gems); end
-  def generate(*gems); end
   def init; end
   def require; end
-  def sync; end
   def todo; end
 
-  private
-
-  def create_config; end
-  def create_post_require; end
-  def generate_binstub; end
-  def generator; end
-
   class << self
     def exit_on_failure?; end
   end
@@ -172,9 +238,15 @@ class Tapioca::Compilers::Dsl::Base
   sig { void }
   def initialize; end
 
+  sig { params(error: String).void }
+  def add_error(error); end
+
   sig { abstract.type_parameters(:T).params(tree: RBI::Tree, constant: T.type_parameter(:T)).void }
   def decorate(tree, constant); end
 
+  sig { returns(T::Array[String]) }
+  def errors; end
+
   sig { abstract.returns(T::Enumerable[Module]) }
   def gather_constants; end
 
@@ -229,6 +301,8 @@ class Tapioca::Compilers::Dsl::Base
   def parameters_types_from_signature(method_def, signature); end
 end
 
+Tapioca::Compilers::Dsl::COMPILERS_PATH = T.let(T.unsafe(nil), String)
+
 class Tapioca::Compilers::DslCompiler
   sig { params(requested_constants: T::Array[Module], requested_generators: T::Array[T.class_of(Tapioca::Compilers::Dsl::Base)], excluded_generators: T::Array[T.class_of(Tapioca::Compilers::Dsl::Base)], error_handler: T.nilable(T.proc.params(error: String).void)).void }
   def initialize(requested_constants:, requested_generators: T.unsafe(nil), excluded_generators: T.unsafe(nil), error_handler: T.unsafe(nil)); end
@@ -242,7 +316,7 @@ class Tapioca::Compilers::DslCompiler
   sig { returns(T::Array[Module]) }
   def requested_constants; end
 
-  sig { params(blk: T.proc.params(constant: Module, rbi: String).void).void }
+  sig { params(blk: T.proc.params(constant: Module, rbi: RBI::File).void).void }
   def run(&blk); end
 
   private
@@ -253,7 +327,7 @@ class Tapioca::Compilers::DslCompiler
   sig { params(requested_generators: T::Array[T.class_of(Tapioca::Compilers::Dsl::Base)], excluded_generators: T::Array[T.class_of(Tapioca::Compilers::Dsl::Base)]).returns(T::Enumerable[Tapioca::Compilers::Dsl::Base]) }
   def gather_generators(requested_generators, excluded_generators); end
 
-  sig { params(constant: Module).returns(T.nilable(String)) }
+  sig { params(constant: Module).returns(T.nilable(RBI::File)) }
   def rbi_for_constant(constant); end
 
   sig { params(error: String).returns(T.noreturn) }
@@ -307,14 +381,16 @@ module Tapioca::Compilers::SymbolTable; end
 class Tapioca::Compilers::SymbolTable::SymbolGenerator
   include ::Tapioca::Reflection
 
-  sig { params(gem: Tapioca::Gemfile::GemSpec, indent: Integer).void }
-  def initialize(gem, indent = T.unsafe(nil)); end
+  sig { params(gem: Tapioca::Gemfile::GemSpec, indent: Integer, include_doc: T::Boolean).void }
+  def initialize(gem, indent = T.unsafe(nil), include_doc = T.unsafe(nil)); end
 
+  sig { returns(Tapioca::Gemfile::GemSpec) }
   def gem; end
 
-  sig { returns(String) }
-  def generate; end
+  sig { params(rbi: RBI::File).void }
+  def generate(rbi); end
 
+  sig { returns(Integer) }
   def indent; end
 
   private
@@ -322,17 +398,12 @@ class Tapioca::Compilers::SymbolTable::SymbolGenerator
   sig { params(name: String).void }
   def add_to_alias_namespace(name); end
 
+  sig { params(name: T.nilable(String)).void }
   def add_to_symbol_queue(name); end
 
   sig { params(name: String).returns(T::Boolean) }
   def alias_namespaced?(name); end
 
-  sig { params(constant: Module).returns([T::Array[Module], T::Array[Module]]) }
-  def collect_dynamic_mixins_of(constant); end
-
-  sig { params(constant: Module, dynamic_extends: T::Array[Module]).returns(T::Array[Module]) }
-  def collect_mixed_in_class_methods(constant, dynamic_extends); end
-
   sig { params(tree: RBI::Tree, name: T.nilable(String), constant: BasicObject).void }
   def compile(tree, name, constant); end
 
@@ -348,6 +419,9 @@ class Tapioca::Compilers::SymbolTable::SymbolGenerator
   sig { params(tree: RBI::Tree, module_name: String, mod: Module, for_visibility: T::Array[Symbol]).void }
   def compile_directly_owned_methods(tree, module_name, mod, for_visibility = T.unsafe(nil)); end
 
+  sig { params(tree: RBI::Tree, constant: Module).void }
+  def compile_dynamic_mixins(tree, constant); end
+
   sig { params(tree: RBI::Tree, constant: Module).void }
   def compile_enums(tree, constant); end
 
@@ -357,9 +431,6 @@ class Tapioca::Compilers::SymbolTable::SymbolGenerator
   sig { params(tree: RBI::Tree, name: String, constant: Module).void }
   def compile_methods(tree, name, constant); end
 
-  sig { params(tree: RBI::Tree, constant: Module).void }
-  def compile_mixes_in_class_methods(tree, constant); end
-
   sig { params(tree: RBI::Tree, constant: Module).void }
   def compile_mixins(tree, constant); end
 
@@ -393,6 +464,9 @@ class Tapioca::Compilers::SymbolTable::SymbolGenerator
   sig { params(constant: Module, strict: T::Boolean).returns(T::Boolean) }
   def defined_in_gem?(constant, strict: T.unsafe(nil)); end
 
+  sig { params(name: String).returns(T::Array[RBI::Comment]) }
+  def documentation_comments(name); end
+
   sig { params(symbols: T::Set[String]).returns(T::Set[String]) }
   def engine_symbols(symbols); end
 
@@ -405,6 +479,7 @@ class Tapioca::Compilers::SymbolTable::SymbolGenerator
   sig { params(constant: Module).returns(T::Array[String]) }
   def get_file_candidates(constant); end
 
+  sig { params(constant: Module).returns(T.nilable(UnboundMethod)) }
   def initialize_method_for(constant); end
 
   sig { params(constant: Module).returns(T::Array[Module]) }
@@ -447,6 +522,7 @@ class Tapioca::Compilers::SymbolTable::SymbolGenerator
   def valid_method_name?(name); end
 end
 
+Tapioca::Compilers::SymbolTable::SymbolGenerator::IGNORED_COMMENTS = T.let(T.unsafe(nil), Array)
 Tapioca::Compilers::SymbolTable::SymbolGenerator::IGNORED_SYMBOLS = T.let(T.unsafe(nil), Array)
 Tapioca::Compilers::SymbolTable::SymbolGenerator::SPECIAL_METHOD_NAMES = T.let(T.unsafe(nil), Array)
 Tapioca::Compilers::SymbolTable::SymbolGenerator::TYPE_PARAMETER_MATCHER = T.let(T.unsafe(nil), Regexp)
@@ -476,8 +552,8 @@ class Tapioca::Compilers::SymbolTable::SymbolLoader::SymbolTableParser
 end
 
 class Tapioca::Compilers::SymbolTableCompiler
-  sig { params(gem: Tapioca::Gemfile::GemSpec, indent: Integer).returns(String) }
-  def compile(gem, indent = T.unsafe(nil)); end
+  sig { params(gem: Tapioca::Gemfile::GemSpec, rbi: RBI::File, indent: Integer, include_docs: T::Boolean).void }
+  def compile(gem, rbi, indent = T.unsafe(nil), include_docs = T.unsafe(nil)); end
 end
 
 class Tapioca::Compilers::TodosCompiler
@@ -491,6 +567,7 @@ class Tapioca::Compilers::TodosCompiler
 end
 
 class Tapioca::Config < ::T::Struct
+  const :doc, T::Boolean, default: T.unsafe(nil)
   const :exclude, T::Array[String]
   const :exclude_generators, T::Array[String]
   const :file_header, T::Boolean, default: T.unsafe(nil)
@@ -586,7 +663,7 @@ class Tapioca::Gemfile
 
   def lockfile; end
 
-  sig { returns([T::Enumerable[T.any(Gem::Specification, T.all(Bundler::RemoteSpecification, Bundler::StubSpecification))], T::Array[String]]) }
+  sig { returns([T::Enumerable[T.any(Bundler::StubSpecification, Gem::Specification)], T::Array[String]]) }
   def materialize_deps; end
 
   sig { returns(Bundler::Runtime) }
@@ -594,7 +671,7 @@ class Tapioca::Gemfile
 end
 
 class Tapioca::Gemfile::GemSpec
-  sig { params(spec: T.any(Gem::Specification, T.all(Bundler::RemoteSpecification, Bundler::StubSpecification))).void }
+  sig { params(spec: T.any(Bundler::StubSpecification, Gem::Specification)).void }
   def initialize(spec); end
 
   sig { params(path: String).returns(T::Boolean) }
@@ -612,6 +689,9 @@ class Tapioca::Gemfile::GemSpec
   sig { returns(String) }
   def name; end
 
+  sig { void }
+  def parse_yard_docs; end
+
   sig { returns(String) }
   def rbi_file_name; end
 
@@ -645,55 +725,55 @@ class Tapioca::Gemfile::GemSpec
 end
 
 Tapioca::Gemfile::GemSpec::IGNORED_GEMS = T.let(T.unsafe(nil), Array)
-Tapioca::Gemfile::Spec = T.type_alias { T.any(Gem::Specification, T.all(Bundler::RemoteSpecification, Bundler::StubSpecification)) }
+Tapioca::Gemfile::Spec = T.type_alias { T.any(Bundler::StubSpecification, Gem::Specification) }
+module Tapioca::Generators; end
 
-class Tapioca::Generator < ::Thor::Shell::Color
-  sig { params(config: Tapioca::Config).void }
-  def initialize(config); end
+class Tapioca::Generators::Base
+  include ::Thor::Base
+  include ::Thor::Invocation
+  include ::Thor::Shell
+  extend ::Thor::Base::ClassMethods
+  extend ::Thor::Invocation::ClassMethods
 
-  sig { params(requested_constants: T::Array[String], should_verify: T::Boolean, quiet: T::Boolean, verbose: T::Boolean).void }
-  def build_dsl(requested_constants, should_verify: T.unsafe(nil), quiet: T.unsafe(nil), verbose: T.unsafe(nil)); end
+  abstract!
 
-  sig { params(gem_names: T::Array[String]).void }
-  def build_gem_rbis(gem_names); end
+  sig { params(default_command: String, file_writer: Thor::Actions).void }
+  def initialize(default_command:, file_writer: T.unsafe(nil)); end
 
-  sig { void }
-  def build_requires; end
+  sig { abstract.void }
+  def generate; end
 
-  sig { void }
-  def build_todos; end
+  private
 
-  sig { returns(Tapioca::Config) }
-  def config; end
+  sig { params(path: T.any(Pathname, String), content: String, force: T::Boolean, skip: T::Boolean, verbose: T::Boolean).void }
+  def create_file(path, content, force: T.unsafe(nil), skip: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
-  sig { params(should_verify: T::Boolean).void }
-  def sync_rbis_with_gemfile(should_verify: T.unsafe(nil)); end
+  sig { params(message: String, color: T.any(Symbol, T::Array[Symbol])).void }
+  def say_error(message = T.unsafe(nil), *color); end
+end
+
+class Tapioca::Generators::Base::FileWriter < ::Thor
+  include ::Thor::Actions
+  extend ::Thor::Actions::ClassMethods
+end
+
+class Tapioca::Generators::Dsl < ::Tapioca::Generators::Base
+  sig { params(requested_constants: T::Array[String], outpath: Pathname, generators: T::Array[String], exclude_generators: T::Array[String], file_header: T::Boolean, compiler_path: String, tapioca_path: String, default_command: String, file_writer: Thor::Actions, should_verify: T::Boolean, quiet: T::Boolean, verbose: T::Boolean).void }
+  def initialize(requested_constants:, outpath:, generators:, exclude_generators:, file_header:, compiler_path:, tapioca_path:, default_command:, file_writer: T.unsafe(nil), should_verify: T.unsafe(nil), quiet: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig { override.void }
+  def generate; end
 
   private
 
   sig { void }
   def abort_if_pending_migrations!; end
 
-  sig { params(filename: Pathname).void }
-  def add(filename); end
-
-  sig { returns(T::Array[String]) }
-  def added_rbis; end
-
   sig { params(cause: Symbol, files: T::Array[String]).returns(String) }
   def build_error_for_files(cause, files); end
 
-  sig { returns(Tapioca::Gemfile) }
-  def bundle; end
-
-  sig { params(constant_name: String, contents: String, outpath: Pathname, quiet: T::Boolean).returns(T.nilable(Pathname)) }
-  def compile_dsl_rbi(constant_name, contents, outpath: T.unsafe(nil), quiet: T.unsafe(nil)); end
-
-  sig { params(gem: Tapioca::Gemfile::GemSpec).void }
-  def compile_gem_rbi(gem); end
-
-  sig { returns(Tapioca::Compilers::SymbolTableCompiler) }
-  def compiler; end
+  sig { params(constant_name: String, rbi: RBI::File, outpath: Pathname, quiet: T::Boolean).returns(T.nilable(Pathname)) }
+  def compile_dsl_rbi(constant_name, rbi, outpath: T.unsafe(nil), quiet: T.unsafe(nil)); end
 
   sig { params(constant_names: T::Array[String]).returns(T::Array[Module]) }
   def constantize(constant_names); end
@@ -704,12 +784,73 @@ class Tapioca::Generator < ::Thor::Shell::Color
   sig { params(constant_name: String).returns(Pathname) }
   def dsl_rbi_filename(constant_name); end
 
-  sig { params(gem_name: String).returns(Pathname) }
-  def existing_rbi(gem_name); end
-
   sig { params(requested_constants: T::Array[String], path: Pathname).returns(T::Set[Pathname]) }
   def existing_rbi_filenames(requested_constants, path: T.unsafe(nil)); end
 
+  sig { params(constant: String).returns(String) }
+  def generate_command_for(constant); end
+
+  sig { params(eager_load: T::Boolean).void }
+  def load_application(eager_load:); end
+
+  sig { void }
+  def load_dsl_generators; end
+
+  sig { returns(Tapioca::Loader) }
+  def loader; end
+
+  sig { params(dir: Pathname).void }
+  def perform_dsl_verification(dir); end
+
+  sig { params(files: T::Set[Pathname]).void }
+  def purge_stale_dsl_rbi_files(files); end
+
+  sig { params(constant: String).returns(String) }
+  def rbi_filename_for(constant); end
+
+  sig { params(path: Pathname).returns(T::Array[Pathname]) }
+  def rbi_files_in(path); end
+
+  sig { params(filename: Pathname).void }
+  def remove(filename); end
+
+  sig { params(diff: T::Hash[String, Symbol], command: String).void }
+  def report_diff_and_exit_if_out_of_date(diff, command); end
+
+  sig { params(class_name: String).returns(String) }
+  def underscore(class_name); end
+
+  sig { params(tmp_dir: Pathname).returns(T::Hash[String, Symbol]) }
+  def verify_dsl_rbi(tmp_dir:); end
+end
+
+class Tapioca::Generators::Gem < ::Tapioca::Generators::Base
+  sig { params(gem_names: T::Array[String], gem_excludes: T::Array[String], prerequire: T.nilable(String), postrequire: String, typed_overrides: T::Hash[String, String], default_command: String, outpath: Pathname, file_header: T::Boolean, doc: T::Boolean, file_writer: Thor::Actions).void }
+  def initialize(gem_names:, gem_excludes:, prerequire:, postrequire:, typed_overrides:, default_command:, outpath:, file_header:, doc:, file_writer: T.unsafe(nil)); end
+
+  sig { override.void }
+  def generate; end
+
+  sig { params(should_verify: T::Boolean).void }
+  def sync(should_verify: T.unsafe(nil)); end
+
+  private
+
+  sig { returns(T::Array[String]) }
+  def added_rbis; end
+
+  sig { params(cause: Symbol, files: T::Array[String]).returns(String) }
+  def build_error_for_files(cause, files); end
+
+  sig { returns(Tapioca::Gemfile) }
+  def bundle; end
+
+  sig { params(gem: Tapioca::Gemfile::GemSpec).void }
+  def compile_gem_rbi(gem); end
+
+  sig { params(gem_name: String).returns(Pathname) }
+  def existing_rbi(gem_name); end
+
   sig { returns(T::Hash[String, String]) }
   def existing_rbis; end
 
@@ -731,12 +872,6 @@ class Tapioca::Generator < ::Thor::Shell::Color
   sig { params(gem_names: T::Array[String]).returns(T::Array[Tapioca::Gemfile::GemSpec]) }
   def gems_to_generate(gem_names); end
 
-  sig { params(eager_load: T::Boolean).void }
-  def load_application(eager_load:); end
-
-  sig { void }
-  def load_dsl_generators; end
-
   sig { returns(Tapioca::Loader) }
   def loader; end
 
@@ -746,24 +881,12 @@ class Tapioca::Generator < ::Thor::Shell::Color
   sig { void }
   def perform_additions; end
 
-  sig { params(dir: Pathname).void }
-  def perform_dsl_verification(dir); end
-
   sig { void }
   def perform_removals; end
 
   sig { void }
   def perform_sync_verification; end
 
-  sig { params(files: T::Set[Pathname]).void }
-  def purge_stale_dsl_rbi_files(files); end
-
-  sig { params(path: Pathname).returns(T::Array[Pathname]) }
-  def rbi_files_in(path); end
-
-  sig { params(command: String, reason: T.nilable(String), strictness: T.nilable(String)).returns(String) }
-  def rbi_header(command, reason: T.unsafe(nil), strictness: T.unsafe(nil)); end
-
   sig { params(filename: Pathname).void }
   def remove(filename); end
 
@@ -775,18 +898,54 @@ class Tapioca::Generator < ::Thor::Shell::Color
 
   sig { void }
   def require_gem_file; end
-
-  sig { params(message: String, color: T.any(Symbol, T::Array[Symbol])).void }
-  def say_error(message = T.unsafe(nil), *color); end
-
-  sig { params(class_name: String).returns(String) }
-  def underscore(class_name); end
-
-  sig { params(tmp_dir: Pathname).returns(T::Hash[String, Symbol]) }
-  def verify_dsl_rbi(tmp_dir:); end
 end
 
-Tapioca::Generator::EMPTY_RBI_COMMENT = T.let(T.unsafe(nil), String)
+class Tapioca::Generators::Init < ::Tapioca::Generators::Base
+  sig { params(sorbet_config: String, default_postrequire: String, default_command: String, file_writer: Thor::Actions).void }
+  def initialize(sorbet_config:, default_postrequire:, default_command:, file_writer: T.unsafe(nil)); end
+
+  sig { override.void }
+  def generate; end
+
+  private
+
+  sig { void }
+  def create_config; end
+
+  sig { void }
+  def create_post_require; end
+
+  sig { void }
+  def generate_binstub; end
+
+  sig { void }
+  def generate_binstub!; end
+
+  sig { returns(Bundler::Installer) }
+  def installer; end
+
+  sig { returns(Bundler::StubSpecification) }
+  def spec; end
+end
+
+class Tapioca::Generators::Require < ::Tapioca::Generators::Base
+  sig { params(requires_path: String, sorbet_config_path: String, default_command: String, file_writer: Thor::Actions).void }
+  def initialize(requires_path:, sorbet_config_path:, default_command:, file_writer: T.unsafe(nil)); end
+
+  sig { override.void }
+  def generate; end
+end
+
+class Tapioca::Generators::Todo < ::Tapioca::Generators::Base
+  sig { params(todos_path: String, file_header: T::Boolean, default_command: String, file_writer: Thor::Actions).void }
+  def initialize(todos_path:, file_header:, default_command:, file_writer: T.unsafe(nil)); end
+
+  sig { override.void }
+  def generate; end
+
+  sig { params(command: String, reason: T.nilable(String), strictness: T.nilable(String)).returns(String) }
+  def rbi_header(command, reason: T.unsafe(nil), strictness: T.unsafe(nil)); end
+end
 
 module Tapioca::GenericTypeRegistry
   class << self
@@ -863,6 +1022,9 @@ module Tapioca::Reflection
   sig { params(constant: Module).returns(T::Array[Module]) }
   def inherited_ancestors_of(constant); end
 
+  sig { params(constant: Module, method: Symbol).returns(Method) }
+  def method_of(constant, method); end
+
   sig { params(constant: Module).returns(T.nilable(String)) }
   def name_of(constant); end
 
@@ -898,6 +1060,7 @@ Tapioca::Reflection::ANCESTORS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
 Tapioca::Reflection::CLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
 Tapioca::Reflection::CONSTANTS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
 Tapioca::Reflection::EQUAL_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+Tapioca::Reflection::METHOD_METHOD = T.let(T.unsafe(nil), UnboundMethod)
 Tapioca::Reflection::NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod)
 Tapioca::Reflection::OBJECT_ID_METHOD = T.let(T.unsafe(nil), UnboundMethod)
 Tapioca::Reflection::PRIVATE_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)

Library/Homebrew/sorbet/rbi/gems/yard-sorbet@0.6.0.rbi

@@ -0,0 +1,194 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `yard-sorbet` gem.
+# Please instead update this file by running `bin/tapioca gem yard-sorbet`.
+
+module YARDSorbet; end
+
+module YARDSorbet::Directives
+  class << self
+    sig { params(docstring: String, directives: T::Array[String]).void }
+    def add_directives(docstring, directives); end
+
+    sig { params(docstring: T.nilable(String)).returns([YARD::Docstring, T::Array[String]]) }
+    def extract_directives(docstring); end
+  end
+end
+
+module YARDSorbet::Handlers; end
+
+class YARDSorbet::Handlers::AbstractDSLHandler < ::YARD::Handlers::Ruby::Base
+  sig { void }
+  def process; end
+end
+
+YARDSorbet::Handlers::AbstractDSLHandler::CLASS_TAG_TEXT = T.let(T.unsafe(nil), String)
+YARDSorbet::Handlers::AbstractDSLHandler::TAG_TEXT = T.let(T.unsafe(nil), String)
+
+class YARDSorbet::Handlers::EnumsHandler < ::YARD::Handlers::Ruby::Base
+  sig { void }
+  def process; end
+
+  private
+
+  sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Boolean) }
+  def const_assign_node?(node); end
+end
+
+class YARDSorbet::Handlers::IncludeHandler < ::YARD::Handlers::Ruby::Base
+  sig { void }
+  def process; end
+
+  private
+
+  sig { returns(YARD::CodeObjects::NamespaceObject) }
+  def included_in; end
+end
+
+class YARDSorbet::Handlers::MixesInClassMethodsHandler < ::YARD::Handlers::Ruby::Base
+  sig { void }
+  def process; end
+end
+
+class YARDSorbet::Handlers::SigHandler < ::YARD::Handlers::Ruby::Base
+  sig { void }
+  def process; end
+
+  private
+
+  sig { params(method_node: YARD::Parser::Ruby::AstNode, node: YARD::Parser::Ruby::AstNode, docstring: YARD::Docstring).void }
+  def parse_params(method_node, node, docstring); end
+
+  sig { params(node: YARD::Parser::Ruby::AstNode, docstring: YARD::Docstring).void }
+  def parse_return(node, docstring); end
+
+  sig { params(method_node: YARD::Parser::Ruby::AstNode, docstring: YARD::Docstring).void }
+  def parse_sig(method_node, docstring); end
+end
+
+YARDSorbet::Handlers::SigHandler::ATTR_NODE_TYPES = T.let(T.unsafe(nil), Array)
+
+module YARDSorbet::Handlers::StructClassHandler
+  sig { void }
+  def process; end
+
+  private
+
+  sig { params(object: YARD::CodeObjects::MethodObject, props: T::Array[YARDSorbet::TStructProp], docstring: YARD::Docstring, directives: T::Array[String]).void }
+  def decorate_t_struct_init(object, props, docstring, directives); end
+
+  sig { params(props: T::Array[YARDSorbet::TStructProp], class_ns: YARD::CodeObjects::ClassObject).void }
+  def process_t_struct_props(props, class_ns); end
+
+  sig { params(props: T::Array[YARDSorbet::TStructProp]).returns(T::Array[[String, T.nilable(String)]]) }
+  def to_object_parameters(props); end
+end
+
+class YARDSorbet::Handlers::StructPropHandler < ::YARD::Handlers::Ruby::Base
+  sig { void }
+  def process; end
+
+  private
+
+  sig { params(object: YARD::CodeObjects::MethodObject, prop: YARDSorbet::TStructProp).void }
+  def decorate_object(object, prop); end
+
+  sig { returns(T.nilable(String)) }
+  def default_value; end
+
+  sig { params(name: String).returns(YARDSorbet::TStructProp) }
+  def make_prop(name); end
+
+  sig { params(object: YARD::CodeObjects::MethodObject, name: String).void }
+  def register_attrs(object, name); end
+
+  sig { params(prop: YARDSorbet::TStructProp).void }
+  def update_state(prop); end
+end
+
+module YARDSorbet::NodeUtils
+  class << self
+    sig { params(node: YARD::Parser::Ruby::AstNode, _blk: T.proc.params(n: YARD::Parser::Ruby::AstNode).void).void }
+    def bfs_traverse(node, &_blk); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T.any(YARD::Parser::Ruby::MethodCallNode, YARD::Parser::Ruby::MethodDefinitionNode)) }
+    def get_method_node(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(YARD::Parser::Ruby::AstNode) }
+    def sibling_node(node); end
+  end
+end
+
+YARDSorbet::NodeUtils::ATTRIBUTE_METHODS = T.let(T.unsafe(nil), Array)
+YARDSorbet::NodeUtils::SIGABLE_NODE = T.type_alias { T.any(YARD::Parser::Ruby::MethodCallNode, YARD::Parser::Ruby::MethodDefinitionNode) }
+YARDSorbet::NodeUtils::SKIP_METHOD_CONTENTS = T.let(T.unsafe(nil), Array)
+
+module YARDSorbet::SigToYARD
+  class << self
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert(node); end
+
+    private
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(String) }
+    def build_generic_type(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert_aref(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert_array(node); end
+
+    sig { params(node: YARD::Parser::Ruby::MethodCallNode).returns(T::Array[String]) }
+    def convert_call(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert_collection(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert_hash(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert_list(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert_node(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert_node_type(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert_ref(node); end
+
+    sig { params(node: YARD::Parser::Ruby::MethodCallNode).returns(T::Array[String]) }
+    def convert_t_method(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert_unknown(node); end
+  end
+end
+
+class YARDSorbet::TStructProp < ::T::Struct
+  const :default, T.nilable(String)
+  const :doc, String
+  const :prop_name, String
+  const :source, String
+  const :types, T::Array[String]
+
+  class << self
+    def inherited(s); end
+  end
+end
+
+module YARDSorbet::TagUtils
+  class << self
+    sig { params(docstring: YARD::Docstring, tag_name: String, name: T.nilable(String)).returns(T.nilable(YARD::Tags::Tag)) }
+    def find_tag(docstring, tag_name, name); end
+
+    sig { params(docstring: YARD::Docstring, tag_name: String, types: T.nilable(T::Array[String]), name: T.nilable(String), text: String).void }
+    def upsert_tag(docstring, tag_name, types = T.unsafe(nil), name = T.unsafe(nil), text = T.unsafe(nil)); end
+  end
+end
+
+YARDSorbet::VERSION = T.let(T.unsafe(nil), String)

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

@@ -3243,6 +3243,12 @@ module DiskUsageExtension
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
+class DynamicMixinCompiler
+  extend ::T::Sig
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
 class ELFTools::Structs::ELF32_PhdrBe
 end
 
@@ -3796,14 +3802,6 @@ module GC
   def self.verify_transient_heap_internal_consistency(); end
 end
 
-module Gem
-  ConfigMap = ::T.let(nil, ::T.untyped)
-  RbConfigPriorities = ::T.let(nil, ::T.untyped)
-  RubyGemsPackageVersion = ::T.let(nil, ::T.untyped)
-  RubyGemsVersion = ::T.let(nil, ::T.untyped)
-  USE_BUNDLER_FOR_GEMDEPS = ::T.let(nil, ::T.untyped)
-end
-
 class Gem::DependencyInstaller
   def _deprecated_add_found_dependencies(to_do, dependency_list); end
 
@@ -4348,8 +4346,6 @@ end
 class Gem::UninstallError
 end
 
-Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError
-
 Gem::Version::Requirement = Gem::Requirement
 
 module Gem
@@ -5825,6 +5821,8 @@ class Object
   PATCH_B_SHA256 = ::T.let(nil, ::T.untyped)
   REQUIRED_RUBY_X = ::T.let(nil, ::T.untyped)
   REQUIRED_RUBY_Y = ::T.let(nil, ::T.untyped)
+  RUBY18 = ::T.let(nil, ::T.untyped)
+  RUBY19 = ::T.let(nil, ::T.untyped)
   RUBY_BIN = ::T.let(nil, ::T.untyped)
   RUBY_COPYRIGHT = ::T.let(nil, ::T.untyped)
   RUBY_DESCRIPTION = ::T.let(nil, ::T.untyped)
@@ -7340,6 +7338,14 @@ end
 class Racc::CparseParams
 end
 
+class Rack::Request
+  def query(); end
+
+  def version_supplied(); end
+
+  def version_supplied=(version_supplied); end
+end
+
 class Random
   def self.bytes(arg); end
 end
@@ -7453,6 +7459,545 @@ class ResourceStageContext
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
+class Ripper
+  def column(); end
+
+  def encoding(); end
+
+  def end_seen?(); end
+
+  def error?(); end
+
+  def filename(); end
+
+  def initialize(*arg); end
+
+  def lineno(); end
+
+  def parse(); end
+
+  def state(); end
+
+  def yydebug(); end
+
+  def yydebug=(yydebug); end
+  EXPR_ARG = ::T.let(nil, ::T.untyped)
+  EXPR_ARG_ANY = ::T.let(nil, ::T.untyped)
+  EXPR_BEG = ::T.let(nil, ::T.untyped)
+  EXPR_BEG_ANY = ::T.let(nil, ::T.untyped)
+  EXPR_CLASS = ::T.let(nil, ::T.untyped)
+  EXPR_CMDARG = ::T.let(nil, ::T.untyped)
+  EXPR_DOT = ::T.let(nil, ::T.untyped)
+  EXPR_END = ::T.let(nil, ::T.untyped)
+  EXPR_ENDARG = ::T.let(nil, ::T.untyped)
+  EXPR_ENDFN = ::T.let(nil, ::T.untyped)
+  EXPR_END_ANY = ::T.let(nil, ::T.untyped)
+  EXPR_FITEM = ::T.let(nil, ::T.untyped)
+  EXPR_FNAME = ::T.let(nil, ::T.untyped)
+  EXPR_LABEL = ::T.let(nil, ::T.untyped)
+  EXPR_LABELED = ::T.let(nil, ::T.untyped)
+  EXPR_MID = ::T.let(nil, ::T.untyped)
+  EXPR_NONE = ::T.let(nil, ::T.untyped)
+  EXPR_VALUE = ::T.let(nil, ::T.untyped)
+  PARSER_EVENT_TABLE = ::T.let(nil, ::T.untyped)
+  SCANNER_EVENT_TABLE = ::T.let(nil, ::T.untyped)
+  Version = ::T.let(nil, ::T.untyped)
+end
+
+class Ripper::Filter
+  def initialize(src, filename=T.unsafe(nil), lineno=T.unsafe(nil)); end
+end
+
+class Ripper::Lexer
+  def lex(); end
+
+  def tokenize(); end
+end
+
+class Ripper::Lexer::Elem
+  def event(); end
+
+  def event=(_); end
+
+  def initialize(pos, event, tok, state); end
+
+  def pos(); end
+
+  def pos=(_); end
+
+  def state(); end
+
+  def state=(_); end
+
+  def tok(); end
+
+  def tok=(_); end
+end
+
+class Ripper::Lexer::Elem
+  def self.[](*arg); end
+
+  def self.members(); end
+end
+
+class Ripper::Lexer::State
+  def &(i); end
+
+  def ==(i); end
+
+  def allbits?(i); end
+
+  def anybits?(i); end
+
+  def initialize(i); end
+
+  def nobits?(i); end
+
+  def to_i(); end
+
+  def to_int(); end
+
+  def to_int=(_); end
+
+  def to_s=(_); end
+
+  def |(i); end
+end
+
+class Ripper::Lexer::State
+  def self.[](*arg); end
+
+  def self.members(); end
+end
+
+class Ripper::Lexer
+end
+
+class Ripper::SexpBuilder
+  def on_BEGIN(*args); end
+
+  def on_CHAR(tok); end
+
+  def on_END(*args); end
+
+  def on___end__(tok); end
+
+  def on_alias(*args); end
+
+  def on_alias_error(*args); end
+
+  def on_aref(*args); end
+
+  def on_aref_field(*args); end
+
+  def on_arg_ambiguous(*args); end
+
+  def on_arg_paren(*args); end
+
+  def on_args_add(*args); end
+
+  def on_args_add_block(*args); end
+
+  def on_args_add_star(*args); end
+
+  def on_args_new(*args); end
+
+  def on_array(*args); end
+
+  def on_assign(*args); end
+
+  def on_assign_error(*args); end
+
+  def on_assoc_new(*args); end
+
+  def on_assoc_splat(*args); end
+
+  def on_assoclist_from_args(*args); end
+
+  def on_backref(tok); end
+
+  def on_backtick(tok); end
+
+  def on_bare_assoc_hash(*args); end
+
+  def on_begin(*args); end
+
+  def on_binary(*args); end
+
+  def on_block_var(*args); end
+
+  def on_blockarg(*args); end
+
+  def on_bodystmt(*args); end
+
+  def on_brace_block(*args); end
+
+  def on_break(*args); end
+
+  def on_call(*args); end
+
+  def on_case(*args); end
+
+  def on_class(*args); end
+
+  def on_class_name_error(*args); end
+
+  def on_comma(tok); end
+
+  def on_command(*args); end
+
+  def on_command_call(*args); end
+
+  def on_comment(tok); end
+
+  def on_const(tok); end
+
+  def on_const_path_field(*args); end
+
+  def on_const_path_ref(*args); end
+
+  def on_const_ref(*args); end
+
+  def on_cvar(tok); end
+
+  def on_def(*args); end
+
+  def on_defined(*args); end
+
+  def on_defs(*args); end
+
+  def on_do_block(*args); end
+
+  def on_dot2(*args); end
+
+  def on_dot3(*args); end
+
+  def on_dyna_symbol(*args); end
+
+  def on_else(*args); end
+
+  def on_elsif(*args); end
+
+  def on_embdoc(tok); end
+
+  def on_embdoc_beg(tok); end
+
+  def on_embdoc_end(tok); end
+
+  def on_embexpr_beg(tok); end
+
+  def on_embexpr_end(tok); end
+
+  def on_embvar(tok); end
+
+  def on_ensure(*args); end
+
+  def on_excessed_comma(*args); end
+
+  def on_fcall(*args); end
+
+  def on_field(*args); end
+
+  def on_float(tok); end
+
+  def on_for(*args); end
+
+  def on_gvar(tok); end
+
+  def on_hash(*args); end
+
+  def on_heredoc_beg(tok); end
+
+  def on_heredoc_end(tok); end
+
+  def on_ident(tok); end
+
+  def on_if(*args); end
+
+  def on_if_mod(*args); end
+
+  def on_ifop(*args); end
+
+  def on_ignored_nl(tok); end
+
+  def on_ignored_sp(tok); end
+
+  def on_imaginary(tok); end
+
+  def on_int(tok); end
+
+  def on_ivar(tok); end
+
+  def on_kw(tok); end
+
+  def on_kwrest_param(*args); end
+
+  def on_label(tok); end
+
+  def on_label_end(tok); end
+
+  def on_lambda(*args); end
+
+  def on_lbrace(tok); end
+
+  def on_lbracket(tok); end
+
+  def on_lparen(tok); end
+
+  def on_magic_comment(*args); end
+
+  def on_massign(*args); end
+
+  def on_method_add_arg(*args); end
+
+  def on_method_add_block(*args); end
+
+  def on_mlhs_add(*args); end
+
+  def on_mlhs_add_post(*args); end
+
+  def on_mlhs_add_star(*args); end
+
+  def on_mlhs_new(*args); end
+
+  def on_mlhs_paren(*args); end
+
+  def on_module(*args); end
+
+  def on_mrhs_add(*args); end
+
+  def on_mrhs_add_star(*args); end
+
+  def on_mrhs_new(*args); end
+
+  def on_mrhs_new_from_args(*args); end
+
+  def on_next(*args); end
+
+  def on_nl(tok); end
+
+  def on_op(tok); end
+
+  def on_opassign(*args); end
+
+  def on_operator_ambiguous(*args); end
+
+  def on_param_error(*args); end
+
+  def on_params(*args); end
+
+  def on_paren(*args); end
+
+  def on_parse_error(*args); end
+
+  def on_period(tok); end
+
+  def on_program(*args); end
+
+  def on_qsymbols_add(*args); end
+
+  def on_qsymbols_beg(tok); end
+
+  def on_qsymbols_new(*args); end
+
+  def on_qwords_add(*args); end
+
+  def on_qwords_beg(tok); end
+
+  def on_qwords_new(*args); end
+
+  def on_rational(tok); end
+
+  def on_rbrace(tok); end
+
+  def on_rbracket(tok); end
+
+  def on_redo(*args); end
+
+  def on_regexp_add(*args); end
+
+  def on_regexp_beg(tok); end
+
+  def on_regexp_end(tok); end
+
+  def on_regexp_literal(*args); end
+
+  def on_regexp_new(*args); end
+
+  def on_rescue(*args); end
+
+  def on_rescue_mod(*args); end
+
+  def on_rest_param(*args); end
+
+  def on_retry(*args); end
+
+  def on_return(*args); end
+
+  def on_return0(*args); end
+
+  def on_rparen(tok); end
+
+  def on_sclass(*args); end
+
+  def on_semicolon(tok); end
+
+  def on_sp(tok); end
+
+  def on_stmts_add(*args); end
+
+  def on_stmts_new(*args); end
+
+  def on_string_add(*args); end
+
+  def on_string_concat(*args); end
+
+  def on_string_content(*args); end
+
+  def on_string_dvar(*args); end
+
+  def on_string_embexpr(*args); end
+
+  def on_string_literal(*args); end
+
+  def on_super(*args); end
+
+  def on_symbeg(tok); end
+
+  def on_symbol(*args); end
+
+  def on_symbol_literal(*args); end
+
+  def on_symbols_add(*args); end
+
+  def on_symbols_beg(tok); end
+
+  def on_symbols_new(*args); end
+
+  def on_tlambda(tok); end
+
+  def on_tlambeg(tok); end
+
+  def on_top_const_field(*args); end
+
+  def on_top_const_ref(*args); end
+
+  def on_tstring_beg(tok); end
+
+  def on_tstring_content(tok); end
+
+  def on_tstring_end(tok); end
+
+  def on_unary(*args); end
+
+  def on_undef(*args); end
+
+  def on_unless(*args); end
+
+  def on_unless_mod(*args); end
+
+  def on_until(*args); end
+
+  def on_until_mod(*args); end
+
+  def on_var_alias(*args); end
+
+  def on_var_field(*args); end
+
+  def on_var_ref(*args); end
+
+  def on_vcall(*args); end
+
+  def on_void_stmt(*args); end
+
+  def on_when(*args); end
+
+  def on_while(*args); end
+
+  def on_while_mod(*args); end
+
+  def on_word_add(*args); end
+
+  def on_word_new(*args); end
+
+  def on_words_add(*args); end
+
+  def on_words_beg(tok); end
+
+  def on_words_new(*args); end
+
+  def on_words_sep(tok); end
+
+  def on_xstring_add(*args); end
+
+  def on_xstring_literal(*args); end
+
+  def on_xstring_new(*args); end
+
+  def on_yield(*args); end
+
+  def on_yield0(*args); end
+
+  def on_zsuper(*args); end
+end
+
+class Ripper::SexpBuilder
+end
+
+class Ripper::SexpBuilderPP
+end
+
+class Ripper::SexpBuilderPP
+end
+
+class Ripper::TokenPattern
+  def initialize(pattern); end
+
+  def match(str); end
+
+  def match_list(tokens); end
+  MAP = ::T.let(nil, ::T.untyped)
+end
+
+class Ripper::TokenPattern::CompileError
+end
+
+class Ripper::TokenPattern::CompileError
+end
+
+class Ripper::TokenPattern::Error
+end
+
+class Ripper::TokenPattern::Error
+end
+
+class Ripper::TokenPattern::MatchData
+  def initialize(tokens, match); end
+
+  def string(n=T.unsafe(nil)); end
+end
+
+class Ripper::TokenPattern::MatchData
+end
+
+class Ripper::TokenPattern::MatchError
+end
+
+class Ripper::TokenPattern::MatchError
+end
+
+class Ripper::TokenPattern
+  def self.compile(*arg); end
+end
+
+class Ripper
+  def self.dedent_string(arg, arg1); end
+
+  def self.lex_state_name(arg); end
+
+  def self.token_match(src, pattern); end
+end
+
 module RuboCop::AST::CollectionNode
   def abbrev(*args, &block); end
 
@@ -9688,6 +10233,14 @@ class Version
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
+class WEBrick::HTTPRequest
+  def version_supplied(); end
+
+  def version_supplied=(version_supplied); end
+
+  def xhr?(); end
+end
+
 class WeakRef
   def initialize(orig); end
 end
@@ -9899,6 +10452,76 @@ end
 module Webrobots
 end
 
+module YARD::CodeObjects
+  extend ::YARD::CodeObjects::NamespaceMapper
+end
+
+module YARDSorbet::Directives
+  extend ::T::Sig
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+class YARDSorbet::Handlers::AbstractDSLHandler
+  extend ::T::Sig
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+class YARDSorbet::Handlers::EnumsHandler
+  extend ::T::Sig
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+class YARDSorbet::Handlers::IncludeHandler
+  extend ::T::Sig
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+class YARDSorbet::Handlers::MixesInClassMethodsHandler
+  extend ::T::Sig
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+class YARDSorbet::Handlers::SigHandler
+  extend ::T::Sig
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+module YARDSorbet::Handlers::StructClassHandler
+  extend ::T::Sig
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+class YARDSorbet::Handlers::StructPropHandler
+  extend ::T::Sig
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+module YARDSorbet::NodeUtils
+  extend ::T::Sig
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+module YARDSorbet::SigToYARD
+  extend ::T::Sig
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+module YARDSorbet::TagUtils
+  extend ::T::Sig
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
 class Zlib::Deflate
   def initialize(*arg); end
 end