treewide: replace substituteAll with replaceVars (part 3)

Driving #237216 forward.

pkgs/by-name/ac/accountsservice/package.nix

···
   lib,
   stdenv,
   fetchurl,
-  substituteAll,
+  replaceVars,
   pkg-config,
   glib,
   shadow,
···
 
   patches = [
     # Hardcode dependency paths.
-    (substituteAll {
-      src = ./fix-paths.patch;
+    (replaceVars ./fix-paths.patch {
       inherit shadow coreutils;
     })
 

pkgs/by-name/al/alvr/package.nix

···
   lib,
   rustPlatform,
   fetchFromGitHub,
-  substituteAll,
+  replaceVars,
   nix-update-script,
   pkg-config,
   autoAddDriverRunpath,
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./fix-finding-libs.patch;
+    (replaceVars ./fix-finding-libs.patch {
       ffmpeg = lib.getDev ffmpeg;
       x264 = lib.getDev x264;
     })

pkgs/by-name/ap/appstream-glib/package.nix

···
   lib,
   stdenv,
   fetchFromGitHub,
-  substituteAll,
+  replaceVars,
   docbook_xml_dtd_42,
   docbook_xsl,
   fontconfig,
···
   ];
 
   patches = [
-    (substituteAll {
-      src = ./paths.patch;
+    (replaceVars ./paths.patch {
       pngquant = "${pngquant}/bin/pngquant";
     })
   ];

pkgs/by-name/cc/ccache/package.nix

···
   lib,
   stdenv,
   fetchFromGitHub,
-  substituteAll,
+  replaceVars,
   binutils,
   asciidoctor,
   cmake,
···
     # Darwin.
     # Additionally, when cross compiling, the correct target prefix
     # needs to be set.
-    (substituteAll {
-      src = ./fix-objdump-path.patch;
+    (replaceVars ./fix-objdump-path.patch {
       objdump = "${binutils.bintools}/bin/${binutils.targetPrefix}objdump";
     })
   ];

pkgs/by-name/cm/cmake/package.nix

···
 { lib
 , stdenv
 , fetchurl
-, substituteAll
+, replaceVars
 , buildPackages
 , bzip2
 , curlMinimal
···
   ++ lib.optional stdenv.hostPlatform.isDarwin ./006-darwin-always-set-runtime-c-flag.diff
   # On platforms where ps is not part of stdenv, patch the invocation of ps to use an absolute path.
   ++ lib.optional (stdenv.hostPlatform.isDarwin || stdenv.hostPlatform.isFreeBSD) (
-    substituteAll {
-      src = ./007-darwin-bsd-ps-abspath.diff;
+    replaceVars ./007-darwin-bsd-ps-abspath.diff {
       ps = lib.getExe ps;
     })
   ++ [

pkgs/by-name/fl/flatpak/package.nix

···
   python3,
   shared-mime-info,
   socat,
-  substituteAll,
+  replaceVars,
   systemd,
   testers,
   valgrind,
···
   patches = [
     # Hardcode paths used by tests and change test runtime generation to use files from Nix store.
     # https://github.com/flatpak/flatpak/issues/1460
-    (substituteAll {
-      src = ./fix-test-paths.patch;
+    (replaceVars ./fix-test-paths.patch {
       inherit
         coreutils
         gettext
···
     })
 
     # Hardcode paths used by Flatpak itself.
-    (substituteAll {
-      src = ./fix-paths.patch;
+    (replaceVars ./fix-paths.patch {
       p11kit = "${p11-kit.bin}/bin/p11-kit";
     })
 
···
     '';
 
   passthru = {
-    icon-validator-patch = substituteAll {
-      src = ./fix-icon-validation.patch;
+    icon-validator-patch = replaceVars ./fix-icon-validation.patch {
       inherit (builtins) storeDir;
     };
 

pkgs/by-name/fo/formatter/package.nix

···
   pkg-config,
   pantheon,
   python3,
-  substituteAll,
+  replaceVars,
   glib,
   gtk3,
   dosfstools,
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./fix-paths.patch;
+    (replaceVars ./fix-paths.patch {
       ext4 = "${e2fsprogs}/bin/mkfs.ext4";
       exfat = "${exfat}/bin/mkfs.exfat";
       fat = "${dosfstools}/bin/mkfs.fat";

pkgs/by-name/gd/gdm/package.nix

···
   stdenv,
   fetchurl,
   fetchpatch,
-  substituteAll,
+  replaceVars,
   meson,
   ninja,
   pkg-config,
···
 
 let
 
-  override = substituteAll {
-    src = ./org.gnome.login-screen.gschema.override;
+  override = replaceVars ./org.gnome.login-screen.gschema.override {
     icon = "${nixos-icons}/share/icons/hicolor/scalable/apps/nix-snowflake-white.svg";
   };
 
···
     })
 
     # Change hardcoded paths to nix store paths.
-    (substituteAll {
-      src = ./fix-paths.patch;
+    (replaceVars ./fix-paths.patch {
       inherit
         coreutils
         plymouth

pkgs/by-name/gl/glib-networking/package.nix

···
   stdenv,
   lib,
   fetchurl,
-  substituteAll,
+  replaceVars,
   meson,
   ninja,
   nixosTests,
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./hardcode-gsettings.patch;
+    (replaceVars ./hardcode-gsettings.patch {
       gds_gsettings_path = glib.getSchemaPath gsettings-desktop-schemas;
     })
 

pkgs/by-name/gn/gnome-control-center/package.nix

···
   fetchurl,
   lib,
   stdenv,
-  substituteAll,
+  replaceVars,
   accountsservice,
   adwaita-icon-theme,
   colord,
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./paths.patch;
+    (replaceVars ./paths.patch {
       gcm = gnome-color-manager;
       inherit glibc tzdata shadow;
       inherit cups networkmanagerapplet;

pkgs/by-name/gn/gnome-desktop/package.nix

···
   lib,
   stdenv,
   fetchurl,
-  substituteAll,
+  replaceVars,
   pkg-config,
   libxslt,
   ninja,
···
   };
 
   patches = lib.optionals stdenv.hostPlatform.isLinux [
-    (substituteAll {
-      src = ./bubblewrap-paths.patch;
+    (replaceVars ./bubblewrap-paths.patch {
       bubblewrap_bin = "${bubblewrap}/bin/bwrap";
       inherit (builtins) storeDir;
     })

pkgs/by-name/gn/gnome-initial-setup/package.nix

···
   stdenv,
   lib,
   fetchurl,
-  substituteAll,
+  replaceVars,
   dconf,
   gettext,
   meson,
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./0001-fix-paths.patch;
+    (replaceVars ./0001-fix-paths.patch {
       inherit tzdata;
       tecla = gnome-tecla;
     })

pkgs/by-name/gn/gnome-pomodoro/package.nix

···
   lib,
   stdenv,
   fetchFromGitHub,
-  substituteAll,
+  replaceVars,
   meson,
   ninja,
   pkg-config,
···
   patches = [
     # Our glib setup hooks moves GSettings schemas to a subdirectory to prevent conflicts.
     # We need to patch the build script so that the extension can find them.
-    (substituteAll {
-      src = ./fix-schema-path.patch;
+    (replaceVars ./fix-schema-path.patch {
       inherit pname version;
     })
   ];

pkgs/by-name/gn/gnome-session/package.nix

···
   fetchurl,
   lib,
   stdenv,
-  substituteAll,
+  replaceVars,
   meson,
   ninja,
   pkg-config,
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./fix-paths.patch;
+    (replaceVars ./fix-paths.patch {
       gsettings = "${glib.bin}/bin/gsettings";
       dbusLaunch = "${dbus.lib}/bin/dbus-launch";
       bash = "${bash}/bin/bash";

pkgs/by-name/gn/gnome-settings-daemon/package.nix

···
 {
   stdenv,
   lib,
-  substituteAll,
+  replaceVars,
   buildPackages,
   fetchurl,
   meson,
···
     # https://gitlab.gnome.org/GNOME/gnome-settings-daemon/-/merge_requests/202
     ./add-gnome-session-ctl-option.patch
 
-    (substituteAll {
-      src = ./fix-paths.patch;
+    (replaceVars ./fix-paths.patch {
       inherit tzdata;
     })
   ];

pkgs/by-name/gn/gnome-settings-daemon46/package.nix

···
 {
   stdenv,
   lib,
-  substituteAll,
+  replaceVars,
   fetchurl,
   meson,
   ninja,
···
     # https://gitlab.gnome.org/GNOME/gnome-settings-daemon/-/merge_requests/202
     ./add-gnome-session-ctl-option.patch
 
-    (substituteAll {
-      src = ./fix-paths.patch;
+    (replaceVars ./fix-paths.patch {
       inherit tzdata;
     })
   ];

pkgs/by-name/gn/gnome-shell-extensions/package.nix

···
   glib,
   gnome,
   gnome-menus,
-  substituteAll,
+  replaceVars,
 }:
 
 stdenv.mkDerivation (finalAttrs: {
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./fix_gmenu.patch;
+    (replaceVars ./fix_gmenu.patch {
       gmenu_path = "${gnome-menus}/lib/girepository-1.0";
     })
-    (substituteAll {
-      src = ./fix_gtop.patch;
+    (replaceVars ./fix_gtop.patch {
       gtop_path = "${libgtop}/lib/girepository-1.0";
     })
   ];

pkgs/by-name/gn/gnome-shell/package.nix

···
 {
   fetchurl,
   fetchpatch,
-  substituteAll,
+  replaceVars,
   lib,
   stdenv,
   docutils,
···
 
   patches = [
     # Hardcode paths to various dependencies so that they can be found at runtime.
-    (substituteAll {
-      src = ./fix-paths.patch;
+    (replaceVars ./fix-paths.patch {
       glib_compile_schemas = "${glib.dev}/bin/glib-compile-schemas";
       gsettings = "${glib.bin}/bin/gsettings";
       tecla = "${lib.getBin gnome-tecla}/bin/tecla";

pkgs/by-name/gn/gnome-software/package.nix

···
   lib,
   stdenv,
   fetchurl,
-  substituteAll,
+  replaceVars,
   pkg-config,
   meson,
   ninja,
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./fix-paths.patch;
+    (replaceVars ./fix-paths.patch {
       inherit isocodes;
     })
   ];

pkgs/by-name/go/google-cloud-cpp/package.nix

···
   lib,
   stdenv,
   fetchFromGitHub,
-  substituteAll,
+  replaceVars,
   c-ares,
   cmake,
   crc32c,
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./hardcode-googleapis-path.patch;
+    (replaceVars ./hardcode-googleapis-path.patch {
       url = googleapis;
     })
   ];

pkgs/by-name/gp/gparted/package.nix

···
   util-linux,
   polkit,
   wrapGAppsHook3,
-  substituteAll,
+  replaceVars,
   mtools,
   dosfstools,
   xhost,
···
   # however the binary won't be suid so it returns
   # an error preventing the program from detection
   patches = [
-    (substituteAll {
-      src = ./polkit.patch;
+    (replaceVars ./polkit.patch {
       polkit_version = polkit.version;
     })
   ];

pkgs/by-name/gu/gusb/package.nix

···
   lib,
   stdenv,
   fetchFromGitHub,
-  substituteAll,
+  replaceVars,
   meson,
   ninja,
   pkg-config,
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./fix-python-path.patch;
+    (replaceVars ./fix-python-path.patch {
       python = "${pythonEnv}/bin/python3";
     })
   ];

pkgs/by-name/gv/gvfs/package.nix

···
   meson,
   ninja,
   pkg-config,
-  substituteAll,
+  replaceVars,
   gettext,
   dbus,
   glib,
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./hardcode-ssh-path.patch;
+    (replaceVars ./hardcode-ssh-path.patch {
       ssh_program = "${lib.getBin openssh}/bin/ssh";
     })
   ];

pkgs/by-name/ha/hare/package.nix

···
   scdoc,
   tzdata,
   mailcap,
-  substituteAll,
+  replaceVars,
   callPackage,
   enableCrossCompilation ? (stdenv.hostPlatform.isLinux && stdenv.hostPlatform.is64bit),
   pkgsCross,
···
 
   patches = [
     # Replace FHS paths with nix store
-    (substituteAll {
-      src = ./001-tzdata.patch;
+    (replaceVars ./001-tzdata.patch {
       inherit tzdata;
     })
     # Don't build haredoc since it uses the build `hare` bin, which breaks
     # cross-compilation.
     ./002-dont-build-haredoc.patch
     # Hardcode harec and qbe.
-    (substituteAll {
-      src = ./003-hardcode-qbe-and-harec.patch;
+    (replaceVars ./003-hardcode-qbe-and-harec.patch {
       harec_bin = lib.getExe harec;
       qbe_bin = lib.getExe qbe;
     })
     # Use mailcap `/etc/mime.types` for Hare's mime module
-    (substituteAll {
-      src = ./004-use-mailcap-for-mimetypes.patch;
+    (replaceVars ./004-use-mailcap-for-mimetypes.patch {
       inherit mailcap;
     })
   ];

pkgs/by-name/ha/haredo/package.nix

···
   nix-update-script,
   makeWrapper,
   bash,
-  substituteAll,
+  replaceVars,
 }:
 stdenv.mkDerivation (finalAttrs: {
   pname = "haredo";
···
 
   patches = [
     # Use nix store's bash instead of sh. `@bash@/bin/sh` is used, since haredo expects a posix shell.
-    (substituteAll {
-      src = ./001-use-nix-store-sh.patch;
+    (replaceVars ./001-use-nix-store-sh.patch {
       inherit bash;
     })
   ];

pkgs/by-name/ho/howard-hinnant-date/package.nix

···
-{ lib, stdenv, fetchFromGitHub, cmake, tzdata, fetchpatch, substituteAll }:
+{ lib, stdenv, fetchFromGitHub, cmake, tzdata, fetchpatch, replaceVars }:
 
 stdenv.mkDerivation rec {
   pname = "howard-hinnant-date";
···
     # Without this patch, this library will drop a `tzdata` directory into
     # `~/Downloads` if it cannot find `/usr/share/zoneinfo`. Make the path it
     # searches for `zoneinfo` be the one from the `tzdata` package.
-    (substituteAll {
-      src = ./make-zoneinfo-available.diff;
+    (replaceVars ./make-zoneinfo-available.diff {
       inherit tzdata;
     })
   ];

pkgs/by-name/in/iniparser/package.nix

···
   stdenv,
   fetchFromGitLab,
   fetchFromGitHub,
-  substituteAll,
+  replaceVars,
   symlinkJoin,
   cmake,
   doxygen,
···
   };
 
   patches = lib.optionals finalAttrs.finalPackage.doCheck [
-    (substituteAll {
+    (replaceVars ./remove-fetchcontent-usage.patch {
       # Do not let cmake's fetchContent download unity
-      src = ./remove-fetchcontent-usage.patch;
       unitySrc = symlinkJoin {
         name = "unity-with-iniparser-config";
         paths = [

pkgs/by-name/is/isc-cron/package.nix

···
   lib,
   fetchurl,
   stdenv,
-  substituteAll,
+  replaceVars,
   vim,
   sendmailPath ? "/usr/sbin/sendmail",
 }:
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./0000-nixpkgs-specific.diff;
+    (replaceVars ./0000-nixpkgs-specific.diff {
       inherit sendmailPath;
       viPath = lib.getExe' vim "vim";
       defPath = lib.concatStringsSep ":" [

pkgs/by-name/jo/john/package.nix

···
   ocl-icd,
   # include non-free ClamAV unrar code
   enableUnfree ? false,
-  substituteAll,
+  replaceVars,
   makeWrapper,
 }:
 
···
   };
 
   patches = lib.optionals withOpenCL [
-    (substituteAll {
-      src = ./opencl.patch;
+    (replaceVars ./opencl.patch {
       ocl_icd = ocl-icd;
     })
   ];

pkgs/by-name/ke/keepass/package.nix

···
   mono,
   makeWrapper,
   icoutils,
-  substituteAll,
+  replaceVars,
   xsel,
   xorg,
   xdotool,
···
   buildInputs = [ icoutils ];
 
   patches = [
-    (substituteAll {
-      src = ./fix-paths.patch;
+    (replaceVars ./fix-paths.patch {
       xsel = "${xsel}/bin/xsel";
       xprop = "${xorg.xprop}/bin/xprop";
       xdotool = "${xdotool}/bin/xdotool";

pkgs/by-name/la/lalrpop/package.nix

···
   lib,
   rustPlatform,
   fetchFromGitHub,
-  substituteAll,
+  replaceVars,
   stdenv,
 }:
 
···
   cargoHash = "sha256-zkPLas+fQQzm7LlWNpTooUR/e30KMS9OET6PMwQ2yAA=";
 
   patches = [
-    (substituteAll {
-      src = ./use-correct-binary-path-in-tests.patch;
+    (replaceVars ./use-correct-binary-path-in-tests.patch {
       target_triple = stdenv.hostPlatform.rust.rustcTarget;
     })
   ];

pkgs/by-name/li/libosinfo/package.nix

···
   perl,
   hwdata,
   osinfo-db,
-  substituteAll,
+  replaceVars,
   vala ? null,
 }:
 
···
   ];
 
   patches = [
-    (substituteAll {
-      src = ./osinfo-db-data-dir.patch;
+    (replaceVars ./osinfo-db-data-dir.patch {
       osinfo_db_data_dir = "${osinfo-db}/share";
     })
 

pkgs/by-name/me/metacity/package.nix

···
   libstartup_notification,
   libxml2,
   pkg-config,
-  substituteAll,
+  replaceVars,
   wrapGAppsHook3,
   zenity,
 }:
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./fix-paths.patch;
+    (replaceVars ./fix-paths.patch {
       inherit zenity;
     })
   ];

pkgs/by-name/mi/minigalaxy/package.nix

···
   libnotify,
   python3Packages,
   steam-run,
-  substituteAll,
+  replaceVars,
   unzip,
   webkitgtk_4_0,
   wrapGAppsHook3,
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./inject-launcher-steam-run.diff;
+    (replaceVars ./inject-launcher-steam-run.diff {
       steamrun = lib.getExe steam-run;
     })
   ];

pkgs/by-name/mi/mirakurun/package.nix

···
   installShellFiles,
   makeWrapper,
   nodejs,
-  substituteAll,
+  replaceVars,
   v4l-utils,
   which,
 }:
···
         nodejs
         which
       ] ++ lib.optionals stdenv.hostPlatform.isLinux [ v4l-utils ];
-      crc32Patch = substituteAll {
-        src = ./fix-musl-detection.patch;
+      crc32Patch = replaceVars ./fix-musl-detection.patch {
         isMusl = if stdenv.hostPlatform.isMusl then "true" else "false";
       };
     in

pkgs/by-name/mu/muffin/package.nix

···
   stdenv,
   lib,
   fetchFromGitHub,
-  substituteAll,
+  replaceVars,
   cairo,
   cinnamon-desktop,
   dbus,
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./fix-paths.patch;
+    (replaceVars ./fix-paths.patch {
       inherit zenity;
     })
   ];

pkgs/by-name/mu/music-assistant/package.nix

···
   fetchFromGitHub,
   ffmpeg-headless,
   nixosTests,
-  substituteAll,
+  replaceVars,
   providers ? [ ],
 }:
 
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./ffmpeg.patch;
+    (replaceVars ./ffmpeg.patch {
       ffmpeg = "${lib.getBin ffmpeg-headless}/bin/ffmpeg";
       ffprobe = "${lib.getBin ffmpeg-headless}/bin/ffprobe";
     })

pkgs/by-name/na/nautilus-python/package.nix

···
 {
   stdenv,
   lib,
-  substituteAll,
+  replaceVars,
   fetchurl,
   meson,
   ninja,
···
 
   patches = [
     # Make PyGObject’s gi library available.
-    (substituteAll {
-      src = ./fix-paths.patch;
+    (replaceVars ./fix-paths.patch {
       pythonPaths = lib.concatMapStringsSep ", " (pkg: "'${pkg}/${python3.sitePackages}'") [
         python3.pkgs.pygobject3
       ];

pkgs/by-name/nu/nut/package.nix

···
   net-snmp,
   openssl,
   pkg-config,
-  substituteAll,
+  replaceVars,
   systemd,
   udev,
   gnused,
···
     # trying to install directly into /etc/nut which predictably fails
     ./nutshutdown-conf-default.patch
 
-    (substituteAll {
-      src = ./hardcode-paths.patch;
+    (replaceVars ./hardcode-paths.patch {
       avahi = "${avahi}/lib";
       freeipmi = "${freeipmi}/lib";
       libgpiod = "${libgpiod_1}/lib";

pkgs/by-name/oc/octoprint/package.nix

···
   fetchFromGitHub,
   fetchPypi,
   python3,
-  substituteAll,
+  replaceVars,
   nix-update-script,
   nixosTests,
   # To include additional plugins, pass them here as an overlay.
···
 
           patches = [
             # substitute pip and let it find out, that it can't write anywhere
-            (substituteAll {
-              src = ./pip-path.patch;
+            (replaceVars ./pip-path.patch {
               pip = "${self.pip}/bin/pip";
             })
 
             # hardcore path to ffmpeg and hide related settings
-            (substituteAll {
-              src = ./ffmpeg-path.patch;
+            (replaceVars ./ffmpeg-path.patch {
               ffmpeg = "${pkgs.ffmpeg}/bin/ffmpeg";
             })
           ];

pkgs/by-name/on/onboard/package.nix

···
   fetchpatch,
   stdenv,
   lib,
-  substituteAll,
+  replaceVars,
   aspellWithDicts,
   at-spi2-core ? null,
   atspiSupport ? true,
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./fix-paths.patch;
+    (replaceVars ./fix-paths.patch {
       inherit mousetweaks;
     })
     # Allow loading hunspell dictionaries installed in NixOS system path

pkgs/by-name/or/orca/package.nix

···
   python3,
   gtk3,
   gnome,
-  substituteAll,
+  replaceVars,
   at-spi2-atk,
   at-spi2-core,
   dbus,
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./fix-paths.patch;
+    (replaceVars ./fix-paths.patch {
       cat = "${coreutils}/bin/cat";
       lsof = "${lsof}/bin/lsof";
       pgrep = "${procps}/bin/pgrep";

pkgs/by-name/pa/patchPpdFilesHook/test.nix

···
 {
-  substituteAll,
+  replaceVars,
   diffutils,
   stdenv,
   patchPpdFilesHook,
 }:
 
 let
-  input = substituteAll {
-    src = ./test.ppd;
+  input = replaceVars ./test.ppd {
     keep = "cmp";
     patch = "cmp";
     pathkeep = "/bin/cmp";
     pathpatch = "/bin/cmp";
   };
 
-  output = substituteAll {
-    src = ./test.ppd;
+  output = replaceVars ./test.ppd {
     keep = "cmp";
     patch = "${diffutils}/bin/cmp";
     pathkeep = "/bin/cmp";

pkgs/by-name/pl/plymouth/package.nix

···
   stdenv,
   fetchFromGitLab,
   writeText,
-  substituteAll,
+  replaceVars,
   meson,
   pkg-config,
   ninja,
···
     # add support for loading plugins from /run to assist NixOS module
     ./add-runtime-plugin-path.patch
     # fix FHS hardcoded paths
-    (substituteAll {
-      src = ./fix-paths.patch;
+    (replaceVars ./fix-paths.patch {
       fcmatch = "${fontconfig}/bin/fc-match";
     })
   ];

pkgs/by-name/po/podman/package.nix

···
   makeWrapper,
   runtimeShell,
   symlinkJoin,
-  substituteAll,
+  replaceVars,
   extraPackages ? [ ],
   crun,
   runc,
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./hardcode-paths.patch;
+    (replaceVars ./hardcode-paths.patch {
       bin_path = helpersBin;
     })
 

pkgs/by-name/pr/pretix/plugins/passbook.nix

···
   lib,
   buildPythonPackage,
   fetchFromGitHub,
-  substituteAll,
+  replaceVars,
 
   # build-system
   pretix-plugin-build,
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./passbook-openssl.patch;
+    (replaceVars ./passbook-openssl.patch {
       openssl = lib.getExe openssl;
     })
   ];

pkgs/by-name/st/streamlink/package.nix

···
   lib,
   python3Packages,
   fetchPypi,
-  substituteAll,
+  replaceVars,
   ffmpeg,
 }:
 
···
   };
 
   patches = [
-    (substituteAll {
-      src = ./ffmpeg-path.patch;
+    (replaceVars ./ffmpeg-path.patch {
       ffmpeg = lib.getExe ffmpeg;
     })
   ];

pkgs/by-name/sw/sway-unwrapped/package.nix

···
-{ lib, stdenv, fetchFromGitHub, fetchpatch, substituteAll, swaybg
+{ lib, stdenv, fetchFromGitHub, fetchpatch, replaceVars, swaybg
 , meson, ninja, pkg-config, wayland-scanner, scdoc
 , libGL, wayland, libxkbcommon, pcre2, json_c, libevdev
 , pango, cairo, libinput, gdk-pixbuf, librsvg
···
   patches = [
     ./load-configuration-from-etc.patch
 
-    (substituteAll {
-      src = ./fix-paths.patch;
+    (replaceVars ./fix-paths.patch {
       inherit swaybg;
     })
 

pkgs/by-name/sw/swayfx-unwrapped/package.nix

···
   stdenv,
   systemd,
   meson,
-  substituteAll,
+  replaceVars,
   swaybg,
   ninja,
   pkg-config,
···
     [
       ./load-configuration-from-etc.patch
 
-      (substituteAll {
-        src = ./fix-paths.patch;
+      (replaceVars ./fix-paths.patch {
         inherit swaybg;
       })
     ]

pkgs/by-name/um/umockdev/package.nix

···
   ninja,
   pkg-config,
   python3,
-  substituteAll,
+  replaceVars,
   systemdMinimal,
   usbutils,
   vala,
···
     # Replace references to udevadm with an absolute paths, so programs using
     # umockdev will just work without having to provide it in their test environment
     # $PATH.
-    (substituteAll {
-      src = ./substitute-udevadm.patch;
+    (replaceVars ./substitute-udevadm.patch {
       udevadm = "${systemdMinimal}/bin/udevadm";
     })
   ];

pkgs/by-name/xs/xscreensaver/package.nix

···
   forceInstallAllHacks ? true,
   withSystemd ? lib.meta.availableOn stdenv.hostPlatform systemd,
   nixosTests,
-  substituteAll,
+  replaceVars,
   wrapperPrefix ? "/run/wrappers/bin",
 }:
 
···
   '';
 
   patches = [
-    (substituteAll {
-      src = ./xscreensaver-wrapper-prefix.patch;
+    (replaceVars ./xscreensaver-wrapper-prefix.patch {
       inherit wrapperPrefix;
     })
   ];