sorbet: upgrade 19 files from typed: true to typed: strict

Upgrades these files from `# typed: true # rubocop:todo Sorbet/StrictSigil`
to `# typed: strict`, adds all required type annotations, and resolves
all resulting type errors.

Files upgraded:
- dependable.rb
- dependency.rb
- dependency_collector.rb
- description_cache_store.rb
- exceptions.rb
- formula_auditor.rb
- global.rb
- ignorable.rb
- manpages/converter/kramdown.rb
- manpages/converter/roff.rb
- manpages/parser/ronn.rb
- requirement.rb
- requirements/macos_requirement.rb
- resource.rb
- resource_auditor.rb
- style.rb
- tab.rb
- tap_auditor.rb
- utils/github.rb

Also adds typed generics (Key/Value type members) to CacheStoreDatabase
and CacheStore, and types the `val` parameter of Tab#with? and Tab#without?
as T.any(String, Dependency, Requirement).

Resolves #17297

Author: dduugg

Library/Homebrew/bottle.rb

@@ -194,7 +194,7 @@ def installed_size
 
   sig { returns(Filename) }
   def filename
-    Filename.create(resource.owner, @tag, @spec.rebuild)
+    Filename.create(T.cast(resource.owner, Formula), @tag, @spec.rebuild)
   end
 
   sig { returns(T.nilable(Resource::BottleManifest)) }
@@ -259,7 +259,7 @@ def root_url(val = nil, specs = {})
 
     @root_url = T.let(val, T.nilable(String))
 
-    filename = Filename.create(resource.owner, @tag, @spec.rebuild)
+    filename = Filename.create(T.cast(resource.owner, Formula), @tag, @spec.rebuild)
     resource_checksum = resource.checksum
     odie "resource checksum is nil" if resource_checksum.nil?
 

Library/Homebrew/brew.rb

@@ -163,16 +163,16 @@
       #{Formatter.bold("Do not report any issues to Homebrew/* repositories!")}
       Read the above document instead before opening any issues or PRs.
     EOS
-  elsif e.formula.head? || e.formula.deprecated? || e.formula.disabled?
-    reason = if e.formula.head?
+  elsif (formula = e.formula) && (formula.head? || formula.deprecated? || formula.disabled?)
+    reason = if formula.head?
       "was built from an unstable upstream --HEAD"
-    elsif e.formula.deprecated?
+    elsif formula.deprecated?
       "is deprecated"
-    elsif e.formula.disabled?
+    elsif formula.disabled?
       "is disabled"
     end
     $stderr.puts <<~EOS
-      #{e.formula.name}'s formula #{reason}.
+      #{formula.name}'s formula #{reason}.
       This build failure is expected behaviour.
     EOS
   end

Library/Homebrew/build.rb

@@ -69,9 +69,9 @@ def expand_reqs
   sig { returns(T::Array[Dependency]) }
   def expand_deps
     formula.recursive_dependencies do |dependent, dep|
-      build = effective_build_options_for(dependent)
+      build = effective_build_options_for(T.cast(dependent, Formula))
       if dep.prune_from_option?(build) ||
-         dep.prune_if_build_and_not_dependent?(dependent, formula) ||
+         dep.prune_if_build_and_not_dependent?(T.cast(dependent, Formula), formula) ||
          (dep.test? && !dep.build?) || dep.implicit?
         Dependency.prune
       elsif dep.build?

Library/Homebrew/build_options.rb

@@ -30,7 +30,7 @@ def initialize(args, options)
   #   args << "--with-example1"
   # end
   # ```
-  sig { params(val: T.any(String, Requirement, Dependency)).returns(T::Boolean) }
+  sig { params(val: T.any(String, Dependable)).returns(T::Boolean) }
   def with?(val)
     option_names = if val.is_a?(String)
       [val]
@@ -56,7 +56,7 @@ def with?(val)
   # ```ruby
   # args << "--no-spam-plz" if build.without? "spam"
   # ```
-  sig { params(val: T.any(String, Requirement, Dependency)).returns(T::Boolean) }
+  sig { params(val: T.any(String, Dependable)).returns(T::Boolean) }
   def without?(val)
     !with?(val)
   end

Library/Homebrew/bundle.rb

@@ -140,7 +140,8 @@ def mark_as_installed_on_request!(entries)
           next if installed_formulae.exclude?(name)
 
           tab = Tab.for_name(name)
-          next if tab.tabfile.blank? || !tab.tabfile.exist?
+          tabfile = tab.tabfile
+          next if tabfile.blank? || !tabfile.exist?
           next if tab.installed_on_request
 
           next name if use_brew_tab

Library/Homebrew/bundle/brew.rb

@@ -287,8 +287,7 @@ def formula_to_hash(formula)
             installed_as_dependency = tab.installed_as_dependency
             installed_on_request = tab.installed_on_request
             runtime_dependencies = if (runtime_deps = tab.runtime_dependencies)
-              runtime_deps.filter_map { |d| d["full_name"] }
-
+              T.cast(runtime_deps, T::Array[T::Hash[String, T.untyped]]).filter_map { |d| d["full_name"] }
             end
             poured_from_bottle = tab.poured_from_bottle
           end

Library/Homebrew/cache_store.rb

@@ -8,16 +8,20 @@
 # residing in the `HOMEBREW_CACHE`.
 #
 class CacheStoreDatabase
+  extend T::Generic
+
+  # Sorbet type members are mutable by design and cannot be frozen.
+  Key = type_member # rubocop:disable Style/MutableConstant
+  # Sorbet type members are mutable by design and cannot be frozen.
+  Value = type_member # rubocop:disable Style/MutableConstant
+
   # Yields the cache store database.
   # Closes the database after use if it has been loaded.
-  #
-  # @param  [Symbol] type
-  # @yield  [CacheStoreDatabase] self
   sig {
     type_parameters(:U)
       .params(
         type: Symbol,
-        _blk: T.proc.params(arg0: CacheStoreDatabase).returns(T.type_parameter(:U)),
+        _blk: T.proc.params(arg0: CacheStoreDatabase[T.anything, T.anything]).returns(T.type_parameter(:U)),
       )
       .returns(T.type_parameter(:U))
   }
@@ -47,32 +51,29 @@ def self.use(type, &_blk)
   end
 
   # Creates a CacheStoreDatabase.
-  #
-  # @param  [Symbol] type
-  # @return [nil]
   sig { params(type: Symbol).void }
   def initialize(type)
     @type = type
     @dirty = T.let(false, T.nilable(T::Boolean))
   end
 
   # Sets a value in the underlying database (and creates it if necessary).
-  sig { params(key: T.anything, value: T.anything).void }
+  sig { params(key: Key, value: Value).void }
   def set(key, value)
     dirty!
     db[key] = value
   end
 
   # Gets a value from the underlying database (if it already exists).
-  sig { params(key: T.anything).returns(T.untyped) }
+  sig { params(key: Key).returns(T.nilable(Value)) }
   def get(key)
     return unless created?
 
     db[key]
   end
 
   # Deletes a value from the underlying database (if it already exists).
-  sig { params(key: T.anything).void }
+  sig { params(key: Key).void }
   def delete(key)
     return unless created?
 
@@ -99,16 +100,12 @@ def write_if_dirty!
   end
 
   # Returns `true` if the cache file has been created for the given `@type`.
-  #
-  # @return [Boolean]
   sig { returns(T::Boolean) }
   def created?
     cache_path.exist?
   end
 
   # Returns the modification time of the cache file (if it already exists).
-  #
-  # @return [Time]
   sig { returns(T.nilable(Time)) }
   def mtime
     return unless created?
@@ -117,25 +114,23 @@ def mtime
   end
 
   # Performs a `select` on the underlying database.
-  #
-  # @return [Hash]
-  sig { params(block: T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(BasicObject)).returns(T::Hash[T.untyped, T.untyped]) }
+  sig {
+    overridable.params(block: T.proc.params(arg0: Key, arg1: Value).returns(BasicObject)).returns(T::Hash[Key, Value])
+  }
   def select(&block)
     db.select(&block)
   end
 
   # Returns `true` if the cache is empty.
-  #
-  # @return [Boolean]
   sig { returns(T::Boolean) }
   def empty?
     db.empty?
   end
 
   # Performs a `each_key` on the underlying database.
-  #
-  # @return [Hash]
-  sig { params(block: T.proc.params(arg0: T.untyped).returns(BasicObject)).returns(T::Hash[T.untyped, T.untyped]) }
+  sig {
+    params(block: T.proc.params(arg0: Key).returns(BasicObject)).returns(T::Hash[Key, Value])
+  }
   def each_key(&block)
     db.each_key(&block)
   end
@@ -145,11 +140,9 @@ def each_key(&block)
   # Lazily loaded database in read/write mode. If this method is called, a
   # database file will be created in the `HOMEBREW_CACHE` with a name
   # corresponding to the `@type` instance variable.
-  #
-  # @return [Hash] db
-  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  sig { returns(T::Hash[Key, Value]) }
   def db
-    @db ||= T.let({}, T.nilable(T::Hash[T.untyped, T.untyped]))
+    @db ||= T.let({}, T.nilable(T::Hash[Key, Value]))
     return @db if !@db.empty? || !created?
 
     begin
@@ -163,8 +156,6 @@ def db
 
   # The path where the database resides in the `HOMEBREW_CACHE` for the given
   # `@type`.
-  #
-  # @return [Pathname]
   sig { returns(Pathname) }
   def cache_path
     HOMEBREW_CACHE/"#{@type}.json"
@@ -177,8 +168,6 @@ def dirty!
   end
 
   # Returns `true` if the cache needs to be written to disk.
-  #
-  # @return [Boolean]
   sig { returns(T::Boolean) }
   def dirty?
     !!@dirty
@@ -190,20 +179,23 @@ def dirty?
 # storage mechanism.
 #
 class CacheStore # rubocop:todo Style/OneClassPerFile
+  extend T::Generic
   extend T::Helpers
 
   abstract!
 
-  # @param  [CacheStoreDatabase] database
-  # @return [nil]
-  sig { params(database: CacheStoreDatabase).void }
+  # Sorbet type members are mutable by design and cannot be frozen.
+  Key = type_member # rubocop:disable Style/MutableConstant
+  # Sorbet type members are mutable by design and cannot be frozen.
+  Value = type_member # rubocop:disable Style/MutableConstant
+
+  sig { params(database: CacheStoreDatabase[Key, Value]).void }
   def initialize(database)
-    @database = database
+    @database = T.let(database, CacheStoreDatabase[Key, Value])
   end
 
   protected
 
-  # @return [CacheStoreDatabase]
-  sig { returns(CacheStoreDatabase) }
+  sig { returns(CacheStoreDatabase[Key, Value]) }
   attr_reader :database
 end

Library/Homebrew/cask/dsl/depends_on.rb

@@ -81,9 +81,11 @@ def macos=(*args)
           elsif first_arg.is_a?(Symbol) && MacOSVersion::SYMBOLS.key?(first_arg)
             MacOSRequirement.new([args.first], comparator: "==")
           elsif (md = /^\s*(?<comparator><|>|[=<>]=)\s*:(?<version>\S+)\s*$/.match(first_arg_s))
-            MacOSRequirement.new([T.must(md[:version]).to_sym], comparator: md[:comparator])
+            # The named capture groups must exist, so we use T.must to assert that they do.
+            MacOSRequirement.new([T.must(md[:version]).to_sym], comparator: T.must(md[:comparator]))
           elsif (md = /^\s*(?<comparator><|>|[=<>]=)\s*(?<version>\S+)\s*$/.match(first_arg_s))
-            MacOSRequirement.new([md[:version]], comparator: md[:comparator])
+            # The named capture groups must exist, so we use T.must to assert that they do.
+            MacOSRequirement.new([md[:version]], comparator: T.must(md[:comparator]))
           # This is not duplicate of the first case: see `args.first` and a different comparator.
           else # rubocop:disable Lint/DuplicateBranch
             MacOSRequirement.new([args.first], comparator: "==")

Library/Homebrew/cask/tab.rb

@@ -68,9 +68,9 @@ def self.empty
     sig { params(cask: Cask).returns(T::Hash[Symbol, T::Array[T::Hash[String, T.untyped]]]) }
     def self.runtime_deps_hash(cask)
       cask_and_formula_dep_graph = ::Utils::TopologicalHash.graph_package_dependencies(cask)
-      cask_deps, formula_deps = cask_and_formula_dep_graph.values.flatten.uniq.partition do |dep|
+      cask_deps, formula_deps = T.cast(cask_and_formula_dep_graph.values.flatten.uniq.partition do |dep|
         dep.is_a?(Cask)
-      end
+      end, [T::Array[Cask], T::Array[Formula]])
 
       runtime_deps = {}
 
@@ -126,7 +126,7 @@ def to_s
       elsif loaded_from_api
         s << "using the formulae.brew.sh API"
       end
-      s << Time.at(time).strftime("on %Y-%m-%d at %H:%M:%S") if time
+      s << Time.at(T.must(time)).strftime("on %Y-%m-%d at %H:%M:%S") if time
       s.join(" ")
     end
   end

Library/Homebrew/cask_dependent.rb

@@ -80,12 +80,18 @@ def requirements
     )
   end
 
-  sig { params(block: T.nilable(T.proc.returns(T::Array[Dependency]))).returns(T::Array[Dependency]) }
+  sig {
+    params(block: T.nilable(T.proc.params(arg0: T.any(Formula, CaskDependent, SoftwareSpec),
+                                          arg1: Dependency).void)).returns(T::Array[Dependency])
+  }
   def recursive_dependencies(&block)
     Dependency.expand(self, &block)
   end
 
-  sig { params(block: T.nilable(T.proc.returns(CaskDependent::Requirement))).returns(Requirements) }
+  sig {
+    params(block: T.nilable(T.proc.params(arg0: T.any(Formula, CaskDependent, SoftwareSpec), arg1: ::Requirement)
+                  .returns(CaskDependent::Requirement))).returns(Requirements)
+  }
   def recursive_requirements(&block)
     Requirement.expand(self, &block)
   end