Only use MachOShim/ELFShim when required

Not including this globally in `Pathname` speeds up the creation of
other `Pathname` objects by ~200x making all of Homebrew faster.

Author: MikeMcQuaid

Library/Homebrew/build.rb

@@ -198,7 +198,7 @@ def install
             (formula.logs/"00.options.out").write \
               "#{formula.full_name} #{formula.build.used_options.sort.join(" ")}".strip
 
-            Pathname.prepend WriteMkpathExtension
+            Pathname.activate_extensions!
             formula.install
 
             stdlibs = detect_stdlibs

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

@@ -1,11 +1,19 @@
 # typed: strict
 # frozen_string_literal: true
 
-class Cleaner
-  private
+module OS
+  module Linux
+    module Cleaner
+      private
 
-  sig { params(path: Pathname).returns(T::Boolean) }
-  def executable_path?(path)
-    path.elf? || path.text_executable?
+      sig { params(path: Pathname).returns(T::Boolean) }
+      def executable_path?(path)
+        return true if path.text_executable?
+
+        ::OSPathname.wrap(path).elf?
+      end
+    end
   end
 end
+
+Cleaner.prepend(OS::Linux::Cleaner)

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

@@ -208,7 +208,7 @@ def check_gcc_dependent_linkage
             # There are other checks that test that, we can skip broken kegs.
             next if dependent_prefix.nil? || !dependent_prefix.exist? || !dependent_prefix.directory?
 
-            keg = Keg.new(dependent_prefix)
+            keg = ::Keg.new(dependent_prefix)
             keg.binary_executable_or_library_files.any? do |binary|
               paths = binary.rpaths
               versioned_linkage = paths.any? { |path| path.match?(%r{lib/gcc/\d+$}) }

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

@@ -3,6 +3,22 @@
 
 require "os/linux/elf"
 
-class Pathname
-  prepend ELFShim
+module OS
+  module Linux
+    module OSPathname
+      module ClassMethods
+        extend T::Helpers
+
+        requires_ancestor { T.class_of(::OSPathname) }
+
+        sig { returns(T::Array[T::Module[T.anything]]) }
+        def self.os_extension_modules
+          [ELFShim, *::OSPathname.os_extension_modules]
+        end
+      end
+    end
+  end
 end
+
+OSPathname.prepend(ELFShim)
+OSPathname.singleton_class.prepend(OS::Linux::OSPathname::ClassMethods)

Library/Homebrew/extend/os/linux/extend/pathname.rbi

@@ -1,5 +1,5 @@
 # typed: strict
 
-class Pathname
+class OSPathname
   include ELFShim
 end

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

@@ -1,9 +1,13 @@
 # typed: strict
 # frozen_string_literal: true
 
-class Keg
-  sig { returns(T::Array[Pathname]) }
-  def binary_executable_or_library_files
-    elf_files
+module OS
+  module Linux
+    module Keg
+      sig { returns(T::Array[::OSPathname]) }
+      def binary_executable_or_library_files = elf_files
+    end
   end
 end
+
+Keg.prepend(OS::Linux::Keg)

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

@@ -3,97 +3,109 @@
 
 require "compilers"
 
-class Keg
-  sig { params(relocation: Relocation, skip_protodesc_cold: T::Boolean).void }
-  def relocate_dynamic_linkage(relocation, skip_protodesc_cold: false)
-    # Patching the dynamic linker of glibc breaks it.
-    return if name.match? Version.formula_optionally_versioned_regex(:glibc)
+module OS
+  module Linux
+    module Keg
+      extend T::Helpers
 
-    old_prefix, new_prefix = relocation.replacement_pair_for(:prefix)
+      requires_ancestor { ::Keg }
 
-    elf_files.each do |file|
-      file.ensure_writable do
-        change_rpath!(file, old_prefix, new_prefix, skip_protodesc_cold:)
-      end
-    end
-  end
+      sig { params(relocation: ::Keg::Relocation, skip_protodesc_cold: T::Boolean).void }
+      def relocate_dynamic_linkage(relocation, skip_protodesc_cold: false)
+        # Patching the dynamic linker of glibc breaks it.
+        return if name.match? Version.formula_optionally_versioned_regex(:glibc)
+
+        old_prefix, new_prefix = relocation.replacement_pair_for(:prefix)
 
-  sig {
-    params(file: Pathname, old_prefix: T.any(String, Regexp), new_prefix: String,
-           skip_protodesc_cold: T::Boolean).returns(T::Boolean)
-  }
-  def change_rpath!(file, old_prefix, new_prefix, skip_protodesc_cold: false)
-    return false if !file.elf? || !file.dynamic_elf?
-
-    # Skip relocation of files with `protodesc_cold` sections because patchelf.rb seems to break them,
-    # but only when bottling (as we don't want to break existing bottles that require relocation).
-    # https://github.com/Homebrew/homebrew-core/pull/232490#issuecomment-3161362452
-    return false if skip_protodesc_cold && file.section_names.include?("protodesc_cold")
-
-    updated = {}
-    old_rpath = file.rpath
-    new_rpath = if old_rpath
-      rpath = old_rpath.split(":")
-                       .map { |x| x.sub(old_prefix, new_prefix) }
-                       .select { |x| x.start_with?(new_prefix, "$ORIGIN") }
-
-      lib_path = "#{new_prefix}/lib"
-      rpath << lib_path unless rpath.include? lib_path
-
-      # Add GCC's lib directory (as of GCC 12+) to RPATH when there is existing versioned linkage.
-      # This prevents broken linkage when pouring bottles built with an old GCC formula.
-      unless name.match?(Version.formula_optionally_versioned_regex(:gcc))
-        rpath.map! { |rp| rp.sub(%r{lib/gcc/\d+$}, "lib/gcc/current") }
+        elf_files.each do |file|
+          file.ensure_writable do
+            change_rpath!(file, old_prefix, new_prefix, skip_protodesc_cold:)
+          end
+        end
       end
 
-      rpath.join(":")
-    end
-    updated[:rpath] = new_rpath if old_rpath != new_rpath
-
-    old_interpreter = file.interpreter
-    new_interpreter = if old_interpreter.nil?
-      nil
-    elsif File.readable? "#{new_prefix}/lib/ld.so"
-      "#{new_prefix}/lib/ld.so"
-    else
-      old_interpreter.sub old_prefix, new_prefix
-    end
-    updated[:interpreter] = new_interpreter if old_interpreter != new_interpreter
+      sig {
+        params(file: ::OSPathname, old_prefix: T.any(String, Regexp), new_prefix: String,
+               skip_protodesc_cold: T::Boolean).returns(T::Boolean)
+      }
+      def change_rpath!(file, old_prefix, new_prefix, skip_protodesc_cold: false)
+        return false if !file.elf? || !file.dynamic_elf?
+
+        # Skip relocation of files with `protodesc_cold` sections because patchelf.rb seems to break them,
+        # but only when bottling (as we don't want to break existing bottles that require relocation).
+        # https://github.com/Homebrew/homebrew-core/pull/232490#issuecomment-3161362452
+        return false if skip_protodesc_cold && file.section_names.include?("protodesc_cold")
+
+        updated = {}
+        old_rpath = file.rpath
+        new_rpath = if old_rpath
+          rpath = old_rpath.split(":")
+                           .map { |x| x.sub(old_prefix, new_prefix) }
+                           .select { |x| x.start_with?(new_prefix, "$ORIGIN") }
+
+          lib_path = "#{new_prefix}/lib"
+          rpath << lib_path unless rpath.include? lib_path
+
+          # Add GCC's lib directory (as of GCC 12+) to RPATH when there is existing versioned linkage.
+          # This prevents broken linkage when pouring bottles built with an old GCC formula.
+          unless name.match?(Version.formula_optionally_versioned_regex(:gcc))
+            rpath.map! { |rp| rp.sub(%r{lib/gcc/\d+$}, "lib/gcc/current") }
+          end
+
+          rpath.join(":")
+        end
+        updated[:rpath] = new_rpath if old_rpath != new_rpath
+
+        old_interpreter = file.interpreter
+        new_interpreter = if old_interpreter.nil?
+          nil
+        elsif File.readable? "#{new_prefix}/lib/ld.so"
+          "#{new_prefix}/lib/ld.so"
+        else
+          old_interpreter.sub old_prefix, new_prefix
+        end
+        updated[:interpreter] = new_interpreter if old_interpreter != new_interpreter
+
+        file.patch!(interpreter: updated[:interpreter], rpath: updated[:rpath])
+        true
+      end
 
-    file.patch!(interpreter: updated[:interpreter], rpath: updated[:rpath])
-    true
-  end
+      sig { params(options: T::Hash[Symbol, T::Boolean]).returns(T::Array[Symbol]) }
+      def detect_cxx_stdlibs(options = {})
+        skip_executables = options.fetch(:skip_executables, false)
+        results = Set.new
+        elf_files.each do |file|
+          next unless file.dynamic_elf?
+          next if file.binary_executable? && skip_executables
+
+          dylibs = file.dynamically_linked_libraries
+          results << :libcxx if dylibs.any? { |s| s.include? "libc++.so" }
+          results << :libstdcxx if dylibs.any? { |s| s.include? "libstdc++.so" }
+        end
+        results.to_a
+      end
 
-  sig { params(options: T::Hash[Symbol, T::Boolean]).returns(T::Array[Symbol]) }
-  def detect_cxx_stdlibs(options = {})
-    skip_executables = options.fetch(:skip_executables, false)
-    results = Set.new
-    elf_files.each do |file|
-      next unless file.dynamic_elf?
-      next if file.binary_executable? && skip_executables
-
-      dylibs = file.dynamically_linked_libraries
-      results << :libcxx if dylibs.any? { |s| s.include? "libc++.so" }
-      results << :libstdcxx if dylibs.any? { |s| s.include? "libstdc++.so" }
-    end
-    results.to_a
-  end
+      sig { returns(T::Array[::OSPathname]) }
+      def elf_files
+        hardlinks = Set.new
+        elf_files = []
+        path.find do |pn|
+          next if pn.symlink? || pn.directory?
 
-  sig { returns(T::Array[Pathname]) }
-  def elf_files
-    hardlinks = Set.new
-    elf_files = []
-    path.find do |pn|
-      next if pn.symlink? || pn.directory?
-      next if !pn.dylib? && !pn.binary_executable?
+          pn = ::OSPathname.wrap(pn)
+          next if !pn.dylib? && !pn.binary_executable?
 
-      # If we've already processed a file, ignore its hardlinks (which have the
-      # same dev ID and inode). This prevents relocations from being performed
-      # on a binary more than once.
-      next unless hardlinks.add? [pn.stat.dev, pn.stat.ino]
+          # If we've already processed a file, ignore its hardlinks (which have the
+          # same dev ID and inode). This prevents relocations from being performed
+          # on a binary more than once.
+          next unless hardlinks.add? [pn.stat.dev, pn.stat.ino]
 
-      elf_files << pn
+          elf_files << pn
+        end
+        elf_files
+      end
     end
-    elf_files
   end
 end
+
+Keg.prepend(OS::Linux::Keg)

Library/Homebrew/extend/os/mac/cleaner.rb

@@ -8,7 +8,9 @@ module Cleaner
 
       sig { params(path: Pathname).returns(T::Boolean) }
       def executable_path?(path)
-        path.mach_o_executable? || path.text_executable?
+        return true if path.text_executable?
+
+        ::OSPathname.wrap(path).mach_o_executable?
       end
     end
   end

Library/Homebrew/extend/os/mac/extend/pathname.rb

@@ -3,6 +3,22 @@
 
 require "os/mac/mach"
 
-class Pathname
-  prepend MachOShim
+module OS
+  module Mac
+    module OSPathname
+      module ClassMethods
+        extend T::Helpers
+
+        requires_ancestor { T.class_of(::OSPathname) }
+
+        sig { returns(T::Array[T::Module[T.anything]]) }
+        def self.os_extension_modules
+          [MachOShim, *::OSPathname.os_extension_modules]
+        end
+      end
+    end
+  end
 end
+
+OSPathname.prepend(MachOShim)
+OSPathname.singleton_class.prepend(OS::Mac::OSPathname::ClassMethods)

Library/Homebrew/extend/os/mac/extend/pathname.rbi

@@ -1,5 +1,5 @@
 # typed: strict
 
-class Pathname
+class OSPathname
   include MachOShim
 end