OnSystem: Add UsesOnSystem class

This adds a `UsesOnSystem` class to `OnSystem`, containing boolean
instance variables to indicate which types of on_system methods are
used in a formula or cask. This is intended as a replacement for
`@on_system_blocks_exist`, which doesn't allow us to determine what
kinds of on_system calls were used. This provides more granularity
but we can still use `@uses_on_system.present?` to determine whether
any on_system calls were used (and this doubles as a `nil` check in
`Formula`, as the `self.class` instance variable has to use a nilable
type).

The `UsesOnSystem` instance variables cover the current
`ARCH_OPTIONS` and `BASE_OS_OPTIONS`. At the moment, we mostly need
to tell whether there are macOS/Linux or Intel/ARM on_system calls,
so I've omitted instance variables for specific macOS version until
we have a need for them.

As a practical example, if you wanted to determine whether a cask
uses Linux on_system calls, you can call
`cask.uses_on_system.linux?`. The `linux` boolean will be `true` if
the cask has an `on_linux` block, an `on_system` block (which requires
Linux), or uses `os linux: ...`. This is something that would be
challenging to determine from outside of `OnSystem` but it's
relatively easy to collect the information in `OnSystem` methods and
make it available like this.

Author: samford

Library/Homebrew/cask/audit.rb

@@ -718,7 +718,7 @@ def audit_min_os
       cask_min_os = [on_system_block_min_os, cask.depends_on.macos&.minimum_version].compact.max
       odebug "Declared minimum OS version: #{cask_min_os&.to_sym}"
       return if cask_min_os&.to_sym == min_os.to_sym
-      return if cask.on_system_blocks_exist? &&
+      return if cask.uses_on_system.present? &&
                 OnSystem.arch_condition_met?(:arm) &&
                 cask_min_os.present? &&
                 cask_min_os < MacOSVersion.new("11")

Library/Homebrew/cask/cask.rb

@@ -414,7 +414,7 @@ def to_hash_with_variations
       hash = to_h
       variations = {}
 
-      if @dsl.on_system_blocks_exist?
+      if @dsl.uses_on_system.present?
         begin
           OnSystem::VALID_OS_ARCH_TAGS.each do |bottle_tag|
             next if bottle_tag.linux? && @dsl.os.nil?

Library/Homebrew/cask/dsl.rb

@@ -106,9 +106,9 @@ class DSL
       :no_autobump!,
       :autobump?,
       :no_autobump_message,
-      :on_system_blocks_exist?,
-      :on_system_block_min_os,
       :depends_on_set_in_block?,
+      :on_system_block_min_os,
+      :uses_on_system,
       *ORDINARY_ARTIFACT_CLASSES.map(&:dsl_key),
       *ACTIVATABLE_ARTIFACT_CLASSES.map(&:dsl_key),
       *ARTIFACT_BLOCK_CLASSES.flat_map { |klass| [klass.dsl_key, klass.uninstall_dsl_key] },
@@ -121,6 +121,11 @@ class DSL
                 :disable_date, :disable_reason, :disable_replacement_cask,
                 :disable_replacement_formula, :on_system_block_min_os
 
+    # A `UsesOnSystem` object that contains boolean instance variables
+    # indicating whether the cask uses specific on_system methods.
+    sig { returns(OnSystem::UsesOnSystem) }
+    attr_reader :uses_on_system
+
     sig { params(cask: Cask).void }
     def initialize(cask)
       # NOTE: Variables set by `set_unique_stanza` must be initialized to `nil`.
@@ -153,13 +158,13 @@ def initialize(cask)
       @name = T.let([], T::Array[String])
       @autobump = T.let(true, T::Boolean)
       @no_autobump_defined = T.let(false, T::Boolean)
-      @on_system_blocks_exist = T.let(false, T::Boolean)
       @os = T.let(nil, T.nilable(String))
       @on_system_block_min_os = T.let(nil, T.nilable(MacOSVersion))
       @sha256 = T.let(nil, T.nilable(T.any(Checksum, Symbol)))
       @staged_path = T.let(nil, T.nilable(Pathname))
       @token = T.let(cask.token, String)
       @url = T.let(nil, T.nilable(URL))
+      @uses_on_system = T.let(OnSystem::UsesOnSystem.new, OnSystem::UsesOnSystem)
       @version = T.let(nil, T.nilable(DSL::Version))
     end
 
@@ -175,9 +180,6 @@ def disabled? = @disabled
     sig { returns(T::Boolean) }
     def livecheck_defined? = @livecheck_defined
 
-    sig { returns(T::Boolean) }
-    def on_system_blocks_exist? = @on_system_blocks_exist
-
     # Specifies the cask's name.
     #
     # NOTE: Multiple names can be specified.
@@ -392,8 +394,15 @@ def sha256(arg = nil, arm: nil, intel: nil, x86_64: nil, x86_64_linux: nil, arm6
 
       x86_64 ||= intel if intel.present? && x86_64.nil?
       set_unique_stanza(:sha256, should_return) do
-        if arm.present? || x86_64.present? || x86_64_linux.present? || arm64_linux.present?
-          @on_system_blocks_exist = true
+        @uses_on_system.arm = true if arm.present?
+        @uses_on_system.intel = true if x86_64.present?
+        if x86_64_linux.present?
+          @uses_on_system.intel = true
+          @uses_on_system.linux = true
+        end
+        if arm64_linux.present?
+          @uses_on_system.arm = true
+          @uses_on_system.linux = true
         end
 
         val = arg || on_system_conditional(
@@ -424,7 +433,8 @@ def arch(arm: nil, intel: nil)
       should_return = arm.nil? && intel.nil?
 
       set_unique_stanza(:arch, should_return) do
-        @on_system_blocks_exist = true
+        @uses_on_system.arm = true if arm
+        @uses_on_system.intel = true if intel
 
         on_arch_conditional(arm:, intel:)
       end
@@ -449,7 +459,8 @@ def os(macos: nil, linux: nil)
       should_return = macos.nil? && linux.nil?
 
       set_unique_stanza(:os, should_return) do
-        @on_system_blocks_exist = true
+        @uses_on_system.macos = true if macos
+        @uses_on_system.linux = true if linux
 
         on_system_conditional(macos:, linux:)
       end

Library/Homebrew/dev-cmd/bump-cask-pr.rb

@@ -199,7 +199,7 @@ def generate_system_options(cask)
         # to on_system blocks referencing macOS versions.
         os_values = []
         arch_values = depends_on_archs.presence || []
-        if cask.on_system_blocks_exist?
+        if cask.uses_on_system.present?
           OnSystem::BASE_OS_OPTIONS.each do |os|
             os_values << if os == :macos
               (current_os_is_macos ? current_os : newest_macos)
@@ -235,7 +235,7 @@ def replace_version_and_checksum(cask, new_hash, new_version, replacement_pairs)
             old_cask = begin
               Cask::CaskLoader.load(cask.sourcefile_path)
             rescue Cask::CaskInvalidError, Cask::CaskUnreadableError
-              raise unless cask.on_system_blocks_exist?
+              raise unless cask.uses_on_system.present?
             end
             next if old_cask.nil?
 
@@ -262,7 +262,7 @@ def replace_version_and_checksum(cask, new_hash, new_version, replacement_pairs)
               replacement_pairs << [/"#{old_hash}"/, ":no_check"] if old_hash != :no_check
             elsif old_hash == :no_check && new_hash != :no_check
               replacement_pairs << [":no_check", "\"#{new_hash}\""] if new_hash.is_a?(String)
-            elsif new_hash && !cask.on_system_blocks_exist? && cask.languages.empty?
+            elsif new_hash && cask.uses_on_system.blank? && cask.languages.empty?
               replacement_pairs << [old_hash.to_s, new_hash.to_s]
             elsif old_hash != :no_check
               opoo "Multiple checksum replacements required; ignoring specified `--sha256` argument." if new_hash

Library/Homebrew/dev-cmd/bump.rb

@@ -305,7 +305,7 @@ def retrieve_pull_requests(formula_or_cask, name, version: nil)
         ).returns(VersionBumpInfo)
       }
       def retrieve_versions_by_arch(formula_or_cask:, repositories:, name:)
-        is_cask_with_blocks = formula_or_cask.is_a?(Cask::Cask) && formula_or_cask.on_system_blocks_exist?
+        is_cask_with_blocks = formula_or_cask.is_a?(Cask::Cask) && formula_or_cask.uses_on_system.present?
         type, version_name = if formula_or_cask.is_a?(Formula)
           [:formula, "formula version:"]
         else

Library/Homebrew/extend/on_system.rb

@@ -22,6 +22,28 @@ module OnSystem
     T::Array[Utils::Bottles::Tag],
   )
 
+  class UsesOnSystem < T::Struct
+    prop :arm, T::Boolean, default: false
+    prop :intel, T::Boolean, default: false
+    prop :linux, T::Boolean, default: false
+    prop :macos, T::Boolean, default: false
+
+    alias arm? arm
+    alias intel? intel
+    alias linux? linux
+    alias macos? macos
+
+    # Whether the object has only default values.
+    sig { returns(T::Boolean) }
+    def empty?
+      !@arm && !@intel && !@linux && !@macos
+    end
+
+    # Whether the object has any non-default values.
+    sig { returns(T::Boolean) }
+    def present? = !empty?
+  end
+
   sig { params(arch: Symbol).returns(T::Boolean) }
   def self.arch_condition_met?(arch)
     raise ArgumentError, "Invalid arch condition: #{arch.inspect}" if ARCH_OPTIONS.exclude?(arch)
@@ -65,7 +87,8 @@ def self.condition_from_method_name(method_name)
   def self.setup_arch_methods(base)
     ARCH_OPTIONS.each do |arch|
       base.define_method(:"on_#{arch}") do |&block|
-        @on_system_blocks_exist = T.let(true, T.nilable(T::Boolean))
+        @uses_on_system ||= T.let(OnSystem::UsesOnSystem.new, T.nilable(OnSystem::UsesOnSystem))
+        @uses_on_system.send(:"#{arch}=", true)
 
         return unless OnSystem.arch_condition_met? OnSystem.condition_from_method_name(T.must(__method__))
 
@@ -78,7 +101,9 @@ def self.setup_arch_methods(base)
     end
 
     base.define_method(:on_arch_conditional) do |arm: nil, intel: nil|
-      @on_system_blocks_exist = true
+      @uses_on_system ||= T.let(OnSystem::UsesOnSystem.new, T.nilable(OnSystem::UsesOnSystem))
+      @uses_on_system.arm = true if arm
+      @uses_on_system.intel = true if intel
 
       if OnSystem.arch_condition_met? :arm
         arm
@@ -92,7 +117,8 @@ def self.setup_arch_methods(base)
   def self.setup_base_os_methods(base)
     BASE_OS_OPTIONS.each do |base_os|
       base.define_method(:"on_#{base_os}") do |&block|
-        @on_system_blocks_exist = true
+        @uses_on_system ||= T.let(OnSystem::UsesOnSystem.new, T.nilable(OnSystem::UsesOnSystem))
+        @uses_on_system.send(:"#{base_os}=", true)
 
         return unless OnSystem.os_condition_met? OnSystem.condition_from_method_name(T.must(__method__))
 
@@ -105,7 +131,9 @@ def self.setup_base_os_methods(base)
     end
 
     base.define_method(:on_system) do |linux, macos:, &block|
-      @on_system_blocks_exist = true
+      @uses_on_system ||= T.let(OnSystem::UsesOnSystem.new, T.nilable(OnSystem::UsesOnSystem))
+      @uses_on_system.linux = true
+      @uses_on_system.macos = true
 
       raise ArgumentError, "The first argument to `on_system` must be `:linux`" if linux != :linux
 
@@ -124,7 +152,9 @@ def self.setup_base_os_methods(base)
     end
 
     base.define_method(:on_system_conditional) do |macos: nil, linux: nil|
-      @on_system_blocks_exist = true
+      @uses_on_system ||= T.let(OnSystem::UsesOnSystem.new, T.nilable(OnSystem::UsesOnSystem))
+      @uses_on_system.macos = true if macos
+      @uses_on_system.linux = true if linux
 
       if OnSystem.os_condition_met?(:macos) && macos.present?
         macos
@@ -138,7 +168,8 @@ def self.setup_base_os_methods(base)
   def self.setup_macos_methods(base)
     MacOSVersion::SYMBOLS.each_key do |os_name|
       base.define_method(:"on_#{os_name}") do |or_condition = nil, &block|
-        @on_system_blocks_exist = true
+        @uses_on_system ||= T.let(OnSystem::UsesOnSystem.new, T.nilable(OnSystem::UsesOnSystem))
+        @uses_on_system.macos = true
 
         os_condition = OnSystem.condition_from_method_name T.must(__method__)
         return unless OnSystem.os_condition_met? os_condition, or_condition

Library/Homebrew/formula.rb

@@ -270,7 +270,7 @@ def initialize(name, path, spec, alias_path: nil, tap: nil, force_bottle: false)
     @follow_installed_alias = T.let(true, T::Boolean)
     @prefix_returns_versioned_prefix = T.let(false, T.nilable(T::Boolean))
     @oldname_locks = T.let([], T::Array[FormulaLock])
-    @on_system_blocks_exist = T.let(false, T::Boolean)
+    @uses_on_system = T.let(OnSystem::UsesOnSystem.new, OnSystem::UsesOnSystem)
   end
 
   sig { params(spec_sym: Symbol).void }
@@ -2591,7 +2591,7 @@ def to_hash_with_variations
 
     variations = {}
 
-    if path.exist? && on_system_blocks_exist?
+    if path.exist? && uses_on_system.present?
       formula_contents = path.read
       OnSystem::VALID_OS_ARCH_TAGS.each do |bottle_tag|
         Homebrew::SimulateSystem.with_tag(bottle_tag) do
@@ -2789,9 +2789,11 @@ def internal_dependencies_hash(spec_symbol)
     end
   end
 
-  sig { returns(T.nilable(T::Boolean)) }
-  def on_system_blocks_exist?
-    self.class.on_system_blocks_exist? || @on_system_blocks_exist
+  # A `UsesOnSystem` object that contains boolean instance variables indicating
+  # whether the formula uses specific on_system methods.
+  sig { returns(OnSystem::UsesOnSystem) }
+  def uses_on_system
+    self.class.uses_on_system || @uses_on_system
   end
 
   sig {
@@ -3331,7 +3333,7 @@ def inherited(child)
         @skip_clean_paths = T.let(Set.new, T.nilable(T::Set[T.any(String, Symbol)]))
         @link_overwrite_paths = T.let(Set.new, T.nilable(T::Set[String]))
         @loaded_from_api = T.let(false, T.nilable(T::Boolean))
-        @on_system_blocks_exist = T.let(false, T.nilable(T::Boolean))
+        @uses_on_system = T.let(OnSystem::UsesOnSystem.new, T.nilable(OnSystem::UsesOnSystem))
         @network_access_allowed = T.let(SUPPORTED_NETWORK_ACCESS_PHASES.to_h do |phase|
           [phase, DEFAULT_NETWORK_ACCESS_ALLOWED]
         end, T.nilable(T::Hash[Symbol, T::Boolean]))
@@ -3345,6 +3347,7 @@ def freeze
       @conflicts.freeze
       @skip_clean_paths.freeze
       @link_overwrite_paths.freeze
+      @uses_on_system.freeze
       super
     end
 
@@ -3355,10 +3358,10 @@ def network_access_allowed = T.must(@network_access_allowed)
     sig { returns(T::Boolean) }
     def loaded_from_api? = !!@loaded_from_api
 
-    # Whether this formula contains OS/arch-specific blocks
-    # (e.g. `on_macos`, `on_arm`, `on_monterey :or_older`, `on_system :linux, macos: :big_sur_or_newer`).
-    sig { returns(T::Boolean) }
-    def on_system_blocks_exist? = !!@on_system_blocks_exist
+    # A `UsesOnSystem` object that contains boolean instance variables
+    # indicating whether the formula uses specific on_system methods.
+    sig { returns(T.nilable(OnSystem::UsesOnSystem)) }
+    attr_reader :uses_on_system
 
     # The reason for why this software is not linked (by default) to {::HOMEBREW_PREFIX}.
     sig { returns(T.nilable(KegOnlyReason)) }

Library/Homebrew/readall.rb

@@ -66,7 +66,7 @@ def self.valid_formulae?(tap, bottle_tag: nil)
       readall_formula = readall_formula_class.new(formula_name, file, :stable, tap:)
       readall_formula.to_hash
       # TODO: Remove check for MACOS_MODULE_REGEX once the `MacOS` module is undefined on Linux
-      cache[:valid_formulae][file] = if readall_formula.on_system_blocks_exist? ||
+      cache[:valid_formulae][file] = if readall_formula.uses_on_system.present? ||
                                         formula_contents.match?(MACOS_MODULE_REGEX)
         [bottle_tag, *cache[:valid_formulae][file]]
       else