pkgs/development/tools: stdenv.lib -> lib

pkgs/development/tools/alloy/default.nix

···
-{ stdenv, fetchurl, jre, makeWrapper, makeDesktopItem }:
+{ lib, stdenv, fetchurl, jre, makeWrapper, makeDesktopItem }:
 
 let generic = { major, version, src }:
 
···
       cp -r ${desktopItem}/share/applications $out/share
     '';
 
-    meta = with stdenv.lib; {
+    meta = with lib; {
       description = "Language & tool for relational models";
       longDescription = ''
         Alloy is a language for describing structures and a tool for exploring

pkgs/development/tools/ammonite/default.nix

···
-{ stdenv, fetchurl, jre, nixosTests, writeScript, common-updater-scripts, git
+{ lib, stdenv, fetchurl, jre, nixosTests, writeScript, common-updater-scripts, git
 , nixfmt, nix, coreutils, gnused, disableRemoteLogging ? true }:
 
-with stdenv.lib;
+with lib;
 
 let
   repo = "[e-mail]:lihaoyi/Ammonite.git";
···
           #!${stdenv.shell}
           set -o errexit
           PATH=${
-            stdenv.lib.makeBinPath [
+            lib.makeBinPath [
               common-updater-scripts
               coreutils
               git

pkgs/development/tools/analysis/autoflake/default.nix

···
-{ stdenv, python3Packages }:
+{ lib, stdenv, python3Packages }:
 
 with python3Packages;
 buildPythonApplication rec {
···
 
   doCheck = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/myint/autoflake";
     description = "A simple program which removes unused imports and unused variables as reported by pyflakes";
     license = licenses.mit;

pkgs/development/tools/analysis/bingrep/default.nix

···
-{ stdenv, rustPlatform, fetchFromGitHub }:
+{ lib, stdenv, rustPlatform, fetchFromGitHub }:
 
 rustPlatform.buildRustPackage rec {
   pname = "bingrep";
···
 
   cargoSha256 = "sha256-3eGYU5O7HSpawIL/8OVmROCzXfdnoMAnIujjrIp00xg=";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Greps through binaries from various OSs and architectures, and colors them";
     homepage = "https://github.com/m4b/bingrep";
     license = licenses.mit;

pkgs/development/tools/analysis/cccc/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 
 let
   name = "cccc";
···
       complexity and metrics proposed by Chidamber&Kemerer and Henry&Kafura.
     '';
     homepage = "http://cccc.sourceforge.net/";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = [ stdenv.lib.maintainers.linquize ];
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.unix;
+    maintainers = [ lib.maintainers.linquize ];
   };
 }

pkgs/development/tools/analysis/checkstyle/default.nix

···
-{ stdenv, fetchurl, makeWrapper, jre }:
+{ lib, stdenv, fetchurl, makeWrapper, jre }:
 
 stdenv.mkDerivation rec {
   version = "8.39";
···
     runHook postInstall
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Checks Java source against a coding standard";
     longDescription = ''
       checkstyle is a development tool to help programmers write Java code that

pkgs/development/tools/analysis/clang-analyzer/default.nix

···
-{ stdenv, fetchurl, clang, llvmPackages, perl, makeWrapper, python3 }:
+{ lib, stdenv, fetchurl, clang, llvmPackages, perl, makeWrapper, python3 }:
 
 stdenv.mkDerivation rec {
   pname = "clang-analyzer";
···
   meta = {
     description = "Clang Static Analyzer";
     homepage    = "http://clang-analyzer.llvm.org";
-    license     = stdenv.lib.licenses.bsd3;
-    platforms   = stdenv.lib.platforms.unix;
-    maintainers = [ stdenv.lib.maintainers.thoughtpolice ];
+    license     = lib.licenses.bsd3;
+    platforms   = lib.platforms.unix;
+    maintainers = [ lib.maintainers.thoughtpolice ];
   };
 }

pkgs/development/tools/analysis/coan/default.nix

···
-{ stdenv, fetchurl, perl }:
+{ lib, stdenv, fetchurl, perl }:
 
 stdenv.mkDerivation rec {
   version = "6.0.1";
···
     mv -v $out/share/man/man1/coan.1.{1,gz}
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "The C preprocessor chainsaw";
     longDescription = ''
       A software engineering tool for analysing preprocessor-based

pkgs/development/tools/analysis/codeql/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchzip
 , zlib
 , xorg
···
     ln -s $out/codeql/codeql $out/bin/
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Semantic code analysis engine";
     homepage = "https://semmle.com/codeql";
     maintainers = [ maintainers.dump_stack ];

pkgs/development/tools/analysis/cov-build/default.nix

···
-{ stdenv, requireFile }:
+{ lib, stdenv, requireFile }:
 
 let
   message = ''
···
   meta = {
     description = "Coverity Scan build tools";
     homepage    = "https://scan.coverity.com";
-    license     = stdenv.lib.licenses.unfreeRedistributable;
-    platforms   = stdenv.lib.platforms.linux;
-    maintainers = [ stdenv.lib.maintainers.thoughtpolice ];
+    license     = lib.licenses.unfreeRedistributable;
+    platforms   = lib.platforms.linux;
+    maintainers = [ lib.maintainers.thoughtpolice ];
   };
 }

pkgs/development/tools/analysis/coz/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchFromGitHub
 , libelfin
 , ncurses
···
   meta = {
     homepage = "https://github.com/plasma-umass/coz";
     description = "Profiler based on casual profiling";
-    license = stdenv.lib.licenses.bsd2;
-    maintainers = with stdenv.lib.maintainers; [ zimbatm ];
+    license = lib.licenses.bsd2;
+    maintainers = with lib.maintainers; [ zimbatm ];
   };
 }

pkgs/development/tools/analysis/cppcheck/default.nix

···
-{ stdenv, fetchurl, libxslt, docbook_xsl, docbook_xml_dtd_45, pcre, withZ3 ? true, z3 }:
+{ lib, stdenv, fetchurl, libxslt, docbook_xsl, docbook_xml_dtd_45, pcre, withZ3 ? true, z3 }:
 
 stdenv.mkDerivation rec {
   pname = "cppcheck";
···
     sha256 = "0mlw0z20qf0g9qrmdmbykzf87wlcgmah8bacmp4mk6dwfzr9g9n3";
   };
 
-  buildInputs = [ pcre ] ++ stdenv.lib.optionals withZ3 [ z3 ];
+  buildInputs = [ pcre ] ++ lib.optionals withZ3 [ z3 ];
   nativeBuildInputs = [ libxslt docbook_xsl docbook_xml_dtd_45 ];
 
   makeFlags = [ "PREFIX=$(out)" "FILESDIR=$(out)/cfg" "HAVE_RULES=yes" ]
-   ++ stdenv.lib.optionals withZ3 [ "USE_Z3=yes" "CPPFLAGS=-DNEW_Z3=1" ];
+   ++ lib.optionals withZ3 [ "USE_Z3=yes" "CPPFLAGS=-DNEW_Z3=1" ];
 
   outputs = [ "out" "man" ];
 
···
     cp cppcheck.1 $man/share/man/man1/cppcheck.1
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A static analysis tool for C/C++ code";
     longDescription = ''
       Check C/C++ code for memory leaks, mismatching allocation-deallocation,

pkgs/development/tools/analysis/egypt/default.nix

···
-{ stdenv, fetchurl, perlPackages }:
+{ lib, stdenv, fetchurl, perlPackages }:
 
 perlPackages.buildPerlPackage rec {
   pname = "egypt";
···
 
   doCheck = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Tool for making call graphs of C programmes";
     longDescription = ''
       Egypt is a simple tool for creating call graphs of C programs. It neither

pkgs/development/tools/analysis/emma/default.nix

···
-{stdenv, fetchurl, unzip}:
+{lib, stdenv, fetchurl, unzip}:
 
 stdenv.mkDerivation {
   name = "emma-2.0.5312";
···
   meta = {
     homepage = "http://emma.sourceforge.net/";
     description = "A code coverage tool for Java";
-    platforms = stdenv.lib.platforms.unix;
-    license = stdenv.lib.licenses.cpl10;
+    platforms = lib.platforms.unix;
+    license = lib.licenses.cpl10;
   };
 }

pkgs/development/tools/analysis/evmdis/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage {
   pname = "evmdis-unstable";
···
     sha256 = "09y4j7ipgv8yd99g3xk3f079w8fqfj7kl1y7ry81ainysn0qlqrg";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/Arachnid/evmdis";
     description = "Ethereum EVM disassembler";
     license = [ licenses.asl20 ];

pkgs/development/tools/analysis/findbugs/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
   name = "findbugs-3.0.1";
···
     EOF
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A static analysis tool to find bugs in Java programs automatically";
     homepage = "http://findbugs.sourceforge.net/";
     maintainers = with maintainers; [ pSub ];

pkgs/development/tools/analysis/flow/default.nix

···
-{ stdenv, fetchFromGitHub, ocamlPackages, CoreServices }:
+{ lib, stdenv, fetchFromGitHub, ocamlPackages, CoreServices }:
 
 stdenv.mkDerivation rec {
   pname = "flow";
···
   '';
 
   buildInputs = (with ocamlPackages; [ ocaml findlib ocamlbuild dtoa core_kernel sedlex_2 ocaml_lwt lwt_log lwt_ppx ppx_deriving ppx_gen_rec ppx_tools_versioned visitors wtf8 ocaml-migrate-parsetree ])
-    ++ stdenv.lib.optionals stdenv.isDarwin [ CoreServices ];
+    ++ lib.optionals stdenv.isDarwin [ CoreServices ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A static type checker for JavaScript";
     homepage = "https://flow.org/";
     changelog = "https://github.com/facebook/flow/releases/tag/v${version}";

pkgs/development/tools/analysis/frama-c/default.nix

···
   meta = {
     description = "An extensible and collaborative platform dedicated to source-code analysis of C software";
     homepage    = "http://frama-c.com/";
-    license     = stdenv.lib.licenses.lgpl21;
-    maintainers = with stdenv.lib.maintainers; [ thoughtpolice amiddelk ];
-    platforms   = stdenv.lib.platforms.unix;
+    license     = lib.licenses.lgpl21;
+    maintainers = with lib.maintainers; [ thoughtpolice amiddelk ];
+    platforms   = lib.platforms.unix;
   };
 }

pkgs/development/tools/analysis/garcosim/tracefilegen/default.nix

···
-{ stdenv, fetchFromGitHub, cmake }:
+{ lib, stdenv, fetchFromGitHub, cmake }:
 
 stdenv.mkDerivation rec {
 
···
     cp -ar $src/Documentation/html $out/share/doc/${name}/.
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Automatically generate all types of basic memory management operations and write into trace files";
     homepage = "https://github.com/GarCoSim";
     maintainers = [ maintainers.cmcdragonkai ];

pkgs/development/tools/analysis/garcosim/tracefilesim/default.nix

···
-{ stdenv, fetchgit }:
+{ lib, stdenv, fetchgit }:
 
 stdenv.mkDerivation {
 
···
     cp ./traceFileSim "$out/bin"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Ease the analysis of existing memory management techniques, as well as the prototyping of new memory management techniques";
     homepage = "https://github.com/GarCoSim";
     maintainers = [ maintainers.cmcdragonkai ];

pkgs/development/tools/analysis/hopper/default.nix

···
       --replace "Exec=/opt/hopper-${rev}/bin/Hopper" "Exec=$out/bin/hopper"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://www.hopperapp.com/index.html";
     description = "A macOS and Linux Disassembler";
     license = licenses.unfree;

pkgs/development/tools/analysis/hotspot/default.nix

···
-{ stdenv,
+{ lib, stdenv,
   mkDerivation,
   cmake,
   elfutils,
···
       then displays the result in a graphical way.
     '';
     homepage = "https://github.com/KDAB/hotspot";
-    license = with stdenv.lib.licenses; [ gpl2 gpl3 ];
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = with stdenv.lib.maintainers; [ nh2 ];
+    license = with lib.licenses; [ gpl2 gpl3 ];
+    platforms = lib.platforms.linux;
+    maintainers = with lib.maintainers; [ nh2 ];
   };
 }

pkgs/development/tools/analysis/include-what-you-use/default.nix

···
-{ stdenv, fetchurl, cmake, llvmPackages, python2 }:
+{ lib, stdenv, fetchurl, cmake, llvmPackages, python2 }:
 
 stdenv.mkDerivation rec {
   pname = "include-what-you-use";
···
       --replace "'include-what-you-use'" "'$out/bin/include-what-you-use'"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Analyze #includes in C/C++ source files with clang";
     longDescription = ''
       For every symbol (type, function variable, or macro) that you use in

pkgs/development/tools/analysis/jdepend/default.nix

···
-{ stdenv, fetchFromGitHub, ant, jdk, runtimeShell }:
+{ lib, stdenv, fetchFromGitHub, ant, jdk, runtimeShell }:
 
 stdenv.mkDerivation rec {
   pname = "jdepend";
···
     chmod a+x $out/bin/jdepend
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Traverses Java class file directories and generates design quality metrics for each Java package";
     homepage = "http://www.clarkware.com/software/JDepend.html";
     license = licenses.bsd3;

pkgs/development/tools/analysis/kcov/default.nix

···
-{stdenv, fetchFromGitHub, cmake, pkg-config, zlib, curl, elfutils, python, libiberty, libopcodes}:
+{lib, stdenv, fetchFromGitHub, cmake, pkg-config, zlib, curl, elfutils, python, libiberty, libopcodes}:
 
 stdenv.mkDerivation rec {
   pname = "kcov";
···
 
   buildInputs = [ zlib curl elfutils python libiberty libopcodes ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Code coverage tester for compiled programs, Python scripts and shell scripts";
 
     longDescription = ''

pkgs/development/tools/analysis/lcov/default.nix

···
- {stdenv, fetchFromGitHub, perl, perlPackages, makeWrapper }:
+ {lib, stdenv, fetchFromGitHub, perl, perlPackages, makeWrapper }:
 
 stdenv.mkDerivation rec {
   pname = "lcov";
···
     wrapProgram $out/bin/genpng --set PERL5LIB ${perlPackages.makeFullPerlPath [ perlPackages.GD ]}
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Code coverage tool that enhances GNU gcov";
 
     longDescription =
···
       '';
 
     homepage = "http://ltp.sourceforge.net/coverage/lcov.php";
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
 
     maintainers = with maintainers; [ dezgeg ];
     platforms = platforms.all;

pkgs/development/tools/analysis/makefile2graph/default.nix

···
-{ stdenv, fetchFromGitHub, makeWrapper, bash, gnumake }:
+{ lib, stdenv, fetchFromGitHub, makeWrapper, bash, gnumake }:
 
 stdenv.mkDerivation {
   name = "makefile2graph-2018-01-03";
···
       --replace '/bin/sh' ${bash}/bin/bash \
       --replace 'make2graph' "$out/bin/make2graph"
     wrapProgram $out/bin/makefile2graph \
-      --set PATH ${stdenv.lib.makeBinPath [ gnumake ]}
+      --set PATH ${lib.makeBinPath [ gnumake ]}
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/lindenb/makefile2graph";
     description = "Creates a graph of dependencies from GNU-Make; Output is a graphiz-dot file or a Gexf-XML file";
     maintainers = with maintainers; [ cmcdragonkai ];

pkgs/development/tools/analysis/oclgrind/default.nix

···
-{ stdenv, fetchFromGitHub, cmake, llvmPackages, readline, python }:
+{ lib, stdenv, fetchFromGitHub, cmake, llvmPackages, readline, python }:
 
 stdenv.mkDerivation rec {
   pname = "oclgrind";
···
     "-DCLANG_ROOT=${llvmPackages.clang-unwrapped}"
   ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "An OpenCL device simulator and debugger";
     homepage = "https://github.com/jrprice/oclgrind";
     license = licenses.bsd3;

pkgs/development/tools/analysis/panopticon/default.nix

···
-{ stdenv, fetchFromGitHub, rustPlatform, qt5, git, cmake
+{ lib, stdenv, fetchFromGitHub, rustPlatform, qt5, git, cmake
 , pkg-config, makeWrapper }:
 
 rustPlatform.buildRustPackage rec {
···
     makeWrapper $out/share/${pname}/${pname} $out/bin/${pname}
      '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A libre cross-platform disassembler";
     longDescription = ''
       Panopticon is a cross platform disassembler for reverse

pkgs/development/tools/analysis/pev/default.nix

···
-{ stdenv, openssl, fetchFromGitHub }:
+{ lib, stdenv, openssl, fetchFromGitHub }:
 
 stdenv.mkDerivation {
   pname = "pev";
···
 
   installFlags = [ "prefix=$(out)" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A full-featured, open source, multiplatform command line toolkit to work with PE (Portable Executables) binaries";
     homepage = "https://pev.sourceforge.net/";
     license = licenses.gpl2;

pkgs/development/tools/analysis/pmd/default.nix

···
-{ stdenv, fetchurl, unzip, makeWrapper, openjdk }:
+{ lib, stdenv, fetchurl, unzip, makeWrapper, openjdk }:
 
 stdenv.mkDerivation rec {
   pname = "pmd";
···
     runHook postInstall
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "An extensible cross-language static code analyzer";
     homepage = "https://pmd.github.io/";
     changelog = "https://pmd.github.io/pmd-${version}/pmd_release_notes.html";

pkgs/development/tools/analysis/qcachegrind/default.nix

···
-{ stdenv, qmake, qtbase, perl, python, php, kcachegrind }:
+{ lib, stdenv, qmake, qtbase, perl, python, php, kcachegrind }:
 
 let
-  name = stdenv.lib.replaceStrings ["kcachegrind"] ["qcachegrind"] kcachegrind.name;
+  name = lib.replaceStrings ["kcachegrind"] ["qcachegrind"] kcachegrind.name;
 
 in stdenv.mkDerivation {
   inherit name;
···
     install -Dm644 kcachegrind/48-apps-kcachegrind.png "$out/share/icons/hicolor/48x48/apps/kcachegrind.png"
   '');
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A Qt GUI to visualize profiling data";
     license = licenses.gpl2;
     platforms = platforms.unix;

pkgs/development/tools/analysis/radare2/default.nix

···
-{stdenv, fetchFromGitHub
+{lib, stdenv, fetchFromGitHub
 , buildPackages
 , pkg-config
 , libusb-compat-0_1, readline, libewf, perl, zlib, openssl
···
 
 
 let
-  inherit (stdenv.lib) optional;
+  inherit (lib) optional;
 
   generic = {
     version_commit, # unused
···
       meta = {
         description = "unix-like reverse engineering framework and commandline tools";
         homepage = "http://radare.org/";
-        license = stdenv.lib.licenses.gpl2Plus;
-        maintainers = with stdenv.lib.maintainers; [ raskin makefu mic92 ];
-        platforms = with stdenv.lib.platforms; linux;
+        license = lib.licenses.gpl2Plus;
+        maintainers = with lib.maintainers; [ raskin makefu mic92 ];
+        platforms = with lib.platforms; linux;
         inherit version;
       };
   };

pkgs/development/tools/analysis/randoop/default.nix

···
-{ stdenv, fetchurl, unzip }:
+{ lib, stdenv, fetchurl, unzip }:
 
 stdenv.mkDerivation rec {
   version = "4.2.5";
···
     cp README.txt $out/doc
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Automatic test generation for Java";
     homepage = "https://randoop.github.io/randoop/";
     license = licenses.mit;

pkgs/development/tools/analysis/rr/default.nix

···
-{ stdenv, fetchFromGitHub, cmake, libpfm, zlib, pkg-config, python3Packages, which, procps, gdb, capnproto }:
+{ lib, stdenv, fetchFromGitHub, cmake, libpfm, zlib, pkg-config, python3Packages, which, procps, gdb, capnproto }:
 
 stdenv.mkDerivation rec {
   version = "5.4.0";
···
       time the same execution is replayed.
     '';
 
-    license = with stdenv.lib.licenses; [ mit bsd2 ];
-    maintainers = with stdenv.lib.maintainers; [ pierron thoughtpolice ];
-    platforms = stdenv.lib.platforms.x86;
+    license = with lib.licenses; [ mit bsd2 ];
+    maintainers = with lib.maintainers; [ pierron thoughtpolice ];
+    platforms = lib.platforms.x86;
   };
 }

pkgs/development/tools/analysis/smatch/default.nix

···
-{ stdenv, fetchgit, sqlite, pkg-config, perl
+{ lib, stdenv, fetchgit, sqlite, pkg-config, perl
 , buildllvmsparse ? true
 , buildc2xml ? true
 , llvm ? null, libxml2 ? null
···
 
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [sqlite perl]
-   ++ stdenv.lib.optional buildllvmsparse llvm
-   ++ stdenv.lib.optional buildc2xml libxml2;
+   ++ lib.optional buildllvmsparse llvm
+   ++ lib.optional buildc2xml libxml2;
 
   preBuild =
     '' sed -i Makefile \
···
   meta = {
     description = "A semantic analysis tool for C";
     homepage = "http://smatch.sourceforge.net/";
-    license = stdenv.lib.licenses.free; /* OSL, see http://www.opensource.org */
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.free; /* OSL, see http://www.opensource.org */
+    platforms = lib.platforms.linux;
   };
 }

pkgs/development/tools/analysis/snowman/default.nix

···
-{ stdenv, mkDerivation, fetchFromGitHub, cmake, boost, qtbase }:
+{ lib, stdenv, mkDerivation, fetchFromGitHub, cmake, boost, qtbase }:
 
 mkDerivation rec {
   pname = "snowman";
···
     export sourceRoot=$sourceRoot/src
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Native code to C/C++ decompiler";
     homepage = "http://derevenets.com/";
 

pkgs/development/tools/analysis/sparse/default.nix

···
-{ fetchurl, stdenv, pkg-config, libxml2, llvm }:
+{ fetchurl, lib, stdenv, pkg-config, libxml2, llvm }:
 
 stdenv.mkDerivation rec {
   name = "sparse-0.5.0";
···
   meta = {
     description = "Semantic parser for C";
     homepage    = "https://git.kernel.org/cgit/devel/sparse/sparse.git/";
-    license     = stdenv.lib.licenses.mit;
-    platforms   = stdenv.lib.platforms.linux;
-    maintainers = [ stdenv.lib.maintainers.thoughtpolice ];
+    license     = lib.licenses.mit;
+    platforms   = lib.platforms.linux;
+    maintainers = [ lib.maintainers.thoughtpolice ];
   };
 }

pkgs/development/tools/analysis/spin/default.nix

···
 , withISpin ? true, tk, swarm, graphviz }:
 
 let
-  binPath = stdenv.lib.makeBinPath [ gcc ];
-  ibinPath = stdenv.lib.makeBinPath [ gcc tk swarm graphviz tk ];
+  binPath = lib.makeBinPath [ gcc ];
+  ibinPath = lib.makeBinPath [ gcc tk swarm graphviz tk ];
 
 in stdenv.mkDerivation rec {
   pname = "spin";
   version = "6.4.9";
-  url-version = stdenv.lib.replaceChars ["."] [""] version;
+  url-version = lib.replaceChars ["."] [""] version;
 
   src = fetchurl {
     # The homepage is behind CloudFlare anti-DDoS protection, which blocks cURL.
···
       --prefix PATH ':' "$out/bin:${ibinPath}"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Formal verification tool for distributed software systems";
     homepage = "http://spinroot.com/";
     license = licenses.free;

pkgs/development/tools/analysis/splint/default.nix

···
-{ fetchurl, stdenv, flex }:
+{ fetchurl, lib, stdenv, flex }:
 
 stdenv.mkDerivation rec {
   name = "splint-3.1.2";
···
     sha256 = "02pv8kscsrkrzip9r08pfs9xs98q74c52mlxzbii6cv6vx1vd3f7";
   };
 
-  patches = [ ./tmpdir.patch ] ++ stdenv.lib.optional stdenv.isDarwin ./darwin.patch;
+  patches = [ ./tmpdir.patch ] ++ lib.optional stdenv.isDarwin ./darwin.patch;
 
   buildInputs = [ flex ];
 
   doCheck = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "http://www.splint.org/";
     description = "Annotation-assisted lightweight static analyzer for C";
 

pkgs/development/tools/analysis/swarm/default.nix

···
-{ stdenv, fetchFromGitHub }:
+{ lib, stdenv, fetchFromGitHub }:
 
 stdenv.mkDerivation {
   name = "swarm-2019-03-11";
···
     install -Dm644 Doc/swarm.1 $out/share/man/man1/swarm.1
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Verification script generator for Spin";
     homepage = "http://spinroot.com/";
     license = licenses.free;

pkgs/development/tools/analysis/uefi-firmware-parser/default.nix

···
-{ stdenv, python3, fetchFromGitHub }:
+{ lib, stdenv, python3, fetchFromGitHub }:
 
 with python3.pkgs;
 
···
     sha256 = "1yn9vi91j1yxkn0icdnjhgl0qrqqkzyhccj39af4f19q1gdw995l";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/theopolis/uefi-firmware-parser/";
     description = "Parse BIOS/Intel ME/UEFI firmware related structures: Volumes, FileSystems, Files, etc";
     # MIT + license headers in some files

pkgs/development/tools/analysis/valgrind/default.nix

···
-{ stdenv, fetchurl, perl, gdb, cctools, xnu, bootstrap_cmds }:
+{ lib, stdenv, fetchurl, perl, gdb, cctools, xnu, bootstrap_cmds }:
 
 stdenv.mkDerivation rec {
   name = "valgrind-3.16.1";
···
 
   # GDB is needed to provide a sane default for `--db-command'.
   # Perl is needed for `callgrind_{annotate,control}'.
-  buildInputs = [ gdb perl ]  ++ stdenv.lib.optionals (stdenv.isDarwin) [ bootstrap_cmds xnu ];
+  buildInputs = [ gdb perl ]  ++ lib.optionals (stdenv.isDarwin) [ bootstrap_cmds xnu ];
 
   # Perl is also a native build input.
   nativeBuildInputs = [ perl ];
···
   enableParallelBuilding = true;
   separateDebugInfo = stdenv.isLinux;
 
-  preConfigure = stdenv.lib.optionalString stdenv.isDarwin (
+  preConfigure = lib.optionalString stdenv.isDarwin (
     let OSRELEASE = ''
       $(awk -F '"' '/#define OSRELEASE/{ print $2 }' \
       <${xnu}/Library/Frameworks/Kernel.framework/Headers/libkern/version.h)'';
···
   postPatch = "";
 
   configureFlags =
-    stdenv.lib.optional (stdenv.hostPlatform.system == "x86_64-linux" || stdenv.hostPlatform.system == "x86_64-darwin") "--enable-only64bit"
-    ++ stdenv.lib.optional stdenv.hostPlatform.isDarwin "--with-xcodedir=${xnu}/include";
+    lib.optional (stdenv.hostPlatform.system == "x86_64-linux" || stdenv.hostPlatform.system == "x86_64-darwin") "--enable-only64bit"
+    ++ lib.optional stdenv.hostPlatform.isDarwin "--with-xcodedir=${xnu}/include";
 
   doCheck = false; # fails
 
···
       Valgrind to build new tools.
     '';
 
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
 
-    maintainers = [ stdenv.lib.maintainers.eelco ];
-    platforms = stdenv.lib.platforms.unix;
+    maintainers = [ lib.maintainers.eelco ];
+    platforms = lib.platforms.unix;
     badPlatforms = [
       "armv5tel-linux" "armv6l-linux" "armv6m-linux"
       "sparc-linux" "sparc64-linux"

pkgs/development/tools/analysis/valkyrie/default.nix

···
-{ stdenv, fetchurl, qt4, qmake4Hook }:
+{ lib, stdenv, fetchurl, qt4, qmake4Hook }:
 
 stdenv.mkDerivation rec {
   name = "valkyrie-2.0.0";
···
 
   nativeBuildInputs = [ qmake4Hook ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "http://www.valgrind.org/";
     description = "Qt4-based GUI for the Valgrind 3.6.x series";
     license = licenses.gpl2;

pkgs/development/tools/apktool/default.nix

···
-{ stdenv, fetchurl, makeWrapper, jre, build-tools }:
+{ lib, stdenv, fetchurl, makeWrapper, jre, build-tools }:
 
 stdenv.mkDerivation rec {
   pname = "apktool";
···
         --prefix PATH : "${builtins.head build-tools}/libexec/android-sdk/build-tools/28.0.3"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A tool for reverse engineering Android apk files";
     homepage    = "https://ibotpeaches.github.io/Apktool/";
     license     = licenses.asl20;

pkgs/development/tools/asn2quickder/default.nix

···
-{ stdenv, buildPythonApplication, fetchFromGitHub, makeWrapper, cmake
+{ lib, stdenv, buildPythonApplication, fetchFromGitHub, makeWrapper, cmake
 , pytestrunner, pytest, six, pyparsing, asn1ate }:
 
 buildPythonApplication rec {
···
 
   propagatedBuildInputs = [ pyparsing asn1ate six ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "An ASN.1 compiler with a backend for Quick DER";
     homepage = "https://github.com/vanrein/asn2quickder";
     license = licenses.bsd3;

pkgs/development/tools/avro-tools/default.nix

···
     --add-flags "-jar $out/libexec/avro-tools/${pname}.jar"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage    = "https://avro.apache.org/";
     description = "Avro command-line tools and utilities";
     license     = lib.licenses.asl20;

pkgs/development/tools/azcopy/default.nix

···
-{ stdenv, fetchFromGitHub, buildGoModule }:
+{ lib, stdenv, fetchFromGitHub, buildGoModule }:
 
 buildGoModule rec {
   pname = "azure-storage-azcopy";
···
     ln -rs "$out/bin/azure-storage-azcopy" "$out/bin/azcopy"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     maintainers = with maintainers; [ colemickens ];
     license = licenses.mit;
     description = "The new Azure Storage data transfer utility - AzCopy v10";

pkgs/development/tools/bazel-watcher/default.nix

···
 , git
 , go
 , python
-, stdenv
+, lib, stdenv
 }:
 
 let
···
     '';
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/bazelbuild/bazel-watcher";
     description = "Tools for building Bazel targets when source files change";
     license = licenses.asl20;

pkgs/development/tools/bazelisk/default.nix

···
-{ stdenv, buildGoModule, fetchFromGitHub }:
+{ lib, stdenv, buildGoModule, fetchFromGitHub }:
 
 buildGoModule rec {
   pname = "bazelisk";
···
 
   buildFlagsArray = [ "-ldflags=-s -w -X main.BazeliskVersion=${version}" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A user-friendly launcher for Bazel";
     longDescription = ''
       BEWARE: This package does not work on NixOS.

pkgs/development/tools/bloaty/default.nix

···
-{ stdenv, cmake, zlib, fetchFromGitHub }:
+{ lib, stdenv, cmake, zlib, fetchFromGitHub }:
 
 stdenv.mkDerivation rec {
   version = "1.1";
···
     install -Dm755 {.,$out/bin}/bloaty
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "a size profiler for binaries";
     homepage = "https://github.com/google/bloaty";
     license = licenses.asl20;

pkgs/development/tools/boost-build/default.nix

···
-{ stdenv, fetchFromGitHub }:
+{ lib, stdenv, fetchFromGitHub }:
 
 stdenv.mkDerivation rec {
   pname = "boost-build";
···
     ./b2 install --prefix=$out
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "http://www.boost.org/boost-build2/";
-    license = stdenv.lib.licenses.boost;
+    license = lib.licenses.boost;
     platforms = platforms.unix;
     maintainers = with maintainers; [ ivan-tkatchev ];
   };

pkgs/development/tools/build-managers/apache-ant/1.9.nix

···
-{ fetchurl, stdenv, coreutils, makeWrapper }:
+{ fetchurl, lib, stdenv, coreutils, makeWrapper }:
 
 let version = "1.9.15"; in
 
···
       by an object that implements a particular Task interface.
     '';
 
-    license = stdenv.lib.licenses.asl20;
-    maintainers = [ stdenv.lib.maintainers.eelco ];
-    platforms = stdenv.lib.platforms.all;
+    license = lib.licenses.asl20;
+    maintainers = [ lib.maintainers.eelco ];
+    platforms = lib.platforms.all;
   };
 }

pkgs/development/tools/build-managers/apache-ant/default.nix

···
-{ fetchurl, stdenv, coreutils, makeWrapper }:
+{ fetchurl, lib, stdenv, coreutils, makeWrapper }:
 
 let version = "1.10.9"; in
 
···
       by an object that implements a particular Task interface.
     '';
 
-    license = stdenv.lib.licenses.asl20;
-    maintainers = [ stdenv.lib.maintainers.eelco ];
-    platforms = stdenv.lib.platforms.all;
+    license = lib.licenses.asl20;
+    maintainers = [ lib.maintainers.eelco ];
+    platforms = lib.platforms.all;
   };
 }

pkgs/development/tools/build-managers/apache-maven/default.nix

···
-{ stdenv, fetchurl, jdk, makeWrapper }:
+{ lib, stdenv, fetchurl, jdk, makeWrapper }:
 
 assert jdk != null;
 
···
 
   inherit jdk;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Build automation tool (used primarily for Java projects)";
     homepage = "http://maven.apache.org/";
     license = licenses.asl20;

pkgs/development/tools/build-managers/arpa2cm/default.nix

···
-{ stdenv, fetchFromGitHub, cmake }:
+{ lib, stdenv, fetchFromGitHub, cmake }:
 
 stdenv.mkDerivation rec {
   pname = "arpa2cm";
···
 
   nativeBuildInputs = [ cmake ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "CMake Module library for the ARPA2 project";
     license = licenses.bsd2;
     maintainers = with maintainers; [ leenaars ];

pkgs/development/tools/build-managers/bam/default.nix

···
-{ stdenv, fetchFromGitHub, lua5_3, python }:
+{ lib, stdenv, fetchFromGitHub, lua5_3, python }:
 
 stdenv.mkDerivation rec {
   pname = "bam";
···
     cp bam "$out/bin"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Yet another build manager";
     maintainers = with maintainers;
     [

pkgs/development/tools/build-managers/bazel/bazel-remote/default.nix

···
 , fetchFromGitHub
 , git
 , go
-, stdenv
+, lib, stdenv
 }:
 
 buildBazelPackage rec {
···
     '';
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/buchgr/bazel-remote";
     description = "A remote HTTP/1.1 cache for Bazel";
     license = licenses.asl20;

pkgs/development/tools/build-managers/bazel/buildtools/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "bazel-buildtools";
···
 
   buildFlagsArray = [ "-ldflags=-s -w -X main.buildVersion=${version} -X main.buildScmRevision=${src.rev}" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Tools for working with Google's bazel buildtool. Includes buildifier, buildozer, and unused_deps";
     homepage = "https://github.com/bazelbuild/buildtools";
     license = licenses.asl20;

pkgs/development/tools/build-managers/bear/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchFromGitHub
 , cmake
 , pkg-config
···
     ./no-double-relative.patch
   ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Tool that generates a compilation database for clang tooling";
     longDescription = ''
       Note: the bear command is very useful to generate compilation commands

pkgs/development/tools/build-managers/bloop/default.nix

···
     installShellCompletion --name bloop.fish --fish ${bloop-fish}
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://scalacenter.github.io/bloop/";
     license = licenses.asl20;
     description = "A Scala build server and command-line tool to make the compile and test developer workflows fast and productive in a build-tool-agnostic way";

pkgs/development/tools/build-managers/bmake/default.nix

···
-{ stdenv, fetchurl
+{ lib, stdenv, fetchurl
 , getopt
 }:
 
···
     ./fix-unexport-env-test.patch
   ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Portable version of NetBSD 'make'";
     homepage    = "http://www.crufty.net/help/sjg/bmake.html";
     license     = licenses.bsd3;

pkgs/development/tools/build-managers/boot/default.nix

···
-{ stdenv, fetchurl, jdk }:
+{ lib, stdenv, fetchurl, jdk }:
 
 stdenv.mkDerivation rec {
   version = "2.7.2";
···
 
   propagatedBuildInputs = [ jdk ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Build tooling for Clojure";
     homepage = "https://boot-clj.com/";
     license = licenses.epl10;

pkgs/development/tools/build-managers/buck/default.nix

···
-{ stdenv, fetchFromGitHub, jdk, ant, python2, python2Packages, watchman, bash, makeWrapper }:
+{ lib, stdenv, fetchFromGitHub, jdk, ant, python2, python2Packages, watchman, bash, makeWrapper }:
 
 stdenv.mkDerivation rec {
   pname = "buck";
···
     install -D -m755 buck-out/gen/programs/buck.pex $out/bin/buck
     wrapProgram $out/bin/buck \
       --prefix PYTHONPATH : $PYTHONPATH \
-      --prefix PATH : "${stdenv.lib.makeBinPath [jdk watchman]}"
+      --prefix PATH : "${lib.makeBinPath [jdk watchman]}"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://buck.build/";
     description = "A high-performance build tool";
     maintainers = [ maintainers.jgertm maintainers.marsam ];

pkgs/development/tools/build-managers/cmake/2.8.nix

···
-{ stdenv, fetchurl, fetchpatch, curl, expat, zlib, bzip2
+{ lib, stdenv, fetchurl, fetchpatch, curl, expat, zlib, bzip2
 , useNcurses ? false, ncurses, useQt4 ? false, qt4, ps
 }:
 
-with stdenv.lib;
+with lib;
 
 assert stdenv ? cc;
 assert stdenv.cc ? libc;
 
 let
-  os = stdenv.lib.optionalString;
+  os = lib.optionalString;
   majorVersion = "2.8";
   minorVersion = "12.2";
   version = "${majorVersion}.${minorVersion}";
···
     "--mandir=/share/man"
     "--system-libs"
     "--no-system-libarchive"
-   ] ++ stdenv.lib.optional useQt4 "--qt-gui";
+   ] ++ lib.optional useQt4 "--qt-gui";
 
   setupHook = ./setup-hook.sh;
 
···
   meta = {
     homepage = "https://cmake.org";
     description = "Cross-Platform Makefile Generator";
-    platforms = if useQt4 then qt4.meta.platforms else stdenv.lib.platforms.unix;
-    maintainers = with stdenv.lib.maintainers; [ xfix ];
-    license = stdenv.lib.licenses.bsd3;
+    platforms = if useQt4 then qt4.meta.platforms else lib.platforms.unix;
+    maintainers = with lib.maintainers; [ xfix ];
+    license = lib.licenses.bsd3;
   };
 }

pkgs/development/tools/build-managers/colormake/default.nix

···
-{ stdenv, fetchFromGitHub, perl }:
+{ lib, stdenv, fetchFromGitHub, perl }:
 
 stdenv.mkDerivation {
   pname = "colormake";
···
     cp -fa colormake.pl colormake colormake-short clmake clmake-short $out/bin
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Simple wrapper around make to colorize the output";
     homepage = "https://bre.klaki.net/programs/colormake/";
     license = licenses.gpl2;

pkgs/development/tools/build-managers/doit/default.nix

···
-{ stdenv, fetchurl, python3Packages }:
+{ lib, stdenv, fetchurl, python3Packages }:
 
 let
 
···
   buildInputs = with python3Packages; [ mock pytest ];
 
   propagatedBuildInputs = with python3Packages; [ cloudpickle ]
-    ++ stdenv.lib.optional stdenv.isLinux pyinotify
-    ++ stdenv.lib.optional stdenv.isDarwin macfsevents;
+    ++ lib.optional stdenv.isLinux pyinotify
+    ++ lib.optional stdenv.isDarwin macfsevents;
 
   # Tests fail due to mysterious gdbm.open() resource temporarily
   # unavailable errors.
   doCheck = false;
   checkPhase = "py.test";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://pydoit.org/";
     description = "A task management & automation tool";
     license = licenses.mit;

pkgs/development/tools/build-managers/dub/default.nix

···
-{ stdenv, fetchFromGitHub, curl, dmd, libevent, rsync }:
+{ lib, stdenv, fetchFromGitHub, curl, dmd, libevent, rsync }:
 
 stdenv.mkDerivation rec {
   pname = "dub";
···
     cp bin/dub $out/bin
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Package and build manager for D applications and libraries";
     homepage = "https://code.dlang.org/";
     license = licenses.mit;

pkgs/development/tools/build-managers/fac/default.nix

···
-{ stdenv, git, fetchFromGitHub, rustPlatform }:
+{ lib, stdenv, git, fetchFromGitHub, rustPlatform }:
 
 rustPlatform.buildRustPackage rec {
   pname = "fac-build";
···
         'std::process::Command::new("${git}/bin/git")'
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = ''
       A build system that uses ptrace to handle dependencies automatically
     '';

pkgs/development/tools/build-managers/gnumake/4.2/default.nix

···
-{ stdenv, fetchurl, guileSupport ? false, pkg-config ? null , guile ? null }:
+{ lib, stdenv, fetchurl, guileSupport ? false, pkg-config ? null , guile ? null }:
 
 assert guileSupport -> ( pkg-config != null && guile != null );
 
···
     ./glibc-2.27-glob.patch
   ];
 
-  nativeBuildInputs = stdenv.lib.optionals guileSupport [ pkg-config ];
-  buildInputs = stdenv.lib.optionals guileSupport [ guile ];
+  nativeBuildInputs = lib.optionals guileSupport [ pkg-config ];
+  buildInputs = lib.optionals guileSupport [ guile ];
 
-  configureFlags = stdenv.lib.optional guileSupport "--with-guile"
+  configureFlags = lib.optional guileSupport "--with-guile"
 
     # Make uses this test to decide whether it should keep track of
     # subseconds. Apple made this possible with APFS and macOS 10.13.
···
     # a second. So, tell Make to ignore nanoseconds in mtime here by
     # overriding the autoconf test for the struct.
     # See https://github.com/NixOS/nixpkgs/issues/51221 for discussion.
-    ++ stdenv.lib.optional stdenv.isDarwin "ac_cv_struct_st_mtim_nsec=no";
+    ++ lib.optional stdenv.isDarwin "ac_cv_struct_st_mtim_nsec=no";
 
   outputs = [ "out" "man" "info" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://www.gnu.org/software/make/";
     description = "A tool to control the generation of non-source files from sources";
     license = licenses.gpl3Plus;

pkgs/development/tools/build-managers/gnumake/default.nix

···
-{ stdenv, fetchurl, guileSupport ? false, pkg-config ? null , guile ? null }:
+{ lib, stdenv, fetchurl, guileSupport ? false, pkg-config ? null , guile ? null }:
 
 assert guileSupport -> ( pkg-config != null && guile != null );
 
···
     ./impure-dirs.patch
   ];
 
-  nativeBuildInputs = stdenv.lib.optionals guileSupport [ pkg-config ];
-  buildInputs = stdenv.lib.optionals guileSupport [ guile ];
+  nativeBuildInputs = lib.optionals guileSupport [ pkg-config ];
+  buildInputs = lib.optionals guileSupport [ guile ];
 
-  configureFlags = stdenv.lib.optional guileSupport "--with-guile"
+  configureFlags = lib.optional guileSupport "--with-guile"
 
     # Make uses this test to decide whether it should keep track of
     # subseconds. Apple made this possible with APFS and macOS 10.13.
···
     # a second. So, tell Make to ignore nanoseconds in mtime here by
     # overriding the autoconf test for the struct.
     # See https://github.com/NixOS/nixpkgs/issues/51221 for discussion.
-    ++ stdenv.lib.optional stdenv.isDarwin "ac_cv_struct_st_mtim_nsec=no";
+    ++ lib.optional stdenv.isDarwin "ac_cv_struct_st_mtim_nsec=no";
 
   outputs = [ "out" "man" "info" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://www.gnu.org/software/make/";
     description = "A tool to control the generation of non-source files from sources";
     license = licenses.gpl3Plus;

pkgs/development/tools/build-managers/gradle/default.nix

···
-{ stdenv, fetchurl, unzip, jdk, java ? jdk, makeWrapper }:
+{ lib, stdenv, fetchurl, unzip, jdk, java ? jdk, makeWrapper }:
 
 rec {
   gradleGen = {name, src, nativeVersion} : stdenv.mkDerivation {
···
         build-by-convention behavior.
       '';
       homepage = "http://www.gradle.org/";
-      license = stdenv.lib.licenses.asl20;
-      platforms = stdenv.lib.platforms.unix;
+      license = lib.licenses.asl20;
+      platforms = lib.platforms.unix;
     };
   };
 

pkgs/development/tools/build-managers/gup/default.nix

···
   meta = {
     inherit (src.meta) homepage;
     description = "A better make, inspired by djb's redo";
-    license = stdenv.lib.licenses.lgpl2Plus;
-    maintainers = [ stdenv.lib.maintainers.timbertson ];
-    platforms = stdenv.lib.platforms.all;
+    license = lib.licenses.lgpl2Plus;
+    maintainers = [ lib.maintainers.timbertson ];
+    platforms = lib.platforms.all;
   };
 }

pkgs/development/tools/build-managers/icmake/default.nix

···
-{ stdenv, fetchFromGitLab, makeWrapper, gcc, ncurses }:
+{ lib, stdenv, fetchFromGitLab, makeWrapper, gcc, ncurses }:
 
 stdenv.mkDerivation rec {
   pname = "icmake";
···
      --prefix PATH : ${ncurses}/bin
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A program maintenance (make) utility using a C-like grammar";
     homepage = "https://fbb-git.gitlab.io/icmake/";
     license = licenses.gpl3;

pkgs/development/tools/build-managers/jam/default.nix

···
-{ stdenv, fetchurl, yacc }:
+{ lib, stdenv, fetchurl, yacc }:
 
 stdenv.mkDerivation rec {
   name = "jam-2.6.1";
···
 
   enableParallelBuilding = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://www.perforce.com/resources/documentation/jam";
     license = licenses.free;
     description = "Just Another Make";

pkgs/development/tools/build-managers/kati/default.nix

···
-{ stdenv, fetchFromGitHub }:
+{ lib, stdenv, fetchFromGitHub }:
 
 stdenv.mkDerivation {
   pname = "kati-unstable";
···
     install -D ckati $out/bin/ckati
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "An experimental GNU make clone";
     homepage = "https://github.com/google/kati";
     platforms = platforms.all;

pkgs/development/tools/build-managers/leiningen/default.nix

···
-{ stdenv, fetchurl, makeWrapper
+{ lib, stdenv, fetchurl, makeWrapper
 , coreutils, jdk, rlwrap, gnupg }:
 
 stdenv.mkDerivation rec {
···
     substituteInPlace $out/bin/lein \
       --replace 'LEIN_JAR=/usr/share/java/leiningen-$LEIN_VERSION-standalone.jar' "LEIN_JAR=$out/share/$JARNAME"
     wrapProgram $out/bin/lein \
-      --prefix PATH ":" "${stdenv.lib.makeBinPath [ rlwrap coreutils ]}" \
+      --prefix PATH ":" "${lib.makeBinPath [ rlwrap coreutils ]}" \
       --set LEIN_GPG ${gnupg}/bin/gpg \
       --set JAVA_CMD ${jdk}/bin/java
   '';
···
   meta = {
     homepage = "https://leiningen.org/";
     description = "Project automation for Clojure";
-    license = stdenv.lib.licenses.epl10;
-    platforms = stdenv.lib.platforms.linux ++ stdenv.lib.platforms.darwin;
-    maintainers = with stdenv.lib.maintainers; [ thiagokokada ];
+    license = lib.licenses.epl10;
+    platforms = lib.platforms.linux ++ lib.platforms.darwin;
+    maintainers = with lib.maintainers; [ thiagokokada ];
   };
 }

pkgs/development/tools/build-managers/mill/default.nix

···
-{ stdenv, fetchurl, jre, makeWrapper }:
+{ lib, stdenv, fetchurl, jre, makeWrapper }:
 
 stdenv.mkDerivation rec {
   pname = "mill";
···
     runHook postInstall
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://www.lihaoyi.com/mill";
     license = licenses.mit;
     description = "A build tool for Scala, Java and more";
···
       modules (written in Java or Scala) or through an external subprocesses.
     '';
     maintainers = with maintainers; [ scalavision ];
-    platforms = stdenv.lib.platforms.all;
+    platforms = lib.platforms.all;
   };
 }

pkgs/development/tools/build-managers/mk/default.nix

···
-{stdenv, fetchurl}:
+{lib, stdenv, fetchurl}:
 
 stdenv.mkDerivation {
   name = "mk-2006-01-31";
···
   builder = ./builder.sh;
 
   meta = {
-    platforms = stdenv.lib.platforms.unix;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/build-managers/msbuild/default.nix

···
-{ stdenv, fetchurl, makeWrapper, glibcLocales, mono, dotnetPackages, unzip, dotnet-sdk }:
+{ lib, stdenv, fetchurl, makeWrapper, glibcLocales, mono, dotnetPackages, unzip, dotnet-sdk }:
 
 let
 
···
 
   # https://github.com/NixOS/nixpkgs/issues/38991
   # bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)
-  LOCALE_ARCHIVE = stdenv.lib.optionalString stdenv.isLinux
+  LOCALE_ARCHIVE = lib.optionalString stdenv.isLinux
       "${glibcLocales}/lib/locale/locale-archive";
 
   buildPhase = ''
···
     ${mono}/bin/mono Helloworld.exe | grep "Hello, world!"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Mono version of Microsoft Build Engine, the build platform for .NET, and Visual Studio";
     homepage = "https://github.com/mono/msbuild";
     license = licenses.mit;

pkgs/development/tools/build-managers/ninja/default.nix

···
-{ stdenv, fetchFromGitHub, fetchpatch, python3, buildDocs ? true, asciidoc, docbook_xml_dtd_45, docbook_xsl, libxslt, re2c }:
+{ lib, stdenv, fetchFromGitHub, fetchpatch, python3, buildDocs ? true, asciidoc, docbook_xml_dtd_45, docbook_xsl, libxslt, re2c }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "ninja";

pkgs/development/tools/build-managers/pants/default.nix

···
-{ stdenv, pythonPackages }:
+{ lib, stdenv, pythonPackages }:
 
-with stdenv.lib;
+with lib;
 with pythonPackages;
 
 buildPythonApplication rec {

pkgs/development/tools/build-managers/qbs/default.nix

···
-{ stdenv, fetchFromGitHub, qmake, qtbase, qtscript }:
+{ lib, stdenv, fetchFromGitHub, qmake, qtbase, qtscript }:
 
 stdenv.mkDerivation rec {
   pname = "qbs";
···
 
   enableParallelBuilding = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A tool that helps simplify the build process for developing projects across multiple platforms";
     homepage = "https://wiki.qt.io/Qbs";
     license = licenses.lgpl3;

pkgs/development/tools/build-managers/rebar/default.nix

···
-{ stdenv, fetchurl, erlang }:
+{ lib, stdenv, fetchurl, erlang }:
 
 
 let
···
       variety of locations (git, hg, etc).
       '';
 
-    platforms = stdenv.lib.platforms.unix;
-    license = stdenv.lib.licenses.asl20;
+    platforms = lib.platforms.unix;
+    license = lib.licenses.asl20;
   };
 }

pkgs/development/tools/build-managers/rebar3/default.nix

···
-{ stdenv, fetchFromGitHub,
+{ lib, stdenv, fetchFromGitHub,
   fetchHex, erlang,
   tree }:
 
···
       variety of locations (hex.pm, git, hg, and so on).
       '';
 
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = with stdenv.lib.maintainers; [ gleber tazjin ];
-    license = stdenv.lib.licenses.asl20;
+    platforms = lib.platforms.unix;
+    maintainers = with lib.maintainers; [ gleber tazjin ];
+    license = lib.licenses.asl20;
   };
 }

pkgs/development/tools/build-managers/redo-apenwarr/default.nix

···
       --replace "/bin/ls" "ls"
 
     substituteInPlace t/110-compile/hello.o.do \
-      --replace "/usr/include" "${stdenv.lib.getDev stdenv.cc.libc}/include"
+      --replace "/usr/include" "${lib.getDev stdenv.cc.libc}/include"
 
     substituteInPlace t/200-shell/nonshelltest.do \
       --replace "/usr/bin/env perl" "${perl}/bin/perl"

pkgs/development/tools/build-managers/redo-c/default.nix

···
-{ stdenv, fetchFromGitHub }:
+{ lib, stdenv, fetchFromGitHub }:
 stdenv.mkDerivation rec {
   pname = "redo-c";
   version = "0.2";
···
     cp '${./Makefile}' Makefile
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "An implementation of the redo build system in portable C with zero dependencies";
     homepage = "https://github.com/leahneukirchen/redo-c";
     license = licenses.cc0;

pkgs/development/tools/build-managers/redo-sh/default.nix

···
-{ stdenv, fetchurl, makeWrapper, coreutils }:
+{ lib, stdenv, fetchurl, makeWrapper, coreutils }:
 
 stdenv.mkDerivation {
   version = "4.0.4";
···
     done
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Redo implementation in Bourne Shell";
     homepage = "http://news.dieweltistgarnichtso.net/bin/redo-sh.html";
     license  = licenses.agpl3;

pkgs/development/tools/build-managers/redo/default.nix

···
-{stdenv, fetchurl, perl }:
+{lib, stdenv, fetchurl, perl }:
 
 stdenv.mkDerivation rec {
   name = "redo-1.4";
···
   meta = {
     homepage = "https://jdebp.eu./Softwares/redo/";
     description = "A system for building target files from source files";
-    license = stdenv.lib.licenses.bsd2;
-    maintainers = [ stdenv.lib.maintainers.vrthra ];
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.bsd2;
+    maintainers = [ lib.maintainers.vrthra ];
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/build-managers/remake/default.nix

···
-{ stdenv, fetchurl, readline }:
+{ lib, stdenv, fetchurl, readline }:
 
 stdenv.mkDerivation rec {
   pname = "remake";
···
 
   meta = {
     homepage = "http://bashdb.sourceforge.net/remake/";
-    license = stdenv.lib.licenses.gpl3;
+    license = lib.licenses.gpl3;
     description = "GNU Make with comprehensible tracing and a debugger";
-    platforms = with stdenv.lib.platforms; linux ++ darwin;
-    maintainers = with stdenv.lib.maintainers; [ bjornfor ];
+    platforms = with lib.platforms; linux ++ darwin;
+    maintainers = with lib.maintainers; [ bjornfor ];
   };
 }

pkgs/development/tools/build-managers/rocm-cmake/default.nix

···
-{ stdenv, fetchFromGitHub, cmake }:
+{ lib, stdenv, fetchFromGitHub, cmake }:
 
 stdenv.mkDerivation rec {
   pname = "rocm-cmake";
···
 
   nativeBuildInputs = [ cmake ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "CMake modules for common build tasks for the ROCm stack";
     homepage = "https://github.com/RadeonOpenCompute/rocm-cmake";
     license = licenses.mit;

pkgs/development/tools/build-managers/samurai/default.nix

···
-{ stdenv, fetchFromGitHub }:
+{ lib, stdenv, fetchFromGitHub }:
 
 stdenv.mkDerivation rec {
   pname = "samurai";
···
 
   makeFlags = [ "DESTDIR=" "PREFIX=${placeholder "out"}" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "ninja-compatible build tool written in C";
     homepage = "https://github.com/michaelforney/samurai";
     license = with licenses; [ mit asl20 ]; # see LICENSE

pkgs/development/tools/build-managers/sbt-extras/default.nix

···
-{ stdenv, fetchFromGitHub, which, curl, makeWrapper, jdk, writeScript
+{ lib, stdenv, fetchFromGitHub, which, curl, makeWrapper, jdk, writeScript
 , common-updater-scripts, cacert, git, nixfmt, nix, jq, coreutils, gnused
 , nixosTests }:
 
···
     install bin/sbt $out/bin
 
     wrapProgram $out/bin/sbt --prefix PATH : ${
-      stdenv.lib.makeBinPath [ which curl ]
+      lib.makeBinPath [ which curl ]
     }
   '';
 
···
       #!${stdenv.shell}
       set -xo errexit
       PATH=${
-        stdenv.lib.makeBinPath [
+        lib.makeBinPath [
           common-updater-scripts
           curl
           cacert
···
     description =
       "A more featureful runner for sbt, the simple/scala/standard build tool";
     homepage = "https://github.com/paulp/sbt-extras";
-    license = stdenv.lib.licenses.bsd3;
-    maintainers = with stdenv.lib.maintainers; [ nequissimus puffnfresh ];
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.bsd3;
+    maintainers = with lib.maintainers; [ nequissimus puffnfresh ];
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/build-managers/sbt/default.nix

···
-{ stdenv, fetchurl, jre, autoPatchelfHook, zlib, writeScript
+{ lib, stdenv, fetchurl, jre, autoPatchelfHook, zlib, writeScript
 , common-updater-scripts, git, nixfmt, nix, coreutils, gnused, nixosTests }:
 
 stdenv.mkDerivation rec {
···
     echo -java-home ${jre.home} >>conf/sbtopts
   '';
 
-  nativeBuildInputs = stdenv.lib.optionals stdenv.isLinux [ autoPatchelfHook ];
+  nativeBuildInputs = lib.optionals stdenv.isLinux [ autoPatchelfHook ];
 
-  buildInputs = stdenv.lib.optionals stdenv.isLinux [ zlib ];
+  buildInputs = lib.optionals stdenv.isLinux [ zlib ];
 
   installPhase = ''
     mkdir -p $out/share/sbt $out/bin
···
     } $out/bin/sbtn
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://www.scala-sbt.org/";
     license = licenses.bsd3;
     description = "A build tool for Scala, Java and more";
···
       #!${stdenv.shell}
       set -o errexit
       PATH=${
-        stdenv.lib.makeBinPath [
+        lib.makeBinPath [
           common-updater-scripts
           git
           nixfmt

pkgs/development/tools/build-managers/scons/common.nix

···
   # The release tarballs don't contain any tests (runtest.py and test/*):
   doCheck = lib.versionOlder version "4.0.0";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "An improved, cross-platform substitute for Make";
     longDescription = ''
       SCons is an Open Source software construction tool. Think of

pkgs/development/tools/build-managers/shards/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchFromGitHub
 , crystal_0_34
 , crystal_0_35
···
       # tries to execute git which fails spectacularly
       doCheck = false;
 
-      meta = with stdenv.lib; {
+      meta = with lib; {
         description = "Dependency manager for the Crystal language";
         license = licenses.asl20;
         maintainers = with maintainers; [ peterhoeg ];

pkgs/development/tools/build-managers/tup/default.nix

···
-{ stdenv, fetchFromGitHub, fuse3, pkg-config, pcre }:
+{ lib, stdenv, fetchFromGitHub, fuse3, pkg-config, pcre }:
 
 stdenv.mkDerivation rec {
   pname = "tup";
···
 
   setupHook = ./setup-hook.sh;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A fast, file-based build system";
     longDescription = ''
       Tup is a file-based build system for Linux, OSX, and Windows. It inputs a list

pkgs/development/tools/build-managers/waf/default.nix

···
-{ stdenv, fetchFromGitLab, python, ensureNewerSourcesForZipFilesHook
+{ lib, stdenv, fetchFromGitLab, python, ensureNewerSourcesForZipFilesHook
 # optional list of extra waf tools, e.g. `[ "doxygen" "pytest" ]`
 , withTools ? null
 }:
 let
-  wafToolsArg = with stdenv.lib.strings;
+  wafToolsArg = with lib.strings;
     optionalString (!isNull withTools) " --tools=\"${concatStringsSep "," withTools}\"";
 in
 stdenv.mkDerivation rec {
···
     install -D waf $out/bin/waf
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Meta build system";
     homepage    = "https://waf.io";
     license     = licenses.bsd3;

pkgs/development/tools/buildkit/default.nix

···
-{ stdenv, fetchFromGitHub, buildGoPackage }:
+{ lib, stdenv, fetchFromGitHub, buildGoPackage }:
 
 buildGoPackage rec {
   pname = "buildkit";
   version = "0.8.1";
 
   goPackagePath = "github.com/moby/buildkit";
-  subPackages = [ "cmd/buildctl" ] ++ stdenv.lib.optionals stdenv.isLinux [ "cmd/buildkitd" ];
+  subPackages = [ "cmd/buildctl" ] ++ lib.optionals stdenv.isLinux [ "cmd/buildkitd" ];
 
   src = fetchFromGitHub {
     owner = "moby";
···
 
   buildFlagsArray = [ "-ldflags=-s -w -X ${goPackagePath}/version.Version=${version} -X ${goPackagePath}/version.Revision=${src.rev}" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Concurrent, cache-efficient, and Dockerfile-agnostic builder toolkit";
     homepage = "https://github.com/moby/buildkit";
     license = licenses.asl20;

pkgs/development/tools/cargo-web/default.nix

···
-{ stdenv, fetchFromGitHub, openssl, perl, pkg-config, rustPlatform
+{ lib, stdenv, fetchFromGitHub, openssl, perl, pkg-config, rustPlatform
 , CoreServices, Security
 }:
 
···
   cargoSha256 = "0i9xp7vd1rp6xgkbbrspm3qq4hxwfwa00di3k73z1x64d3d8r5fm";
 
   nativeBuildInputs = [ openssl perl pkg-config ];
-  buildInputs = stdenv.lib.optionals stdenv.isDarwin [ CoreServices Security ];
+  buildInputs = lib.optionals stdenv.isDarwin [ CoreServices Security ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A Cargo subcommand for the client-side Web";
     homepage = "https://github.com/koute/cargo-web";
     license = with licenses; [ asl20 /* or */ mit ];

pkgs/development/tools/cask/default.nix

···
-{ stdenv, fetchurl, python, emacs }:
+{ lib, stdenv, fetchurl, python, emacs }:
 
 stdenv.mkDerivation rec {
   pname = "cask";
···
     ln -s $out/share/emacs/site-lisp/cask/bin/cask $out/bin/cask
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Project management for Emacs";
     longDescription = ''
       Cask is a project management tool for Emacs that helps automate the

pkgs/development/tools/castxml/default.nix

···
     sha256 = "0ypj67xrgj228myp7l1gsjw1ja97q68nmj98dsd33srmiayqraj4";
   };
 
-  nativeBuildInputs = [ cmake ] ++ stdenv.lib.optionals withMan [ python3Packages.sphinx ];
+  nativeBuildInputs = [ cmake ] ++ lib.optionals withMan [ python3Packages.sphinx ];
 
   clangVersion = lib.getVersion llvmPackages.clang;
 
···
     ctest -E 'cmd.cc-(gnu|msvc)-((c-src-c)|(src-cxx))-cmd'
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/CastXML/CastXML";
     license = licenses.asl20;
     description = "Abstract syntax tree XML output tool";

pkgs/development/tools/cdecl/default.nix

···
-{stdenv, fetchurl, yacc, flex, readline, ncurses, gnused}:
+{lib, stdenv, fetchurl, yacc, flex, readline, ncurses, gnused}:
 
 stdenv.mkDerivation {
   name = "cdecl-2.5";
···
 
   meta = {
     description = "Translator English -- C/C++ declarations";
-    license = stdenv.lib.licenses.publicDomain;
-    maintainers = with stdenv.lib.maintainers; [joelteon];
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.publicDomain;
+    maintainers = with lib.maintainers; [joelteon];
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/chit/default.nix

···
-{ stdenv, fetchFromGitHub, rustPlatform, pkg-config, openssl
+{ lib, stdenv, fetchFromGitHub, rustPlatform, pkg-config, openssl
 , darwin
 }:
 
···
 
   cargoSha256 = "1w25k3bqmmcrhpkw510vbwph0rfmrzi2wby0z2rz1q4k1f9k486m";
 
-  nativeBuildInputs = stdenv.lib.optionals stdenv.isLinux [ pkg-config ];
+  nativeBuildInputs = lib.optionals stdenv.isLinux [ pkg-config ];
   buildInputs = []
-  ++ stdenv.lib.optionals stdenv.isLinux [ openssl ]
-  ++ stdenv.lib.optionals stdenv.isDarwin (with darwin.apple_sdk.frameworks; [ CoreFoundation CoreServices Security ])
+  ++ lib.optionals stdenv.isLinux [ openssl ]
+  ++ lib.optionals stdenv.isDarwin (with darwin.apple_sdk.frameworks; [ CoreFoundation CoreServices Security ])
   ;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Crate help in terminal: A tool for looking up details about rust crates without going to crates.io";
     longDescription = ''
       Chit helps answer these questions:

pkgs/development/tools/clang-tools/default.nix

···
-{ stdenv, llvmPackages }:
+{ lib, stdenv, llvmPackages }:
 
 let
   clang = llvmPackages.clang-unwrapped;
 
 in stdenv.mkDerivation {
   pname = "clang-tools";
-  version = stdenv.lib.getVersion clang;
+  version = lib.getVersion clang;
 
   dontUnpack = true;
 
···
     runHook preInstall
 
     mkdir -p $out/bin
-    export libc_includes="${stdenv.lib.getDev stdenv.cc.libc}/include"
+    export libc_includes="${lib.getDev stdenv.cc.libc}/include"
     export libcpp_includes="${llvmPackages.libcxx}/include/c++/v1"
 
     export clang=${clang}
···
 
   meta = clang.meta // {
     description = "Standalone command line tools for C++ development";
-    maintainers = with stdenv.lib.maintainers; [ aherrmann ];
+    maintainers = with lib.maintainers; [ aherrmann ];
   };
 }

pkgs/development/tools/clog-cli/default.nix

···
-{ fetchFromGitHub, rustPlatform, stdenv }:
+{ fetchFromGitHub, rustPlatform, lib, stdenv }:
 
 with rustPlatform;
 
···
   meta = {
     description = "Generate changelogs from local git metadata";
     homepage = "https://github.com/clog-tool/clog-cli";
-    license = stdenv.lib.licenses.mit;
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = [stdenv.lib.maintainers.nthorne];
+    license = lib.licenses.mit;
+    platforms = lib.platforms.unix;
+    maintainers = [lib.maintainers.nthorne];
   };
 }

pkgs/development/tools/cloudfoundry-cli/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub, fetchurl, installShellFiles }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub, fetchurl, installShellFiles }:
 
 buildGoPackage rec {
   pname = "cloudfoundry-cli";
···
     installShellCompletion --bash $bashCompletionScript
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "The official command line client for Cloud Foundry";
     homepage = "https://github.com/cloudfoundry/cli";
     maintainers = with maintainers; [ ris ];

pkgs/development/tools/clpm/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchgit
 , wrapLisp
 , sbcl
···
   # fixupPhase results in fatal error in SBCL, `Can't find sbcl.core`
   dontFixup = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Common Lisp Package Manager";
     homepage = "https://www.clpm.dev/";
     license = licenses.bsd2;

pkgs/development/tools/cmake-language-server/default.nix

···
   };
 
   # can be removed after v0.1.2
-  patches = stdenv.lib.optional stdenv.isDarwin (fetchpatch {
+  patches = lib.optional stdenv.isDarwin (fetchpatch {
     url = "https://github.com/regen100/cmake-language-server/commit/0ec120f39127f25898ab110b43819e3e9becb8a3.patch";
     sha256 = "1xbmarvsvzd61fnlap4qscnijli2rw2iqr7cyyvar2jd87z6sfp0";
   });

pkgs/development/tools/compile-daemon/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "compile-daemon-unstable";
···
 
   goDeps = ./deps.nix;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Very simple compile daemon for Go";
     license = licenses.bsd2;
     maintainers = with maintainers; [ ];

pkgs/development/tools/continuous-integration/buildkite-agent/default.nix

···
-{ fetchFromGitHub, stdenv, buildGoModule,
+{ fetchFromGitHub, lib, stdenv, buildGoModule,
   makeWrapper, coreutils, git, openssh, bash, gnused, gnugrep }:
 buildGoModule rec {
   name = "buildkite-agent-${version}";
···
 
     # These are runtime dependencies
     wrapProgram $out/bin/buildkite-agent \
-      --prefix PATH : '${stdenv.lib.makeBinPath [ openssh git coreutils gnused gnugrep ]}'
+      --prefix PATH : '${lib.makeBinPath [ openssh git coreutils gnused gnugrep ]}'
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Build runner for buildkite.com";
     longDescription = ''
       The buildkite-agent is a small, reliable, and cross-platform build runner

pkgs/development/tools/continuous-integration/buildkite-agent/generic.nix

···
   nativeBuildInputs = [ makeWrapper ];
 
   postInstall = ''
-    ${stdenv.lib.optionalString hasBootstrapScript ''
+    ${lib.optionalString hasBootstrapScript ''
     # Install bootstrap.sh
     mkdir -p $out/libexec/buildkite-agent
     cp $NIX_BUILD_TOP/go/src/${goPackagePath}/templates/bootstrap.sh $out/libexec/buildkite-agent
···
 
     # These are runtime dependencies
     wrapProgram $out/bin/buildkite-agent \
-      ${stdenv.lib.optionalString hasBootstrapScript "--set BUILDKITE_BOOTSTRAP_SCRIPT_PATH $out/libexec/buildkite-agent/bootstrap.sh"} \
-      --prefix PATH : '${stdenv.lib.makeBinPath [ openssh git coreutils gnused gnugrep ]}'
+      ${lib.optionalString hasBootstrapScript "--set BUILDKITE_BOOTSTRAP_SCRIPT_PATH $out/libexec/buildkite-agent/bootstrap.sh"} \
+      --prefix PATH : '${lib.makeBinPath [ openssh git coreutils gnused gnugrep ]}'
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Build runner for buildkite.com";
     longDescription = ''
       The buildkite-agent is a small, reliable, and cross-platform build runner

pkgs/development/tools/continuous-integration/drone-cli/default.nix

···
-{ stdenv, fetchFromGitHub, buildGoModule }:
+{ lib, stdenv, fetchFromGitHub, buildGoModule }:
 
 let version = "1.2.4";
 in buildGoModule rec {
···
     sha256 = "14sm5k2ifvr4g9369zqgb92vrr4rc0bxf5m52l3g8bd2s8fq8nx8";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     maintainers = with maintainers; [ bricewge ];
     license = licenses.asl20;
     description = "Command line client for the Drone continuous integration server";

pkgs/development/tools/continuous-integration/drone/default.nix

···
-{ stdenv, fetchFromGitHub, buildGoModule }:
+{ lib, stdenv, fetchFromGitHub, buildGoModule }:
 
 buildGoModule rec {
   name = "drone.io-${version}";
···
     sha256 = "sha256-12Jac+mXWdUX8gWvmpdO9ROv7Bi0YzvyqnNDVNJOr34=";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     maintainers = with maintainers; [ elohmeier vdemeester ];
     license = licenses.asl20;
     description = "Continuous Integration platform built on container technology";

pkgs/development/tools/continuous-integration/gocd-agent/default.nix

···
-{ stdenv, fetchurl, unzip }:
+{ lib, stdenv, fetchurl, unzip }:
 
 stdenv.mkDerivation rec {
   name = "gocd-agent-${version}-${rev}";
···
     url = "https://download.go.cd/binaries/${version}-${rev}/generic/go-agent-${version}-${rev}.zip";
     sha256 = "1nirdv82i8x4s1dyb0rmxldh8avappd4g3mbbl6xp7r7s0drcprp";
   };
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A continuous delivery server specializing in advanced workflow modeling and visualization";
     homepage = "http://www.go.cd";
     license = licenses.asl20;

pkgs/development/tools/continuous-integration/gocd-server/default.nix

···
-{ stdenv, fetchurl, unzip }:
+{ lib, stdenv, fetchurl, unzip }:
 
 stdenv.mkDerivation rec {
   name = "gocd-server-${version}-${rev}";
···
     sha256 = "0c30qzd6awlw0zx91rk6na0mmgykqkgrw9ychx18ivjwma0hr0sc";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A continuous delivery server specializing in advanced workflow modeling and visualization";
     homepage = "http://www.go.cd";
     license = licenses.asl20;

pkgs/development/tools/continuous-integration/jenkins/default.nix

···
-{ stdenv, fetchurl, common-updater-scripts, coreutils, git, gnused, nix, nixfmt
+{ lib, stdenv, fetchurl, common-updater-scripts, coreutils, git, gnused, nix, nixfmt
 , writeScript, nixosTests, jq, cacert, curl }:
 
 stdenv.mkDerivation rec {
···
       #!${stdenv.shell}
       set -o errexit
       PATH=${
-        stdenv.lib.makeBinPath [
+        lib.makeBinPath [
           cacert
           common-updater-scripts
           coreutils
···
     '';
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "An extendable open source continuous integration server";
     homepage = "https://jenkins-ci.org";
     license = licenses.mit;

pkgs/development/tools/continuous-integration/laminar/default.nix

···
     rm -r $out/lib # it contains only systemd unit file
   '');
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Lightweight and modular continuous integration service";
     homepage = "https://laminar.ohwg.net";
     license = licenses.gpl3;

pkgs/development/tools/corgi/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   name = "corgi-${rev}";
···
 
   goDeps = ./deps.nix;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "CLI workflow manager";
     longDescription = ''
       Corgi is a command-line tool that helps with your repetitive command usages by organizing them into reusable snippet.

pkgs/development/tools/coursier/default.nix

···
-{ stdenv, fetchurl, makeWrapper, jre, writeScript, common-updater-scripts
+{ lib, stdenv, fetchurl, makeWrapper, jre, writeScript, common-updater-scripts
 , coreutils, git, gnused, nix, nixfmt }:
 
 let
···
     #!${stdenv.shell}
     set -o errexit
     PATH=${
-      stdenv.lib.makeBinPath [
+      lib.makeBinPath [
         common-updater-scripts
         coreutils
         git
···
     fi
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://get-coursier.io/";
     description =
       "A Scala library to fetch dependencies from Maven / Ivy repositories";

pkgs/development/tools/cppclean/default.nix

···
-{ stdenv, fetchFromGitHub, python3Packages }:
+{ lib, stdenv, fetchFromGitHub, python3Packages }:
 
 with python3Packages;
 
···
     ./test.bash
     '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Finds problems in C++ source that slow development of large code bases";
     homepage    = "https://github.com/myint/cppclean";
     license     = licenses.asl20;

pkgs/development/tools/cue/default.nix

···
-{ buildGoModule, fetchgit, stdenv }:
+{ buildGoModule, fetchgit, lib, stdenv }:
 
 buildGoModule rec {
   pname = "cue";
···
   meta = {
     description = "A data constraint language which aims to simplify tasks involving defining and using data";
     homepage = "https://cuelang.org/";
-    maintainers = with stdenv.lib.maintainers; [ solson ];
-    license = stdenv.lib.licenses.asl20;
+    maintainers = with lib.maintainers; [ solson ];
+    license = lib.licenses.asl20;
   };
 }

pkgs/development/tools/database/dbmate/default.nix

···
-{ stdenv, buildGoModule, fetchFromGitHub }:
+{ lib, stdenv, buildGoModule, fetchFromGitHub }:
 
 buildGoModule rec {
   pname = "dbmate";
···
 
   doCheck = false;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Database migration tool";
     homepage = "https://github.com/amacneil/dbmate";
     license = licenses.mit;

pkgs/development/tools/database/ephemeralpg/default.nix

···
-{ stdenv, fetchurl, postgresql, getopt, makeWrapper }:
+{ lib, stdenv, fetchurl, postgresql, getopt, makeWrapper }:
 stdenv.mkDerivation rec {
   pname = "ephemeralpg";
   version = "3.1";
···
   installPhase = ''
     mkdir -p $out
     PREFIX=$out make install
-    wrapProgram $out/bin/pg_tmp --prefix PATH : ${stdenv.lib.makeBinPath [ postgresql getopt ]}
+    wrapProgram $out/bin/pg_tmp --prefix PATH : ${lib.makeBinPath [ postgresql getopt ]}
   '';
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Run tests on an isolated, temporary PostgreSQL database";
     license = licenses.isc;
     homepage = "http://ephemeralpg.org/";

pkgs/development/tools/database/pg_checksums/default.nix

···
-{ stdenv, fetchFromGitHub, libxslt, docbook_xsl, postgresql }:
+{ lib, stdenv, fetchFromGitHub, libxslt, docbook_xsl, postgresql }:
 
 stdenv.mkDerivation rec {
   pname = "pg_checksums";
···
     install -Dm644 -t $out/share/man/man1 doc/man1/pg_checksums.1
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Activate/deactivate/verify checksums in offline PostgreSQL clusters";
     homepage = "https://github.com/credativ/pg_checksums";
     maintainers = [ maintainers.marsam ];

pkgs/development/tools/database/pgcli/default.nix

···
-{ stdenv
+{ lib, stdenv
 , buildPythonApplication
 , fetchPypi
 , isPy3k
···
 
   checkInputs = [ pytestCheckHook mock ];
 
-  disabledTests = stdenv.lib.optionals stdenv.isDarwin [ "test_application_name_db_uri" ];
+  disabledTests = lib.optionals stdenv.isDarwin [ "test_application_name_db_uri" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Command-line interface for PostgreSQL";
     longDescription = ''
       Rich command-line interface for PostgreSQL with auto-completion and

pkgs/development/tools/database/pyrseas/default.nix

···
-{ stdenv, pythonPackages, fetchFromGitHub }:
+{ lib, stdenv, pythonPackages, fetchFromGitHub }:
 
 let
   pgdbconn = pythonPackages.buildPythonPackage {
···
   meta = {
     description = "A declarative language to describe PostgreSQL databases";
     homepage = "https://perseas.github.io/";
-    license = stdenv.lib.licenses.bsd3;
-    maintainers = with stdenv.lib.maintainers; [ pmeunier ];
+    license = lib.licenses.bsd3;
+    maintainers = with lib.maintainers; [ pmeunier ];
   };
 }

pkgs/development/tools/database/shmig/default.nix

···
     mkdir -p $out/bin
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Minimalistic database migration tool with MySQL, PostgreSQL and SQLite support";
     homepage = "https://github.com/mbucc/shmig";
     license = licenses.bsd3;

pkgs/development/tools/database/sqlcheck/default.nix

···
-{ stdenv, fetchFromGitHub, cmake }:
+{ lib, stdenv, fetchFromGitHub, cmake }:
 
 stdenv.mkDerivation rec {
   pname = "sqlcheck";
···
 
   doCheck = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     inherit (src.meta) homepage;
     description = "Automatically identify anti-patterns in SQL queries";
     license = licenses.asl20;

pkgs/development/tools/database/sqldeveloper/default.nix

···
-{ stdenv, makeDesktopItem, makeWrapper, requireFile, unzip, jdk }:
+{ lib, stdenv, makeDesktopItem, makeWrapper, requireFile, unzip, jdk }:
 
 let
   version = "20.2.0.175.1842";
···
       --run "cd $out/libexec/sqldeveloper/bin"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Oracle's Oracle DB GUI client";
     longDescription = ''
       Oracle SQL Developer is a free integrated development environment that

pkgs/development/tools/database/squirrel-sql/default.nix

···
 # To enable specific database drivers, override this derivation and pass the
 # driver packages in the drivers argument (e.g. mysql_jdbc, postgresql_jdbc).
-{ stdenv, fetchurl, makeDesktopItem, makeWrapper, unzip
+{ lib, stdenv, fetchurl, makeDesktopItem, makeWrapper, unzip
 , jre
 , drivers ? []
 }:
···
     icon = "squirrel-sql";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Universal SQL Client";
     homepage = "http://squirrel-sql.sourceforge.net/";
     license = licenses.lgpl21;

pkgs/development/tools/database/timescaledb-parallel-copy/default.nix

···
-{ stdenv, buildGoModule, fetchFromGitHub }:
+{ lib, stdenv, buildGoModule, fetchFromGitHub }:
 
 buildGoModule rec {
   pname = "timescaledb-parallel-copy";
···
 
   vendorSha256 = "03siay3hv1sgmmp7w4f9b0xb8c6bnbx0v4wy5grjl5k04zhnj76b";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Bulk, parallel insert of CSV records into PostgreSQL";
     homepage = "https://github.com/timescale/timescaledb-parallel-copy";
     license = licenses.asl20;

pkgs/development/tools/database/timescaledb-tune/default.nix

···
-{ stdenv, buildGoModule, fetchFromGitHub }:
+{ lib, stdenv, buildGoModule, fetchFromGitHub }:
 
 buildGoModule rec {
   pname = "timescaledb-tune";
···
 
   vendorSha256 = "0hbpprbxs19fcar7xcy42kn9yfzhal2zsv5pml9ghiv2s61yns4z";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A tool for tuning your TimescaleDB for better performance";
     homepage = "https://github.com/timescale/timescaledb-tune";
     license = licenses.asl20;

pkgs/development/tools/database/webdis/default.nix

···
-{ stdenv, fetchFromGitHub, hiredis, http-parser, jansson, libevent, fetchpatch }:
+{ lib, stdenv, fetchFromGitHub, hiredis, http-parser, jansson, libevent, fetchpatch }:
 
 stdenv.mkDerivation rec {
   pname = "webdis";
···
     "CONFDIR=${placeholder "out"}/share/webdis"
   ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A Redis HTTP interface with JSON output";
     homepage = "https://webd.is/";
     license = licenses.bsd2;

pkgs/development/tools/dcadec/default.nix

···
-{ stdenv, fetchFromGitHub }:
+{ lib, stdenv, fetchFromGitHub }:
 
 stdenv.mkDerivation rec {
   pname = "dcadec";
···
 
   doCheck = false; # fails with "ERROR: Run 'git submodule update --init test/samples' first."
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "DTS Coherent Acoustics decoder with support for HD extensions";
     maintainers = with maintainers; [ edwtjo ];
     homepage = "https://github.com/foo86/dcadec";

pkgs/development/tools/deis/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "deis";
···
     export GOPATH=$GOPATH:$NIX_BUILD_TOP/go/src/${goPackagePath}/Godeps/_workspace
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://deis.io";
     description = "A command line utility used to interact with the Deis open source PaaS";
     license = licenses.asl20;

pkgs/development/tools/deisctl/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "deis";
···
     export GOPATH=$GOPATH:$NIX_BUILD_TOP/go/src/${goPackagePath}/Godeps/_workspace
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://deis.io";
     description = "A command-line utility used to provision and operate a Deis cluster";
     license = licenses.asl20;

pkgs/development/tools/delve/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "delve";
···
     sha256 = "10zvla2jqxqibxdk3zbnsxg63i0zcwcn9npvw3bbicwd2z4vvskk";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "debugger for the Go programming language";
     homepage = "https://github.com/derekparker/delve";
     maintainers = with maintainers; [ vdemeester ];

pkgs/development/tools/dep/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "dep";
···
 
   buildFlagsArray = ("-ldflags=-s -w -X main.commitHash=${rev} -X main.version=${version}");
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/golang/dep";
     description = "Go dependency management tool";
     license = licenses.bsd3;

pkgs/development/tools/devd/default.nix

···
-{ buildGoPackage, fetchFromGitHub, stdenv }:
+{ buildGoPackage, fetchFromGitHub, lib, stdenv }:
 
 buildGoPackage rec {
   pname = "devd";
···
   };
   goPackagePath = "github.com/cortesi/devd";
   subPackages = [ "cmd/devd" ];
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A local webserver for developers";
     homepage = "https://github.com/cortesi/devd";
     license = licenses.mit;

pkgs/development/tools/devpi-client/default.nix

···
-{ stdenv
+{ lib, stdenv
 , buildPythonApplication
 , fetchPypi
 # buildInputs
···
 
   LC_ALL = "en_US.UTF-8";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "http://doc.devpi.net";
     description = "Client for devpi, a pypi index server and packaging meta tool";
     license = licenses.mit;

pkgs/development/tools/devpi-server/default.nix

···
-{ stdenv, fetchFromGitHub, python3Packages, nginx }:
+{ lib, stdenv, fetchFromGitHub, python3Packages, nginx }:
 
 python3Packages.buildPythonApplication rec {
   pname = "devpi-server";
···
     pytestCheckHook
     pytest-flake8
     webtest
-  ] ++ stdenv.lib.optionals isPy27 [ mock ];
+  ] ++ lib.optionals isPy27 [ mock ];
 
   # root_passwd_hash tries to write to store
   # TestMirrorIndexThings tries to write to /var through ngnix
···
     "TestMirrorIndexThings"
   ];
 
-  meta = with stdenv.lib;{
+  meta = with lib;{
     homepage = "http://doc.devpi.net";
     description = "Github-style pypi index server and packaging meta tool";
     license = licenses.mit;

pkgs/development/tools/devtodo/default.nix

···
-{ stdenv, fetchurl, readline, ncurses }:
+{ lib, stdenv, fetchurl, readline, ncurses }:
 
 stdenv.mkDerivation rec {
   pname = "devtodo";
···
 
   enableParallelBuilding = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://swapoff.org/devtodo1.html";
     description = "A hierarchical command-line task manager";
     license = licenses.gpl2;

pkgs/development/tools/diesel-cli/default.nix

···
   "support for at least one database must be enabled";
 
 let
-  inherit (stdenv.lib) optional optionals optionalString;
+  inherit (lib) optional optionals optionalString;
   features = ''
     ${optionalString sqliteSupport "sqlite"} \
     ${optionalString postgresqlSupport "postgres"} \

pkgs/development/tools/dive/default.nix

···
-{ stdenv, buildGoModule, fetchFromGitHub, pkg-config, btrfs-progs, gpgme, lvm2 }:
+{ lib, stdenv, buildGoModule, fetchFromGitHub, pkg-config, btrfs-progs, gpgme, lvm2 }:
 
 buildGoModule rec {
   pname = "dive";
···
 
   nativeBuildInputs = [ pkg-config ];
 
-  buildInputs = stdenv.lib.optionals stdenv.isLinux [ btrfs-progs gpgme lvm2 ];
+  buildInputs = lib.optionals stdenv.isLinux [ btrfs-progs gpgme lvm2 ];
 
   buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A tool for exploring each layer in a docker image";
     homepage = "https://github.com/wagoodman/dive";
     license = licenses.mit;

pkgs/development/tools/documentation/antora/default.nix

···
-{ stdenv, nodePackages }:
+{ lib, stdenv, nodePackages }:
 
 let
   linkNodeDeps = ({ pkg, deps, name ? "" }:
     let
-      targetModule = if name != "" then name else stdenv.lib.getName pkg;
+      targetModule = if name != "" then name else lib.getName pkg;
     in nodePackages.${pkg}.override (oldAttrs: {
       postInstall = ''
         mkdir -p $out/lib/node_modules/${targetModule}/node_modules
-        ${stdenv.lib.concatStringsSep "\n" (map (dep: ''
-          ln -s ${nodePackages.${dep}}/lib/node_modules/${stdenv.lib.getName dep} \
-            $out/lib/node_modules/${targetModule}/node_modules/${stdenv.lib.getName dep}
+        ${lib.concatStringsSep "\n" (map (dep: ''
+          ln -s ${nodePackages.${dep}}/lib/node_modules/${lib.getName dep} \
+            $out/lib/node_modules/${targetModule}/node_modules/${lib.getName dep}
         '') deps
         )}
       '';

pkgs/development/tools/documentation/doxygen/default.nix

···
-{ stdenv, cmake, fetchFromGitHub, python3, flex, bison, qt5, CoreServices, libiconv }:
+{ lib, stdenv, cmake, fetchFromGitHub, python3, flex, bison, qt5, CoreServices, libiconv }:
 
 stdenv.mkDerivation rec {
   pname = "doxygen";
···
   src = fetchFromGitHub {
     owner = "doxygen";
     repo = "doxygen";
-    rev = "Release_${stdenv.lib.replaceStrings [ "." ] [ "_" ] version}";
+    rev = "Release_${lib.replaceStrings [ "." ] [ "_" ] version}";
     sha256 = "17chvi3i80rj4750smpizf562xjzd2xcv5rfyh997pyvc1zbq5rh";
   };
 
···
   ];
 
   buildInputs =
-       stdenv.lib.optionals (qt5 != null) (with qt5; [ qtbase wrapQtAppsHook ])
-    ++ stdenv.lib.optional stdenv.isSunOS libiconv
-    ++ stdenv.lib.optionals stdenv.isDarwin [ CoreServices libiconv ];
+       lib.optionals (qt5 != null) (with qt5; [ qtbase wrapQtAppsHook ])
+    ++ lib.optional stdenv.isSunOS libiconv
+    ++ lib.optionals stdenv.isDarwin [ CoreServices libiconv ];
 
   cmakeFlags =
     [ "-DICONV_INCLUDE_DIR=${libiconv}/include" ] ++
-    stdenv.lib.optional (qt5 != null) "-Dbuild_wizard=YES";
+    lib.optional (qt5 != null) "-Dbuild_wizard=YES";
 
   NIX_CFLAGS_COMPILE =
-    stdenv.lib.optionalString stdenv.isDarwin "-mmacosx-version-min=10.9";
+    lib.optionalString stdenv.isDarwin "-mmacosx-version-min=10.9";
 
   enableParallelBuilding = false;
 
   meta = {
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
     homepage = "http://doxygen.nl/";
     description = "Source code documentation generator tool";
 
···
       manual (in LaTeX) from a set of documented source files.
     '';
 
-    platforms = if qt5 != null then stdenv.lib.platforms.linux else stdenv.lib.platforms.unix;
+    platforms = if qt5 != null then lib.platforms.linux else lib.platforms.unix;
   };
 }

pkgs/development/tools/documentation/gnome-doc-utils/default.nix

···
-{ stdenv, fetchurl, pkg-config, libxml2Python, libxslt, intltool, gnome3
+{ lib, stdenv, fetchurl, pkg-config, libxml2Python, libxslt, intltool, gnome3
 , python2Packages }:
 
 python2Packages.buildPythonApplication rec {
···
   format = "other";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "19n4x25ndzngaciiyd8dd6s2mf9gv6nv3wv27ggns2smm7zkj1nb";
   };
 
···
     rm $out/nix-support/propagated-build-inputs
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Collection of documentation utilities for the GNOME project";
     homepage = "https://gitlab.gnome.org/GNOME/gnome-doc-utils";
     license = with licenses; [ gpl2Plus lgpl2Plus ];

pkgs/development/tools/documentation/gtk-doc/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchFromGitLab
 , meson
 , ninja
···
     docbook_xml_dtd_43
     docbook_xsl
     libxslt
-  ] ++ stdenv.lib.optionals withDblatex [
+  ] ++ lib.optionals withDblatex [
     dblatex
   ];
 
···
     };
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Tools to extract documentation embedded in GTK and GNOME source code";
     homepage = "https://www.gtk.org/gtk-doc";
     license = licenses.gpl2;

pkgs/development/tools/documentation/mdsh/default.nix

···
-{ stdenv, fetchFromGitHub, rustPlatform }:
+{ lib, stdenv, fetchFromGitHub, rustPlatform }:
 
 rustPlatform.buildRustPackage rec {
   pname = "mdsh";
···
 
   cargoSha256 = "118ykkqlf0x6gcgywx4pg3qawfhfr5q5f51gvrw9s302c1lmgk3g";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Markdown shell pre-processor";
     homepage = "https://github.com/zimbatm/mdsh";
     license = with licenses; [ mit ];

pkgs/development/tools/documentation/mkdocs/default.nix

···
     backports_tempfile
   ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Project documentation with Markdown / static website generator";
     longDescription = ''
       MkDocs is a fast, simple and downright gorgeous static site generator that's

pkgs/development/tools/dot-http/default.nix

···
 
   nativeBuildInputs = [ pkg-config ];
 
-  buildInputs = [ openssl ] ++ stdenv.lib.optionals stdenv.isDarwin [
+  buildInputs = [ openssl ] ++ lib.optionals stdenv.isDarwin [
     libiconv Security
   ];
 

pkgs/development/tools/drip/default.nix

···
-{ stdenv, fetchFromGitHub, jdk8, which, makeWrapper }:
+{ lib, stdenv, fetchFromGitHub, jdk8, which, makeWrapper }:
 
 stdenv.mkDerivation rec {
   pname = "drip";
···
     runHook postInstall
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A launcher for the Java Virtual Machine intended to be a drop-in replacement for the java command, only faster";
     license = licenses.epl10;
     homepage = "https://github.com/ninjudd/drip";

pkgs/development/tools/drm_info/default.nix

···
-{ stdenv, fetchFromGitHub
+{ lib, stdenv, fetchFromGitHub
 , libdrm, json_c, pciutils
 , meson, ninja, pkg-config
 }:
···
   nativeBuildInputs = [ meson ninja pkg-config ];
   buildInputs = [ libdrm json_c pciutils ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Small utility to dump info about DRM devices";
     homepage = "https://github.com/ascent12/drm_info";
     license = licenses.mit;

pkgs/development/tools/dtools/default.nix

···
       $makeCmd INSTALL_DIR=$out install
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Ancillary tools for the D programming language compiler";
     homepage = "https://github.com/dlang/tools";
     license = lib.licenses.boost;
     maintainers = with maintainers; [ ThomasMader ];
-    platforms = stdenv.lib.platforms.unix;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/easyjson/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage {
   pname = "easyjson";
···
     sha256 = "0q85h383mhbkcjm2vqm72bi8n2252fv3c56q3lclzb8n2crnjcdk";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/mailru/easyjson";
     description = "Fast JSON serializer for golang";
     license = licenses.mit;

pkgs/development/tools/eclipse-mat/default.nix

···
     libCairo=$out/eclipse/libcairo-swt.so
     patchelf --set-interpreter $interpreter $out/mat/MemoryAnalyzer
     [ -f $libCairo ] && patchelf --set-rpath ${
-      stdenv.lib.makeLibraryPath [ freetype fontconfig libX11 libXrender zlib ]
+      lib.makeLibraryPath [ freetype fontconfig libX11 libXrender zlib ]
     } $libCairo
 
     # Create wrapper script.  Pass -configuration to store settings in ~/.eclipse-mat/<version>
     makeWrapper $out/mat/MemoryAnalyzer $out/bin/eclipse-mat \
       --prefix PATH : ${jdk}/bin \
-      --prefix LD_LIBRARY_PATH : ${stdenv.lib.makeLibraryPath ([ glib gtk3 libXtst webkitgtk ])} \
+      --prefix LD_LIBRARY_PATH : ${lib.makeLibraryPath ([ glib gtk3 libXtst webkitgtk ])} \
       --prefix XDG_DATA_DIRS : "$GSETTINGS_SCHEMAS_PATH" \
       --add-flags "-configuration \$HOME/.eclipse-mat/''${version}/configuration"
 

pkgs/development/tools/electron/default.nix

···
-{ stdenv
+{ lib, stdenv
 , libXScrnSaver
 , makeWrapper
 , fetchurl

pkgs/development/tools/electron/generic.nix

···
-{ stdenv
+{ lib, stdenv
 , libXScrnSaver
 , makeWrapper
 , fetchurl
···
 let
   name = "electron-${version}";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Cross platform desktop application shell";
     homepage = "https://github.com/electron/electron";
     license = licenses.mit;
···
     passthru.headers = headersFetcher version hashes.headers;
   };
 
-  electronLibPath = with stdenv.lib; makeLibraryPath (
+  electronLibPath = with lib; makeLibraryPath (
     [ libuuid at-spi2-atk at-spi2-core libappindicator-gtk3 ]
     ++ optionals (! versionOlder version "9.0.0") [ libdrm mesa ]
     ++ optionals (! versionOlder version "11.0.0") [ libxkbcommon ]
···
         $out/lib/electron/electron
 
       wrapProgram $out/lib/electron/electron \
-        --prefix LD_PRELOAD : ${stdenv.lib.makeLibraryPath [ libXScrnSaver ]}/libXss.so.1 \
+        --prefix LD_PRELOAD : ${lib.makeLibraryPath [ libXScrnSaver ]}/libXss.so.1 \
         "''${gappsWrapperArgs[@]}"
     '';
   };

pkgs/development/tools/erlang/cuter/default.nix

···
-{ stdenv, autoreconfHook, which, writeText, makeWrapper, fetchFromGitHub, erlang
+{ lib, stdenv, autoreconfHook, which, writeText, makeWrapper, fetchFromGitHub, erlang
 , z3, python }:
 
 stdenv.mkDerivation rec {
···
 
   meta = {
     description = "A concolic testing tool for the Erlang functional programming language";
-    license = stdenv.lib.licenses.gpl3;
+    license = lib.licenses.gpl3;
     homepage = "https://github.com/aggelgian/cuter";
-    maintainers = with stdenv.lib.maintainers; [ ericbmerritt ];
-    platforms = with stdenv.lib.platforms; unix;
+    maintainers = with lib.maintainers; [ ericbmerritt ];
+    platforms = with lib.platforms; unix;
   };
 }

pkgs/development/tools/fac/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub, makeWrapper, git }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub, makeWrapper, git }:
 
 buildGoPackage rec {
   pname = "fac";
···
     install -D go/src/${goPackagePath}/assets/doc/fac.1 $out/share/man/man1/fac.1
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "CUI for fixing git conflicts";
     inherit (src.meta) homepage;
     license = licenses.mit;

pkgs/development/tools/fedpkg/default.nix

···
-{ stdenv, buildPythonApplication, buildPythonPackage, isPy3k, fetchurl, rpkg, offtrac, urlgrabber, pyopenssl, python_fedora }:
+{ lib, stdenv, buildPythonApplication, buildPythonPackage, isPy3k, fetchurl, rpkg, offtrac, urlgrabber, pyopenssl, python_fedora }:
 
 let
   fedora_cert = buildPythonPackage rec {
···
   patches = [ ./fix-paths.patch ];
   propagatedBuildInputs = [ rpkg offtrac urlgrabber fedora_cert ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Subclass of the rpkg project for dealing with rpm packaging";
     homepage = "https://pagure.io/fedpkg";
     license = licenses.gpl2;

pkgs/development/tools/flamegraph/default.nix

···
-{ stdenv, fetchFromGitHub, perl }:
+{ lib, stdenv, fetchFromGitHub, perl }:
 
 stdenv.mkDerivation rec {
   pname = "FlameGraph";
···
     runHook postInstall
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     license = with licenses; [ asl20 cddl gpl2Plus ];
     homepage = "http://www.brendangregg.com/flamegraphs.html";
     description = "Visualization for profiled code";

pkgs/development/tools/flatpak-builder/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchurl
 , substituteAll
 , nixosTests
···
     };
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Tool to build flatpaks from source";
     homepage = "https://github.com/flatpak/flatpak-builder";
     license = licenses.lgpl21Plus;

pkgs/development/tools/flootty/default.nix

···
-{ stdenv, python3Packages }:
+{ lib, stdenv, python3Packages }:
 
 python3Packages.buildPythonApplication rec {
   pname = "Flootty";
···
     sha256 = "0gfl143ly81pmmrcml91yr0ypvwrs5q4s1sfdc0l2qkqpy233ih7";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A collaborative terminal. In practice, it's similar to a shared screen or tmux session";
     homepage = "https://floobits.com/help/flootty";
     license = licenses.asl20;

pkgs/development/tools/flyway/default.nix

···
-{ stdenv, fetchurl, jre_headless, makeWrapper }:
+{ lib, stdenv, fetchurl, jre_headless, makeWrapper }:
   let
     version = "7.3.1";
   in
···
           --add-flags "org.flywaydb.commandline.Main" \
           --add-flags "-jarDirs='$out/share/flyway/jars'"
       '';
-      meta = with stdenv.lib; {
+      meta = with lib; {
         description = "Evolve your Database Schema easily and reliably across all your instances";
         longDescription = ''
           The Flyway command-line tool is a standalone Flyway distribution.

pkgs/development/tools/fmbt/default.nix

···
-{ stdenv, fetchFromGitHub, python, autoreconfHook, pkg-config, makeWrapper
+{ lib, stdenv, fetchFromGitHub, python, autoreconfHook, pkg-config, makeWrapper
 , flex
 , gettext, libedit, glib, imagemagick, libxml2, boost, gnuplot, graphviz
 , tesseract, gts, libXtst
···
   preBuild = ''
     export PYTHONPATH="$PYTHONPATH:$out/lib/python${python.pythonVersion}/site-packages"
     export PATH="$PATH:$out/bin"
-    export LD_LIBRARY_PATH="${stdenv.lib.makeLibraryPath [libXtst]}"
+    export LD_LIBRARY_PATH="${lib.makeLibraryPath [libXtst]}"
   '';
 
   postInstall = ''
···
     done
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Free Model-Based Testing tool";
     homepage = "https://github.com/intel/fMBT";
     license = licenses.lgpl21;

pkgs/development/tools/fusee-launcher/default.nix

···
-{ stdenv
+{ lib, stdenv
 , python3Packages
 , python3
 , fetchFromGitHub
···
   buildInputs = [ python3 python3Packages.pyusb ];
   pythonPath = with python3Packages; [ pyusb ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/Cease-and-DeSwitch/fusee-launcher";
     description = "Work-in-progress launcher for one of the Tegra X1 bootROM exploits";
     license = licenses.gpl2;

pkgs/development/tools/galen/default.nix

···
-{ stdenv, fetchurl, jre8, unzip }:
+{ lib, stdenv, fetchurl, jre8, unzip }:
 
 stdenv.mkDerivation rec {
   pname = "galen";
···
   cp galen.jar $out/bin
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "http://galenframework.com";
     description = "Automated layout testing for websites";
     license = licenses.asl20;

pkgs/development/tools/gamecube-tools/default.nix

···
-{ stdenv, fetchFromGitHub, autoreconfHook
+{ lib, stdenv, fetchFromGitHub, autoreconfHook
 , freeimage, libGL }:
 
 stdenv.mkDerivation rec {
···
     sha256 = "0zvpkzqvl8iv4ndzhkjkmrzpampyzgb91spv0h2x2arl8zy4z7ca";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Tools for gamecube/wii projects";
     homepage = "https://github.com/devkitPro/gamecube-tools/";
     license = licenses.gpl2;

pkgs/development/tools/gauge/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "gauge";
···
     sha256 = "02yrk4d5mm4j2grlhqkf4grxawx91kd2vhdn7k5wd2dl6wsnlgcl";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
    description = "Light weight cross-platform test automation";
    homepage    = "https://gauge.org";
    license     = licenses.gpl3;

pkgs/development/tools/gdm/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "gdm";
···
 
   goDeps = ./deps.nix;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Minimalist dependency manager for Go written in Go";
     homepage = "https://github.com/sparrc/gdm";
     license = licenses.unlicense;

pkgs/development/tools/git-ftp/default.nix

···
-{ stdenv, fetchFromGitHub, pandoc, man }:
+{ lib, stdenv, fetchFromGitHub, pandoc, man }:
 stdenv.mkDerivation rec {
   pname = "git-ftp";
   version = "1.6.0";
···
 
   buildInputs = [pandoc man];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Git powered FTP client written as shell script";
     homepage = "https://git-ftp.github.io/";
     license = licenses.gpl3;

pkgs/development/tools/git-quick-stats/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchFromGitHub
 , makeWrapper
 , coreutils
···
 
   postInstall =
     let
-      path = stdenv.lib.makeBinPath [
+      path = lib.makeBinPath [
         coreutils
         gawk
         git
···
       wrapProgram $out/bin/git-quick-stats --suffix PATH : ${path}
     '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/arzzen/git-quick-stats";
     description = "A simple and efficient way to access various statistics in git repository";
     platforms = platforms.all;

pkgs/development/tools/git-series/default.nix

···
-{ stdenv, fetchFromGitHub, fetchpatch, rustPlatform
+{ lib, stdenv, fetchFromGitHub, fetchpatch, rustPlatform
 , openssl, cmake, perl, pkg-config, zlib, curl, libgit2, libssh2
 }:
 
···
     install -D "$src/git-series.1" "$out/man/man1/git-series.1"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A tool to help with formatting git patches for review on mailing lists";
     longDescription = ''
           git series tracks changes to a patch series over time. git

pkgs/development/tools/github/cligh/default.nix

···
-{ stdenv, fetchFromGitHub, buildPythonApplication, pyxdg, PyGithub }:
+{ lib, stdenv, fetchFromGitHub, buildPythonApplication, pyxdg, PyGithub }:
 
 buildPythonApplication rec {
   pname = "cligh";
···
 
   propagatedBuildInputs = [ pyxdg PyGithub ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "http://the-brannons.com/software/cligh.html";
     description = "A simple command-line interface to the facilities of Github";
     longDescription = ''

pkgs/development/tools/github/github-release/default.nix

···
-{ stdenv, system, fetchurl }:
+{ lib, stdenv, system, fetchurl }:
 
 let
   linuxPredicate = system == "x86_64-linux";
···
     cp "${metadata.archiveBinaryPath}/github-release" "$out/bin/"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Commandline app to create and edit releases on Github (and upload artifacts)";
     longDescription = ''
       A small commandline app written in Go that allows you to easily create and

pkgs/development/tools/glade/default.nix

···
   version = "3.38.2";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/glade/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    url = "mirror://gnome/sources/glade/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "1dxsiz9ahqkxg2a1dw9sbd8jg59y5pdz4c1gvnbmql48gmj8gz4q";
   };
 

pkgs/development/tools/glide/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "glide";
···
     sha256 = "1wskg1cxqy9sp0738qiiagdw09dbs3swxsk4z6w5hsfiq2h44a54";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://glide.sh";
     description = "Package management for Go";
     license = licenses.mit;

pkgs/development/tools/gllvm/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "gllvm";
···
     sha256 = "15cgngvd9mg057iz32fk5kcprcvvavahbvfvl5ds8x7shbm60g7s";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/SRI-CSL/gllvm";
     description = "Whole Program LLVM: wllvm ported to go";
     license = licenses.bsd3;

pkgs/development/tools/glock/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "glock";
-  version = "20160816-${stdenv.lib.strings.substring 0 7 rev}";
+  version = "20160816-${lib.strings.substring 0 7 rev}";
   rev = "b8c84ff5ade15a6238ca61c20d3afc70d2e41276";
 
   goPackagePath = "github.com/robfig/glock";
···
 
   goDeps = ./deps.nix;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/robfig/glock";
     description = "A command-line tool to lock Go dependencies to specific revisions";
     license = licenses.mit;

pkgs/development/tools/glslviewer/default.nix

···
-{ stdenv, fetchFromGitHub, glfw, pkg-config, libXrandr, libXdamage
+{ lib, stdenv, fetchFromGitHub, glfw, pkg-config, libXrandr, libXdamage
 , libXext, libXrender, libXinerama, libXcursor, libXxf86vm, libXi
 , libX11, libGLU, python3Packages, ensureNewerSourcesForZipFilesHook
 , Cocoa
···
     libXext libXrender libXinerama libXcursor libXxf86vm
     libXi libX11
   ] ++ (with python3Packages; [ python setuptools wrapPython ])
-    ++ stdenv.lib.optional stdenv.isDarwin Cocoa;
+    ++ lib.optional stdenv.isDarwin Cocoa;
   pythonPath = with python3Packages; [ pyyaml requests ];
 
   # Makefile has /usr/local/bin hard-coded for 'make install'
···
     wrapPythonPrograms
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Live GLSL coding renderer";
     homepage = "http://patriciogonzalezvivo.com/2015/glslViewer/";
     license = licenses.bsd3;

pkgs/development/tools/gnome-desktop-testing/default.nix

···
-{ stdenv
+{ lib, stdenv
 , glib
 , autoreconfHook
 , pkg-config
···
 
   enableParallelBuilding = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "GNOME test runner for installed tests";
     homepage = "https://wiki.gnome.org/Initiatives/GnomeGoals/InstalledTests";
     license = licenses.lgpl2Plus;

pkgs/development/tools/gnulib/default.nix

···
-{ stdenv, fetchgit }:
+{ lib, stdenv, fetchgit }:
 
 stdenv.mkDerivation {
   pname = "gnulib";
···
   meta = {
     homepage = "https://www.gnu.org/software/gnulib/";
     description = "Central location for code to be shared among GNU packages";
-    license = stdenv.lib.licenses.gpl3Plus;
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.gpl3Plus;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/go-bindata-assetfs/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "go-bindata-assetfs";
···
     sha256 = "0b6q8h9fwpgpkvml1j87wq9174g7px1dmskhm884drpvswda2djk";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Serve embedded files from jteeuwen/go-bindata";
     license = licenses.bsd2;
     maintainers = with maintainers; [ avnik ];

pkgs/development/tools/go-bindata/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage {
   pname = "go-bindata";
···
 
   excludedPackages = "testdata";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/jteeuwen/go-bindata";
     description = "A small utility which generates Go code from any file, useful for embedding binary data in a Go program";
     maintainers = with maintainers; [ cstrahan ];

pkgs/development/tools/go-langserver/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "go-langserver";
···
     sha256 = "1wv7xf81s3qi8xydxjkkp8vacdzrq8sbj04346fz73nsn85z0sgp";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A Go language server protocol server";
     homepage = "https://github.com/sourcegraph/go-langserver";
     license = licenses.mit;

pkgs/development/tools/go-outline/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "go-outline";
···
   meta = {
     description = "Utility to extract JSON representation of declarations from a Go source file";
     homepage = "https://github.com/ramya-rao-a/go-outline";
-    maintainers = with stdenv.lib.maintainers; [ vdemeester ];
-    license = stdenv.lib.licenses.mit;
+    maintainers = with lib.maintainers; [ vdemeester ];
+    license = lib.licenses.mit;
   };
 }

pkgs/development/tools/go-protobuf/default.nix

···
-{ stdenv, buildGoModule, fetchFromGitHub }:
+{ lib, stdenv, buildGoModule, fetchFromGitHub }:
 
 buildGoModule rec {
   pname = "go-protobuf";
···
 
   doCheck = false;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage    = "https://github.com/golang/protobuf";
     description = " Go bindings for protocol buffer";
     maintainers = with maintainers; [ lewo ];

pkgs/development/tools/go-repo-root/default.nix

···
-{ stdenv, buildGoPackage, fetchgit }:
+{ lib, stdenv, buildGoPackage, fetchgit }:
 
 buildGoPackage rec {
   pname = "go-repo-root";
-  version = "20140911-${stdenv.lib.strings.substring 0 7 rev}";
+  version = "20140911-${lib.strings.substring 0 7 rev}";
   rev = "90041e5c7dc634651549f96814a452f4e0e680f9";
 
   goPackagePath = "github.com/cstrahan/go-repo-root";

pkgs/development/tools/go-symbols/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "go-symbols";
···
   meta = {
     description = "A utility for extracting a JSON representation of the package symbols from a go source tree";
     homepage = "https://github.com/acroca/go-symbols";
-    maintainers = with stdenv.lib.maintainers; [ vdemeester ];
-    license = stdenv.lib.licenses.mit;
+    maintainers = with lib.maintainers; [ vdemeester ];
+    license = lib.licenses.mit;
   };
 }

pkgs/development/tools/go2nix/default.nix

···
-{ stdenv, buildGoPackage, go-bindata, gotools, nix-prefetch-git, git, makeWrapper,
+{ lib, stdenv, buildGoPackage, go-bindata, gotools, nix-prefetch-git, git, makeWrapper,
   fetchFromGitHub }:
 
 buildGoPackage rec {
···
 
   doCheck = false; # tries to access the net
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Go apps packaging for Nix";
     homepage = "https://github.com/kamilchm/go2nix";
     license = licenses.mit;

pkgs/development/tools/goa/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "goa";
···
 
   goDeps = ./deps.nix;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://goa.design";
     description = "A framework for building microservices in Go using a unique design-first approach";
     license = licenses.mit;

pkgs/development/tools/gocode-gomod/default.nix

···
-{ stdenv, buildGoModule, fetchFromGitHub }:
+{ lib, stdenv, buildGoModule, fetchFromGitHub }:
 
 buildGoModule rec {
   pname = "gocode-gomod";
···
     mv $out/bin/gocode $out/bin/gocode-gomod
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "An autocompletion daemon for the Go programming language";
     longDescription = ''
       Gocode is a helper tool which is intended to be integrated with your

pkgs/development/tools/gocode/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "gocode-unstable";
···
 
   goDeps = ./deps.nix;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "An autocompletion daemon for the Go programming language";
     longDescription = ''
       Gocode is a helper tool which is intended to be integrated with your

pkgs/development/tools/goconvey/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "goconvey";
···
   meta = {
     description = "Go testing in the browser. Integrates with `go test`. Write behavioral tests in Go";
     homepage = "https://github.com/smartystreets/goconvey";
-    maintainers = with stdenv.lib.maintainers; [ vdemeester ];
-    license = stdenv.lib.licenses.mit;
+    maintainers = with lib.maintainers; [ vdemeester ];
+    license = lib.licenses.mit;
   };
 }

pkgs/development/tools/godef/default.nix

···
-{ stdenv, buildGoModule, fetchFromGitHub }:
+{ lib, stdenv, buildGoModule, fetchFromGitHub }:
 
 buildGoModule rec {
   pname = "godef";
···
   meta = {
     description = "Print where symbols are defined in Go source code";
     homepage = "https://github.com/rogpeppe/godef/";
-    maintainers = with stdenv.lib.maintainers; [ vdemeester rvolosatovs ];
-    license = stdenv.lib.licenses.bsd3;
+    maintainers = with lib.maintainers; [ vdemeester rvolosatovs ];
+    license = lib.licenses.bsd3;
   };
 }

pkgs/development/tools/godot/default.nix

···
   meta = {
     homepage    = "https://godotengine.org";
     description = "Free and Open Source 2D and 3D game engine";
-    license     = stdenv.lib.licenses.mit;
+    license     = lib.licenses.mit;
     platforms   = [ "i686-linux" "x86_64-linux" ];
-    maintainers = [ stdenv.lib.maintainers.twey ];
+    maintainers = [ lib.maintainers.twey ];
   };
 }

pkgs/development/tools/godot/headless.nix

···
-{ godot, stdenv }:
+{ godot, lib, stdenv }:
 godot.overrideAttrs (oldAttrs: rec {
   pname = "godot-headless";
   sconsFlags = "target=release_debug platform=server tools=yes";
···
   '';
   meta.description =
     "Free and Open Source 2D and 3D game engine (headless build)";
-  meta.maintainers = with stdenv.lib.maintainers; [ twey yusdacra ];
+  meta.maintainers = with lib.maintainers; [ twey yusdacra ];
 })

pkgs/development/tools/godot/server.nix

···
-{ godot, stdenv }:
+{ godot, lib, stdenv }:
 godot.overrideAttrs (oldAttrs: rec {
   pname = "godot-server";
   sconsFlags = "target=release platform=server tools=no";
···
   '';
   meta.description =
     "Free and Open Source 2D and 3D game engine (server build)";
-  meta.maintainers = with stdenv.lib.maintainers; [ twey yusdacra ];
+  meta.maintainers = with lib.maintainers; [ twey yusdacra ];
 })

pkgs/development/tools/golint/default.nix

···
-{ stdenv, buildGoPackage, fetchgit }:
+{ lib, stdenv, buildGoPackage, fetchgit }:
 
 buildGoPackage rec {
   pname = "lint";
-  version = "20181026-${stdenv.lib.strings.substring 0 7 rev}";
+  version = "20181026-${lib.strings.substring 0 7 rev}";
   rev = "c67002cb31c3a748b7688c27f20d8358b4193582";
 
   goPackagePath = "golang.org/x/lint";
···
 
   goDeps = ./deps.nix;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://golang.org";
     description = "Linter for Go source code";
     license = licenses.bsd3;

pkgs/development/tools/gomodifytags/default.nix

···
-{ stdenv, buildGoModule, fetchFromGitHub }:
+{ lib, stdenv, buildGoModule, fetchFromGitHub }:
 
 buildGoModule rec {
   pname = "gomodifytags";
···
   meta = {
     description = "Go tool to modify struct field tags";
     homepage = "https://github.com/fatih/gomodifytags";
-    maintainers = with stdenv.lib.maintainers; [ vdemeester ];
-    license = stdenv.lib.licenses.bsd3;
+    maintainers = with lib.maintainers; [ vdemeester ];
+    license = lib.licenses.bsd3;
   };
 }

pkgs/development/tools/google-app-engine-go-sdk/default.nix

···
-{ stdenv, fetchzip, python3Packages, makeWrapper }:
+{ lib, stdenv, fetchzip, python3Packages, makeWrapper }:
 
 with python3Packages;
 
···
     done
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Google App Engine SDK for Go";
     version = version;
     homepage = "https://cloud.google.com/appengine/docs/go/";

pkgs/development/tools/gopkgs/default.nix

···
-{ stdenv, buildGoModule, fetchFromGitHub }:
+{ lib, stdenv, buildGoModule, fetchFromGitHub }:
 
 buildGoModule rec {
   pname = "gopkgs";
···
   meta = {
     description = "Tool to get list available Go packages";
     homepage = "https://github.com/uudashr/gopkgs";
-    maintainers = with stdenv.lib.maintainers; [ vdemeester ];
-    license = stdenv.lib.licenses.mit;
+    maintainers = with lib.maintainers; [ vdemeester ];
+    license = lib.licenses.mit;
   };
 }

pkgs/development/tools/gosec/default.nix

···
-{ stdenv, buildGoModule, fetchFromGitHub }:
+{ lib, stdenv, buildGoModule, fetchFromGitHub }:
 
 buildGoModule rec {
   pname = "gosec";
···
 
   buildFlagsArray = [ "-ldflags=-s -w -X main.Version=${version} -X main.GitTag=${src.rev} -X main.BuildDate=unknown" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/securego/gosec";
     description = "Golang security checker";
     license = licenses.asl20;

pkgs/development/tools/gotags/default.nix

···
-{ stdenv, buildGoPackage, fetchgit }:
+{ lib, stdenv, buildGoPackage, fetchgit }:
 
 buildGoPackage rec {
   pname = "gotags";
-  version = "20150803-${stdenv.lib.strings.substring 0 7 rev}";
+  version = "20150803-${lib.strings.substring 0 7 rev}";
   rev = "be986a34e20634775ac73e11a5b55916085c48e7";
 
   goPackagePath = "github.com/jstemmer/gotags";

pkgs/development/tools/gotests/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "gotests";
···
   meta = {
     description = "Generate Go tests from your source code";
     homepage = "https://github.com/cweill/gotests";
-    maintainers = with stdenv.lib.maintainers; [ vdemeester ];
-    license = stdenv.lib.licenses.asl20;
+    maintainers = with lib.maintainers; [ vdemeester ];
+    license = lib.licenses.asl20;
   };
 }

pkgs/development/tools/gotools/default.nix

···
-{ stdenv, buildGoModule, fetchgit }:
+{ lib, stdenv, buildGoModule, fetchgit }:
 
 buildGoModule rec {
   pname = "gotools-unstable";
···
   '';
 
   excludedPackages = "\\("
-    + stdenv.lib.concatStringsSep "\\|" ([ "testdata" "vet" "cover" ])
+    + lib.concatStringsSep "\\|" ([ "testdata" "vet" "cover" ])
     + "\\)";
 
   # Set GOTOOLDIR for derivations adding this to buildInputs

pkgs/development/tools/govendor/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "govendor";
···
     sha256 = "0g02cd25chyijg0rzab4xr627pkvk5k33mscd6r0gf1v5xvadcfq";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/kardianos/govendor";
     description = "Go vendor tool that works with the standard vendor file";
     license = licenses.bsd3;

pkgs/development/tools/govers/default.nix

···
-{ stdenv, buildGoPackage, fetchgit }:
+{ lib, stdenv, buildGoPackage, fetchgit }:
 
 buildGoPackage rec {
   pname = "govers";
-  version = "20160623-${stdenv.lib.strings.substring 0 7 rev}";
+  version = "20160623-${lib.strings.substring 0 7 rev}";
   rev = "77fd787551fc5e7ae30696e009e334d52d2d3a43";
 
   goPackagePath = "github.com/rogpeppe/govers";

pkgs/development/tools/gox/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "gox";
···
     sha256 = "0mkh81hd7kn45dz7b6yhzqsg2mvg1g6pwx89jjigxrnqhyg9vrl7";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/mitchellh/gox";
     description = "A dead simple, no frills Go cross compile tool";
     license = licenses.mpl20;

pkgs/development/tools/gpp/default.nix

···
-{ stdenv, fetchFromGitHub, autoreconfHook }:
+{ lib, stdenv, fetchFromGitHub, autoreconfHook }:
 
 stdenv.mkDerivation {
   pname = "gpp";
···
   installCheckPhase = "$out/bin/gpp --help";
   doInstallCheck = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "General-purpose preprocessor with customizable syntax";
     homepage = "https://logological.org/gpp";
     license = licenses.lgpl3;

pkgs/development/tools/gron/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "gron";
···
 
   goDeps = ./deps.nix;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Make JSON greppable!";
     longDescription = ''
       gron transforms JSON into discrete assignments to make it easier to grep

pkgs/development/tools/guile/g-wrap/default.nix

···
-{ fetchurl, stdenv, guile, guile-lib, libffi, pkg-config, glib }:
+{ fetchurl, lib, stdenv, guile, guile-lib, libffi, pkg-config, glib }:
 
 stdenv.mkDerivation rec {
   pname = "g-wrap";
···
 
   doCheck = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A wrapper generator for Guile";
     longDescription = ''
       G-Wrap is a tool (and Guile library) for generating function wrappers for

pkgs/development/tools/guile/guile-lint/default.nix

···
-{ stdenv, fetchurl, guile }:
+{ lib, stdenv, fetchurl, guile }:
 
 stdenv.mkDerivation rec {
   pname = "guile-lint";
···
 
   doCheck = !stdenv.isDarwin;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Checks syntax and semantics in a Guile program or module";
     homepage = "https://user42.tuxfamily.org/guile-lint/index.html";
     license = licenses.gpl3Plus;

pkgs/development/tools/haskell/dconf2nix/dconf2nix.nix

···
 { mkDerivation, base, containers, fetchgit, hedgehog
-, optparse-applicative, parsec, stdenv, template-haskell, text
+, optparse-applicative, parsec, lib, stdenv, template-haskell, text
 }:
 mkDerivation {
   pname = "dconf2nix";
···
     base containers hedgehog parsec template-haskell text
   ];
   description = "Convert dconf files to Nix, as expected by Home Manager";
-  license = stdenv.lib.licenses.asl20;
+  license = lib.licenses.asl20;
 }

pkgs/development/tools/haskell/haskell-language-server/default.nix

···
 , hls-tactics-plugin, hslogger, hspec, hspec-core
 , hspec-expectations, lens, lsp-test, mtl, optparse-applicative
 , optparse-simple, ormolu, process, regex-tdfa, safe-exceptions
-, shake, stdenv, stm, stylish-haskell, tasty, tasty-ant-xml
+, shake, lib, stdenv, stm, stylish-haskell, tasty, tasty-ant-xml
 , tasty-expected-failure, tasty-golden, tasty-hunit, tasty-rerun
 , temporary, text, transformers, unordered-containers, with-utf8
 , yaml
···
   testToolDepends = [ ghcide ];
   homepage = "https://github.com/haskell/haskell-language-server#readme";
   description = "LSP server for GHC";
-  license = stdenv.lib.licenses.asl20;
+  license = lib.licenses.asl20;
 }

pkgs/development/tools/haskell/haskell-language-server/hls-class-plugin.nix

···
 { mkDerivation, aeson, base, containers, fetchgit, ghc
 , ghc-exactprint, ghcide, haskell-lsp, hls-plugin-api, lens, shake
-, stdenv, text, transformers, unordered-containers
+, lib, stdenv, text, transformers, unordered-containers
 }:
 mkDerivation {
   pname = "hls-class-plugin";
···
     hls-plugin-api lens shake text transformers unordered-containers
   ];
   description = "Explicit imports plugin for Haskell Language Server";
-  license = stdenv.lib.licenses.asl20;
+  license = lib.licenses.asl20;
 }

pkgs/development/tools/haskell/haskell-language-server/hls-eval-plugin.nix

···
 , extra, fetchgit, filepath, ghc, ghc-boot-th, ghc-paths, ghcide
 , hashable, haskell-lsp, haskell-lsp-types, hls-plugin-api
 , parser-combinators, pretty-simple, QuickCheck, safe-exceptions
-, shake, stdenv, temporary, text, time, transformers
+, shake, lib, stdenv, temporary, text, time, transformers
 , unordered-containers
 }:
 mkDerivation {
···
     unordered-containers
   ];
   description = "Eval plugin for Haskell Language Server";
-  license = stdenv.lib.licenses.asl20;
+  license = lib.licenses.asl20;
 }

pkgs/development/tools/haskell/haskell-language-server/hls-explicit-imports-plugin.nix

···
 { mkDerivation, aeson, base, containers, deepseq, fetchgit, ghc
-, ghcide, haskell-lsp-types, hls-plugin-api, shake, stdenv, text
+, ghcide, haskell-lsp-types, hls-plugin-api, shake, lib, stdenv, text
 , unordered-containers
 }:
 mkDerivation {
···
     hls-plugin-api shake text unordered-containers
   ];
   description = "Explicit imports plugin for Haskell Language Server";
-  license = stdenv.lib.licenses.asl20;
+  license = lib.licenses.asl20;
 }

pkgs/development/tools/haskell/haskell-language-server/hls-hlint-plugin.nix

···
 , containers, data-default, deepseq, Diff, directory, extra
 , fetchgit, filepath, ghc, ghc-lib, ghc-lib-parser-ex, ghcide
 , hashable, haskell-lsp, hlint, hls-plugin-api, hslogger, lens
-, regex-tdfa, shake, stdenv, temporary, text, transformers
+, regex-tdfa, shake, lib, stdenv, temporary, text, transformers
 , unordered-containers
 }:
 mkDerivation {
···
     regex-tdfa shake temporary text transformers unordered-containers
   ];
   description = "Hlint integration plugin with Haskell Language Server";
-  license = stdenv.lib.licenses.asl20;
+  license = lib.licenses.asl20;
 }

pkgs/development/tools/haskell/haskell-language-server/hls-retrie-plugin.nix

···
 { mkDerivation, aeson, base, containers, deepseq, directory, extra
 , fetchgit, ghc, ghcide, hashable, haskell-lsp, haskell-lsp-types
-, hls-plugin-api, retrie, safe-exceptions, shake, stdenv, text
+, hls-plugin-api, retrie, safe-exceptions, shake, lib, stdenv, text
 , transformers, unordered-containers
 }:
 mkDerivation {
···
     shake text transformers unordered-containers
   ];
   description = "Retrie integration plugin for Haskell Language Server";
-  license = stdenv.lib.licenses.asl20;
+  license = lib.licenses.asl20;
 }

pkgs/development/tools/haskell/haskell-language-server/hls-tactics-plugin.nix

···
 , directory, extra, fetchgit, filepath, fingertree, generic-lens
 , ghc, ghc-boot-th, ghc-exactprint, ghc-source-gen, ghcide
 , haskell-lsp, hie-bios, hls-plugin-api, hspec, hspec-discover
-, lens, mtl, QuickCheck, refinery, retrie, shake, stdenv, syb, text
+, lens, mtl, QuickCheck, refinery, retrie, shake, lib, stdenv, syb, text
 , transformers
 }:
 mkDerivation {
···
   testToolDepends = [ hspec-discover ];
   description = "Tactics plugin for Haskell Language Server";
   license = "unknown";
-  hydraPlatforms = stdenv.lib.platforms.none;
+  hydraPlatforms = lib.platforms.none;
 }

pkgs/development/tools/haskell/hyper-haskell/default.nix

···
-{ stdenv, fetchFromGitHub, jshon, electron_3
+{ lib, stdenv, fetchFromGitHub, jshon, electron_3
 , runtimeShell, hyper-haskell-server, extra-packages ? [] }:
 
 let
-  binPath = stdenv.lib.makeBinPath ([ hyper-haskell-server ] ++ extra-packages);
+  binPath = lib.makeBinPath ([ hyper-haskell-server ] ++ extra-packages);
   electron = electron_3;
 in stdenv.mkDerivation rec {
   pname = "hyper-haskell";
···
     chmod 755 $out/bin/hyper-haskell
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "The strongly hyped graphical interpreter for the Haskell programming language";
     homepage = "https://github.com/HeinrichApfelmus/hyper-haskell";
     license = licenses.bsd3;

pkgs/development/tools/haskell/ihaskell/wrapper.nix

···
-{ stdenv, writeScriptBin, makeWrapper, buildEnv, haskell, ghcWithPackages, jupyter, packages }:
+{ lib, stdenv, writeScriptBin, makeWrapper, buildEnv, haskell, ghcWithPackages, jupyter, packages }:
 let
   ihaskellEnv = ghcWithPackages (self: [
     self.ihaskell
···
   ihaskellSh = writeScriptBin "ihaskell-notebook" ''
     #! ${stdenv.shell}
     export GHC_PACKAGE_PATH="$(echo ${ihaskellEnv}/lib/*/package.conf.d| tr ' ' ':'):$GHC_PACKAGE_PATH"
-    export PATH="${stdenv.lib.makeBinPath ([ ihaskellEnv jupyter ])}''${PATH:+:}$PATH"
+    export PATH="${lib.makeBinPath ([ ihaskellEnv jupyter ])}''${PATH:+:}$PATH"
     ${ihaskellEnv}/bin/ihaskell install -l $(${ihaskellEnv}/bin/ghc --print-libdir) && ${jupyter}/bin/jupyter notebook
   '';
 in

pkgs/development/tools/haskell/vaultenv/default.nix

···
 { mkDerivation, async, base, bytestring, connection, containers
 , directory, hpack, hspec, hspec-discover, hspec-expectations
 , http-client, http-conduit, lens, lens-aeson, megaparsec, mtl
-, optparse-applicative, parser-combinators, retry, stdenv, text
+, optparse-applicative, parser-combinators, retry, lib, stdenv, text
 , unix, unordered-containers, utf8-string, fetchzip, dotenv
 }:
 mkDerivation rec {
···
   preConfigure = "hpack";
   homepage = "https://github.com/channable/vaultenv#readme";
   description = "Runs processes with secrets from HashiCorp Vault";
-  license = stdenv.lib.licenses.bsd3;
-  maintainers = with stdenv.lib.maintainers; [ lnl7 manveru ];
+  license = lib.licenses.bsd3;
+  maintainers = with lib.maintainers; [ lnl7 manveru ];
 }

pkgs/development/tools/hcloud/default.nix

···
-{ stdenv, buildGoModule, fetchFromGitHub, installShellFiles }:
+{ lib, stdenv, buildGoModule, fetchFromGitHub, installShellFiles }:
 
 buildGoModule rec {
   pname = "hcloud";
···
   meta = {
     description = "A command-line interface for Hetzner Cloud, a provider for cloud virtual private servers";
     homepage = "https://github.com/hetznercloud/cli";
-    license = stdenv.lib.licenses.mit;
-    maintainers = [ stdenv.lib.maintainers.zauberpony ];
+    license = lib.licenses.mit;
+    maintainers = [ lib.maintainers.zauberpony ];
   };
 }

pkgs/development/tools/hexio/default.nix

···
-{ stdenv, fetchFromGitHub, python, pcsclite, pth }:
+{ lib, stdenv, fetchFromGitHub, python, pcsclite, pth }:
 
 stdenv.mkDerivation rec {
   pname = "hexio";
···
 
   patchPhase = ''
     substituteInPlace Makefile \
-      --replace '-I/usr/local/include/PCSC/' '-I${stdenv.lib.getDev pcsclite}/include/PCSC/' \
+      --replace '-I/usr/local/include/PCSC/' '-I${lib.getDev pcsclite}/include/PCSC/' \
       --replace '-L/usr/local/lib/pth' '-I${pth}/lib/'
     '';
 
···
     make DESTDIR=$out PREFIX=/ install
     '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Low-level I/O helpers for hexadecimal, tty/serial devices and so on";
     homepage = "https://github.com/vanrein/hexio";
     license = licenses.bsd2;

pkgs/development/tools/iaca/2.1.nix

···
-{ stdenv, makeWrapper, requireFile, gcc, unzip }:
-with stdenv.lib;
+{ lib, stdenv, makeWrapper, requireFile, gcc, unzip }:
+with lib;
 
 # v2.1: last version with NHM/WSM arch support
 stdenv.mkDerivation {

pkgs/development/tools/iaca/3.0.nix

···
-{ stdenv, requireFile, unzip }:
-with stdenv.lib;
+{ lib, stdenv, requireFile, unzip }:
+with lib;
 
 stdenv.mkDerivation {
   name = "iaca-3.0";

pkgs/development/tools/icestorm/default.nix

···
-{ stdenv, fetchFromGitHub
+{ lib, stdenv, fetchFromGitHub
 , pkg-config, libftdi1
 , python3, pypy3
 
···
       creating bitstream files.
     '';
     homepage    = "http://www.clifford.at/icestorm/";
-    license     = stdenv.lib.licenses.isc;
-    maintainers = with stdenv.lib.maintainers; [ shell thoughtpolice emily ];
-    platforms   = stdenv.lib.platforms.all;
+    license     = lib.licenses.isc;
+    maintainers = with lib.maintainers; [ shell thoughtpolice emily ];
+    platforms   = lib.platforms.all;
   };
 }

pkgs/development/tools/icr/default.nix

···
       --prefix PATH : ${lib.makeBinPath [ crystal shards makeWrapper which ]}
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Interactive console for the Crystal programming language";
     homepage = "https://github.com/crystal-community/icr";
     license = licenses.mit;

pkgs/development/tools/imatix_gsl/default.nix

···
-{ stdenv, fetchFromGitHub, pcre } :
+{ lib, stdenv, fetchFromGitHub, pcre } :
 
 stdenv.mkDerivation {
   pname = "imatix_gsl";
···
   preBuild = "cd src";
   installFlags = [ "DESTDIR=$(out)" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     license = licenses.gpl3Plus;
     homepage = "https://github.com/imatix/gsl/";
     description = "A universal code generator";

pkgs/development/tools/irony-server/default.nix

···
-{ stdenv, cmake, llvmPackages, irony }:
+{ lib, stdenv, cmake, llvmPackages, irony }:
 
 stdenv.mkDerivation {
   pname = "irony-server";
···
     "-DCMAKE_PREFIX_PATH=${llvmPackages.clang-unwrapped}"
   ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "The server part of irony";
     homepage = "https://melpa.org/#/irony";
     maintainers = [ maintainers.deepfire ];

pkgs/development/tools/java/cfr/default.nix

···
-{ stdenv, makeWrapper, fetchurl, jre }:
+{ lib, stdenv, makeWrapper, fetchurl, jre }:
 
 stdenv.mkDerivation rec {
   pname = "cfr";
···
     makeWrapper ${jre}/bin/java $out/bin/cfr --add-flags "-jar $jar"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Another java decompiler";
     longDescription = ''
       CFR will decompile modern Java features - Java 8 lambdas (pre and post

pkgs/development/tools/java/dex2jar/default.nix

···
     done
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = https://sourceforge.net/projects/dex2jar/;
     description = "Tools to work with android .dex and java .class files";
     maintainers = with maintainers; [ makefu ];

pkgs/development/tools/java/fastjar/default.nix

···
-{ fetchurl, stdenv, zlib }:
+{ fetchurl, lib, stdenv, zlib }:
 
 let version = "0.98"; in
   stdenv.mkDerivation {
···
 
       homepage = "https://savannah.nongnu.org/projects/fastjar/";
 
-      license = stdenv.lib.licenses.gpl2Plus;
-      platforms = stdenv.lib.platforms.linux;
+      license = lib.licenses.gpl2Plus;
+      platforms = lib.platforms.linux;
       maintainers = [ ];
     };
   }

pkgs/development/tools/java/jhiccup/default.nix

···
-{ stdenv, fetchzip }:
+{ lib, stdenv, fetchzip }:
 
 stdenv.mkDerivation rec {
   pname = "jhiccup";
···
   meta = {
     description = "Measure JVM application stalls and GC pauses";
     homepage    = "https://www.azul.com/jhiccup/";
-    license     = stdenv.lib.licenses.cc0;
-    platforms   = stdenv.lib.platforms.linux;
-    maintainers = with stdenv.lib.maintainers; [ thoughtpolice ];
+    license     = lib.licenses.cc0;
+    platforms   = lib.platforms.linux;
+    maintainers = with lib.maintainers; [ thoughtpolice ];
   };
 }

pkgs/development/tools/java/visualvm/default.nix

···
     cp -r . $out
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A visual interface for viewing information about Java applications";
     longDescription = ''
       VisualVM is a visual tool integrating several commandline JDK

pkgs/development/tools/jbake/default.nix

···
-{ stdenv, fetchzip, makeWrapper, jre }:
+{ lib, stdenv, fetchzip, makeWrapper, jre }:
 
 stdenv.mkDerivation rec {
   version = "2.6.5";
···
   '';
   doCheck = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Java based, open source, static site/blog generator for developers & designers";
     homepage = "https://jbake.org/";
     license = licenses.mit;

pkgs/development/tools/jbang/default.nix

···
     $out/bin/jbang --version 2>&1 | grep -q "${version}"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Run java as scripts anywhere";
     longDescription = ''
       jbang uses the java language to build scripts similar to groovy scripts. Dependencies are automatically

pkgs/development/tools/jd/default.nix

···
-{ stdenv, buildGoPackage, fetchgit }:
+{ lib, stdenv, buildGoPackage, fetchgit }:
 
 buildGoPackage rec {
   pname = "jd";
···
     sha256 = "0dj4k38pf80dl77jns29vx2dj265s4ksg2q2s9n240b7b8z8mn5h";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Interactive JSON Editor";
     license = licenses.mit;
     maintainers = [ maintainers.np ];

pkgs/development/tools/jid/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "jid";
···
   meta = {
     description = "A command-line tool to incrementally drill down JSON";
     homepage = "https://github.com/simeji/jid";
-    license = stdenv.lib.licenses.mit;
-    maintainers = with stdenv.lib.maintainers; [ stesie ];
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ stesie ];
   };
 }

pkgs/development/tools/jira_cli/default.nix

···
-{ stdenv, libffi, openssl, python3Packages }:
+{ lib, stdenv, libffi, openssl, python3Packages }:
 let
   inherit (python3Packages) fetchPypi buildPythonApplication vcrpy mock hiro;
 in
···
       jira  keyrings-alt
     ];
 
-    meta = with stdenv.lib; {
+    meta = with lib; {
       description = "A command line interface to Jira";
       homepage = "https://github.com/alisaifee/jira-cli";
       maintainers = with maintainers; [ nyarly ];

pkgs/development/tools/jl/default.nix

···
 { mkDerivation, fetchFromGitHub, fetchpatch
 , aeson, aeson-pretty, attoparsec, base, bytestring, conduit, conduit-extra
-, containers, exceptions, mtl, optparse-simple, parsec, scientific, stdenv
+, containers, exceptions, mtl, optparse-simple, parsec, scientific, lib, stdenv
 , text, unordered-containers, vector
 }:
 mkDerivation rec {
···
     aeson aeson-pretty base bytestring conduit conduit-extra containers
     mtl optparse-simple text vector
   ];
-  license = stdenv.lib.licenses.bsd3;
+  license = lib.licenses.bsd3;
   description = "Functional sed for JSON";
-  maintainers = with stdenv.lib.maintainers; [ fgaz ];
+  maintainers = with lib.maintainers; [ fgaz ];
   homepage = "https://github.com/chrisdone/jl";
 }

pkgs/development/tools/jmespath/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "jmespath";
···
     repo = "go-jmespath";
     sha256 = "0f4j0m44limnjd6q5fk152g6jq2a5cshcdms4p3a1br8pl9wp5fb";
   };
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A JMESPath implementation in Go";
     homepage = "https://github.com/jmespath/go-jmespath";
     maintainers = with maintainers; [ cransom ];

pkgs/development/tools/jo/default.nix

···
-{stdenv, fetchFromGitHub, autoreconfHook, pandoc, pkg-config}:
+{lib, stdenv, fetchFromGitHub, autoreconfHook, pandoc, pkg-config}:
 
 stdenv.mkDerivation rec {
   pname = "jo";
···
 
   nativeBuildInputs = [ autoreconfHook pandoc pkg-config ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A small utility to create JSON objects";
     homepage = "https://github.com/jpmens/jo";
     license = licenses.gpl2Plus;

pkgs/development/tools/jp/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "jp";
···
     repo = "jp";
     sha256 = "0fdbnihbd0kq56am3bmh2zrfk4fqjslcbm48malbgmpqw3a5nvpi";
   };
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A command line interface to the JMESPath expression language for JSON";
     homepage = "https://github.com/jmespath/jp";
     maintainers = with maintainers; [ cransom ];

pkgs/development/tools/jq/default.nix

···
-{ stdenv, nixosTests, fetchurl, oniguruma }:
+{ lib, stdenv, nixosTests, fetchurl, oniguruma }:
 
 stdenv.mkDerivation rec {
   pname = "jq";
···
     "--mandir=\${man}/share/man"
   ]
   # jq is linked to libjq:
-    ++ stdenv.lib.optional (!stdenv.isDarwin) "LDFLAGS=-Wl,-rpath,\\\${libdir}";
+    ++ lib.optional (!stdenv.isDarwin) "LDFLAGS=-Wl,-rpath,\\\${libdir}";
 
   doInstallCheck = true;
   installCheckTarget = "check";
···
 
   passthru.tests = { inherit (nixosTests) jq; };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A lightweight and flexible command-line JSON processor";
     license = licenses.mit;
     maintainers = with maintainers; [ raskin globin ];

pkgs/development/tools/just/default.nix

···
-{ stdenv, fetchFromGitHub, rustPlatform, coreutils, bash, installShellFiles }:
+{ lib, stdenv, fetchFromGitHub, rustPlatform, coreutils, bash, installShellFiles }:
 
 rustPlatform.buildRustPackage rec {
   pname = "just";
···
   # Skip "choose" when running "cargo test", since this test case needs "fzf".
   checkFlags = [ "--skip=choose" "--skip=edit" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A handy way to save and run project-specific commands";
     homepage = "https://github.com/casey/just";
     license = licenses.cc0;

pkgs/development/tools/k6/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "k6";
···
 
   subPackages = [ "./" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A modern load testing tool, using Go and JavaScript";
     homepage = "https://k6.io/";
     changelog = "https://github.com/loadimpact/k6/releases/tag/v${version}";

pkgs/development/tools/kafkacat/default.nix

···
-{ stdenv, fetchFromGitHub, pkg-config, zlib, rdkafka, yajl }:
+{ lib, stdenv, fetchFromGitHub, pkg-config, zlib, rdkafka, yajl }:
 
 stdenv.mkDerivation rec {
   pname = "kafkacat";
···
     patchShebangs ./configure
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A generic non-JVM producer and consumer for Apache Kafka";
     homepage = "https://github.com/edenhill/kafkacat";
     license = licenses.bsd2;

pkgs/development/tools/kind/default.nix

···
-{ stdenv, buildGoModule, fetchFromGitHub, installShellFiles }:
+{ lib, stdenv, buildGoModule, fetchFromGitHub, installShellFiles }:
 
-with stdenv.lib;
+with lib;
 
 buildGoModule rec {
   pname = "kind";
···
     description = "Kubernetes IN Docker - local clusters for testing Kubernetes";
     homepage    = "https://github.com/kubernetes-sigs/kind";
     maintainers = with maintainers; [ offline rawkode ];
-    license     = stdenv.lib.licenses.asl20;
+    license     = lib.licenses.asl20;
     platforms   = platforms.unix;
   };
 }

pkgs/development/tools/krew/default.nix

···
     description = "Package manager for kubectl plugins";
     homepage = "https://github.com/kubernetes-sigs/krew";
     maintainers = with maintainers; [ vdemeester ];
-    license = stdenv.lib.licenses.asl20;
+    license = lib.licenses.asl20;
     platforms = platforms.unix;
   };
 }

pkgs/development/tools/ktlint/default.nix

···
-{ stdenv, fetchurl, makeWrapper, jre_headless }:
+{ lib, stdenv, fetchurl, makeWrapper, jre_headless }:
 
 stdenv.mkDerivation rec {
   pname = "ktlint";
···
     wrapProgram $out/bin/ktlint --prefix PATH : "${jre_headless}/bin"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "An anti-bikeshedding Kotlin linter with built-in formatter";
     homepage = "https://ktlint.github.io/";
     license = licenses.mit;

pkgs/development/tools/kubectx/default.nix

···
-{ stdenv, buildGoModule, fetchFromGitHub, installShellFiles }:
+{ lib, stdenv, buildGoModule, fetchFromGitHub, installShellFiles }:
 
 buildGoModule rec {
   pname = "kubectx";
···
     installShellCompletion completion/*
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Fast way to switch between clusters and namespaces in kubectl!";
     license = licenses.asl20;
     homepage = "https://github.com/ahmetb/kubectx";

pkgs/development/tools/kubicorn/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
-with stdenv.lib;
+with lib;
 
 buildGoPackage rec {
   pname = "kubicorn";
-  version = "2018-10-13-${stdenv.lib.strings.substring 0 7 rev}";
+  version = "2018-10-13-${lib.strings.substring 0 7 rev}";
   rev = "4c7f3623e9188fba43778271afe161a4facfb657";
 
   src = fetchFromGitHub {
···
   meta = {
     description = "Simple, cloud native infrastructure for Kubernetes";
     homepage = "http://kubicorn.io/";
-    maintainers = with stdenv.lib.maintainers; [ offline ];
-    license = stdenv.lib.licenses.asl20;
+    maintainers = with lib.maintainers; [ offline ];
+    license = lib.licenses.asl20;
   };
 }

pkgs/development/tools/kubie/default.nix

···
 
   nativeBuildInputs = [ installShellFiles ];
 
-  buildInputs = stdenv.lib.optionals stdenv.isDarwin [ Security ];
+  buildInputs = lib.optionals stdenv.isDarwin [ Security ];
 
   postInstall = ''
     installShellCompletion completion/kubie.bash

pkgs/development/tools/kythe/default.nix

···
-{ stdenv, binutils , fetchurl, ncurses5 }:
+{ lib, stdenv, binutils , fetchurl, ncurses5 }:
 
 stdenv.mkDerivation rec {
   version = "0.0.30";
···
                 write_entries write_tables entrystream; do
       echo "Patching:" $exe
       patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $exe
-      patchelf --set-rpath "${stdenv.lib.makeLibraryPath [ stdenv.cc.cc ncurses5 ]}" $exe
+      patchelf --set-rpath "${lib.makeLibraryPath [ stdenv.cc.cc ncurses5 ]}" $exe
     done
     cd ../
     cp -R ./ $out
     ln -s $out/tools $out/bin
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A pluggable, (mostly) language-agnostic ecosystem for building tools that work with code";
     longDescription = ''
     The Kythe project was founded to provide and support tools and standards

pkgs/development/tools/lattice-diamond/default.nix

···
-{ stdenv, rpmextract, patchelf, makeWrapper, file, requireFile, glib, zlib, 
+{ lib, stdenv, rpmextract, patchelf, makeWrapper, file, requireFile, glib, zlib, 
     freetype, fontconfig, xorg, libusb-compat-0_1 }:
 
 stdenv.mkDerivation {
···
     done
   '';
 
-  libPath = stdenv.lib.makeLibraryPath [
+  libPath = lib.makeLibraryPath [
     glib zlib freetype fontconfig
     xorg.libSM xorg.libICE xorg.libXrender xorg.libXext xorg.libX11 xorg.libXt
     libusb-compat-0_1
···
       next-generation replacement for ispLEVER.
     '';
     homepage = "http://www.latticesemi.com/latticediamond";
-    license = stdenv.lib.licenses.unfree;
-    maintainers = with stdenv.lib.maintainers; [ q3k ];
+    license = lib.licenses.unfree;
+    maintainers = with lib.maintainers; [ q3k ];
     platforms = [ "x86_64-linux" ];
   };
 }

pkgs/development/tools/lazygit/default.nix

···
-{ stdenv, buildGoModule, fetchFromGitHub }:
+{ lib, stdenv, buildGoModule, fetchFromGitHub }:
 
 buildGoModule rec {
   pname = "lazygit";
···
 
   buildFlagsArray = [ "-ldflags=-X main.version=${version} -X main.buildSource=nix" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Simple terminal UI for git commands";
     homepage = "https://github.com/jesseduffield/lazygit";
     changelog = "https://github.com/jesseduffield/lazygit/releases/tag/v${version}";

pkgs/development/tools/leaps/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "leaps";
···
     description = "A pair programming tool and library written in Golang";
     homepage = "https://github.com/jeffail/leaps/";
     license = "MIT";
-    maintainers = with stdenv.lib.maintainers; [ qknight ];
-    platforms = stdenv.lib.platforms.unix;
+    maintainers = with lib.maintainers; [ qknight ];
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/libsigrok/default.nix

···
-{ stdenv, fetchurl, pkg-config, libzip, glib, libusb1, libftdi1, check
+{ lib, stdenv, fetchurl, pkg-config, libzip, glib, libusb1, libftdi1, check
 , libserialport, librevisa, doxygen, glibmm, python
 , version ? "0.5.1", sha256 ? "171b553dir5gn6w4f7n37waqk62nq2kf1jykx4ifjacdz5xdw3z4"
 }:
···
     tar --strip-components=1 -xvf "${firmware}" -C "$out/share/sigrok-firmware/"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Core library of the sigrok signal analysis software suite";
     homepage = "https://sigrok.org/";
     license = licenses.gpl3Plus;

pkgs/development/tools/libsigrokdecode/default.nix

···
-{ stdenv, fetchurl, pkg-config, glib, python3, libsigrok, check }:
+{ lib, stdenv, fetchurl, pkg-config, glib, python3, libsigrok, check }:
 
 stdenv.mkDerivation rec {
   name = "libsigrokdecode-0.5.3";
···
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ glib python3 libsigrok check ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Protocol decoding library for the sigrok signal analysis software suite";
     homepage = "https://sigrok.org/";
     license = licenses.gpl3Plus;

pkgs/development/tools/literate-programming/Literate/default.nix

···
-{ stdenv, fetchgit, dmd, dub }:
+{ lib, stdenv, fetchgit, dmd, dub }:
 
 stdenv.mkDerivation {
   pname = "Literate";
···
 
   installPhase = "install -D bin/lit $out/bin/lit";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A literate programming tool for any language";
     homepage    = "http://literate.zbyedidia.webfactional.com/";
     license = licenses.mit;

pkgs/development/tools/literate-programming/eweb/default.nix

···
-{ stdenv, fetchurl, python3, asciidoc }:
+{ lib, stdenv, fetchurl, python3, asciidoc }:
 
 stdenv.mkDerivation rec {
   pname = "eweb";
···
     cp etangle.w etangle.html $out/share/doc/${pname}-${version}
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "http://eweb.sourceforge.net/";
     description = "An Asciidoc-based literate programming tool, written in Python";
     platforms = platforms.linux;

pkgs/development/tools/literate-programming/funnelweb/default.nix

···
-{stdenv, fetchurl}:
+{lib, stdenv, fetchurl}:
 
 stdenv.mkDerivation rec {
 
···
     install fw $out/bin/fw
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     version = "3.20";
     description = "A simple, reliable literate-programming macro preprocessor";
     homepage = "http://www.ross.net/funnelweb/";

pkgs/development/tools/literate-programming/noweb/default.nix

···
-{ stdenv, fetchFromGitHub, gawk, groff, icon-lang ? null }:
+{ lib, stdenv, fetchFromGitHub, gawk, groff, icon-lang ? null }:
 
 let noweb = stdenv.mkDerivation rec {
   pname = "noweb";
···
 
   patches = [ ./no-FAQ.patch ];
 
-  nativeBuildInputs = [ groff ] ++ stdenv.lib.optionals (!isNull icon-lang) [ icon-lang ];
+  nativeBuildInputs = [ groff ] ++ lib.optionals (!isNull icon-lang) [ icon-lang ];
 
   preBuild = ''
     mkdir -p "$out/lib/noweb"
     cd src
   '';
 
-  makeFlags = stdenv.lib.optionals (!isNull icon-lang) [
+  makeFlags = lib.optionals (!isNull icon-lang) [
     "LIBSRC=icon"
     "ICONC=icont"
-  ] ++ stdenv.lib.optionals stdenv.isDarwin [
+  ] ++ lib.optionals stdenv.isDarwin [
     "CC=clang"
   ];
 
···
   tlType = "run";
   passthru.pkgs = [ noweb.tex ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A simple, extensible literate-programming tool";
     homepage = "https://www.cs.tufts.edu/~nr/noweb";
     license = licenses.bsd2;

pkgs/development/tools/literate-programming/nuweb/default.nix

···
-{stdenv, fetchurl, tex}:
+{lib, stdenv, fetchurl, tex}:
 
 stdenv.mkDerivation rec {
 
···
     cp htdocs/index.html nuweb.w nuweb.pdf nuwebdoc.pdf README $out/share/doc/${pname}-${version}
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A simple literate programming tool";
     homepage = "http://nuweb.sourceforge.net";
     license = licenses.free;

pkgs/development/tools/makerpm/default.nix

···
-{ stdenv, fetchFromGitHub, zlib, libarchive, openssl }:
+{ lib, stdenv, fetchFromGitHub, zlib, libarchive, openssl }:
 
 stdenv.mkDerivation rec {
   version = "1.0";
···
     sha256 = "089dkbh5705ppyi920rd0ksjc0143xmvnhm8qrx93rsgwc1ggi1y";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/ivan-tkatchev/makerpm/";
     description = "A clean, simple RPM packager reimplemented completely from scratch";
     license = licenses.free;

pkgs/development/tools/manul/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage {
   name = "manul-unstable-2016-09-30";
···
   deleteVendor = true;
   goDeps = ./deps.nix;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "The madness vendoring utility for Golang programs";
     homepage = "https://github.com/kovetskiy/manul";
     license = licenses.mit;

pkgs/development/tools/mdk/default.nix

···
-{ stdenv, fetchurl, intltool, pkg-config, glib }:
+{ lib, stdenv, fetchurl, intltool, pkg-config, glib }:
 
 stdenv.mkDerivation {
   name = "gnu-mdk-1.3.0";
···
   meta = {
     description = "GNU MIX Development Kit (MDK)";
     homepage = "https://www.gnu.org/software/mdk/";
-    license = stdenv.lib.licenses.gpl3;
-    platforms = stdenv.lib.platforms.all;
+    license = lib.licenses.gpl3;
+    platforms = lib.platforms.all;
   };
 }

pkgs/development/tools/minizinc/default.nix

···
-{ stdenv, fetchFromGitHub, fetchpatch, cmake, flex, bison }:
+{ lib, stdenv, fetchFromGitHub, fetchpatch, cmake, flex, bison }:
 let
   version = "2.4.3";
 in
···
     })
   ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://www.minizinc.org/";
     description = "A medium-level constraint modelling language";
 

pkgs/development/tools/minizinc/ide.nix

···
-{ stdenv, fetchFromGitHub, qtbase, qtwebengine, qtwebkit, qmake, makeWrapper, minizinc }:
+{ lib, stdenv, fetchFromGitHub, qtbase, qtwebengine, qtwebkit, qmake, makeWrapper, minizinc }:
 let
   version = "2.4.3";
 in
···
   enableParallelBuilding = true;
 
   postInstall = ''
-    wrapProgram $out/bin/MiniZincIDE --prefix PATH ":" ${stdenv.lib.makeBinPath [ minizinc ]}
+    wrapProgram $out/bin/MiniZincIDE --prefix PATH ":" ${lib.makeBinPath [ minizinc ]}
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://www.minizinc.org/";
     description = "IDE for MiniZinc, a medium-level constraint modelling language";
 

pkgs/development/tools/misc/abi-compliance-checker/default.nix

···
-{ stdenv, fetchFromGitHub, ctags, perl, binutils, abi-dumper }:
+{ lib, stdenv, fetchFromGitHub, ctags, perl, binutils, abi-dumper }:
 
 stdenv.mkDerivation rec {
   pname = "abi-compliance-checker";
···
 
   makeFlags = [ "prefix=$(out)" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://lvc.github.io/abi-compliance-checker";
     description = "A tool for checking backward API/ABI compatibility of a C/C++ library";
     license = licenses.lgpl21;

pkgs/development/tools/misc/abi-dumper/default.nix

···
-{ stdenv, fetchFromGitHub, ctags, perl, elfutils, vtable-dumper }:
+{ lib, stdenv, fetchFromGitHub, ctags, perl, elfutils, vtable-dumper }:
 
 stdenv.mkDerivation rec {
   pname = "abi-dumper";
···
   preBuild = "mkdir -p $out";
   makeFlags = [ "prefix=$(out)" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/lvc/abi-dumper";
     description = "Dump ABI of an ELF object containing DWARF debug info";
     license = licenses.lgpl21;

pkgs/development/tools/misc/arcanist/default.nix

···
 , fetchFromGitHub
 , flex
 , php
-, stdenv
+, lib, stdenv
 }:
 
 # Make a custom wrapper. If `wrapProgram` is used, arcanist thinks .arc-wrapped is being
···
   };
   buildInputs = [ bison flex php ];
 
-  postPatch = stdenv.lib.optionalString stdenv.isAarch64 ''
+  postPatch = lib.optionalString stdenv.isAarch64 ''
     substituteInPlace support/xhpast/Makefile \
       --replace "-minline-all-stringops" ""
   '';
···
   meta = {
     description = "Command line interface to Phabricator";
     homepage = "http://phabricator.org";
-    license = stdenv.lib.licenses.asl20;
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = [ stdenv.lib.maintainers.thoughtpolice ];
+    license = lib.licenses.asl20;
+    platforms = lib.platforms.unix;
+    maintainers = [ lib.maintainers.thoughtpolice ];
   };
 }

pkgs/development/tools/misc/argbash/default.nix

···
-{ stdenv, fetchFromGitHub, autoconf, runtimeShell, python3Packages, makeWrapper }:
+{ lib, stdenv, fetchFromGitHub, autoconf, runtimeShell, python3Packages, makeWrapper }:
 
 stdenv.mkDerivation rec {
   pname = "argbash";
···
       --prefix PATH : '${autoconf}/bin'
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Bash argument parsing code generator";
     homepage = "https://argbash.io/";
     license = licenses.free; # custom license.  See LICENSE in source repo.

pkgs/development/tools/misc/asls/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchurl
 , erlangR22
 }:
···
   buildInputs = [ erlangR22 ];
   installPhase = "install -Dm755 -t $out/bin asls";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "AssemblyScript Language Server";
     homepage = "https://github.com/saulecabrera/asls";
     license = licenses.mit;

pkgs/development/tools/misc/autobuild/default.nix

···
-{ fetchurl, stdenv, makeWrapper, perl, openssh, rsync }:
+{ fetchurl, lib, stdenv, makeWrapper, perl, openssh, rsync }:
 
 stdenv.mkDerivation rec {
   name = "autobuild-5.3";
···
     '';
 
     homepage = "https://josefsson.org/autobuild/";
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
   };
 }

pkgs/development/tools/misc/autoconf-archive/default.nix

···
-{ stdenv, fetchurl, xz }:
+{ lib, stdenv, fetchurl, xz }:
 
 stdenv.mkDerivation rec {
   pname = "autoconf-archive";
···
 
   buildInputs = [ xz ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Archive of autoconf m4 macros";
     homepage = "https://www.gnu.org/software/autoconf-archive/";
     license = licenses.gpl3;

pkgs/development/tools/misc/autoconf/2.13.nix

···
-{stdenv, fetchurl, m4, perl, lzma}:
+{lib, stdenv, fetchurl, m4, perl, lzma}:
 
 stdenv.mkDerivation rec {
   name = "autoconf-2.13";
···
       can use, in the form of M4 macro calls.
     '';
 
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/misc/autoconf/2.64.nix

···
-{ stdenv, fetchurl, m4, perl }:
+{ lib, stdenv, fetchurl, m4, perl }:
 
 stdenv.mkDerivation rec {
   name = "autoconf-2.64";
···
       can use, in the form of M4 macro calls.
     '';
 
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
 
-    platforms = stdenv.lib.platforms.all;
+    platforms = lib.platforms.all;
   };
 }

pkgs/development/tools/misc/autoconf/2.69.nix

···
-{ stdenv, fetchurl, m4, perl }:
+{ lib, stdenv, fetchurl, m4, perl }:
 
 stdenv.mkDerivation rec {
   name = "autoconf-2.69";
···
       can use, in the form of M4 macro calls.
     '';
 
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
 
-    platforms = stdenv.lib.platforms.all;
+    platforms = lib.platforms.all;
   };
 }

pkgs/development/tools/misc/autoconf/default.nix

···
-{ stdenv, fetchurl, m4, perl }:
+{ lib, stdenv, fetchurl, m4, perl }:
 
 # Note: this package is used for bootstrapping fetchurl, and thus
 # cannot use fetchpatch! All mutable patches (generated by GitHub or
···
       can use, in the form of M4 macro calls.
     '';
 
-    license = stdenv.lib.licenses.gpl3Plus;
+    license = lib.licenses.gpl3Plus;
 
-    platforms = stdenv.lib.platforms.all;
+    platforms = lib.platforms.all;
   };
 }

pkgs/development/tools/misc/autogen/default.nix

···
-{ stdenv, buildPackages, fetchurl, autoreconfHook, which, pkg-config, perl, guile, libxml2 }:
+{ lib, stdenv, buildPackages, fetchurl, autoreconfHook, which, pkg-config, perl, guile, libxml2 }:
 
 stdenv.mkDerivation rec {
   pname = "autogen";
···
 
   nativeBuildInputs = [
     which pkg-config perl autoreconfHook/*patches applied*/
-  ] ++ stdenv.lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
+  ] ++ lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
     # autogen needs a build autogen when cross-compiling
     buildPackages.buildPackages.autogen buildPackages.texinfo
   ];
···
       # Debian: https://salsa.debian.org/debian/autogen/-/blob/master/debian/rules#L21
       "--enable-timeout=78"
     ]
-    ++ (stdenv.lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
+    ++ (lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
       "--with-libxml2=${libxml2.dev}"
       "--with-libxml2-cflags=-I${libxml2.dev}/include/libxml2"
       # the configure check for regcomp wants to run a host program
···
       sed -e "s|$lib/lib|/no-such-autogen-lib-path|" -i $f
     done
 
-  '' + stdenv.lib.optionalString (!stdenv.hostPlatform.isDarwin) ''
+  '' + lib.optionalString (!stdenv.hostPlatform.isDarwin) ''
     # remove /build/** from RPATHs
     for f in "$bin"/bin/*; do
       local nrp="$(patchelf --print-rpath "$f" | sed -E 's@(:|^)/build/[^:]*:@\1@g')"
···
     done
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Automated text and program generation tool";
     license = with licenses; [ gpl3Plus lgpl3Plus ];
     homepage = "https://www.gnu.org/software/autogen/";

pkgs/development/tools/misc/automake/automake-1.11.x.nix

···
-{ stdenv, fetchurl, perl, autoconf }:
+{ lib, stdenv, fetchurl, perl, autoconf }:
 
 stdenv.mkDerivation rec {
   name = "automake-1.11.6";
···
       Standards.  Automake requires the use of Autoconf.
     '';
 
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
 
-    platforms = stdenv.lib.platforms.all;
+    platforms = lib.platforms.all;
   };
 }

pkgs/development/tools/misc/automake/automake-1.15.x.nix

···
-{ stdenv, fetchurl, perl, autoconf }:
+{ lib, stdenv, fetchurl, perl, autoconf }:
 
 stdenv.mkDerivation rec {
   name = "automake-1.15.1";
···
     branch = "1.15";
     homepage = "https://www.gnu.org/software/automake/";
     description = "GNU standard-compliant makefile generator";
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
 
     longDescription = ''
       GNU Automake is a tool for automatically generating
···
       Standards.  Automake requires the use of Autoconf.
     '';
 
-    platforms = stdenv.lib.platforms.all;
+    platforms = lib.platforms.all;
   };
 }

pkgs/development/tools/misc/automake/automake-1.16.x.nix

···
-{ stdenv, fetchurl, perl, autoconf }:
+{ lib, stdenv, fetchurl, perl, autoconf }:
 
 stdenv.mkDerivation rec {
   name = "automake-1.16.3";
···
     branch = "1.16";
     homepage = "https://www.gnu.org/software/automake/";
     description = "GNU standard-compliant makefile generator";
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
 
     longDescription = ''
       GNU Automake is a tool for automatically generating
···
       Standards.  Automake requires the use of Autoconf.
     '';
 
-    platforms = stdenv.lib.platforms.all;
+    platforms = lib.platforms.all;
   };
 }

pkgs/development/tools/misc/automoc4/default.nix

···
-{ stdenv, fetchurl, cmake, qt4 }:
+{ lib, stdenv, fetchurl, cmake, qt4 }:
 
 stdenv.mkDerivation rec {
   pname = "automoc4";
···
   nativeBuildInputs = [ cmake ];
   buildInputs = [ qt4 ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://techbase.kde.org/Development/Tools/Automoc4";
     description = "KDE Meta Object Compiler";
     license = licenses.bsd2;

pkgs/development/tools/misc/avrdude/default.nix

···
-{ stdenv, fetchurl, yacc, flex, libusb-compat-0_1, libelf, libftdi1, readline
+{ lib, stdenv, fetchurl, yacc, flex, libusb-compat-0_1, libelf, libftdi1, readline
 # docSupport is a big dependency, disabled by default
 , docSupport ? false, texLive ? null, texinfo ? null, texi2html ? null
 }:
···
     sha256 = "15m1w1qad3dj7r8n5ng1qqcaiyx1gyd6hnc3p2apgjllccdp77qg";
   };
 
-  configureFlags = stdenv.lib.optionals docSupport "--enable-doc";
+  configureFlags = lib.optionals docSupport "--enable-doc";
 
   buildInputs = [ yacc flex libusb-compat-0_1 libelf libftdi1 readline ]
-    ++ stdenv.lib.optionals docSupport [ texLive texinfo texi2html ];
+    ++ lib.optionals docSupport [ texLive texinfo texi2html ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Command-line tool for programming Atmel AVR microcontrollers";
     longDescription = ''
       AVRDUDE (AVR Downloader/UploaDEr) is an utility to

pkgs/development/tools/misc/awf/default.nix

···
-{ stdenv, fetchFromGitHub, autoreconfHook, gtk2, gtk3, pkg-config
+{ lib, stdenv, fetchFromGitHub, autoreconfHook, gtk2, gtk3, pkg-config
 , wrapGAppsHook }:
 
 stdenv.mkDerivation rec {
···
     ./autogen.sh
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A Widget Factory";
     longDescription = ''
       A widget factory is a theme preview application for gtk2 and

pkgs/development/tools/misc/babeltrace/default.nix

···
-{ stdenv, fetchurl, pkg-config, glib, libuuid, popt, elfutils }:
+{ lib, stdenv, fetchurl, pkg-config, glib, libuuid, popt, elfutils }:
 
 stdenv.mkDerivation rec {
   name = "babeltrace-1.5.8";
···
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ glib libuuid popt elfutils ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Command-line tool and library to read and convert LTTng tracefiles";
     homepage = "https://www.efficios.com/babeltrace";
     license = licenses.mit;

pkgs/development/tools/misc/bashdb/default.nix

···
-{ stdenv, fetchurl, makeWrapper, python3Packages }:
+{ lib, stdenv, fetchurl, makeWrapper, python3Packages }:
 
 stdenv.mkDerivation rec {
   pname = "bashdb";
···
   meta = {
     description = "Bash script debugger";
     homepage = "http://bashdb.sourceforge.net/";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/development/tools/misc/bin_replace_string/default.nix

···
-{ stdenv, fetchurl, libelf, txt2man }:
+{ lib, stdenv, fetchurl, libelf, txt2man }:
 
 stdenv.mkDerivation {
   pname = "bin_replace_string";
···
 
   enableParallelBuilding = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Edit precompiled binaries";
     longDescription = ''
       bin_replace_string edits C-style strings in precompiled binaries. This is

pkgs/development/tools/misc/bossa/default.nix

···
-{ stdenv, fetchgit, wxGTK, libX11, readline }:
+{ lib, stdenv, fetchgit, wxGTK, libX11, readline }:
 
 let
   # BOSSA needs a "bin2c" program to embed images.
···
     cp bin/bossa{c,sh,} $out/bin/
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A flash programming utility for Atmel's SAM family of flash-based ARM microcontrollers";
     longDescription = ''
       BOSSA is a flash programming utility for Atmel's SAM family of

pkgs/development/tools/misc/bsdbuild/default.nix

···
-{ stdenv, fetchurl, perl, libtool, pkg-config, gettext, mandoc, ed }:
+{ lib, stdenv, fetchurl, perl, libtool, pkg-config, gettext, mandoc, ed }:
 
 stdenv.mkDerivation rec {
   pname = "bsdbuild";
···
       directory, BSDBuild will produce the required Makefiles in place).
     '';
 
-    license = stdenv.lib.licenses.bsd3;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.bsd3;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/development/tools/misc/cbrowser/default.nix

···
-{ fetchurl, stdenv, tk, makeWrapper }:
+{ fetchurl, lib, stdenv, tk, makeWrapper }:
 
 stdenv.mkDerivation rec {
   name = "cbrowser-0.8";
···
   meta = {
     description = "Tcl/Tk GUI front-end to cscope";
 
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
 
     homepage = "https://sourceforge.net/projects/cbrowser/";
 
-    maintainers = with stdenv.lib.maintainers; [viric];
+    maintainers = with lib.maintainers; [viric];
 
-    platforms = with stdenv.lib.platforms; linux;
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/development/tools/misc/cc-tool/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchFromGitHub
 , autoreconfHook
 , boost
···
     install -D udev/90-cc-debugger.rules $out/lib/udev/rules.d/90-cc-debugger.rules
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Command line tool for the Texas Instruments CC Debugger";
     longDescription = ''
       cc-tool provides support for Texas Instruments CC Debugger

pkgs/development/tools/misc/ccache/default.nix

···
           local cname="$1"
           if [ -x "${unwrappedCC}/bin/$cname" ]; then
             makeWrapper ${ccache}/bin/ccache $out/bin/$cname \
-              --run ${stdenv.lib.escapeShellArg extraConfig} \
+              --run ${lib.escapeShellArg extraConfig} \
               --add-flags ${unwrappedCC}/bin/$cname
           fi
         }
···
     };
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Compiler cache for fast recompilation of C/C++ code";
     homepage = "https://ccache.dev";
     downloadPage = "https://ccache.dev/download.html";

pkgs/development/tools/misc/ccls/default.nix

···
-{ stdenv, fetchFromGitHub
+{ lib, stdenv, fetchFromGitHub
 , cmake, llvmPackages, rapidjson, runtimeShell }:
 
 stdenv.mkDerivation rec {
···
   postFixup = ''
     # We need to tell ccls where to find the standard library headers.
 
-    standard_library_includes="\\\"-isystem\\\", \\\"${stdenv.lib.getDev stdenv.cc.libc}/include\\\""
+    standard_library_includes="\\\"-isystem\\\", \\\"${lib.getDev stdenv.cc.libc}/include\\\""
     standard_library_includes+=", \\\"-isystem\\\", \\\"${llvmPackages.libcxx}/include/c++/v1\\\""
     export standard_library_includes
 
···
     chmod --reference=$out/bin/$wrapped $out/bin/ccls
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A c/c++ language server powered by clang";
     homepage    = "https://github.com/MaskRay/ccls";
     license     = licenses.asl20;

pkgs/development/tools/misc/cflow/default.nix

···
-{ stdenv, fetchurl, gettext, emacs }:
+{ lib, stdenv, fetchurl, gettext, emacs }:
 
 stdenv.mkDerivation rec {
   name = "cflow-1.6";
···
 
   buildInputs = [ gettext ] ++
     # We don't have Emacs/GTK/etc. on {Dar,Cyg}win.
-    stdenv.lib.optional
-      (! (stdenv.lib.lists.any (x: stdenv.hostPlatform.system == x)
+    lib.optional
+      (! (lib.lists.any (x: stdenv.hostPlatform.system == x)
               [ "i686-cygwin" ]))
       emacs;
 
   doCheck = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Tool to analyze the control flow of C programs";
 
     longDescription = ''

pkgs/development/tools/misc/cgdb/default.nix

···
-{ stdenv, fetchurl, ncurses, readline, flex, texinfo }:
+{ lib, stdenv, fetchurl, ncurses, readline, flex, texinfo }:
 
 stdenv.mkDerivation rec {
   pname = "cgdb";
···
 
   buildInputs = [ ncurses readline flex texinfo ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A curses interface to gdb";
 
     homepage = "https://cgdb.github.io/";

pkgs/development/tools/misc/checkbashisms/default.nix

···
-{ stdenv, fetchurl, perl }:
+{ lib, stdenv, fetchurl, perl }:
 stdenv.mkDerivation rec {
   version = "2.0.0.2";
   pname = "checkbashisms";
···
   meta = {
     homepage = "https://sourceforge.net/projects/checkbaskisms/";
     description = "Check shell scripts for non-portable syntax";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/misc/chrpath/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 
 stdenv.mkDerivation {
   name = "chrpath-0.16";
···
     sha256 = "0yvfq891mcdkf8g18gjjkn2m5rvs8z4z4cl1vwdhx6f2p9a4q3dv";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Command line tool to adjust the RPATH or RUNPATH of ELF binaries";
     longDescription = ''
       chrpath changes, lists or removes the rpath or runpath setting in a

pkgs/development/tools/misc/circleci-cli/default.nix

···
-{ stdenv, fetchFromGitHub, buildGoModule }:
+{ lib, stdenv, fetchFromGitHub, buildGoModule }:
 
 buildGoModule rec {
   pname = "circleci-cli";
···
     install -Dm644 -t $out/share/circleci-cli _data/data.yml
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     # Box blurb edited from the AUR package circleci-cli
     description = ''
       Command to enable you to reproduce the CircleCI environment locally and

pkgs/development/tools/misc/cl-launch/default.nix

···
-{stdenv, fetchurl}:
+{lib, stdenv, fetchurl}:
 let
   s = # Generated upstream information
   rec {
···
   meta = {
     inherit (s) version;
     description = ''Common Lisp launcher script'';
-    license = stdenv.lib.licenses.llgpl21 ;
-    maintainers = [stdenv.lib.maintainers.raskin];
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.llgpl21 ;
+    maintainers = [lib.maintainers.raskin];
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/misc/cli11/default.nix

···
 {
-  stdenv,
+  lib, stdenv,
   fetchFromGitHub,
   cmake,
   gtest,
···
     sed -i '/TrueFalseTest/d' tests/CMakeLists.txt
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Command line parser for C++11";
     homepage = "https://github.com/CLIUtils/CLI11";
     platforms = platforms.unix;

pkgs/development/tools/misc/clojure-lsp/default.nix

···
-{ stdenv, fetchurl, jre, makeWrapper }:
+{ lib, stdenv, fetchurl, jre, makeWrapper }:
 
 stdenv.mkDerivation rec {
   pname = "clojure-lsp";
···
       --add-flags "-jar $out/share/java/${pname}.jar"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Language Server Protocol (LSP) for Clojure";
     homepage = "https://github.com/snoe/clojure-lsp";
     license = licenses.mit;

pkgs/development/tools/misc/coccinelle/default.nix

···
-{ fetchurl, stdenv, python, ncurses, ocamlPackages, pkg-config }:
+{ fetchurl, lib, stdenv, python, ncurses, ocamlPackages, pkg-config }:
 
 stdenv.mkDerivation rec {
   pname = "coccinelle";
···
     '';
 
     homepage = "http://coccinelle.lip6.fr/";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = [ stdenv.lib.maintainers.thoughtpolice ];
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.unix;
+    maintainers = [ lib.maintainers.thoughtpolice ];
   };
 }

pkgs/development/tools/misc/complexity/default.nix

···
-{ fetchurl, stdenv, autogen }:
+{ fetchurl, lib, stdenv, autogen }:
 
 stdenv.mkDerivation rec {
   pname = "complexity";
···
          addresses several issues not considered in that scoring scheme.
       '';
 
-    license = stdenv.lib.licenses.gpl3Plus;
+    license = lib.licenses.gpl3Plus;
 
     homepage = "https://www.gnu.org/software/complexity/";
 
-    platforms = stdenv.lib.platforms.gnu ++ stdenv.lib.platforms.linux;
+    platforms = lib.platforms.gnu ++ lib.platforms.linux;
     maintainers = [ ];
   };
 }

pkgs/development/tools/misc/cppi/default.nix

···
-{ fetchurl, stdenv }:
+{ fetchurl, lib, stdenv }:
 
 stdenv.mkDerivation rec {
   name = "cppi-1.18";
···
          to the level of nesting of that directive.
       '';
 
-    license = stdenv.lib.licenses.gpl3Plus;
+    license = lib.licenses.gpl3Plus;
 
     maintainers = [ ];
-    platforms = stdenv.lib.platforms.all;
+    platforms = lib.platforms.all;
   };
 }

pkgs/development/tools/misc/cproto/default.nix

···
-{ stdenv, fetchurl, flex, bison }:
+{ lib, stdenv, fetchurl, flex, bison }:
 
 stdenv.mkDerivation rec {
   pname = "cproto";
···
     [ "$("$out/bin/cproto" -V 2>&1)" = '${version}' ]
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Tool to generate C function prototypes from C source code";
     homepage = "https://invisible-island.net/cproto/";
     license = licenses.publicDomain;

pkgs/development/tools/misc/creduce/default.nix

···
-{ stdenv, fetchurl, cmake, makeWrapper
+{ lib, stdenv, fetchurl, cmake, makeWrapper
 , llvm, clang-unwrapped
 , flex
 , zlib
···
   # On Linux, c-reduce's preferred way to reason about
   # the cpu architecture/topology is to use 'lscpu',
   # so let's make sure it knows where to find it:
-  postPatch = stdenv.lib.optionalString stdenv.isLinux ''
+  postPatch = lib.optionalString stdenv.isLinux ''
     substituteInPlace creduce/creduce_utils.pm --replace \
       lscpu ${util-linux}/bin/lscpu
   '';
···
     wrapProgram $out/bin/creduce --prefix PERL5LIB : "$PERL5LIB"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A C program reducer";
     homepage = "https://embed.cs.utah.edu/creduce";
     # Officially, the license is: https://github.com/csmith-project/creduce/blob/master/COPYING

pkgs/development/tools/misc/cscope/default.nix

···
-{ fetchurl, stdenv, ncurses
+{ fetchurl, lib, stdenv, ncurses
 , emacsSupport ? true, emacs
 }:
 
···
   configureFlags = [ "--with-ncurses=${ncurses.dev}" ];
 
   buildInputs = [ ncurses ];
-  nativeBuildInputs = stdenv.lib.optional emacsSupport emacs;
+  nativeBuildInputs = lib.optional emacsSupport emacs;
 
-  postInstall = stdenv.lib.optionalString emacsSupport ''
+  postInstall = lib.optionalString emacsSupport ''
     cd "contrib/xcscope"
 
     sed -i "cscope-indexer" \
···
 
     homepage = "http://cscope.sourceforge.net/";
 
-    maintainers = with stdenv.lib.maintainers; [viric];
+    maintainers = with lib.maintainers; [viric];
 
-    platforms = stdenv.lib.platforms.unix;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/misc/csmith/default.nix

···
-{ stdenv, fetchurl, m4, makeWrapper, libbsd, perlPackages }:
+{ lib, stdenv, fetchurl, m4, makeWrapper, libbsd, perlPackages }:
 
 stdenv.mkDerivation rec {
   pname = "csmith";
···
 
   enableParallelBuilding = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A random generator of C programs";
     homepage = "https://embed.cs.utah.edu/csmith";
     # Officially, the license is this: https://github.com/csmith-project/csmith/blob/master/COPYING

pkgs/development/tools/misc/ctags/default.nix

···
-{ stdenv, fetchsvn, autoreconfHook }:
+{ lib, stdenv, fetchsvn, autoreconfHook }:
 
 stdenv.mkDerivation rec {
   name = "ctags-${revision}";
···
   # don't use $T(E)MP which is set to the build directory
   configureFlags= [ "--enable-tmpdir=/tmp" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A tool for fast source code browsing (exuberant ctags)";
     longDescription = ''
       Ctags generates an index (or tag) file of language objects found

pkgs/development/tools/misc/cwebbin/default.nix

···
-{ stdenv, fetchFromGitHub, fetchurl, tie }:
+{ lib, stdenv, fetchFromGitHub, fetchurl, tie }:
 
 stdenv.mkDerivation rec {
   pname = "cwebbin";
···
     make -f Makefile.unix install $makeFlags
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     inherit (src.meta) homepage;
     description = "Literate Programming in C/C++";
     platforms = with platforms; unix;

pkgs/development/tools/misc/d-feet/default.nix

···
-{ stdenv
+{ lib, stdenv
 , pkg-config
 , fetchurl
 , meson
···
   format = "other";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/d-feet/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    url = "mirror://gnome/sources/d-feet/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "1cgxgpj546jgpyns6z9nkm5k48lid8s36mvzj8ydkjqws2d19zqz";
   };
 
···
     };
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "D-Feet is an easy to use D-Bus debugger";
     longDescription = ''
       D-Feet can be used to inspect D-Bus interfaces of running programs

pkgs/development/tools/misc/dbench/default.nix

···
-{ stdenv, fetchgit, autoconf, popt, zlib, rpcsvc-proto, libtirpc }:
+{ lib, stdenv, fetchgit, autoconf, popt, zlib, rpcsvc-proto, libtirpc }:
 
 stdenv.mkDerivation {
   name = "dbench-2013-01-01";
···
     ln -s dbench/doc/dbench/loadfiles $out/share/loadfiles
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Filesystem benchmark tool based on load patterns";
     homepage = "https://dbench.samba.org/";
     license = licenses.gpl3;

pkgs/development/tools/misc/ddd/default.nix

···
-{stdenv, fetchurl, motif, ncurses, libX11, libXt}:
+{lib, stdenv, fetchurl, motif, ncurses, libX11, libXt}:
 
 stdenv.mkDerivation rec {
   name = "ddd-3.3.12";
···
   meta = {
     homepage = "https://www.gnu.org/software/ddd";
     description = "Graphical front-end for command-line debuggers";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/development/tools/misc/dejagnu/default.nix

···
-{ fetchurl, stdenv, expect, makeWrapper }:
+{ fetchurl, lib, stdenv, expect, makeWrapper }:
 
 stdenv.mkDerivation rec {
   name = "dejagnu-1.6.2";
···
       --prefix PATH ":" "${expect}/bin"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Framework for testing other programs";
 
     longDescription = ''

pkgs/development/tools/misc/dfu-programmer/default.nix

···
-{ stdenv, fetchurl, libusb-compat-0_1 }:
+{ lib, stdenv, fetchurl, libusb-compat-0_1 }:
 let
   version = "0.7.2";
 in
···
 
   configureFlags = [ "--disable-libusb_1_0" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     license = licenses.gpl2;
     description = "A Device Firmware Update based USB programmer for Atmel chips with a USB bootloader";
     homepage = "http://dfu-programmer.sourceforge.net/";

pkgs/development/tools/misc/dfu-util/default.nix

···
-{ stdenv, fetchurl, pkg-config, libusb1 }:
+{ lib, stdenv, fetchurl, pkg-config, libusb1 }:
 
 stdenv.mkDerivation rec {
   pname = "dfu-util";
···
     sha256 = "0hlvc47ccf5hry13saqhc1j5cdq5jyjv4i05kj0mdh3rzj6wagd0";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Device firmware update (DFU) USB programmer";
     longDescription = ''
       dfu-util is a program that implements the host (PC) side of the USB

pkgs/development/tools/misc/dialog/default.nix

···
-{ stdenv, fetchurl
+{ lib, stdenv, fetchurl
 , ncurses
 , withLibrary ? false, libtool
 , unicodeSupport ? true
···
 
   configureFlags = [
     "--disable-rpath-hacks"
-    (stdenv.lib.withFeature withLibrary "libtool")
-    "--with-ncurses${stdenv.lib.optionalString unicodeSupport "w"}"
-    "--with-libtool-opts=${stdenv.lib.optionalString enableShared "-shared"}"
+    (lib.withFeature withLibrary "libtool")
+    "--with-ncurses${lib.optionalString unicodeSupport "w"}"
+    "--with-libtool-opts=${lib.optionalString enableShared "-shared"}"
   ];
 
-  installTargets = [ "install${stdenv.lib.optionalString withLibrary "-full"}" ];
+  installTargets = [ "install${lib.optionalString withLibrary "-full"}" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://invisible-island.net/dialog/dialog.html";
     description = "Display dialog boxes from shell";
     license = licenses.lgpl21Plus;

pkgs/development/tools/misc/direvent/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchurl
 }:
 
···
     sha256 = "0m9vi01b1km0cpknflyzsjnknbava0s1n6393b2bpjwyvb6j5613";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Directory event monitoring daemon";
     homepage = "https://www.gnu.org.ua/software/direvent/";
     license = licenses.gpl3Plus;

pkgs/development/tools/misc/distcc/default.nix

···
-{ stdenv, fetchFromGitHub, popt, avahi, pkg-config, python, gtk2, runCommand
+{ lib, stdenv, fetchFromGitHub, popt, avahi, pkg-config, python, gtk2, runCommand
 , gcc, autoconf, automake, which, procps, libiberty_static
 , runtimeShell
 , sysconfDir ? ""   # set this parameter to override the default value $out/etc
···
       homepage = "http://distcc.org";
       license = "GPL";
 
-      platforms = stdenv.lib.platforms.linux;
-      maintainers = with stdenv.lib.maintainers; [ anderspapitto ];
+      platforms = lib.platforms.linux;
+      maintainers = with lib.maintainers; [ anderspapitto ];
     };
   };
 in

pkgs/development/tools/misc/distcc/masq.nix

···
-{ stdenv, gccRaw, binutils }:
+{ lib, stdenv, gccRaw, binutils }:
 
 stdenv.mkDerivation {
   name = "distcc-masq-${gccRaw.name}";
···
   '';
 
   meta = {
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/development/tools/misc/doclifter/default.nix

···
-{stdenv, fetchurl, python}:
+{lib, stdenv, fetchurl, python}:
 
 stdenv.mkDerivation {
   name = "doclifter-2.19";
···
     description = "Lift documents in nroff markups to XML-DocBook";
     homepage = "http://www.catb.org/esr/doclifter";
     license = "BSD";
-    platforms = stdenv.lib.platforms.unix;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/misc/docopts/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "docopts";
···
     install -D -m 755 ./go/src/$goPackagePath/docopts.sh $out/bin/docopts.sh
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/docopt/${pname}";
     description = "docopt CLI tool for shell scripting";
     license = licenses.mit;

pkgs/development/tools/misc/drush/default.nix

···
-{ stdenv, fetchurl, php73, which, makeWrapper, bash, coreutils, ncurses }:
+{ lib, stdenv, fetchurl, php73, which, makeWrapper, bash, coreutils, ncurses }:
 
 stdenv.mkDerivation rec {
   name = "drush-6.1.0";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Command-line shell and Unix scripting interface for Drupal";
     homepage    = "https://github.com/drush-ops/drush";
     license     = licenses.gpl2;
···
     mkdir -p "$out"
     cp -r . "$out/src"
     mkdir "$out/bin"
-    wrapProgram "$out/src/drush" --prefix PATH : "${stdenv.lib.makeBinPath [ which php73 bash coreutils ncurses ]}"
+    wrapProgram "$out/src/drush" --prefix PATH : "${lib.makeBinPath [ which php73 bash coreutils ncurses ]}"
     ln -s "$out/src/drush" "$out/bin/drush"
   '';
 }

pkgs/development/tools/misc/editorconfig-core-c/default.nix

···
-{ stdenv, fetchgit, cmake, pcre, doxygen }:
+{ lib, stdenv, fetchgit, cmake, pcre, doxygen }:
 
 stdenv.mkDerivation rec {
   name = "editorconfig-core-c-${meta.version}";
···
   # parallel: https://bugzilla.gnome.org/show_bug.cgi?id=791153
   enableParallelBuilding = false;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://editorconfig.org/";
     description = "EditorConfig core library written in C";
     longDescription = ''

pkgs/development/tools/misc/eggdbus/default.nix

···
-{ stdenv, fetchurl, pkg-config, glib, dbus, dbus-glib }:
+{ lib, stdenv, fetchurl, pkg-config, glib, dbus, dbus-glib }:
 
 stdenv.mkDerivation rec {
   name = "eggdbus-0.6";
···
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ glib dbus dbus-glib ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://hal.freedesktop.org/releases/";
     description = "D-Bus bindings for GObject";
     platforms = platforms.linux;

pkgs/development/tools/misc/elfinfo/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "elfinfo";
···
     sha256 = "1n8bg0rcq9fqa6rdnk6x9ngvm59hcayblkpjv9j5myn2vmm6fv8m";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Small utility for showing information about ELF files";
     homepage = "https://elfinfo.roboticoverlords.org/";
     license = licenses.mit;

pkgs/development/tools/misc/elfkickers/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
   pname = "elfkickers";
···
 
   enableParallelBuilding = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "http://www.muppetlabs.com/~breadbox/software/elfkickers.html";
     description = "A collection of programs that access and manipulate ELF files";
     platforms = platforms.linux;

pkgs/development/tools/misc/epm/default.nix

···
-{stdenv, fetchFromGitHub, rpm}:
+{lib, stdenv, fetchFromGitHub, rpm}:
 
 stdenv.mkDerivation rec {
   pname = "epm";
···
     sed -i 's/README/README.md/' Makefile
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "The ESP Package Manager generates distribution archives for a variety of platforms";
     homepage = "https://www.msweet.org/projects.php?Z2";
     license = licenses.gpl2;

pkgs/development/tools/misc/findnewest/default.nix

···
-{ stdenv, fetchFromGitHub, autoreconfHook }:
+{ lib, stdenv, fetchFromGitHub, autoreconfHook }:
 
 stdenv.mkDerivation rec {
   pname = "findnewest";
···
 
   nativeBuildInputs = [ autoreconfHook ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/0-wiz-0/findnewest";
     description = "Recursively find newest file in a hierarchy and print its timestamp";
     license = licenses.bsd2;

pkgs/development/tools/misc/fsatrace/default.nix

···
-{ stdenv, fetchFromGitHub }:
+{ lib, stdenv, fetchFromGitHub }:
 
 stdenv.mkDerivation rec {
   pname = "fsatrace";
···
     ln -s $out/$installDir/fsatrace $out/bin/fsatrace
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/jacereda/fsatrace";
     description = "filesystem access tracer";
     license = licenses.isc;

pkgs/development/tools/misc/fswatch/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchFromGitHub
 , autoreconfHook
                      # for xargs
···
     sha256 = "11479ac436g8bwk0lfnmdms0cirv9k11pdvfrrg9jwkki1j1abkk";
   };
 
-  nativeBuildInputs = [ autoreconfHook ] ++ stdenv.lib.optionals stdenv.isDarwin [ CoreServices ];
+  nativeBuildInputs = [ autoreconfHook ] ++ lib.optionals stdenv.isDarwin [ CoreServices ];
   buildInputs = [ gettext libtool makeWrapper texinfo ];
 
   enableParallelBuilding = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A cross-platform file change monitor with multiple backends";
     homepage = "https://github.com/emcrisostomo/fswatch";
     license = licenses.gpl3Plus;

pkgs/development/tools/misc/fujprog/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchFromGitHub
 , cmake
 , pkg-config
···
   buildInputs = [
     libftdi1
     libusb-compat-0_1
-  ] ++ stdenv.lib.optionals stdenv.isDarwin [ IOKit ];
+  ] ++ lib.optionals stdenv.isDarwin [ IOKit ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "JTAG programmer for the ULX3S and ULX2S open hardware FPGA development boards";
     homepage = "https://github.com/kost/fujprog";
     license = licenses.bsd2;

pkgs/development/tools/misc/gdb/default.nix

···
-{ stdenv, targetPackages
+{ lib, stdenv, targetPackages
 
 # Build time
 , fetchurl, pkg-config, perl, texinfo, setupDebugInfoDirs, buildPackages
···
 
 let
   basename = "gdb";
-  targetPrefix = stdenv.lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform)
+  targetPrefix = lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform)
                  "${stdenv.targetPlatform.config}-";
 in
 
···
 
   patches = [
     ./debug-info-from-env.patch
-  ] ++ stdenv.lib.optionals stdenv.isDarwin [
+  ] ++ lib.optionals stdenv.isDarwin [
     ./darwin-target-match.patch
   ];
 
   nativeBuildInputs = [ pkg-config texinfo perl setupDebugInfoDirs ];
 
   buildInputs = [ ncurses readline gmp mpfr expat libipt zlib guile ]
-    ++ stdenv.lib.optional pythonSupport python3
-    ++ stdenv.lib.optional doCheck dejagnu;
+    ++ lib.optional pythonSupport python3
+    ++ lib.optional doCheck dejagnu;
 
   propagatedNativeBuildInputs = [ setupDebugInfoDirs ];
 
···
   enableParallelBuilding = true;
 
   # darwin build fails with format hardening since v7.12
-  hardeningDisable = stdenv.lib.optionals stdenv.isDarwin [ "format" ];
+  hardeningDisable = lib.optionals stdenv.isDarwin [ "format" ];
 
   NIX_CFLAGS_COMPILE = "-Wno-format-nonliteral";
 
   # TODO(@Ericson2314): Always pass "--target" and always prefix.
-  configurePlatforms = [ "build" "host" ] ++ stdenv.lib.optional (stdenv.targetPlatform != stdenv.hostPlatform) "target";
+  configurePlatforms = [ "build" "host" ] ++ lib.optional (stdenv.targetPlatform != stdenv.hostPlatform) "target";
 
   # GDB have to be built out of tree.
   preConfigure = ''
···
   '';
   configureScript = "../configure";
 
-  configureFlags = with stdenv.lib; [
+  configureFlags = with lib; [
     "--enable-targets=all" "--enable-64-bit-bfd"
     "--disable-install-libbfd"
     "--disable-shared" "--enable-static"
···
     "--with-mpfr=${mpfr.dev}"
     "--with-expat" "--with-libexpat-prefix=${expat.dev}"
     "--with-auto-load-safe-path=${builtins.concatStringsSep ":" safePaths}"
-  ] ++ stdenv.lib.optional (!pythonSupport) "--without-python";
+  ] ++ lib.optional (!pythonSupport) "--without-python";
 
   postInstall =
     '' # Remove Info files already provided by Binutils and other packages.
···
   # TODO: Investigate & fix the test failures.
   doCheck = false;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "The GNU Project debugger";
 
     longDescription = ''
···
 
     homepage = "https://www.gnu.org/software/gdb/";
 
-    license = stdenv.lib.licenses.gpl3Plus;
+    license = lib.licenses.gpl3Plus;
 
     platforms = with platforms; linux ++ cygwin ++ darwin;
     maintainers = with maintainers; [ pierron globin lsix ];

pkgs/development/tools/misc/gdbgui/default.nix

···
-{ stdenv
+{ lib, stdenv
 , buildPythonApplication
 , fetchPypi
 , gdb
···
 
   postInstall = ''
     wrapProgram $out/bin/gdbgui \
-      --prefix PATH : ${stdenv.lib.makeBinPath [ gdb ]}
+      --prefix PATH : ${lib.makeBinPath [ gdb ]}
   '';
 
   # tests do not work without stdout/stdin
   doCheck = false;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A browser-based frontend for GDB";
     homepage = "https://www.gdbgui.com/";
     license = licenses.gpl3;

pkgs/development/tools/misc/gengetopt/default.nix

···
-{ fetchurl, stdenv, texinfo, help2man }:
+{ fetchurl, lib, stdenv, texinfo, help2man }:
 
 stdenv.mkDerivation rec {
   pname = "gengetopt";
···
 
     homepage = "https://www.gnu.org/software/gengetopt/";
 
-    license = stdenv.lib.licenses.gpl3Plus;
+    license = lib.licenses.gpl3Plus;
 
     maintainers = [ ];
-    platforms = stdenv.lib.platforms.all;
+    platforms = lib.platforms.all;
   };
 }

pkgs/development/tools/misc/global/default.nix

···
-{ fetchurl, stdenv, libtool, makeWrapper
+{ fetchurl, lib, stdenv, libtool, makeWrapper
 , coreutils, ctags, ncurses, pythonPackages, sqlite, universal-ctags
 }:
 
···
       --prefix PYTHONPATH : "$(toPythonPath ${pythonPackages.pygments})"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Source code tag system";
     longDescription = ''
       GNU GLOBAL is a source code tagging system that works the same way

pkgs/development/tools/misc/gnum4/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 
 # Note: this package is used for bootstrapping fetchurl, and thus
 # cannot use fetchpatch! All mutable patches (generated by GitHub or
···
         sha256 = "12lmdnbml9lfvy0khpjc42riicddaz7li8wmbnsam7zsw6al11qk";
       })
     ]
-    ++ stdenv.lib.optional stdenv.isDarwin ./darwin-secure-format.patch;
+    ++ lib.optional stdenv.isDarwin ./darwin-secure-format.patch;
 
   meta = {
     homepage = "https://www.gnu.org/software/m4/";
···
       compiler or as a macro processor in its own right.
     '';
 
-    license = stdenv.lib.licenses.gpl3Plus;
-    platforms = stdenv.lib.platforms.unix ++ stdenv.lib.platforms.windows;
+    license = lib.licenses.gpl3Plus;
+    platforms = lib.platforms.unix ++ lib.platforms.windows;
   };
 
 }

pkgs/development/tools/misc/gob2/default.nix

···
-{ stdenv, fetchurl, pkg-config, glib, bison, flex, gnome3 }:
+{ lib, stdenv, fetchurl, pkg-config, glib, bison, flex, gnome3 }:
 
 stdenv.mkDerivation rec {
   pname = "gob2";
   version = "2.0.20";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "5fe5d7990fd65b0d4b617ba894408ebaa6df453f2781c15a1cfdf2956c0c5428";
   };
 
···
   meta = {
     description = "Preprocessor for making GObjects with inline C code";
     homepage = "https://www.jirka.org/gob.html";
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/misc/gperf/3.0.x.nix

···
-{stdenv, fetchurl, autoreconfHook }:
+{lib, stdenv, fetchurl, autoreconfHook }:
 
 stdenv.mkDerivation rec {
   name = "gperf-3.0.4";
···
       employed by gperf.
     '';
 
-    license = stdenv.lib.licenses.gpl3Plus;
+    license = lib.licenses.gpl3Plus;
 
     homepage = "https://www.gnu.org/software/gperf/";
-    platforms = stdenv.lib.platforms.unix;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/misc/gperf/default.nix

···
-{stdenv, fetchurl}:
+{lib, stdenv, fetchurl}:
 
 stdenv.mkDerivation rec {
   name = "gperf-3.1";
···
       employed by gperf.
     '';
 
-    license = stdenv.lib.licenses.gpl3Plus;
+    license = lib.licenses.gpl3Plus;
 
     homepage = "https://www.gnu.org/software/gperf/";
-    platforms = stdenv.lib.platforms.unix;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/misc/gpshell/default.nix

···
-{ stdenv, fetchurl, pkg-config, globalplatform, pcsclite, gppcscconnectionplugin
+{ lib, stdenv, fetchurl, pkg-config, globalplatform, pcsclite, gppcscconnectionplugin
 , makeWrapper
 }:
 
···
     wrapProgram "$out/bin/gpshell" --prefix LD_LIBRARY_PATH : "${gppcscconnectionplugin}/lib"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://sourceforge.net/p/globalplatform/wiki/Home/";
     description = "Smartcard management application";
     license = licenses.gpl3;

pkgs/development/tools/misc/gputils/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
   pname = "gputils";
···
     sha256 = "055v83fdgqljprapf7rmh8x66mr13fj0qypj49xba5spx0ca123g";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://gputils.sourceforge.io";
     description = "A collection of tools for the Microchip (TM) PIC microcontrollers. It includes gpasm, gplink, and gplib";
     license = licenses.gpl2;

pkgs/development/tools/misc/gtkdialog/default.nix

···
-{stdenv, fetchurl, gtk2, pkg-config }:
+{lib, stdenv, fetchurl, gtk2, pkg-config }:
 
 stdenv.mkDerivation {
   name = "gtkdialog-0.8.3";
···
     homepage = "https://code.google.com/archive/p/gtkdialog/";
     # community links: http://murga-linux.com/puppy/viewtopic.php?t=111923 -> https://github.com/01micko/gtkdialog
     description = "Small utility for fast and easy GUI building from many scripted and compiled languages";
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/development/tools/misc/gtkperf/default.nix

···
-{ stdenv, fetchurl, gtk2, pkg-config, libintl }:
+{ lib, stdenv, fetchurl, gtk2, pkg-config, libintl }:
 
 stdenv.mkDerivation {
   name = "gtkperf-0.40.0";
···
   # https://openbenchmarking.org/innhold/7e9780c11550d09aa67bdba71248facbe2d781db
   patches = [ ./bench.patch ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Application designed to test GTK performance";
     homepage = "http://gtkperf.sourceforge.net/";
     license = with licenses; [ gpl2 ];

pkgs/development/tools/misc/help2man/default.nix

···
-{ stdenv, fetchurl, perlPackages, gettext }:
+{ lib, stdenv, fetchurl, perlPackages, gettext }:
 
 # Note: this package is used for bootstrapping fetchurl, and thus
 # cannot use fetchpatch! All mutable patches (generated by GitHub or
···
     cat > $out/bin/help2man <<EOF
     #! $SHELL -e
     export PERL5LIB=\''${PERL5LIB:+:}${perlPackages.LocaleGettext}/${perlPackages.perl.libPrefix}
-    ${stdenv.lib.optionalString stdenv.hostPlatform.isCygwin
+    ${lib.optionalString stdenv.hostPlatform.isCygwin
         ''export PATH=\''${PATH:+:}${gettext}/bin''}
     exec -a \$0 $out/bin/.help2man-wrapped "\$@"
     EOF
     chmod +x $out/bin/help2man
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Generate man pages from `--help' output";
 
     longDescription =

pkgs/development/tools/misc/hound/default.nix

···
-{ stdenv
+{ lib, stdenv
 , buildGoPackage
 , fetchFromGitHub
 , makeWrapper
···
     inherit (src.meta) homepage;
 
     description = "Lightning fast code searching made easy";
-    license = stdenv.lib.licenses.mit;
-    maintainers = with stdenv.lib.maintainers; [ grahamc ];
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ grahamc ];
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/misc/hydra-cli/default.nix

···
     pkg-config
   ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A client for the Hydra CI";
     homepage = "https://github.com/nlewo/hydra-cli";
     license = with licenses; [ mit ];

pkgs/development/tools/misc/hydra/common.nix

···
 
   passthru = { inherit perlDeps migration tests; };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Nix-based continuous build system";
     license = licenses.gpl3;
     platforms = platforms.linux;

pkgs/development/tools/misc/icon-naming-utils/default.nix

···
-{stdenv, fetchurl, perlPackages, librsvg}:
+{lib, stdenv, fetchurl, perlPackages, librsvg}:
 
 stdenv.mkDerivation rec {
   name = "icon-naming-utils-0.8.90";
···
           --replace '/bin/perl' '/bin/perl -I${perlPackages.XMLSimple}/${perlPackages.perl.libPrefix}'
     '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "http://tango.freedesktop.org/Standard_Icon_Naming_Specification";
     platforms = with platforms; linux ++ darwin;
     license = licenses.gpl2;

pkgs/development/tools/misc/igprof/default.nix

···
-{stdenv, fetchFromGitHub, libunwind, cmake, pcre, gdb}:
+{lib, stdenv, fetchFromGitHub, libunwind, cmake, pcre, gdb}:
 
 stdenv.mkDerivation rec {
   version = "5.9.16";
···
       details and see the big picture from combined workloads.
     '';
 
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
 
     homepage = "https://igprof.org/";
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = with stdenv.lib.maintainers; [ ktf ];
+    platforms = lib.platforms.linux;
+    maintainers = with lib.maintainers; [ ktf ];
   };
 }

pkgs/development/tools/misc/indent/default.nix

···
-{ stdenv, fetchurl, texinfo }:
+{ lib, stdenv, fetchurl, texinfo }:
 
 stdenv.mkDerivation rec {
   name = "indent-2.2.12";
···
 
   buildInputs = [ texinfo ];
 
-  NIX_CFLAGS_COMPILE = stdenv.lib.optionalString stdenv.cc.isClang
+  NIX_CFLAGS_COMPILE = lib.optionalString stdenv.cc.isClang
     "-Wno-implicit-function-declaration";
 
   hardeningDisable = [ "format" ];
···
   meta = {
     homepage = "https://www.gnu.org/software/indent/";
     description = "A source code reformatter";
-    license = stdenv.lib.licenses.gpl3Plus;
-    maintainers = [ stdenv.lib.maintainers.mmahut ];
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.gpl3Plus;
+    maintainers = [ lib.maintainers.mmahut ];
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/misc/inotify-tools/default.nix

···
-{ stdenv, autoreconfHook, fetchFromGitHub, fetchpatch }:
+{ lib, stdenv, autoreconfHook, fetchFromGitHub, fetchpatch }:
 
 stdenv.mkDerivation rec {
   pname = "inotify-tools";
···
 
   nativeBuildInputs = [ autoreconfHook ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/rvoicilas/inotify-tools/wiki";
     license = licenses.gpl2;
     maintainers = with maintainers; [ marcweber pSub ];

pkgs/development/tools/misc/intel-gpu-tools/default.nix

···
-{ stdenv, fetchurl, pkg-config, libdrm, libpciaccess, cairo, xorgproto, udev
+{ lib, stdenv, fetchurl, pkg-config, libdrm, libpciaccess, cairo, xorgproto, udev
 , libX11, libXext, libXv, libXrandr, glib, bison, libunwind, python3, kmod
 , procps, utilmacros, gtk-doc, openssl, peg, elfutils
 }:
···
 
   enableParallelBuilding = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://01.org/linuxgraphics/";
     description = "Tools for development and testing of the Intel DRM driver";
     license = licenses.mit;

pkgs/development/tools/misc/intltool/default.nix

···
-{ stdenv, fetchurl, fetchpatch, gettext, perlPackages, buildPackages }:
+{ lib, stdenv, fetchurl, fetchpatch, gettext, perlPackages, buildPackages }:
 
 stdenv.mkDerivation rec {
   pname = "intltool";
···
   nativeBuildInputs = with perlPackages; [ perl XMLParser ];
   propagatedBuildInputs = [ gettext ] ++ (with perlPackages; [ perl XMLParser ]);
 
-  postInstall = stdenv.lib.optionalString (stdenv.hostPlatform != stdenv.buildPlatform) ''
+  postInstall = lib.optionalString (stdenv.hostPlatform != stdenv.buildPlatform) ''
     for f in $out/bin/*; do
       substituteInPlace $f --replace "${buildPackages.perl}" "${perlPackages.perl}"
     done
   '';
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Translation helper tool";
     homepage = "https://launchpad.net/intltool/";
     license = licenses.gpl2Plus;

pkgs/development/tools/misc/iozone/default.nix

···
   meta = {
     description = "IOzone Filesystem Benchmark";
     homepage    = "http://www.iozone.org/";
-    license     = stdenv.lib.licenses.unfreeRedistributable;
+    license     = lib.licenses.unfreeRedistributable;
     platforms   = ["i686-linux" "x86_64-linux" "x86_64-darwin" "aarch64-linux" ];
-    maintainers = with stdenv.lib.maintainers; [ Baughn makefu ];
+    maintainers = with lib.maintainers; [ Baughn makefu ];
   };
 }

pkgs/development/tools/misc/itm-tools/default.nix

···
-{ stdenv, fetchFromGitHub, rustPlatform, pkg-config }:
+{ lib, stdenv, fetchFromGitHub, rustPlatform, pkg-config }:
 
 rustPlatform.buildRustPackage rec {
   pname = "itm-tools";
···
 
   doCheck = false;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Tools for analyzing ITM traces";
     homepage = "https://github.com/japaric/itm-tools";
     license = with licenses; [ asl20 mit ];

pkgs/development/tools/misc/itstool/default.nix

···
   meta = {
     homepage = "http://itstool.org/";
     description = "XML to PO and back again";
-    license = stdenv.lib.licenses.gpl3Plus;
-    platforms = stdenv.lib.platforms.all;
+    license = lib.licenses.gpl3Plus;
+    platforms = lib.platforms.all;
     maintainers = [ ];
   };
 }

pkgs/development/tools/misc/jscoverage/default.nix

···
-{ autoconf, fetchurl, makedepend, perl, python, stdenv, unzip, zip }:
+{ autoconf, fetchurl, makedepend, perl, python, lib, stdenv, unzip, zip }:
 
 stdenv.mkDerivation rec {
   name = "jscoverage-0.5.1";
···
     '';
 
     homepage = "http://siliconforks.com/jscoverage/";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/development/tools/misc/kconfig-frontends/default.nix

···
-{ stdenv, fetchurl, pkg-config, bison, flex, gperf, ncurses, pythonPackages }:
+{ lib, stdenv, fetchurl, pkg-config, bison, flex, gperf, ncurses, pythonPackages }:
 
 stdenv.mkDerivation rec {
   basename = "kconfig-frontends";
···
     wrapPythonPrograms
   '';
 
-  NIX_CFLAGS_COMPILE = stdenv.lib.optionalString stdenv.cc.isClang "-Wno-error=format-security";
+  NIX_CFLAGS_COMPILE = lib.optionalString stdenv.cc.isClang "-Wno-error=format-security";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Out of Linux tree packaging of the kconfig infrastructure";
     longDescription = ''
       Configuration language and system for the Linux kernel and other

pkgs/development/tools/misc/kdbg/default.nix

···
-{ stdenv, fetchurl, cmake, extra-cmake-modules, qt5,
+{ lib, stdenv, fetchurl, cmake, extra-cmake-modules, qt5,
   ki18n, kconfig, kiconthemes, kxmlgui, kwindowsystem,
   qtbase, makeWrapper,
 }:
···
     wrapProgram $out/bin/kdbg --prefix QT_PLUGIN_PATH : ${qtbase}/${qtbase.qtPluginPrefix}
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://www.kdbg.org/";
     description = ''
       A graphical user interface to gdb, the GNU debugger. It provides an

pkgs/development/tools/misc/kibana/6.x.nix

···
 { elk6Version
 , enableUnfree ? true
-, stdenv
+, lib, stdenv
 , makeWrapper
 , fetchurl
 , nodejs-10_x
···
 , which
 }:
 
-with stdenv.lib;
+with lib;
 let
   nodejs = nodejs-10_x;
   inherit (builtins) elemAt;
···
     mv * $out/libexec/kibana/
     rm -r $out/libexec/kibana/node
     makeWrapper $out/libexec/kibana/bin/kibana $out/bin/kibana \
-      --prefix PATH : "${stdenv.lib.makeBinPath [ nodejs coreutils which ]}"
+      --prefix PATH : "${lib.makeBinPath [ nodejs coreutils which ]}"
     sed -i 's@NODE=.*@NODE=${nodejs}/bin/node@' $out/libexec/kibana/bin/kibana
   '';
 

pkgs/development/tools/misc/kibana/7.x.nix

···
 { elk7Version
 , enableUnfree ? true
-, stdenv
+, lib, stdenv
 , makeWrapper
 , fetchurl
 , nodejs-10_x
···
 , which
 }:
 
-with stdenv.lib;
+with lib;
 let
   nodejs = nodejs-10_x;
   inherit (builtins) elemAt;
···
     mv * $out/libexec/kibana/
     rm -r $out/libexec/kibana/node
     makeWrapper $out/libexec/kibana/bin/kibana $out/bin/kibana \
-      --prefix PATH : "${stdenv.lib.makeBinPath [ nodejs coreutils which ]}"
+      --prefix PATH : "${lib.makeBinPath [ nodejs coreutils which ]}"
     sed -i 's@NODE=.*@NODE=${nodejs}/bin/node@' $out/libexec/kibana/bin/kibana
   '';
 

pkgs/development/tools/misc/libtool/default.nix

···
-{stdenv, fetchurl, m4, perl}:
+{lib, stdenv, fetchurl, m4, perl}:
 
 # Note: this package is used for bootstrapping fetchurl, and thus
 # cannot use fetchpatch! All mutable patches (generated by GitHub or
···
 
     homepage = "https://www.gnu.org/software/libtool/";
 
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/misc/libtool/libtool2.nix

···
-{ stdenv, fetchurl, m4, perl, help2man
+{ lib, stdenv, fetchurl, m4, perl, help2man
 }:
 
 stdenv.mkDerivation rec {
···
 
   enableParallelBuilding = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "GNU Libtool, a generic library support script";
     longDescription = ''
       GNU libtool is a generic library support script.  Libtool hides

pkgs/development/tools/misc/libwhich/default.nix

···
-{ stdenv, fetchFromGitHub }:
+{ lib, stdenv, fetchFromGitHub }:
 
 stdenv.mkDerivation rec {
   pname = "libwhich";
···
     install -Dm755 -t $out/bin libwhich
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Like `which`, for dynamic libraries";
     homepage = "https://github.com/vtjnash/libwhich";
     license = licenses.mit;

pkgs/development/tools/misc/loccount/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitLab }:
+{ lib, stdenv, buildGoPackage, fetchFromGitLab }:
 buildGoPackage rec {
   pname = "loccount";
   version = "1.2";
···
     sha256 = "18z7ai7wy2k9yd3w65d37apfqs3h9bc2c15y7v1bydppi44zfsdk";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Re-implementation of sloccount in Go";
     longDescription = ''
       loccount is a re-implementation of David A. Wheeler's sloccount tool

pkgs/development/tools/misc/lsof/default.nix

···
-{ stdenv, fetchFromGitHub, buildPackages, ncurses }:
+{ lib, stdenv, fetchFromGitHub, buildPackages, ncurses }:
 
-let dialect = with stdenv.lib; last (splitString "-" stdenv.hostPlatform.system); in
+let dialect = with lib; last (splitString "-" stdenv.hostPlatform.system); in
 
 stdenv.mkDerivation rec {
   pname = "lsof";
···
 
   patches = [ ./no-build-info.patch ];
 
-  postPatch = stdenv.lib.optionalString stdenv.hostPlatform.isMusl ''
+  postPatch = lib.optionalString stdenv.hostPlatform.isMusl ''
     substituteInPlace dialects/linux/dlsof.h --replace "defined(__UCLIBC__)" 1
-  '' + stdenv.lib.optionalString stdenv.isDarwin ''
+  '' + lib.optionalString stdenv.isDarwin ''
     sed -i 's|lcurses|lncurses|g' Configure
   '';
 
   # Stop build scripts from searching global include paths
-  LSOF_INCLUDE = "${stdenv.lib.getDev stdenv.cc.libc}/include";
+  LSOF_INCLUDE = "${lib.getDev stdenv.cc.libc}/include";
   configurePhase = "LINUX_CONF_CC=$CC_FOR_BUILD LSOF_CC=$CC LSOF_AR=\"$AR cr\" LSOF_RANLIB=$RANLIB ./Configure -n ${dialect}";
   preBuild = ''
     for filepath in $(find dialects/${dialect} -type f); do
···
     cp lsof $out/bin
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/lsof-org/lsof";
     description = "A tool to list open files";
     longDescription = ''

pkgs/development/tools/misc/ltrace/default.nix

···
-{ stdenv, fetchurl, elfutils, libunwind }:
+{ lib, stdenv, fetchurl, elfutils, libunwind }:
 
 stdenv.mkDerivation {
   name = "ltrace-0.7.3";
···
       patches="$patches $(cat debian/patches/series | sed 's|^|debian/patches/|')"
     '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Library call tracer";
     homepage = "https://www.ltrace.org/";
     platforms = [ "i686-linux" "x86_64-linux" ];

pkgs/development/tools/misc/lttng-tools/default.nix

···
-{ stdenv, fetchurl, pkg-config, popt, libuuid, liburcu, lttng-ust, kmod, libxml2 }:
+{ lib, stdenv, fetchurl, pkg-config, popt, libuuid, liburcu, lttng-ust, kmod, libxml2 }:
 
 stdenv.mkDerivation rec {
   pname = "lttng-tools";
···
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ popt libuuid liburcu lttng-ust libxml2 kmod ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Tracing tools (kernel + user space) for Linux";
     homepage = "https://lttng.org/";
     license = licenses.lgpl21;

pkgs/development/tools/misc/lttng-ust/default.nix

···
-{ stdenv, fetchurl, liburcu, python3 }:
+{ lib, stdenv, fetchurl, liburcu, python3 }:
 
 # NOTE:
 #   ./configure ...
···
 
   propagatedBuildInputs = [ liburcu ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "LTTng Userspace Tracer libraries";
     homepage = "https://lttng.org/";
     license = licenses.lgpl21Plus;

pkgs/development/tools/misc/lttv/default.nix

···
-{ stdenv, fetchurl, pkg-config, glib, gtk2, popt, babeltrace }:
+{ lib, stdenv, fetchurl, pkg-config, glib, gtk2, popt, babeltrace }:
 
 stdenv.mkDerivation rec {
   name = "lttv-1.5";
···
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ glib gtk2 popt babeltrace ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Graphical trace viewer for LTTng trace files";
     homepage = "https://lttng.org/";
     # liblttvtraceread (ltt/ directory) is distributed under the GNU LGPL v2.1.

pkgs/development/tools/misc/luarocks/default.nix

···
-{stdenv, fetchFromGitHub
+{lib, stdenv, fetchFromGitHub
 , curl, makeWrapper, which, unzip
 , lua
 # for 'luarocks pack'
···
     export LUA_PATH="src/?.lua;''${LUA_PATH:-}"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     inherit version;
     description = ''A package manager for Lua'';
     license = licenses.mit ;

pkgs/development/tools/misc/macdylibbundler/default.nix

···
-{ stdenv, makeWrapper, fetchFromGitHub, cctools }:
+{ lib, stdenv, makeWrapper, fetchFromGitHub, cctools }:
 
 stdenv.mkDerivation {
   pname = "macdylibbundler";
···
       --prefix PATH ":" "${cctools}/bin"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Utility to ease bundling libraries into executables for OSX";
     longDescription = ''
       dylibbundler is a small command-line programs that aims to make bundling

pkgs/development/tools/misc/micronucleus/default.nix

···
    };
 
    buildInputs = [ libusb-compat-0_1 ];
-   makeFlags = stdenv.lib.optionals stdenv.isDarwin [ "CC=cc" ];
+   makeFlags = lib.optionals stdenv.isDarwin [ "CC=cc" ];
 
    installPhase = ''
      mkdir -p $out/bin

pkgs/development/tools/misc/msitools/default.nix

···
-{ stdenv, fetchurl, intltool, glib, pkg-config, libgsf, libuuid, gcab, bzip2, gnome3 }:
+{ lib, stdenv, fetchurl, intltool, glib, pkg-config, libgsf, libuuid, gcab, bzip2, gnome3 }:
 
 stdenv.mkDerivation rec {
   pname = "msitools";
   version = "0.98";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "19wb3n3nwkpc6bjr0q3f1znaxsfaqgjbdxxnbx8ic8bb5b49hwac";
   };
 
···
     };
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Set of programs to inspect and build Windows Installer (.MSI) files";
     homepage = "https://wiki.gnome.org/msitools";
     license = [ licenses.gpl2 licenses.lgpl21 ];

pkgs/development/tools/misc/nimlsp/default.nix

···
-{ stdenv, fetchFromGitHub, srcOnly, nim }:
+{ lib, stdenv, fetchFromGitHub, srcOnly, nim }:
 let
   astpatternmatching = fetchFromGitHub {
     owner = "krux02";
···
     install -Dt $out/bin src/nimlsp
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Language Server Protocol implementation for Nim";
     homepage = "https://github.com/PMunch/nimlsp";
     license = licenses.mit;

pkgs/development/tools/misc/ninka/default.nix

···
-{ stdenv, fetchFromGitHub, perl, perlPackages }:
+{ lib, stdenv, fetchFromGitHub, perl, perlPackages }:
 
 assert stdenv ? glibc;
 
···
     perl Makefile.PL
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A sentence based license detector";
     homepage = "http://ninka.turingmachine.org/";
     license = licenses.gpl2;

pkgs/development/tools/misc/nrfutil/default.nix

···
-{ stdenv, python37Packages, fetchFromGitHub }:
+{ lib, stdenv, python37Packages, fetchFromGitHub }:
 
 with python37Packages; buildPythonApplication rec {
   pname = "nrfutil";
···
     mkdir test-reports
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Device Firmware Update tool for nRF chips";
     homepage = "https://github.com/NordicSemiconductor/pc-nrfutil";
     license = licenses.unfreeRedistributable;

pkgs/development/tools/misc/nxpmicro-mfgtools/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchFromGitHub
 , cmake
 , pkg-config
···
 
   preConfigure = "echo ${version} > .tarball-version";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Freescale/NXP I.MX chip image deploy tools";
     longDescription = ''
       UUU (Universal Update Utility) is a command line tool, evolved out of

pkgs/development/tools/misc/objconv/default.nix

···
-{ stdenv, fetchurl, unzip }:
+{ lib, stdenv, fetchurl, unzip }:
 
 stdenv.mkDerivation rec {
   pname = "objconv";
···
     mv objconv-instructions.pdf $out/doc/objconv
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Object and executable file converter, modifier and disassembler";
     homepage = "https://www.agner.org/optimize/";
     license = licenses.gpl2;

pkgs/development/tools/misc/opengrok/default.nix

···
-{ stdenv, fetchurl, jre, ctags, makeWrapper, coreutils, git, runtimeShell }:
+{ lib, stdenv, fetchurl, jre, ctags, makeWrapper, coreutils, git, runtimeShell }:
 
 stdenv.mkDerivation rec {
   pname = "opengrok";
···
     substituteInPlace $out/bin/OpenGrok --replace "/bin/uname" "${coreutils}/bin/uname"
     substituteInPlace $out/bin/Messages --replace "#!/bin/ksh" "#!${runtimeShell}"
     wrapProgram $out/bin/OpenGrok \
-      --prefix PATH : "${stdenv.lib.makeBinPath [ ctags git ]}" \
+      --prefix PATH : "${lib.makeBinPath [ ctags git ]}" \
       --set JAVA_HOME "${jre}" \
       --set OPENGROK_TOMCAT_BASE "/var/tomcat"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Source code search and cross reference engine";
     homepage = "https://opengrok.github.io/OpenGrok/";
     license = licenses.cddl;

pkgs/development/tools/misc/pahole/default.nix

···
-{ stdenv, fetchgit, cmake, elfutils, zlib }:
+{ lib, stdenv, fetchgit, cmake, elfutils, zlib }:
 
 stdenv.mkDerivation rec {
   pname = "pahole";
···
   # Put libraries in "lib" subdirectory, not top level of $out
   cmakeFlags = [ "-D__LIB=lib" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://git.kernel.org/cgit/devel/pahole/pahole.git/";
     description = "Pahole and other DWARF utils";
     license = licenses.gpl2;

pkgs/development/tools/misc/patchelf/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 
 # Note: this package is used for bootstrapping fetchurl, and thus
 # cannot use fetchpatch! All mutable patches (generated by GitHub or
···
   # fails 8 out of 24 tests, problems when loading libc.so.6
   doCheck = stdenv.name == "stdenv-linux";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/NixOS/patchelf/blob/master/README";
     license = licenses.gpl3;
     description = "A small utility to modify the dynamic linker and RPATH of ELF executables";

pkgs/development/tools/misc/patchelf/unstable.nix

···
-{ stdenv, fetchurl, autoreconfHook, fetchFromGitHub }:
+{ lib, stdenv, fetchurl, autoreconfHook, fetchFromGitHub }:
 
 stdenv.mkDerivation rec {
   name = "patchelf-${version}";
···
   };
 
   # Drop test that fails on musl (?)
-  postPatch = stdenv.lib.optionalString stdenv.hostPlatform.isMusl ''
+  postPatch = lib.optionalString stdenv.hostPlatform.isMusl ''
     substituteInPlace tests/Makefile.am \
       --replace "set-rpath-library.sh" ""
   '';
···
 
   doCheck = !stdenv.isDarwin;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/NixOS/patchelf/blob/master/README";
     license = licenses.gpl3;
     description = "A small utility to modify the dynamic linker and RPATH of ELF executables";

pkgs/development/tools/misc/perfect-hash/default.nix

···
-{ stdenv, python3, fetchFromGitHub }:
+{ lib, stdenv, python3, fetchFromGitHub }:
 python3.pkgs.buildPythonApplication rec {
   pname = "perfect-hash";
   version = "0.4.1";
···
     cp -r examples $out/share/doc/perfect-hash
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Minimal perfect hash function generator";
     longDescription = ''
       Generate a minimal perfect hash function for a given set of keys.

pkgs/development/tools/misc/pkg-config/default.nix

···
-{ stdenv, fetchurl, libiconv, vanilla ? false }:
+{ lib, stdenv, fetchurl, libiconv, vanilla ? false }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "pkg-config";

pkgs/development/tools/misc/pkgconf/default.nix

···
-{ stdenv, fetchurl, removeReferencesTo }:
+{ lib, stdenv, fetchurl, removeReferencesTo }:
 
 stdenv.mkDerivation rec {
   pname = "pkgconf";
···
     mv ${placeholder "dev"}/share ${placeholder "out"}
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Package compiler and linker metadata toolkit";
     homepage = "https://git.dereferenced.org/pkgconf/pkgconf";
     platforms = platforms.all;

pkgs/development/tools/misc/pmccabe/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
   pname = "pmccabe";
···
 
   doCheck = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "McCabe-style function complexity and line counting for C and C++";
     homepage = "https://people.debian.org/~bame/pmccabe/";
     license = licenses.gpl2Plus;

pkgs/development/tools/misc/prelink/default.nix

···
-{ stdenv, fetchurl, libelf }:
+{ lib, stdenv, fetchurl, libelf }:
 
 let
   version = "20130503";
···
   inherit version;
 
   buildInputs = [
-    libelf stdenv.cc.libc (stdenv.lib.getOutput "static" stdenv.cc.libc)
+    libelf stdenv.cc.libc (lib.getOutput "static" stdenv.cc.libc)
   ];
 
   src = fetchurl {
···
     homepage = "https://people.redhat.com/jakub/prelink/";
     license = "GPL";
     description = "ELF prelinking utility to speed up dynamic linking";
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/development/tools/misc/premake/3.nix

···
-{stdenv, fetchurl, unzip}:
+{lib, stdenv, fetchurl, unzip}:
 
 let baseName = "premake";
   version  = "3.7";
···
   meta = {
     homepage = "http://industriousone.com/premake";
     description = "A simple build configuration and project generation tool using lua";
-    license = stdenv.lib.licenses.bsd3;
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.bsd3;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/misc/premake/5.nix

···
-{ stdenv, fetchFromGitHub, Foundation, readline }:
+{ lib, stdenv, fetchFromGitHub, Foundation, readline }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "premake5";
···
   meta = {
     homepage = "https://premake.github.io";
     description = "A simple build configuration and project generation tool using lua";
-    license = stdenv.lib.licenses.bsd3;
+    license = lib.licenses.bsd3;
     platforms = platforms.darwin ++ platforms.linux;
   };
 }

pkgs/development/tools/misc/premake/default.nix

···
-{ stdenv, fetchurl, unzip }:
+{ lib, stdenv, fetchurl, unzip }:
 
 let baseName = "premake";
   version  = "4.3";
···
   premake_cmd = "premake4";
   setupHook = ./setup-hook.sh;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "http://industriousone.com/premake";
     description = "A simple build configuration and project generation tool using lua";
-    license = stdenv.lib.licenses.bsd3;
+    license = lib.licenses.bsd3;
     platforms = platforms.unix;
     maintainers = [ maintainers.bjornfor ];
   };

pkgs/development/tools/misc/ptags/default.nix

···
     $releaseDir/ptags --help > /dev/null
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A parallel universal-ctags wrapper for git repository";
     homepage = "https://github.com/dalance/ptags";
     maintainers = with maintainers; [ pamplemousse ];

pkgs/development/tools/misc/pwndbg/default.nix

···
-{ stdenv
+{ lib, stdenv
 , python3
 , fetchFromGitHub
 , makeWrapper
···
       --set NIX_PYTHONPATH ${pythonPath}
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Exploit Development and Reverse Engineering with GDB Made Easy";
     homepage = "https://github.com/pwndbg/pwndbg";
     license = licenses.mit;

pkgs/development/tools/misc/remarkable/remarkable-toolchain/default.nix

···
-{ stdenv, fetchurl, libarchive, python, file, which }:
+{ lib, stdenv, fetchurl, libarchive, python, file, which }:
 
 stdenv.mkDerivation rec {
   pname = "remarkable-toolchain";
···
     ENVCLEANED=1 $src -y -d $out
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A toolchain for cross-compiling to reMarkable tablets";
     homepage = "https://remarkable.engineering/";
     license = licenses.gpl2;

pkgs/development/tools/misc/remarkable/remarkable2-toolchain/default.nix

···
-{ stdenv, fetchurl, libarchive, python3, file }:
+{ lib, stdenv, fetchurl, libarchive, python3, file }:
 
 stdenv.mkDerivation rec {
   pname = "remarkable2-toolchain";
···
     ./install-toolchain.sh -D -y -d $out
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A toolchain for cross-compiling to reMarkable 2 tablets";
     homepage = "https://remarkable.engineering/";
     license = licenses.gpl2Plus;

pkgs/development/tools/misc/rman/default.nix

···
-{stdenv, fetchurl}:
+{lib, stdenv, fetchurl}:
 
 stdenv.mkDerivation {
   name = "rman-3.2";
···
   meta = {
     description = "Parse formatted man pages and man page source from most flavors of UNIX and converts them to HTML, ASCII, TkMan, DocBook, and other formats";
     license = "artistic";
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/development/tools/misc/rolespec/default.nix

···
-{ stdenv, fetchFromGitHub, makeWrapper }:
+{ lib, stdenv, fetchFromGitHub, makeWrapper }:
 
 stdenv.mkDerivation rec {
 
···
   dontPatchELF = true;
   dontStrip = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/nickjj/rolespec";
     description = "A test library for testing Ansible roles";
     longDescription = ''

pkgs/development/tools/misc/saleae-logic/default.nix

···
 #
 # In NixOS, simply add this package to services.udev.packages.
 
-{ stdenv, fetchurl, unzip, glib, libSM, libICE, gtk2, libXext, libXft
+{ lib, stdenv, fetchurl, unzip, glib, libSM, libICE, gtk2, libXext, libXft
 , fontconfig, libXrender, libXfixes, libX11, libXi, libXrandr, libXcursor
 , freetype, libXinerama, libxcb, zlib, pciutils
 , makeDesktopItem, xkeyboardconfig, dbus, runtimeShell, libGL
···
 
 let
 
-  libPath = stdenv.lib.makeLibraryPath [
+  libPath = lib.makeLibraryPath [
     glib libSM libICE gtk2 libXext libXft fontconfig libXrender libXfixes libX11
     libXi libXrandr libXcursor freetype libXinerama libxcb zlib stdenv.cc.cc.lib
     dbus libGL
···
     cp Drivers/99-SaleaeLogic.rules "$out/etc/udev/rules.d/"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Software for Saleae logic analyzers";
     homepage = "https://www.saleae.com/";
     license = licenses.unfree;

pkgs/development/tools/misc/scc/default.nix

···
-{ stdenv, buildGoModule, fetchFromGitHub }:
+{ lib, stdenv, buildGoModule, fetchFromGitHub }:
 
 buildGoModule rec {
   pname = "scc";
···
   # scc has a scripts/ sub-package that's for testing.
   excludedPackages = [ "scripts" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/boyter/scc";
     description = "A very fast accurate code counter with complexity calculations and COCOMO estimates written in pure Go";
     maintainers = with maintainers; [ sigma Br1ght0ne ];

pkgs/development/tools/misc/sipp/default.nix

···
-{stdenv, fetchurl, ncurses, libpcap }:
+{lib, stdenv, fetchurl, ncurses, libpcap }:
 
 stdenv.mkDerivation rec {
   version = "3.6.0";
···
 
   buildInputs = [ncurses libpcap];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "http://sipp.sf.net";
     description = "The SIPp testing tool";
     license = licenses.gpl3;

pkgs/development/tools/misc/sloccount/default.nix

···
-{ fetchurl, stdenv, perl, makeWrapper }:
+{ fetchurl, lib, stdenv, perl, makeWrapper }:
 
 stdenv.mkDerivation rec {
   name = "sloccount-2.26";
···
       the Perl CPAN library using this tool suite.
     '';
 
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
 
     homepage = "https://www.dwheeler.com/sloccount/";
 
     maintainers = [ ];
-    platforms = stdenv.lib.platforms.all;
+    platforms = lib.platforms.all;
   };
 }

pkgs/development/tools/misc/srecord/default.nix

···
-{ stdenv, fetchurl, boost, libtool, groff, ghostscript, libgcrypt ? null }:
+{ lib, stdenv, fetchurl, boost, libtool, groff, ghostscript, libgcrypt ? null }:
 
 stdenv.mkDerivation rec {
   name = "srecord-1.64";
···
 
   buildInputs = [ boost libtool groff ghostscript libgcrypt ];
 
-  configureFlags = stdenv.lib.optional (libgcrypt == null) "--without-gcrypt";
+  configureFlags = lib.optional (libgcrypt == null) "--without-gcrypt";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Collection of powerful tools for manipulating EPROM load files";
     homepage = "http://srecord.sourceforge.net/";
     license = licenses.gpl3Plus;
     maintainers = [ maintainers.bjornfor ];
-    platforms = stdenv.lib.platforms.unix;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/misc/stlink/default.nix

···
-{ stdenv, fetchFromGitHub, cmake, libusb1 }:
+{ lib, stdenv, fetchFromGitHub, cmake, libusb1 }:
 
 let
   # The Darwin build of stlink explicitly refers to static libusb.
···
     mkdir -p $out/etc/modprobe.d
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "In-circuit debug and programming for ST-Link devices";
     license = licenses.bsd3;
     platforms = platforms.unix;

pkgs/development/tools/misc/stm32cubemx/default.nix

···
-{ stdenv, requireFile, makeDesktopItem, libicns, imagemagick, jre, fetchzip }:
+{ lib, stdenv, requireFile, makeDesktopItem, libicns, imagemagick, jre, fetchzip }:
 
 let
   version = "6.0.1";
···
     ln -s ${desktopItem}/share/applications/* $out/share/applications
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A graphical tool for configuring STM32 microcontrollers and microprocessors";
     longDescription = ''
       A graphical tool that allows a very easy configuration of STM32

pkgs/development/tools/misc/stm32flash/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
   name = "stm32flash-0.5";
···
     cp stm32flash $out/bin/
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Open source flash program for the STM32 ARM processors using the ST bootloader";
     homepage = "https://sourceforge.net/projects/stm32flash/";
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
     platforms = platforms.all; # Should work on all platforms
     maintainers = with maintainers; [ elitak ];
   };

pkgs/development/tools/misc/strace/default.nix

···
-{ stdenv, fetchurl, perl, libunwind, buildPackages }:
+{ lib, stdenv, fetchurl, perl, libunwind, buildPackages }:
 
 stdenv.mkDerivation rec {
   pname = "strace";
···
   depsBuildBuild = [ buildPackages.stdenv.cc ];
   nativeBuildInputs = [ perl ];
 
-  buildInputs = [ perl.out ] ++ stdenv.lib.optional libunwind.supportsHost libunwind; # support -k
+  buildInputs = [ perl.out ] ++ lib.optional libunwind.supportsHost libunwind; # support -k
 
   postPatch = "patchShebangs --host strace-graph";
 
   configureFlags = [ "--enable-mpers=check" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://strace.io/";
     description = "A system call tracer for Linux";
     license =  with licenses; [ lgpl21Plus gpl2Plus ]; # gpl2Plus is for the test suite

pkgs/development/tools/misc/swig/2.x.nix

···
-{ stdenv, fetchFromGitHub, autoconf, automake, libtool, bison, pcre }:
+{ lib, stdenv, fetchFromGitHub, autoconf, automake, libtool, bison, pcre }:
 
 stdenv.mkDerivation rec {
   pname = "swig";
···
     ./autogen.sh
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "SWIG, an interface compiler that connects C/C++ code to higher-level languages";
     homepage = "http://swig.org/";
     # Different types of licenses available: http://www.swig.org/Release/LICENSE .

pkgs/development/tools/misc/swig/3.x.nix

···
-{ stdenv, fetchFromGitHub, autoconf, automake, libtool, bison, pcre }:
+{ lib, stdenv, fetchFromGitHub, autoconf, automake, libtool, bison, pcre }:
 
 stdenv.mkDerivation rec {
   pname = "swig";
···
     ./autogen.sh
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "An interface compiler that connects C/C++ code to higher-level languages";
     homepage = "http://swig.org/";
     # Different types of licenses available: http://www.swig.org/Release/LICENSE .

pkgs/development/tools/misc/swig/4.nix

···
-{ stdenv, fetchFromGitHub, autoconf, automake, libtool, bison, pcre }:
+{ lib, stdenv, fetchFromGitHub, autoconf, automake, libtool, bison, pcre }:
 
 stdenv.mkDerivation rec {
   pname = "swig";
···
     ./autogen.sh
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "SWIG, an interface compiler that connects C/C++ code to higher-level languages";
     homepage = "http://swig.org/";
     # Different types of licenses available: http://www.swig.org/Release/LICENSE .

pkgs/development/tools/misc/swig/default.nix

···
-{ stdenv, fetchurl, boost, tcl }:
+{ lib, stdenv, fetchurl, boost, tcl }:
 
 stdenv.mkDerivation rec {
   pname = "swig";
···
 
   doCheck = !stdenv.isCygwin;
   # 'make check' uses boost and tcl
-  buildInputs = stdenv.lib.optionals doCheck [ boost tcl ];
+  buildInputs = lib.optionals doCheck [ boost tcl ];
 
   configureFlags = [ "--disable-ccache" ];
 
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "SWIG, an interface compiler that connects C/C++ code to higher-level languages";
     homepage = "http://swig.org/";
     # Different types of licenses available: http://www.swig.org/Release/LICENSE .

pkgs/development/tools/misc/sysbench/default.nix

···
-{ stdenv, fetchFromGitHub, autoreconfHook, pkg-config
+{ lib, stdenv, fetchFromGitHub, autoreconfHook, pkg-config
 , libmysqlclient, libaio
 }:
 
···
   meta = {
     description = "Modular, cross-platform and multi-threaded benchmark tool";
     homepage = "https://github.com/akopytov/sysbench";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/development/tools/misc/tcptrack/default.nix

···
-{ stdenv, fetchFromGitHub, ncurses, libpcap }:
+{ lib, stdenv, fetchFromGitHub, ncurses, libpcap }:
 
 stdenv.mkDerivation rec {
   pname = "tcptrack";
···
 
   NIX_CFLAGS_COMPILE = "-Wno-error=cpp";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     inherit (src.meta) homepage;
     description = "libpcap based program for live TCP connection monitoring";
     license = licenses.lgpl21;

pkgs/development/tools/misc/teensy-loader-cli/default.nix

···
-{ stdenv, fetchFromGitHub, go-md2man, installShellFiles, libusb-compat-0_1 }:
+{ lib, stdenv, fetchFromGitHub, go-md2man, installShellFiles, libusb-compat-0_1 }:
 
 stdenv.mkDerivation rec {
   pname = "teensy-loader-cli";
···
     installManPage *.1
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Firmware uploader for the Teensy microcontroller boards";
     homepage = "https://www.pjrc.com/teensy/";
     license = licenses.gpl3;

pkgs/development/tools/misc/tet/default.nix

···
-{ fetchurl, stdenv }:
+{ fetchurl, lib, stdenv }:
 
 stdenv.mkDerivation ({
   version = "3.8";
···
   meta = {
     description = "The Test Environment Toolkit is used in test applications like The Open Group's UNIX Certification program and the Free Standards Group's LSB Certification program";
     homepage = "http://tetworks.opengroup.org/Products/tet.htm";
-    license = stdenv.lib.licenses.artistic1;
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.artistic1;
+    platforms = lib.platforms.unix;
     maintainers = [ ];
   };
 })

pkgs/development/tools/misc/texi2html/default.nix

···
-{ stdenv, fetchurl, perl, gettext, buildPackages }:
+{ lib, stdenv, fetchurl, perl, gettext, buildPackages }:
 
 stdenv.mkDerivation rec {
   pname = "texi2html";
···
     patchShebangs separated_to_hash.pl
   '';
 
-  postInstall = stdenv.lib.optionalString (stdenv.buildPlatform != stdenv.hostPlatform) ''
+  postInstall = lib.optionalString (stdenv.buildPlatform != stdenv.hostPlatform) ''
     for f in $out/bin/*; do
       substituteInPlace $f --replace "${buildPackages.perl}" "${perl}"
     done
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Perl script which converts Texinfo source files to HTML output";
     homepage = "https://www.nongnu.org/texi2html/";
     license = licenses.gpl2;

pkgs/development/tools/misc/texinfo/common.nix

···
 { version, sha256 }:
 
-{ stdenv, buildPackages, fetchurl, perl, xz, gettext
+{ lib, stdenv, buildPackages, fetchurl, perl, xz, gettext
 
 # we are a dependency of gcc, this simplifies bootstraping
 , interactive ? false, ncurses, procps
···
   crossBuildTools = stdenv.hostPlatform != stdenv.buildPlatform;
 in
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation {
   name = "texinfo-${optionalString interactive "interactive-"}${version}";
···
     ++ optional interactive ncurses;
 
   configureFlags = [ "PERL=${buildPackages.perl}/bin/perl" ]
-    ++ stdenv.lib.optional stdenv.isSunOS "AWK=${gawk}/bin/awk";
+    ++ lib.optional stdenv.isSunOS "AWK=${gawk}/bin/awk";
 
   installFlags = [ "TEXMF=$(out)/texmf-dist" ];
   installTargets = [ "install" "install-tex" ];

pkgs/development/tools/misc/tie/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
   pname = "tie";
···
     cp tie $out/bin
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://www.ctan.org/tex-archive/web/tie";
     description = "Allow multiple web change files";
     platforms = with platforms; unix;

pkgs/development/tools/misc/tokei/default.nix

···
-{ stdenv, fetchFromGitHub, rustPlatform, libiconv, darwin }:
+{ lib, stdenv, fetchFromGitHub, rustPlatform, libiconv, darwin }:
 
 rustPlatform.buildRustPackage rec {
   pname = "tokei";
···
 
   cargoSha256 = "sha256-iUDc54E8AiLMJw9h99kg/3VmaSi8GqfQyrPwa9nJ994=";
 
-  buildInputs = stdenv.lib.optionals stdenv.isDarwin [
+  buildInputs = lib.optionals stdenv.isDarwin [
     libiconv darwin.apple_sdk.frameworks.Security
   ];
 
   # enable all output formats
   cargoBuildFlags = [ "--features" "all" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A program that allows you to count your code, quickly";
     longDescription = ''
       Tokei is a program that displays statistics about your code. Tokei will show number of files, total lines within those files and code, comments, and blanks grouped by language.

pkgs/development/tools/misc/uisp/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 
 stdenv.mkDerivation {
   name = "uisp-20050207";
···
 
   meta = {
     description = "Tool for AVR microcontrollers which can interface to many hardware in-system programmers";
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
     homepage = "https://savannah.nongnu.org/projects/uisp";
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/development/tools/misc/uncrustify/default.nix

···
-{ stdenv, fetchFromGitHub, cmake, python }:
+{ lib, stdenv, fetchFromGitHub, cmake, python }:
 
 stdenv.mkDerivation rec {
   name = "${product}-${version}";
···
 
   nativeBuildInputs = [ cmake python ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Source code beautifier for C, C++, C#, ObjectiveC, D, Java, Pawn and VALA";
     homepage = "http://uncrustify.sourceforge.net/";
     license = licenses.gpl2Plus;

pkgs/development/tools/misc/unifdef/default.nix

···
-{ fetchurl, stdenv }:
+{ fetchurl, lib, stdenv }:
 
 stdenv.mkDerivation rec {
   name = "unifdef-2.6";
···
     export DESTDIR=$out
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "http://dotat.at/prog/unifdef/";
     description = "Selectively remove C preprocessor conditionals";
     license = licenses.bsd2;

pkgs/development/tools/misc/universal-ctags/default.nix

···
-{ stdenv, fetchFromGitHub, autoreconfHook, pkg-config, perl, pythonPackages, libiconv, jansson }:
+{ lib, stdenv, fetchFromGitHub, autoreconfHook, pkg-config, perl, pythonPackages, libiconv, jansson }:
 
 stdenv.mkDerivation {
   pname = "universal-ctags";
···
   };
 
   nativeBuildInputs = [ autoreconfHook pkg-config pythonPackages.docutils ];
-  buildInputs = [ jansson ] ++ stdenv.lib.optional stdenv.isDarwin libiconv;
+  buildInputs = [ jansson ] ++ lib.optional stdenv.isDarwin libiconv;
 
   # to generate makefile.in
   autoreconfPhase = ''
···
 
   checkFlags = [ "units" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A maintained ctags implementation";
     homepage = "https://ctags.io/";
     license = licenses.gpl2Plus;

pkgs/development/tools/misc/unused/default.nix

···
-{ stdenv, fetchFromGitHub, rustPlatform, cmake }:
+{ lib, stdenv, fetchFromGitHub, rustPlatform, cmake }:
 rustPlatform.buildRustPackage rec {
   pname = "unused";
   version = "0.2.1";
···
 
   cargoSha256 = "1c0gj2wp0nydv0binxj3ikm5sm6y5z3pklp5b06dgvq02licz57a";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A tool to identify potentially unused code";
     homepage = "https://unused.codes";
     license = licenses.mit;

pkgs/development/tools/misc/usb-modeswitch/data.nix

···
-{ stdenv, fetchurl, tcl, usb-modeswitch }:
+{ lib, stdenv, fetchurl, tcl, usb-modeswitch }:
 
 stdenv.mkDerivation rec {
   pname = "usb-modeswitch-data";
···
   # the usb_modeswitch.d directory
   nativeBuildInputs = [ tcl ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Device database and the rules file for 'multi-mode' USB devices";
     inherit (usb-modeswitch.meta) license maintainers platforms;
   };

pkgs/development/tools/misc/usb-modeswitch/default.nix

···
   buildInputs = [ libusb1 tcl ];
   nativeBuildInputs = [ pkg-config makeWrapper ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A mode switching tool for controlling 'multi-mode' USB devices";
     license = licenses.gpl2;
     maintainers = with maintainers; [ marcweber peterhoeg ];

pkgs/development/tools/misc/vtable-dumper/default.nix

···
-{ stdenv, fetchFromGitHub, libelf }:
+{ lib, stdenv, fetchFromGitHub, libelf }:
 
 stdenv.mkDerivation rec {
   pname = "vtable-dumper";
···
   buildInputs = [ libelf ];
   makeFlags = [ "prefix=$(out)" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/lvc/vtable-dumper";
     description = "A tool to list content of virtual tables in a C++ shared library";
     license = licenses.lgpl21;

pkgs/development/tools/misc/watson-ruby/default.nix

···
-{ stdenv, bundlerEnv, ruby, bundlerUpdateScript }:
+{ lib, stdenv, bundlerEnv, ruby, bundlerUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "watson-ruby";
···
 
   passthru.updateScript = bundlerUpdateScript "watson-ruby";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "An inline issue manager";
     homepage    = "https://goosecode.com/watson/";
     license     = with licenses; mit;

pkgs/development/tools/misc/whatstyle/default.nix

···
-{ stdenv, python3, fetchFromGitHub, clang-unwrapped }:
+{ lib, stdenv, python3, fetchFromGitHub, clang-unwrapped }:
 
 python3.pkgs.buildPythonApplication rec {
   pname = "whatstyle";
···
 
   doCheck = false; # 3 or 4 failures depending on version, haven't investigated.
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Find a code format style that fits given source files";
     homepage = "https://github.com/mikr/whatstyle";
     license = licenses.mit;

pkgs/development/tools/misc/xc3sprog/default.nix

···
-{ stdenv, fetchsvn, cmake, libusb-compat-0_1, libftdi }:
+{ lib, stdenv, fetchsvn, cmake, libusb-compat-0_1, libftdi }:
 
 # The xc3sprog project doesn't seem to make proper releases, they only put out
 # prebuilt binary subversion snapshots on sourceforge.
···
   nativeBuildInputs = [ cmake ];
   buildInputs = [ libusb-compat-0_1 libftdi ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Command-line tools for programming FPGAs, microcontrollers and PROMs via JTAG";
     homepage = "http://xc3sprog.sourceforge.net/";
     license = licenses.gpl2Plus;

pkgs/development/tools/misc/ycmd/default.nix

···
   };
 
   nativeBuildInputs = [ cmake ]
-    ++ stdenv.lib.optional stdenv.hostPlatform.isDarwin fixDarwinDylibNames;
+    ++ lib.optional stdenv.hostPlatform.isDarwin fixDarwinDylibNames;
   buildInputs = [ boost llvmPackages.libclang ]
-    ++ stdenv.lib.optional stdenv.hostPlatform.isDarwin Cocoa;
+    ++ lib.optional stdenv.hostPlatform.isDarwin Cocoa;
 
   buildPhase = ''
     export EXTRA_CMAKE_ARGS=-DPATH_TO_LLVM_ROOT=${llvmPackages.clang-unwrapped}
···
                 "'$out/lib/ycmd/ycmd/__main__.py'"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A code-completion and comprehension server";
     homepage = "https://github.com/Valloric/ycmd";
     license = licenses.gpl3;

pkgs/development/tools/misc/yodl/default.nix

···
-{ stdenv, fetchFromGitLab, perl, icmake, util-linux }:
+{ lib, stdenv, fetchFromGitLab, perl, icmake, util-linux }:
 
 stdenv.mkDerivation rec {
   pname = "yodl";
···
     ./build install man
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A package that implements a pre-document language and tools to process it";
     homepage = "https://fbb-git.gitlab.io/yodl/";
     license = licenses.gpl3;

pkgs/development/tools/modd/default.nix

···
-{ buildGoPackage, fetchFromGitHub, stdenv }:
+{ buildGoPackage, fetchFromGitHub, lib, stdenv }:
 
 buildGoPackage rec {
   pname = "modd";
···
   };
   goPackagePath = "github.com/cortesi/modd";
   subPackages = [ "cmd/modd" ];
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A flexible developer tool that runs processes and responds to filesystem changes";
     homepage = "https://github.com/cortesi/modd";
     license = licenses.mit;

pkgs/development/tools/mustache-go/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "mustache-go";
···
     sha256 = "0mnh5zbpfwymddm1dppg9i9d1r8jqyg03z2gl6c5a8fgbrnxpjvc";
   };
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/cbroglie/mustache";
     description = "The mustache template language in Go";
     license = [ licenses.mit ];

pkgs/development/tools/nemiver/default.nix

···
   version = "0.9.6";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/nemiver/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    url = "mirror://gnome/sources/nemiver/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "85ab8cf6c4f83262f441cb0952a6147d075c3c53d0687389a3555e946b694ef2";
   };
 

pkgs/development/tools/neoload/default.nix

···
-{ stdenv, fetchurl, writeTextFile, jre, makeWrapper, fontsConf, licenseAccepted ? false }:
+{ lib, stdenv, fetchurl, writeTextFile, jre, makeWrapper, fontsConf, licenseAccepted ? false }:
 
 # If you happen to use this software on the XMonad window manager, you will have issues with
 # grey windows, no resizing, menus not showing and other glitches.
···
     homepage = "https://www.neotys.com/product/overview-neoload.html";
 
     # https://www.neotys.com/documents/legal/eula/neoload/eula_en.html
-    license = stdenv.lib.licenses.unfree;
+    license = lib.licenses.unfree;
 
-    maintainers = [ stdenv.lib.maintainers.bluescreen303 ];
+    maintainers = [ lib.maintainers.bluescreen303 ];
     platforms = [ "i686-linux" "x86_64-linux" ];
   };
 }

pkgs/development/tools/node-webkit/nw12.nix

···
 
     ln -s ${lib.getLib systemd}/lib/libudev.so $out/share/nwjs/libudev.so.0
 
-    patchelf --set-rpath "${nwEnv}/lib:${nwEnv}/lib64:${stdenv.lib.makeLibraryPath [ stdenv.cc.cc ]}:$out/share/nwjs" $out/share/nwjs/nw
+    patchelf --set-rpath "${nwEnv}/lib:${nwEnv}/lib64:${lib.makeLibraryPath [ stdenv.cc.cc ]}:$out/share/nwjs" $out/share/nwjs/nw
     patchelf --set-rpath "${nwEnv}/lib:${nwEnv}/lib64:$out/share/nwjs" $out/share/nwjs/nwjc
 
     mkdir -p $out/bin
···
 
   buildInputs = [ makeWrapper ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "An app runtime based on Chromium and node.js";
     homepage = "https://nwjs.io/";
     platforms = ["i686-linux" "x86_64-linux"];

pkgs/development/tools/nrpl/default.nix

···
       --prefix PATH : ${lib.makeBinPath [ nim tinycc ]}
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "REPL for the Nim programming language";
     homepage = "https://github.com/wheineman/nrpl";
     license = licenses.mit;

pkgs/development/tools/nwjs/default.nix

···
   dontPatchELF = true;
 
   installPhase =
-    let ccPath = stdenv.lib.makeLibraryPath [ stdenv.cc.cc ];
+    let ccPath = lib.makeLibraryPath [ stdenv.cc.cc ];
     in ''
       mkdir -p $out/share/nwjs
       cp -R * $out/share/nwjs
···
 
   buildInputs = [ makeWrapper ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "An app runtime based on Chromium and node.js";
     homepage = "https://nwjs.io/";
     platforms = ["i686-linux" "x86_64-linux"];

pkgs/development/tools/ocaml/camlidl/default.nix

···
-{ stdenv, fetchurl, ocaml, writeText }:
+{ lib, stdenv, fetchurl, ocaml, writeText }:
 
 let
   pname = "camlidl";
···
     description = "A stub code generator and COM binding for Objective Caml";
     homepage = webpage;
     license = "LGPL";
-    maintainers = [ stdenv.lib.maintainers.roconnor ];
+    maintainers = [ lib.maintainers.roconnor ];
   };
 }

pkgs/development/tools/ocaml/camlp4/default.nix

···
-{ stdenv, fetchzip, which, ocaml, ocamlbuild }:
+{ lib, stdenv, fetchzip, which, ocaml, ocamlbuild }:
 
-if stdenv.lib.versionAtLeast ocaml.version "4.09"
+if lib.versionAtLeast ocaml.version "4.09"
 then throw "camlp4 is not available for OCaml ${ocaml.version}"
 else
 
···
 
   dontStrip = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A software system for writing extensible parsers for programming languages";
     homepage = "https://github.com/ocaml/camlp4";
     platforms = ocaml.meta.platforms or [];

pkgs/development/tools/ocaml/camlp5/default.nix

···
-{ stdenv, fetchzip, ocaml, perl }:
+{ lib, stdenv, fetchzip, ocaml, perl }:
 
-if stdenv.lib.versionOlder ocaml.version "4.02"
+if lib.versionOlder ocaml.version "4.02"
 then throw "camlp5 is not available for OCaml ${ocaml.version}"
 else
 
···
 
   dontStrip = true;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Preprocessor-pretty-printer for OCaml";
     longDescription = ''
       Camlp5 is a preprocessor and pretty-printer for OCaml programs.

pkgs/development/tools/ocaml/cppo/default.nix

···
-{ stdenv, fetchurl, fetchFromGitHub, ocaml, findlib, ocamlbuild
+{ lib, stdenv, fetchurl, fetchFromGitHub, ocaml, findlib, ocamlbuild
 , buildDunePackage
 }:
 
 let
   pname = "cppo";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "The C preprocessor for OCaml";
     longDescription = ''
       Cppo is an equivalent of the C preprocessor targeted at the OCaml language and its variants.
···
 
 in
 
-if stdenv.lib.versionAtLeast ocaml.version "4.02" then
+if lib.versionAtLeast ocaml.version "4.02" then
 
 buildDunePackage rec {
   inherit pname;

pkgs/development/tools/ocaml/dune/2.nix

···
-{ stdenv, fetchurl, ocaml, findlib }:
+{ lib, stdenv, fetchurl, ocaml, findlib }:
 
-if stdenv.lib.versionOlder ocaml.version "4.08"
+if lib.versionOlder ocaml.version "4.08"
 then throw "dune is not available for OCaml ${ocaml.version}"
 else
 
···
     homepage = "https://dune.build/";
     description = "A composable build system";
     changelog = "https://github.com/ocaml/dune/releases/tag/${version}";
-    maintainers = [ stdenv.lib.maintainers.vbgl stdenv.lib.maintainers.marsam ];
-    license = stdenv.lib.licenses.mit;
+    maintainers = [ lib.maintainers.vbgl lib.maintainers.marsam ];
+    license = lib.licenses.mit;
     inherit (ocaml.meta) platforms;
   };
 }

pkgs/development/tools/ocaml/findlib/default.nix

···
-{ stdenv, fetchurl, fetchpatch, m4, ncurses, ocaml, writeText }:
+{ lib, stdenv, fetchurl, fetchpatch, m4, ncurses, ocaml, writeText }:
 
 stdenv.mkDerivation rec {
   pname = "ocaml-findlib";
···
   meta = {
     homepage = "http://projects.camlcity.org/projects/findlib.html";
     description = "O'Caml library manager";
-    license = stdenv.lib.licenses.mit;
+    license = lib.licenses.mit;
     platforms = ocaml.meta.platforms or [];
     maintainers = [
-      stdenv.lib.maintainers.maggesi
-      stdenv.lib.maintainers.vbmithr
+      lib.maintainers.maggesi
+      lib.maintainers.vbmithr
     ];
   };
 }

pkgs/development/tools/ocaml/oasis/default.nix

···
-{ stdenv, fetchurl, ocaml, findlib, ocamlbuild, ocamlmod, ocamlify }:
+{ lib, stdenv, fetchurl, ocaml, findlib, ocamlbuild, ocamlmod, ocamlify }:
 
 stdenv.mkDerivation {
   version = "0.4.10";
···
   buildPhase     = "ocaml setup.ml -build";
   installPhase   = "ocaml setup.ml -install";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "http://oasis.forge.ocamlcore.org/";
     description = "Configure, build and install system for OCaml projects";
     license = licenses.lgpl21;

pkgs/development/tools/ocaml/obuild/default.nix

···
-{ stdenv, fetchzip, ocaml }:
+{ lib, stdenv, fetchzip, ocaml }:
 
 let version = "0.1.10"; in
 
···
     homepage = "https://github.com/ocaml-obuild/obuild";
     platforms = ocaml.meta.platforms or [];
     description = "Simple package build system for OCaml";
-    license = stdenv.lib.licenses.lgpl21;
-    maintainers = with stdenv.lib.maintainers; [ volth ];
+    license = lib.licenses.lgpl21;
+    maintainers = with lib.maintainers; [ volth ];
   };
 }

pkgs/development/tools/ocaml/ocamlbuild/default.nix

···
-{ stdenv, fetchFromGitHub, ocaml, findlib }:
+{ lib, stdenv, fetchFromGitHub, ocaml, findlib }:
 let
   version = "0.14.0";
 in
···
     "OCAMLBUILD_LIBDIR=$OCAMLFIND_DESTDIR"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/ocaml/ocamlbuild/";
     description = "A build system with builtin rules to easily build most OCaml projects";
     license = licenses.lgpl2;

pkgs/development/tools/ocaml/ocamlify/default.nix

···
-{ stdenv, fetchurl, ocaml, findlib, ocamlbuild }:
+{ lib, stdenv, fetchurl, ocaml, findlib, ocamlbuild }:
 
 stdenv.mkDerivation {
   name = "ocamlify-0.0.2";
···
     homepage = "https://forge.ocamlcore.org/projects/ocamlmod/ocamlmod";
     description = "Generate OCaml modules from source files";
     platforms = ocaml.meta.platforms or [];
-    license = stdenv.lib.licenses.lgpl21;
-    maintainers = with stdenv.lib.maintainers; [
+    license = lib.licenses.lgpl21;
+    maintainers = with lib.maintainers; [
       maggesi
     ];
   };

pkgs/development/tools/ocaml/ocamlmod/default.nix

···
-{ stdenv, fetchurl, ocaml, findlib, ocamlbuild, ounit }:
+{ lib, stdenv, fetchurl, ocaml, findlib, ocamlbuild, ounit }:
 
 stdenv.mkDerivation {
   pname = "ocamlmod";
···
     homepage = "https://forge.ocamlcore.org/projects/ocamlmod/ocamlmod";
     description = "Generate OCaml modules from source files";
     platforms = ocaml.meta.platforms or [];
-    maintainers = with stdenv.lib.maintainers; [
+    maintainers = with lib.maintainers; [
       maggesi
     ];
   };

pkgs/development/tools/ocaml/ocp-build/default.nix

···
-{ stdenv, fetchFromGitHub, ocaml, findlib, ncurses, cmdliner, re }:
+{ lib, stdenv, fetchFromGitHub, ocaml, findlib, ncurses, cmdliner, re }:
 let
   version = "1.99.21";
 in
···
   export configureFlags="$configureFlags --with-metadir=$OCAMLFIND_DESTDIR"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://www.typerex.org/ocp-build.html";
     description = "A build tool for OCaml";
     longDescription = ''

pkgs/development/tools/ocaml/ocsigen-i18n/default.nix

···
-{ stdenv, fetchzip, ocamlPackages }:
+{ lib, stdenv, fetchzip, ocamlPackages }:
 
 stdenv.mkDerivation rec
 {
···
   meta = {
     homepage = "https://github.com/besport/ocsigen-i18n";
     description = "I18n made easy for web sites written with eliom";
-    license = stdenv.lib.licenses.lgpl21;
-    maintainers = [ stdenv.lib.maintainers.gal_bolle ];
+    license = lib.licenses.lgpl21;
+    maintainers = [ lib.maintainers.gal_bolle ];
   };
 
 }

pkgs/development/tools/ocaml/omake/0.9.8.6-rc1.nix

···
-{stdenv, fetchurl, makeWrapper, ocaml, ncurses}:
+{lib, stdenv, fetchurl, makeWrapper, ocaml, ncurses}:
 let
   pname = "omake";
   version = "0.9.8.6-0.rc1";
   webpage = "http://omake.metaprl.org";
 in
 
-if stdenv.lib.versionAtLeast ocaml.version "4.06"
+if lib.versionAtLeast ocaml.version "4.06"
 then throw "${pname}-${version} is not available for OCaml ${ocaml.version}"
 else
 

pkgs/development/tools/ocaml/omake/default.nix

···
-{ stdenv, fetchurl, ocaml, ncurses }:
+{ lib, stdenv, fetchurl, ocaml, ncurses }:
 
 stdenv.mkDerivation rec {
 
···
   meta = {
     description = "A build system designed for scalability and portability";
     homepage = "http://projects.camlcity.org/projects/omake.html";
-    license = with stdenv.lib.licenses; [
+    license = with lib.licenses; [
       mit /* scripts */
       gpl2 /* program */
     ];

pkgs/development/tools/ocaml/opaline/default.nix

···
-{ stdenv, fetchFromGitHub, ocamlPackages }:
+{ lib, stdenv, fetchFromGitHub, ocamlPackages }:
 
 stdenv.mkDerivation rec {
   version = "0.3.2";
···
 
   meta = {
     description = "OPAm Light INstaller Engine";
-    license = stdenv.lib.licenses.mit;
-    maintainers = [ stdenv.lib.maintainers.vbgl ];
+    license = lib.licenses.mit;
+    maintainers = [ lib.maintainers.vbgl ];
     inherit (src.meta) homepage;
     inherit (ocamlPackages.ocaml.meta) platforms;
   };

pkgs/development/tools/ocaml/opam/1.2.2.nix

···
 
   doCheck = false;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A package manager for OCaml";
     homepage = "http://opam.ocamlpro.com/";
     maintainers = [ maintainers.henrytill ];

pkgs/development/tools/ocaml/opam/default.nix

···
 
   doCheck = false;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A package manager for OCaml";
     homepage = "https://opam.ocaml.org/";
     maintainers = [ maintainers.henrytill maintainers.marsam ];

pkgs/development/tools/ocaml/utop/default.nix

···
-{ stdenv, fetchurl, ocaml, findlib
+{ lib, stdenv, fetchurl, ocaml, findlib
 , lambdaTerm, cppo, makeWrapper, buildDunePackage
 }:
 
-if !stdenv.lib.versionAtLeast ocaml.version "4.03"
+if !lib.versionAtLeast ocaml.version "4.03"
 then throw "utop is not available for OCaml ${ocaml.version}"
 else
 
···
       --prefix CAML_LD_LIBRARY_PATH ":" "${get "CAML_LD_LIBRARY_PATH"}" \
       --prefix OCAMLPATH ":" "${get "OCAMLPATH"}" \
       --prefix OCAMLPATH ":" $(unset OCAMLPATH; addOCamlPath "$out"; printf %s "$OCAMLPATH") \
-      --add-flags "-I ${findlib}/lib/ocaml/${stdenv.lib.getVersion ocaml}/site-lib"
+      --add-flags "-I ${findlib}/lib/ocaml/${lib.getVersion ocaml}/site-lib"
    done
    '';
 
···
     It integrates with the tuareg mode in Emacs.
     '';
     homepage = "https://github.com/diml/utop";
-    license = stdenv.lib.licenses.bsd3;
+    license = lib.licenses.bsd3;
     platforms = ocaml.meta.platforms or [];
     maintainers = [
-      stdenv.lib.maintainers.gal_bolle
+      lib.maintainers.gal_bolle
     ];
   };
 }

pkgs/development/tools/omniorb/default.nix

···
-{ stdenv, fetchurl, python2 }:
+{ lib, stdenv, fetchurl, python2 }:
 stdenv.mkDerivation rec {
 
   pname = "omniorb";
···
 
   hardeningDisable = [ "format" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A robust high performance CORBA ORB for C++ and Python. It is freely available under the terms of the GNU Lesser General Public License (for the libraries), and GNU General Public License (for the tools). omniORB is largely CORBA 2.6 compliant";
     homepage    = "http://omniorb.sourceforge.net/";
     license     = licenses.gpl2Plus;

pkgs/development/tools/omnisharp-roslyn/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchurl
 , mono5
 , makeWrapper
···
     --add-flags "$out/src/OmniSharp.exe"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "OmniSharp based on roslyn workspaces";
     homepage = "https://github.com/OmniSharp/omnisharp-roslyn";
     platforms = platforms.linux;

pkgs/development/tools/out-of-tree/default.nix

···
 
   postFixup = ''
     wrapProgram $out/bin/out-of-tree \
-      --prefix PATH : "${stdenv.lib.makeBinPath [ qemu docker which ]}"
+      --prefix PATH : "${lib.makeBinPath [ qemu docker which ]}"
   '';
 
   meta = with lib; {

pkgs/development/tools/packet/default.nix

···
 # This file was generated by https://github.com/kamilchm/go2nix v1.2.1
-{ stdenv, buildGoPackage, fetchgit }:
+{ lib, stdenv, buildGoPackage, fetchgit }:
 
 buildGoPackage rec {
   pname = "packet";
···
   meta = {
     description = "a CLI tool to manage packet.net services";
     homepage = "https://github.com/ebsarr/packet";
-    license = stdenv.lib.licenses.mit;
-    maintainers = [ stdenv.lib.maintainers.grahamc ];
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.mit;
+    maintainers = [ lib.maintainers.grahamc ];
+    platforms = lib.platforms.unix;
   };
 }

pkgs/development/tools/parsing/antlr/3.5.nix

···
     homepage = "https://www.antlr.org/";
     license = licenses.bsd3;
     platforms = platforms.linux;
-    maintainers = [ stdenv.lib.maintainers.farlion ];
+    maintainers = [ lib.maintainers.farlion ];
   };
 }

pkgs/development/tools/parsing/antlr/4.8.nix

···
       outputs = [ "out" "dev" "doc" ];
 
       nativeBuildInputs = [ cmake ninja pkg-config ];
-      buildInputs = stdenv.lib.optional stdenv.isLinux libuuid
-        ++ stdenv.lib.optional stdenv.isDarwin darwin.apple_sdk.frameworks.CoreFoundation;
+      buildInputs = lib.optional stdenv.isLinux libuuid
+        ++ lib.optional stdenv.isDarwin darwin.apple_sdk.frameworks.CoreFoundation;
 
       postUnpack = ''
         export sourceRoot=$sourceRoot/runtime/Cpp

pkgs/development/tools/parsing/bison/default.nix

···
-{ stdenv, fetchurl, m4, perl, help2man }:
+{ lib, stdenv, fetchurl, m4, perl, help2man }:
 
 # Note: this package is used for bootstrapping fetchurl, and thus
 # cannot use fetchpatch! All mutable patches (generated by GitHub or
···
     sha256 = "1qkp2rfi5njyp5c5avajab00aj74pkmkgzkvshv4p2ydkhswgazv";
   };
 
-  nativeBuildInputs = [ m4 perl ] ++ stdenv.lib.optional stdenv.isSunOS help2man;
+  nativeBuildInputs = [ m4 perl ] ++ lib.optional stdenv.isSunOS help2man;
   propagatedBuildInputs = [ m4 ];
 
   doCheck = false; # fails
···
   meta = {
     homepage = "https://www.gnu.org/software/bison/";
     description = "Yacc-compatible parser generator";
-    license = stdenv.lib.licenses.gpl3Plus;
+    license = lib.licenses.gpl3Plus;
 
     longDescription = ''
       Bison is a general-purpose parser generator that converts an
···
       to use Bison.
     '';
 
-    platforms = stdenv.lib.platforms.unix;
+    platforms = lib.platforms.unix;
   };
 
   passthru = { glrSupport = true; };

pkgs/development/tools/parsing/flex/2.5.35.nix

···
 
   propagatedBuildInputs = [ m4 ];
 
-  preConfigure = stdenv.lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
+  preConfigure = lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
     "ac_cv_func_malloc_0_nonnull=yes"
     "ac_cv_func_realloc_0_nonnull=yes"
   ];

pkgs/development/tools/parsing/flex/2.6.1.nix

···
 
   postPatch = ''
     patchShebangs tests
-  '' + stdenv.lib.optionalString (stdenv.hostPlatform != stdenv.buildPlatform) ''
+  '' + lib.optionalString (stdenv.hostPlatform != stdenv.buildPlatform) ''
     substituteInPlace Makefile.in --replace "tests" " ";
   '';
 
···
 
   propagatedBuildInputs = [ m4 ];
 
-  preConfigure = stdenv.lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
+  preConfigure = lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
     "ac_cv_func_malloc_0_nonnull=yes"
     "ac_cv_func_realloc_0_nonnull=yes"
   ];
 
-  postConfigure = stdenv.lib.optionalString (stdenv.isDarwin || stdenv.isCygwin) ''
+  postConfigure = lib.optionalString (stdenv.isDarwin || stdenv.isCygwin) ''
     sed -i Makefile -e 's/-no-undefined//;'
   '';
 

pkgs/development/tools/parsing/flex/default.nix

···
 
   postPatch = ''
     patchShebangs tests
-  '' + stdenv.lib.optionalString (stdenv.buildPlatform != stdenv.hostPlatform) ''
+  '' + lib.optionalString (stdenv.buildPlatform != stdenv.hostPlatform) ''
     substituteInPlace Makefile.in --replace "tests" " "
 
     substituteInPlace doc/Makefile.am --replace 'flex.1: $(top_srcdir)/configure.ac' 'flex.1: '
···
   buildInputs = [ bison ];
   propagatedBuildInputs = [ m4 ];
 
-  preConfigure = stdenv.lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
+  preConfigure = lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
     "ac_cv_func_malloc_0_nonnull=yes"
     "ac_cv_func_realloc_0_nonnull=yes"
   ];
 
-  postConfigure = stdenv.lib.optionalString (stdenv.isDarwin || stdenv.isCygwin) ''
+  postConfigure = lib.optionalString (stdenv.isDarwin || stdenv.isCygwin) ''
     sed -i Makefile -e 's/-no-undefined//;'
   '';
 

pkgs/development/tools/parsing/ragel/default.nix

···
         inherit sha256;
       };
 
-      buildInputs = stdenv.lib.optional build-manual [ transfig ghostscript tex ];
+      buildInputs = lib.optional build-manual [ transfig ghostscript tex ];
 
-      preConfigure = stdenv.lib.optional build-manual ''
+      preConfigure = lib.optional build-manual ''
         sed -i "s/build_manual=no/build_manual=yes/g" DIST
       '';
 
       configureFlags = [ "--with-colm=${colm}" ];
 
-      NIX_CFLAGS_COMPILE = stdenv.lib.optionalString stdenv.cc.isGNU "-std=gnu++98";
+      NIX_CFLAGS_COMPILE = lib.optionalString stdenv.cc.isGNU "-std=gnu++98";
 
       doCheck = true;
 
···
   ragelStable = generic {
     version = "6.10";
     sha256 = "0gvcsl62gh6sg73nwaxav4a5ja23zcnyxncdcdnqa2yjcpdnw5az";
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
   };
 
   ragelDev = generic {
     version = "7.0.0.12";
     sha256 = "0x3si355lv6q051lgpg8bpclpiq5brpri5lv3p8kk2qhzfbyz69r";
-    license = stdenv.lib.licenses.mit;
+    license = lib.licenses.mit;
   };
 }

pkgs/development/tools/pgformatter/default.nix

···
       --replace "'INSTALLDIRS'  => \$INSTALLDIRS," "'INSTALLDIRS'  => \$INSTALLDIRS, 'INSTALLVENDORLIB' => 'bin/lib', 'INSTALLVENDORBIN' => 'bin', 'INSTALLVENDORSCRIPT' => 'bin', 'INSTALLVENDORMAN1DIR' => 'share/man/man1', 'INSTALLVENDORMAN3DIR' => 'share/man/man3',"
   '';
 
-  nativeBuildInputs = stdenv.lib.optional stdenv.isDarwin shortenPerlShebang;
-  postInstall = stdenv.lib.optionalString stdenv.isDarwin ''
+  nativeBuildInputs = lib.optional stdenv.isDarwin shortenPerlShebang;
+  postInstall = lib.optionalString stdenv.isDarwin ''
     shortenPerlShebang $out/bin/pg_format
   '';
 

pkgs/development/tools/pgloader/default.nix

···
   nativeBuildInputs = [ git makeWrapper ];
   buildInputs = [ sbcl cacert sqlite freetds libzip curl openssl ];
 
-  LD_LIBRARY_PATH = stdenv.lib.makeLibraryPath [ sqlite libzip curl git openssl freetds ];
+  LD_LIBRARY_PATH = lib.makeLibraryPath [ sqlite libzip curl git openssl freetds ];
 
   buildPhase = ''
     export PATH=$PATH:$out/bin

pkgs/development/tools/phantomjs/default.nix

···
   buildPhase = lib.optionalString (!stdenv.isDarwin) ''
     patchelf \
       --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
-      --set-rpath "${stdenv.lib.makeLibraryPath [ freetype fontconfig stdenv.cc.cc stdenv.cc.cc openssl ]}" \
+      --set-rpath "${lib.makeLibraryPath [ freetype fontconfig stdenv.cc.cc stdenv.cc.cc openssl ]}" \
       bin/phantomjs
   '';
 

pkgs/development/tools/phantomjs2/default.nix

···
     bison flex fontconfig freetype gperf icu openssl
     libjpeg libpng perl python ruby sqlite qtwebkit qtbase
     makeWrapper
-  ] ++ stdenv.lib.optionals stdenv.isDarwin (with darwin.apple_sdk.frameworks; [
+  ] ++ lib.optionals stdenv.isDarwin (with darwin.apple_sdk.frameworks; [
     AGL ApplicationServices AppKit Cocoa OpenGL
     darwin.libobjc fakeClang cups
   ]);
···
   # invalid suffix on literal; C++11 requires a space between litend identifier
   NIX_CFLAGS_COMPILE = "-Wno-reserved-user-defined-literal";
 
-  __impureHostDeps = stdenv.lib.optional stdenv.isDarwin "/usr/lib/libicucore.dylib";
+  __impureHostDeps = lib.optional stdenv.isDarwin "/usr/lib/libicucore.dylib";
 
   enableParallelBuilding = true;
 
···
     mkdir -p $out/share/doc/phantomjs
     cp -a bin $out
     cp -a ChangeLog examples LICENSE.BSD README.md third-party.txt $out/share/doc/phantomjs
-  '' + stdenv.lib.optionalString stdenv.isDarwin ''
+  '' + lib.optionalString stdenv.isDarwin ''
     install_name_tool -change \
         ${darwin.CF}/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation \
         /System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation \
···
   '' + ''
     wrapProgram $out/bin/phantomjs \
     --set QT_QPA_PLATFORM offscreen \
-    --prefix PATH : ${stdenv.lib.makeBinPath [ qtbase ]}
+    --prefix PATH : ${lib.makeBinPath [ qtbase ]}
   '';
 
   meta = with lib; {

pkgs/development/tools/poetry2nix/poetry2nix/overrides.nix

···
   cryptography = super.cryptography.overridePythonAttrs (
     old: {
       nativeBuildInputs = old.nativeBuildInputs or [ ]
-        ++ stdenv.lib.optional (stdenv.buildPlatform != stdenv.hostPlatform) self.python.pythonForBuild.pkgs.cffi;
+        ++ lib.optional (stdenv.buildPlatform != stdenv.hostPlatform) self.python.pythonForBuild.pkgs.cffi;
       buildInputs = old.buildInputs ++ [ pkgs.openssl ];
     }
   );
···
       inherit (pkgs.darwin.apple_sdk.frameworks) Cocoa;
     in
     {
-      NIX_CFLAGS_COMPILE = stdenv.lib.optionalString stdenv.isDarwin "-I${pkgs.libcxx}/include/c++/v1";
+      NIX_CFLAGS_COMPILE = lib.optionalString stdenv.isDarwin "-I${pkgs.libcxx}/include/c++/v1";
 
       XDG_RUNTIME_DIR = "/tmp";
 
···
         pkgs.libpng
         pkgs.freetype
       ]
-        ++ stdenv.lib.optionals enableGtk3 [ pkgs.cairo self.pycairo pkgs.gtk3 pkgs.gobject-introspection self.pygobject3 ]
-        ++ stdenv.lib.optionals enableTk [ pkgs.tcl pkgs.tk self.tkinter pkgs.libX11 ]
-        ++ stdenv.lib.optionals enableQt [ self.pyqt5 ]
+        ++ lib.optionals enableGtk3 [ pkgs.cairo self.pycairo pkgs.gtk3 pkgs.gobject-introspection self.pygobject3 ]
+        ++ lib.optionals enableTk [ pkgs.tcl pkgs.tk self.tkinter pkgs.libX11 ]
+        ++ lib.optionals enableQt [ self.pyqt5 ]
       ;
 
       inherit (super.matplotlib) patches;

pkgs/development/tools/profiling/EZTrace/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchurl, autoconf, gfortran
 , libelf, libiberty, zlib, libbfd, libopcodes
 , buildPackages
···
 
   meta = {
     description = "Tool that aims at generating automatically execution trace from HPC programs";
-    license = stdenv.lib.licenses.cecill-b;
-    maintainers = with stdenv.lib.maintainers; [ ];
+    license = lib.licenses.cecill-b;
+    maintainers = with lib.maintainers; [ ];
   };
 }

pkgs/development/tools/profiling/oprofile/default.nix

···
-{ stdenv, buildPackages
+{ lib, stdenv, buildPackages
 , fetchurl, pkg-config
 , libbfd, popt, zlib, linuxHeaders, libiberty_static
 , withGUI ? false, qt4 ? null
···
 
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ libbfd zlib popt linuxHeaders libiberty_static ]
-    ++ stdenv.lib.optionals withGUI [ qt4 ];
+    ++ lib.optionals withGUI [ qt4 ];
 
   configureFlags = [
       "--with-kernel=${linuxHeaders}"
       "--disable-shared"   # needed because only the static libbfd is available
     ]
-    ++ stdenv.lib.optional withGUI "--with-qt-dir=${qt4} --enable-gui=qt4";
+    ++ lib.optional withGUI "--with-qt-dir=${qt4} --enable-gui=qt4";
 
   meta = {
     description = "System-wide profiler for Linux";
···
       is profiled: hardware and software interrupt handlers, kernel
       modules, the kernel, shared libraries, and applications.
     '';
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
     homepage = "http://oprofile.sourceforge.net/";
 
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
     maintainers = [ ];
   };
 }

pkgs/development/tools/profiling/sysprof/capture.nix

···
-{ stdenv
+{ lib, stdenv
 , meson
 , ninja
 , sysprof
···
 
   meta = sysprof.meta // {
     description = "Static library for Sysprof capture data generation";
-    platforms = stdenv.lib.platforms.all;
+    platforms = lib.platforms.all;
   };
 }

pkgs/development/tools/profiling/sysprof/default.nix

···
   outputs = [ "out" "lib" "dev" ];
 
   src = fetchurl {
-    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "1z2i9187f2jx456l7h07wy8m9a0p7pj3xiv1aji3snq7rjb1lkj0";
   };
 

pkgs/development/tools/purescript/spago/spago.nix

···
 , http-conduit, http-types, lens-family-core, megaparsec, mtl
 , network-uri, open-browser, optparse-applicative, prettyprinter
 , process, QuickCheck, retry, rio, rio-orphans, safe, semver-range
-, stdenv, stm, stringsearch, tar, template-haskell, temporary, text
+, lib, stdenv, stm, stringsearch, tar, template-haskell, temporary, text
 , time, transformers, turtle, unliftio, unordered-containers
 , utf8-string, vector, versions, with-utf8, zlib
 }:
···
   testToolDepends = [ hspec-discover ];
   prePatch = "hpack";
   homepage = "https://github.com/purescript/spago#readme";
-  license = stdenv.lib.licenses.bsd3;
+  license = lib.licenses.bsd3;
 }

pkgs/development/tools/py-spy/default.nix

···
   NIX_CFLAGS_COMPILE = "-L${libunwind}/lib";
 
   # error: linker `arm-linux-gnueabihf-gcc` not found
-  preConfigure = stdenv.lib.optionalString (stdenv.buildPlatform != stdenv.hostPlatform) ''
+  preConfigure = lib.optionalString (stdenv.buildPlatform != stdenv.hostPlatform) ''
     export RUSTFLAGS="-Clinker=$CC"
   '';
 

pkgs/development/tools/pydb/default.nix

···
-{ stdenv, fetchurl, python2, emacs }:
+{ lib, stdenv, fetchurl, python2, emacs }:
 
 stdenv.mkDerivation {
   name = "pydb-1.26";
···
   meta = {
     description = "Python debugger with GDB-like commands and Emacs bindings";
     homepage = "http://bashdb.sourceforge.net/pydb/";
-    license = stdenv.lib.licenses.gpl3;
-    platforms = stdenv.lib.platforms.all;
+    license = lib.licenses.gpl3;
+    platforms = lib.platforms.all;
   };
 }

pkgs/development/tools/quilt/default.nix

···
-{ stdenv, fetchurl, makeWrapper, bash, perl, diffstat, diffutils, patch, findutils }:
+{ lib, stdenv, fetchurl, makeWrapper, bash, perl, diffstat, diffutils, patch, findutils }:
 
 stdenv.mkDerivation rec {
 
···
       and more.
     '';
 
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.all;
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.all;
   };
 
 }

pkgs/development/tools/rdocker/default.nix

···
 
   postInstall = ''
     wrapProgram $out/bin/rdocker \
-      --prefix PATH : ${stdenv.lib.makeBinPath [ openssh ]}
+      --prefix PATH : ${lib.makeBinPath [ openssh ]}
   '';
 
   meta = with lib; {
     description = "Securely control a remote docker daemon CLI using ssh forwarding, no SSL setup needed";
     homepage = "https://github.com/dvddarias/rdocker";
-    maintainers = [ stdenv.lib.maintainers.pneumaticat ];
+    maintainers = [ lib.maintainers.pneumaticat ];
     license = licenses.mit;
     platforms = platforms.unix;
   };

pkgs/development/tools/react-native-debugger/default.nix

···
 }:
 
 let
-  rpath = stdenv.lib.makeLibraryPath [
+  rpath = lib.makeLibraryPath [
     cairo
     stdenv.cc.cc
     gdk-pixbuf

pkgs/development/tools/repository-managers/nexus/default.nix

···
     wrapProgram $out/bin/nexus \
       --set JAVA_HOME ${jre_headless} \
       --set ALTERNATIVE_NAME "nexus" \
-      --prefix PATH "${stdenv.lib.makeBinPath [ gawk ]}"
+      --prefix PATH "${lib.makeBinPath [ gawk ]}"
 
     runHook postInstall
   '';

pkgs/development/tools/rtags/default.nix

···
   meta = {
     description = "C/C++ client-server indexer based on clang";
     homepage = "https://github.com/andersbakken/rtags";
-    license = stdenv.lib.licenses.gpl3;
-    platforms = with stdenv.lib.platforms; x86_64 ++ aarch64;
+    license = lib.licenses.gpl3;
+    platforms = with lib.platforms; x86_64 ++ aarch64;
   };
 }

pkgs/development/tools/rund/default.nix

···
     homepage = "https://github.com/dragon-lang/rund";
     license = lib.licenses.boost;
     maintainers = with maintainers; [ jonathanmarler ];
-    platforms = stdenv.lib.platforms.unix;
+    platforms = lib.platforms.unix;
   };
 }

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

···
 
   cargoSha256 = "0d797cisiydblh64vqpfdjf37wmxrvs77phdrqh582lbrvnfhx2j";
 
-  buildInputs = stdenv.lib.optional stdenv.isDarwin Security;
+  buildInputs = lib.optional stdenv.isDarwin Security;
 
   # Test checks against machine code output, which fails with some
   # LLVM/compiler versions.

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

···
 
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ openssl ]
-  ++ stdenv.lib.optionals stdenv.isDarwin [ CoreFoundation libiconv Security ];
+  ++ lib.optionals stdenv.isDarwin [ CoreFoundation libiconv Security ];
 
   meta = with lib; {
     description = "A cargo subcommand to build and install C-ABI compatibile dynamic and static libraries";

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

···
 
   cargoSha256 = "sha256-sZxkEQBZ2PJXSvwcA+IL7uW/gcnzuzRcDklNW5vpzWg=";
 
-  buildInputs = stdenv.lib.optionals stdenv.isDarwin [ libiconv Security ];
+  buildInputs = lib.optionals stdenv.isDarwin [ libiconv Security ];
 
   checkFlagsArray = [ "offline_tests" ];
 

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

···
 
   nativeBuildInputs = [ perl pkg-config ];
 
-  buildInputs = [ openssl ] ++ stdenv.lib.optionals stdenv.isDarwin [ Security libiconv curl ];
+  buildInputs = [ openssl ] ++ lib.optionals stdenv.isDarwin [ Security libiconv curl ];
 
   meta = with lib; {
     description = "A cryptographically verifiable code review system for the cargo (Rust) package manager";

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

···
   nativeBuildInputs = [ perl pkg-config ];
 
   buildInputs = [ openssl  ]
-    ++ stdenv.lib.optionals stdenv.isDarwin [ Security libiconv curl ];
+    ++ lib.optionals stdenv.isDarwin [ Security libiconv curl ];
 
   meta = with lib; {
     description = "Cargo plugin to generate list of all licenses for a crate";

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

···
 
   nativeBuildInputs = [ pkg-config ];
 
-  buildInputs = [ openssl ] ++ stdenv.lib.optionals stdenv.isDarwin [ Security libiconv curl ];
+  buildInputs = [ openssl ] ++ lib.optionals stdenv.isDarwin [ Security libiconv curl ];
 
   meta = with lib; {
     description = "Discover funding links for your project's dependencies";

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

···
   # FIXME: Use impure version of CoreFoundation because of missing symbols.
   # CFURLSetResourcePropertyForKey is defined in the headers but there's no
   # corresponding implementation in the sources from opensource.apple.com.
-  preConfigure = stdenv.lib.optionalString stdenv.isDarwin ''
+  preConfigure = lib.optionalString stdenv.isDarwin ''
     export NIX_CFLAGS_COMPILE="-F${CoreFoundation}/Library/Frameworks $NIX_CFLAGS_COMPILE"
   '';
 

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

···
   nativeBuildInputs = [ pkg-config ];
 
   buildInputs = [ openssl  ]
-    ++ stdenv.lib.optionals stdenv.isDarwin [ Security libiconv curl ];
+    ++ lib.optionals stdenv.isDarwin [ Security libiconv curl ];
 
   preCheck = ''
     export HOME=$(mktemp -d) USER=nixbld

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

···
     sha256 = "026vc8d0jkc1d7dlp3ldmwks7svpvqzl0k5niri8a12cl5w5b9hj";
   };
 
-  buildInputs = stdenv.lib.optionals stdenv.isDarwin [ Security ];
+  buildInputs = lib.optionals stdenv.isDarwin [ Security ];
 
   cargoSha256 = "1ryi5qi1zz2yljyj4rn84q9zkzafc9w4nw3zc01hlzpnb1sjw5sw";
 

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

···
   nativeBuildInputs = [ pkg-config ];
 
   buildInputs = [ openssl ]
-    ++ stdenv.lib.optionals stdenv.isDarwin [ Security SystemConfiguration ];
+    ++ lib.optionals stdenv.isDarwin [ Security SystemConfiguration ];
 
   cargoSha256 = "sha256-Qh14lks72bsetwyv0ALF7nZo3m3FDEmVxzFkHJoEuzE=";
 

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

···
 
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ curl libgit2 openssl ]
-    ++ stdenv.lib.optional stdenv.isDarwin Security;
+    ++ lib.optional stdenv.isDarwin Security;
 
   doCheck = true;
 

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

···
   nativeBuildInputs = [ pkg-config ];
 
   buildInputs = [ openssl ]
-    ++ stdenv.lib.optionals stdenv.isDarwin [ CoreServices Security libiconv ];
+    ++ lib.optionals stdenv.isDarwin [ CoreServices Security libiconv ];
 
   # Requires network access
   doCheck = false;

pkgs/development/tools/rust/cbindgen/default.nix

···
 
   cargoSha256 = "1lzzckzcgj496chbfd6lhwxcangv0krx8m5k2jwffnb9mfgac7hx";
 
-  buildInputs = stdenv.lib.optional stdenv.isDarwin Security;
+  buildInputs = lib.optional stdenv.isDarwin Security;
 
   checkFlags = [
     # https://github.com/eqrion/cbindgen/issues/338

pkgs/development/tools/rust/maturin/default.nix

···
   nativeBuildInputs = [ pkg-config ];
 
   buildInputs = [ gmp openssl ]
-    ++ stdenv.lib.optional stdenv.isDarwin Security
-    ++ stdenv.lib.optional stdenv.isLinux dbus;
+    ++ lib.optional stdenv.isDarwin Security
+    ++ lib.optional stdenv.isLinux dbus;
 
   # Requires network access, fails in sandbox.
   doCheck = false;

pkgs/development/tools/rust/racer/default.nix

···
   cargoSha256 = "sha256-iUomr9viCdZk4nV75/OP8vHtJpMbmy+pq1IbaA2lLmE=";
 
   nativeBuildInputs = [ makeWrapper ];
-  buildInputs = stdenv.lib.optional stdenv.isDarwin Security;
+  buildInputs = lib.optional stdenv.isDarwin Security;
 
   # a nightly compiler is required unless we use this cheat code.
   RUSTC_BOOTSTRAP = 1;

pkgs/development/tools/rust/racerd/default.nix

···
   doCheck = false;
 
   nativeBuildInputs = [ makeWrapper ];
-  buildInputs = stdenv.lib.optional stdenv.isDarwin Security;
+  buildInputs = lib.optional stdenv.isDarwin Security;
 
   RUST_SRC_PATH = rustPlatform.rustcSrc;
 

pkgs/development/tools/rust/rustup/default.nix

···
 
   buildInputs = [
     curl zlib
-  ] ++ stdenv.lib.optionals stdenv.isDarwin [ CoreServices Security ];
+  ] ++ lib.optionals stdenv.isDarwin [ CoreServices Security ];
 
   cargoBuildFlags = [ "--features no-self-update" ];
 

pkgs/development/tools/sauce-connect/default.nix

···
 
   buildInputs = [ unzip ];
 
-  patchPhase = stdenv.lib.optionalString stdenv.isLinux ''
+  patchPhase = lib.optionalString stdenv.isLinux ''
     patchelf \
       --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath "$out/lib:${makeLibraryPath [zlib]}" \

pkgs/development/tools/selenium/chromedriver/default.nix

···
 }:
 
 let
-  upstream-info = (stdenv.lib.importJSON ../../../../applications/networking/browsers/chromium/upstream-info.json).stable.chromedriver;
+  upstream-info = (lib.importJSON ../../../../applications/networking/browsers/chromium/upstream-info.json).stable.chromedriver;
   allSpecs = {
     x86_64-linux = {
       system = "linux64";
···
   spec = allSpecs.${stdenv.hostPlatform.system}
     or (throw "missing chromedriver binary for ${stdenv.hostPlatform.system}");
 
-  libs = stdenv.lib.makeLibraryPath [
+  libs = lib.makeLibraryPath [
     stdenv.cc.cc.lib
     cairo fontconfig freetype
     gdk-pixbuf glib gtk2 gconf
···
 
   installPhase = ''
     install -m755 -D chromedriver $out/bin/chromedriver
-  '' + stdenv.lib.optionalString (!stdenv.isDarwin) ''
+  '' + lib.optionalString (!stdenv.isDarwin) ''
     patchelf --set-interpreter ${glibc.out}/lib/ld-linux-x86-64.so.2 $out/bin/chromedriver
     wrapProgram "$out/bin/chromedriver" --prefix LD_LIBRARY_PATH : "${libs}:\$LD_LIBRARY_PATH"
   '';

pkgs/development/tools/selenium/htmlunit-driver/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "htmlunit-driver-standalone";

pkgs/development/tools/selenium/selendroid/default.nix

···
-{ stdenv, fetchurl, makeWrapper, jdk, selenium-server-standalone }:
+{ lib, stdenv, fetchurl, makeWrapper, jdk, selenium-server-standalone }:
 
-with stdenv.lib;
+with lib;
 let
     name = "selendroid-standalone-${version}";
     pluginName = "selendroid-grid-plugin-${version}";

pkgs/development/tools/selenium/server/default.nix

···
-{ stdenv, fetchurl, makeWrapper, jre
+{ lib, stdenv, fetchurl, makeWrapper, jre
 , htmlunit-driver, chromedriver, chromeSupport ? true }:
 
-with stdenv.lib;
+with lib;
 
 let
   minorVersion = "3.141";

pkgs/development/tools/simavr/default.nix

···
 
   nativeBuildInputs = [ which pkg-config avrgcc ];
   buildInputs = [ libelf freeglut libGLU libGL ]
-    ++ stdenv.lib.optional stdenv.isDarwin GLUT;
+    ++ lib.optional stdenv.isDarwin GLUT;
 
   # Hack to avoid TMPDIR in RPATHs.
   preFixup = ''rm -rf "$(pwd)" && mkdir "$(pwd)" '';

pkgs/development/tools/slimerjs/default.nix

···
-{stdenv, fetchFromGitHub, zip, unzip, firefox, bash}:
+{lib, stdenv, fetchFromGitHub, zip, unzip, firefox, bash}:
 let
   s = # Generated upstream information
   rec {
···
   meta = {
     inherit (s) version;
     description = ''Gecko-based programmatically-driven browser'';
-    license = stdenv.lib.licenses.mpl20 ;
-    maintainers = [stdenv.lib.maintainers.raskin];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.mpl20 ;
+    maintainers = [lib.maintainers.raskin];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/development/tools/so/default.nix

···
   cargoSha256 = "1ddbhy1plag4ckbmlyj47wnky7vgmfa68msl3hl25h1lwmzaf1aq";
 
   nativeBuildInputs = [ pkg-config ];
-  buildInputs = [ openssl ] ++ stdenv.lib.optionals stdenv.isDarwin [
+  buildInputs = [ openssl ] ++ lib.optionals stdenv.isDarwin [
     libiconv Security
   ];
 

pkgs/development/tools/sourcetrail/default.nix

···
     desktop-file-utils
     imagemagick
     javaIndexer # the resulting jar file is copied by our install script
-  ] ++ stdenv.lib.optionals doCheck testBinPath;
+  ] ++ lib.optionals doCheck testBinPath;
   buildInputs = [
     boost pythonIndexer shared-mime-info
   ] ++ (with qt5; [ qtbase qtsvg ])
···
   ];
 
   postPatch = let
-    major = stdenv.lib.versions.major version;
-    minor = stdenv.lib.versions.minor version;
-    patch = stdenv.lib.versions.patch version;
+    major = lib.versions.major version;
+    minor = lib.versions.minor version;
+    patch = lib.versions.patch version;
   in ''
     # Upstream script obtains it's version from git:
     # https://github.com/CoatiSoftware/Sourcetrail/blob/master/cmake/version.cmake
···
 
     mkdir -p $out/bin
     makeQtWrapper $out/opt/sourcetrail/bin/sourcetrail $out/bin/sourcetrail \
-      --prefix PATH : ${stdenv.lib.makeBinPath binPath}
+      --prefix PATH : ${lib.makeBinPath binPath}
   '';
 
   checkPhase = ''
···
     # shorten PATH to prevent build failures
     wrapQtApp ./Sourcetrail_test \
       --set PATH "" \
-      --prefix PATH : ${stdenv.lib.makeBinPath testBinPath} \
+      --prefix PATH : ${lib.makeBinPath testBinPath} \
       --set MAVEN_OPTS "-Dmaven.repo.local=$TMPDIR/m2repo"
     ./Sourcetrail_test
     popd

pkgs/development/tools/sqsh/default.nix

···
 
     substituteInPlace src/cmd_connect.c \
       --replace CS_TDS_80 CS_TDS_73
-  '' + stdenv.lib.optionalString stdenv.isDarwin ''
+  '' + lib.optionalString stdenv.isDarwin ''
     substituteInPlace configure --replace "libct.so" "libct.dylib"
   '';
 

pkgs/development/tools/summon/default.nix

···
 { stdenv, buildGoModule, fetchFromGitHub, lib, patchResolver ? true }:
 
-with stdenv.lib;
+with lib;
 
 buildGoModule rec {
   pname = "summon";

pkgs/development/tools/sumneko-lua-language-server/default.nix

···
-{ stdenv, fetchFromGitHub, ninja, makeWrapper }:
+{ lib, stdenv, fetchFromGitHub, ninja, makeWrapper }:
 
 stdenv.mkDerivation rec {
   pname = "sumneko-lua-language-server";
···
       --metapath='~/.cache/sumneko_lua/meta'"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Lua Language Server coded by Lua ";
     homepage = "https://github.com/sumneko/lua-language-server";
     license = licenses.mit;

pkgs/development/tools/the-way/default.nix

···
 
   nativeBuildInputs = [ installShellFiles ];
 
-  buildInputs = stdenv.lib.optionals stdenv.isDarwin  [ AppKit Security ];
+  buildInputs = lib.optionals stdenv.isDarwin  [ AppKit Security ];
 
   cargoSha256 = "1aiyfsvmrqcmlw0z1944i9s5g3yxc39na5mf16pb9a4bhw8zcwjr";
-  checkFlagsArray = stdenv.lib.optionals stdenv.isDarwin [ "--skip=copy" ];
+  checkFlagsArray = lib.optionals stdenv.isDarwin [ "--skip=copy" ];
   cargoParallelTestThreads = false;
 
   postInstall = ''

pkgs/development/tools/trellis/default.nix

···
   version = "2021.01.02";
 
   # git describe --tags
-  realVersion = with stdenv.lib; with builtins;
+  realVersion = with lib; with builtins;
     "1.0-482-g${substring 0 7 (elemAt srcs 0).rev}";
 
   srcs = [
···
       open Verilog to bitstream toolchain for these devices.
     '';
     homepage    = "https://github.com/SymbiFlow/prjtrellis";
-    license     = stdenv.lib.licenses.isc;
+    license     = lib.licenses.isc;
     maintainers = with maintainers; [ q3k thoughtpolice emily ];
-    platforms   = stdenv.lib.platforms.all;
+    platforms   = lib.platforms.all;
   };
 }

pkgs/development/tools/tychus/default.nix

···
-{ stdenv, fetchFromGitHub, buildGoPackage, CoreFoundation }:
+{ lib, stdenv, fetchFromGitHub, buildGoPackage, CoreFoundation }:
 
 buildGoPackage rec {
   pname = "tychus";
···
     sha256 = "02ybxjsfga89gpg0k21zmykhhnpx1vy3ny8fcwj0qsg73i11alvw";
   };
 
-  buildInputs = stdenv.lib.optionals stdenv.hostPlatform.isDarwin [ CoreFoundation ];
+  buildInputs = lib.optionals stdenv.hostPlatform.isDarwin [ CoreFoundation ];
 
   buildFlags = [ "--tags" "release" ];
 
   meta = {
     description = "Command line utility to live-reload your application";
     homepage = "https://github.com/devlocker/tychus";
-    license = stdenv.lib.licenses.mit;
+    license = lib.licenses.mit;
   };
 }

pkgs/development/tools/uftrace/default.nix

···
-{stdenv, fetchFromGitHub}:
+{lib, stdenv, fetchFromGitHub}:
 
 stdenv.mkDerivation rec {
   pname = "uftrace";
···
   meta = {
     description = "Function (graph) tracer for user-space";
     homepage = "https://github.com/namhyung/uftrace";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = [stdenv.lib.maintainers.nthorne];
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.linux;
+    maintainers = [lib.maintainers.nthorne];
   };
 }

pkgs/development/tools/vcstool/default.nix

···
 
   propagatedBuildInputs = [ pyyaml setuptools ];
 
-  makeWrapperArgs = ["--prefix" "PATH" ":" (stdenv.lib.makeBinPath [ git breezy subversion ])];
+  makeWrapperArgs = ["--prefix" "PATH" ":" (lib.makeBinPath [ git breezy subversion ])];
 
   doCheck = false; # requires network
 

pkgs/development/tools/vultr/default.nix

···
-{ stdenv, buildGoPackage, fetchFromGitHub }:
+{ lib, stdenv, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
   pname = "vultr";
···
   meta = {
     description = "A command line tool for Vultr services, a provider for cloud virtual private servers";
     homepage = "https://github.com/JamesClonk/vultr";
-    license = stdenv.lib.licenses.mit;
-    maintainers = [ stdenv.lib.maintainers.zauberpony ];
+    license = lib.licenses.mit;
+    maintainers = [ lib.maintainers.zauberpony ];
   };
 }

pkgs/development/tools/wasm-pack/default.nix

···
     # gracefully exit while doing work.
     # See: https://github.com/rustwasm/wasm-pack/issues/650
     libressl
-  ] ++ stdenv.lib.optionals stdenv.isDarwin [ curl Security ];
+  ] ++ lib.optionals stdenv.isDarwin [ curl Security ];
 
   # Most tests rely on external resources and build artifacts.
   # Disabling check here to work with build sandboxing.

pkgs/development/tools/wiggle/default.nix

···
-{ stdenv, fetchurl, ncurses, groff }:
+{ lib, stdenv, fetchurl, ncurses, groff }:
 
 stdenv.mkDerivation {
 
···
        already been applied, and will ignore them.
     '';
 
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.all;
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.all;
   };
 
 }

pkgs/development/tools/wrangler/default.nix

···
 
   cargoSha256 = "0w845virvw7mvibc76ar2hbffhfzj2v8v1xkrsssrgzyaryb48jk";
 
-  nativeBuildInputs = [ perl ] ++ stdenv.lib.optionals stdenv.isLinux [ pkg-config ];
+  nativeBuildInputs = [ perl ] ++ lib.optionals stdenv.isLinux [ pkg-config ];
 
-  buildInputs = stdenv.lib.optionals stdenv.isLinux [ openssl ]
-    ++ stdenv.lib.optionals stdenv.isDarwin [
+  buildInputs = lib.optionals stdenv.isLinux [ openssl ]
+    ++ lib.optionals stdenv.isDarwin [
       curl
       darwin.apple_sdk.frameworks.Security
       darwin.apple_sdk.frameworks.CoreServices

pkgs/development/tools/xcbuild/default.nix

···
     cp -r --no-preserve=all ${linenoise} ThirdParty/linenoise
   '';
 
-  postPatch = stdenv.lib.optionalString (!stdenv.isDarwin) ''
+  postPatch = lib.optionalString (!stdenv.isDarwin) ''
     # Avoid a glibc >= 2.25 deprecation warning that gets fatal via -Werror.
     sed 1i'#include <sys/sysmacros.h>' \
       -i Libraries/xcassets/Headers/xcassets/Slot/SystemVersion.h
-  '' + stdenv.lib.optionalString stdenv.isDarwin ''
+  '' + lib.optionalString stdenv.isDarwin ''
     # Apple Open Sourced LZFSE, but not libcompression, and it isn't
     # part of an impure framework we can add
     substituteInPlace Libraries/libcar/Sources/Rendition.cpp \
···
 
   nativeBuildInputs = [ cmake ninja ];
   buildInputs = [ zlib libxml2 libpng ]
-    ++ stdenv.lib.optionals stdenv.isDarwin [ CoreServices CoreGraphics ImageIO ];
+    ++ lib.optionals stdenv.isDarwin [ CoreServices CoreGraphics ImageIO ];
 
   meta = with lib; {
     description = "Xcode-compatible build tool";