Implement bottle OS-aware dependency resolution for uses_from_macos

Co-authored-by: MikeMcQuaid <[email protected]>

Author: Copilot

Library/Homebrew/dependency.rb

@@ -42,8 +42,14 @@ def to_formula(prefer_stub: false)
     formula
   end
 
-  sig { params(minimum_version: T.nilable(Version), minimum_revision: T.nilable(Integer)).returns(T::Boolean) }
-  def installed?(minimum_version: nil, minimum_revision: nil)
+  sig {
+    params(
+      minimum_version:   T.nilable(Version),
+      minimum_revision:  T.nilable(Integer),
+      bottle_os_version: T.nilable(String),
+    ).returns(T::Boolean)
+  }
+  def installed?(minimum_version: nil, minimum_revision: nil, bottle_os_version: nil)
     formula = begin
       to_formula(prefer_stub: true)
     rescue FormulaUnavailableError
@@ -80,8 +86,8 @@ def installed?(minimum_version: nil, minimum_revision: nil)
     end
   end
 
-  def satisfied?(inherited_options = [], minimum_version: nil, minimum_revision: nil)
-    installed?(minimum_version:, minimum_revision:) &&
+  def satisfied?(inherited_options = [], minimum_version: nil, minimum_revision: nil, bottle_os_version: nil)
+    installed?(minimum_version:, minimum_revision:, bottle_os_version:) &&
       missing_options(inherited_options).empty?
   end
 
@@ -261,22 +267,37 @@ def hash
     [name, tags, bounds].hash
   end
 
-  sig { params(minimum_version: T.nilable(Version), minimum_revision: T.nilable(Integer)).returns(T::Boolean) }
-  def installed?(minimum_version: nil, minimum_revision: nil)
-    use_macos_install? || super
+  sig {
+    params(
+      minimum_version:   T.nilable(Version),
+      minimum_revision:  T.nilable(Integer),
+      bottle_os_version: T.nilable(String),
+    ).returns(T::Boolean)
+  }
+  def installed?(minimum_version: nil, minimum_revision: nil, bottle_os_version: nil)
+    use_macos_install?(bottle_os_version:) || super
   end
 
-  sig { returns(T::Boolean) }
-  def use_macos_install?
+  sig { params(bottle_os_version: T.nilable(String)).returns(T::Boolean) }
+  def use_macos_install?(bottle_os_version: nil)
     # Check whether macOS is new enough for dependency to not be required.
     if Homebrew::SimulateSystem.simulating_or_running_on_macos?
-      # Assume the oldest macOS version when simulating a generic macOS version
-      return true if Homebrew::SimulateSystem.current_os == :macos && !bounds.key?(:since)
+      # If there's no since bound, the dependency is always available from macOS
+      return true if !bounds.key?(:since) && Homebrew::SimulateSystem.current_os == :macos
+
+      # When installing a bottle built on an older macOS version, use that version
+      # to determine if the dependency should come from macOS or Homebrew
+      effective_os = if bottle_os_version.present? && Homebrew::SimulateSystem.current_os != :macos
+        # bottle_os_version is a string like "14" for Sonoma, "15" for Sequoia
+        # Convert it to a MacOS version symbol for comparison
+        MacOSVersion.new(bottle_os_version)
+      else
+        MacOSVersion.from_symbol(Homebrew::SimulateSystem.current_os)
+      end
 
-      if Homebrew::SimulateSystem.current_os != :macos
-        current_os = MacOSVersion.from_symbol(Homebrew::SimulateSystem.current_os)
-        since_os = MacOSVersion.from_symbol(bounds[:since]) if bounds.key?(:since)
-        return true if current_os >= since_os
+      if bounds.key?(:since)
+        since_os = MacOSVersion.from_symbol(bounds[:since])
+        return true if effective_os >= since_os
       end
     end
 

Library/Homebrew/formula_installer.rb

@@ -40,6 +40,9 @@ class FormulaInstaller
   sig { returns(T::Hash[String, T::Hash[String, String]]) }
   attr_reader :bottle_tab_runtime_dependencies
 
+  sig { returns(T.nilable(String)) }
+  attr_reader :bottle_built_os_version
+
   sig { returns(Options) }
   attr_accessor :options
 
@@ -138,6 +141,7 @@ def initialize(
     @poured_bottle = T.let(false, T::Boolean)
     @start_time = T.let(nil, T.nilable(Time))
     @bottle_tab_runtime_dependencies = T.let({}.freeze, T::Hash[String, T::Hash[String, String]])
+    @bottle_built_os_version = T.let(nil, T.nilable(String))
     @hold_locks = T.let(false, T::Boolean)
     @show_summary_heading = T.let(false, T::Boolean)
     @etc_var_preinstall = T.let([], T::Array[Pathname])
@@ -340,10 +344,18 @@ def prelude
 
     # Setup bottle_tab_runtime_dependencies for compute_dependencies
     begin
-      @bottle_tab_runtime_dependencies = formula.bottle_tab_attributes
-                                                .fetch("runtime_dependencies", []).then { |deps| deps || [] }
-                                                .each_with_object({}) { |dep, h| h[dep["full_name"]] = dep }
-                                                .freeze
+      bottle_tab_attrs = formula.bottle_tab_attributes
+      @bottle_tab_runtime_dependencies = bottle_tab_attrs
+                                         .fetch("runtime_dependencies", []).then { |deps| deps || [] }
+                                         .each_with_object({}) { |dep, h| h[dep["full_name"]] = dep }
+                                         .freeze
+      # Extract the OS version the bottle was built on.
+      # Only use this for bottles built on a different OS version than the current OS.
+      # This ensures that when installing older bottles (e.g., sonoma bottle on sequoia),
+      # we resolve dependencies according to the bottle's built OS, not the current OS.
+      bottle_os_version = bottle_tab_attrs.dig("built_on", "os_version")
+      current_os_version = OS_VERSION
+      @bottle_built_os_version = bottle_os_version if bottle_os_version != current_os_version
     rescue Resource::BottleManifest::Error
       # If we can't get the bottle manifest, assume a full dependencies install.
     end
@@ -778,8 +790,9 @@ def expand_dependencies_for_formula(formula, inherited_options)
 
       if dep.prune_from_option?(build) || ((dep.build? || dep.test?) && !keep_build_test)
         Dependency.prune
-      elsif dep.satisfied?(inherited_options[dep.name], minimum_version:  bottle_runtime_version,
-                                                        minimum_revision: bottle_runtime_revision)
+      elsif dep.satisfied?(inherited_options[dep.name], minimum_version:   bottle_runtime_version,
+                                                        minimum_revision:  bottle_runtime_revision,
+                                                        bottle_os_version:)
         Dependency.skip
       end
     end

Library/Homebrew/test/dependency_spec.rb

@@ -122,4 +122,20 @@
       expect(dep).not_to be_test
     end
   end
+
+  describe "Dependency#installed? with bottle_os_version" do
+    it "accepts bottle_os_version parameter" do
+      dep = described_class.new("foo")
+      # Should not raise an error with the new parameter
+      expect { dep.installed?(bottle_os_version: "14") }.not_to raise_error
+    end
+  end
+
+  describe "Dependency#satisfied? with bottle_os_version" do
+    it "accepts bottle_os_version parameter" do
+      dep = described_class.new("foo")
+      # Should not raise an error with the new parameter
+      expect { dep.satisfied?([], bottle_os_version: "14") }.not_to raise_error
+    end
+  end
 end