autoremove: handle runtime dependencies

Library/Homebrew/test/utils/autoremove_spec.rb

@@ -40,23 +40,31 @@
     end
 
     let(:tab_from_keg) { instance_double(Tab) }
+    let(:keg_for_formula_with_deps) { instance_double(Keg, tab: tab_from_keg, optlinked?: true) }
+    let(:keg_for_first_dep) { instance_double(Keg, tab: tab_from_keg, optlinked?: true) }
+    let(:keg_for_second_dep) { instance_double(Keg, tab: tab_from_keg, optlinked?: true) }
+    let(:keg_for_build_dep) { instance_double(Keg, tab: tab_from_keg, optlinked?: true) }
 
     before do
       allow(formula_with_deps).to receive_messages(
         installed_runtime_formula_dependencies: [first_formula_dep, second_formula_dep],
-        any_installed_keg:                      instance_double(Keg, tab: tab_from_keg),
+        runtime_installed_formula_dependents:   [],
+        any_installed_keg:                      keg_for_formula_with_deps,
       )
       allow(first_formula_dep).to receive_messages(
         installed_runtime_formula_dependencies: [second_formula_dep],
-        any_installed_keg:                      instance_double(Keg, tab: tab_from_keg),
+        runtime_installed_formula_dependents:   [],
+        any_installed_keg:                      keg_for_first_dep,
       )
       allow(second_formula_dep).to receive_messages(
         installed_runtime_formula_dependencies: [],
-        any_installed_keg:                      instance_double(Keg, tab: tab_from_keg),
+        runtime_installed_formula_dependents:   [],
+        any_installed_keg:                      keg_for_second_dep,
       )
       allow(formula_is_build_dep).to receive_messages(
         installed_runtime_formula_dependencies: [],
-        any_installed_keg:                      instance_double(Keg, tab: tab_from_keg),
+        runtime_installed_formula_dependents:   [],
+        any_installed_keg:                      keg_for_build_dep,
       )
     end
   end
@@ -67,6 +75,21 @@
     before do
       allow(Formulary).to receive(:factory).with("three", { warn: false })
                                            .and_return(formula_is_build_dep)
+      allow(formula_with_deps).to receive(:runtime_dependencies)
+        .with(read_from_tab: false, undeclared: false)
+        .and_return([
+          instance_double(Dependency, to_formula: first_formula_dep),
+          instance_double(Dependency, to_formula: second_formula_dep),
+        ])
+      allow(first_formula_dep).to receive(:runtime_dependencies)
+        .with(read_from_tab: false, undeclared: false)
+        .and_return([])
+      allow(second_formula_dep).to receive(:runtime_dependencies)
+        .with(read_from_tab: false, undeclared: false)
+        .and_return([])
+      allow(formula_is_build_dep).to receive(:runtime_dependencies)
+        .with(read_from_tab: false, undeclared: false)
+        .and_return([])
     end
 
     context "when formulae are bottles" do
@@ -78,6 +101,23 @@
       end
     end
 
+    context "when a formula has runtime dependencies according to current definition" do
+      it "keeps the dependency" do
+        allow(tab_from_keg).to receive(:poured_from_bottle).and_return(true)
+        allow(formula_with_deps).to receive(:installed_runtime_formula_dependencies)
+          .and_return([])
+        # Set up pango-like scenario: formula_with_deps depends on second_formula_dep
+        dep_requirement = instance_double(Dependency)
+        allow(dep_requirement).to receive(:to_formula).and_return(second_formula_dep)
+        allow(formula_with_deps).to receive(:runtime_dependencies)
+          .with(read_from_tab: false, undeclared: false)
+          .and_return([dep_requirement])
+
+        expect(described_class.send(:bottled_formulae_with_no_formula_dependents, formulae))
+          .not_to include(second_formula_dep)
+      end
+    end
+
     context "when formulae are built from source" do
       it "filters out formulae" do
         allow(tab_from_keg).to receive(:poured_from_bottle).and_return(false)
@@ -93,6 +133,18 @@
 
     before do
       allow(tab_from_keg).to receive(:poured_from_bottle).and_return(true)
+      allow(formula_with_deps).to receive(:runtime_dependencies)
+        .with(read_from_tab: false, undeclared: false)
+        .and_return([])
+      allow(first_formula_dep).to receive(:runtime_dependencies)
+        .with(read_from_tab: false, undeclared: false)
+        .and_return([])
+      allow(second_formula_dep).to receive(:runtime_dependencies)
+        .with(read_from_tab: false, undeclared: false)
+        .and_return([])
+      allow(formula_is_build_dep).to receive(:runtime_dependencies)
+        .with(read_from_tab: false, undeclared: false)
+        .and_return([])
     end
 
     specify "installed on request" do

Library/Homebrew/utils/autoremove.rb

@@ -7,10 +7,6 @@ module Utils
   # @private
   module Autoremove
     class << self
-      # An array of {Formula} without {Formula} or {Cask}
-      # dependents that weren't installed on request and without
-      # build dependencies for {Formula} installed from source.
-      # @private
       sig { params(formulae: T::Array[Formula], casks: T::Array[Cask::Cask]).returns(T::Array[Formula]) }
       def removable_formulae(formulae, casks)
         unused_formulae = unused_formulae_with_no_formula_dependents(formulae)
@@ -19,8 +15,6 @@ def removable_formulae(formulae, casks)
 
       private
 
-      # An array of all installed {Formula} with {Cask} dependents.
-      # @private
       sig { params(casks: T::Array[Cask::Cask]).returns(T::Array[Formula]) }
       def formulae_with_cask_dependents(casks)
         casks.flat_map { |cask| cask.depends_on[:formula] }.compact.flat_map do |name|
@@ -35,45 +29,51 @@ def formulae_with_cask_dependents(casks)
         end
       end
 
-      # An array of all installed bottled {Formula} without runtime {Formula}
-      # dependents for bottles and without build {Formula} dependents
-      # for those built from source.
-      # @private
       sig { params(formulae: T::Array[Formula]).returns(T::Array[Formula]) }
+      # Returns the subset of the given formulae that are bottled and have no
+      # other formulae depending on them, based on current formula definitions.
+      # Formulae that are runtime dependencies, or that were built from source
+      # (and their build dependencies), are filtered out and kept.
       def bottled_formulae_with_no_formula_dependents(formulae)
         formulae_to_keep = T.let([], T::Array[Formula])
         formulae.each do |formula|
-          formulae_to_keep += formula.installed_runtime_formula_dependencies
+          keg = formula.any_installed_keg
+          # Include runtime deps from the current formula definition.
+          formulae_to_keep += formula.runtime_dependencies(read_from_tab: false,
+                                                           undeclared:    false).filter_map do |dep|
+            dep.to_formula
+          rescue FormulaUnavailableError
+            nil
+          end
 
-          if (tab = formula.any_installed_keg&.tab)
-            # Ignore build dependencies when the formula is a bottle
-            next if tab.poured_from_bottle
+          tab = keg&.tab
+          next unless tab
+          next if tab.poured_from_bottle
 
-            # Keep the formula if it was built from source
-            formulae_to_keep << formula
-          end
+          # Keep non-bottled formulae and their build dependencies
+          formulae_to_keep << formula
 
-          formula.deps.select(&:build?).each do |dep|
-            formulae_to_keep << dep.to_formula
+          formulae_to_keep += formula.deps.select(&:build?).filter_map do |dep|
+            dep.to_formula
           rescue FormulaUnavailableError
-            # do nothing
+            nil
           end
         end
         names_to_keep = formulae_to_keep.to_set(&:name)
         formulae.reject { |f| names_to_keep.include?(f.name) }
       end
 
-      # Recursive function that returns an array of {Formula} without
-      # {Formula} dependents that weren't installed on request.
+      # An array of {Formula} without {Formula} or {Cask}
+      # dependents that weren't installed on request and without
+      # build dependencies for {Formula} installed from source.
       # @private
       sig { params(formulae: T::Array[Formula]).returns(T::Array[Formula]) }
       def unused_formulae_with_no_formula_dependents(formulae)
         unused_formulae = bottled_formulae_with_no_formula_dependents(formulae).select do |f|
           tab = f.any_installed_keg&.tab
-          next unless tab
-          next unless tab.installed_on_request_present?
+          next false unless tab
 
-          tab.installed_on_request == false
+          tab.installed_on_request_present? && tab.installed_on_request == false
         end
 
         unless unused_formulae.empty?