generate-cask-ci-matrix: respect on_linux architecture constraints

Refactor the architecture filtering logic in `generate-cask-ci-matrix` to correctly inspect `on_linux` blocks using `Homebrew::SimulateSystem`. This ensures that architecture dependencies defined within `on_linux` (e.g., `depends_on arch: :intel`) are respected when generating the CI matrix.

Author: biplavbarua

Library/Homebrew/dev-cmd/generate-cask-ci-matrix.rb

@@ -9,6 +9,8 @@
 
 module Homebrew
   module DevCmd
+    # Generates a GitHub Actions CI matrix for Casks.
+    # @api private
     class GenerateCaskCiMatrix < AbstractCommand
       MAX_JOBS = 256
 
@@ -127,33 +129,71 @@ def run
 
       sig { params(cask: Cask::Cask).returns(T::Hash[T::Hash[Symbol, T.any(Symbol, String)], Float]) }
       def filter_runners(cask)
-        filtered_macos_runners = RUNNERS.select do |runner, _|
-          runner[:symbol] != :linux &&
+        filtered_runners = if cask.supports_macos?
+          filtered_macos_runners = MACOS_RUNNERS.select do |runner, _|
             cask.depends_on.macos.present? &&
-            cask.depends_on.macos.allows?(MacOSVersion.from_symbol(T.must(runner[:symbol]).to_sym))
-        end
+              cask.depends_on.macos.allows?(MacOSVersion.from_symbol(T.must(runner[:symbol]).to_sym))
+          end
+
+          return MACOS_RUNNERS.dup if filtered_macos_runners.none?
 
-        filtered_runners = if filtered_macos_runners.any?
           filtered_macos_runners
-        else
-          RUNNERS.dup
         end
 
-        filtered_runners = filtered_runners.merge(LINUX_RUNNERS) if cask.supports_linux?
+        filtered_runners = T.must(filtered_runners)
 
         archs = architectures(cask:)
+        odebug "Architectures macOS: #{archs}" if archs.any?
         filtered_runners.select! do |runner, _|
           archs.include?(runner.fetch(:arch))
         end
 
+        odebug "Filtered runners: #{filtered_runners.keys.map { |r| r[:name] }}" if filtered_runners.any?
+        if cask.supports_linux?
+          filtered_linux_runners = LINUX_RUNNERS.dup
+
+          archs = architectures(cask:, os: :linux, arch: :intel)
+          filtered_linux_runners.select! do |runner, _|
+            archs.include?(runner.fetch(:arch))
+          end
+
+          filtered_runners.merge!(filtered_linux_runners)
+        end
+
+        odebug "Architectures linux: #{archs}" if archs.any?
+        odebug "Filtered runners: #{filtered_runners.keys.map { |r| r[:name] }}" if filtered_runners.any?
+
         filtered_runners
       end
 
-      sig { params(cask: Cask::Cask).returns(T::Array[Symbol]) }
-      def architectures(cask:)
-        return RUNNERS.keys.map { |r| r.fetch(:arch).to_sym }.uniq.sort if cask.depends_on.arch.blank?
+      sig { params(cask: Cask::Cask, os: Symbol, arch: Symbol).returns(T::Array[Symbol]) }
+      def architectures(cask:, os: :macos, arch: :arm)
+        architectures = T.let([], T.untyped)
+        begin
+          tag = Utils::Bottles::Tag.new(system: os, arch: arch)
+          Homebrew::SimulateSystem.with_tag(tag) do
+            cask.refresh
+
+            if cask.depends_on.arch.blank?
+              # If the Cask does not define a general architecture requirement,
+              # check if there is one specific to Linux.
+              architectures = if (linux_archs = Homebrew::SimulateSystem.with(os: :linux) do
+                Cask::CaskLoader.load(cask.sourcefile_path).depends_on.arch
+              end)
+                linux_archs.map { |a| a[:type] }.uniq.sort
+              else
+                RUNNERS.keys.map { |r| r.fetch(:arch).to_sym }.uniq.sort
+              end
+              next
+            end
+
+            architectures = cask.depends_on.arch.map { |arch| arch[:type] }
+          end
+        rescue ::Cask::CaskInvalidError
+          # Can't read cask for this system-arch combination.
+        end
 
-        cask.depends_on.arch.map { |arch| arch[:type] }.uniq.sort
+        architectures
       end
 
       sig {
@@ -255,7 +295,7 @@ def generate_matrix(tap, labels: [], cask_names: [], skip_install: false, new_ca
             native_runner_arch = arch == runner.fetch(:arch)
             # we don't need to run simulated archs on Linux
             next if runner.fetch(:symbol) == :linux && !native_runner_arch
-            # we don't need to run simulated archs on macOS
+            # we don't need to run simulated archs on macOS Sequoia
             next if runner.fetch(:symbol) == :sequoia && !native_runner_arch
 
             # If it's just a single OS test then we can just use the two real arch runners.

Library/Homebrew/test/dev-cmd/generate-cask-ci-matrix_spec.rb

@@ -1,8 +1,27 @@
+# typed: strict
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
 require "dev-cmd/generate-cask-ci-matrix"
 
 RSpec.describe Homebrew::DevCmd::GenerateCaskCiMatrix do
   it_behaves_like "parseable arguments"
+
+  describe "#architectures" do
+    let(:cmd) { described_class.new }
+    let(:linux_arch_cask) { Cask::CaskLoader.load(TEST_FIXTURE_DIR/"cask/Casks/on-linux-arch.rb") }
+    let(:standard_cask) { Cask::CaskLoader.load(TEST_FIXTURE_DIR/"cask/Casks/basic-cask.rb") }
+
+    it "returns only [:intel] for Casks with an on_linux arch dependency" do
+      expect(cmd.architectures(cask: linux_arch_cask)).to eq([:intel])
+    end
+
+    it "returns all runners for standard Casks" do
+      # Assuming standard behavior is to return all archs from RUNNERS
+      expected_archs = Homebrew::DevCmd::GenerateCaskCiMatrix::RUNNERS.keys.map do |r|
+        r.fetch(:arch).to_sym
+      end.uniq.sort
+      expect(cmd.architectures(cask: standard_cask)).to eq(expected_archs)
+    end
+  end
 end

Library/Homebrew/test/support/fixtures/cask/Casks/on-linux-arch.rb

@@ -0,0 +1,15 @@
+cask "on-linux-arch" do
+  version "1.0.0"
+  sha256 :no_check
+
+  url "https://brew.sh/"
+  name "On Linux Arch"
+  desc "Cask with on_linux architecture dependency"
+  homepage "https://brew.sh/"
+
+  on_linux do
+    depends_on arch: :intel
+  end
+
+  app "On Linux Arch.app"
+end