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 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

@@ -715,7 +715,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

@@ -409,7 +409,7 @@ def to_hash_with_variations
       hash = to_h
       variations = {}
 
-      if @dsl.on_system_blocks_exist?
+      if @dsl.uses_on_system.present?
         begin
           OnSystem::ALL_OS_ARCH_COMBINATIONS.each do |os, arch|
             bottle_tag = ::Utils::Bottles::Tag.new(system: os, arch:)

Library/Homebrew/cask/dsl.rb

@@ -100,27 +100,33 @@ class DSL
       :livecheck,
       :livecheck_defined?,
       :livecheckable?, # TODO: remove once `#livecheckable?` is removed
-      :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] },
     ]).freeze
 
     include OnSystem::MacOSAndLinux
 
-    attr_reader :cask, :token, :deprecation_date, :deprecation_reason, :deprecation_replacement, :disable_date,
-                :disable_reason, :disable_replacement, :on_system_block_min_os
+    attr_reader :cask, :token, :deprecation_date, :deprecation_reason,
+                :deprecation_replacement, :disable_date, :disable_reason,
+                :disable_replacement, :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
 
     def initialize(cask)
       @cask = cask
       @depends_on_set_in_block = T.let(false, T::Boolean)
       @deprecated = T.let(false, T::Boolean)
       @disabled = T.let(false, T::Boolean)
       @livecheck_defined = T.let(false, T::Boolean)
-      @on_system_blocks_exist = T.let(false, T::Boolean)
       @token = cask.token
+      @uses_on_system = T.let(OnSystem::UsesOnSystem.new, OnSystem::UsesOnSystem)
     end
 
     sig { returns(T::Boolean) }
@@ -135,9 +141,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.
@@ -353,8 +356,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(
@@ -385,7 +395,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
@@ -410,7 +421,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

@@ -194,7 +194,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)
@@ -230,7 +230,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?
 
@@ -257,7 +257,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

@@ -303,7 +303,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

@@ -9,6 +9,28 @@ module OnSystem
   ALL_OS_OPTIONS = [*MacOSVersion::SYMBOLS.keys, :linux].freeze
   ALL_OS_ARCH_COMBINATIONS = ALL_OS_OPTIONS.product(ARCH_OPTIONS).freeze
 
+  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)
@@ -52,7 +74,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 = true
+        @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__))
 
@@ -65,7 +88,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
@@ -79,7 +104,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__))
 
@@ -92,7 +118,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 if macos
 
       raise ArgumentError, "The first argument to `on_system` must be `:linux`" if linux != :linux
 
@@ -111,7 +139,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
@@ -125,7 +155,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

@@ -265,7 +265,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 }
@@ -2588,7 +2588,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::ALL_OS_ARCH_COMBINATIONS.each do |os, arch|
         bottle_tag = Utils::Bottles::Tag.new(system: os, arch:)
@@ -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