Merge remote-tracking branch 'origin/staging' into staging-next

maintainers/maintainer-list.nix

···
     githubId = 4296804;
     name = "Alex Franchuk";
   };
+  agbrooks = {
+    email = "[e-mail]";
+    github = "agbrooks";
+    githubId = 19290901;
+    name = "Andrew Brooks";
+  };
   aherrmann = {
     email = "[e-mail]";
     github = "aherrmann";

pkgs/applications/blockchains/openethereum/default.nix

···
 , darwin
 }:
 
-rustPlatform.buildRustPackage.override { stdenv = stdenv; } rec {
+rustPlatform.buildRustPackage rec {
   pname = "openethereum";
-  version = "3.2.5";
+  version = "3.2.6";
 
   src = fetchFromGitHub {
     owner = "openethereum";
     repo = "openethereum";
     rev = "v${version}";
-    sha256 = "1g48fkznvr9fs3j9zy2d9pcwnahmyghxg2b9bsn2mxpyczmfqrki";
+    sha256 = "0lxps3cyg8dzb9qr1kg91s9jc3mnm6hxybwcbhva38pcq4yc40xc";
   };
 
-  cargoSha256 = "02nlm5ariv4dr6b3rckzs7hw1xrl83yvhimrzb0g5l0j0sxh1nhc";
+  cargoSha256 = "08yrpls3szmw6vy2c4d6b1k907ga0809ylvyx0zb6f8mp8z7ahl2";
 
   nativeBuildInputs = [ cmake pkg-config ];
 

pkgs/applications/editors/poke/default.nix

···
   ] ++ lib.optional guiSupport makeWrapper;
 
   buildInputs = [ boehmgc readline ]
-  ++ lib.optional guiSupport tk
+  ++ lib.optionals guiSupport [ tk tcl.tclPackageHook tcllib ]
   ++ lib.optional miSupport json_c
   ++ lib.optional nbdSupport libnbd
   ++ lib.optional textStylingSupport gettext
···
 
   doCheck = !isCross;
   checkInputs = lib.optionals (!isCross) [ dejagnu ];
-
-  postFixup = lib.optionalString guiSupport ''
-    wrapProgram "$out/bin/poke-gui" \
-      --prefix TCLLIBPATH ' ' ${tcllib}/lib/tcllib${tcllib.version}
-  '';
 
   meta = with lib; {
     description = "Interactive, extensible editor for binary data";

pkgs/applications/graphics/ImageMagick/7.0.nix

···
 
 stdenv.mkDerivation rec {
   pname = "imagemagick";
-  version = "7.0.11-9";
+  version = "7.0.11-12";
 
   src = fetchFromGitHub {
     owner = "ImageMagick";
     repo = "ImageMagick";
     rev = version;
-    sha256 = "sha256-eL9zFrgkLb3pS8/UlQB5+p50UG8j3Q7TNDwcO/3BuXo=";
+    sha256 = "sha256-vTCfpHcja0z/aplcunUDlg/90EbfrR/xQ9bzdG0n2RY=";
   };
 
   outputs = [ "out" "dev" "doc" ]; # bin/ isn't really big

pkgs/applications/networking/cluster/k9s/default.nix

···
 
 buildGoModule rec {
   pname = "k9s";
-  version = "0.24.8";
+  version = "0.24.9";
 
   src = fetchFromGitHub {
     owner  = "derailed";
     repo   = "k9s";
     rev    = "v${version}";
-    sha256 = "sha256-6RGm2uiYvsdpWdhNwDTw4z1O6uNErkWTuyOiwKIvXOY=";
+    sha256 = "sha256-9/P6OaSZDJ98EQ9DM4Oib0T1sC1K3WxUXh4IQU3qXbs=";
   };
 
   buildFlagsArray = ''
···
       -X github.com/derailed/k9s/cmd.commit=${src.rev}
   '';
 
-  vendorSha256 = "sha256-lzxGTubm+qQes5QKaamfmSkXs4qquHHjIhts8YmKlYI=";
+  vendorSha256 = "sha256-hqmymxP4zK8GVqOxzB6vRfFyo+VIeI1suBu64/oEVig=";
 
   doCheck = false;
 

pkgs/applications/science/chemistry/jmol/default.nix

···
   };
 in
 stdenv.mkDerivation rec {
-  version = "14.31.38";
+  version = "14.31.39";
   pname = "jmol";
 
   src = let
     baseVersion = "${lib.versions.major version}.${lib.versions.minor version}";
   in fetchurl {
     url = "mirror://sourceforge/jmol/Jmol/Version%20${baseVersion}/Jmol%20${version}/Jmol-${version}-binary.tar.gz";
-    sha256 = "sha256-yXJ1KtTH3bi24GFiVXu8zzQkreDkqbCxgm7fVoSJepg=";
+    sha256 = "sha256-ss+QvBsmivqNdjXW45Sv9h/JXuZpryCGmRTsUgcDlRE=";
   };
 
   patchPhase = ''

pkgs/applications/version-management/fossil/default.nix

···
     sha256 = "sha256-uNDJIBlt2K4pFS+nRI5ROh+nxYiHG3heP7/Ae0KgX7k=";
   };
 
-  nativeBuildInputs = [ installShellFiles tcl ];
+  nativeBuildInputs = [ installShellFiles tcl tcllib ];
 
   buildInputs = [ zlib openssl readline sqlite which ed ]
     ++ lib.optional stdenv.isDarwin libiconv;
···
 
   configureFlags = [ "--disable-internal-sqlite" ]
     ++ lib.optional withJson "--json";
-
-  preCheck = ''
-    export TCLLIBPATH="${tcllib}/lib/tcllib${tcllib.version}"
-  '';
 
   preBuild = ''
     export USER=nonexistent-but-specified-user

pkgs/applications/version-management/git-and-tools/git/default.nix

···
 , curl, openssl, zlib, expat, perlPackages, python3, gettext, cpio
 , gnugrep, gnused, gawk, coreutils # needed at runtime by git-filter-branch etc
 , openssh, pcre2
-, asciidoctor, texinfo, xmlto, docbook2x, docbook_xsl, docbook_xsl_ns, docbook_xml_dtd_45
+, asciidoc, texinfo, xmlto, docbook2x, docbook_xsl, docbook_xml_dtd_45
 , libxslt, tcl, tk, makeWrapper, libiconv
 , svnSupport, subversionClient, perlLibs, smtpPerlLibs
 , perlSupport ? stdenv.buildPlatform == stdenv.hostPlatform
···
   '';
 
   nativeBuildInputs = [ gettext perlPackages.perl makeWrapper ]
-    ++ lib.optionals withManual [ asciidoctor texinfo xmlto docbook2x
-         docbook_xsl docbook_xsl_ns docbook_xml_dtd_45 libxslt ];
+    ++ lib.optionals withManual [ asciidoc texinfo xmlto docbook2x
+         docbook_xsl docbook_xml_dtd_45 libxslt ];
   buildInputs = [curl openssl zlib expat cpio libiconv]
     ++ lib.optionals perlSupport [ perlPackages.perl ]
     ++ lib.optionals guiSupport [tcl tk]
···
       }
 
       # Install git-subtree.
-      make -C contrib/subtree install ${lib.optionalString withManual "USE_ASCIIDOCTOR=1 install-doc"}
+      make -C contrib/subtree install ${lib.optionalString withManual "install-doc"}
       rm -rf contrib/subtree
 
       # Install contrib stuff.
···
       '')
 
    + lib.optionalString withManual ''# Install man pages
-       make -j $NIX_BUILD_CORES -l $NIX_BUILD_CORES USE_ASCIIDOCTOR=1 PERL_PATH="${buildPackages.perl}/bin/perl" cmd-list.made install install-html \
+       make -j $NIX_BUILD_CORES -l $NIX_BUILD_CORES PERL_PATH="${buildPackages.perl}/bin/perl" cmd-list.made install install-html \
          -C Documentation ''
 
    + (if guiSupport then ''

pkgs/applications/video/kodi-packages/inputstream-adaptive/default.nix

···
 buildKodiBinaryAddon rec {
   pname = "inputstream-adaptive";
   namespace = "inputstream.adaptive";
-  version = "2.6.14";
+  version = "2.6.15";
 
   src = fetchFromGitHub {
     owner = "xbmc";
     repo = "inputstream.adaptive";
     rev = "${version}-${rel}";
-    sha256 = "sha256-5hYB9J4syY+2XOTdg9h7xLk8MMEG88EETIgkUmz4KOU=";
+    sha256 = "sha256-Q4MaHIUM/ixAKyTklwuXCu7t/po+q5ZT+YpYf1n+PkA=";
   };
 
   extraNativeBuildInputs = [ gtest ];

pkgs/build-support/pkg-config-wrapper/add-flags.sh

···
 accumulateRoles
 
 for var in "${var_templates_list[@]}"; do
-    mangleVarList "$var" ${role_suffixes[@]+"${role_suffixes[@]}"}
+    mangleVarListGeneric ":" "$var" ${role_suffixes[@]+"${role_suffixes[@]}"}
 done
 
 export NIX_PKG_CONFIG_WRAPPER_FLAGS_SET_@suffixSalt@=1

pkgs/build-support/wrapper-common/utils.bash

···
     fi
 }
 
-mangleVarList() {
+mangleVarListGeneric() {
+    local sep="$1"
+    shift
     local var="$1"
     shift
     local -a role_suffixes=("$@")
···
     for suffix in "${role_suffixes[@]}"; do
         local inputVar="${var}${suffix}"
         if [ -v "$inputVar" ]; then
-            export ${outputVar}+="${!outputVar:+ }${!inputVar}"
+            export ${outputVar}+="${!outputVar:+$sep}${!inputVar}"
         fi
     done
+}
+
+mangleVarList() {
+    mangleVarListGeneric " " "$@"
 }
 
 mangleVarBool() {

pkgs/development/compilers/llvm/10/clang/default.nix

···
-{ lib, stdenv, llvm_meta, fetch, cmake, libxml2, libllvm, version, clang-tools-extra_src, python3
+{ lib, stdenv, llvm_meta, fetch, substituteAll, cmake, libxml2, libllvm, version, clang-tools-extra_src, python3
 , buildLlvmTools
 , fixDarwinDylibNames
 , enableManpages ? false
···
       # https://reviews.llvm.org/D51899
       ./compiler-rt-baremetal.patch
       ./gnu-install-dirs.patch
+      (substituteAll {
+        src = ../../clang-6-10-LLVMgold-path.patch;
+        libllvmLibdir = "${libllvm.lib}/lib";
+      })
     ];
 
     postPatch = ''
···
 
     outputs = [ "out" "lib" "dev" "python" ];
 
-    # Clang expects to find LLVMgold in its own prefix
     postInstall = ''
-      if [ -e ${libllvm.lib}/lib/LLVMgold.so ]; then
-        ln -sv ${libllvm.lib}/lib/LLVMgold.so $lib/lib
-      fi
-
       ln -sv $out/bin/clang $out/bin/cpp
 
       # Move libclang to 'lib' output

pkgs/development/compilers/llvm/11/clang/default.nix

···
-{ lib, stdenv, llvm_meta, fetch, fetchpatch, cmake, libxml2, libllvm, version, clang-tools-extra_src, python3
+{ lib, stdenv, llvm_meta, fetch, fetchpatch, substituteAll, cmake, libxml2, libllvm, version, clang-tools-extra_src, python3
 , buildLlvmTools
 , fixDarwinDylibNames
 , enableManpages ? false
···
         excludes = [ "docs/*" "test/*" ];
         sha256 = "0gxgmi0qbm89mq911dahallhi8m6wa9vpklklqmxafx4rplrr8ph";
       })
+      (substituteAll {
+        src = ../../clang-11-12-LLVMgold-path.patch;
+        libllvmLibdir = "${libllvm.lib}/lib";
+      })
     ];
 
     postPatch = ''
···
 
     outputs = [ "out" "lib" "dev" "python" ];
 
-    # Clang expects to find LLVMgold in its own prefix
     postInstall = ''
-      if [ -e ${libllvm.lib}/lib/LLVMgold.so ]; then
-        ln -sv ${libllvm.lib}/lib/LLVMgold.so $lib/lib
-      fi
-
       ln -sv $out/bin/clang $out/bin/cpp
 
       # Move libclang to 'lib' output

pkgs/development/compilers/llvm/12/clang/default.nix

···
-{ lib, stdenv, llvm_meta, fetch, cmake, libxml2, libllvm, version, clang-tools-extra_src, python3
+{ lib, stdenv, llvm_meta, fetch, substituteAll, cmake, libxml2, libllvm, version, clang-tools-extra_src, python3
 , buildLlvmTools
 , fixDarwinDylibNames
 , enableManpages ? false
···
       ./purity.patch
       # https://reviews.llvm.org/D51899
       ./gnu-install-dirs.patch
+      (substituteAll {
+        src = ../../clang-11-12-LLVMgold-path.patch;
+        libllvmLibdir = "${libllvm.lib}/lib";
+      })
     ];
 
     postPatch = ''
···
 
     outputs = [ "out" "lib" "dev" "python" ];
 
-    # Clang expects to find LLVMgold in its own prefix
     postInstall = ''
-      if [ -e ${libllvm.lib}/lib/LLVMgold.so ]; then
-        ln -sv ${libllvm.lib}/lib/LLVMgold.so $lib/lib
-      fi
-
       ln -sv $out/bin/clang $out/bin/cpp
 
       # Move libclang to 'lib' output

pkgs/development/compilers/llvm/5/clang/LLVMgold-path.patch

···
+diff --git a/lib/Driver/ToolChains/CommonArgs.cpp b/lib/Driver/ToolChains/CommonArgs.cpp
+index 00bd60bc24bb..17416b0bd3c0 100644
+--- a/lib/Driver/ToolChains/CommonArgs.cpp
++++ b/lib/Driver/ToolChains/CommonArgs.cpp
+@@ -376,8 +376,7 @@ void tools::AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
+   // as gold requires -plugin to come before any -plugin-opt that -Wl might
+   // forward.
+   CmdArgs.push_back("-plugin");
+-  std::string Plugin =
+-      ToolChain.getDriver().Dir + "/../lib" CLANG_LIBDIR_SUFFIX "/LLVMgold.so";
++  std::string Plugin = "@libllvmLibdir@" "/LLVMgold.so";
+   CmdArgs.push_back(Args.MakeArgString(Plugin));
+ 
+   // Try to pass driver level flags relevant to LTO code generation down to

pkgs/development/compilers/llvm/5/clang/default.nix

···
-{ lib, stdenv, llvm_meta, fetch, cmake, libxml2, libllvm, version, clang-tools-extra_src, python3
+{ lib, stdenv, llvm_meta, fetch, substituteAll, cmake, libxml2, libllvm, version, clang-tools-extra_src, python3
 , buildLlvmTools
 , fixDarwinDylibNames
 , enableManpages ? false
···
     patches = [
       ./purity.patch
       ./gnu-install-dirs.patch
+      (substituteAll {
+        src = ./LLVMgold-path.patch;
+        libllvmLibdir = "${libllvm.lib}/lib";
+      })
     ];
 
     postPatch = ''
···
 
     outputs = [ "out" "lib" "dev" "python" ];
 
-    # Clang expects to find LLVMgold in its own prefix
     postInstall = ''
-      if [ -e ${libllvm.lib}/lib/LLVMgold.so ]; then
-        ln -sv ${libllvm.lib}/lib/LLVMgold.so $lib/lib
-      fi
-
       ln -sv $out/bin/clang $out/bin/cpp
 
       # Move libclang to 'lib' output

pkgs/development/compilers/llvm/6/clang/default.nix

···
-{ lib, stdenv, llvm_meta, fetch, cmake, libxml2, libllvm, version, clang-tools-extra_src, python3
+{ lib, stdenv, llvm_meta, fetch, substituteAll, cmake, libxml2, libllvm, version, clang-tools-extra_src, python3
 , buildLlvmTools
 , fixDarwinDylibNames
 , enableManpages ? false
···
     patches = [
       ./purity.patch
       ./gnu-install-dirs.patch
+      (substituteAll {
+        src = ../../clang-6-10-LLVMgold-path.patch;
+        libllvmLibdir = "${libllvm.lib}/lib";
+      })
     ];
 
     postPatch = ''
···
 
     outputs = [ "out" "lib" "dev" "python" ];
 
-    # Clang expects to find LLVMgold in its own prefix
     postInstall = ''
-      if [ -e ${libllvm.lib}/lib/LLVMgold.so ]; then
-        ln -sv ${libllvm.lib}/lib/LLVMgold.so $lib/lib
-      fi
-
       ln -sv $out/bin/clang $out/bin/cpp
 
       # Move libclang to 'lib' output

pkgs/development/compilers/llvm/7/clang/default.nix

···
-{ lib, stdenv, llvm_meta, fetch, cmake, libxml2, libllvm, version, clang-tools-extra_src, python3
+{ lib, stdenv, llvm_meta, fetch, substituteAll, cmake, libxml2, libllvm, version, clang-tools-extra_src, python3
 , buildLlvmTools
 , fixDarwinDylibNames
 , enableManpages ? false
···
       # needed for our bootstrapping to not interfere with C.
       ./unwindlib.patch
       ./gnu-install-dirs.patch
+      (substituteAll {
+        src = ../../clang-6-10-LLVMgold-path.patch;
+        libllvmLibdir = "${libllvm.lib}/lib";
+      })
     ];
 
     postPatch = ''
···
 
     outputs = [ "out" "lib" "dev" "python" ];
 
-    # Clang expects to find LLVMgold in its own prefix
     postInstall = ''
-      if [ -e ${libllvm.lib}/lib/LLVMgold.so ]; then
-        ln -sv ${libllvm.lib}/lib/LLVMgold.so $lib/lib
-      fi
-
       ln -sv $out/bin/clang $out/bin/cpp
 
       # Move libclang to 'lib' output

pkgs/development/compilers/llvm/8/clang/default.nix

···
-{ lib, stdenv, llvm_meta, fetch, cmake, libxml2, libllvm, version, clang-tools-extra_src, python3
+{ lib, stdenv, llvm_meta, fetch, substituteAll, cmake, libxml2, libllvm, version, clang-tools-extra_src, python3
 , buildLlvmTools
 , fixDarwinDylibNames
 , enableManpages ? false
···
       # make clang -xhip use $PATH to find executables
       ./HIP-use-PATH-8.patch
       ./gnu-install-dirs.patch
+      (substituteAll {
+        src = ../../clang-6-10-LLVMgold-path.patch;
+        libllvmLibdir = "${libllvm.lib}/lib";
+      })
     ];
 
     postPatch = ''
···
 
     outputs = [ "out" "lib" "dev" "python" ];
 
-    # Clang expects to find LLVMgold in its own prefix
     postInstall = ''
-      if [ -e ${libllvm.lib}/lib/LLVMgold.so ]; then
-        ln -sv ${libllvm.lib}/lib/LLVMgold.so $lib/lib
-      fi
-
       ln -sv $out/bin/clang $out/bin/cpp
 
       # Move libclang to 'lib' output

pkgs/development/compilers/llvm/9/clang/default.nix

···
-{ lib, stdenv, llvm_meta, fetch, cmake, libxml2, libllvm, version, clang-tools-extra_src, python3
+{ lib, stdenv, llvm_meta, fetch, substituteAll, cmake, libxml2, libllvm, version, clang-tools-extra_src, python3
 , buildLlvmTools
 , fixDarwinDylibNames
 , enableManpages ? false
···
       # make clang -xhip use $PATH to find executables
       ./HIP-use-PATH-9.patch
       ./gnu-install-dirs.patch
+      (substituteAll {
+        src = ../../clang-6-10-LLVMgold-path.patch;
+        libllvmLibdir = "${libllvm.lib}/lib";
+      })
     ];
 
     postPatch = ''
···
 
     outputs = [ "out" "lib" "dev" "python" ];
 
-    # Clang expects to find LLVMgold in its own prefix
     postInstall = ''
-      if [ -e ${libllvm.lib}/lib/LLVMgold.so ]; then
-        ln -sv ${libllvm.lib}/lib/LLVMgold.so $lib/lib
-      fi
-
       ln -sv $out/bin/clang $out/bin/cpp
 
       # Move libclang to 'lib' output

pkgs/development/compilers/llvm/clang-11-12-LLVMgold-path.patch

···
+diff --git a/lib/Driver/ToolChains/CommonArgs.cpp b/lib/Driver/ToolChains/CommonArgs.cpp
+index 6b6e276b8ce7..7896542a1202 100644
+--- a/lib/Driver/ToolChains/CommonArgs.cpp
++++ b/lib/Driver/ToolChains/CommonArgs.cpp
+@@ -409,7 +409,7 @@ void tools::addLTOOptions(const ToolChain &ToolChain, const ArgList &Args,
+ 
+     SmallString<1024> Plugin;
+     llvm::sys::path::native(
+-        Twine(D.Dir) + "/../lib" CLANG_LIBDIR_SUFFIX "/LLVMgold" + Suffix,
++        Twine("@libllvmLibdir@" "/LLVMgold") + Suffix,
+         Plugin);
+     CmdArgs.push_back(Args.MakeArgString(Plugin));
+   }

pkgs/development/compilers/llvm/clang-6-10-LLVMgold-path.patch

···
+diff --git a/lib/Driver/ToolChains/CommonArgs.cpp b/lib/Driver/ToolChains/CommonArgs.cpp
+index 37ec73468570..b73e75aa6e59 100644
+--- a/lib/Driver/ToolChains/CommonArgs.cpp
++++ b/lib/Driver/ToolChains/CommonArgs.cpp
+@@ -370,8 +370,8 @@ void tools::AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
+ #endif
+ 
+   SmallString<1024> Plugin;
+-  llvm::sys::path::native(Twine(ToolChain.getDriver().Dir) +
+-                              "/../lib" CLANG_LIBDIR_SUFFIX "/LLVMgold" +
++  llvm::sys::path::native(Twine("@libllvmLibdir@"
++                                "/LLVMgold") +
+                               Suffix,
+                           Plugin);
+   CmdArgs.push_back(Args.MakeArgString(Plugin));

pkgs/development/compilers/rust/1_52.nix

···
 , CoreFoundation, Security
 , pkgsBuildTarget, pkgsBuildBuild, pkgsBuildHost
 , makeRustPlatform
-, llvmPackages_11, llvm_11
+, llvmPackages_11
+, llvmPackages_12, llvm_12
 } @ args:
 
 import ./default.nix {
   rustcVersion = "1.52.1";
   rustcSha256 = "sha256-Om8jom0Oj4erv78yxc19qgwLcdCYar78Vrml+/vQv5g=";
 
-  llvmSharedForBuild = pkgsBuildBuild.llvmPackages_11.libllvm.override { enableSharedLibraries = true; };
-  llvmSharedForHost = pkgsBuildHost.llvmPackages_11.libllvm.override { enableSharedLibraries = true; };
-  llvmSharedForTarget = pkgsBuildTarget.llvmPackages_11.libllvm.override { enableSharedLibraries = true; };
+  llvmSharedForBuild = pkgsBuildBuild.llvmPackages_12.libllvm.override { enableSharedLibraries = true; };
+  llvmSharedForHost = pkgsBuildHost.llvmPackages_12.libllvm.override { enableSharedLibraries = true; };
+  llvmSharedForTarget = pkgsBuildTarget.llvmPackages_12.libllvm.override { enableSharedLibraries = true; };
 
   llvmBootstrapForDarwin = llvmPackages_11;
 
   # For use at runtime
-  llvmShared = llvm_11.override { enableSharedLibraries = true; };
+  llvmShared = llvm_12.override { enableSharedLibraries = true; };
 
   # Note: the version MUST be one version prior to the version we're
   # building
···
   ];
 }
 
-(builtins.removeAttrs args [ "fetchpatch" "pkgsBuildHost" "llvmPackages_11" "llvm_11"])
+(builtins.removeAttrs args [ "fetchpatch" "pkgsBuildHost" "llvmPackages_11" "llvmPackages_12" "llvm_12"])

pkgs/development/interpreters/chibi/default.nix

···
 { lib, stdenv, fetchFromGitHub, makeWrapper }:
 let
-  version = "0.9.1";
+  version = "0.10";
   name = "chibi-scheme-${version}";
 in
 stdenv.mkDerivation {
···
     owner = "ashinn";
     repo = "chibi-scheme";
     rev = version;
-    sha256 = "0nd63i924ifh39cba1hd4sbi6vh1cb73v97nrn4bf8rrjh3k8pdi";
+    sha256 = "sha256-7vDxcnXhq1wJSLFHGxtwh+H+KWxh6B0JXSMPzSmQFXo=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/development/interpreters/python/hooks/pip-build-hook.sh

···
 
     mkdir -p dist
     echo "Creating a wheel..."
-    @pythonInterpreter@ -m pip wheel --no-index --no-deps --no-clean --no-build-isolation --wheel-dir dist .
+    @pythonInterpreter@ -m pip wheel --verbose --no-index --no-deps --no-clean --no-build-isolation --wheel-dir dist .
     echo "Finished creating a wheel..."
 
     runHook postBuild

pkgs/development/interpreters/ruby/default.nix

···
   opString = lib.optionalString;
   patchSet = import ./rvm-patchsets.nix { inherit fetchFromGitHub; };
   config = import ./config.nix { inherit fetchFromSavannah; };
-  rubygems = import ./rubygems { inherit stdenv lib fetchurl; };
+  rubygems = import ./rubygems { inherit stdenv lib fetchurl fetchpatch; };
 
   # Contains the ruby version heuristics
   rubyVersion = import ./ruby-version.nix { inherit lib; };

pkgs/development/interpreters/ruby/rubygems/default.nix

···
-{ stdenv, lib, fetchurl }:
+{ stdenv, lib, fetchurl, fetchpatch }:
 
 stdenv.mkDerivation rec {
   name = "rubygems";
···
     ./0001-add-post-extract-hook.patch
     ./0002-binaries-with-env-shebang.patch
     ./0003-gem-install-default-to-user.patch
+    # Ensure tmp directory are not left behind
+    # https://github.com/rubygems/rubygems/pull/4610
+    (fetchpatch {
+      url = "https://github.com/rubygems/rubygems/commit/2c2ffde6e4a9f7f571d38af687034fb8507a833d.patch";
+      sha256 = "sha256-bs2dXALKiJvMgk7lKjMx0NzGqlEqDYBBO35UrzNifms=";
+    })
   ];
 
   installPhase = ''

pkgs/development/interpreters/tcl/generic.nix

···
-{ lib, stdenv
+{ lib, stdenv, callPackage, makeSetupHook, makeWrapper
 
 # Version specific stuff
 , release, version, src
 , ...
 }:
 
-stdenv.mkDerivation {
-  pname = "tcl";
-  inherit version;
+let
+  baseInterp =
+    stdenv.mkDerivation {
+      pname = "tcl";
+      inherit version src;
 
-  inherit src;
+      outputs = [ "out" "man" ];
 
-  outputs = [ "out" "man" ];
+      setOutputFlags = false;
 
-  setOutputFlags = false;
+      preConfigure = ''
+        cd unix
+      '';
 
-  preConfigure = ''
-    cd unix
-  '';
+      configureFlags = [
+        "--enable-threads"
+        # Note: using $out instead of $man to prevent a runtime dependency on $man.
+        "--mandir=${placeholder "out"}/share/man"
+        "--enable-man-symlinks"
+        # Don't install tzdata because NixOS already has a more up-to-date copy.
+        "--with-tzdata=no"
+        "tcl_cv_strtod_unbroken=ok"
+      ] ++ lib.optional stdenv.is64bit "--enable-64bit";
 
-  configureFlags = [
-    "--enable-threads"
-    # Note: using $out instead of $man to prevent a runtime dependency on $man.
-    "--mandir=${placeholder "out"}/share/man"
-    "--enable-man-symlinks"
-    # Don't install tzdata because NixOS already has a more up-to-date copy.
-    "--with-tzdata=no"
-    "tcl_cv_strtod_unbroken=ok"
-  ] ++ lib.optional stdenv.is64bit "--enable-64bit";
+      enableParallelBuilding = true;
 
-  enableParallelBuilding = true;
+      postInstall = let
+        dllExtension = stdenv.hostPlatform.extensions.sharedLibrary;
+      in ''
+        make install-private-headers
+        ln -s $out/bin/tclsh${release} $out/bin/tclsh
+        ln -s $out/lib/libtcl${release}${dllExtension} $out/lib/libtcl${dllExtension}
+      '';
 
-  postInstall = let
-    dllExtension = stdenv.hostPlatform.extensions.sharedLibrary;
-  in ''
-    make install-private-headers
-    ln -s $out/bin/tclsh${release} $out/bin/tclsh
-    ln -s $out/lib/libtcl${release}${dllExtension} $out/lib/libtcl${dllExtension}
-  '';
+      meta = with lib; {
+        description = "The Tcl scripting language";
+        homepage = "https://www.tcl.tk/";
+        license = licenses.tcltk;
+        platforms = platforms.all;
+        maintainers = with maintainers; [ agbrooks ];
+      };
 
-  meta = with lib; {
-    description = "The Tcl scripting language";
-    homepage = "https://www.tcl.tk/";
-    license = licenses.tcltk;
-    platforms = platforms.all;
-    maintainers = with maintainers; [ vrthra ];
-  };
+      passthru = rec {
+        inherit release version;
+        libPrefix = "tcl${release}";
+        libdir = "lib/${libPrefix}";
+        tclPackageHook = callPackage ({}: makeSetupHook {
+          name = "tcl-package-hook";
+          deps = [ makeWrapper ];
+        } ./tcl-package-hook.sh) {};
+      };
+    };
+
+  mkTclDerivation = callPackage ./mk-tcl-derivation.nix { tcl = baseInterp; };
 
-  passthru = rec {
-    inherit release version;
-    libPrefix = "tcl${release}";
-    libdir = "lib/${libPrefix}";
-  };
-}
+in baseInterp.overrideAttrs (self: {
+     passthru = self.passthru // {
+       inherit mkTclDerivation;
+     };
+})

pkgs/development/interpreters/tcl/mk-tcl-derivation.nix

···
+# Generic builder for tcl packages/applications, generally based on mk-python-derivation.nix
+{ tcl
+, lib
+, makeWrapper
+, runCommand
+, writeScript
+}:
+
+{ buildInputs ? []
+, nativeBuildInputs ? []
+, propagatedBuildInputs ? []
+, checkInputs ? []
+
+# true if we should skip the configuration phase altogether
+, dontConfigure ? false
+
+# Extra flags passed to configure step
+, configureFlags ? []
+
+# Whether or not we should add common Tcl-related configure flags
+, addTclConfigureFlags ? true
+
+, meta ? {}
+, passthru ? {}
+, doCheck ? true
+, ... } @ attrs:
+
+let
+  inherit (tcl) stdenv;
+  inherit (lib) getBin optionalAttrs optionals;
+
+  defaultTclPkgConfigureFlags = [
+    "--with-tcl=${tcl}/lib"
+    "--with-tclinclude=${tcl}/include"
+    "--exec-prefix=\${out}"
+  ];
+
+  self = (stdenv.mkDerivation ((builtins.removeAttrs attrs [
+    "addTclConfigureFlags" "checkPhase" "checkInputs" "doCheck"
+  ]) // {
+
+    buildInputs = buildInputs ++ [ makeWrapper tcl.tclPackageHook ];
+    nativeBuildInputs = nativeBuildInputs ++ [ tcl ];
+    propagatedBuildInputs = propagatedBuildInputs ++ [ tcl ];
+
+    TCLSH = "${getBin tcl}/bin/tclsh";
+
+    # Run tests after install, at which point we've done all TCLLIBPATH setup
+    doCheck = false;
+    doInstallCheck = attrs.doCheck or ((attrs ? doInstallCheck) && attrs.doInstallCheck);
+    installCheckInputs = checkInputs ++ (optionals (attrs ? installCheckInputs) attrs.installCheckInputs);
+
+    # Add typical values expected by TEA for configureFlags
+    configureFlags =
+      if (!dontConfigure && addTclConfigureFlags)
+        then (configureFlags ++ defaultTclPkgConfigureFlags)
+        else configureFlags;
+
+    meta = {
+      platforms = tcl.meta.platforms;
+    } // meta;
+
+
+  } // optionalAttrs (attrs?checkPhase) {
+    installCheckPhase = attrs.checkPhase;
+  }
+  ));
+
+in lib.extendDerivation true passthru self

pkgs/development/interpreters/tcl/tcl-package-hook.sh

···
+# This hook ensures that we do the following in post-fixup:
+# * wrap any installed executables with a wrapper that configures TCLLIBPATH
+# * write a setup hook that extends the TCLLIBPATH of any anti-dependencies
+
+# Add a directory to TCLLIBPATH, provided that it exists
+_addToTclLibPath() {
+    local tclPkg="$1"
+    if [[ -z "$tclPkg" ]]; then
+        return
+    fi
+
+    if [[ ! -d "$tclPkg" ]]; then
+        >&2 echo "can't add $tclPkg to TCLLIBPATH; that directory doesn't exist"
+        exit 1
+    fi
+
+    if [[ "$tclPkg" == *" "* ]]; then
+        tclPkg="{$tclPkg}"
+    fi
+
+    if [[ -z "${TCLLIBPATH-}" ]]; then
+        export TCLLIBPATH="$tclPkg"
+    else
+        if [[ "$TCLLIBPATH" != *"$tclPkg "* && "$TCLLIBPATH" != *"$tclPkg" ]]; then
+            export TCLLIBPATH="${TCLLIBPATH} $tclPkg"
+        fi
+    fi
+}
+
+# Locate any directory containing an installed pkgIndex file
+findInstalledTclPkgs() {
+    local -r newLibDir="${!outputLib}/lib"
+    if [[ ! -d "$newLibDir" ]]; then
+        >&2 echo "Assuming no loadable tcl packages installed ($newLibDir does not exist)"
+        return
+    fi
+    echo "$(find "$newLibDir" -name pkgIndex.tcl -exec dirname {} \;)"
+}
+
+# Wrap any freshly-installed binaries and set up their TCLLIBPATH
+wrapTclBins() {
+    if [[ -z "${TCLLIBPATH-}" ]]; then
+        echo "skipping automatic Tcl binary wrapping (nothing to do)"
+        return
+    fi
+
+    local -r tclBinsDir="${!outputBin}/bin"
+    if [[ ! -d "$tclBinsDir" ]]; then
+        echo "No outputBin found, not using any TCLLIBPATH wrapper"
+        return
+    fi
+
+    find "$tclBinsDir" -type f -executable -print |
+        while read -r someBin; do
+            echo "Adding TCLLIBPATH wrapper for $someBin"
+            wrapProgram "$someBin" --prefix TCLLIBPATH ' ' "$TCLLIBPATH"
+        done
+}
+
+# Generate hook to adjust TCLLIBPATH in anti-dependencies
+writeTclLibPathHook() {
+    local -r hookPath="${!outputLib}/nix-support/setup-hook"
+    mkdir -p "$(dirname "$hookPath")"
+
+    typeset -f _addToTclLibPath >> "$hookPath"
+    local -r tclPkgs=$(findInstalledTclPkgs)
+    while IFS= read -r tclPkg; do
+        echo "_addToTclLibPath \"$tclPkg\"" >> "$hookPath"
+        _addToTclLibPath "$tclPkg" true
+    done <<< "$tclPkgs"
+}
+
+postFixupHooks+=(writeTclLibPathHook)
+postFixupHooks+=(wrapTclBins)

pkgs/development/interpreters/tclreadline/default.nix

···
 , tk
 }:
 
-stdenv.mkDerivation rec {
+tcl.mkTclDerivation rec {
   pname = "tclreadline";
   version = "2.3.8";
 
···
   ];
   buildInputs = [
     readline
-    tcl
     tk
   ];
 
···
   configureFlags = [
     "--enable-tclshrl"
     "--enable-wishrl"
-    "--with-tcl=${tcl}/lib"
     "--with-tk=${tk}/lib"
     "--with-readline-includes=${readline.dev}/include/readline"
     "--with-libtool=${libtool}"

pkgs/development/libraries/atk/default.nix

···
 { lib, stdenv, fetchurl, meson, ninja, gettext, pkg-config, glib
 , fixDarwinDylibNames, gobject-introspection, gnome
+, withIntrospection ? stdenv.buildPlatform == stdenv.hostPlatform
 }:
 
 let
···
 
   outputs = [ "out" "dev" ];
 
-  nativeBuildInputs = [ meson ninja pkg-config gettext gobject-introspection glib ]
-    ++ lib.optional stdenv.hostPlatform.isDarwin fixDarwinDylibNames;
+  nativeBuildInputs = [ meson ninja pkg-config gettext glib ]
+    ++ lib.optional stdenv.hostPlatform.isDarwin fixDarwinDylibNames
+    ++ lib.optional withIntrospection gobject-introspection;
 
   propagatedBuildInputs = [
     # Required by atk.pc
···
     # meson builds an incorrect .pc file
     # glib should be Requires not Requires.private
     ./fix_pc.patch
+  ];
+
+  mesonFlags = [
+    "-Dintrospection=${lib.boolToString withIntrospection}"
   ];
 
   doCheck = true;

pkgs/development/libraries/bwidget/default.nix

···
-{ lib, stdenv, fetchurl, tcl }:
+{ lib, fetchurl, tcl, tk }:
 
-stdenv.mkDerivation rec {
+tcl.mkTclDerivation rec {
   pname = "bwidget";
   version = "1.9.14";
 
···
   };
 
   dontBuild = true;
+  propagatedBuildInputs = [ tk ];
 
   installPhase = ''
-    mkdir -p "$out/lib/${passthru.libPrefix}"
-    cp -R *.tcl lang images "$out/lib/${passthru.libPrefix}"
+    mkdir -p "$out/lib/bwidget${version}"
+    cp -R *.tcl lang images "$out/lib/bwidget${version}"
   '';
 
-  passthru = {
-    libPrefix = "bwidget${version}";
-  };
-
-  buildInputs = [ tcl ];
-
   meta = {
     homepage = "https://sourceforge.net/projects/tcllib";
     description = "High-level widget set for Tcl/Tk";
+    maintainers = with lib.maintainers; [ agbrooks ];
     license = lib.licenses.tcltk;
     platforms = lib.platforms.linux;
   };

pkgs/development/libraries/dav1d/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "dav1d";
-  version = "0.8.2";
+  version = "0.9.0";
 
   src = fetchFromGitLab {
     domain = "code.videolan.org";
     owner = "videolan";
     repo = pname;
     rev = version;
-    sha256 = "0plmnxpz66yv3nqv1kgbyyfnwfqi9dqs0zbsdj488i6464a1m6si";
+    sha256 = "0ki3wlyaqr80gl1srbbd18dd5bs1sl9icxym8ar62abpvgzxl5yk";
   };
 
   nativeBuildInputs = [ meson ninja nasm pkg-config ];

pkgs/development/libraries/dbus-glib/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "dbus-glib-0.110";
+  name = "dbus-glib-0.112";
 
   src = fetchurl {
     url = "${meta.homepage}/releases/dbus-glib/${name}.tar.gz";
-    sha256 = "09g8swvc95bk1z6j8sw463p2v0dqmgm2zjfndf7i8sbcyq67dr3w";
+    sha256 = "sha256-fVUNzN/NKG4ziVUBgp7Zce62XGFOc6rbSgiu73GbFDo=";
   };
 
   outputs = [ "out" "dev" "devdoc" ];
···
 
   meta = {
     homepage = "https://dbus.freedesktop.org";
-    license = with lib.licenses; [ afl21 gpl2 ];
+    license = with lib.licenses; [ afl21 gpl2Plus ];
     description = "Obsolete glib bindings for D-Bus lightweight IPC mechanism";
     maintainers = [ ];
     platforms = lib.platforms.unix;

pkgs/development/libraries/incrtcl/default.nix

···
 { lib, stdenv, fetchurl, writeText, tcl }:
 
-stdenv.mkDerivation rec {
+tcl.mkTclDerivation rec {
   pname = "incrtcl";
   version = "4.2.0";
 
···
     sha256 = "0w28v0zaraxcq1s9pa6cihqqwqvvwfgz275lks7w4gl7hxjxmasw";
   };
 
-  buildInputs = [ tcl ];
-  configureFlags = [ "--with-tcl=${tcl}/lib" ];
   enableParallelBuilding = true;
 
   patchPhase = ''
     substituteInPlace configure --replace "\''${TCL_SRC_DIR}/generic" "${tcl}/include"
-  '';
-
-  preConfigure = ''
-    configureFlags="--exec_prefix=$prefix $configureFlags"
   '';
 
   postInstall = ''

pkgs/development/libraries/itktcl/default.nix

···
 { lib, stdenv, fetchurl, tcl, tk, incrtcl }:
 
-stdenv.mkDerivation rec {
+tcl.mkTclDerivation rec {
   pname = "itk-tcl";
   version = "4.1.0";
 
···
     sha256 = "1iy964jfgsfnc1agk1w6bbm44x18ily8d4wmr7cc9z9f4acn2r6s";
   };
 
-  buildInputs = [ tcl tk incrtcl ];
+  buildInputs = [ tk incrtcl ];
   enableParallelBuilding = true;
 
   configureFlags = [
-    "--with-tcl=${tcl}/lib"
     "--with-tk=${tk}/lib"
     "--with-itcl=${incrtcl}/lib"
     "--with-tkinclude=${tk.dev}/include"

pkgs/development/libraries/libdrm/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "libdrm";
-  version = "2.4.105";
+  version = "2.4.106";
 
   src = fetchurl {
     url = "https://dri.freedesktop.org/${pname}/${pname}-${version}.tar.xz";
-    sha256 = "0iiamypwdfiz250ki120nh598r48yyacmnndb4mkximdgi5h478x";
+    sha256 = "1m3vwpabjg3az84vmyxi96jyd7rrqm6qkhk1gq41w5wv89aarn4j";
   };
 
   outputs = [ "out" "dev" "bin" ];

pkgs/development/libraries/libgcrypt/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "libgcrypt";
-  version = "1.9.2";
+  version = "1.9.3";
 
   src = fetchurl {
     url = "mirror://gnupg/libgcrypt/${pname}-${version}.tar.bz2";
-    sha256 = "sha256-ssENCRUTsnHkcXcnRgex/7o9lbGIu/qHl/lIrskFPFo=";
+    sha256 = "sha256-l+vk+U4vfjW3UhlM4VoPPGYyTg/2ryZlm7+1/y7DKP0=";
   };
 
   outputs = [ "out" "dev" "info" ];
···
 
   meta = with lib; {
     homepage = "https://www.gnu.org/software/libgcrypt/";
+    changelog = "https://git.gnupg.org/cgi-bin/gitweb.cgi?p=libgcrypt.git;a=blob;f=NEWS;hb=refs/tags/${pname}-${version}";
     description = "General-purpose cryptographic library";
     license = licenses.lgpl2Plus;
     platforms = platforms.all;

pkgs/development/libraries/libjpeg-turbo/default.nix

···
 stdenv.mkDerivation rec {
 
   pname = "libjpeg-turbo";
-  version = "2.0.6";
+  version = "2.1.0";
 
   src = fetchFromGitHub {
     owner = "libjpeg-turbo";
     repo = "libjpeg-turbo";
     rev = version;
-    sha256 = "0njdxfmyk8smj8bbd6fs3lxjaq3lybivwgg16gpnbiyl984dpi9b";
+    sha256 = "sha256-Ma3Q/zMJPjsQmoaYJtVbHJOx65AfGLWJYi2iRFm3l5s=";
   };
 
   # This is needed by freeimage

pkgs/development/libraries/libksba/default.nix

···
 { buildPackages, lib, stdenv, fetchurl, gettext, libgpgerror }:
 
 stdenv.mkDerivation rec {
-  name = "libksba-1.5.0";
+  name = "libksba-1.5.1";
 
   src = fetchurl {
     url = "mirror://gnupg/libksba/${name}.tar.bz2";
-    sha256 = "1fm0mf3wq9fmyi1rmc1vk2fafn6liiw2mgxml3g7ybbb44lz2jmf";
+    sha256 = "sha256-sPTGXk5EfZojSfa4wOd6KL6VMeRUi6AsVF0fRtx7+SE=";
   };
 
   outputs = [ "out" "dev" "info" ];

pkgs/development/libraries/libndctl/default.nix

···
 { lib, stdenv, fetchFromGitHub, autoreconfHook
-, asciidoctor, pkg-config, xmlto, docbook_xsl, docbook_xml_dtd_45, libxslt
+, asciidoc, pkg-config, xmlto, docbook_xsl, docbook_xml_dtd_45, libxslt
 , json_c, kmod, which, util-linux, udev, keyutils
 }:
 
···
   outputs = [ "out" "lib" "man" "dev" ];
 
   nativeBuildInputs =
-    [ autoreconfHook asciidoctor pkg-config xmlto docbook_xml_dtd_45 docbook_xsl libxslt
+    [ autoreconfHook asciidoc pkg-config xmlto docbook_xml_dtd_45 docbook_xsl libxslt
       which
     ];
 
···
   configureFlags =
     [ "--without-bash"
       "--without-systemd"
+      "--disable-asciidoctor" # depends on ruby 2.7, use asciidoc instead
     ];
 
   patchPhase = ''

pkgs/development/libraries/libqmi/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "libqmi";
-  version = "1.28.2";
+  version = "1.28.4";
 
   outputs = [ "out" "dev" "devdoc" ];
 
   src = fetchurl {
     url = "https://www.freedesktop.org/software/libqmi/${pname}-${version}.tar.xz";
-    sha256 = "jIw+5xmHTSUpvOmzWwKP5DWzbwA5eaNg060JOESdt4M=";
+    sha256 = "sha256-OxTNKrUiGnrbs5/tFu9pdTjqHHkwiCGtLRm1BeHarqA=";
   };
 
   nativeBuildInputs = [

pkgs/development/libraries/libsass/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "libsass";
-  version = "3.6.4";
+  version = "3.6.5";
 
   src = fetchFromGitHub {
     owner = "sass";
     repo = pname;
     rev = version;
-    sha256 = "074kvacdan85h4qrvsk97575ys9xgkc044gplz3m6vn4a8pcl2rn";
+    sha256 = "1cxj6r85d5f3qxdwzxrmkx8z875hig4cr8zsi30w6vj23cyds3l2";
     # Remove unicode file names which leads to different checksums on HFS+
     # vs. other filesystems because of unicode normalisation.
     extraPostFetch = ''

pkgs/development/libraries/libwacom/default.nix

···
-{ lib, stdenv, fetchFromGitHub, meson, ninja, glib, pkg-config, udev, libgudev, doxygen }:
+{ lib, stdenv, fetchFromGitHub, meson, ninja, glib, pkg-config, udev, libgudev, doxygen, python3 }:
 
 stdenv.mkDerivation rec {
   pname = "libwacom";
-  version = "1.9";
+  version = "1.10";
 
   outputs = [ "out" "dev" ];
 
···
     owner = "linuxwacom";
     repo = "libwacom";
     rev = "libwacom-${version}";
-    sha256 = "sha256-o1xCSrWKPzz1GePEVB1jgx2cGzRtw0I6c4wful08Vx4=";
+    sha256 = "sha256-Q7b54AMAxdIzN7TUuhIdlrXaVtj2szV4n3y9bAE0LsU=";
   };
 
-  nativeBuildInputs = [ pkg-config meson ninja doxygen ];
+  nativeBuildInputs = [ pkg-config meson ninja doxygen python3 ];
 
   mesonFlags = [ "-Dtests=disabled" ];
 

pkgs/development/libraries/libxml2/default.nix

···
-{ stdenv, lib, fetchurl
+{ stdenv, lib, fetchurl, fetchpatch
 , zlib, xz, libintl, python, gettext, ncurses, findXMLCatalogs
 , pythonSupport ? enableShared && stdenv.buildPlatform == stdenv.hostPlatform
 , icuSupport ? false, icu ? null
···
     #   https://github.com/NixOS/nixpkgs/pull/63174
     #   https://github.com/NixOS/nixpkgs/pull/72342
     ./utf8-xmlErrorFuncHandler.patch
+
+    # Work around lxml API misuse.
+    # https://gitlab.gnome.org/GNOME/libxml2/issues/255
+    (fetchpatch {
+      url = "https://gitlab.gnome.org/GNOME/libxml2/commit/85b1792e37b131e7a51af98a37f92472e8de5f3f.patch";
+      sha256 = "epqlNs2S0Zczox3KyCB6R2aJKh87lXydlZ0x6tLHweE=";
+    })
   ];
 
   outputs = [ "bin" "dev" "out" "man" "doc" ]

pkgs/development/libraries/mesa/default.nix

···
 , llvmPackages, libffi, libomxil-bellagio, libva-minimal
 , libelf, libvdpau
 , libglvnd
-, enableRadv ? true
 , galliumDrivers ? ["auto"]
 , driDrivers ? ["auto"]
 , vulkanDrivers ? ["auto"]
···
 let
   # Release calendar: https://www.mesa3d.org/release-calendar.html
   # Release frequency: https://www.mesa3d.org/releasing.html#schedule
-  version = "21.0.1";
+  version = "21.0.3";
   branch  = versions.major version;
 
 self = stdenv.mkDerivation {
···
       "ftp://ftp.freedesktop.org/pub/mesa/${version}/mesa-${version}.tar.xz"
       "ftp://ftp.freedesktop.org/pub/mesa/older-versions/${branch}.x/${version}/mesa-${version}.tar.xz"
     ];
-    sha256 = "1fqj2xhhd1ary0pfg31jq6fqcnd6qgyrw1445nmz554k8n2ck7rp";
+    sha256 = "0awiyvicvcn3b18x0vx5ik3ly0k3k51ivz2ljj8pnx6ms95nyp2n";
   };
 
   prePatch = "patchShebangs .";

pkgs/development/libraries/science/math/openblas/default.nix

···
-{ lib, stdenv, fetchFromGitHub, fetchpatch, perl, which
+{ lib, stdenv, fetchFromGitHub, perl, which
 # Most packages depending on openblas expect integer width to match
 # pointer width, but some expect to use 32-bit integers always
 # (for compatibility with reference BLAS).
···
 in
 stdenv.mkDerivation rec {
   pname = "openblas";
-  version = "0.3.13";
+  version = "0.3.15";
 
   outputs = [ "out" "dev" ];
 
···
     owner = "xianyi";
     repo = "OpenBLAS";
     rev = "v${version}";
-    sha256 = "14jxh0v3jfbw4mfjx4mcz4dd51lyq7pqvh9k8dg94539ypzjr2lj";
+    sha256 = "1qjr02cqncv20abdp1yzr55n7smhx6h9chqvb0xbp18byynvj87w";
   };
-
-  # apply https://github.com/xianyi/OpenBLAS/pull/3060 to fix a crash on arm
-  # remove this when updating to 0.3.14 or newer
-  patches = [
-    (fetchpatch {
-      name = "label-get_cpu_ftr-as-volatile.patch";
-      url = "https://github.com/xianyi/OpenBLAS/commit/6fe0f1fab9d6a7f46d71d37ebb210fbf56924fbc.diff";
-      sha256 = "06gwh73k4sas1ap2fi3jvpifbjkys2vhmnbj4mzrsvj279ljsfdk";
-    })
-  ];
 
   inherit blas64;
 

pkgs/development/libraries/tcllib/default.nix

···
-{ lib, stdenv, fetchurl, tcl }:
+{ lib, fetchurl, tcl }:
 
-stdenv.mkDerivation rec {
+tcl.mkTclDerivation rec {
   pname = "tcllib";
   version = "1.20";
 
···
     url = "mirror://sourceforge/tcllib/tcllib-${version}.tar.gz";
     sha256 = "0wax281h6ksz974a5qpfgf9y34lmlpd8i87lkm1w94ybbd3rgc73";
   };
-
-  passthru = {
-    libPrefix = "tcllib${version}";
-  };
-
-  buildInputs = [ tcl ];
 
   meta = {
     homepage = "https://sourceforge.net/projects/tcllib/";

pkgs/development/libraries/tcltls/default.nix

···
-{ lib, stdenv, fetchurl, tcl, openssl }:
+{ lib, fetchurl, tcl, openssl }:
 
-stdenv.mkDerivation rec {
+tcl.mkTclDerivation rec {
   pname = "tcltls";
-  version = "1.6.7";
+  version = "1.7.21";
 
   src = fetchurl {
-    url = "mirror://sourceforge/tls/tls${version}-src.tar.gz";
-    sha256 = "1f53sfcnrridjl5ayrq1xrqkahs8khf8c3d0m2brndbhahzdw6ai";
+    url = "https://core.tcl-lang.org/tcltls/uv/tcltls-${version}.tar.gz";
+    sha256 = "0xf1rfsnn4k9j1bd2a1p8ir0xr4a3phgr9lcgbazh4084l2y8sl0";
   };
 
-  buildInputs = [ tcl openssl ];
+  buildInputs = [ openssl ];
 
   configureFlags = [
-    "--with-tcl=${tcl}/lib"
-    "--with-tclinclude=${tcl}/include"
     "--with-ssl-dir=${openssl.dev}"
   ];
 
-  preConfigure = ''
-    configureFlags="--exec_prefix=$prefix $configureFlags"
-  '';
-
-  passthru = {
-    libPrefix = "tls${version}";
-  };
-
   meta = {
-    homepage = "http://tls.sourceforge.net/";
+    homepage = "https://core.tcl-lang.org/tcltls/index";
     description = "An OpenSSL / RSA-bsafe Tcl extension";
+    maintainers = [ lib.maintainers.agbrooks ];
     license = lib.licenses.tcltk;
     platforms = lib.platforms.unix;
   };

pkgs/development/libraries/tclx/default.nix

···
-{ lib, stdenv, fetchurl, tcl }:
+{ lib, fetchurl, tcl }:
 
-stdenv.mkDerivation rec {
+tcl.mkTclDerivation rec {
   name = "tclx-${version}.${patch}";
   version = "8.4";
   patch = "1";
···
     sha256 = "1v2qwzzidz0is58fd1p7wfdbscxm3ip2wlbqkj5jdhf6drh1zd59";
   };
 
-  passthru = {
-    libPrefix = ""; # Using tclx${version} did not work
-  };
-
-  buildInputs = [ tcl ];
-
-  configureFlags = [ "--with-tcl=${tcl}/lib" "--exec-prefix=\${prefix}" ];
+  # required in order for tclx to properly detect tclx.tcl at runtime
+  postInstall = ''
+    ln -s $prefix/lib/tclx${version} $prefix/lib/tclx${version}/tclx${version}
+  '';
 
   meta = {
     homepage = "http://tclx.sourceforge.net/";

pkgs/development/libraries/tix/default.nix

···
 { lib, stdenv, fetchurl, tcl, tk, fetchpatch } :
 
-stdenv.mkDerivation {
+tcl.mkTclDerivation {
   version = "8.4.3";
   pname = "tix";
   src = fetchurl {
···
     sha256 = "1jaz0l22xj7x1k4rb9ia6i1psnbwk4pblgq4gfvya7gg7fbb7r36";
     })
   ;
-  buildInputs = [ tcl tk ];
+  buildInputs = [ tk ];
   # the configure script expects to find the location of the sources of
   # tcl and tk in {tcl,tk}Config.sh
   # In fact, it only needs some private headers. We copy them in
···
       ln -s $i private_headers/generic;
     done;
     '';
+  addTclConfigureFlags = false;
   configureFlags = [
-    "--with-tclinclude=${tcl}/include"
     "--with-tclconfig=."
     "--with-tkinclude=${tk.dev}/include"
     "--with-tkconfig=."
···
     ];
   };
 }
-

pkgs/development/libraries/tk/generic.nix

···
 , enableAqua ? stdenv.isDarwin, darwin
 , ... }:
 
-stdenv.mkDerivation {
+tcl.mkTclDerivation {
   name = "tk-${tcl.version}";
 
   inherit src patches;
···
 
   configureFlags = [
     "--enable-threads"
-    "--with-tcl=${tcl}/lib"
   ] ++ lib.optional stdenv.is64bit "--enable-64bit"
     ++ lib.optional enableAqua "--enable-aqua";
 
   nativeBuildInputs = [ pkg-config ];
   buildInputs = lib.optional enableAqua (with darwin.apple_sdk.frameworks; [ Cocoa ]);
 
-  propagatedBuildInputs = [ tcl libXft ];
+  propagatedBuildInputs = [ libXft ];
 
   doCheck = false; # fails. can't find itself
 

pkgs/development/libraries/wayland/protocols.nix

···
-{ lib, stdenv, fetchurl, wayland-scanner }:
+{ lib, stdenv, fetchurl
+, pkg-config
+, meson, ninja, wayland-scanner
+, python3, wayland
+}:
 
 stdenv.mkDerivation rec {
   pname = "wayland-protocols";
   version = "1.21";
+
+  doCheck = stdenv.hostPlatform == stdenv.buildPlatform;
 
   src = fetchurl {
     url = "https://wayland.freedesktop.org/releases/${pname}-${version}.tar.xz";
     sha256 = "1rfdlkzz67qsb955zqb8jbw3m22pl6ppvrvfq8bqiqcb5n24b6dr";
   };
 
-  nativeBuildInputs = [ wayland-scanner ];
+  postPatch = lib.optionalString doCheck ''
+    patchShebangs tests/
+  '';
+
+  depsBuildBuild = [ pkg-config ];
+  nativeBuildInputs = [ meson ninja wayland-scanner ];
+  checkInputs = [ python3 wayland ];
+
+  mesonFlags = [ "-Dtests=${lib.boolToString doCheck}" ];
 
   meta = {
     description = "Wayland protocol extensions";

pkgs/development/python-modules/importlib-metadata/default.nix

···
 
 buildPythonPackage rec {
   pname = "importlib-metadata";
-  version = "3.7.3";
+  version = "4.0.1";
   disabled = pythonOlder "3.6";
 
   src = fetchPypi {
     pname = "importlib_metadata";
     inherit version;
-    sha256 = "742add720a20d0467df2f444ae41704000f50e1234f46174b51f9c6031a1bd71";
+    sha256 = "sha256-jFARluSfud9d9DgzvbHkMo9khHdj7IpQcDFItzeE1YE=";
   };
 
   nativeBuildInputs = [ setuptools-scm ];

pkgs/development/python-modules/marshmallow-sqlalchemy/default.nix

···
 { lib
 , buildPythonPackage
+, pythonOlder
 , fetchPypi
 , marshmallow
 , sqlalchemy
···
 
 buildPythonPackage rec {
   pname = "marshmallow-sqlalchemy";
-  version = "0.24.2";
+  version = "0.25.0";
+  disabled = pythonOlder "3.6";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "ee3ead3b83de6608c6850ff60515691b0dc556ca226680f8a82b9f785cdb71b1";
+    sha256 = "0i39ckrixh1w9fmkm0wl868gvza72j5la0x6dd0cij9shf1iyjgi";
   };
 
   propagatedBuildInputs = [
···
     sqlalchemy
   ];
 
+  pythonImportsCheck = [
+    "marshmallow_sqlalchemy"
+  ];
+
   checkInputs = [
     pytest-lazy-fixture
     pytestCheckHook
···
 
   meta = with lib; {
     homepage = "https://github.com/marshmallow-code/marshmallow-sqlalchemy";
-    description = "SQLAlchemy integration with marshmallow ";
+    description = "SQLAlchemy integration with marshmallow";
     license = licenses.mit;
   };
 

pkgs/development/python-modules/marshmallow/default.nix

···
-{ lib, buildPythonPackage, fetchPypi,
-  dateutil, simplejson, isPy27
+{ lib
+, buildPythonPackage
+, pythonOlder
+, fetchFromGitHub
+, pytestCheckHook
+, pytz
+, simplejson
 }:
 
 buildPythonPackage rec {
   pname = "marshmallow";
-  version = "3.10.0";
-  disabled = isPy27;
+  version = "3.11.1";
+  disabled = pythonOlder "3.5";
+
+  src = fetchFromGitHub {
+    owner = "marshmallow-code";
+    repo = pname;
+    rev = version;
+    sha256 = "1ypm142y3giaqydc7fkigm9r057yp2sd1ng5zr2x3w3wbbj5yfm6";
+  };
+
+  pythonImportsCheck = [
+    "marshmallow"
+  ];
+
+  checkInputs = [
+    pytestCheckHook
+    pytz
+    simplejson
+  ];
 
-  meta = {
-    homepage = "https://github.com/marshmallow-code/marshmallow";
+  meta = with lib; {
     description = ''
       A lightweight library for converting complex objects to and from
       simple Python datatypes.
     '';
-    license = lib.licenses.mit;
+    homepage = "https://github.com/marshmallow-code/marshmallow";
+    license = licenses.mit;
   };
-
-  src = fetchPypi {
-    inherit pname version;
-    sha256 = "4ab2fdb7f36eb61c3665da67a7ce281c8900db08d72ba6bf0e695828253581f7";
-  };
-
-  propagatedBuildInputs = [ dateutil simplejson ];
-
-  doCheck = false;
 }

pkgs/development/python-modules/sqlalchemy/default.nix

···
-{ stdenv, lib, fetchPypi, buildPythonPackage, isPy3k, isPy35, fetchpatch
+{ stdenv
+, lib
+, fetchPypi
+, buildPythonPackage
+, isPy3k
+, pythonOlder
+, greenlet
+, importlib-metadata
 , mock
 , pysqlite ? null
 , pytestCheckHook
···
 
 buildPythonPackage rec {
   pname = "SQLAlchemy";
-  version = "1.3.23";
+  version = "1.4.15";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "6fca33672578666f657c131552c4ef8979c1606e494f78cd5199742dfb26918b";
+    sha256 = "1rj9h3mcxrgh5q8qvz7m39diyil27l5mldr49mgz6xfibk3h1w8g";
   };
 
-  patches = [
-    # fix test_pyodbc_extra_connect_azure test failure
-    (fetchpatch {
-      url = "https://github.com/sqlalchemy/sqlalchemy/commit/7293b3dc0e9eb3dae84ffd831494b85355df8e73.patch";
-      sha256 = "1z61lzxamz74771ddlqmbxba1dcr77f016vqfcmb44dxb228w2db";
-    })
+  propagatedBuildInputs = [
+    greenlet
+  ] ++ lib.optionals (pythonOlder "3.8") [
+    importlib-metadata
   ];
 
   checkInputs = [
···
     mock
   ] ++ lib.optional (!isPy3k) pysqlite;
 
-  pytestFlagsArray = [ "-n auto" ];
+  pytestFlagsArray = [
+    "-n auto"
+  ];
 
   postInstall = ''
     sed -e 's:--max-worker-restart=5::g' -i setup.cfg
···
   dontUseSetuptoolsCheck = true;
 
   # disable mem-usage tests on mac, has trouble serializing pickle files
-  disabledTests = lib.optionals isPy35 [ "exception_persistent_flush_py3k "]
-    ++ lib.optionals stdenv.isDarwin [ "MemUsageWBackendTest" "MemUsageTest" ];
+  disabledTests = lib.optionals stdenv.isDarwin [
+    "MemUsageWBackendTest"
+    "MemUsageTest"
+  ];
 
   meta = with lib; {
     homepage = "http://www.sqlalchemy.org/";

pkgs/development/tools/just/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "just";
-  version = "0.9.1";
+  version = "0.9.3";
 
   src = fetchFromGitHub {
     owner = "casey";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-5W/5HgXjDmr2JGYGy5FPmCNIuAagmzEHnskDUg+FzjY=";
+    sha256 = "sha256-rcHS0QchUzgcSVIw01x0p1lU/q2CqC5QAwLSFuBTPtE=";
   };
 
-  cargoSha256 = "sha256-4lLWtj/MLaSZU7nC4gVn7TyhaLtO1FUSinQejocpiuY=";
+  cargoSha256 = "sha256-LZL95AFzbWhdWPGjJr7lZORtVOUdz8lno0T8xSkblHU=";
 
   nativeBuildInputs = [ installShellFiles ];
   buildInputs = lib.optionals stdenv.isDarwin [ libiconv ];

pkgs/development/tools/rust/cargo-c/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "cargo-c";
-  version = "0.8.0";
+  version = "0.8.1";
 
   src = stdenv.mkDerivation rec {
     name = "${pname}-source-${version}";
···
       owner = "lu-zero";
       repo = pname;
       rev = "v${version}";
-      sha256 = "1rvbikhbqsfa2sh79kapqg4yz19r1yhqfykl6cf4yjg6vawkwfw1";
+      sha256 = "0fd0xql5cbqgmir2z3ah91iasaq9133wmi5bnhiy3dv7drcqv4rc";
     };
     cargoLock = fetchurl {
       url = "https://github.com/lu-zero/${pname}/releases/download/v${version}/Cargo.lock";
-      sha256 = "17cdac8ym59jwjxs3k4isazknhrlr6lw0j0r76n5xf0dd7apfgcs";
+      sha256 = "1xlh3h77rxhqyr1nkqyanb120lwdks6fklh202camqpmznd763g5";
     };
 
     installPhase = ''
···
     '';
   };
 
-  cargoSha256 = "0pxakfiidxfczh3harnjhb1zv340r812jxzwam8z2kyw3mkyhh8z";
+  cargoSha256 = "0b952xkg0l31laqlhsv3cqdag7v15k9na6xr6q9y8xwy1fjh9gzv";
 
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ openssl ]

pkgs/games/scid-vs-pc/default.nix

···
-{ lib, stdenv, fetchurl, tcl, tk, libX11, zlib, makeWrapper, makeDesktopItem }:
+{ lib, fetchurl, tcl, tk, libX11, zlib, makeWrapper, makeDesktopItem }:
 
-stdenv.mkDerivation rec {
+tcl.mkTclDerivation rec {
   pname = "scid-vs-pc";
   version = "4.21";
 
···
   };
 
   nativeBuildInputs = [ makeWrapper ];
-  buildInputs = [ tcl tk libX11 zlib ];
+  buildInputs = [ tk libX11 zlib ];
 
   prePatch = ''
     sed -i -e '/^ *set headerPath *{/a ${tcl}/include ${tk}/include' \
···
 
     for cmd in $out/bin/* ; do
       wrapProgram "$cmd" \
-        --set TCLLIBPATH "${tcl}/${tcl.libdir}" \
         --set TK_LIBRARY "${tk}/lib/${tk.libPrefix}"
     done
   '';
···
     platforms = lib.platforms.linux;
   };
 }
-

pkgs/games/scid/default.nix

···
-{ lib, stdenv, fetchurl, tcl, tk, libX11, zlib, makeWrapper }:
+{ lib, fetchurl, tcl, tk, libX11, zlib, makeWrapper }:
 
-stdenv.mkDerivation {
+tcl.mkTclDerivation {
   pname = "scid";
   version = "4.3";
 
···
   };
 
   nativeBuildInputs = [ makeWrapper ];
-  buildInputs = [ tcl tk libX11 zlib ];
+  buildInputs = [ tk libX11 zlib ];
 
   prePatch = ''
     sed -i -e '/^ *set headerPath *{/a ${tcl}/include ${tk}/include' \
···
     for cmd in $out/bin/*
     do
       wrapProgram "$cmd" \
-        --set TCLLIBPATH "${tcl}/${tcl.libdir}" \
         --set TK_LIBRARY "${tk}/lib/${tk.libPrefix}"
     done
   '';
 
   meta = {
     description = "Chess database with play and training functionality";
+    maintainers = with lib.maintainers; [ agbrooks ];
     homepage = "http://scid.sourceforge.net/";
     license = lib.licenses.gpl2;
   };

pkgs/games/tcl2048/default.nix

···
 { lib, stdenv, fetchurl, tcl, tcllib, runtimeShell }:
 
-stdenv.mkDerivation {
+tcl.mkTclDerivation {
   name = "tcl2048-0.4.0";
 
   src = fetchurl {
···
     sha256 = "53f5503efd7f029b2614b0f9b1e3aac6c0342735a3c9b811d74a5135fee3e89e";
   };
 
-  phases = "installPhase";
+  buildInputs = [ tcllib ];
+  phases = "installPhase fixupPhase";
 
   installPhase = ''
     mkdir -pv $out/bin
-    cp $src $out/2048.tcl
-    cat > $out/bin/2048 << EOF
-    #!${runtimeShell}
-
-    # wrapper for tcl2048
-    export TCLLIBPATH="${tcllib}/lib/tcllib${tcllib.version}"
-    ${tcl}/bin/tclsh $out/2048.tcl
-    EOF
-
-    chmod +x $out/bin/2048
+    install -m 755 $src $out/bin/2048
   '';
 
   meta = {

pkgs/servers/x11/xorg/default.nix

···
   }) {};
 
   libX11 = callPackage ({ stdenv, pkg-config, fetchurl, xorgproto, libxcb, xtrans }: stdenv.mkDerivation {
-    name = "libX11-1.7.0";
+    name = "libX11-1.7.1";
     builder = ./builder.sh;
     src = fetchurl {
-      url = "mirror://xorg/individual/lib/libX11-1.7.0.tar.bz2";
-      sha256 = "0m6bfwllr3pq2c00l51y62yiq15kphc8dw69zf67qhwmclxzkj1n";
+      url = "mirror://xorg/individual/lib/libX11-1.7.1.tar.bz2";
+      sha256 = "0isxad59hvdwggbxqqjjjg3zmih9xiq4d9mdsnqbyb2nmbg46kp6";
     };
     hardeningDisable = [ "bindnow" "relro" ];
     nativeBuildInputs = [ pkg-config ];

pkgs/servers/x11/xorg/tarballs.list

···
 mirror://xorg/individual/lib/libpciaccess-0.16.tar.bz2
 mirror://xorg/individual/lib/libSM-1.2.3.tar.bz2
 mirror://xorg/individual/lib/libWindowsWM-1.0.1.tar.bz2
-mirror://xorg/individual/lib/libX11-1.7.0.tar.bz2
+mirror://xorg/individual/lib/libX11-1.7.1.tar.bz2
 mirror://xorg/individual/lib/libXau-1.0.9.tar.bz2
 mirror://xorg/individual/lib/libXaw-1.0.14.tar.bz2
 mirror://xorg/individual/lib/libXaw3d-1.6.3.tar.bz2

pkgs/tools/filesystems/btrfs-progs/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "btrfs-progs";
-  version = "5.11.1";
+  version = "5.12.1";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/people/kdave/btrfs-progs/btrfs-progs-v${version}.tar.xz";
-    sha256 = "sha256-46rMxHVuxOVQLLKp+Ftn1SiWZE9MPA+IprxZjHC96/4=";
+    sha256 = "sha256-lQhG/qRU+0scOfD6RUmDZEVy35HfXAYEezNb8tVHN1k=";
   };
 
   nativeBuildInputs = [

pkgs/tools/misc/expect/default.nix

···
 { lib, stdenv, buildPackages, fetchurl, tcl, makeWrapper, autoreconfHook, fetchpatch }:
 
-stdenv.mkDerivation rec {
+tcl.mkTclDerivation rec {
   pname = "expect";
   version = "5.45.4";
 
···
     sed -i "s,/bin/stty,$(type -p stty),g" configure.in
   '';
 
-  nativeBuildInputs = [ autoreconfHook makeWrapper tcl ];
-  buildInputs = [ tcl ];
+  nativeBuildInputs = [ autoreconfHook makeWrapper ];
 
   strictDeps = true;
   hardeningDisable = [ "format" ];
 
-  configureFlags = [
-    "--with-tcl=${buildPackages.tcl}/lib"
-    "--with-tclinclude=${tcl}/include"
-    "--exec-prefix=${placeholder "out"}"
-  ];
-
-  postInstall = ''
+  postInstall = lib.optionalString stdenv.isDarwin ''
     for i in $out/bin/*; do
-      wrapProgram $i \
-        --prefix PATH : "${tcl}/bin" \
-        --prefix TCLLIBPATH ' ' $out/lib/* \
-        ${lib.optionalString stdenv.isDarwin "--prefix DYLD_LIBRARY_PATH : $out/lib/expect${version}"}
+      wrapProgram $i --prefix DYLD_LIBRARY_PATH : $out/lib/expect${version}
     done
   '';
 

pkgs/tools/misc/remind/default.nix

···
 , fetchurl
 , tk
 , tcllib
-, makeWrapper
+, tcl
 , tkremind ? true
 }:
 
 let
-  inherit (lib) optional optionalString;
-  tclLibraries = lib.optionals tkremind [ tcllib tk ];
-  tclLibPaths = lib.concatStringsSep " "
-    (map (p: "${p}/lib/${p.libPrefix}") tclLibraries);
+  inherit (lib) optional optionals optionalString;
+  tclLibraries = optionals tkremind [ tcllib tk ];
   tkremindPatch = optionalString tkremind ''
     substituteInPlace scripts/tkremind --replace "exec wish" "exec ${tk}/bin/wish"
   '';
 in
-stdenv.mkDerivation rec {
+tcl.mkTclDerivation rec {
   pname = "remind";
   version = "03.03.06";
 
···
     sha256 = "sha256-lpoMAXDJxwODY0/aoo25GRBYWFhE4uf11pR5/ITZX1s=";
   };
 
-  nativeBuildInputs = optional tkremind makeWrapper;
   propagatedBuildInputs = tclLibraries;
 
   postPatch = ''
···
       --replace "rkrphgvba(0);" "" \
       --replace "rkrphgvba(1);" ""
     ${tkremindPatch}
-  '';
-
-  postInstall = optionalString tkremind ''
-    wrapProgram $out/bin/tkremind --set TCLLIBPATH "${tclLibPaths}"
   '';
 
   meta = with lib; {

pkgs/top-level/all-packages.nix

···
   };
   rust_1_52 = callPackage ../development/compilers/rust/1_52.nix {
     inherit (darwin.apple_sdk.frameworks) CoreFoundation Security;
-    llvm_11 = llvmPackages_11.libllvm;
+    llvm_12 = llvmPackages_12.libllvm;
   };
   rust = rust_1_52;
 
···
 
   tcllib = callPackage ../development/libraries/tcllib { };
 
-  tcltls = callPackage ../development/libraries/tcltls {
-    openssl = openssl_1_0_2;
-  };
+  tcltls = callPackage ../development/libraries/tcltls { };
 
   tclx = callPackage ../development/libraries/tclx { };
 
···
 
   zcash = callPackage ../applications/blockchains/zcash { stdenv = llvmPackages_11.stdenv; };
 
-  openethereum = callPackage ../applications/blockchains/openethereum { stdenv = llvmPackages_12.stdenv; };
+  openethereum = callPackage ../applications/blockchains/openethereum { };
 
   parity-ui = callPackage ../applications/blockchains/parity-ui { };