Revert "sorbet: upgrade remaining 19 files to typed: strict"

Author: chenrui333

Library/Homebrew/attestation.rb

@@ -120,7 +120,7 @@ def self.sort_formulae_for_install(formulae)
     # @api private
     sig {
       params(bottle: Bottle, signing_repo: String,
-             signing_workflow: T.nilable(String), subject: T.nilable(String)).returns(T::Hash[String, T.untyped])
+             signing_workflow: T.nilable(String), subject: T.nilable(String)).returns(T::Hash[T.untyped, T.untyped])
     }
     def self.check_attestation(bottle, signing_repo, signing_workflow = nil, subject = nil)
       cmd = ["attestation", "verify", bottle.cached_download, "--repo", signing_repo, "--format",
@@ -138,12 +138,12 @@ def self.check_attestation(bottle, signing_repo, signing_workflow = nil, subject
                                  env: { "GH_TOKEN" => credentials, "GH_HOST" => "github.com" },
                                  secrets: [credentials], print_stderr: false, chdir: HOMEBREW_TEMP)
       rescue ErrorDuringExecution => e
-        if e.exitstatus == 1 && e.stderr.include?("unknown command")
+        if e.status.exitstatus == 1 && e.stderr.include?("unknown command")
           raise GhIncompatible, "gh CLI is incompatible with attestations"
         end
 
         # Even if we have credentials, they may be invalid or malformed.
-        if e.exitstatus == 4 || e.stderr.include?("HTTP 401: Bad credentials")
+        if e.status.exitstatus == 4 || e.stderr.include?("HTTP 401: Bad credentials")
           raise GhAuthInvalid, "invalid credentials"
         end
 
@@ -205,7 +205,7 @@ def self.check_attestation(bottle, signing_repo, signing_workflow = nil, subject
     # @raise [InvalidAttestationError] on any verification failures
     #
     # @api private
-    sig { params(bottle: Bottle).returns(T::Hash[String, T.untyped]) }
+    sig { params(bottle: Bottle).returns(T::Hash[T.untyped, T.untyped]) }
     def self.check_core_attestation(bottle)
       begin
         # Ideally, we would also constrain the signing workflow here, but homebrew-core

Library/Homebrew/bottle.rb

@@ -194,7 +194,7 @@ def installed_size
 
   sig { returns(Filename) }
   def filename
-    Filename.create(T.cast(resource.owner, Formula), @tag, @spec.rebuild)
+    Filename.create(resource.owner, @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(T.cast(resource.owner, Formula), @tag, @spec.rebuild)
+    filename = Filename.create(resource.owner, @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 (formula = e.formula) && (formula.head? || formula.deprecated? || formula.disabled?)
-    reason = if formula.head?
+  elsif e.formula.head? || e.formula.deprecated? || e.formula.disabled?
+    reason = if e.formula.head?
       "was built from an unstable upstream --HEAD"
-    elsif formula.deprecated?
+    elsif e.formula.deprecated?
       "is deprecated"
-    elsif formula.disabled?
+    elsif e.formula.disabled?
       "is disabled"
     end
     $stderr.puts <<~EOS
-      #{formula.name}'s formula #{reason}.
+      #{e.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(T.cast(dependent, Formula))
+      build = effective_build_options_for(dependent)
       if dep.prune_from_option?(build) ||
-         dep.prune_if_build_and_not_dependent?(T.cast(dependent, Formula), formula) ||
+         dep.prune_if_build_and_not_dependent?(dependent, formula) ||
          (dep.test? && !dep.build?) || dep.implicit?
         Dependency.prune
       elsif dep.build?
@@ -291,8 +291,8 @@ def normalize_pod2man_outputs!(formula)
     error_hash["cmd"] = e.cmd
     error_hash["status"] = if e.status.is_a?(Process::Status)
       {
-        exitstatus: e.exitstatus,
-        termsig:    e.termsig,
+        exitstatus: e.status.exitstatus,
+        termsig:    e.status.termsig,
       }
     else
       e.status

Library/Homebrew/build_environment.rb

@@ -59,12 +59,12 @@ def env(*settings)
   ].freeze
   private_constant :KEYS
 
-  sig { params(env: T::Hash[String, T.nilable(T.any(String, T::Boolean, PATH))]).returns(T::Array[String]) }
+  sig { params(env: T::Hash[String, T.nilable(T.any(String, Pathname))]).returns(T::Array[String]) }
   def self.keys(env)
     KEYS & env.keys
   end
 
-  sig { params(env: T::Hash[String, T.nilable(T.any(String, T::Boolean, PATH))], out: IO).void }
+  sig { params(env: T::Hash[String, T.nilable(T.any(String, Pathname))], out: IO).void }
   def self.dump(env, out = $stdout)
     keys = self.keys(env)
     keys -= %w[CC CXX OBJC OBJCXX] if env["CC"] == env["HOMEBREW_CC"]
@@ -75,7 +75,6 @@ def self.dump(env, out = $stdout)
       string = "#{key}: #{value}"
       case key
       when "CC", "CXX", "LD"
-        value = T.cast(value, String)
         string << " => #{Pathname.new(value).realpath}" if value.present? && File.symlink?(value)
       end
       string.freeze

Library/Homebrew/build_options.rb

@@ -30,7 +30,7 @@ def initialize(args, options)
   #   args << "--with-example1"
   # end
   # ```
-  sig { params(val: T.any(String, Dependable)).returns(T::Boolean) }
+  sig { params(val: T.any(String, Requirement, Dependency)).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, Dependable)).returns(T::Boolean) }
+  sig { params(val: T.any(String, Requirement, Dependency)).returns(T::Boolean) }
   def without?(val)
     !with?(val)
   end

Library/Homebrew/bundle.rb

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

Library/Homebrew/bundle/brew.rb

@@ -287,7 +287,8 @@ 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)
-              T.cast(runtime_deps, T::Array[T::Hash[String, T.untyped]]).filter_map { |d| d["full_name"] }
+              runtime_deps.filter_map { |d| d["full_name"] }
+
             end
             poured_from_bottle = tab.poured_from_bottle
           end

Library/Homebrew/cache_store.rb

@@ -8,20 +8,16 @@
 # 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[T.anything, T.anything]).returns(T.type_parameter(:U)),
+        _blk: T.proc.params(arg0: CacheStoreDatabase).returns(T.type_parameter(:U)),
       )
       .returns(T.type_parameter(:U))
   }
@@ -51,29 +47,32 @@ 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: Key, value: Value).void }
+  sig { params(key: T.anything, value: T.anything).void }
   def set(key, value)
     dirty!
     db[key] = value
   end
 
   # Gets a value from the underlying database (if it already exists).
-  sig { params(key: Key).returns(T.nilable(Value)) }
+  sig { params(key: T.anything).returns(T.untyped) }
   def get(key)
     return unless created?
 
     db[key]
   end
 
   # Deletes a value from the underlying database (if it already exists).
-  sig { params(key: Key).void }
+  sig { params(key: T.anything).void }
   def delete(key)
     return unless created?
 
@@ -100,12 +99,16 @@ 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?
@@ -114,23 +117,25 @@ def mtime
   end
 
   # Performs a `select` on the underlying database.
-  sig {
-    overridable.params(block: T.proc.params(arg0: Key, arg1: Value).returns(BasicObject)).returns(T::Hash[Key, Value])
-  }
+  #
+  # @return [Hash]
+  sig { params(block: T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(BasicObject)).returns(T::Hash[T.untyped, T.untyped]) }
   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.
-  sig {
-    params(block: T.proc.params(arg0: Key).returns(BasicObject)).returns(T::Hash[Key, Value])
-  }
+  #
+  # @return [Hash]
+  sig { params(block: T.proc.params(arg0: T.untyped).returns(BasicObject)).returns(T::Hash[T.untyped, T.untyped]) }
   def each_key(&block)
     db.each_key(&block)
   end
@@ -140,9 +145,11 @@ 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.
-  sig { returns(T::Hash[Key, Value]) }
+  #
+  # @return [Hash] db
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
   def db
-    @db ||= T.let({}, T.nilable(T::Hash[Key, Value]))
+    @db ||= T.let({}, T.nilable(T::Hash[T.untyped, T.untyped]))
     return @db if !@db.empty? || !created?
 
     begin
@@ -156,6 +163,8 @@ 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"
@@ -168,6 +177,8 @@ def dirty!
   end
 
   # Returns `true` if the cache needs to be written to disk.
+  #
+  # @return [Boolean]
   sig { returns(T::Boolean) }
   def dirty?
     !!@dirty
@@ -179,23 +190,20 @@ def dirty?
 # storage mechanism.
 #
 class CacheStore # rubocop:todo Style/OneClassPerFile
-  extend T::Generic
   extend T::Helpers
 
   abstract!
 
-  # 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 }
+  # @param  [CacheStoreDatabase] database
+  # @return [nil]
+  sig { params(database: CacheStoreDatabase).void }
   def initialize(database)
     @database = database
   end
 
   protected
 
-  sig { returns(CacheStoreDatabase[Key, Value]) }
+  # @return [CacheStoreDatabase]
+  sig { returns(CacheStoreDatabase) }
   attr_reader :database
 end

Library/Homebrew/cask/dsl/depends_on.rb

@@ -81,11 +81,9 @@ 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))
-            # 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]))
+            MacOSRequirement.new([T.must(md[:version]).to_sym], comparator: md[:comparator])
           elsif (md = /^\s*(?<comparator><|>|[=<>]=)\s*(?<version>\S+)\s*$/.match(first_arg_s))
-            # 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]))
+            MacOSRequirement.new([md[:version]], comparator: 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: "==")