Remove alias generic_* definitions in favour of using super

Library/Homebrew/api/analytics.rb

@@ -10,7 +10,6 @@ class << self
         def analytics_api_path
           "analytics"
         end
-        alias generic_analytics_api_path analytics_api_path
 
         sig { params(category: String, days: T.any(Integer, String)).returns(T::Hash[String, T.untyped]) }
         def fetch(category, days)

Library/Homebrew/dev-cmd/update-test.rb

@@ -142,6 +142,7 @@ def run
 
       private
 
+      sig { returns(String) }
       def git_tags
         tags = Utils.popen_read("git", "tag", "--list", "--sort=-version:refname")
         if tags.blank?

Library/Homebrew/diagnostic.rb

@@ -350,7 +350,6 @@ def check_tmpdir_sticky_bit
             sudo chmod +t #{HOMEBREW_TEMP}
         EOS
       end
-      alias generic_check_tmpdir_sticky_bit check_tmpdir_sticky_bit
 
       def check_exist_directories
         return if HOMEBREW_PREFIX.writable?

Library/Homebrew/extend/ENV/shared.rb

@@ -54,8 +54,6 @@ def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_a
     @debug_symbols = debug_symbols
     reset
   end
-  alias generic_shared_setup_build_environment setup_build_environment
-  private :generic_shared_setup_build_environment
 
   sig { void }
   def reset

Library/Homebrew/extend/ENV/std.rb

@@ -68,7 +68,6 @@ def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_a
     gcc_formula = gcc_version_formula(cc)
     append_path "PATH", gcc_formula.opt_bin.to_s
   end
-  alias generic_setup_build_environment setup_build_environment
 
   sig { returns(T.nilable(PATH)) }
   def determine_pkg_config_libdir

Library/Homebrew/extend/ENV/super.rb

@@ -125,7 +125,6 @@ def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_a
     # These flags will also be present:
     # a - apply fix for apr-1-config path
   end
-  alias generic_setup_build_environment setup_build_environment
 
   private
 
@@ -152,7 +151,6 @@ def homebrew_extra_paths
         .reverse
         .map { |d| d.opt_libexec/"bin" }
   end
-  alias generic_homebrew_extra_paths homebrew_extra_paths
 
   sig { returns(T.nilable(PATH)) }
   def determine_path
@@ -372,8 +370,8 @@ def refurbish_args
     append_to_cccfg "O"
   end
 
+  # This is an exception where we want to use this method name format.
   # rubocop: disable Naming/MethodName
-  # Fixes style error `Naming/MethodName: Use snake_case for method names.`
   sig { params(block: T.nilable(T.proc.void)).void }
   def O0(&block)
     if block

Library/Homebrew/extend/os/linux/dev-cmd/update-test.rb

@@ -1,19 +1,19 @@
 # typed: strict
 # frozen_string_literal: true
 
-module Homebrew
-  module DevCmd
-    class UpdateTest < AbstractCommand
-      alias generic_git_tags git_tags
+module OS
+  module Linux
+    module DevCmd
+      module UpdateTest
+        private
 
-      private
-
-      sig { returns(String) }
-      def git_tags
-        tags = generic_git_tags
-        tags = Utils.popen_read("git tag --list | sort -rV") if tags.blank?
-        tags
+        sig { returns(String) }
+        def git_tags
+          super.presence || Utils.popen_read("git tag --list | sort -rV")
+        end
       end
     end
   end
 end
+
+Homebrew::DevCmd::UpdateTest.prepend(OS::Linux::DevCmd::UpdateTest)

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

@@ -62,7 +62,7 @@ def needs_compiler_formula?
       def build_system_info
         super.merge({
           "glibc_version"     => OS::Linux::Glibc.version.to_s.presence,
-          "oldest_cpu_family" => Hardware.oldest_cpu.to_s,
+          "oldest_cpu_family" => ::Hardware.oldest_cpu.to_s,
         })
       end
     end

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

@@ -32,7 +32,7 @@
         end
 
         def check_tmpdir_sticky_bit
-          message = generic_check_tmpdir_sticky_bit
+          message = super
           return if message.nil?
 
           message + <<~EOS
@@ -74,11 +74,11 @@
         end
 
         def check_supported_architecture
-          return if Hardware::CPU.intel?
-          return if Homebrew::EnvConfig.developer? && ENV["HOMEBREW_ARM64_TESTING"].present? && Hardware::CPU.arm?
+          return if ::Hardware::CPU.intel?
+          return if Homebrew::EnvConfig.developer? && ENV["HOMEBREW_ARM64_TESTING"].present? && ::Hardware::CPU.arm?
 
           <<~EOS
-            Your CPU architecture (#{Hardware::CPU.arch}) is not supported. We only support
+            Your CPU architecture (#{::Hardware::CPU.arch}) is not supported. We only support
             x86_64 CPU architectures. You will be unable to use binary packages (bottles).
 
             #{support_tier_message(tier: 2)}

Library/Homebrew/extend/os/linux/extend/ENV/shared.rb

@@ -1,16 +1,22 @@
 # typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-module SharedEnvExtension
-  def effective_arch
-    if @build_bottle && @bottle_arch
-      @bottle_arch.to_sym
-    elsif @build_bottle
-      Hardware.oldest_cpu
-    elsif Hardware::CPU.intel? || Hardware::CPU.arm?
-      :native
-    else
-      :dunno
+module OS
+  module Linux
+    module SharedEnvExtension
+      def effective_arch
+        if @build_bottle && @bottle_arch
+          @bottle_arch.to_sym
+        elsif @build_bottle
+          ::Hardware.oldest_cpu
+        elsif ::Hardware::CPU.intel? || ::Hardware::CPU.arm?
+          :native
+        else
+          :dunno
+        end
+      end
     end
   end
 end
+
+SharedEnvExtension.prepend(OS::Linux::SharedEnvExtension)

Library/Homebrew/extend/os/linux/extend/ENV/std.rb

@@ -1,36 +1,45 @@
 # typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-module Stdenv
-  sig {
-    params(
-      formula:         T.nilable(Formula),
-      cc:              T.nilable(String),
-      build_bottle:    T.nilable(T::Boolean),
-      bottle_arch:     T.nilable(String),
-      testing_formula: T::Boolean,
-      debug_symbols:   T.nilable(T::Boolean),
-    ).void
-  }
-  def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil, testing_formula: false,
-                              debug_symbols: false)
-    generic_setup_build_environment(formula:, cc:, build_bottle:, bottle_arch:,
-                                    testing_formula:, debug_symbols:)
-
-    prepend_path "CPATH", HOMEBREW_PREFIX/"include"
-    prepend_path "LIBRARY_PATH", HOMEBREW_PREFIX/"lib"
-    prepend_path "LD_RUN_PATH", HOMEBREW_PREFIX/"lib"
-
-    return unless @formula
-
-    prepend_path "CPATH", @formula.include
-    prepend_path "LIBRARY_PATH", @formula.lib
-    prepend_path "LD_RUN_PATH", @formula.lib
-  end
+module OS
+  module Linux
+    module Stdenv
+      extend T::Helpers
+
+      requires_ancestor { ::SharedEnvExtension }
+
+      sig {
+        params(
+          formula:         T.nilable(::Formula),
+          cc:              T.nilable(String),
+          build_bottle:    T.nilable(T::Boolean),
+          bottle_arch:     T.nilable(String),
+          testing_formula: T::Boolean,
+          debug_symbols:   T.nilable(T::Boolean),
+        ).void
+      }
+      def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil,
+                                  testing_formula: false, debug_symbols: false)
+        super
+
+        prepend_path "CPATH", HOMEBREW_PREFIX/"include"
+        prepend_path "LIBRARY_PATH", HOMEBREW_PREFIX/"lib"
+        prepend_path "LD_RUN_PATH", HOMEBREW_PREFIX/"lib"
 
-  def libxml2
-    append "CPPFLAGS", "-I#{Formula["libxml2"].include/"libxml2"}"
-  rescue FormulaUnavailableError
-    nil
+        return unless @formula
+
+        prepend_path "CPATH", @formula.include
+        prepend_path "LIBRARY_PATH", @formula.lib
+        prepend_path "LD_RUN_PATH", @formula.lib
+      end
+
+      def libxml2
+        append "CPPFLAGS", "-I#{::Formula["libxml2"].include/"libxml2"}"
+      rescue FormulaUnavailableError
+        nil
+      end
+    end
   end
 end
+
+Stdenv.prepend(OS::Linux::Stdenv)

Library/Homebrew/extend/os/linux/extend/ENV/super.rb

@@ -1,79 +1,93 @@
 # typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-module Superenv
-  sig { returns(Pathname) }
-  def self.shims_path
-    HOMEBREW_SHIMS_PATH/"linux/super"
-  end
+module OS
+  module Linux
+    module Superenv
+      extend T::Helpers
 
-  sig { returns(T.nilable(Pathname)) }
-  def self.bin
-    shims_path.realpath
-  end
+      requires_ancestor { SharedEnvExtension }
+      requires_ancestor { ::Superenv }
 
-  sig {
-    params(
-      formula:         T.nilable(Formula),
-      cc:              T.nilable(String),
-      build_bottle:    T.nilable(T::Boolean),
-      bottle_arch:     T.nilable(String),
-      testing_formula: T::Boolean,
-      debug_symbols:   T.nilable(T::Boolean),
-    ).void
-  }
-  def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil, testing_formula: false,
-                              debug_symbols: false)
-    generic_setup_build_environment(formula:, cc:, build_bottle:, bottle_arch:,
-                                    testing_formula:, debug_symbols:)
-    self["HOMEBREW_OPTIMIZATION_LEVEL"] = "O2"
-    self["HOMEBREW_DYNAMIC_LINKER"] = determine_dynamic_linker_path
-    self["HOMEBREW_RPATH_PATHS"] = determine_rpath_paths(@formula)
-    m4_path_deps = ["libtool", "bison"]
-    self["M4"] = "#{HOMEBREW_PREFIX}/opt/m4/bin/m4" if deps.any? { m4_path_deps.include?(_1.name) }
+      module ClassMethods
+        sig { returns(Pathname) }
+        def shims_path
+          HOMEBREW_SHIMS_PATH/"linux/super"
+        end
 
-    # Pointer authentication and BTI are hardening techniques most distros
-    # use by default on their packages. arm64 Linux we're packaging
-    # everything from scratch so the entire dependency tree can have it.
-    append_to_cccfg "b" if Hardware::CPU.arch == :arm64 && DevelopmentTools.gcc_version("gcc") >= 9
-  end
+        sig { returns(T.nilable(Pathname)) }
+        def bin
+          shims_path.realpath
+        end
+      end
 
-  def homebrew_extra_paths
-    paths = generic_homebrew_extra_paths
-    paths += %w[binutils make].filter_map do |f|
-      bin = Formulary.factory(f).opt_bin
-      bin if bin.directory?
-    rescue FormulaUnavailableError
-      nil
-    end
-    paths
-  end
+      sig {
+        params(
+          formula:         T.nilable(Formula),
+          cc:              T.nilable(String),
+          build_bottle:    T.nilable(T::Boolean),
+          bottle_arch:     T.nilable(String),
+          testing_formula: T::Boolean,
+          debug_symbols:   T.nilable(T::Boolean),
+        ).void
+      }
+      def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil,
+                                  testing_formula: false, debug_symbols: false)
+        super
 
-  def homebrew_extra_isystem_paths
-    paths = []
-    # Add paths for GCC headers when building against versioned glibc because we have to use -nostdinc.
-    if deps.any? { |d| d.name.match?(/^glibc@.+$/) }
-      gcc_include_dir = Utils.safe_popen_read(cc, "--print-file-name=include").chomp
-      gcc_include_fixed_dir = Utils.safe_popen_read(cc, "--print-file-name=include-fixed").chomp
-      paths << gcc_include_dir << gcc_include_fixed_dir
-    end
-    paths
-  end
+        self["HOMEBREW_OPTIMIZATION_LEVEL"] = "O2"
+        self["HOMEBREW_DYNAMIC_LINKER"] = determine_dynamic_linker_path
+        self["HOMEBREW_RPATH_PATHS"] = determine_rpath_paths(@formula)
+        m4_path_deps = ["libtool", "bison"]
+        self["M4"] = "#{HOMEBREW_PREFIX}/opt/m4/bin/m4" if deps.any? { m4_path_deps.include?(_1.name) }
 
-  def determine_rpath_paths(formula)
-    PATH.new(
-      *formula&.lib,
-      "#{HOMEBREW_PREFIX}/opt/gcc/lib/gcc/current",
-      PATH.new(run_time_deps.map { |dep| dep.opt_lib.to_s }).existing,
-      "#{HOMEBREW_PREFIX}/lib",
-    )
-  end
+        # Pointer authentication and BTI are hardening techniques most distros
+        # use by default on their packages. arm64 Linux we're packaging
+        # everything from scratch so the entire dependency tree can have it.
+        append_to_cccfg "b" if ::Hardware::CPU.arch == :arm64 && ::DevelopmentTools.gcc_version("gcc") >= 9
+      end
+
+      def homebrew_extra_paths
+        paths = super
+        paths += %w[binutils make].filter_map do |f|
+          bin = Formulary.factory(f).opt_bin
+          bin if bin.directory?
+        rescue FormulaUnavailableError
+          nil
+        end
+        paths
+      end
+
+      def homebrew_extra_isystem_paths
+        paths = []
+        # Add paths for GCC headers when building against versioned glibc because we have to use -nostdinc.
+        if deps.any? { |d| d.name.match?(/^glibc@.+$/) }
+          gcc_include_dir = Utils.safe_popen_read(cc, "--print-file-name=include").chomp
+          gcc_include_fixed_dir = Utils.safe_popen_read(cc, "--print-file-name=include-fixed").chomp
+          paths << gcc_include_dir << gcc_include_fixed_dir
+        end
+        paths
+      end
 
-  sig { returns(T.nilable(String)) }
-  def determine_dynamic_linker_path
-    path = "#{HOMEBREW_PREFIX}/lib/ld.so"
-    return unless File.readable? path
+      def determine_rpath_paths(formula)
+        PATH.new(
+          *formula&.lib,
+          "#{HOMEBREW_PREFIX}/opt/gcc/lib/gcc/current",
+          PATH.new(run_time_deps.map { |dep| dep.opt_lib.to_s }).existing,
+          "#{HOMEBREW_PREFIX}/lib",
+        )
+      end
 
-    path
+      sig { returns(T.nilable(String)) }
+      def determine_dynamic_linker_path
+        path = "#{HOMEBREW_PREFIX}/lib/ld.so"
+        return unless File.readable? path
+
+        path
+      end
+    end
   end
 end
+
+Superenv.singleton_class.prepend(OS::Linux::Superenv::ClassMethods)
+Superenv.prepend(OS::Linux::Superenv)