From 241bcb262a1b21549828bfee0bb2177d8b1061eb Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 26 Jul 2021 02:44:20 +0000
Subject: [PATCH 01/13] build(deps-dev): bump sorbet in /Library/Homebrew

Bumps [sorbet](https://github.com/sorbet/sorbet) from 0.5.6274 to 0.5.6519.
- [Release notes](https://github.com/sorbet/sorbet/releases)
- [Commits](https://github.com/sorbet/sorbet/commits)

---
updated-dependencies:
- dependency-name: sorbet
  dependency-type: direct:development
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 Library/Homebrew/Gemfile.lock | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Library/Homebrew/Gemfile.lock b/Library/Homebrew/Gemfile.lock
index 68d5595ebf..e4c042569d 100644
--- a/Library/Homebrew/Gemfile.lock
+++ b/Library/Homebrew/Gemfile.lock
@@ -146,11 +146,11 @@ GEM
       simplecov (~> 0.8)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.3)
-    sorbet (0.5.6274)
-      sorbet-static (= 0.5.6274)
+    sorbet (0.5.6519)
+      sorbet-static (= 0.5.6519)
     sorbet-runtime (0.5.6274)
     sorbet-runtime-stub (0.2.0)
-    sorbet-static (0.5.6274-universal-darwin-14)
+    sorbet-static (0.5.6519-universal-darwin-14)
     spoom (1.0.9)
       colorize
       sorbet (~> 0.5.5)

From 0d8caf722ba87e654a8c25df8f943dd0d610f1ad Mon Sep 17 00:00:00 2001
From: BrewTestBot <1589480+BrewTestBot@users.noreply.github.com>
Date: Mon, 26 Jul 2021 02:46:43 +0000
Subject: [PATCH 02/13] brew vendor-gems: commit updates.

---
 Library/Homebrew/Gemfile.lock                   | 2 +-
 Library/Homebrew/vendor/bundle/bundler/setup.rb | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Library/Homebrew/Gemfile.lock b/Library/Homebrew/Gemfile.lock
index e4c042569d..1bcb62f2b7 100644
--- a/Library/Homebrew/Gemfile.lock
+++ b/Library/Homebrew/Gemfile.lock
@@ -148,7 +148,7 @@ GEM
     simplecov_json_formatter (0.1.3)
     sorbet (0.5.6519)
       sorbet-static (= 0.5.6519)
-    sorbet-runtime (0.5.6274)
+    sorbet-runtime (0.5.6519)
     sorbet-runtime-stub (0.2.0)
     sorbet-static (0.5.6519-universal-darwin-14)
     spoom (1.0.9)
diff --git a/Library/Homebrew/vendor/bundle/bundler/setup.rb b/Library/Homebrew/vendor/bundle/bundler/setup.rb
index ddaff70f7d..8a71060db5 100644
--- a/Library/Homebrew/vendor/bundle/bundler/setup.rb
+++ b/Library/Homebrew/vendor/bundle/bundler/setup.rb
@@ -54,7 +54,7 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parallel-1.20.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parallel_tests-3.7.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parser-3.0.2.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rainbow-3.0.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-runtime-0.5.6274/lib"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-runtime-0.5.6519/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parlour-6.0.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/patchelf-1.3.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/plist-3.6.0/lib"
@@ -73,8 +73,8 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-3.10.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-github-2.3.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-its-1.3.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-retry-0.6.2/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-static-0.5.6274-universal-darwin-14/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-0.5.6274/lib"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-static-0.5.6519-universal-darwin-14/lib"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-0.5.6519/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-sorbet-1.8.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-wait-0.0.9/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec_junit_formatter-0.4.1/lib"

From 07239d267c6ad44839bfa8944e20390963b7e4e7 Mon Sep 17 00:00:00 2001
From: Bo Anderson <mail@boanderson.me>
Date: Tue, 27 Jul 2021 04:44:24 +0100
Subject: [PATCH 03/13] Migrate from Sorbet DSL plugins to Parlour

---
 Library/Homebrew/.parlour                     |  10 ++
 Library/Homebrew/Gemfile                      |   1 +
 Library/Homebrew/Gemfile.lock                 |   1 +
 Library/Homebrew/dev-cmd/typecheck.rb         |   1 +
 Library/Homebrew/extend/hash_validator.rbi    |   6 +
 Library/Homebrew/extend/time.rbi              |   9 +
 Library/Homebrew/sorbet/config                |   3 -
 Library/Homebrew/sorbet/parlour.rb            |  42 +++++
 Library/Homebrew/sorbet/parlour/attr.rb       | 110 ++++++++++++
 .../Homebrew/sorbet/plugins/attr_predicate.rb |  13 --
 Library/Homebrew/sorbet/plugins/attr_rw.rb    |  13 --
 .../Homebrew/sorbet/plugins/def_delegator.rb  |  17 --
 .../Homebrew/sorbet/plugins/def_delegators.rb |  17 --
 Library/Homebrew/sorbet/plugins/delegate.rb   |  21 ---
 Library/Homebrew/sorbet/plugins/using.rb      |  43 -----
 Library/Homebrew/sorbet/rbi/parlour.rbi       | 164 ++++++++++++++++++
 Library/Homebrew/sorbet/triggers.yml          |  10 --
 Library/Homebrew/unpack_strategy.rbi          |  11 ++
 18 files changed, 355 insertions(+), 137 deletions(-)
 create mode 100644 Library/Homebrew/.parlour
 create mode 100644 Library/Homebrew/extend/hash_validator.rbi
 create mode 100644 Library/Homebrew/extend/time.rbi
 create mode 100644 Library/Homebrew/sorbet/parlour.rb
 create mode 100644 Library/Homebrew/sorbet/parlour/attr.rb
 delete mode 100644 Library/Homebrew/sorbet/plugins/attr_predicate.rb
 delete mode 100644 Library/Homebrew/sorbet/plugins/attr_rw.rb
 delete mode 100644 Library/Homebrew/sorbet/plugins/def_delegator.rb
 delete mode 100644 Library/Homebrew/sorbet/plugins/def_delegators.rb
 delete mode 100644 Library/Homebrew/sorbet/plugins/delegate.rb
 delete mode 100644 Library/Homebrew/sorbet/plugins/using.rb
 create mode 100644 Library/Homebrew/sorbet/rbi/parlour.rbi
 delete mode 100644 Library/Homebrew/sorbet/triggers.yml

diff --git a/Library/Homebrew/.parlour b/Library/Homebrew/.parlour
new file mode 100644
index 0000000000..1fe16333dc
--- /dev/null
+++ b/Library/Homebrew/.parlour
@@ -0,0 +1,10 @@
+parser: false
+
+output_file:
+  rbi: sorbet/rbi/parlour.rbi
+
+relative_requires:
+  - sorbet/parlour.rb
+
+plugins:
+  Attr: {}
diff --git a/Library/Homebrew/Gemfile b/Library/Homebrew/Gemfile
index a434b3a5c9..c83f920267 100644
--- a/Library/Homebrew/Gemfile
+++ b/Library/Homebrew/Gemfile
@@ -24,6 +24,7 @@ gem "simplecov-cobertura", require: false
 gem "warning", require: false
 
 group :sorbet, optional: true do
+  gem "parlour", require: false
   gem "rspec-sorbet", require: false
   gem "sorbet", require: false
   gem "sorbet-runtime", require: false
diff --git a/Library/Homebrew/Gemfile.lock b/Library/Homebrew/Gemfile.lock
index 1bcb62f2b7..99689717d8 100644
--- a/Library/Homebrew/Gemfile.lock
+++ b/Library/Homebrew/Gemfile.lock
@@ -188,6 +188,7 @@ DEPENDENCIES
   mechanize
   minitest
   parallel_tests
+  parlour
   patchelf
   plist
   ronn
diff --git a/Library/Homebrew/dev-cmd/typecheck.rb b/Library/Homebrew/dev-cmd/typecheck.rb
index 07ee66aae3..73242d0a5b 100644
--- a/Library/Homebrew/dev-cmd/typecheck.rb
+++ b/Library/Homebrew/dev-cmd/typecheck.rb
@@ -61,6 +61,7 @@ module Homebrew
 
         ohai "Updating Tapioca RBI files..."
         system "bundle", "exec", "tapioca", "sync", "--exclude", *excluded_gems
+        system "bundle", "exec", "parlour"
         system "bundle", "exec", "srb", "rbi", "hidden-definitions"
         system "bundle", "exec", "srb", "rbi", "todo"
 
diff --git a/Library/Homebrew/extend/hash_validator.rbi b/Library/Homebrew/extend/hash_validator.rbi
new file mode 100644
index 0000000000..715b783813
--- /dev/null
+++ b/Library/Homebrew/extend/hash_validator.rbi
@@ -0,0 +1,6 @@
+# typed: strict
+
+class Hash
+  sig { params(valid_keys: T.untyped).void }
+  def assert_valid_keys!(*valid_keys); end
+end
diff --git a/Library/Homebrew/extend/time.rbi b/Library/Homebrew/extend/time.rbi
new file mode 100644
index 0000000000..ab1c7254f9
--- /dev/null
+++ b/Library/Homebrew/extend/time.rbi
@@ -0,0 +1,9 @@
+# typed: strict
+
+class Time
+  sig { returns(T.any(Integer, Float)) }
+  def remaining; end
+
+  sig { returns(T.any(Integer, Float)) }
+  def remaining!; end
+end
diff --git a/Library/Homebrew/sorbet/config b/Library/Homebrew/sorbet/config
index 024ba458ec..02fbf5ab02 100644
--- a/Library/Homebrew/sorbet/config
+++ b/Library/Homebrew/sorbet/config
@@ -6,6 +6,3 @@
 
 --ignore
 /test/.gem
-
---dsl-plugins
-sorbet/triggers.yml
diff --git a/Library/Homebrew/sorbet/parlour.rb b/Library/Homebrew/sorbet/parlour.rb
new file mode 100644
index 0000000000..c33a64dc8c
--- /dev/null
+++ b/Library/Homebrew/sorbet/parlour.rb
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+# typed: true
+
+require_relative "../warnings"
+Warnings.ignore :parser_syntax do
+  require "parser/current"
+end
+
+module Homebrew
+  module Parlour
+    extend T::Sig
+
+    ROOT_DIR = T.let(Pathname(__dir__).parent.realpath.freeze, Pathname)
+
+    sig { returns(T::Array[Parser::AST::Node]) }
+    def self.ast_list
+      @@ast_list ||= begin
+        ast_list = []
+        parser = Parser::CurrentRuby.new
+
+        ROOT_DIR.find do |path|
+          Find.prune if path.directory? && %w[sorbet shims test vendor].any? { |subdir| path == ROOT_DIR/subdir }
+
+          Find.prune if path.file? && path.extname != ".rb"
+
+          next unless path.file?
+
+          buffer = Parser::Source::Buffer.new(path, source: path.read)
+
+          parser.reset
+          ast = parser.parse(buffer)
+          ast_list << ast if ast
+        end
+
+        ast_list
+      end
+    end
+  end
+end
+
+require "parlour"
+require_relative "parlour/attr"
diff --git a/Library/Homebrew/sorbet/parlour/attr.rb b/Library/Homebrew/sorbet/parlour/attr.rb
new file mode 100644
index 0000000000..8f8c4bf8fd
--- /dev/null
+++ b/Library/Homebrew/sorbet/parlour/attr.rb
@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Attr < Parlour::Plugin
+  sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    tree = T.let([], T::Array[T.untyped])
+    Homebrew::Parlour.ast_list.each do |node|
+      tree += find_custom_attr(node)
+    end
+    process_custom_attr(tree, root)
+  end
+
+  sig { override.returns(T.nilable(String)) }
+  def strictness
+    return "strict"
+  end
+
+  private
+
+  sig { params(node: Parser::AST::Node, list: T::Array[String]).returns(T::Array[String]) }
+  def traverse_module_name(node, list = [])
+    parent, name = node.children
+    list = traverse_module_name(parent, list) if parent
+    list << name.to_s
+    list
+  end
+
+  sig { params(node: T.nilable(Parser::AST::Node)).returns(T.nilable(String)) }
+  def extract_module_name(node)
+    return if node.nil?
+
+    traverse_module_name(node).join("::")
+  end
+    
+  sig { params(node: Parser::AST::Node).returns(T::Array[T.untyped]) }
+  def find_custom_attr(node)
+    tree = T.let([], T::Array[T.untyped])
+    children = node.children.dup
+
+    if node.type == :begin
+      children.each do |child|
+        subtree = find_custom_attr(child)
+        tree += subtree unless subtree.empty?
+      end
+    elsif node.type == :sclass
+      subtree = find_custom_attr(node.children[1])
+      return tree if subtree.empty?
+      
+      tree << [:sclass, subtree]
+    elsif node.type == :class || node.type == :module
+      element = []
+      if node.type == :class
+        element << :class
+        element << extract_module_name(children.shift)
+        element << extract_module_name(children.shift)
+      elsif node.type == :module
+        element << :module
+        element << extract_module_name(children.shift)
+      end
+
+      body = children.shift
+      return tree if body.nil?
+
+      subtree = find_custom_attr(body)
+      return tree if subtree.empty?
+
+      element << subtree
+      tree << element
+    elsif node.type == :send && children.shift.nil?
+      method_name = children.shift
+      if method_name == :attr_rw || method_name == :attr_predicate
+        children.each do |name_node|
+          tree << [method_name, name_node.children.first.to_s]
+        end
+      end
+    end
+
+    tree
+  end
+
+  sig { params(tree: T::Array[T.untyped], namespace: Parlour::RbiGenerator::Namespace, sclass: T::Boolean).void }
+  def process_custom_attr(tree, namespace, sclass: false)
+    tree.each do |node|
+      type = node.shift
+      case type
+      when :sclass
+        process_custom_attr(node.shift, namespace, sclass: true)
+      when :class
+        class_namespace = namespace.create_class(node.shift, superclass: node.shift)
+        process_custom_attr(node.shift, class_namespace)
+      when :module
+        module_namespace = namespace.create_module(node.shift)
+        process_custom_attr(node.shift, module_namespace)
+      when :attr_rw
+        name = node.shift
+        name = "self.#{name}" if sclass
+        namespace.create_method(name, parameters: [
+          Parlour::RbiGenerator::Parameter.new("arg", type: "T.untyped", default: "T.unsafe(nil)")
+        ], return_type: "T.untyped")
+      when :attr_predicate
+        name = node.shift
+        name = "self.#{name}" if sclass
+        namespace.create_method(name, return_type: "T::Boolean")
+      else
+        raise "Malformed tree."
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/sorbet/plugins/attr_predicate.rb b/Library/Homebrew/sorbet/plugins/attr_predicate.rb
deleted file mode 100644
index 2559705d5d..0000000000
--- a/Library/Homebrew/sorbet/plugins/attr_predicate.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-source = ARGV[5]
-
-source.scan(/:([^?]+\?)/).flatten.each do |method|
-  puts <<~RUBY
-    # typed: strict
-
-    sig { returns(T::Boolean) }
-    def #{method}; end
-  RUBY
-end
diff --git a/Library/Homebrew/sorbet/plugins/attr_rw.rb b/Library/Homebrew/sorbet/plugins/attr_rw.rb
deleted file mode 100644
index 2363d3bffa..0000000000
--- a/Library/Homebrew/sorbet/plugins/attr_rw.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-source = ARGV[5]
-
-source.scan(/:([^\s,]+)/).flatten.each do |method|
-  puts <<~RUBY
-    # typed: strict
-
-    sig { params(arg: T.untyped).returns(T.untyped) }
-    def #{method}(arg = T.unsafe(nil)); end
-  RUBY
-end
diff --git a/Library/Homebrew/sorbet/plugins/def_delegator.rb b/Library/Homebrew/sorbet/plugins/def_delegator.rb
deleted file mode 100644
index 7eea2d6bd0..0000000000
--- a/Library/Homebrew/sorbet/plugins/def_delegator.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-source = ARGV[5]
-
-match = source.match(/\s*def_delegator\s+.*:(?<method>[^:]+)\s*\Z/m)
-
-raise if match.nil?
-
-method = match[:method]
-
-puts <<~RUBY
-  # typed: strict
-
-  sig {params(arg0: T.untyped, blk: T.untyped).returns(T.untyped)}
-  def #{method}(*arg0, &blk); end
-RUBY
diff --git a/Library/Homebrew/sorbet/plugins/def_delegators.rb b/Library/Homebrew/sorbet/plugins/def_delegators.rb
deleted file mode 100644
index ac09880d3c..0000000000
--- a/Library/Homebrew/sorbet/plugins/def_delegators.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-source = ARGV[5]
-
-symbols = source.scan(/:[^\s,]+/)
-
-_, *methods = symbols.map { |s| s.delete_prefix(":") }
-
-methods.each do |method|
-  puts <<~RUBY
-    # typed: strict
-
-    sig {params(arg0: T.untyped, blk: T.untyped).returns(T.untyped)}
-    def #{method}(*arg0, &blk); end
-  RUBY
-end
diff --git a/Library/Homebrew/sorbet/plugins/delegate.rb b/Library/Homebrew/sorbet/plugins/delegate.rb
deleted file mode 100644
index 8a249d188c..0000000000
--- a/Library/Homebrew/sorbet/plugins/delegate.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-source = ARGV[5]
-
-methods = if (single = source[/delegate\s+([^:]+):\s+/, 1])
-  [single]
-else
-  multiple = source[/delegate\s+\[(.*?)\]\s+=>\s+/m, 1]
-  non_comments = multiple.gsub(/\#.*$/, "")
-  non_comments.scan(/:([^:,\s]+)/).flatten
-end
-
-methods.each do |method|
-  puts <<~RUBY
-    # typed: strict
-
-    sig {params(arg0: T.untyped, blk: T.untyped).returns(T.untyped)}
-    def #{method}(*arg0, &blk); end
-  RUBY
-end
diff --git a/Library/Homebrew/sorbet/plugins/using.rb b/Library/Homebrew/sorbet/plugins/using.rb
deleted file mode 100644
index 288c4c6c44..0000000000
--- a/Library/Homebrew/sorbet/plugins/using.rb
+++ /dev/null
@@ -1,43 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-source = ARGV[5]
-
-case source[/\Ausing\s+(.*)\Z/, 1]
-when "Magic"
-  puts <<-RUBY
-    # typed: strict
-
-    class ::Pathname
-      sig { returns(String) }
-      def magic_number; end
-
-      sig { returns(String) }
-      def file_type; end
-
-      sig { returns(T::Array[String]) }
-      def zipinfo; end
-    end
-  RUBY
-when "HashValidator"
-  puts <<-RUBY
-    # typed: strict
-
-    class ::Hash
-      sig { params(valid_keys: T.untyped).void }
-      def assert_valid_keys!(*valid_keys); end
-    end
-  RUBY
-when "TimeRemaining"
-  puts <<-RUBY
-    # typed: strict
-
-    class ::Time
-      sig { returns(T.any(Integer, Float)) }
-      def remaining; end
-
-      sig { returns(T.any(Integer, Float)) }
-      def remaining!; end
-    end
-  RUBY
-end
diff --git a/Library/Homebrew/sorbet/rbi/parlour.rbi b/Library/Homebrew/sorbet/rbi/parlour.rbi
new file mode 100644
index 0000000000..ed2a0e5fcd
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/parlour.rbi
@@ -0,0 +1,164 @@
+# typed: strict
+module Homebrew
+  class Cleanup
+    sig { returns(T::Boolean) }
+    def dry_run?; end
+
+    sig { returns(T::Boolean) }
+    def scrub?; end
+
+    sig { returns(T::Boolean) }
+    def prune?; end
+  end
+end
+
+module Debrew
+  sig { returns(T::Boolean) }
+  def self.active?; end
+end
+
+class Formula
+  sig { params(arg: T.untyped).returns(T.untyped) }
+  def self.desc(arg = T.unsafe(nil)); end
+
+  sig { params(arg: T.untyped).returns(T.untyped) }
+  def self.homepage(arg = T.unsafe(nil)); end
+
+  sig { params(arg: T.untyped).returns(T.untyped) }
+  def self.revision(arg = T.unsafe(nil)); end
+
+  sig { params(arg: T.untyped).returns(T.untyped) }
+  def self.version_scheme(arg = T.unsafe(nil)); end
+end
+
+class FormulaInstaller
+  sig { returns(T::Boolean) }
+  def installed_as_dependency?; end
+
+  sig { returns(T::Boolean) }
+  def installed_on_request?; end
+
+  sig { returns(T::Boolean) }
+  def show_summary_heading?; end
+
+  sig { returns(T::Boolean) }
+  def show_header?; end
+
+  sig { returns(T::Boolean) }
+  def force_bottle?; end
+
+  sig { returns(T::Boolean) }
+  def ignore_deps?; end
+
+  sig { returns(T::Boolean) }
+  def only_deps?; end
+
+  sig { returns(T::Boolean) }
+  def interactive?; end
+
+  sig { returns(T::Boolean) }
+  def git?; end
+
+  sig { returns(T::Boolean) }
+  def force?; end
+
+  sig { returns(T::Boolean) }
+  def keep_tmp?; end
+
+  sig { returns(T::Boolean) }
+  def verbose?; end
+
+  sig { returns(T::Boolean) }
+  def debug?; end
+
+  sig { returns(T::Boolean) }
+  def quiet?; end
+
+  sig { returns(T::Boolean) }
+  def hold_locks?; end
+end
+
+class Requirement
+  sig { params(arg: T.untyped).returns(T.untyped) }
+  def self.fatal(arg = T.unsafe(nil)); end
+
+  sig { params(arg: T.untyped).returns(T.untyped) }
+  def self.cask(arg = T.unsafe(nil)); end
+
+  sig { params(arg: T.untyped).returns(T.untyped) }
+  def self.download(arg = T.unsafe(nil)); end
+end
+
+class BottleSpecification
+  sig { params(arg: T.untyped).returns(T.untyped) }
+  def rebuild(arg = T.unsafe(nil)); end
+end
+
+class SystemCommand
+  sig { returns(T::Boolean) }
+  def sudo?; end
+
+  sig { returns(T::Boolean) }
+  def print_stdout?; end
+
+  sig { returns(T::Boolean) }
+  def print_stderr?; end
+
+  sig { returns(T::Boolean) }
+  def must_succeed?; end
+end
+
+module Cask
+  class Audit
+    sig { returns(T::Boolean) }
+    def appcast?; end
+
+    sig { returns(T::Boolean) }
+    def new_cask?; end
+
+    sig { returns(T::Boolean) }
+    def strict?; end
+
+    sig { returns(T::Boolean) }
+    def online?; end
+
+    sig { returns(T::Boolean) }
+    def token_conflicts?; end
+  end
+
+  class DSL
+    class Caveats < Base
+      sig { returns(T::Boolean) }
+      def discontinued?; end
+    end
+  end
+
+  class Installer
+    sig { returns(T::Boolean) }
+    def binaries?; end
+
+    sig { returns(T::Boolean) }
+    def force?; end
+
+    sig { returns(T::Boolean) }
+    def skip_cask_deps?; end
+
+    sig { returns(T::Boolean) }
+    def require_sha?; end
+
+    sig { returns(T::Boolean) }
+    def reinstall?; end
+
+    sig { returns(T::Boolean) }
+    def upgrade?; end
+
+    sig { returns(T::Boolean) }
+    def verbose?; end
+
+    sig { returns(T::Boolean) }
+    def installed_as_dependency?; end
+
+    sig { returns(T::Boolean) }
+    def quarantine?; end
+  end
+end
diff --git a/Library/Homebrew/sorbet/triggers.yml b/Library/Homebrew/sorbet/triggers.yml
deleted file mode 100644
index ccf1647ba4..0000000000
--- a/Library/Homebrew/sorbet/triggers.yml
+++ /dev/null
@@ -1,10 +0,0 @@
-ruby_extra_args:
-  - --disable-gems
-
-triggers:
-  using: sorbet/plugins/using.rb
-  attr_predicate: sorbet/plugins/attr_predicate.rb
-  attr_rw: sorbet/plugins/attr_rw.rb
-  def_delegator: sorbet/plugins/def_delegator.rb
-  def_delegators: sorbet/plugins/def_delegators.rb
-  delegate: sorbet/plugins/delegate.rb
diff --git a/Library/Homebrew/unpack_strategy.rbi b/Library/Homebrew/unpack_strategy.rbi
index d7550c56b2..55284f6668 100644
--- a/Library/Homebrew/unpack_strategy.rbi
+++ b/Library/Homebrew/unpack_strategy.rbi
@@ -3,3 +3,14 @@
 module UnpackStrategy
   include Kernel
 end
+
+class Pathname
+  sig { returns(String) }
+  def magic_number; end
+
+  sig { returns(String) }
+  def file_type; end
+
+  sig { returns(T::Array[String]) }
+  def zipinfo; end
+end

From a5ff1b0b2ece36567d38a4ff7bee13d872d5ce3e Mon Sep 17 00:00:00 2001
From: Bo Anderson <mail@boanderson.me>
Date: Tue, 27 Jul 2021 04:44:40 +0100
Subject: [PATCH 04/13] Update Sorbet hidden definitions

---
 .../sorbet/rbi/hidden-definitions/hidden.rbi  | 1534 ++++++++++++++++-
 1 file changed, 1528 insertions(+), 6 deletions(-)

diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
index eaa201754b..27b549f2cd 100644
--- a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
+++ b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
@@ -2838,6 +2838,8 @@ end
 
 class Array
   include ::MessagePack::CoreExt
+  def abbrev(pattern=T.unsafe(nil)); end
+
   def compact_blank!(); end
 
   def extract_options!(); end
@@ -2874,6 +2876,8 @@ class Array
 end
 
 class Array
+  def self.parse(string); end
+
   def self.try_convert(_); end
 
   def self.wrap(object); end
@@ -2937,6 +2941,13 @@ class Binding
   def irb(); end
 end
 
+module Blank
+end
+
+module Blank
+  def self.included(base); end
+end
+
 module Bootsnap
   def bundler?(); end
   VERSION = ::T.let(nil, ::T.untyped)
@@ -5857,6 +5868,22 @@ module Cask::Utils
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
+class Caveats
+  def empty?(*args, &block); end
+
+  def to_s(*args, &block); end
+end
+
+class Checksum
+  def [](*args, &block); end
+
+  def empty?(*args, &block); end
+
+  def length(*args, &block); end
+
+  def to_s(*args, &block); end
+end
+
 class Class
   def any_instance(); end
 
@@ -6251,6 +6278,351 @@ module CodeRay
   def self.scanner(lang, options=T.unsafe(nil), &block); end
 end
 
+module Commander
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Commander::Command
+  def action(*args, &block); end
+
+  def call(args=T.unsafe(nil)); end
+
+  def description(); end
+
+  def description=(description); end
+
+  def example(description, command); end
+
+  def examples(); end
+
+  def examples=(examples); end
+
+  def global_options(); end
+
+  def initialize(name); end
+
+  def name(); end
+
+  def name=(name); end
+
+  def option(*args, &block); end
+
+  def option_proc(switches); end
+
+  def options(); end
+
+  def options=(options); end
+
+  def parse_options_and_call_procs(*args); end
+
+  def proxy_option_struct(); end
+
+  def proxy_options(); end
+
+  def proxy_options=(proxy_options); end
+
+  def run(*args); end
+
+  def summary(); end
+
+  def summary=(summary); end
+
+  def syntax(); end
+
+  def syntax=(syntax); end
+
+  def when_called(*args, &block); end
+end
+
+class Commander::Command::Options
+  include ::Blank
+  def __hash__(); end
+
+  def default(defaults=T.unsafe(nil)); end
+
+  def method_missing(meth, *args); end
+end
+
+class Commander::Command::Options
+end
+
+class Commander::Command
+end
+
+module Commander::Delegates
+  def add_command(*args, &block); end
+
+  def alias_command(*args, &block); end
+
+  def always_trace!(*args, &block); end
+
+  def command(*args, &block); end
+
+  def default_command(*args, &block); end
+
+  def defined_commands(*args, &block); end
+
+  def global_option(*args, &block); end
+
+  def never_trace!(*args, &block); end
+
+  def program(*args, &block); end
+
+  def run!(*args, &block); end
+end
+
+module Commander::Delegates
+end
+
+module Commander::HelpFormatter
+end
+
+class Commander::HelpFormatter::Base
+  def initialize(runner); end
+
+  def render(); end
+
+  def render_command(command); end
+end
+
+class Commander::HelpFormatter::Base
+end
+
+class Commander::HelpFormatter::Context
+  def decorate_binding(_bind); end
+
+  def initialize(target); end
+end
+
+class Commander::HelpFormatter::Context
+end
+
+class Commander::HelpFormatter::ProgramContext
+  def decorate_binding(bind); end
+
+  def max_aliases_length(bind); end
+
+  def max_command_length(bind); end
+
+  def max_key_length(hash, default=T.unsafe(nil)); end
+end
+
+class Commander::HelpFormatter::ProgramContext
+end
+
+class Commander::HelpFormatter::Terminal
+  def template(name); end
+end
+
+class Commander::HelpFormatter::Terminal
+end
+
+class Commander::HelpFormatter::TerminalCompact
+end
+
+class Commander::HelpFormatter::TerminalCompact
+end
+
+module Commander::HelpFormatter
+  def self.indent(amount, text); end
+end
+
+module Commander::Methods
+  include ::Commander::UI
+  include ::Commander::UI::AskForClass
+  include ::Commander::Delegates
+end
+
+module Commander::Methods
+end
+
+module Commander::Platform
+end
+
+module Commander::Platform
+  def self.jruby?(); end
+end
+
+class Commander::Runner
+  def active_command(); end
+
+  def add_command(command); end
+
+  def alias?(name); end
+
+  def alias_command(alias_name, name, *args); end
+
+  def always_trace!(); end
+
+  def args_without_command_name(); end
+
+  def command(name, &block); end
+
+  def command_exists?(name); end
+
+  def command_name_from_args(); end
+
+  def commands(); end
+
+  def create_default_commands(); end
+
+  def default_command(name); end
+
+  def expand_optionally_negative_switches(switches); end
+
+  def global_option(*args, &block); end
+
+  def global_option_proc(switches, &block); end
+
+  def help_formatter(); end
+
+  def help_formatter_alias_defaults(); end
+
+  def help_formatter_aliases(); end
+
+  def initialize(args=T.unsafe(nil)); end
+
+  def never_trace!(); end
+
+  def options(); end
+
+  def parse_global_options(); end
+
+  def program(key, *args, &block); end
+
+  def program_defaults(); end
+
+  def remove_global_options(options, args); end
+
+  def require_program(*keys); end
+
+  def require_valid_command(command=T.unsafe(nil)); end
+
+  def run!(); end
+
+  def run_active_command(); end
+
+  def say(*args); end
+
+  def valid_command_names_from(*args); end
+
+  def version(); end
+end
+
+class Commander::Runner::CommandError
+end
+
+class Commander::Runner::CommandError
+end
+
+class Commander::Runner::InvalidCommandError
+end
+
+class Commander::Runner::InvalidCommandError
+end
+
+class Commander::Runner
+  def self.instance(); end
+
+  def self.separate_switches_from_description(*args); end
+
+  def self.switch_to_sym(switch); end
+end
+
+module Commander::UI
+end
+
+module Commander::UI::AskForClass
+  def ask_for_array(prompt); end
+
+  def ask_for_file(prompt); end
+
+  def ask_for_float(prompt); end
+
+  def ask_for_integer(prompt); end
+
+  def ask_for_pathname(prompt); end
+
+  def ask_for_regexp(prompt); end
+
+  def ask_for_string(prompt); end
+
+  def ask_for_symbol(prompt); end
+
+  def method_missing(method_name, *arguments, &block); end
+  DEPRECATED_CONSTANTS = ::T.let(nil, ::T.untyped)
+end
+
+module Commander::UI::AskForClass
+end
+
+class Commander::UI::ProgressBar
+  def completed?(); end
+
+  def erase_line(); end
+
+  def finished?(); end
+
+  def generate_tokens(); end
+
+  def increment(tokens=T.unsafe(nil)); end
+
+  def initialize(total, options=T.unsafe(nil)); end
+
+  def percent_complete(); end
+
+  def progress_bar(); end
+
+  def show(); end
+
+  def steps_remaining(); end
+
+  def time_elapsed(); end
+
+  def time_remaining(); end
+end
+
+class Commander::UI::ProgressBar
+end
+
+module Commander::UI
+  def self.applescript(script); end
+
+  def self.ask_editor(input=T.unsafe(nil), preferred_editor=T.unsafe(nil)); end
+
+  def self.available_editor(preferred=T.unsafe(nil)); end
+
+  def self.choose(message=T.unsafe(nil), *choices, &block); end
+
+  def self.color(*args); end
+
+  def self.converse(prompt, responses=T.unsafe(nil)); end
+
+  def self.enable_paging(); end
+
+  def self.io(input=T.unsafe(nil), output=T.unsafe(nil), &block); end
+
+  def self.log(action, *args); end
+
+  def self.password(message=T.unsafe(nil), mask=T.unsafe(nil)); end
+
+  def self.progress(arr, options=T.unsafe(nil)); end
+
+  def self.replace_tokens(str, hash); end
+
+  def self.say_error(*args); end
+
+  def self.say_ok(*args); end
+
+  def self.say_warning(*args); end
+
+  def self.speak(message, voice=T.unsafe(nil), rate=T.unsafe(nil)); end
+end
+
+module Commander
+  def self.configure(*configuration_opts, &configuration_block); end
+end
+
 class CompilerSelector::Compiler
   def self.[](*_); end
 
@@ -7113,8 +7485,6 @@ end
 
 module Enumerable
   include ::ActiveSupport::ToJsonWithActiveSupportEncoder
-  def chain(*_); end
-
   def compact_blank(); end
 
   def exclude?(object); end
@@ -8237,6 +8607,1052 @@ class Hash
   def self.try_convert(_); end
 end
 
+class HighLine
+  include ::HighLine::BuiltinStyles
+  include ::HighLine::CustomErrors
+  def agree(yes_or_no_question, character=T.unsafe(nil)); end
+
+  def ask(template_or_question, answer_type=T.unsafe(nil), &details); end
+
+  def choose(*items, &details); end
+
+  def color(string, *colors); end
+
+  def color_code(*colors); end
+
+  def get_response_character_mode(question); end
+
+  def get_response_getc_mode(question); end
+
+  def get_response_line_mode(question); end
+
+  def indent(increase=T.unsafe(nil), statement=T.unsafe(nil), multiline=T.unsafe(nil)); end
+
+  def indent_level(); end
+
+  def indent_level=(indent_level); end
+
+  def indent_size(); end
+
+  def indent_size=(indent_size); end
+
+  def indentation(); end
+
+  def initialize(input=T.unsafe(nil), output=T.unsafe(nil), wrap_at=T.unsafe(nil), page_at=T.unsafe(nil), indent_size=T.unsafe(nil), indent_level=T.unsafe(nil)); end
+
+  def input(); end
+
+  def key(); end
+
+  def key=(key); end
+
+  def list(items, mode=T.unsafe(nil), option=T.unsafe(nil)); end
+
+  def multi_indent(); end
+
+  def multi_indent=(multi_indent); end
+
+  def new_scope(); end
+
+  def newline(); end
+
+  def output(); end
+
+  def output_cols(); end
+
+  def output_rows(); end
+
+  def page_at(); end
+
+  def page_at=(setting); end
+
+  def puts(*args); end
+
+  def render_statement(statement); end
+
+  def reset_use_color(); end
+
+  def say(statement); end
+
+  def shell_style_lambda(menu); end
+
+  def terminal(); end
+
+  def track_eof(); end
+
+  def track_eof=(track_eof); end
+
+  def track_eof?(); end
+
+  def uncolor(string); end
+
+  def use_color(); end
+
+  def use_color=(use_color); end
+
+  def use_color?(); end
+
+  def wrap_at(); end
+
+  def wrap_at=(setting); end
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+module HighLine::BuiltinStyles
+  BASIC_COLORS = ::T.let(nil, ::T.untyped)
+  BLACK = ::T.let(nil, ::T.untyped)
+  BLACK_STYLE = ::T.let(nil, ::T.untyped)
+  BLINK = ::T.let(nil, ::T.untyped)
+  BLINK_STYLE = ::T.let(nil, ::T.untyped)
+  BLUE = ::T.let(nil, ::T.untyped)
+  BLUE_STYLE = ::T.let(nil, ::T.untyped)
+  BOLD = ::T.let(nil, ::T.untyped)
+  BOLD_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_BLACK = ::T.let(nil, ::T.untyped)
+  BRIGHT_BLACK_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_BLUE = ::T.let(nil, ::T.untyped)
+  BRIGHT_BLUE_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_CYAN = ::T.let(nil, ::T.untyped)
+  BRIGHT_CYAN_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_GRAY = ::T.let(nil, ::T.untyped)
+  BRIGHT_GRAY_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_GREEN = ::T.let(nil, ::T.untyped)
+  BRIGHT_GREEN_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_GREY = ::T.let(nil, ::T.untyped)
+  BRIGHT_GREY_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_MAGENTA = ::T.let(nil, ::T.untyped)
+  BRIGHT_MAGENTA_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_NONE = ::T.let(nil, ::T.untyped)
+  BRIGHT_NONE_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_RED = ::T.let(nil, ::T.untyped)
+  BRIGHT_RED_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_WHITE = ::T.let(nil, ::T.untyped)
+  BRIGHT_WHITE_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_YELLOW = ::T.let(nil, ::T.untyped)
+  BRIGHT_YELLOW_STYLE = ::T.let(nil, ::T.untyped)
+  CLEAR = ::T.let(nil, ::T.untyped)
+  CLEAR_STYLE = ::T.let(nil, ::T.untyped)
+  COLORS = ::T.let(nil, ::T.untyped)
+  COLOR_LIST = ::T.let(nil, ::T.untyped)
+  CONCEALED = ::T.let(nil, ::T.untyped)
+  CONCEALED_STYLE = ::T.let(nil, ::T.untyped)
+  CYAN = ::T.let(nil, ::T.untyped)
+  CYAN_STYLE = ::T.let(nil, ::T.untyped)
+  DARK = ::T.let(nil, ::T.untyped)
+  DARK_STYLE = ::T.let(nil, ::T.untyped)
+  ERASE_CHAR = ::T.let(nil, ::T.untyped)
+  ERASE_CHAR_STYLE = ::T.let(nil, ::T.untyped)
+  ERASE_LINE = ::T.let(nil, ::T.untyped)
+  ERASE_LINE_STYLE = ::T.let(nil, ::T.untyped)
+  GRAY = ::T.let(nil, ::T.untyped)
+  GRAY_STYLE = ::T.let(nil, ::T.untyped)
+  GREEN = ::T.let(nil, ::T.untyped)
+  GREEN_STYLE = ::T.let(nil, ::T.untyped)
+  GREY = ::T.let(nil, ::T.untyped)
+  GREY_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_BLACK = ::T.let(nil, ::T.untyped)
+  LIGHT_BLACK_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_BLUE = ::T.let(nil, ::T.untyped)
+  LIGHT_BLUE_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_CYAN = ::T.let(nil, ::T.untyped)
+  LIGHT_CYAN_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_GRAY = ::T.let(nil, ::T.untyped)
+  LIGHT_GRAY_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_GREEN = ::T.let(nil, ::T.untyped)
+  LIGHT_GREEN_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_GREY = ::T.let(nil, ::T.untyped)
+  LIGHT_GREY_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_MAGENTA = ::T.let(nil, ::T.untyped)
+  LIGHT_MAGENTA_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_NONE = ::T.let(nil, ::T.untyped)
+  LIGHT_NONE_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_RED = ::T.let(nil, ::T.untyped)
+  LIGHT_RED_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_WHITE = ::T.let(nil, ::T.untyped)
+  LIGHT_WHITE_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_YELLOW = ::T.let(nil, ::T.untyped)
+  LIGHT_YELLOW_STYLE = ::T.let(nil, ::T.untyped)
+  MAGENTA = ::T.let(nil, ::T.untyped)
+  MAGENTA_STYLE = ::T.let(nil, ::T.untyped)
+  NONE = ::T.let(nil, ::T.untyped)
+  NONE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BLACK = ::T.let(nil, ::T.untyped)
+  ON_BLACK_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BLUE = ::T.let(nil, ::T.untyped)
+  ON_BLUE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_BLACK = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_BLACK_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_BLUE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_BLUE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_CYAN = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_CYAN_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_GRAY = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_GRAY_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_GREEN = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_GREEN_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_GREY = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_GREY_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_MAGENTA = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_MAGENTA_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_NONE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_NONE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_RED = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_RED_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_WHITE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_WHITE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_YELLOW = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_YELLOW_STYLE = ::T.let(nil, ::T.untyped)
+  ON_CYAN = ::T.let(nil, ::T.untyped)
+  ON_CYAN_STYLE = ::T.let(nil, ::T.untyped)
+  ON_GRAY = ::T.let(nil, ::T.untyped)
+  ON_GRAY_STYLE = ::T.let(nil, ::T.untyped)
+  ON_GREEN = ::T.let(nil, ::T.untyped)
+  ON_GREEN_STYLE = ::T.let(nil, ::T.untyped)
+  ON_GREY = ::T.let(nil, ::T.untyped)
+  ON_GREY_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_BLACK = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_BLACK_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_BLUE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_BLUE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_CYAN = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_CYAN_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_GRAY = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_GRAY_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_GREEN = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_GREEN_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_GREY = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_GREY_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_MAGENTA = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_MAGENTA_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_NONE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_NONE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_RED = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_RED_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_WHITE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_WHITE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_YELLOW = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_YELLOW_STYLE = ::T.let(nil, ::T.untyped)
+  ON_MAGENTA = ::T.let(nil, ::T.untyped)
+  ON_MAGENTA_STYLE = ::T.let(nil, ::T.untyped)
+  ON_NONE = ::T.let(nil, ::T.untyped)
+  ON_NONE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_RED = ::T.let(nil, ::T.untyped)
+  ON_RED_STYLE = ::T.let(nil, ::T.untyped)
+  ON_WHITE = ::T.let(nil, ::T.untyped)
+  ON_WHITE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_YELLOW = ::T.let(nil, ::T.untyped)
+  ON_YELLOW_STYLE = ::T.let(nil, ::T.untyped)
+  RED = ::T.let(nil, ::T.untyped)
+  RED_STYLE = ::T.let(nil, ::T.untyped)
+  RESET = ::T.let(nil, ::T.untyped)
+  RESET_STYLE = ::T.let(nil, ::T.untyped)
+  REVERSE = ::T.let(nil, ::T.untyped)
+  REVERSE_STYLE = ::T.let(nil, ::T.untyped)
+  STYLES = ::T.let(nil, ::T.untyped)
+  STYLE_LIST = ::T.let(nil, ::T.untyped)
+  UNDERLINE = ::T.let(nil, ::T.untyped)
+  UNDERLINE_STYLE = ::T.let(nil, ::T.untyped)
+  UNDERSCORE = ::T.let(nil, ::T.untyped)
+  UNDERSCORE_STYLE = ::T.let(nil, ::T.untyped)
+  WHITE = ::T.let(nil, ::T.untyped)
+  WHITE_STYLE = ::T.let(nil, ::T.untyped)
+  YELLOW = ::T.let(nil, ::T.untyped)
+  YELLOW_STYLE = ::T.let(nil, ::T.untyped)
+end
+
+module HighLine::BuiltinStyles::ClassMethods
+  def const_missing(name); end
+  RGB_COLOR_PATTERN = ::T.let(nil, ::T.untyped)
+end
+
+module HighLine::BuiltinStyles::ClassMethods
+end
+
+module HighLine::BuiltinStyles
+  def self.included(base); end
+end
+
+class HighLine::ColorScheme
+  def [](color_tag); end
+
+  def []=(color_tag, constants); end
+
+  def definition(color_tag); end
+
+  def include?(color_tag); end
+
+  def initialize(h=T.unsafe(nil)); end
+
+  def keys(); end
+
+  def load_from_hash(h); end
+
+  def to_hash(); end
+end
+
+class HighLine::ColorScheme
+end
+
+module HighLine::CustomErrors
+end
+
+class HighLine::CustomErrors::ExplainableError
+  def explanation_key(); end
+end
+
+class HighLine::CustomErrors::ExplainableError
+end
+
+class HighLine::CustomErrors::NoAutoCompleteMatch
+end
+
+class HighLine::CustomErrors::NoAutoCompleteMatch
+end
+
+class HighLine::CustomErrors::NoConfirmationQuestionError
+end
+
+class HighLine::CustomErrors::NoConfirmationQuestionError
+end
+
+class HighLine::CustomErrors::NotInRangeQuestionError
+end
+
+class HighLine::CustomErrors::NotInRangeQuestionError
+end
+
+class HighLine::CustomErrors::NotValidQuestionError
+end
+
+class HighLine::CustomErrors::NotValidQuestionError
+end
+
+class HighLine::CustomErrors::QuestionError
+end
+
+class HighLine::CustomErrors::QuestionError
+end
+
+module HighLine::CustomErrors
+end
+
+class HighLine::List
+  def col_down(); end
+
+  def col_down_mode(); end
+
+  def cols(); end
+
+  def cols=(cols); end
+
+  def initialize(items, options=T.unsafe(nil)); end
+
+  def items(); end
+
+  def list(); end
+
+  def row_join_str_size(); end
+
+  def row_join_string(); end
+
+  def row_join_string=(row_join_string); end
+
+  def slice_by_cols(); end
+
+  def slice_by_rows(); end
+
+  def to_a(); end
+
+  def transpose(); end
+
+  def transpose_mode(); end
+end
+
+class HighLine::List
+end
+
+class HighLine::ListRenderer
+  def highline(); end
+
+  def initialize(items, mode=T.unsafe(nil), option=T.unsafe(nil), highline); end
+
+  def items(); end
+
+  def mode(); end
+
+  def option(); end
+
+  def render(); end
+end
+
+class HighLine::ListRenderer
+end
+
+class HighLine::Menu
+  def add_item(item); end
+
+  def all_items(); end
+
+  def build_item(*args); end
+
+  def choice(name, help=T.unsafe(nil), text=T.unsafe(nil), &action); end
+
+  def choices(*names, &action); end
+
+  def decorate_index(index); end
+
+  def decorate_item(text, ix); end
+
+  def find_item_from_selection(items, selection); end
+
+  def flow(); end
+
+  def flow=(flow); end
+
+  def gather_selected(highline_context, selections, details=T.unsafe(nil)); end
+
+  def get_item_by_letter(items, selection); end
+
+  def get_item_by_number(items, selection); end
+
+  def header(); end
+
+  def header=(header); end
+
+  def help(topic, help); end
+
+  def hidden(name, help=T.unsafe(nil), &action); end
+
+  def index(); end
+
+  def index=(style); end
+
+  def index_color(); end
+
+  def index_color=(index_color); end
+
+  def index_suffix(); end
+
+  def index_suffix=(index_suffix); end
+
+  def init_help(); end
+
+  def initialize(); end
+
+  def layout(); end
+
+  def layout=(new_layout); end
+
+  def list_option(); end
+
+  def list_option=(list_option); end
+
+  def map_items_by_index(); end
+
+  def map_items_by_name(); end
+
+  def mark_for_decoration(text, ix); end
+
+  def nil_on_handled(); end
+
+  def nil_on_handled=(nil_on_handled); end
+
+  def options(); end
+
+  def parse_list(); end
+
+  def prompt(); end
+
+  def prompt=(prompt); end
+
+  def select(highline_context, selection, details=T.unsafe(nil)); end
+
+  def select_by(); end
+
+  def select_by=(select_by); end
+
+  def shell(); end
+
+  def shell=(shell); end
+
+  def show_default_if_any(); end
+
+  def to_ary(); end
+
+  def update_responses(); end
+
+  def value_for_array_selections(items, selections, details); end
+
+  def value_for_hash_selections(items, selections, details); end
+
+  def value_for_selected_item(item, details); end
+end
+
+class HighLine::Menu::Item
+  def action(); end
+
+  def help(); end
+
+  def initialize(name, attributes); end
+
+  def item_help(); end
+
+  def name(); end
+
+  def text(); end
+end
+
+class HighLine::Menu::Item
+end
+
+class HighLine::Menu
+  def self.index_color(); end
+
+  def self.index_color=(index_color); end
+end
+
+class HighLine::Paginator
+  def continue_paging?(); end
+
+  def highline(); end
+
+  def initialize(highline); end
+
+  def page_print(text); end
+end
+
+class HighLine::Paginator
+end
+
+class HighLine::Question
+  include ::HighLine::CustomErrors
+  def above(); end
+
+  def above=(above); end
+
+  def answer(); end
+
+  def answer=(answer); end
+
+  def answer_or_default(answer_string); end
+
+  def answer_type(); end
+
+  def answer_type=(answer_type); end
+
+  def ask_on_error_msg(); end
+
+  def below(); end
+
+  def below=(below); end
+
+  def build_responses(message_source=T.unsafe(nil)); end
+
+  def build_responses_new_hash(message_source); end
+
+  def case(); end
+
+  def case=(_); end
+
+  def change_case(answer_string); end
+
+  def character(); end
+
+  def character=(character); end
+
+  def check_range(); end
+
+  def choices_complete(answer_string); end
+
+  def completion(); end
+
+  def completion=(completion); end
+
+  def confirm(); end
+
+  def confirm=(confirm); end
+
+  def confirm_question(highline); end
+
+  def convert(); end
+
+  def default(); end
+
+  def default=(default); end
+
+  def default_responses_hash(); end
+
+  def directory(); end
+
+  def directory=(directory); end
+
+  def echo(); end
+
+  def echo=(echo); end
+
+  def expected_range(); end
+
+  def final_response(error); end
+
+  def final_responses(); end
+
+  def first_answer(); end
+
+  def first_answer=(first_answer); end
+
+  def first_answer?(); end
+
+  def format_answer(answer_string); end
+
+  def gather(); end
+
+  def gather=(gather); end
+
+  def get_echo_for_response(response); end
+
+  def get_response(highline); end
+
+  def get_response_or_default(highline); end
+
+  def glob(); end
+
+  def glob=(glob); end
+
+  def in(); end
+
+  def in=(_); end
+
+  def in_range?(); end
+
+  def initialize(template, answer_type); end
+
+  def limit(); end
+
+  def limit=(limit); end
+
+  def overwrite(); end
+
+  def overwrite=(overwrite); end
+
+  def readline(); end
+
+  def readline=(readline); end
+
+  def remove_whitespace(answer_string); end
+
+  def responses(); end
+
+  def selection(); end
+
+  def show_question(highline); end
+
+  def template(); end
+
+  def template=(template); end
+
+  def valid_answer?(); end
+
+  def validate(); end
+
+  def validate=(validate); end
+
+  def verify_match(); end
+
+  def verify_match=(verify_match); end
+
+  def whitespace(); end
+
+  def whitespace=(whitespace); end
+end
+
+class HighLine::Question::AnswerConverter
+  def answer(*args, &block); end
+
+  def answer=(*args, &block); end
+
+  def answer_type(*args, &block); end
+
+  def check_range(*args, &block); end
+
+  def choices_complete(*args, &block); end
+
+  def convert(); end
+
+  def directory(*args, &block); end
+
+  def initialize(question); end
+
+  def to_array(); end
+
+  def to_file(); end
+
+  def to_float(); end
+
+  def to_integer(); end
+
+  def to_pathname(); end
+
+  def to_proc(); end
+
+  def to_regexp(); end
+
+  def to_string(); end
+
+  def to_symbol(); end
+end
+
+class HighLine::Question::AnswerConverter
+  extend ::Forwardable
+end
+
+class HighLine::Question
+  def self.build(template_or_question, answer_type=T.unsafe(nil), &details); end
+end
+
+class HighLine::QuestionAsker
+  include ::HighLine::CustomErrors
+  def ask_once(); end
+
+  def gather_answers(); end
+
+  def gather_hash(); end
+
+  def gather_integer(); end
+
+  def gather_regexp(); end
+
+  def initialize(question, highline); end
+
+  def question(); end
+end
+
+class HighLine::QuestionAsker
+end
+
+class HighLine::SampleColorScheme
+  def initialize(_h=T.unsafe(nil)); end
+  SAMPLE_SCHEME = ::T.let(nil, ::T.untyped)
+end
+
+class HighLine::SampleColorScheme
+end
+
+class HighLine::Statement
+  def highline(); end
+
+  def initialize(source, highline); end
+
+  def source(); end
+
+  def statement(); end
+
+  def template_string(); end
+end
+
+class HighLine::Statement
+  def self.const_missing(constant); end
+end
+
+class HighLine::String
+  include ::HighLine::StringExtensions
+  def bright_black(); end
+
+  def bright_blue(); end
+
+  def bright_cyan(); end
+
+  def bright_gray(); end
+
+  def bright_green(); end
+
+  def bright_grey(); end
+
+  def bright_magenta(); end
+
+  def bright_none(); end
+
+  def bright_red(); end
+
+  def bright_white(); end
+
+  def bright_yellow(); end
+
+  def color(*args); end
+
+  def concealed(); end
+
+  def dark(); end
+
+  def foreground(*args); end
+
+  def gray(); end
+
+  def grey(); end
+
+  def light_gray(); end
+
+  def light_grey(); end
+
+  def light_none(); end
+
+  def method_missing(method, *_args); end
+
+  def none(); end
+
+  def on(arg); end
+
+  def on_bright_black(); end
+
+  def on_bright_blue(); end
+
+  def on_bright_cyan(); end
+
+  def on_bright_gray(); end
+
+  def on_bright_green(); end
+
+  def on_bright_grey(); end
+
+  def on_bright_magenta(); end
+
+  def on_bright_none(); end
+
+  def on_bright_red(); end
+
+  def on_bright_white(); end
+
+  def on_bright_yellow(); end
+
+  def on_gray(); end
+
+  def on_grey(); end
+
+  def on_light_gray(); end
+
+  def on_light_grey(); end
+
+  def on_light_none(); end
+
+  def on_none(); end
+
+  def on_rgb(*colors); end
+
+  def reset(); end
+
+  def rgb(*colors); end
+
+  def uncolor(); end
+end
+
+class HighLine::String
+end
+
+module HighLine::StringExtensions
+  STYLE_METHOD_NAME_PATTERN = ::T.let(nil, ::T.untyped)
+end
+
+module HighLine::StringExtensions
+  def self.define_builtin_style_methods(base); end
+
+  def self.define_style_support_methods(base); end
+
+  def self.included(base); end
+end
+
+class HighLine::Style
+  def blue(); end
+
+  def bright(); end
+
+  def builtin(); end
+
+  def builtin=(builtin); end
+
+  def code(); end
+
+  def color(string); end
+
+  def green(); end
+
+  def initialize(defn=T.unsafe(nil)); end
+
+  def light(); end
+
+  def list(); end
+
+  def name(); end
+
+  def on(); end
+
+  def red(); end
+
+  def rgb(); end
+
+  def rgb=(rgb); end
+
+  def to_hash(); end
+
+  def variant(new_name, options=T.unsafe(nil)); end
+end
+
+class HighLine::Style
+  def self.ansi_rgb_to_hex(ansi_number); end
+
+  def self.clear_index(); end
+
+  def self.code_index(); end
+
+  def self.index(style); end
+
+  def self.list(); end
+
+  def self.rgb(*colors); end
+
+  def self.rgb_hex(*colors); end
+
+  def self.rgb_number(*parts); end
+
+  def self.rgb_parts(hex); end
+
+  def self.uncolor(string); end
+end
+
+class HighLine::TemplateRenderer
+  def answer(*args, &block); end
+
+  def answer_type(*args, &block); end
+
+  def color(*args, &block); end
+
+  def header(*args, &block); end
+
+  def highline(); end
+
+  def initialize(template, source, highline); end
+
+  def key(*args, &block); end
+
+  def list(*args, &block); end
+
+  def menu(); end
+
+  def method_missing(method, *args); end
+
+  def prompt(*args, &block); end
+
+  def render(); end
+
+  def source(); end
+
+  def template(); end
+end
+
+class HighLine::TemplateRenderer
+  extend ::Forwardable
+  def self.const_missing(name); end
+end
+
+class HighLine::Terminal
+  def character_mode(); end
+
+  def get_character(); end
+
+  def get_line(question, highline); end
+
+  def get_line_default(highline); end
+
+  def get_line_with_readline(question, highline); end
+
+  def initialize(input, output); end
+
+  def initialize_system_extensions(); end
+
+  def input(); end
+
+  def jruby?(); end
+
+  def output(); end
+
+  def raw_no_echo_mode(); end
+
+  def raw_no_echo_mode_exec(); end
+
+  def readline_read(question); end
+
+  def restore_mode(); end
+
+  def rubinius?(); end
+
+  def terminal_size(); end
+
+  def windows?(); end
+end
+
+class HighLine::Terminal::IOConsole
+end
+
+class HighLine::Terminal::IOConsole
+end
+
+class HighLine::Terminal
+  def self.get_terminal(input, output); end
+end
+
+module HighLine::Wrapper
+end
+
+module HighLine::Wrapper
+  def self.actual_length(string_with_escapes); end
+
+  def self.wrap(text, wrap_at); end
+end
+
+class HighLine
+  extend ::HighLine::BuiltinStyles::ClassMethods
+  extend ::SingleForwardable
+  def self.String(s); end
+
+  def self.Style(*args); end
+
+  def self.color(*args, &block); end
+
+  def self.color_code(*args, &block); end
+
+  def self.color_scheme(); end
+
+  def self.color_scheme=(color_scheme); end
+
+  def self.colorize_strings(); end
+
+  def self.default_instance(); end
+
+  def self.default_instance=(default_instance); end
+
+  def self.find_or_create_style(arg); end
+
+  def self.find_or_create_style_list(*args); end
+
+  def self.reset(); end
+
+  def self.reset_color_scheme(); end
+
+  def self.reset_use_color(*args, &block); end
+
+  def self.supports_rgb_color?(); end
+
+  def self.track_eof=(*args, &block); end
+
+  def self.track_eof?(*args, &block); end
+
+  def self.uncolor(*args, &block); end
+
+  def self.use_color=(*args, &block); end
+
+  def self.use_color?(*args, &block); end
+
+  def self.using_color_scheme?(); end
+end
+
 module Homebrew
   MAX_PORT = ::T.let(nil, ::T.untyped)
   MIN_PORT = ::T.let(nil, ::T.untyped)
@@ -8566,6 +9982,31 @@ module Homebrew::Livecheck::Strategy
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
+module Homebrew::Parlour
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+class Homebrew::Service
+  def bin(*args, &block); end
+
+  def etc(*args, &block); end
+
+  def libexec(*args, &block); end
+
+  def opt_bin(*args, &block); end
+
+  def opt_libexec(*args, &block); end
+
+  def opt_pkgshare(*args, &block); end
+
+  def opt_prefix(*args, &block); end
+
+  def opt_sbin(*args, &block); end
+
+  def var(*args, &block); end
+end
+
 class Homebrew::Service
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
@@ -9900,18 +11341,27 @@ end
 module Kernel
   include ::ActiveSupport::ForkTracker::CoreExtPrivate
   include ::ActiveSupport::ForkTracker::CoreExt
+  def agree(*args, &block); end
+
+  def ask(*args, &block); end
+
+  def choose(*args, &block); end
+
   def itself(); end
 
   def object_id(); end
 
   def pretty_inspect(); end
 
+  def say(*args, &block); end
+
   def then(); end
 
   def yield_self(); end
 end
 
 module Kernel
+  extend ::Forwardable
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
   def self.at_exit(); end
@@ -11288,6 +12738,12 @@ module MachO
   def self.open(filename); end
 end
 
+module MachOShim
+  def dylib_id(*args, &block); end
+
+  def rpaths(*args, &block); end
+end
+
 Markdown = RDiscount
 
 module MessagePack
@@ -12581,9 +14037,13 @@ Net::HTTPServerErrorCode = Net::HTTPServerError
 
 Net::HTTPSession = Net::HTTP
 
-Net::HTTPSuccess::EXCEPTION_TYPE = Net::HTTPError
+class Net::HTTPSuccess
+end
 
-Net::HTTPSuccessCode = Net::HTTPSuccess
+Net::HTTPSuccessCode::EXCEPTION_TYPE = Net::HTTPError
+
+class Net::HTTPSuccess
+end
 
 class Net::HTTPURITooLong
   HAS_BODY = ::T.let(nil, ::T.untyped)
@@ -12742,8 +14202,12 @@ class Object
   include ::ActiveSupport::ForkTracker::CoreExt
   def acts_like?(duck); end
 
+  def get_binding(); end
+
   def html_safe?(); end
 
+  def or_ask(*args, &details); end
+
   def pry(object=T.unsafe(nil), hash=T.unsafe(nil)); end
 
   def stub(name, val_or_callable, *block_args); end
@@ -12911,8 +14375,6 @@ module OpenSSL::SSL
 end
 
 class OpenSSL::SSL::SSLContext
-  def add_certificate(*_); end
-
   def alpn_protocols(); end
 
   def alpn_protocols=(alpn_protocols); end
@@ -12980,6 +14442,10 @@ class Options
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
+class PATH
+  def each(*args, &block); end
+end
+
 class PATH
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
@@ -14085,6 +15551,18 @@ class Pathname
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
+class PkgVersion
+  def major(*args, &block); end
+
+  def major_minor(*args, &block); end
+
+  def major_minor_patch(*args, &block); end
+
+  def minor(*args, &block); end
+
+  def patch(*args, &block); end
+end
+
 class Proc
   include ::MethodSource::SourceLocation::ProcExtensions
   include ::MethodSource::MethodExtensions
@@ -20069,6 +21547,8 @@ class RSpec::Core::OutputWrapper
 
   def autoclose?(*args, &block); end
 
+  def beep(*args, &block); end
+
   def binmode(*args, &block); end
 
   def binmode?(*args, &block); end
@@ -20091,6 +21571,14 @@ class RSpec::Core::OutputWrapper
 
   def codepoints(*args, &block); end
 
+  def cooked(*args, &block); end
+
+  def cooked!(*args, &block); end
+
+  def cursor(*args, &block); end
+
+  def cursor=(*args, &block); end
+
   def each(*args, &block); end
 
   def each_byte(*args, &block); end
@@ -20101,6 +21589,10 @@ class RSpec::Core::OutputWrapper
 
   def each_line(*args, &block); end
 
+  def echo=(*args, &block); end
+
+  def echo?(*args, &block); end
+
   def eof(*args, &block); end
 
   def eof?(*args, &block); end
@@ -20121,8 +21613,16 @@ class RSpec::Core::OutputWrapper
 
   def getc(*args, &block); end
 
+  def getch(*args, &block); end
+
+  def getpass(*args, &block); end
+
   def gets(*args, &block); end
 
+  def goto(*args, &block); end
+
+  def iflush(*args, &block); end
+
   def initialize(output); end
 
   def inspect(*args, &block); end
@@ -20131,6 +21631,8 @@ class RSpec::Core::OutputWrapper
 
   def ioctl(*args, &block); end
 
+  def ioflush(*args, &block); end
+
   def isatty(*args, &block); end
 
   def lineno(*args, &block); end
@@ -20141,6 +21643,8 @@ class RSpec::Core::OutputWrapper
 
   def method_missing(name, *args, &block); end
 
+  def noecho(*args, &block); end
+
   def nonblock(*args, &block); end
 
   def nonblock=(*args, &block); end
@@ -20149,6 +21653,8 @@ class RSpec::Core::OutputWrapper
 
   def nread(*args, &block); end
 
+  def oflush(*args, &block); end
+
   def output(); end
 
   def output=(output); end
@@ -20163,6 +21669,8 @@ class RSpec::Core::OutputWrapper
 
   def pread(*args, &block); end
 
+  def pressed?(*args, &block); end
+
   def print(*args, &block); end
 
   def printf(*args, &block); end
@@ -20173,6 +21681,10 @@ class RSpec::Core::OutputWrapper
 
   def pwrite(*args, &block); end
 
+  def raw(*args, &block); end
+
+  def raw!(*args, &block); end
+
   def read(*args, &block); end
 
   def read_nonblock(*args, &block); end
@@ -20229,6 +21741,10 @@ class RSpec::Core::OutputWrapper
 
   def wait_writable(*args, &block); end
 
+  def winsize(*args, &block); end
+
+  def winsize=(*args, &block); end
+
   def write(*args, &block); end
 
   def write_nonblock(*args, &block); end
@@ -26841,6 +28357,8 @@ end
 RspecJunitFormatter = RSpecJUnitFormatter
 
 module RuboCop::AST::CollectionNode
+  def abbrev(*args, &block); end
+
   def compact_blank(*args, &block); end
 
   def compact_blank!(*args, &block); end
@@ -29948,6 +31466,10 @@ class User
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
+class Utils::AST::FormulaAST
+  def process(*args, &block); end
+end
+
 class Utils::AST::FormulaAST
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks

From cee86846ce1115fc4fd85010526104c292280d7f Mon Sep 17 00:00:00 2001
From: Bo Anderson <mail@boanderson.me>
Date: Tue, 27 Jul 2021 05:12:15 +0100
Subject: [PATCH 05/13] Fix Sorbet violations.

---
 Library/Homebrew/cli/args.rb                |  2 +-
 Library/Homebrew/cmd/home.rb                |  4 +++-
 Library/Homebrew/sorbet/parlour.rb          | 10 ++++++----
 Library/Homebrew/sorbet/parlour/attr.rb     | 18 ++++++++++--------
 Library/Homebrew/version.rb                 |  1 +
 Library/Homebrew/yard/ignore_directives.rbi |  6 ++++++
 6 files changed, 27 insertions(+), 14 deletions(-)
 create mode 100644 Library/Homebrew/yard/ignore_directives.rbi

diff --git a/Library/Homebrew/cli/args.rb b/Library/Homebrew/cli/args.rb
index ba341a36f1..49a9940541 100644
--- a/Library/Homebrew/cli/args.rb
+++ b/Library/Homebrew/cli/args.rb
@@ -68,7 +68,7 @@ module Homebrew
 
       def build_from_source_formulae
         if build_from_source? || self[:HEAD?] || self[:build_bottle?]
-          named.to_formulae_and_casks.select { |f| f.is_a?(Formula) }.map(&:full_name)
+          named.to_formulae.map(&:full_name)
         else
           []
         end
diff --git a/Library/Homebrew/cmd/home.rb b/Library/Homebrew/cmd/home.rb
index 125aeb8ff1..649c3d09da 100644
--- a/Library/Homebrew/cmd/home.rb
+++ b/Library/Homebrew/cmd/home.rb
@@ -36,7 +36,9 @@ module Homebrew
       return
     end
 
-    homepages = args.named.to_formulae_and_casks.map do |formula_or_cask|
+    # to_formulae_and_casks is typed to possibly return Kegs (but won't without explicitly asking)
+    formulae_or_casks = T.cast(args.named.to_formulae_and_casks, T::Array[T.any(Formula, Cask::Cask)])
+    homepages = formulae_or_casks.map do |formula_or_cask|
       puts "Opening homepage for #{name_of(formula_or_cask)}"
       formula_or_cask.homepage
     end
diff --git a/Library/Homebrew/sorbet/parlour.rb b/Library/Homebrew/sorbet/parlour.rb
index c33a64dc8c..102df89819 100644
--- a/Library/Homebrew/sorbet/parlour.rb
+++ b/Library/Homebrew/sorbet/parlour.rb
@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: true
+# frozen_string_literal: true
 
 require_relative "../warnings"
 Warnings.ignore :parser_syntax do
@@ -7,19 +7,21 @@ Warnings.ignore :parser_syntax do
 end
 
 module Homebrew
+  # Parlour type signature generator helper class for Homebrew.
   module Parlour
     extend T::Sig
 
-    ROOT_DIR = T.let(Pathname(__dir__).parent.realpath.freeze, Pathname)
+    ROOT_DIR = T.let(Pathname(__dir__).parent.realpath.freeze, Pathname).freeze
 
     sig { returns(T::Array[Parser::AST::Node]) }
     def self.ast_list
-      @@ast_list ||= begin
+      @ast_list ||= begin
         ast_list = []
         parser = Parser::CurrentRuby.new
+        prune_dirs = %w[sorbet shims test vendor].freeze
 
         ROOT_DIR.find do |path|
-          Find.prune if path.directory? && %w[sorbet shims test vendor].any? { |subdir| path == ROOT_DIR/subdir }
+          Find.prune if path.directory? && prune_dirs.any? { |subdir| path == ROOT_DIR/subdir }
 
           Find.prune if path.file? && path.extname != ".rb"
 
diff --git a/Library/Homebrew/sorbet/parlour/attr.rb b/Library/Homebrew/sorbet/parlour/attr.rb
index 8f8c4bf8fd..20be56b7c5 100644
--- a/Library/Homebrew/sorbet/parlour/attr.rb
+++ b/Library/Homebrew/sorbet/parlour/attr.rb
@@ -1,6 +1,7 @@
-# frozen_string_literal: true
 # typed: strict
+# frozen_string_literal: true
 
+# Parlour type signature generator plugin for Homebrew DSL attributes.
 class Attr < Parlour::Plugin
   sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
   def generate(root)
@@ -13,7 +14,7 @@ class Attr < Parlour::Plugin
 
   sig { override.returns(T.nilable(String)) }
   def strictness
-    return "strict"
+    "strict"
   end
 
   private
@@ -32,7 +33,7 @@ class Attr < Parlour::Plugin
 
     traverse_module_name(node).join("::")
   end
-    
+
   sig { params(node: Parser::AST::Node).returns(T::Array[T.untyped]) }
   def find_custom_attr(node)
     tree = T.let([], T::Array[T.untyped])
@@ -46,15 +47,16 @@ class Attr < Parlour::Plugin
     elsif node.type == :sclass
       subtree = find_custom_attr(node.children[1])
       return tree if subtree.empty?
-      
+
       tree << [:sclass, subtree]
     elsif node.type == :class || node.type == :module
       element = []
-      if node.type == :class
+      case node.type
+      when :class
         element << :class
         element << extract_module_name(children.shift)
         element << extract_module_name(children.shift)
-      elsif node.type == :module
+      when :module
         element << :module
         element << extract_module_name(children.shift)
       end
@@ -69,7 +71,7 @@ class Attr < Parlour::Plugin
       tree << element
     elsif node.type == :send && children.shift.nil?
       method_name = children.shift
-      if method_name == :attr_rw || method_name == :attr_predicate
+      if [:attr_rw, :attr_predicate].include?(method_name)
         children.each do |name_node|
           tree << [method_name, name_node.children.first.to_s]
         end
@@ -96,7 +98,7 @@ class Attr < Parlour::Plugin
         name = node.shift
         name = "self.#{name}" if sclass
         namespace.create_method(name, parameters: [
-          Parlour::RbiGenerator::Parameter.new("arg", type: "T.untyped", default: "T.unsafe(nil)")
+          Parlour::RbiGenerator::Parameter.new("arg", type: "T.untyped", default: "T.unsafe(nil)"),
         ], return_type: "T.untyped")
       when :attr_predicate
         name = node.shift
diff --git a/Library/Homebrew/version.rb b/Library/Homebrew/version.rb
index bab7e36e69..9ab1b12f55 100644
--- a/Library/Homebrew/version.rb
+++ b/Library/Homebrew/version.rb
@@ -39,6 +39,7 @@ class Version
       when /\A#{PostToken::PATTERN}\z/o    then PostToken
       when /\A#{NumericToken::PATTERN}\z/o then NumericToken
       when /\A#{StringToken::PATTERN}\z/o  then StringToken
+      else raise "Cannot find a matching token pattern"
       end.new(val)
     end
 
diff --git a/Library/Homebrew/yard/ignore_directives.rbi b/Library/Homebrew/yard/ignore_directives.rbi
new file mode 100644
index 0000000000..caf505de9c
--- /dev/null
+++ b/Library/Homebrew/yard/ignore_directives.rbi
@@ -0,0 +1,6 @@
+# typed: strict
+
+module YARD
+  class Docstring; end
+  class DocstringParser; end
+end

From dc2b55f383d09cb0365811460b6a0191ef064eee Mon Sep 17 00:00:00 2001
From: BrewTestBot <1589480+BrewTestBot@users.noreply.github.com>
Date: Tue, 27 Jul 2021 04:18:21 +0000
Subject: [PATCH 06/13] Update RBI files for sorbet.

---
 Library/Homebrew/sorbet/rbi/todo.rbi | 2 --
 1 file changed, 2 deletions(-)

diff --git a/Library/Homebrew/sorbet/rbi/todo.rbi b/Library/Homebrew/sorbet/rbi/todo.rbi
index ecceecfa9d..ca35a66298 100644
--- a/Library/Homebrew/sorbet/rbi/todo.rbi
+++ b/Library/Homebrew/sorbet/rbi/todo.rbi
@@ -3,8 +3,6 @@
 
 # typed: strong
 module ::StackProf; end
-module ::YARD::Docstring; end
-module ::YARD::DocstringParser; end
 module DependencyCollector::Compat; end
 module GitHubPackages::JSONSchemer; end
 module OS::Mac::Version::NULL; end

From ff15e091ecc5bd88bd44d7c16e6a58cdd112cb0d Mon Sep 17 00:00:00 2001
From: Bo Anderson <mail@boanderson.me>
Date: Fri, 6 Aug 2021 14:03:18 +0100
Subject: [PATCH 07/13] Add RBI file for Formula delegate methods

---
 Library/Homebrew/formula.rbi | 54 ++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 Library/Homebrew/formula.rbi

diff --git a/Library/Homebrew/formula.rbi b/Library/Homebrew/formula.rbi
new file mode 100644
index 0000000000..360ab51722
--- /dev/null
+++ b/Library/Homebrew/formula.rbi
@@ -0,0 +1,54 @@
+# typed: strict
+
+# This file provides definitions for Forwardable#delegate, which is currently not supported by Sorbet.
+
+class Formula
+  def bottle_unneeded?; end
+  def bottle_disabled?; end
+  def bottle_disable_reason; end
+  def bottle_defined?; end
+  def bottle_tag?; end
+  def bottled?; end
+  def bottle_specification; end
+  def downloader; end
+
+  def desc; end
+  def license; end
+  def homepage; end
+  def livecheck; end
+  def livecheckable?; end
+  def service?; end
+  def version; end
+
+  def resource; end
+  def deps; end
+  def uses_from_macos_elements; end
+  def requirements; end
+  def cached_download; end
+  def clear_cache; end
+  def options; end
+  def deprecated_options; end
+  def deprecated_flags; end
+  def option_defined?; end
+  def compiler_failures; end
+
+  def plist_manual; end
+  def plist_startup; end
+  def pour_bottle_check_unsatisfied_reason; end
+  def keg_only_reason; end
+  def deprecated?; end
+  def deprecation_date; end
+  def deprecation_reason; end
+  def disabled?; end
+  def disable_date; end
+  def disable_reason; end
+
+  def pinnable?; end
+  def pinned?; end
+  def pinned_version; end
+  def pin; end
+  def unpin; end
+
+  def env; end
+  def conflicts; end
+end

From b48d56122506f15c10fe8c352b0310966de6d73d Mon Sep 17 00:00:00 2001
From: BrewTestBot <1589480+BrewTestBot@users.noreply.github.com>
Date: Fri, 6 Aug 2021 13:06:58 +0000
Subject: [PATCH 08/13] brew vendor-gems: commit updates.

---
 Library/Homebrew/Gemfile.lock                   | 8 ++++----
 Library/Homebrew/vendor/bundle/bundler/setup.rb | 6 +++---
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/Library/Homebrew/Gemfile.lock b/Library/Homebrew/Gemfile.lock
index 99689717d8..3f6e207f2a 100644
--- a/Library/Homebrew/Gemfile.lock
+++ b/Library/Homebrew/Gemfile.lock
@@ -146,11 +146,11 @@ GEM
       simplecov (~> 0.8)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.3)
-    sorbet (0.5.6519)
-      sorbet-static (= 0.5.6519)
-    sorbet-runtime (0.5.6519)
+    sorbet (0.5.9013)
+      sorbet-static (= 0.5.9013)
+    sorbet-runtime (0.5.9013)
     sorbet-runtime-stub (0.2.0)
-    sorbet-static (0.5.6519-universal-darwin-14)
+    sorbet-static (0.5.9013-universal-darwin-14)
     spoom (1.0.9)
       colorize
       sorbet (~> 0.5.5)
diff --git a/Library/Homebrew/vendor/bundle/bundler/setup.rb b/Library/Homebrew/vendor/bundle/bundler/setup.rb
index 8a71060db5..5565d0185b 100644
--- a/Library/Homebrew/vendor/bundle/bundler/setup.rb
+++ b/Library/Homebrew/vendor/bundle/bundler/setup.rb
@@ -54,7 +54,7 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parallel-1.20.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parallel_tests-3.7.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parser-3.0.2.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rainbow-3.0.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-runtime-0.5.6519/lib"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-runtime-0.5.9013/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parlour-6.0.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/patchelf-1.3.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/plist-3.6.0/lib"
@@ -73,8 +73,8 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-3.10.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-github-2.3.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-its-1.3.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-retry-0.6.2/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-static-0.5.6519-universal-darwin-14/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-0.5.6519/lib"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-static-0.5.9013-universal-darwin-14/lib"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-0.5.9013/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-sorbet-1.8.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-wait-0.0.9/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec_junit_formatter-0.4.1/lib"

From ce887063de7e1127651e7d9d227eefdb9ffd905c Mon Sep 17 00:00:00 2001
From: Mike McQuaid <mike@mikemcquaid.com>
Date: Wed, 11 Aug 2021 09:13:41 +0100
Subject: [PATCH 09/13] Update sorbet

---
 Library/Homebrew/Gemfile.lock | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/Library/Homebrew/Gemfile.lock b/Library/Homebrew/Gemfile.lock
index 3f6e207f2a..90f7e2681d 100644
--- a/Library/Homebrew/Gemfile.lock
+++ b/Library/Homebrew/Gemfile.lock
@@ -146,17 +146,17 @@ GEM
       simplecov (~> 0.8)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.3)
-    sorbet (0.5.9013)
-      sorbet-static (= 0.5.9013)
-    sorbet-runtime (0.5.9013)
+    sorbet (0.5.9030)
+      sorbet-static (= 0.5.9030)
+    sorbet-runtime (0.5.9030)
     sorbet-runtime-stub (0.2.0)
-    sorbet-static (0.5.9013-universal-darwin-14)
-    spoom (1.0.9)
+    sorbet-static (0.5.9030-universal-darwin-14)
+    spoom (1.1.2)
       colorize
-      sorbet (~> 0.5.5)
+      sorbet (>= 0.5.6347)
       sorbet-runtime
       thor (>= 0.19.2)
-    tapioca (0.4.23)
+    tapioca (0.4.24)
       bundler (>= 1.17.3)
       parlour (>= 2.1.0)
       pry (>= 0.12.2)

From 0c337c4c123299cfd1695d4023718d981f597342 Mon Sep 17 00:00:00 2001
From: Mike McQuaid <mike@mikemcquaid.com>
Date: Wed, 11 Aug 2021 09:14:58 +0100
Subject: [PATCH 10/13] brew vendor-gems: commit updates.

---
 .../Homebrew/vendor/bundle/bundler/setup.rb   | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/Library/Homebrew/vendor/bundle/bundler/setup.rb b/Library/Homebrew/vendor/bundle/bundler/setup.rb
index 5565d0185b..7270ac5c09 100644
--- a/Library/Homebrew/vendor/bundle/bundler/setup.rb
+++ b/Library/Homebrew/vendor/bundle/bundler/setup.rb
@@ -13,12 +13,12 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/public_suffix-4.0.6/l
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/addressable-2.8.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/ast-2.4.2/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/bindata-2.4.10/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-14/2.6.0-static/msgpack-1.4.2"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/universal-darwin-20/2.6.0/msgpack-1.4.2"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/msgpack-1.4.2/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-14/2.6.0-static/bootsnap-1.7.5"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/universal-darwin-20/2.6.0/bootsnap-1.7.5"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/bootsnap-1.7.5/lib"
 $:.unshift "#{path}/"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-14/2.6.0-static/byebug-11.1.3"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/universal-darwin-20/2.6.0/byebug-11.1.3"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/byebug-11.1.3/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/coderay-1.1.3/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/colorize-0.8.1/lib"
@@ -28,12 +28,12 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/connection_pool-2.2.5
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/did_you_mean-1.5.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/diff-lcs-1.4.4/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/docile-1.4.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-14/2.6.0-static/unf_ext-0.0.7.7"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/universal-darwin-20/2.6.0/unf_ext-0.0.7.7"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/unf_ext-0.0.7.7/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/unf-0.1.4/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/domain_name-0.5.20190701/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/elftools-1.1.3/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-14/2.6.0-static/hpricot-0.8.6"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/universal-darwin-20/2.6.0/hpricot-0.8.6"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/hpricot-0.8.6/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/http-cookie-1.0.4/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/mime-types-data-3.2021.0704/lib"
@@ -41,7 +41,7 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/mime-types-3.3.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/net-http-digest_auth-1.4.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/net-http-persistent-4.0.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/mini_portile2-2.5.3/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-14/2.6.0-static/racc-1.5.2"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/universal-darwin-20/2.6.0/racc-1.5.2"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/racc-1.5.2/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/nokogiri-1.11.7-x86_64-darwin/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rubyntlm-0.6.3/lib"
@@ -54,13 +54,13 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parallel-1.20.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parallel_tests-3.7.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parser-3.0.2.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rainbow-3.0.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-runtime-0.5.9013/lib"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-runtime-0.5.9030/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parlour-6.0.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/patchelf-1.3.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/plist-3.6.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/pry-0.14.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rack-2.2.3/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-14/2.6.0-static/rdiscount-2.2.0.2"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/universal-darwin-20/2.6.0/rdiscount-2.2.0.2"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rdiscount-2.2.0.2/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/regexp_parser-2.1.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rexml-3.2.5/lib"
@@ -73,8 +73,8 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-3.10.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-github-2.3.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-its-1.3.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-retry-0.6.2/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-static-0.5.9013-universal-darwin-14/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-0.5.9013/lib"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-static-0.5.9030-universal-darwin-20/lib"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-0.5.9030/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-sorbet-1.8.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-wait-0.0.9/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec_junit_formatter-0.4.1/lib"
@@ -93,6 +93,6 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/simplecov-0.21.2/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/simplecov-cobertura-1.4.2/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-runtime-stub-0.2.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/thor-1.1.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/spoom-1.0.9/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/tapioca-0.4.23/lib"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/spoom-1.1.2/lib"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/tapioca-0.4.24/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/warning-1.2.0/lib"

From 99be6d930260491df6f0241c9e8bf846c14ab835 Mon Sep 17 00:00:00 2001
From: BrewTestBot <1589480+BrewTestBot@users.noreply.github.com>
Date: Wed, 11 Aug 2021 08:26:20 +0000
Subject: [PATCH 11/13] brew vendor-gems: commit updates.

---
 Library/Homebrew/vendor/bundle/bundler/setup.rb | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/Library/Homebrew/vendor/bundle/bundler/setup.rb b/Library/Homebrew/vendor/bundle/bundler/setup.rb
index 7270ac5c09..1e452e5aff 100644
--- a/Library/Homebrew/vendor/bundle/bundler/setup.rb
+++ b/Library/Homebrew/vendor/bundle/bundler/setup.rb
@@ -13,12 +13,12 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/public_suffix-4.0.6/l
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/addressable-2.8.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/ast-2.4.2/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/bindata-2.4.10/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/universal-darwin-20/2.6.0/msgpack-1.4.2"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-14/2.6.0-static/msgpack-1.4.2"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/msgpack-1.4.2/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/universal-darwin-20/2.6.0/bootsnap-1.7.5"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-14/2.6.0-static/bootsnap-1.7.5"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/bootsnap-1.7.5/lib"
 $:.unshift "#{path}/"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/universal-darwin-20/2.6.0/byebug-11.1.3"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-14/2.6.0-static/byebug-11.1.3"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/byebug-11.1.3/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/coderay-1.1.3/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/colorize-0.8.1/lib"
@@ -28,12 +28,12 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/connection_pool-2.2.5
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/did_you_mean-1.5.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/diff-lcs-1.4.4/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/docile-1.4.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/universal-darwin-20/2.6.0/unf_ext-0.0.7.7"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-14/2.6.0-static/unf_ext-0.0.7.7"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/unf_ext-0.0.7.7/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/unf-0.1.4/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/domain_name-0.5.20190701/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/elftools-1.1.3/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/universal-darwin-20/2.6.0/hpricot-0.8.6"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-14/2.6.0-static/hpricot-0.8.6"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/hpricot-0.8.6/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/http-cookie-1.0.4/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/mime-types-data-3.2021.0704/lib"
@@ -41,7 +41,7 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/mime-types-3.3.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/net-http-digest_auth-1.4.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/net-http-persistent-4.0.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/mini_portile2-2.5.3/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/universal-darwin-20/2.6.0/racc-1.5.2"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-14/2.6.0-static/racc-1.5.2"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/racc-1.5.2/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/nokogiri-1.11.7-x86_64-darwin/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rubyntlm-0.6.3/lib"
@@ -60,7 +60,7 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/patchelf-1.3.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/plist-3.6.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/pry-0.14.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rack-2.2.3/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/universal-darwin-20/2.6.0/rdiscount-2.2.0.2"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-14/2.6.0-static/rdiscount-2.2.0.2"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rdiscount-2.2.0.2/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/regexp_parser-2.1.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rexml-3.2.5/lib"
@@ -73,7 +73,7 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-3.10.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-github-2.3.1/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-its-1.3.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-retry-0.6.2/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-static-0.5.9030-universal-darwin-20/lib"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-static-0.5.9030-universal-darwin-14/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-0.5.9030/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-sorbet-1.8.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-wait-0.0.9/lib"

From e854fd4e25532b639fb581a329ed5a6bb6b93579 Mon Sep 17 00:00:00 2001
From: BrewTestBot <1589480+BrewTestBot@users.noreply.github.com>
Date: Wed, 11 Aug 2021 08:28:34 +0000
Subject: [PATCH 12/13] Update RBI files for sorbet.

---
 .../gems/{spoom@1.0.9.rbi => spoom@1.1.2.rbi} | 287 +++++++++++++-----
 ...{tapioca@0.4.23.rbi => tapioca@0.4.24.rbi} |   2 +-
 .../sorbet/rbi/hidden-definitions/hidden.rbi  |   1 +
 3 files changed, 217 insertions(+), 73 deletions(-)
 rename Library/Homebrew/sorbet/rbi/gems/{spoom@1.0.9.rbi => spoom@1.1.2.rbi} (94%)
 rename Library/Homebrew/sorbet/rbi/gems/{tapioca@0.4.23.rbi => tapioca@0.4.24.rbi} (99%)

diff --git a/Library/Homebrew/sorbet/rbi/gems/spoom@1.0.9.rbi b/Library/Homebrew/sorbet/rbi/gems/spoom@1.1.2.rbi
similarity index 94%
rename from Library/Homebrew/sorbet/rbi/gems/spoom@1.0.9.rbi
rename to Library/Homebrew/sorbet/rbi/gems/spoom@1.1.2.rbi
index 52c85a0222..86ec668668 100644
--- a/Library/Homebrew/sorbet/rbi/gems/spoom@1.0.9.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/spoom@1.1.2.rbi
@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `spoom` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
@@ -11,14 +11,14 @@ module Spoom
   end
 end
 
-module Spoom::Cli
-end
+module Spoom::Cli; end
 
 class Spoom::Cli::Bump < ::Thor
-  include(::Spoom::Cli::Helper)
+  include ::Spoom::Cli::Helper
 
   sig { params(directory: String).void }
   def bump(directory = T.unsafe(nil)); end
+
   def config_files(path: T.unsafe(nil)); end
   def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
   def print_changes(files, command:, from: T.unsafe(nil), to: T.unsafe(nil), dry: T.unsafe(nil), path: T.unsafe(nil)); end
@@ -26,14 +26,14 @@ class Spoom::Cli::Bump < ::Thor
 end
 
 class Spoom::Cli::Config < ::Thor
-  include(::Spoom::Cli::Helper)
+  include ::Spoom::Cli::Helper
 
   def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
   def show; end
 end
 
 class Spoom::Cli::Coverage < ::Thor
-  include(::Spoom::Cli::Helper)
+  include ::Spoom::Cli::Helper
 
   def bundle_install(path, sha); end
   def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
@@ -48,36 +48,50 @@ end
 Spoom::Cli::Coverage::DATA_DIR = T.let(T.unsafe(nil), String)
 
 module Spoom::Cli::Helper
-  include(::Thor::Shell)
+  include ::Thor::Shell
 
   sig { params(string: String).returns(String) }
   def blue(string); end
+
   sig { returns(T::Boolean) }
   def color?; end
+
   sig { params(string: String, color: Symbol).returns(String) }
   def colorize(string, color); end
+
   sig { returns(String) }
   def exec_path; end
+
   sig { params(string: String).returns(String) }
   def gray(string); end
+
   sig { params(string: String).returns(String) }
   def green(string); end
+
   sig { params(string: String).returns(String) }
   def highlight(string); end
+
   sig { void }
   def in_sorbet_project!; end
+
   sig { returns(T::Boolean) }
   def in_sorbet_project?; end
+
   sig { params(string: String).returns(String) }
   def red(string); end
+
   sig { params(message: String).void }
   def say(message); end
+
   sig { params(message: String, status: T.nilable(String), nl: T::Boolean).void }
   def say_error(message, status: T.unsafe(nil), nl: T.unsafe(nil)); end
+
   sig { returns(Spoom::Sorbet::Config) }
   def sorbet_config; end
+
   sig { returns(String) }
   def sorbet_config_file; end
+
   sig { params(string: String).returns(String) }
   def yellow(string); end
 end
@@ -85,7 +99,7 @@ end
 Spoom::Cli::Helper::HIGHLIGHT_COLOR = T.let(T.unsafe(nil), Symbol)
 
 class Spoom::Cli::LSP < ::Thor
-  include(::Spoom::Cli::Helper)
+  include ::Spoom::Cli::Helper
 
   def defs(file, line, col); end
   def find(query); end
@@ -104,7 +118,7 @@ class Spoom::Cli::LSP < ::Thor
 end
 
 class Spoom::Cli::Main < ::Thor
-  include(::Spoom::Cli::Helper)
+  include ::Spoom::Cli::Helper
 
   def __print_version; end
   def bump(*args); end
@@ -120,7 +134,7 @@ class Spoom::Cli::Main < ::Thor
 end
 
 class Spoom::Cli::Run < ::Thor
-  include(::Spoom::Cli::Helper)
+  include ::Spoom::Cli::Helper
 
   def colorize_message(message); end
   def format_error(error, format); end
@@ -129,34 +143,34 @@ class Spoom::Cli::Run < ::Thor
 end
 
 Spoom::Cli::Run::DEFAULT_FORMAT = T.let(T.unsafe(nil), String)
-
 Spoom::Cli::Run::SORT_CODE = T.let(T.unsafe(nil), String)
-
 Spoom::Cli::Run::SORT_ENUM = T.let(T.unsafe(nil), Array)
-
 Spoom::Cli::Run::SORT_LOC = T.let(T.unsafe(nil), String)
 
 module Spoom::Coverage
   class << self
     sig { params(snapshots: T::Array[Spoom::Coverage::Snapshot], palette: Spoom::Coverage::D3::ColorPalette, path: String).returns(Spoom::Coverage::Report) }
     def report(snapshots, palette:, path: T.unsafe(nil)); end
+
     sig { params(path: String).returns(Spoom::FileTree) }
     def sigils_tree(path: T.unsafe(nil)); end
+
     sig { params(path: String, rbi: T::Boolean, sorbet_bin: T.nilable(String)).returns(Spoom::Coverage::Snapshot) }
     def snapshot(path: T.unsafe(nil), rbi: T.unsafe(nil), sorbet_bin: T.unsafe(nil)); end
+
     sig { params(path: String).returns(Spoom::Sorbet::Config) }
     def sorbet_config(path: T.unsafe(nil)); end
   end
 end
 
-module Spoom::Coverage::Cards
-end
+module Spoom::Coverage::Cards; end
 
 class Spoom::Coverage::Cards::Card < ::Spoom::Coverage::Template
   sig { params(template: String, title: T.nilable(String), body: T.nilable(String)).void }
   def initialize(template: T.unsafe(nil), title: T.unsafe(nil), body: T.unsafe(nil)); end
 
   def body; end
+
   sig { returns(T.nilable(String)) }
   def title; end
 end
@@ -171,6 +185,7 @@ class Spoom::Coverage::Cards::Erb < ::Spoom::Coverage::Cards::Card
 
   sig { abstract.returns(String) }
   def erb; end
+
   sig { override.returns(String) }
   def html; end
 end
@@ -186,10 +201,13 @@ class Spoom::Coverage::Cards::Snapshot < ::Spoom::Coverage::Cards::Card
 
   sig { returns(Spoom::Coverage::D3::Pie::Calls) }
   def pie_calls; end
+
   sig { returns(Spoom::Coverage::D3::Pie::Sigils) }
   def pie_sigils; end
+
   sig { returns(Spoom::Coverage::D3::Pie::Sigs) }
   def pie_sigs; end
+
   sig { returns(Spoom::Coverage::Snapshot) }
   def snapshot; end
 end
@@ -214,6 +232,11 @@ class Spoom::Coverage::Cards::Timeline::Calls < ::Spoom::Coverage::Cards::Timeli
   def initialize(snapshots:, title: T.unsafe(nil)); end
 end
 
+class Spoom::Coverage::Cards::Timeline::RBIs < ::Spoom::Coverage::Cards::Timeline
+  sig { params(snapshots: T::Array[Spoom::Coverage::Snapshot], title: String).void }
+  def initialize(snapshots:, title: T.unsafe(nil)); end
+end
+
 class Spoom::Coverage::Cards::Timeline::Runtimes < ::Spoom::Coverage::Cards::Timeline
   sig { params(snapshots: T::Array[Spoom::Coverage::Snapshot], title: String).void }
   def initialize(snapshots:, title: T.unsafe(nil)); end
@@ -238,6 +261,7 @@ module Spoom::Coverage::D3
   class << self
     sig { params(palette: Spoom::Coverage::D3::ColorPalette).returns(String) }
     def header_script(palette); end
+
     sig { returns(String) }
     def header_style; end
   end
@@ -251,29 +275,29 @@ class Spoom::Coverage::D3::Base
 
   sig { returns(String) }
   def html; end
+
   sig { returns(String) }
   def id; end
+
   sig { abstract.returns(String) }
   def script; end
+
   sig { returns(String) }
   def tooltip; end
 
   class << self
     sig { returns(String) }
     def header_script; end
+
     sig { returns(String) }
     def header_style; end
   end
 end
 
 Spoom::Coverage::D3::COLOR_FALSE = T.let(T.unsafe(nil), String)
-
 Spoom::Coverage::D3::COLOR_IGNORE = T.let(T.unsafe(nil), String)
-
 Spoom::Coverage::D3::COLOR_STRICT = T.let(T.unsafe(nil), String)
-
 Spoom::Coverage::D3::COLOR_STRONG = T.let(T.unsafe(nil), String)
-
 Spoom::Coverage::D3::COLOR_TRUE = T.let(T.unsafe(nil), String)
 
 class Spoom::Coverage::D3::CircleMap < ::Spoom::Coverage::D3::Base
@@ -283,6 +307,7 @@ class Spoom::Coverage::D3::CircleMap < ::Spoom::Coverage::D3::Base
   class << self
     sig { returns(String) }
     def header_script; end
+
     sig { returns(String) }
     def header_style; end
   end
@@ -294,18 +319,20 @@ class Spoom::Coverage::D3::CircleMap::Sigils < ::Spoom::Coverage::D3::CircleMap
 
   sig { params(node: Spoom::FileTree::Node).returns(Float) }
   def tree_node_score(node); end
+
   sig { params(node: Spoom::FileTree::Node).returns(T.nilable(String)) }
   def tree_node_strictness(node); end
+
   sig { params(node: Spoom::FileTree::Node).returns(T::Hash[Symbol, T.untyped]) }
   def tree_node_to_json(node); end
 end
 
 class Spoom::Coverage::D3::ColorPalette < ::T::Struct
-  prop :ignore, String
   prop :false, String
-  prop :true, String
+  prop :ignore, String
   prop :strict, String
   prop :strong, String
+  prop :true, String
 
   class << self
     def inherited(s); end
@@ -324,6 +351,7 @@ class Spoom::Coverage::D3::Pie < ::Spoom::Coverage::D3::Base
   class << self
     sig { returns(String) }
     def header_script; end
+
     sig { returns(String) }
     def header_style; end
   end
@@ -361,26 +389,35 @@ class Spoom::Coverage::D3::Timeline < ::Spoom::Coverage::D3::Base
 
   sig { params(y: String, color: String, curve: String).returns(String) }
   def area(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
+
   sig { params(y: String, color: String, curve: String).returns(String) }
   def line(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
+
   sig { abstract.returns(String) }
   def plot; end
+
   sig { params(y: String).returns(String) }
   def points(y:); end
+
   sig { override.returns(String) }
   def script; end
+
   sig { returns(String) }
   def x_scale; end
+
   sig { returns(String) }
   def x_ticks; end
+
   sig { params(min: String, max: String, ticks: String).returns(String) }
   def y_scale(min:, max:, ticks:); end
+
   sig { params(ticks: String, format: String, padding: Integer).returns(String) }
   def y_ticks(ticks:, format:, padding:); end
 
   class << self
     sig { returns(String) }
     def header_script; end
+
     sig { returns(String) }
     def header_style; end
   end
@@ -394,12 +431,30 @@ class Spoom::Coverage::D3::Timeline::Calls < ::Spoom::Coverage::D3::Timeline::St
   def tooltip; end
 end
 
+class Spoom::Coverage::D3::Timeline::RBIs < ::Spoom::Coverage::D3::Timeline::Stacked
+  sig { params(id: String, snapshots: T::Array[Spoom::Coverage::Snapshot]).void }
+  def initialize(id, snapshots); end
+
+  sig { override.params(y: String, color: String, curve: String).returns(String) }
+  def line(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
+
+  sig { override.returns(String) }
+  def plot; end
+
+  sig { override.returns(String) }
+  def script; end
+
+  sig { override.returns(String) }
+  def tooltip; end
+end
+
 class Spoom::Coverage::D3::Timeline::Runtimes < ::Spoom::Coverage::D3::Timeline
   sig { params(id: String, snapshots: T::Array[Spoom::Coverage::Snapshot]).void }
   def initialize(id, snapshots); end
 
   sig { override.returns(String) }
   def plot; end
+
   sig { override.returns(String) }
   def tooltip; end
 end
@@ -427,8 +482,10 @@ class Spoom::Coverage::D3::Timeline::Stacked < ::Spoom::Coverage::D3::Timeline
 
   sig { override.params(y: String, color: String, curve: String).returns(String) }
   def line(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
+
   sig { override.returns(String) }
   def plot; end
+
   sig { override.returns(String) }
   def script; end
 end
@@ -439,6 +496,7 @@ class Spoom::Coverage::D3::Timeline::Versions < ::Spoom::Coverage::D3::Timeline
 
   sig { override.returns(String) }
   def plot; end
+
   sig { override.returns(String) }
   def tooltip; end
 end
@@ -451,18 +509,25 @@ class Spoom::Coverage::Page < ::Spoom::Coverage::Template
 
   sig { returns(String) }
   def body_html; end
+
   sig { abstract.returns(T::Array[Spoom::Coverage::Cards::Card]) }
   def cards; end
+
   sig { returns(String) }
   def footer_html; end
+
   sig { returns(String) }
   def header_html; end
+
   sig { returns(String) }
   def header_script; end
+
   sig { returns(String) }
   def header_style; end
+
   sig { returns(Spoom::Coverage::D3::ColorPalette) }
   def palette; end
+
   sig { returns(String) }
   def title; end
 end
@@ -475,47 +540,57 @@ class Spoom::Coverage::Report < ::Spoom::Coverage::Page
 
   sig { override.returns(T::Array[Spoom::Coverage::Cards::Card]) }
   def cards; end
+
   sig { override.returns(String) }
   def header_html; end
+
   sig { returns(String) }
   def project_name; end
+
   sig { returns(Spoom::FileTree) }
   def sigils_tree; end
+
   sig { returns(T::Array[Spoom::Coverage::Snapshot]) }
   def snapshots; end
+
   sig { returns(T.nilable(String)) }
   def sorbet_intro_commit; end
+
   sig { returns(T.nilable(Time)) }
   def sorbet_intro_date; end
 end
 
 class Spoom::Coverage::Snapshot < ::T::Struct
-  prop :timestamp, Integer, default: T.unsafe(nil)
-  prop :version_static, T.nilable(String), default: T.unsafe(nil)
-  prop :version_runtime, T.nilable(String), default: T.unsafe(nil)
-  prop :duration, Integer, default: T.unsafe(nil)
+  prop :calls_typed, Integer, default: T.unsafe(nil)
+  prop :calls_untyped, Integer, default: T.unsafe(nil)
+  prop :classes, Integer, default: T.unsafe(nil)
   prop :commit_sha, T.nilable(String), default: T.unsafe(nil)
   prop :commit_timestamp, T.nilable(Integer), default: T.unsafe(nil)
+  prop :duration, Integer, default: T.unsafe(nil)
   prop :files, Integer, default: T.unsafe(nil)
-  prop :modules, Integer, default: T.unsafe(nil)
-  prop :classes, Integer, default: T.unsafe(nil)
-  prop :singleton_classes, Integer, default: T.unsafe(nil)
-  prop :methods_without_sig, Integer, default: T.unsafe(nil)
   prop :methods_with_sig, Integer, default: T.unsafe(nil)
-  prop :calls_untyped, Integer, default: T.unsafe(nil)
-  prop :calls_typed, Integer, default: T.unsafe(nil)
+  prop :methods_without_sig, Integer, default: T.unsafe(nil)
+  prop :modules, Integer, default: T.unsafe(nil)
+  prop :rbi_files, Integer, default: T.unsafe(nil)
   prop :sigils, T::Hash[String, Integer], default: T.unsafe(nil)
+  prop :singleton_classes, Integer, default: T.unsafe(nil)
+  prop :timestamp, Integer, default: T.unsafe(nil)
+  prop :version_runtime, T.nilable(String), default: T.unsafe(nil)
+  prop :version_static, T.nilable(String), default: T.unsafe(nil)
 
   sig { params(out: T.any(IO, StringIO), colors: T::Boolean, indent_level: Integer).void }
   def print(out: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil)); end
+
   sig { params(arg: T.untyped).returns(String) }
   def to_json(*arg); end
 
   class << self
     sig { params(json: String).returns(Spoom::Coverage::Snapshot) }
     def from_json(json); end
+
     sig { params(obj: T::Hash[String, T.untyped]).returns(Spoom::Coverage::Snapshot) }
     def from_obj(obj); end
+
     def inherited(s); end
   end
 end
@@ -530,6 +605,7 @@ class Spoom::Coverage::SnapshotPrinter < ::Spoom::Printer
 
   sig { params(value: T.nilable(Integer), total: T.nilable(Integer)).returns(String) }
   def percent(value, total); end
+
   sig { params(hash: T::Hash[String, Integer], total: Integer).void }
   def print_map(hash, total); end
 end
@@ -542,14 +618,15 @@ class Spoom::Coverage::Template
 
   sig { returns(String) }
   def erb; end
+
   sig { returns(Binding) }
   def get_binding; end
+
   sig { returns(String) }
   def html; end
 end
 
-class Spoom::Error < ::StandardError
-end
+class Spoom::Error < ::StandardError; end
 
 class Spoom::FileTree
   sig { params(paths: T::Enumerable[String], strip_prefix: T.nilable(String)).void }
@@ -557,16 +634,22 @@ class Spoom::FileTree
 
   sig { params(path: String).returns(Spoom::FileTree::Node) }
   def add_path(path); end
+
   sig { params(paths: T::Enumerable[String]).void }
   def add_paths(paths); end
+
   sig { returns(T::Array[Spoom::FileTree::Node]) }
   def nodes; end
+
   sig { returns(T::Array[String]) }
   def paths; end
+
   sig { params(out: T.any(IO, StringIO), show_strictness: T::Boolean, colors: T::Boolean, indent_level: Integer).void }
   def print(out: T.unsafe(nil), show_strictness: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil)); end
+
   sig { returns(T::Array[Spoom::FileTree::Node]) }
   def roots; end
+
   sig { returns(T.nilable(String)) }
   def strip_prefix; end
 
@@ -577,9 +660,9 @@ class Spoom::FileTree
 end
 
 class Spoom::FileTree::Node < ::T::Struct
-  const :parent, T.nilable(Spoom::FileTree::Node)
-  const :name, String
   const :children, T::Hash[String, Spoom::FileTree::Node], default: T.unsafe(nil)
+  const :name, String
+  const :parent, T.nilable(Spoom::FileTree::Node)
 
   sig { returns(String) }
   def path; end
@@ -595,10 +678,13 @@ class Spoom::FileTree::TreePrinter < ::Spoom::Printer
 
   sig { params(node: Spoom::FileTree::Node).void }
   def print_node(node); end
+
   sig { params(nodes: T::Array[Spoom::FileTree::Node]).void }
   def print_nodes(nodes); end
+
   sig { void }
   def print_tree; end
+
   sig { returns(Spoom::FileTree) }
   def tree; end
 
@@ -606,6 +692,7 @@ class Spoom::FileTree::TreePrinter < ::Spoom::Printer
 
   sig { params(node: Spoom::FileTree::Node).returns(T.nilable(String)) }
   def node_strictness(node); end
+
   sig { params(strictness: T.nilable(String)).returns(Symbol) }
   def strictness_color(strictness); end
 end
@@ -614,33 +701,49 @@ module Spoom::Git
   class << self
     sig { params(arg: String, path: String).returns([String, String, T::Boolean]) }
     def checkout(*arg, path: T.unsafe(nil)); end
+
     sig { params(sha: String, path: String).returns(T.nilable(Time)) }
     def commit_time(sha, path: T.unsafe(nil)); end
+
     sig { params(sha: String, path: String).returns(T.nilable(Integer)) }
     def commit_timestamp(sha, path: T.unsafe(nil)); end
+
+    sig { params(path: String).returns(T.nilable(String)) }
+    def current_branch(path: T.unsafe(nil)); end
+
     sig { params(arg: String, path: String).returns([String, String, T::Boolean]) }
     def diff(*arg, path: T.unsafe(nil)); end
+
     sig { params(timestamp: String).returns(Time) }
     def epoch_to_time(timestamp); end
+
     sig { params(command: String, arg: String, path: String).returns([String, String, T::Boolean]) }
     def exec(command, *arg, path: T.unsafe(nil)); end
+
     sig { params(path: String).returns(T.nilable(String)) }
     def last_commit(path: T.unsafe(nil)); end
+
     sig { params(arg: String, path: String).returns([String, String, T::Boolean]) }
     def log(*arg, path: T.unsafe(nil)); end
+
     sig { params(arg: String, path: String).returns([String, String, T::Boolean]) }
     def rev_parse(*arg, path: T.unsafe(nil)); end
+
     sig { params(arg: String, path: String).returns([String, String, T::Boolean]) }
     def show(*arg, path: T.unsafe(nil)); end
+
     sig { params(path: String).returns(T.nilable(String)) }
     def sorbet_intro_commit(path: T.unsafe(nil)); end
+
+    sig { params(path: String).returns(T.nilable(String)) }
+    def sorbet_removal_commit(path: T.unsafe(nil)); end
+
     sig { params(path: String).returns(T::Boolean) }
     def workdir_clean?(path: T.unsafe(nil)); end
   end
 end
 
-module Spoom::LSP
-end
+module Spoom::LSP; end
 
 class Spoom::LSP::Client
   def initialize(sorbet_bin, *sorbet_args, path: T.unsafe(nil)); end
@@ -662,15 +765,16 @@ class Spoom::LSP::Client
 end
 
 class Spoom::LSP::Diagnostic < ::T::Struct
-  include(::Spoom::LSP::PrintableSymbol)
+  include ::Spoom::LSP::PrintableSymbol
 
-  const :range, Spoom::LSP::Range
   const :code, Integer
-  const :message, String
   const :informations, Object
+  const :message, String
+  const :range, Spoom::LSP::Range
 
   sig { override.params(printer: Spoom::LSP::SymbolPrinter).void }
   def accept_printer(printer); end
+
   def to_s; end
 
   class << self
@@ -680,17 +784,18 @@ class Spoom::LSP::Diagnostic < ::T::Struct
 end
 
 class Spoom::LSP::DocumentSymbol < ::T::Struct
-  include(::Spoom::LSP::PrintableSymbol)
+  include ::Spoom::LSP::PrintableSymbol
 
-  const :name, String
+  const :children, T::Array[Spoom::LSP::DocumentSymbol]
   const :detail, T.nilable(String)
   const :kind, Integer
   const :location, T.nilable(Spoom::LSP::Location)
+  const :name, String
   const :range, T.nilable(Spoom::LSP::Range)
-  const :children, T::Array[Spoom::LSP::DocumentSymbol]
 
   sig { override.params(printer: Spoom::LSP::SymbolPrinter).void }
   def accept_printer(printer); end
+
   def kind_string; end
   def to_s; end
 
@@ -701,15 +806,9 @@ class Spoom::LSP::DocumentSymbol < ::T::Struct
 end
 
 Spoom::LSP::DocumentSymbol::SYMBOL_KINDS = T.let(T.unsafe(nil), Hash)
-
-class Spoom::LSP::Error < ::StandardError
-end
-
-class Spoom::LSP::Error::AlreadyOpen < ::Spoom::LSP::Error
-end
-
-class Spoom::LSP::Error::BadHeaders < ::Spoom::LSP::Error
-end
+class Spoom::LSP::Error < ::StandardError; end
+class Spoom::LSP::Error::AlreadyOpen < ::Spoom::LSP::Error; end
+class Spoom::LSP::Error::BadHeaders < ::Spoom::LSP::Error; end
 
 class Spoom::LSP::Error::Diagnostics < ::Spoom::LSP::Error
   def initialize(uri, diagnostics); end
@@ -723,13 +822,14 @@ class Spoom::LSP::Error::Diagnostics < ::Spoom::LSP::Error
 end
 
 class Spoom::LSP::Hover < ::T::Struct
-  include(::Spoom::LSP::PrintableSymbol)
+  include ::Spoom::LSP::PrintableSymbol
 
   const :contents, String
   const :range, T.nilable(T::Range[T.untyped])
 
   sig { override.params(printer: Spoom::LSP::SymbolPrinter).void }
   def accept_printer(printer); end
+
   def to_s; end
 
   class << self
@@ -739,13 +839,14 @@ class Spoom::LSP::Hover < ::T::Struct
 end
 
 class Spoom::LSP::Location < ::T::Struct
-  include(::Spoom::LSP::PrintableSymbol)
+  include ::Spoom::LSP::PrintableSymbol
 
-  const :uri, String
   const :range, Spoom::LSP::Range
+  const :uri, String
 
   sig { override.params(printer: Spoom::LSP::SymbolPrinter).void }
   def accept_printer(printer); end
+
   def to_s; end
 
   class << self
@@ -770,13 +871,14 @@ class Spoom::LSP::Notification < ::Spoom::LSP::Message
 end
 
 class Spoom::LSP::Position < ::T::Struct
-  include(::Spoom::LSP::PrintableSymbol)
+  include ::Spoom::LSP::PrintableSymbol
 
-  const :line, Integer
   const :char, Integer
+  const :line, Integer
 
   sig { override.params(printer: Spoom::LSP::SymbolPrinter).void }
   def accept_printer(printer); end
+
   def to_s; end
 
   class << self
@@ -793,13 +895,14 @@ module Spoom::LSP::PrintableSymbol
 end
 
 class Spoom::LSP::Range < ::T::Struct
-  include(::Spoom::LSP::PrintableSymbol)
+  include ::Spoom::LSP::PrintableSymbol
 
-  const :start, Spoom::LSP::Position
   const :end, Spoom::LSP::Position
+  const :start, Spoom::LSP::Position
 
   sig { override.params(printer: Spoom::LSP::SymbolPrinter).void }
   def accept_printer(printer); end
+
   def to_s; end
 
   class << self
@@ -829,14 +932,15 @@ class Spoom::LSP::ResponseError < ::Spoom::LSP::Error
 end
 
 class Spoom::LSP::SignatureHelp < ::T::Struct
-  include(::Spoom::LSP::PrintableSymbol)
+  include ::Spoom::LSP::PrintableSymbol
 
-  const :label, T.nilable(String)
   const :doc, Object
+  const :label, T.nilable(String)
   const :params, T::Array[T.untyped]
 
   sig { override.params(printer: Spoom::LSP::SymbolPrinter).void }
   def accept_printer(printer); end
+
   def to_s; end
 
   class << self
@@ -851,14 +955,19 @@ class Spoom::LSP::SymbolPrinter < ::Spoom::Printer
 
   sig { params(uri: String).returns(String) }
   def clean_uri(uri); end
+
   def prefix; end
   def prefix=(_arg0); end
+
   sig { params(objects: T::Array[Spoom::LSP::PrintableSymbol]).void }
   def print_list(objects); end
+
   sig { params(object: T.nilable(Spoom::LSP::PrintableSymbol)).void }
   def print_object(object); end
+
   sig { params(objects: T::Array[Spoom::LSP::PrintableSymbol]).void }
   def print_objects(objects); end
+
   def seen; end
   def seen=(_arg0); end
 end
@@ -871,21 +980,30 @@ class Spoom::Printer
 
   sig { params(string: String, color: Symbol).returns(String) }
   def colorize(string, color); end
+
   sig { void }
   def dedent; end
+
   sig { void }
   def indent; end
+
   sig { returns(T.any(IO, StringIO)) }
   def out; end
+
   def out=(_arg0); end
+
   sig { params(string: T.nilable(String)).void }
   def print(string); end
+
   sig { params(string: T.nilable(String), color: Symbol, colors: Symbol).void }
   def print_colored(string, color, *colors); end
+
   sig { params(string: T.nilable(String)).void }
   def printl(string); end
+
   sig { void }
   def printn; end
+
   sig { void }
   def printt; end
 end
@@ -896,21 +1014,25 @@ module Spoom::Sorbet
   class << self
     sig { params(arg: String, path: String, capture_err: T::Boolean, sorbet_bin: T.nilable(String)).returns([String, T::Boolean]) }
     def srb(*arg, path: T.unsafe(nil), capture_err: T.unsafe(nil), sorbet_bin: T.unsafe(nil)); end
+
     sig { params(config: Spoom::Sorbet::Config, path: String).returns(T::Array[String]) }
     def srb_files(config, path: T.unsafe(nil)); end
+
     sig { params(arg: String, path: String, capture_err: T::Boolean, sorbet_bin: T.nilable(String)).returns(T.nilable(T::Hash[String, Integer])) }
     def srb_metrics(*arg, path: T.unsafe(nil), capture_err: T.unsafe(nil), sorbet_bin: T.unsafe(nil)); end
+
     sig { params(arg: String, path: String, capture_err: T::Boolean, sorbet_bin: T.nilable(String)).returns([String, T::Boolean]) }
     def srb_tc(*arg, path: T.unsafe(nil), capture_err: T.unsafe(nil), sorbet_bin: T.unsafe(nil)); end
+
     sig { params(arg: String, path: String, capture_err: T::Boolean, sorbet_bin: T.nilable(String)).returns(T.nilable(String)) }
     def srb_version(*arg, path: T.unsafe(nil), capture_err: T.unsafe(nil), sorbet_bin: T.unsafe(nil)); end
+
     sig { params(gem: String, path: String).returns(T.nilable(String)) }
     def version_from_gemfile_lock(gem: T.unsafe(nil), path: T.unsafe(nil)); end
   end
 end
 
 Spoom::Sorbet::BIN_PATH = T.let(T.unsafe(nil), String)
-
 Spoom::Sorbet::CONFIG_PATH = T.let(T.unsafe(nil), String)
 
 class Spoom::Sorbet::Config
@@ -918,17 +1040,27 @@ class Spoom::Sorbet::Config
   def initialize; end
 
   def allowed_extensions; end
+
   sig { returns(Spoom::Sorbet::Config) }
   def copy; end
+
   def ignore; end
+
+  sig { returns(T::Boolean) }
+  def no_stdlib; end
+
+  def no_stdlib=(_arg0); end
+
   sig { returns(String) }
   def options_string; end
+
   sig { returns(T::Array[String]) }
   def paths; end
 
   class << self
     sig { params(sorbet_config_path: String).returns(Spoom::Sorbet::Config) }
     def parse_file(sorbet_config_path); end
+
     sig { params(sorbet_config: String).returns(Spoom::Sorbet::Config) }
     def parse_string(sorbet_config); end
 
@@ -947,21 +1079,27 @@ module Spoom::Sorbet::Errors
 end
 
 class Spoom::Sorbet::Errors::Error
-  include(::Comparable)
+  include ::Comparable
 
   sig { params(file: T.nilable(String), line: T.nilable(Integer), message: T.nilable(String), code: T.nilable(Integer), more: T::Array[String]).void }
   def initialize(file, line, message, code, more = T.unsafe(nil)); end
 
   sig { params(other: T.untyped).returns(Integer) }
   def <=>(other); end
+
   def code; end
+
   sig { returns(T.nilable(String)) }
   def file; end
+
   sig { returns(T.nilable(Integer)) }
   def line; end
+
   def message; end
+
   sig { returns(T::Array[String]) }
   def more; end
+
   sig { returns(String) }
   def to_s; end
 end
@@ -977,10 +1115,13 @@ class Spoom::Sorbet::Errors::Parser
 
   sig { params(line: String).void }
   def append_error(line); end
+
   sig { void }
   def close_error; end
+
   sig { params(line: String).returns(T.nilable(Spoom::Sorbet::Errors::Error)) }
   def match_error_line(line); end
+
   sig { params(error: Spoom::Sorbet::Errors::Error).void }
   def open_error(error); end
 
@@ -991,17 +1132,17 @@ class Spoom::Sorbet::Errors::Parser
 end
 
 Spoom::Sorbet::Errors::Parser::ERROR_LINE_MATCH_REGEX = T.let(T.unsafe(nil), Regexp)
-
 Spoom::Sorbet::Errors::Parser::HEADER = T.let(T.unsafe(nil), Array)
-
 Spoom::Sorbet::GEM_PATH = T.let(T.unsafe(nil), String)
 
 module Spoom::Sorbet::MetricsParser
   class << self
     sig { params(path: String, prefix: String).returns(T::Hash[String, Integer]) }
     def parse_file(path, prefix = T.unsafe(nil)); end
+
     sig { params(obj: T::Hash[String, T.untyped], prefix: String).returns(T::Hash[String, Integer]) }
     def parse_hash(obj, prefix = T.unsafe(nil)); end
+
     sig { params(string: String, prefix: String).returns(T::Hash[String, Integer]) }
     def parse_string(string, prefix = T.unsafe(nil)); end
   end
@@ -1013,37 +1154,37 @@ module Spoom::Sorbet::Sigils
   class << self
     sig { params(path: T.any(Pathname, String), new_strictness: String).returns(T::Boolean) }
     def change_sigil_in_file(path, new_strictness); end
+
     sig { params(path_list: T::Array[String], new_strictness: String).returns(T::Array[String]) }
     def change_sigil_in_files(path_list, new_strictness); end
+
     sig { params(path: T.any(Pathname, String)).returns(T.nilable(String)) }
     def file_strictness(path); end
+
     sig { params(directory: T.any(Pathname, String), strictness: String, extension: String).returns(T::Array[String]) }
     def files_with_sigil_strictness(directory, strictness, extension: T.unsafe(nil)); end
+
     sig { params(strictness: String).returns(String) }
     def sigil_string(strictness); end
+
     sig { params(content: String).returns(T.nilable(String)) }
     def strictness_in_content(content); end
+
     sig { params(content: String, new_strictness: String).returns(String) }
     def update_sigil(content, new_strictness); end
+
     sig { params(strictness: String).returns(T::Boolean) }
     def valid_strictness?(strictness); end
   end
 end
 
 Spoom::Sorbet::Sigils::SIGIL_REGEXP = T.let(T.unsafe(nil), Regexp)
-
 Spoom::Sorbet::Sigils::STRICTNESS_FALSE = T.let(T.unsafe(nil), String)
-
 Spoom::Sorbet::Sigils::STRICTNESS_IGNORE = T.let(T.unsafe(nil), String)
-
 Spoom::Sorbet::Sigils::STRICTNESS_INTERNAL = T.let(T.unsafe(nil), String)
-
 Spoom::Sorbet::Sigils::STRICTNESS_STRICT = T.let(T.unsafe(nil), String)
-
 Spoom::Sorbet::Sigils::STRICTNESS_STRONG = T.let(T.unsafe(nil), String)
-
 Spoom::Sorbet::Sigils::STRICTNESS_TRUE = T.let(T.unsafe(nil), String)
-
 Spoom::Sorbet::Sigils::VALID_STRICTNESS = T.let(T.unsafe(nil), Array)
 
 class Spoom::Timeline
@@ -1052,8 +1193,10 @@ class Spoom::Timeline
 
   sig { params(dates: T::Array[Time]).returns(T::Array[String]) }
   def commits_for_dates(dates); end
+
   sig { returns(T::Array[Time]) }
   def months; end
+
   sig { returns(T::Array[String]) }
   def ticks; end
 end
diff --git a/Library/Homebrew/sorbet/rbi/gems/tapioca@0.4.23.rbi b/Library/Homebrew/sorbet/rbi/gems/tapioca@0.4.24.rbi
similarity index 99%
rename from Library/Homebrew/sorbet/rbi/gems/tapioca@0.4.23.rbi
rename to Library/Homebrew/sorbet/rbi/gems/tapioca@0.4.24.rbi
index eb341cce62..bc4fe3d31c 100644
--- a/Library/Homebrew/sorbet/rbi/gems/tapioca@0.4.23.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/tapioca@0.4.24.rbi
@@ -1615,7 +1615,7 @@ class Tapioca::RBI::Rewriters::SortNodes < ::Tapioca::RBI::Visitor
   private
 
   sig { params(kind: Tapioca::RBI::Group::Kind).returns(Integer) }
-  def kind_rank(kind); end
+  def group_rank(kind); end
 
   sig { params(node: Tapioca::RBI::Node).returns(T.nilable(String)) }
   def node_name(node); end
diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
index 27b549f2cd..703c02679c 100644
--- a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
+++ b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
@@ -30665,6 +30665,7 @@ end
 
 module Spoom::Cli::Helper
   extend ::T::Sig
+  extend ::T::Helpers
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
 end

From 62f7dcaa0e809e3154e2f6d930a129a74dfd74e7 Mon Sep 17 00:00:00 2001
From: Mike McQuaid <mike@mikemcquaid.com>
Date: Wed, 11 Aug 2021 09:39:58 +0100
Subject: [PATCH 13/13] dev-cmd/typecheck: don't suppress 5061 errors, do
 suppress 5067.

---
 Library/Homebrew/dev-cmd/typecheck.rb | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Library/Homebrew/dev-cmd/typecheck.rb b/Library/Homebrew/dev-cmd/typecheck.rb
index 73242d0a5b..c8270e8512 100644
--- a/Library/Homebrew/dev-cmd/typecheck.rb
+++ b/Library/Homebrew/dev-cmd/typecheck.rb
@@ -104,8 +104,9 @@ module Homebrew
 
       srb_exec = %w[bundle exec srb tc]
 
-      # TODO: comment explaining why?
-      srb_exec << "--suppress-error-code" << "5061"
+      # As-of Sorbet 0.5.9030 there's a lot of complaints about superclass/class
+      # relationships in RSpec (that we don't control)
+      srb_exec << "--suppress-error-code" << "5067"
 
       srb_exec << "--quiet" if args.quiet?