Merge pull request #11771 from Homebrew/dependabot/bundler/Library/Homebrew/sorbet-0.5.6519

build(deps-dev): bump sorbet from 0.5.6274 to 0.5.9030 in /Library/Homebrew

Library/Homebrew/.parlour

@@ -0,0 +1,10 @@
+parser: false
+
+output_file:
+  rbi: sorbet/rbi/parlour.rbi
+
+relative_requires:
+  - sorbet/parlour.rb
+
+plugins:
+  Attr: {}

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

Library/Homebrew/Gemfile.lock

@@ -146,14 +146,14 @@ GEM
       simplecov (~> 0.8)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.3)
-    sorbet (0.5.6274)
+    sorbet (0.5.9030)
-      sorbet-static (= 0.5.6274)
+      sorbet-static (= 0.5.9030)
-    sorbet-runtime (0.5.6274)
+    sorbet-runtime (0.5.9030)
     sorbet-runtime-stub (0.2.0)
-    sorbet-static (0.5.6274-universal-darwin-14)
+    sorbet-static (0.5.9030-universal-darwin-14)
-    spoom (1.0.9)
+    spoom (1.1.2)
       colorize
-      sorbet (~> 0.5.5)
+      sorbet (>= 0.5.6347)
       sorbet-runtime
       thor (>= 0.19.2)
     tapioca (0.4.24)
@@ -188,6 +188,7 @@ DEPENDENCIES
   mechanize
   minitest
   parallel_tests
+  parlour
   patchelf
   plist
   ronn

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

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

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"
 
@@ -103,8 +104,9 @@ module Homebrew
 
       srb_exec = %w[bundle exec srb tc]
 
-      # TODO: comment explaining why?
+      # As-of Sorbet 0.5.9030 there's a lot of complaints about superclass/class
-      srb_exec << "--suppress-error-code" << "5061"
+      # relationships in RSpec (that we don't control)
+      srb_exec << "--suppress-error-code" << "5067"
 
       srb_exec << "--quiet" if args.quiet?
 

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

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

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

Library/Homebrew/sorbet/config

@@ -6,6 +6,3 @@
 
 --ignore
 /test/.gem
-
---dsl-plugins
-sorbet/triggers.yml

Library/Homebrew/sorbet/parlour.rb

@@ -0,0 +1,44 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "../warnings"
+Warnings.ignore :parser_syntax do
+  require "parser/current"
+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).freeze
+
+    sig { returns(T::Array[Parser::AST::Node]) }
+    def self.ast_list
+      @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? && prune_dirs.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"

Library/Homebrew/sorbet/parlour/attr.rb

@@ -0,0 +1,112 @@
+# 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)
+    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
+    "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 = []
+      case node.type
+      when :class
+        element << :class
+        element << extract_module_name(children.shift)
+        element << extract_module_name(children.shift)
+      when :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 [:attr_rw, :attr_predicate].include?(method_name)
+        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

Library/Homebrew/sorbet/plugins/attr_predicate.rb

@@ -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

Library/Homebrew/sorbet/plugins/attr_rw.rb

@@ -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

Library/Homebrew/sorbet/plugins/def_delegator.rb

@@ -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

Library/Homebrew/sorbet/plugins/def_delegators.rb

@@ -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

Library/Homebrew/sorbet/plugins/delegate.rb

@@ -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

Library/Homebrew/sorbet/plugins/using.rb

@@ -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

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
+module Spoom::Cli; end
-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
+module Spoom::Coverage::Cards; end
-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 :calls_typed, Integer, default: T.unsafe(nil)
-  prop :version_static, T.nilable(String), default: T.unsafe(nil)
+  prop :calls_untyped, Integer, default: T.unsafe(nil)
-  prop :version_runtime, T.nilable(String), default: T.unsafe(nil)
+  prop :classes, Integer, default: T.unsafe(nil)
-  prop :duration, 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 :methods_without_sig, Integer, default: T.unsafe(nil)
-  prop :calls_typed, 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
+class Spoom::Error < ::StandardError; end
-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
+module Spoom::LSP; end
-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 < ::StandardError
+class Spoom::LSP::Error::AlreadyOpen < ::Spoom::LSP::Error; end
-end
+class Spoom::LSP::Error::BadHeaders < ::Spoom::LSP::Error; 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

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

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

Library/Homebrew/sorbet/triggers.yml

@@ -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

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

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.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"
@@ -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-static-0.5.9030-universal-darwin-14/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-0.5.6274/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/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"

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
 

Library/Homebrew/yard/ignore_directives.rbi

@@ -0,0 +1,6 @@
+# typed: strict
+
+module YARD
+  class Docstring; end
+  class DocstringParser; end
+end