Update Linux CI to use GCC 12

Update both the variables that dictate this and the documents that
explain it.

Author: MikeMcQuaid

Dockerfile

@@ -45,6 +45,7 @@ RUN apt-get update \
   tzdata \
   jq \
   && if [ "$(. /etc/lsb-release; echo "${DISTRIB_RELEASE}" | cut -d. -f1)" -ge 22 ]; then apt-get install -y --no-install-recommends skopeo; fi \
+  && if [ "$(. /etc/lsb-release; echo "${DISTRIB_RELEASE}" | cut -d. -f1)" -eq 22 ]; then apt-get install -y --no-install-recommends g++-12; fi \
   && mkdir -p /etc/apt/keyrings \
   && chmod 0755 /etc /etc/apt /etc/apt/keyrings \
   && curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | tee /etc/apt/keyrings/githubcli-archive-keyring.gpg >/dev/null \

Library/Homebrew/development_tools.rb

@@ -102,6 +102,11 @@ def llvm_clang_build_version
       end, T.nilable(Version))
     end
 
+    sig { returns(Pathname) }
+    def host_gcc_path
+      Pathname.new("/usr/bin/gcc")
+    end
+
     # Get the GCC version.
     #
     # @api internal

Library/Homebrew/extend/os/linux/development_tools.rb

@@ -29,6 +29,17 @@ def locate(tool)
       sig { returns(Symbol) }
       def default_compiler = :gcc
 
+      sig { returns(Pathname) }
+      def host_gcc_path
+        @host_gcc_path ||= T.let(
+          if OS::Linux.os_version.include?("Ubuntu 22.04")
+            Pathname.new("/usr/bin/gcc-12")
+          else
+            Pathname.new("/usr/bin/gcc")
+          end, T.nilable(Pathname)
+        )
+      end
+
       sig { returns(T::Boolean) }
       def needs_libc_formula?
         return @needs_libc_formula unless @needs_libc_formula.nil?
@@ -41,13 +52,12 @@ def needs_libc_formula?
       def needs_compiler_formula?
         return @needs_compiler_formula unless @needs_compiler_formula.nil?
 
-        gcc = "/usr/bin/gcc"
-        @needs_compiler_formula = T.let(if File.exist?(gcc)
-                                          ::DevelopmentTools.gcc_version(gcc) < OS::LINUX_GCC_CI_VERSION
-                                        else
-                                          true
-        end, T.nilable(T::Boolean))
-        !!@needs_compiler_formula
+        @needs_compiler_formula = T.let(nil, T.nilable(T::Boolean))
+        @needs_compiler_formula = if host_gcc_path.exist?
+          ::DevelopmentTools.gcc_version(host_gcc_path.to_s) < OS::LINUX_GCC_CI_VERSION
+        else
+          true
+        end
       end
 
       sig { returns(T::Hash[String, T.nilable(String)]) }

Library/Homebrew/extend/os/linux/system_config.rb

@@ -19,7 +19,7 @@ def host_glibc_version
     end
 
     def host_gcc_version
-      gcc = Pathname.new "/usr/bin/gcc"
+      gcc = DevelopmentTools.host_gcc_path
       return "N/A" unless gcc.executable?
 
       `#{gcc} --version 2>/dev/null`[/ (\d+\.\d+\.\d+)/, 1]
@@ -47,7 +47,7 @@ def dump_verbose_config(out = $stdout)
       out.puts "OS: #{OS::Linux.os_version}"
       out.puts "WSL: #{OS::Linux.wsl_version}" if OS::Linux.wsl?
       out.puts "Host glibc: #{host_glibc_version}"
-      out.puts "/usr/bin/gcc: #{host_gcc_version}"
+      out.puts "#{DevelopmentTools.host_gcc_path}: #{host_gcc_version}"
       out.puts "/usr/bin/ruby: #{host_ruby_version}" if RUBY_PATH != HOST_RUBY_PATH
       ["glibc", CompilerSelector.preferred_gcc, OS::LINUX_PREFERRED_GCC_RUNTIME_FORMULA, "xorg"].each do |f|
         out.puts "#{f}: #{formula_linked_version(f)}"

Library/Homebrew/os.rb

@@ -49,8 +49,8 @@ def self.kernel_name
   LINUX_CI_OS_VERSION = "Ubuntu 22.04"
   LINUX_GLIBC_CI_VERSION = "2.35"
   LINUX_GLIBC_NEXT_CI_VERSION = "2.39"
-  LINUX_GCC_CI_VERSION = "11.0"
-  LINUX_PREFERRED_GCC_COMPILER_FORMULA = "gcc@11" # https://packages.ubuntu.com/jammy/gcc
+  LINUX_GCC_CI_VERSION = "12.0"
+  LINUX_PREFERRED_GCC_COMPILER_FORMULA = "gcc@12" # https://packages.ubuntu.com/jammy/gcc-12
   LINUX_PREFERRED_GCC_RUNTIME_FORMULA = "gcc"
 
   if OS.mac?

docs/Linux-CI.md

@@ -1,5 +1,5 @@
 ---
-last_review_date: "1970-01-01"
+last_review_date: "2025-03-28"
 ---
 
 # Linux CI in `homebrew/core`
@@ -20,25 +20,23 @@ We have moved our CI to Ubuntu 22.04
 
 Moving from Ubuntu 16.04 to Ubuntu 22.04 (and thus skipping version 18.04 and 20.04) took longer than expected.
 
-We plan to proceed with regular updates from 2022 onwards. We aim to use the latest Ubuntu LTS version for our CI.
-
-We will start using the latest Ubuntu LTS version for our CI no earlier than 3 months after its release and, ideally, no more than 12 months after its release.
+We plan to proceed with regular updates from 2022 onwards. We aim to use the oldest supported Ubuntu LTS version for our CI that provides the GCC version we need.
 
 | Distribution | Glibc | GCC | LTS standard security maintenance |
 |---|---|---|---|
 | Ubuntu 14.04 | 2.19 | 4 | From 2014 to 2017 |
 | Ubuntu 16.04 | 2.23 | 5 | From 2017 to 2022 |
 | Ubuntu 20.04 | 2.31 | 5 | From 2020 to 2025 |
-| Ubuntu 22.04 | 2.35 | 11 | From 2022 to 2027 |
+| Ubuntu 22.04 | 2.35 | 11 (provides 12) | From 2022 to 2027 |
 | Ubuntu 24.04 | 2.39 | 13 | From 2024 to 2029 |
 | Ubuntu 26.04 | ? | ? | ? |
 
 [Source](https://ubuntu.com/about/release-cycle)
 
-## Why always use the latest version?
+## Why upgrade to a newer version?
 
 Homebrew is a rolling-release package manager. We try to ship the newest things as quickly as possible, on macOS and Linux.
 
 When a formula needs a newer GCC because our host GCC in CI is too old, we needed to make that formula depend on a newer Homebrew GCC. All C++ dependents of that formula immediately acquire a dependency on Homebrew GCC as well. While we have taken the steps to make sure this no longer holds up GCC updates, it still creates a maintenance burden. This problem is more likely for formula which are very actively maintained and try to use newer features of C++. We decided that we shouldn't have a maintenance burden for formulae which are doing the right thing by staying up to date. It makes a lot of sense for Homebrew maintainers to submit upstream fixes when formulae are not working with newer compilers. It makes a lot less sense for Homebrew maintainers to submit fixes because our host compiler is too old.
 
-Note that `glibc` will need to be installed for more users as their `glibc` version will often be too old: disk space is cheap and we have can handle this situation for our users. This situation will often arise when update to a new LTS version and adoption of the new Ubuntu is still low during the first months. For the same reasons as above: we prefer to stay on the bleeding edge and give our users a gentle nudge to think about updating their OS.
+Note that `glibc` will need to be installed for more users as their `glibc` version will often be too old. This is not as smooth as using a newer GCC as we don't test this configuration in CI. This is why we want to balance the newest GCC with a more conservative `glibc`.