Merge staging-next into staging

doc/contributing/contributing-to-documentation.chapter.md

···
 ```ShellSession
 $ cd /path/to/nixpkgs/doc
 $ nix-shell
-[nix-shell]$ make $makeFlags
+[nix-shell]$ make
 ```
 
 If you experience problems, run `make debug` to help understand the docbook errors.

doc/default.nix

···
 
   src = lib.cleanSource ./.;
 
-  makeFlags = [
-    "PANDOC_LUA_FILTERS_DIR=${pkgs.pandoc-lua-filters}/share/pandoc/filters"
-  ];
-
   postPatch = ''
     ln -s ${doc-support} ./doc-support/result
   '';
···
     echo "doc manual $dest manual.html" >> $out/nix-support/hydra-build-products
     echo "doc manual $dest nixpkgs-manual.epub" >> $out/nix-support/hydra-build-products
   '';
+
+  # Environment variables
+  PANDOC_LUA_FILTERS_DIR = "${pkgs.pandoc-lua-filters}/share/pandoc/filters";
 }

pkgs/applications/audio/bjumblr/default.nix

···
 { lib, stdenv, fetchFromGitHub, libX11, cairo, lv2, pkg-config, libsndfile }:
 
 stdenv.mkDerivation rec {
-  pname = "BJumblr";
+  pname = "bjumblr";
   version = "1.6.6";
 
   src = fetchFromGitHub {
     owner = "sjaehn";
-    repo = pname;
+    repo = "BJumblr";
     rev = version;
     sha256 = "1nbxi54023vck3qgmr385cjzinmdnvz62ywb6bcksmc3shl080mg";
   };

pkgs/applications/audio/bsequencer/default.nix

···
 { lib, stdenv, fetchFromGitHub, xorg, cairo, lv2, pkg-config }:
 
 stdenv.mkDerivation rec {
-  pname = "BSEQuencer";
+  pname = "bsequencer";
   version = "1.8.8";
 
   src = fetchFromGitHub {
     owner = "sjaehn";
-    repo = pname;
+    repo = "BSEQuencer";
     rev = version;
     sha256 = "sha256-OArIMf0XP9CKDdb3H4s8jMzVRjoLFQDPmTS9rS2KW3w=";
   };

pkgs/applications/audio/bshapr/default.nix

···
 { lib, stdenv, fetchFromGitHub, xorg, cairo, lv2, pkg-config }:
 
 stdenv.mkDerivation rec {
-  pname = "BShapr";
+  pname = "bshapr";
   version = "0.12";
 
   src = fetchFromGitHub {
     owner = "sjaehn";
-    repo = pname;
+    repo = "BShapr";
     rev = "v${version}";
     sha256 = "sha256-2DySlD5ZTxeQ2U++Dr67bek5oVbAiOHCxM6S5rTTZN0=";
   };

pkgs/applications/audio/bslizr/default.nix

···
 { lib, stdenv, fetchFromGitHub, xorg, cairo, lv2, pkg-config }:
 
 stdenv.mkDerivation rec {
-  pname = "BSlizr";
+  pname = "bslizr";
   version = "1.2.14";
 
   src = fetchFromGitHub {
     owner = "sjaehn";
-    repo = pname;
+    repo = "BSlizr";
     rev = version;
     sha256 = "sha256-dut3I68tJWQH+X6acKROqb5HywufeBQ4/HkXFKsA3hY=";
   };

pkgs/applications/networking/instant-messengers/ferdi/default.nix

···
-{ lib, mkFranzDerivation, fetchurl }:
+{ lib, mkFranzDerivation, fetchurl, xorg, xdg-utils, buildEnv, writeShellScriptBin }:
 
-mkFranzDerivation rec {
+let
+  mkFranzDerivation' = mkFranzDerivation.override {
+    xdg-utils = buildEnv {
+      name = "xdg-utils-for-ferdi";
+      paths = [
+        xdg-utils
+        (lib.hiPrio (writeShellScriptBin "xdg-open" ''
+          unset GDK_BACKEND
+          exec ${xdg-utils}/bin/xdg-open "$@"
+        ''))
+      ];
+    };
+  };
+in
+mkFranzDerivation' rec {
   pname = "ferdi";
   name = "Ferdi";
-  version = "5.6.0-beta.5";
+  version = "5.6.0-beta.6";
   src = fetchurl {
     url = "https://github.com/getferdi/ferdi/releases/download/v${version}/ferdi_${version}_amd64.deb";
-    sha256 = "sha256-fDUzYir53OQ3O4o9eG70sGD+FJ0/4SDNsTfh97WFRnQ=";
+    sha256 = "sha256-Q1HSAEVcaxFyOq7oWqa6AJJpsBKRxbsKb9ydyK/gH/A=";
   };
+  extraBuildInputs = [ xorg.libxshmfence ];
   meta = with lib; {
     description = "Combine your favorite messaging services into one application";
     homepage = "https://getferdi.com/";
     license = licenses.asl20;
-    maintainers = [ maintainers.davidtwco ];
+    maintainers = with maintainers; [ davidtwco ma27 ];
     platforms = [ "x86_64-linux" ];
     hydraPlatforms = [ ];
   };

pkgs/applications/networking/instant-messengers/franz/generic.nix

···
 
 # Helper function for building a derivation for Franz and forks.
 
-{ pname, name, version, src, meta }:
+{ pname, name, version, src, meta, extraBuildInputs ? [] }:
+
 stdenv.mkDerivation rec {
   inherit pname version src meta;
 
···
   dontPatchELF = true;
 
   nativeBuildInputs = [ autoPatchelfHook makeWrapper wrapGAppsHook dpkg ];
-  buildInputs = (with xorg; [
+  buildInputs = extraBuildInputs ++ (with xorg; [
     libXi
     libXcursor
     libXdamage

pkgs/applications/networking/instant-messengers/rambox/default.nix

···
     description = "Free and Open Source messaging and emailing app that combines common web applications into one";
     homepage = "https://rambox.pro";
     license = licenses.mit;
-    maintainers = with maintainers; [ ma27 ];
+    maintainers = with maintainers; [ ];
     platforms = ["i686-linux" "x86_64-linux"];
     hydraPlatforms = [];
+    knownVulnerabilities = [
+      "Electron 7.2.4 is EOL and contains at least the following vulnerabilities: CVE-2020-6458, CVE-2020-6460 and more (https://www.electronjs.org/releases/stable?version=7). Consider using an alternative such as `ferdi'."
+    ];
   };
 }

pkgs/applications/networking/instant-messengers/signal-desktop/default.nix

···
       else "");
 in stdenv.mkDerivation rec {
   pname = "signal-desktop";
-  version = "5.3.0"; # Please backport all updates to the stable channel.
+  version = "5.4.0"; # Please backport all updates to the stable channel.
   # All releases have a limited lifetime and "expire" 90 days after the release.
   # When releases "expire" the application becomes unusable until an update is
   # applied. The expiration date for the current release can be extracted with:
···
 
   src = fetchurl {
     url = "https://updates.signal.org/desktop/apt/pool/main/s/signal-desktop/signal-desktop_${version}_amd64.deb";
-    sha256 = "15lclxw3njih90zlh2n90v8ljg0wnglw5w8jrpa7rbd789yagvq7";
+    sha256 = "046xy033ars70ay5ryj39i5053py00xj92ajdg212pamq415z1zb";
   };
 
   nativeBuildInputs = [

pkgs/applications/networking/sniffers/wireshark/default.nix

···
 with lib;
 
 let
-  version = "3.4.5";
+  version = "3.4.6";
   variant = if withQt then "qt" else "cli";
 
 in stdenv.mkDerivation {
···
 
   src = fetchurl {
     url = "https://www.wireshark.org/download/src/all-versions/wireshark-${version}.tar.xz";
-    sha256 = "sha256-3hqv0QCh4SB8hQ0YDpfdkauNoPXra+7FRfclzbFF0zM=";
+    sha256 = "0a26kcj3n1a2kw1f3fc6s1x3rw3f3bj2cq6rp7k0kc4ciwh7i9hj";
   };
 
   cmakeFlags = [
···
 
   meta = with lib; {
     homepage = "https://www.wireshark.org/";
+    changelog = "https://www.wireshark.org/docs/relnotes/wireshark-${version}.html";
     description = "Powerful network protocol analyzer";
     license = licenses.gpl2Plus;
 

pkgs/applications/science/logic/acgtk/default.nix

···
   };
 
   buildInputs = [ dune_2 ] ++ (with ocamlPackages; [
-    ocaml findlib ansiterminal cairo2 cmdliner fmt logs menhir mtime yojson
+    ocaml findlib ansiterminal cairo2 cmdliner fmt logs menhir menhirLib mtime yojson
   ]);
 
   buildPhase = "dune build --profile=release";

pkgs/applications/science/logic/why3/default.nix

···
   };
 
   buildInputs = with ocamlPackages; [
-    ocaml findlib ocamlgraph zarith menhir
+    ocaml findlib ocamlgraph zarith menhir menhirLib
     # Compressed Sessions
     # Emacs compilation of why3.el
     emacs

pkgs/development/compilers/compcert/default.nix

···
 }:
 
 let
-  ocaml-pkgs      = with ocamlPackages; [ ocaml findlib menhir ];
+  ocaml-pkgs      = with ocamlPackages; [ ocaml findlib menhir menhirLib ];
   ccomp-platform = if stdenv.isDarwin then "x86_64-macosx" else "x86_64-linux";
   inherit (coqPackages) coq flocq;
   inherit (lib) optional optionalString;

pkgs/development/compilers/fstar/default.nix

···
   nativeBuildInputs = [ makeWrapper installShellFiles ];
 
   buildInputs = with ocamlPackages; [
-    z3 ocaml findlib batteries menhir stdint
+    z3 ocaml findlib batteries menhir menhirLib stdint
     zarith camlp4 yojson pprint
     ulex ocaml-migrate-parsetree process ppx_deriving ppx_deriving_yojson ocamlbuild
   ];

pkgs/development/compilers/go/1.14.nix

···
-{ lib, stdenv, fetchurl, tzdata, iana-etc, runCommand
-, perl, which, pkg-config, patch, procps, pcre, cacert, Security, Foundation
-, mailcap, runtimeShell
+{ lib
+, stdenv
+, fetchurl
+, tzdata
+, iana-etc
+, runCommand
+, perl
+, which
+, pkg-config
+, patch
+, procps
+, pcre
+, cacert
+, Security
+, Foundation
+, mailcap
+, runtimeShell
 , buildPackages
 , pkgsBuildTarget
 , fetchpatch
···
 }:
 
 let
-
-  inherit (lib) optionals optionalString;
-
-  version = "1.14.15";
-
   go_bootstrap = buildPackages.callPackage ./bootstrap.nix { };
 
-  goBootstrap = runCommand "go-bootstrap" {} ''
+  goBootstrap = runCommand "go-bootstrap" { } ''
     mkdir $out
     cp -rf ${go_bootstrap}/* $out/
     chmod -R u+w $out
···
 
 stdenv.mkDerivation rec {
   pname = "go";
-  inherit version;
+  version = "1.14.15";
 
   src = fetchurl {
     url = "https://dl.google.com/go/go${version}.src.tar.gz";
···
   # perl is used for testing go vet
   nativeBuildInputs = [ perl which pkg-config patch procps ];
   buildInputs = [ cacert pcre ]
-    ++ optionals stdenv.isLinux [ stdenv.cc.libc.out ]
-    ++ optionals (stdenv.hostPlatform.libc == "glibc") [ stdenv.cc.libc.static ];
+    ++ lib.optionals stdenv.isLinux [ stdenv.cc.libc.out ]
+    ++ lib.optionals (stdenv.hostPlatform.libc == "glibc") [ stdenv.cc.libc.static ];
 
-  depsTargetTargetPropagated = optionals stdenv.isDarwin [ Security Foundation ];
+  depsTargetTargetPropagated = lib.optionals stdenv.isDarwin [ Security Foundation ];
 
   hardeningDisable = [ "all" ];
 
···
     # Disable cgo lookup tests not works, they depend on resolver
     rm src/net/cgo_unix_test.go
 
-  '' + optionalString stdenv.isLinux ''
+  '' + lib.optionalString stdenv.isLinux ''
     # prepend the nix path to the zoneinfo files but also leave the original value for static binaries
     # that run outside a nix server
     sed -i 's,\"/usr/share/zoneinfo/,"${tzdata}/share/zoneinfo/\"\,\n\t&,' src/time/zoneinfo_unix.go
 
-  '' + optionalString stdenv.isAarch32 ''
+  '' + lib.optionalString stdenv.isAarch32 ''
     echo '#!${runtimeShell}' > misc/cgo/testplugin/test.bash
-  '' + optionalString stdenv.isDarwin ''
+  '' + lib.optionalString stdenv.isDarwin ''
     substituteInPlace src/race.bash --replace \
       "sysctl machdep.cpu.extfeatures | grep -qv EM64T" true
     sed -i 's,strings.Contains(.*sysctl.*,true {,' src/cmd/dist/util.go
···
 
   # {CC,CXX}_FOR_TARGET must be only set for cross compilation case as go expect those
   # to be different from CC/CXX
-  CC_FOR_TARGET = if (stdenv.buildPlatform != stdenv.targetPlatform) then
+  CC_FOR_TARGET =
+    if (stdenv.buildPlatform != stdenv.targetPlatform) then
       "${targetCC}/bin/${targetCC.targetPrefix}cc"
     else
       null;
-  CXX_FOR_TARGET = if (stdenv.buildPlatform != stdenv.targetPlatform) then
+  CXX_FOR_TARGET =
+    if (stdenv.buildPlatform != stdenv.targetPlatform) then
       "${targetCC}/bin/${targetCC.targetPrefix}c++"
     else
       null;
 
-  GOARM = toString (lib.intersectLists [(stdenv.hostPlatform.parsed.cpu.version or "")] ["5" "6" "7"]);
+  GOARM = toString (lib.intersectLists [ (stdenv.hostPlatform.parsed.cpu.version or "") ] [ "5" "6" "7" ]);
   GO386 = 387; # from Arch: don't assume sse2 on i686
   CGO_ENABLED = 1;
   # Hopefully avoids test timeouts on Hydra
···
   # Some tests assume things like home directories and users exists
   GO_BUILDER_NAME = "nix";
 
-  GOROOT_BOOTSTRAP="${goBootstrap}/share/go";
+  GOROOT_BOOTSTRAP = "${goBootstrap}/share/go";
 
   postConfigure = ''
     export GOCACHE=$TMPDIR/go-cache
···
 
     export PATH=$(pwd)/bin:$PATH
 
-    ${optionalString (stdenv.buildPlatform != stdenv.targetPlatform) ''
+    ${lib.optionalString (stdenv.buildPlatform != stdenv.targetPlatform) ''
     # Independent from host/target, CC should produce code for the building system.
     # We only set it when cross-compiling.
     export CC=${buildPackages.stdenv.cc}/bin/cc
···
   '' + (if (stdenv.buildPlatform != stdenv.hostPlatform) then ''
     mv bin/*_*/* bin
     rmdir bin/*_*
-    ${optionalString (!(GOHOSTARCH == GOARCH && GOOS == GOHOSTOS)) ''
+    ${lib.optionalString (!(GOHOSTARCH == GOARCH && GOOS == GOHOSTOS)) ''
       rm -rf pkg/${GOHOSTOS}_${GOHOSTARCH} pkg/tool/${GOHOSTOS}_${GOHOSTARCH}
     ''}
   '' else if (stdenv.hostPlatform != stdenv.targetPlatform) then ''
     rm -rf bin/*_*
-    ${optionalString (!(GOHOSTARCH == GOARCH && GOOS == GOHOSTOS)) ''
+    ${lib.optionalString (!(GOHOSTARCH == GOARCH && GOOS == GOHOSTOS)) ''
       rm -rf pkg/${GOOS}_${GOARCH} pkg/tool/${GOOS}_${GOARCH}
     ''}
   '' else "");

pkgs/development/compilers/go/1.15.nix

···
-{ lib, stdenv, fetchurl, tzdata, iana-etc, runCommand
-, perl, which, pkg-config, patch, procps, pcre, cacert, Security, Foundation
-, mailcap, runtimeShell
+{ lib
+, stdenv
+, fetchurl
+, tzdata
+, iana-etc
+, runCommand
+, perl
+, which
+, pkg-config
+, patch
+, procps
+, pcre
+, cacert
+, Security
+, Foundation
+, mailcap
+, runtimeShell
 , buildPackages
 , pkgsBuildTarget
 , fetchpatch
···
 }:
 
 let
-
-  inherit (lib) optionals optionalString;
-
-  version = "1.15.13";
-
   go_bootstrap = buildPackages.callPackage ./bootstrap.nix { };
 
-  goBootstrap = runCommand "go-bootstrap" {} ''
+  goBootstrap = runCommand "go-bootstrap" { } ''
     mkdir $out
     cp -rf ${go_bootstrap}/* $out/
     chmod -R u+w $out
···
 
 stdenv.mkDerivation rec {
   pname = "go";
-  inherit version;
+  version = "1.15.13";
 
   src = fetchurl {
     url = "https://dl.google.com/go/go${version}.src.tar.gz";
···
   # perl is used for testing go vet
   nativeBuildInputs = [ perl which pkg-config patch procps ];
   buildInputs = [ cacert pcre ]
-    ++ optionals stdenv.isLinux [ stdenv.cc.libc.out ]
-    ++ optionals (stdenv.hostPlatform.libc == "glibc") [ stdenv.cc.libc.static ];
+    ++ lib.optionals stdenv.isLinux [ stdenv.cc.libc.out ]
+    ++ lib.optionals (stdenv.hostPlatform.libc == "glibc") [ stdenv.cc.libc.static ];
 
-  depsTargetTargetPropagated = optionals stdenv.isDarwin [ Security Foundation ];
+  depsTargetTargetPropagated = lib.optionals stdenv.isDarwin [ Security Foundation ];
 
   hardeningDisable = [ "all" ];
 
···
     # Disable cgo lookup tests not works, they depend on resolver
     rm src/net/cgo_unix_test.go
 
-  '' + optionalString stdenv.isLinux ''
+  '' + lib.optionalString stdenv.isLinux ''
     # prepend the nix path to the zoneinfo files but also leave the original value for static binaries
     # that run outside a nix server
     sed -i 's,\"/usr/share/zoneinfo/,"${tzdata}/share/zoneinfo/\"\,\n\t&,' src/time/zoneinfo_unix.go
 
-  '' + optionalString stdenv.isAarch32 ''
+  '' + lib.optionalString stdenv.isAarch32 ''
     echo '#!${runtimeShell}' > misc/cgo/testplugin/test.bash
-  '' + optionalString stdenv.isDarwin ''
+  '' + lib.optionalString stdenv.isDarwin ''
     substituteInPlace src/race.bash --replace \
       "sysctl machdep.cpu.extfeatures | grep -qv EM64T" true
     sed -i 's,strings.Contains(.*sysctl.*,true {,' src/cmd/dist/util.go
···
 
   # {CC,CXX}_FOR_TARGET must be only set for cross compilation case as go expect those
   # to be different from CC/CXX
-  CC_FOR_TARGET = if (stdenv.buildPlatform != stdenv.targetPlatform) then
+  CC_FOR_TARGET =
+    if (stdenv.buildPlatform != stdenv.targetPlatform) then
       "${targetCC}/bin/${targetCC.targetPrefix}cc"
     else
       null;
-  CXX_FOR_TARGET = if (stdenv.buildPlatform != stdenv.targetPlatform) then
+  CXX_FOR_TARGET =
+    if (stdenv.buildPlatform != stdenv.targetPlatform) then
       "${targetCC}/bin/${targetCC.targetPrefix}c++"
     else
       null;
 
-  GOARM = toString (lib.intersectLists [(stdenv.hostPlatform.parsed.cpu.version or "")] ["5" "6" "7"]);
+  GOARM = toString (lib.intersectLists [ (stdenv.hostPlatform.parsed.cpu.version or "") ] [ "5" "6" "7" ]);
   GO386 = 387; # from Arch: don't assume sse2 on i686
   CGO_ENABLED = 1;
   # Hopefully avoids test timeouts on Hydra
···
   # Some tests assume things like home directories and users exists
   GO_BUILDER_NAME = "nix";
 
-  GOROOT_BOOTSTRAP="${goBootstrap}/share/go";
+  GOROOT_BOOTSTRAP = "${goBootstrap}/share/go";
 
   postConfigure = ''
     export GOCACHE=$TMPDIR/go-cache
···
 
     export PATH=$(pwd)/bin:$PATH
 
-    ${optionalString (stdenv.buildPlatform != stdenv.targetPlatform) ''
+    ${lib.optionalString (stdenv.buildPlatform != stdenv.targetPlatform) ''
     # Independent from host/target, CC should produce code for the building system.
     # We only set it when cross-compiling.
     export CC=${buildPackages.stdenv.cc}/bin/cc
···
   '' + (if (stdenv.buildPlatform != stdenv.hostPlatform) then ''
     mv bin/*_*/* bin
     rmdir bin/*_*
-    ${optionalString (!(GOHOSTARCH == GOARCH && GOOS == GOHOSTOS)) ''
+    ${lib.optionalString (!(GOHOSTARCH == GOARCH && GOOS == GOHOSTOS)) ''
       rm -rf pkg/${GOHOSTOS}_${GOHOSTARCH} pkg/tool/${GOHOSTOS}_${GOHOSTARCH}
     ''}
   '' else if (stdenv.hostPlatform != stdenv.targetPlatform) then ''
     rm -rf bin/*_*
-    ${optionalString (!(GOHOSTARCH == GOARCH && GOOS == GOHOSTOS)) ''
+    ${lib.optionalString (!(GOHOSTARCH == GOARCH && GOOS == GOHOSTOS)) ''
       rm -rf pkg/${GOOS}_${GOARCH} pkg/tool/${GOOS}_${GOARCH}
     ''}
   '' else "");

pkgs/development/compilers/go/1.16.nix

···
-{ lib, stdenv, fetchurl, tzdata, iana-etc, runCommand
-, perl, which, pkg-config, patch, procps, pcre, cacert, Security, Foundation, xcbuild
-, mailcap, runtimeShell
+{ lib
+, stdenv
+, fetchurl
+, tzdata
+, iana-etc
+, runCommand
+, perl
+, which
+, pkg-config
+, patch
+, procps
+, pcre
+, cacert
+, Security
+, Foundation
+, xcbuild
+, mailcap
+, runtimeShell
 , buildPackages
 , pkgsBuildTarget
-, fetchpatch
 , callPackage
 }:
 
 let
-
-  inherit (lib) optionals optionalString;
-
-  version = "1.16.5";
-
   go_bootstrap = buildPackages.callPackage ./bootstrap.nix { };
 
-  goBootstrap = runCommand "go-bootstrap" {} ''
+  goBootstrap = runCommand "go-bootstrap" { } ''
     mkdir $out
     cp -rf ${go_bootstrap}/* $out/
     chmod -R u+w $out
···
 
 stdenv.mkDerivation rec {
   pname = "go";
-  inherit version;
+  version = "1.16.5";
 
   src = fetchurl {
     url = "https://dl.google.com/go/go${version}.src.tar.gz";
···
   # perl is used for testing go vet
   nativeBuildInputs = [ perl which pkg-config patch procps ];
   buildInputs = [ cacert pcre ]
-    ++ optionals stdenv.isLinux [ stdenv.cc.libc.out ]
-    ++ optionals (stdenv.hostPlatform.libc == "glibc") [ stdenv.cc.libc.static ];
+    ++ lib.optionals stdenv.isLinux [ stdenv.cc.libc.out ]
+    ++ lib.optionals (stdenv.hostPlatform.libc == "glibc") [ stdenv.cc.libc.static ];
 
-  propagatedBuildInputs = optionals stdenv.isDarwin [ xcbuild ];
+  propagatedBuildInputs = lib.optionals stdenv.isDarwin [ xcbuild ];
 
-  depsTargetTargetPropagated = optionals stdenv.isDarwin [ Security Foundation ];
+  depsTargetTargetPropagated = lib.optionals stdenv.isDarwin [ Security Foundation ];
 
   hardeningDisable = [ "all" ];
 
···
     # Disable cgo lookup tests not works, they depend on resolver
     rm src/net/cgo_unix_test.go
 
-  '' + optionalString stdenv.isLinux ''
+  '' + lib.optionalString stdenv.isLinux ''
     # prepend the nix path to the zoneinfo files but also leave the original value for static binaries
     # that run outside a nix server
     sed -i 's,\"/usr/share/zoneinfo/,"${tzdata}/share/zoneinfo/\"\,\n\t&,' src/time/zoneinfo_unix.go
 
-  '' + optionalString stdenv.isAarch32 ''
+  '' + lib.optionalString stdenv.isAarch32 ''
     echo '#!${runtimeShell}' > misc/cgo/testplugin/test.bash
-  '' + optionalString stdenv.isDarwin ''
+  '' + lib.optionalString stdenv.isDarwin ''
     substituteInPlace src/race.bash --replace \
       "sysctl machdep.cpu.extfeatures | grep -qv EM64T" true
     sed -i 's,strings.Contains(.*sysctl.*,true {,' src/cmd/dist/util.go
···
 
   # {CC,CXX}_FOR_TARGET must be only set for cross compilation case as go expect those
   # to be different from CC/CXX
-  CC_FOR_TARGET = if (stdenv.buildPlatform != stdenv.targetPlatform) then
+  CC_FOR_TARGET =
+    if (stdenv.buildPlatform != stdenv.targetPlatform) then
       "${targetCC}/bin/${targetCC.targetPrefix}cc"
     else
       null;
-  CXX_FOR_TARGET = if (stdenv.buildPlatform != stdenv.targetPlatform) then
+  CXX_FOR_TARGET =
+    if (stdenv.buildPlatform != stdenv.targetPlatform) then
       "${targetCC}/bin/${targetCC.targetPrefix}c++"
     else
       null;
 
-  GOARM = toString (lib.intersectLists [(stdenv.hostPlatform.parsed.cpu.version or "")] ["5" "6" "7"]);
+  GOARM = toString (lib.intersectLists [ (stdenv.hostPlatform.parsed.cpu.version or "") ] [ "5" "6" "7" ]);
   GO386 = "softfloat"; # from Arch: don't assume sse2 on i686
   CGO_ENABLED = 1;
   # Hopefully avoids test timeouts on Hydra
···
   # Some tests assume things like home directories and users exists
   GO_BUILDER_NAME = "nix";
 
-  GOROOT_BOOTSTRAP="${goBootstrap}/share/go";
+  GOROOT_BOOTSTRAP = "${goBootstrap}/share/go";
 
   postConfigure = ''
     export GOCACHE=$TMPDIR/go-cache
···
 
     export PATH=$(pwd)/bin:$PATH
 
-    ${optionalString (stdenv.buildPlatform != stdenv.targetPlatform) ''
+    ${lib.optionalString (stdenv.buildPlatform != stdenv.targetPlatform) ''
     # Independent from host/target, CC should produce code for the building system.
     # We only set it when cross-compiling.
     export CC=${buildPackages.stdenv.cc}/bin/cc
···
   '' + (if (stdenv.buildPlatform != stdenv.hostPlatform) then ''
     mv bin/*_*/* bin
     rmdir bin/*_*
-    ${optionalString (!(GOHOSTARCH == GOARCH && GOOS == GOHOSTOS)) ''
+    ${lib.optionalString (!(GOHOSTARCH == GOARCH && GOOS == GOHOSTOS)) ''
       rm -rf pkg/${GOHOSTOS}_${GOHOSTARCH} pkg/tool/${GOHOSTOS}_${GOHOSTARCH}
     ''}
   '' else if (stdenv.hostPlatform != stdenv.targetPlatform) then ''
     rm -rf bin/*_*
-    ${optionalString (!(GOHOSTARCH == GOARCH && GOOS == GOHOSTOS)) ''
+    ${lib.optionalString (!(GOHOSTARCH == GOARCH && GOOS == GOHOSTOS)) ''
       rm -rf pkg/${GOOS}_${GOARCH} pkg/tool/${GOOS}_${GOARCH}
     ''}
   '' else "");

pkgs/development/compilers/go/2-dev.nix

···
-{ pkgs, lib, stdenv, fetchurl, fetchgit, tzdata, iana-etc, runCommand
-, perl, which, pkg-config, patch, procps, pcre, cacert, Security, Foundation
-, mailcap, runtimeShell
+{ lib
+, stdenv
+, fetchgit
+, tzdata
+, iana-etc
+, runCommand
+, perl
+, which
+, pkg-config
+, patch
+, procps
+, pcre
+, cacert
+, Security
+, Foundation
+, mailcap
+, runtimeShell
 , buildPackages
 , pkgsBuildTarget
-, fetchpatch
 , callPackage
 }:
 
 let
-
-  inherit (lib) optionals optionalString;
-
   go_bootstrap = buildPackages.callPackage ./bootstrap.nix { };
 
-  goBootstrap = runCommand "go-bootstrap" {} ''
+  goBootstrap = runCommand "go-bootstrap" { } ''
     mkdir $out
     cp -rf ${go_bootstrap}/* $out/
     chmod -R u+w $out
···
   version = "2021-04-13";
 
   src = fetchgit {
-    url = https://go.googlesource.com/go;
+    url = "https://go.googlesource.com/go";
     rev = "9cd52cf2a93a958e8e001aea36886e7846c91f2f";
     sha256 = "sha256:0hybm93y4i4j7bs86y7h73nc1wqnspkq75if7n1032zf9bs8sm96";
   };
···
   # perl is used for testing go vet
   nativeBuildInputs = [ perl which pkg-config patch procps ];
   buildInputs = [ cacert pcre ]
-    ++ optionals stdenv.isLinux [ stdenv.cc.libc.out ]
-    ++ optionals (stdenv.hostPlatform.libc == "glibc") [ stdenv.cc.libc.static ];
+    ++ lib.optionals stdenv.isLinux [ stdenv.cc.libc.out ]
+    ++ lib.optionals (stdenv.hostPlatform.libc == "glibc") [ stdenv.cc.libc.static ];
 
-  depsTargetTargetPropagated = optionals stdenv.isDarwin [ Security Foundation ];
+  depsTargetTargetPropagated = lib.optionals stdenv.isDarwin [ Security Foundation ];
 
   hardeningDisable = [ "all" ];
 
···
     # Disable cgo lookup tests not works, they depend on resolver
     rm src/net/cgo_unix_test.go
 
-  '' + optionalString stdenv.isLinux ''
+  '' + lib.optionalString stdenv.isLinux ''
     # prepend the nix path to the zoneinfo files but also leave the original value for static binaries
     # that run outside a nix server
     sed -i 's,\"/usr/share/zoneinfo/,"${tzdata}/share/zoneinfo/\"\,\n\t&,' src/time/zoneinfo_unix.go
 
-  '' + optionalString stdenv.isAarch32 ''
+  '' + lib.optionalString stdenv.isAarch32 ''
     echo '#!${runtimeShell}' > misc/cgo/testplugin/test.bash
-  '' + optionalString stdenv.isDarwin ''
+  '' + lib.optionalString stdenv.isDarwin ''
     substituteInPlace src/race.bash --replace \
       "sysctl machdep.cpu.extfeatures | grep -qv EM64T" true
     sed -i 's,strings.Contains(.*sysctl.*,true {,' src/cmd/dist/util.go
···
 
   # {CC,CXX}_FOR_TARGET must be only set for cross compilation case as go expect those
   # to be different from CC/CXX
-  CC_FOR_TARGET = if (stdenv.buildPlatform != stdenv.targetPlatform) then
+  CC_FOR_TARGET =
+    if (stdenv.buildPlatform != stdenv.targetPlatform) then
       "${targetCC}/bin/${targetCC.targetPrefix}cc"
     else
       null;
-  CXX_FOR_TARGET = if (stdenv.buildPlatform != stdenv.targetPlatform) then
+  CXX_FOR_TARGET =
+    if (stdenv.buildPlatform != stdenv.targetPlatform) then
       "${targetCC}/bin/${targetCC.targetPrefix}c++"
     else
       null;
 
-  GOARM = toString (lib.intersectLists [(stdenv.hostPlatform.parsed.cpu.version or "")] ["5" "6" "7"]);
+  GOARM = toString (lib.intersectLists [ (stdenv.hostPlatform.parsed.cpu.version or "") ] [ "5" "6" "7" ]);
   GO386 = "softfloat"; # from Arch: don't assume sse2 on i686
   CGO_ENABLED = 1;
   # Hopefully avoids test timeouts on Hydra
···
   # Some tests assume things like home directories and users exists
   GO_BUILDER_NAME = "nix";
 
-  GOROOT_BOOTSTRAP="${goBootstrap}/share/go";
+  GOROOT_BOOTSTRAP = "${goBootstrap}/share/go";
 
   postConfigure = ''
     export GOCACHE=$TMPDIR/go-cache
···
 
     export PATH=$(pwd)/bin:$PATH
 
-    ${optionalString (stdenv.buildPlatform != stdenv.targetPlatform) ''
+    ${lib.optionalString (stdenv.buildPlatform != stdenv.targetPlatform) ''
     # Independent from host/target, CC should produce code for the building system.
     # We only set it when cross-compiling.
     export CC=${buildPackages.stdenv.cc}/bin/cc
···
   '' + (if (stdenv.buildPlatform != stdenv.hostPlatform) then ''
     mv bin/*_*/* bin
     rmdir bin/*_*
-    ${optionalString (!(GOHOSTARCH == GOARCH && GOOS == GOHOSTOS)) ''
+    ${lib.optionalString (!(GOHOSTARCH == GOARCH && GOOS == GOHOSTOS)) ''
       rm -rf pkg/${GOHOSTOS}_${GOHOSTARCH} pkg/tool/${GOHOSTOS}_${GOHOSTARCH}
     ''}
   '' else if (stdenv.hostPlatform != stdenv.targetPlatform) then ''
     rm -rf bin/*_*
-    ${optionalString (!(GOHOSTARCH == GOARCH && GOOS == GOHOSTOS)) ''
+    ${lib.optionalString (!(GOHOSTARCH == GOARCH && GOOS == GOHOSTOS)) ''
       rm -rf pkg/${GOOS}_${GOARCH} pkg/tool/${GOOS}_${GOARCH}
     ''}
   '' else "");

pkgs/development/compilers/llvm/git/default.nix

···
   release_version = "12.0.0";
   candidate = ""; # empty or "rcN"
   dash-candidate = lib.optionalString (candidate != "") "-${candidate}";
+  rev = ""; # When using a Git commit
   version = "${release_version}${dash-candidate}"; # differentiating these (variables) is important for RCs
   targetConfig = stdenv.targetPlatform.config;
 
   src = fetchFromGitHub {
     owner = "llvm";
     repo = "llvm-project";
-    rev = "llvmorg-${version}";
+    rev = if rev != "" then rev else "llvmorg-${version}";
     sha256 = "07jz8pywc2qqa1srdnqg5p2y4lx3ki1inpigarzgxc3j20r4gb58";
   };
 

pkgs/development/compilers/llvm/update-git.py

···
+#! /usr/bin/env nix-shell
+#! nix-shell -i python3 -p python3 nix
+
+import csv
+import fileinput
+import json
+import os
+import re
+import subprocess
+
+from codecs import iterdecode
+from datetime import datetime
+from urllib.request import urlopen, Request
+
+
+def get_latest_chromium_build():
+    HISTORY_URL = 'https://omahaproxy.appspot.com/history?os=linux'
+    print(f'GET {HISTORY_URL}')
+    with urlopen(HISTORY_URL) as resp:
+        builds = csv.DictReader(iterdecode(resp, 'utf-8'))
+        for build in builds:
+            if build['channel'] != 'dev':
+                continue
+            return build
+
+
+def get_file_revision(revision, file_path):
+    """Fetches the requested Git revision of the given Chromium file."""
+    url = f'https://raw.githubusercontent.com/chromium/chromium/{revision}/{file_path}'
+    with urlopen(url) as http_response:
+        return http_response.read().decode()
+
+
+def get_commit(ref):
+    url = f'https://api.github.com/repos/llvm/llvm-project/commits/{ref}'
+    headers = {'Accept': 'application/vnd.github.v3+json'}
+    request = Request(url, headers=headers)
+    with urlopen(request) as http_response:
+        return json.loads(http_response.read().decode())
+
+
+def nix_prefetch_url(url, algo='sha256'):
+    """Prefetches the content of the given URL."""
+    print(f'nix-prefetch-url {url}')
+    out = subprocess.check_output(['nix-prefetch-url', '--type', algo, '--unpack', url])
+    return out.decode('utf-8').rstrip()
+
+
+chromium_build = get_latest_chromium_build()
+chromium_version = chromium_build['version']
+print(f'chromiumDev version: {chromium_version}')
+print('Getting LLVM commit...')
+clang_update_script = get_file_revision(chromium_version, 'tools/clang/scripts/update.py')
+clang_revision = re.search(r"^CLANG_REVISION = '(.+)'$", clang_update_script, re.MULTILINE).group(1)
+clang_commit_short = re.search(r"llvmorg-[0-9]+-init-[0-9]+-g([0-9a-f]{8})", clang_revision).group(1)
+release_version = re.search(r"^RELEASE_VERSION = '(.+)'$", clang_update_script, re.MULTILINE).group(1)
+commit = get_commit(clang_commit_short)
+date = datetime.fromisoformat(commit['commit']['committer']['date'].rstrip('Z')).date().isoformat()
+version = f'unstable-{date}'
+print('Prefetching source tarball...')
+hash = nix_prefetch_url(f'https://github.com/llvm/llvm-project/archive/{commit["sha"]}.tar.gz')
+print('Updating default.nix...')
+default_nix = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'git/default.nix')
+with fileinput.FileInput(default_nix, inplace=True) as f:
+    for line in f:
+        result = re.sub(r'^  release_version = ".+";', f'  release_version = "{release_version}";', line)
+        result = re.sub(r'^  version = ".+";', f'  version = "{version}";', line)
+        result = re.sub(r'^  rev = ".*";', f'  rev = "{commit["sha"]}";', result)
+        result = re.sub(r'^    sha256 = ".+";', f'    sha256 = "{hash}";', result)
+        print(result, end='')

pkgs/development/compilers/mezzo/default.nix

···
-{ lib, stdenv, fetchFromGitHub, ocaml, findlib, ocamlbuild, menhir, yojson, ulex, pprint, fix, functory }:
+{ lib, stdenv, fetchFromGitHub, ocaml, findlib, ocamlbuild, menhir, menhirLib, yojson, ulex, pprint, fix, functory }:
 
 if lib.versionAtLeast ocaml.version "4.06"
 then throw "mezzo is not available for OCaml ${ocaml.version}"
···
     sha256 = "0yck5r6di0935s3iy2mm9538jkf77ssr789qb06ms7sivd7g3ip6";
   };
 
-  buildInputs = [ ocaml findlib ocamlbuild yojson menhir ulex pprint fix functory ];
+  buildInputs = [ ocaml findlib ocamlbuild yojson menhir menhirLib ulex pprint fix functory ];
 
   # Sets warning 3 as non-fatal
   prePatch = lib.optionalString (check-ocaml-version "4.02") ''

pkgs/development/compilers/reason/default.nix

···
 { lib, stdenv, makeWrapper, fetchFromGitHub, ocaml, findlib, dune_2
-, fix, menhir, merlin-extend, ppx_tools_versioned, utop, cppo
+, fix, menhir, menhirLib, menhirSdk, merlin-extend, ppx_tools_versioned, utop, cppo
 }:
 
 stdenv.mkDerivation rec {
···
     sha256 = "0m6ldrci1a4j0qv1cbwh770zni3al8qxsphl353rv19f6rblplhs";
   };
 
-  nativeBuildInputs = [ makeWrapper ];
+  nativeBuildInputs = [ makeWrapper menhir ];
 
-  propagatedBuildInputs = [ menhir merlin-extend ppx_tools_versioned ];
+  propagatedBuildInputs = [ menhirLib merlin-extend ppx_tools_versioned ];
 
-  buildInputs = [ ocaml findlib dune_2 cppo fix utop menhir ];
+  buildInputs = [ ocaml findlib dune_2 cppo fix utop menhir menhirSdk ];
 
   buildFlags = [ "build" ]; # do not "make tests" before reason lib is installed
 

pkgs/development/libraries/libunwind/default.nix

···
     description = "A portable and efficient API to determine the call-chain of a program";
     maintainers = with maintainers; [ orivej ];
     platforms = platforms.linux;
+    badPlatforms = [ "riscv32-linux" "riscv64-linux" ];
     license = licenses.mit;
   };
-
-  passthru.supportsHost = !stdenv.hostPlatform.isRiscV;
 }

pkgs/development/ocaml-modules/dolmen/default.nix

···
-{ stdenv, lib, fetchFromGitHub, ocaml, findlib, ocamlbuild, menhir }:
+{ stdenv, lib, fetchFromGitHub, ocaml, findlib, ocamlbuild, menhir, menhirLib }:
 
 stdenv.mkDerivation rec {
   name = "ocaml${ocaml.version}-dolmen-${version}";
···
     sha256 = "1b9mf8p6mic0n76acx8x82hhgm2n40sdv0jri95im65l52223saf";
   };
 
-  buildInputs = [ ocaml findlib ocamlbuild ];
-  propagatedBuildInputs = [ menhir ];
+  buildInputs = [ ocaml findlib ocamlbuild menhir ];
+  propagatedBuildInputs = [ menhirLib ];
 
   makeFlags = [ "-C" "src" ];
 

pkgs/development/ocaml-modules/earlybird/default.nix

···
 { lib, fetchurl, ocaml, buildDunePackage
-, cmdliner, dap, fmt, iter, logs, lru, lwt_ppx, lwt_react, menhir, path_glob, ppx_deriving_yojson
+, cmdliner, dap, fmt, iter, logs, lru, lwt_ppx, lwt_react, menhir, menhirLib, path_glob, ppx_deriving_yojson
 }:
 
 if lib.versionAtLeast ocaml.version "4.13"
···
     sha256 = "1pwzhcr3pw24ra4j4d23vz71h0psz4xkyp7b12l2wl1slxzjbrxa";
   };
 
-  buildInputs = [ cmdliner dap fmt iter logs lru lwt_ppx lwt_react menhir path_glob ppx_deriving_yojson ];
+  buildInputs = [ cmdliner dap fmt iter logs lru lwt_ppx lwt_react menhir menhirLib path_glob ppx_deriving_yojson ];
 
   meta = {
     homepage = "https://github.com/hackwaly/ocamlearlybird";

pkgs/development/ocaml-modules/menhir/default.nix

···
-{ lib, stdenv, fetchurl, ocaml, findlib, ocamlbuild
-, version ? if lib.versionAtLeast (lib.getVersion ocaml) "4.02" then "20190626" else "20140422"
-}@args:
+{ lib, fetchFromGitLab, buildDunePackage
+, menhirLib, menhirSdk
+}:
 
-let
-  src = fetchurl (
-  if version == "20140422" then { url = "http://cristal.inria.fr/~fpottier/menhir/menhir-20140422.tar.gz"; sha256 = "1ki1f2id6a14h9xpv2k8yb6px7dyw8cvwh39csyzj4qpzx7wia0d"; }
-  else if version == "20170712" then { url = "http://gallium.inria.fr/~fpottier/menhir/menhir-20170712.tar.gz"; sha256 = "006hq3bwj81j67f2k9cgzj5wr4hai8j36925p5n3sd2j01ljsj6a"; }
-  else if version == "20181113" then { url = "https://gitlab.inria.fr/fpottier/menhir/repository/20181113/archive.tar.gz"; sha256 = "0hl611l0gyl7b2bm7m0sk7vjz14m0i7znrnjq3gw58pylj934dx4"; }
-  else if version == "20190626" then { url = "https://gitlab.inria.fr/fpottier/menhir/repository/20190626/archive.tar.gz"; sha256 = "0nigjnskg89knyi2zj1w211mb1pvkrwfqpz9a0qbw80k3hm8gg0h"; }
-  else throw ("menhir: unknown version " ++ version)
-  );
-in
+buildDunePackage rec {
+  pname = "menhir";
+
+  inherit (menhirLib) version src useDune2;
+
+  buildInputs = [ menhirLib menhirSdk ];
 
-import ./generic.nix (args // { inherit version src; })
+  meta = menhirSdk.meta // {
+    description = "A LR(1) parser generator for OCaml";
+  };
+}

pkgs/development/ocaml-modules/menhir/generic.nix

···
-{ version, src, lib, stdenv, ocaml, findlib, ocamlbuild, ... }:
-
-stdenv.mkDerivation {
-  pname = "menhir";
-  inherit version;
-
-  inherit src;
-
-  buildInputs = [ ocaml findlib ocamlbuild ];
-
-  createFindlibDestdir = true;
-
-  preBuild = ''
-    # fix makefiles.
-    RM=$(type -p rm)
-    CHMOD=$(type -p chmod)
-    for f in src/Makefile demos/OMakefile* demos/Makefile*
-    do
-      substituteInPlace $f \
-        --replace /bin/rm $RM \
-        --replace /bin/chmod $CHMOD
-    done
-
-    export PREFIX=$out
-  '';
-
-  meta = with lib; {
-    homepage = "http://pauillac.inria.fr/~fpottier/menhir/";
-    description = "A LR(1) parser generator for OCaml";
-    longDescription = ''
-      Menhir is a LR(1) parser generator for the Objective Caml programming
-      language.  That is, Menhir compiles LR(1) grammar specifications down
-      to OCaml code.  Menhir was designed and implemented by François Pottier
-      and Yann Régis-Gianas.
-    '';
-    license = with licenses; [
-      (if versionAtLeast version "20170418" then gpl2 else qpl) /* generator */
-      lgpl2 /* library */
-    ];
-    platforms = ocaml.meta.platforms or [];
-    maintainers = with maintainers; [ maggesi ];
-  };
-}

pkgs/development/ocaml-modules/menhir/lib.nix

···
+{ lib, fetchFromGitLab, buildDunePackage }:
+
+buildDunePackage rec {
+  pname = "menhirLib";
+  version = "20210419";
+
+  src = fetchFromGitLab {
+    domain = "gitlab.inria.fr";
+    owner = "fpottier";
+    repo = "menhir";
+    rev = version;
+    sha256 = "0jcbr7s3iwfr7xxfybs3h407g76yfp5yq5r9i0wg2ahvvbqh03ky";
+  };
+
+  useDune2 = true;
+
+  meta = with lib; {
+    homepage = "http://pauillac.inria.fr/~fpottier/menhir/";
+    description = "Runtime support library for parsers generated by Menhir";
+    longDescription = ''
+      Menhir is a LR(1) parser generator for the Objective Caml programming
+      language.  That is, Menhir compiles LR(1) grammar specifications down
+      to OCaml code.  Menhir was designed and implemented by François Pottier
+      and Yann Régis-Gianas.
+    '';
+    license = with licenses; [ lgpl2Only ];
+    maintainers = with maintainers; [ vbgl ];
+  };
+}

pkgs/development/ocaml-modules/menhir/sdk.nix

···
+{ lib, fetchFromGitLab, buildDunePackage
+, menhirLib
+}:
+
+buildDunePackage rec {
+  pname = "menhirSdk";
+
+  inherit (menhirLib) version src useDune2;
+
+  meta = menhirLib.meta // {
+    description = "Compile-time library for auxiliary tools related to Menhir";
+    license = with lib.licenses; [ gpl2Only ];
+  };
+}
+

pkgs/development/ocaml-modules/mustache/default.nix

···
-{ lib, buildDunePackage, fetchFromGitHub, ezjsonm, menhir, ounit }:
+{ lib, buildDunePackage, fetchFromGitHub, ezjsonm, menhir, menhirLib, ounit }:
 
 buildDunePackage rec {
   pname = "mustache";
···
     sha256 = "19v8rk8d8lkfm2rmhdawfgadji6wa267ir5dprh4w9l1sfj8a1py";
   };
 
-  buildInputs = [ ezjsonm ];
-  propagatedBuildInputs = [ menhir ];
+  buildInputs = [ ezjsonm menhir ];
+  propagatedBuildInputs = [ menhirLib ];
 
   doCheck = true;
   checkInputs = [ ounit ];

pkgs/development/ocaml-modules/stdcompat/default.nix

···
+{ stdenv, lib, fetchurl
+, ocaml, findlib
+}:
+
+stdenv.mkDerivation rec {
+  pname = "ocaml${ocaml.version}-stdcompat";
+  version = "15";
+
+  src = fetchurl {
+    url = "https://github.com/thierry-martinez/stdcompat/releases/download/v${version}/stdcompat-${version}.tar.gz";
+    sha256 = "1xcwb529m4lg9cbnxa9m3x2nnl9nxzz1x5lxpvdfflg4zxl6yx2y";
+  };
+
+  buildInputs = [ ocaml findlib ];
+
+  configureFlags = "--libdir=$(OCAMLFIND_DESTDIR)";
+
+  meta = {
+    homepage = "https://github.com/thierry-martinez/stdcompat";
+    license = lib.licenses.bsd2;
+    maintainers = [ lib.maintainers.vbgl ];
+    inherit (ocaml.meta) platforms;
+  };
+}

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

···
   checkInputs = [ pytestCheckHook ];
 
   pytestFlagsArray = [ "aiomultiprocess/tests/*.py" ];
+
+  disabledTests = [
+    # tests are flaky and make the whole test suite time out
+    "test_pool_worker_exceptions"
+    "test_pool_worker_max_tasks"
+    "test_pool_worker_stop"
+  ];
+
   pythonImportsCheck = [ "aiomultiprocess" ];
 
   meta = with lib; {

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

···
     tqdm
   ];
 
-  postPatch = ''
-    # https://github.com/angr/angrop/issues/35
-    substituteInPlace setup.py \
-      --replace "packages=['angrop']," "packages=find_packages()," \
-      --replace "from distutils.core import setup" "from setuptools import find_packages, setup"
-  '';
-
   # Tests have additional requirements, e.g., angr binaries
   # cle is executing the tests with the angr binaries already and is a requirement of angr
   doCheck = false;

pkgs/development/python-modules/pyls-black/default.nix

···
-{ lib, buildPythonPackage, fetchFromGitHub, fetchpatch
-, black, toml, pytest, python-language-server, isPy3k
+{ lib
+, buildPythonPackage
+, fetchFromGitHub
+, black
+, toml
+, pytestCheckHook
+, python-language-server
+, isPy3k
 }:
 
 buildPythonPackage rec {
   pname = "pyls-black";
-  version = "0.4.6";
+  version = "0.4.7";
 
   src = fetchFromGitHub {
     owner = "rupert";
     repo = "pyls-black";
     rev = "v${version}";
-    sha256 = "0cjf0mjn156qp0x6md6mncs31hdpzfim769c2lixaczhyzwywqnj";
+    sha256 = "0bkhfnlik89j3yamr20br4wm8975f20v33wabi2nyxvj10whr5dj";
   };
 
-  # Fix test failure with black 21.4b0+
-  # Remove if https://github.com/rupert/pyls-black/pull/39 merged.
-  patches = [
-    (fetchpatch {
-      url = "https://github.com/rupert/pyls-black/commit/728207b540d9c25eb0d1cd96419ebfda2e257f63.patch";
-      sha256 = "0i3w5myhjl5lq1lpkizagnmk6m8fkn3igfyv5f2qcrn5n7f119ak";
-    })
-  ];
-
   disabled = !isPy3k;
 
-  checkPhase = ''
-    pytest
-  '';
-
-  checkInputs = [ pytest ];
+  checkInputs = [ pytestCheckHook ];
 
   propagatedBuildInputs = [ black toml python-language-server ];
 

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

···
     description = "A zip archive generator";
     homepage = "https://github.com/allanlei/python-zipstream";
     license = lib.licenses.gpl3Plus;
-    maintainers = with lib.maintainers; [ primeos ];
+    maintainers = with lib.maintainers; [ ];
   };
 }

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

···
     biniou
     camlzip
     easy-format
-    menhir
+    menhirLib
     mlgmpidl
     num
     ocamlgraph
···
   nativeBuildInputs = [ autoconf wrapGAppsHook ];
 
   buildInputs = with ocamlPackages; [
-    ncurses ocaml findlib ltl2ba ocamlgraph yojson menhir camlzip
+    ncurses ocaml findlib ltl2ba ocamlgraph yojson menhirLib camlzip
     lablgtk coq graphviz zarith apron why3 mlgmpidl doxygen
     gdk-pixbuf
   ];

pkgs/development/tools/esbuild/default.nix

···
 
 buildGoModule rec {
   pname = "esbuild";
-  version = "0.12.5";
+  version = "0.12.6";
 
   src = fetchFromGitHub {
     owner = "evanw";
     repo = "esbuild";
     rev = "v${version}";
-    sha256 = "sha256-9EVlmdolr189vdnuA01UUrcrmZ9W0FtvCcJuuSX1nLs=";
+    sha256 = "sha256-ncRHsYxG4XVT7TUJv+VgXMsLmQ52+/dXUlgMy8QnzNc=";
   };
 
   vendorSha256 = "sha256-2ABWPqhK2Cf4ipQH7XvRrd+ZscJhYPc3SV2cGT0apdg=";

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

···
 
 stdenv.mkDerivation rec {
   pname = "coccinelle";
-  version = "1.0.6";
+  version = "1.1.0";
 
   src = fetchurl {
-    url = "http://coccinelle.lip6.fr/distrib/${pname}-${version}.tgz";
-    sha256 = "02g9hmwkvfl838zz690yra5jzrqjg6y6ffxkrfcsx790bhkfsll4";
+    url = "https://coccinelle.gitlabpages.inria.fr/website/distrib/${pname}-${version}.tar.gz";
+    sha256 = "0k0x4qnxzj8fymkp6y9irggcah070hj7hxq8l6ddj8ccpmjbhnsb";
   };
 
   buildInputs = with ocamlPackages; [
     ocaml findlib menhir
-    ocaml_pcre pycaml
+    ocaml_pcre parmap stdcompat
     python ncurses pkg-config
   ];
 
-  doCheck = !stdenv.isDarwin;
-
-  # The build system builds two versions of spgen:
-  # 'spgen' with ocamlc -custom (bytecode specially linked)
-  # and 'spgen.opt' using ocamlopt.
-  # I'm not sure of the intentions here, but the way
-  # the 'spgen' binary is produced results in an
-  # invalid/incorrect interpreter path (/lib/ld-linux*).
-  # We could patch it, but without knowing why it's
-  # finding the wrong path it seems safer to use
-  # the .opt version that is built correctly.
-  # All that said, our fix here is simple: remove 'spgen'.
-  # The bin/spgen entrypoint is really a bash script
-  # and will use spgen.opt if 'spgen' doesn't exist.
-  postInstall = ''
-    rm $out/lib/coccinelle/spgen/spgen
-  '';
+  doCheck = false;
 
   meta = {
     description = "Program to apply semantic patches to C code";

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

···
 { lib, stdenv, fetchurl, perl, libunwind, buildPackages }:
 
-# libunwind does not have the supportsHost attribute on darwin, thus
-# when this package is evaluated it causes an evaluation error
-assert stdenv.isLinux;
-
 stdenv.mkDerivation rec {
   pname = "strace";
   version = "5.12";
···
   depsBuildBuild = [ buildPackages.stdenv.cc ];
   nativeBuildInputs = [ perl ];
 
-  buildInputs = [ perl.out ] ++ lib.optional libunwind.supportsHost libunwind; # support -k
+  # On RISC-V platforms, LLVM's libunwind implementation is unsupported by strace.
+  # The build will silently fall back and -k will not work on RISC-V.
+  buildInputs = [ perl.out libunwind ]; # support -k
 
   postPatch = "patchShebangs --host strace-graph";
 

pkgs/development/tools/ocaml/js_of_ocaml/compiler.nix

···
 { lib, fetchurl, buildDunePackage
 , ocaml, cmdliner, cppo, yojson, ppxlib
-, menhir
+, menhir, menhirLib
 }:
 
 buildDunePackage rec {
···
   };
 
   nativeBuildInputs = [ cppo menhir ];
-  buildInputs = [ cmdliner ];
+  buildInputs = [ cmdliner menhirLib ];
 
   configurePlatforms = [];
   propagatedBuildInputs = [ yojson ppxlib ];

pkgs/development/tools/ocaml/merlin/4.x.nix

···
 , dot-merlin-reader
 , jq
 , menhir
+, menhirLib
+, menhirSdk
 }:
 
 let
···
   checkInputs = [
     jq
     menhir
+    menhirLib
+    menhirSdk
   ];
 
   meta = with lib; {

pkgs/development/tools/ocaml/ocamlformat/generic.nix

···
       uutf
       fix
       menhir
+      menhirLib
+      menhirSdk
       dune-build-info
       ocaml-version
       # Changed since 0.16.0:
···
       uutf
       fix
       menhir
+      menhirLib
+      menhirSdk
       dune-build-info
       ocaml-version
       # Changed since 0.16.0:
···
       uutf
       fix
       menhir
+      menhirLib
+      menhirSdk
       (ppxlib.override { version = "0.18.0"; })
       dune-build-info # lib.versionAtLeast version "0.16.0"
       ocaml-version # lib.versionAtLeast version "0.16.0"
···
       uutf
       fix
       menhir
+      menhirLib
+      menhirSdk
     ] else [
       base
       cmdliner

pkgs/os-specific/linux/pam_u2f/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "pam_u2f";
-  version = "1.1.0";
+  version = "1.1.1";
 
   src     = fetchurl {
     url = "https://developers.yubico.com/pam-u2f/Releases/${pname}-${version}.tar.gz";
-    sha256 = "01fwbrfnjkv93vvqm54jywdcxa1p7d4r32azicwnx75nxfbbzhqd";
+    sha256 = "12p3pkrp32vzpg7707cgx8zgvgj8iqwhy39sm761k7plqi027mmp";
   };
 
   nativeBuildInputs = [ pkg-config ];
···
 
   preConfigure = ''
     configureFlagsArray+=("--with-pam-dir=$out/lib/security")
+  '';
+
+  # a no-op makefile to prevent building the fuzz targets
+  postConfigure = ''
+    cat > fuzz/Makefile <<EOF
+    all:
+    install:
+    EOF
   '';
 
   meta = with lib; {

pkgs/tools/audio/liquidsoap/full.nix

···
       ocamlPackages.xmlm ocamlPackages.ocaml_pcre
       ocamlPackages.camomile
       ocamlPackages.fdkaac
-      ocamlPackages.srt ocamlPackages.sedlex_2 ocamlPackages.menhir
+      ocamlPackages.srt ocamlPackages.sedlex_2 ocamlPackages.menhir ocamlPackages.menhirLib
     ];
 
   hardeningDisable = [ "format" "fortify" ];

pkgs/tools/misc/plantuml/default.nix

···
 { lib, stdenv, fetchurl, makeWrapper, jre, graphviz }:
 
 stdenv.mkDerivation rec {
-  version = "1.2021.3";
+  version = "1.2021.7";
   pname = "plantuml";
 
   src = fetchurl {
     url = "mirror://sourceforge/project/plantuml/${version}/plantuml.${version}.jar";
-    sha256 = "sha256-Kx2fTx71oVkAgsytl1OFBcENMnJ1ZHmg8qvYDFTSS2M=";
+    sha256 = "sha256-2hQIwUpkxLHGG+kx8AekSKJ1qO8inL8xnko0dlLC1Kg=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/tools/misc/zellij/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "zellij";
-  version = "0.12.1";
+  version = "0.13.0";
 
   src = fetchFromGitHub {
     owner = "zellij-org";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-OgpSVyXvJeRpxHWfIoJjQbbkt2RSze0IL5za3igGE6s=";
+    sha256 = "sha256-m7rAlFMhkX6+l+OceZ/RnusdhGew+Rjp7AmZ7vo2wr0=";
   };
 
-  cargoSha256 = "sha256-LgJPhwOuzlKIw5smy4WJvC0CFoylnMlx6Re7gVPtiq8=";
+  cargoSha256 = "sha256-iTPOlbS3gWlJ8E2VB7z/kOsOJcngPGof7R5cH3Z0xk0=";
 
   nativeBuildInputs = [ installShellFiles ];
 

pkgs/tools/typesetting/satysfi/default.nix

···
     nativeBuildInputs = [ ruby dune_2 ];
 
     buildInputs = [ camlpdf otfm yojson-with-position ] ++ (with ocamlPackages; [
-      ocaml findlib menhir
+      ocaml findlib menhir menhirLib
       batteries camlimages core_kernel ppx_deriving uutf omd cppo re
     ]);
 

pkgs/top-level/all-packages.nix

···
   # Does not actually depend on Qt 5
   inherit (plasma5Packages) extra-cmake-modules;
 
-  coccinelle = callPackage ../development/tools/misc/coccinelle {
-    ocamlPackages = ocaml-ng.ocamlPackages_4_05;
-  };
+  coccinelle = callPackage ../development/tools/misc/coccinelle { };
 
   cpptest = callPackage ../development/libraries/cpptest { };
 
···
 
   libutempter = callPackage ../development/libraries/libutempter { };
 
-  libunwind = if stdenv.isDarwin
-    then darwin.libunwind
+  libunwind =
+    if stdenv.isDarwin then darwin.libunwind
+    else if stdenv.hostPlatform.isRiscV then llvmPackages_latest.libunwind
     else callPackage ../development/libraries/libunwind { };
 
   libuv = callPackage ../development/libraries/libuv {

pkgs/top-level/ocaml-packages.nix

···
 
     menhir = callPackage ../development/ocaml-modules/menhir { };
 
+    menhirLib = callPackage ../development/ocaml-modules/menhir/lib.nix { };
+
+    menhirSdk = callPackage ../development/ocaml-modules/menhir/sdk.nix { };
+
     merlin =
       if lib.versionAtLeast ocaml.version "4.11"
       then callPackage ../development/tools/ocaml/merlin/4.x.nix { }
···
     };
 
     ssl = callPackage ../development/ocaml-modules/ssl { };
+
+    stdcompat = callPackage ../development/ocaml-modules/stdcompat { };
 
     stdlib-shims = callPackage ../development/ocaml-modules/stdlib-shims { };