Merge release-21.05 into staging-next-21.05

pkgs/development/compilers/ghc/8.10.7.nix

@@ -0,0 +1,298 @@
+{ lib, stdenv, pkgsBuildTarget, targetPackages
+
+# build-tools
+, bootPkgs
+, autoconf, automake, coreutils, fetchpatch, fetchurl, perl, python3, m4, sphinx, xattr
+, bash
+
+, libiconv ? null, ncurses
+
+, # GHC can be built with system libffi or a bundled one.
+  libffi ? null
+
+, useLLVM ? !stdenv.targetPlatform.isx86
+, # LLVM is conceptually a run-time-only depedendency, but for
+  # non-x86, we need LLVM to bootstrap later stages, so it becomes a
+  # build-time dependency too.
+  buildLlvmPackages, llvmPackages
+
+, # If enabled, GHC will be built with the GPL-free but slower integer-simple
+  # library instead of the faster but GPLed integer-gmp library.
+  enableIntegerSimple ? !(lib.meta.availableOn stdenv.hostPlatform gmp), gmp
+
+, # If enabled, use -fPIC when compiling static libs.
+  enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform
+
+  # aarch64 outputs otherwise exceed 2GB limit
+, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64
+
+, # Whether to build dynamic libs for the standard library (on the target
+  # platform). Static libs are always built.
+  enableShared ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.useiOSPrebuilt
+
+, # Whether to build terminfo.
+  enableTerminfo ? !stdenv.targetPlatform.isWindows
+
+, # What flavour to build. An empty string indicates no
+  # specific flavour and falls back to ghc default values.
+  ghcFlavour ? lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform)
+    (if useLLVM then "perf-cross" else "perf-cross-ncg")
+
+, # Whether to disable the large address space allocator
+  # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/
+  disableLargeAddressSpace ? stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64
+}:
+
+assert !enableIntegerSimple -> gmp != null;
+
+let
+  inherit (stdenv) buildPlatform hostPlatform targetPlatform;
+
+  inherit (bootPkgs) ghc;
+
+  # TODO(@Ericson2314) Make unconditional
+  targetPrefix = lib.optionalString
+    (targetPlatform != hostPlatform)
+    "${targetPlatform.config}-";
+
+  buildMK = ''
+    BuildFlavour = ${ghcFlavour}
+    ifneq \"\$(BuildFlavour)\" \"\"
+    include mk/flavours/\$(BuildFlavour).mk
+    endif
+    DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}
+    INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}
+  '' + lib.optionalString (targetPlatform != hostPlatform) ''
+    Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"}
+    CrossCompilePrefix = ${targetPrefix}
+    HADDOCK_DOCS = NO
+    BUILD_SPHINX_HTML = NO
+    BUILD_SPHINX_PDF = NO
+  '' + lib.optionalString (!enableProfiledLibs) ''
+    GhcLibWays = "v dyn"
+  '' + lib.optionalString enableRelocatedStaticLibs ''
+    GhcLibHcOpts += -fPIC
+    GhcRtsHcOpts += -fPIC
+  '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
+    EXTRA_CC_OPTS += -std=gnu99
+  ''
+  # While split sections are now enabled by default in ghc 8.8 for windows,
+  # they seem to lead to `too many sections` errors when building base for
+  # profiling.
+  + lib.optionalString targetPlatform.isWindows ''
+    SplitSections = NO
+  '';
+
+  # Splicer will pull out correct variations
+  libDeps = platform: lib.optional enableTerminfo ncurses
+    ++ [libffi]
+    ++ lib.optional (!enableIntegerSimple) gmp
+    ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv;
+
+  toolsForTarget = [
+    pkgsBuildTarget.targetPackages.stdenv.cc
+  ] ++ lib.optional useLLVM buildLlvmPackages.llvm;
+
+  targetCC = builtins.head toolsForTarget;
+
+  # ld.gold is disabled for musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856
+  # see #84670 and #49071 for more background.
+  useLdGold = targetPlatform.isLinux && !(targetPlatform.useLLVM or false) && !targetPlatform.isMusl && !targetPlatform.isWindows;
+
+  runtimeDeps = [
+    targetPackages.stdenv.cc.bintools
+    coreutils
+  ]
+  # On darwin, we need unwrapped bintools as well (for otool)
+  ++ lib.optionals (stdenv.targetPlatform.linker == "cctools") [
+    targetPackages.stdenv.cc.bintools.bintools
+  ];
+
+in
+stdenv.mkDerivation (rec {
+  version = "8.10.7";
+  name = "${targetPrefix}ghc-${version}";
+
+  src = fetchurl {
+    url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz";
+    sha256 = "e3eef6229ce9908dfe1ea41436befb0455fefb1932559e860ad4c606b0d03c9d";
+  };
+
+  enableParallelBuilding = true;
+
+  outputs = [ "out" "doc" ];
+
+  patches = [
+    # See upstream patch at
+    # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/4885. Since we build
+    # from source distributions, the auto-generated configure script needs to be
+    # patched as well, therefore we use an in-tree patch instead of pulling the
+    # upstream patch. Don't forget to check backport status of the upstream patch
+    # when adding new GHC releases in nixpkgs.
+    ./respect-ar-path.patch
+
+    # cabal passes incorrect --host= when cross-compiling
+    # https://github.com/haskell/cabal/issues/5887
+    (fetchpatch {
+            url = "https://raw.githubusercontent.com/input-output-hk/haskell.nix/122bd81150386867da07fdc9ad5096db6719545a/overlays/patches/ghc/cabal-host.patch";
+      sha256 = "sha256:0yd0sajgi24sc1w5m55lkg2lp6kfkgpp3lgija2c8y3cmkwfpdc1";
+    })
+
+    # In order to build ghcjs packages, the Cabal of the ghc used for the ghcjs
+    # needs to be patched. Ref https://github.com/haskell/cabal/pull/7575
+    (fetchpatch {
+      url = "https://github.com/haskell/cabal/commit/369c4a0a54ad08a9e6b0d3bd303fedd7b5e5a336.patch";
+      sha256 = "120f11hwyaqa0pq9g5l1300crqij49jg0rh83hnp9sa49zfdwx1n";
+      stripLen = 3;
+      extraPrefix = "libraries/Cabal/Cabal/";
+    })
+  ] ++ lib.optionals stdenv.isDarwin [
+    # Make Block.h compile with c++ compilers. Remove with the next release
+    (fetchpatch {
+      url = "https://gitlab.haskell.org/ghc/ghc/-/commit/97d0b0a367e4c6a52a17c3299439ac7de129da24.patch";
+      sha256 = "0r4zjj0bv1x1m2dgxp3adsf2xkr94fjnyj1igsivd9ilbs5ja0b5";
+    })
+  ];
+
+  postPatch = "patchShebangs .";
+
+  # GHC is a bit confused on its cross terminology.
+  preConfigure = ''
+    for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do
+      export "''${env#TARGET_}=''${!env}"
+    done
+    # GHC is a bit confused on its cross terminology, as these would normally be
+    # the *host* tools.
+    export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"
+    export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"
+    # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177
+    export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString useLdGold ".gold"}"
+    export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"
+    export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"
+    export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"
+    export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"
+    export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"
+    export STRIP="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}strip"
+
+    echo -n "${buildMK}" > mk/build.mk
+    sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure
+  '' + lib.optionalString (!stdenv.isDarwin) ''
+    export NIX_LDFLAGS+=" -rpath $out/lib/ghc-${version}"
+  '' + lib.optionalString stdenv.isDarwin ''
+    export NIX_LDFLAGS+=" -no_dtrace_dof"
+
+    # GHC tries the host xattr /usr/bin/xattr by default which fails since it expects python to be 2.7
+    export XATTR=${lib.getBin xattr}/bin/xattr
+  '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
+    sed -i -e '5i ,("armv7a-unknown-linux-androideabi", ("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", "cortex-a8", ""))' llvm-targets
+  '' + lib.optionalString targetPlatform.isMusl ''
+      echo "patching llvm-targets for musl targets..."
+      echo "Cloning these existing '*-linux-gnu*' targets:"
+      grep linux-gnu llvm-targets | sed 's/^/  /'
+      echo "(go go gadget sed)"
+      sed -i 's,\(^.*linux-\)gnu\(.*\)$,\0\n\1musl\2,' llvm-targets
+      echo "llvm-targets now contains these '*-linux-musl*' targets:"
+      grep linux-musl llvm-targets | sed 's/^/  /'
+
+      echo "And now patching to preserve '-musleabi' as done with '-gnueabi'"
+      # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen)
+      for x in configure aclocal.m4; do
+        substituteInPlace $x \
+          --replace '*-android*|*-gnueabi*)' \
+                    '*-android*|*-gnueabi*|*-musleabi*)'
+      done
+  '';
+
+  # TODO(@Ericson2314): Always pass "--target" and always prefix.
+  configurePlatforms = [ "build" "host" ]
+    ++ lib.optional (targetPlatform != hostPlatform) "target";
+
+  # `--with` flags for libraries needed for RTS linker
+  configureFlags = [
+    "--datadir=$doc/share/doc/ghc"
+    "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib"
+  ] ++ lib.optionals (libffi != null) [
+    "--with-system-libffi"
+    "--with-ffi-includes=${targetPackages.libffi.dev}/include"
+    "--with-ffi-libraries=${targetPackages.libffi.out}/lib"
+  ] ++ lib.optionals (targetPlatform == hostPlatform && !enableIntegerSimple) [
+    "--with-gmp-includes=${targetPackages.gmp.dev}/include"
+    "--with-gmp-libraries=${targetPackages.gmp.out}/lib"
+  ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [
+    "--with-iconv-includes=${libiconv}/include"
+    "--with-iconv-libraries=${libiconv}/lib"
+  ] ++ lib.optionals (targetPlatform != hostPlatform) [
+    "--enable-bootstrap-with-devel-snapshot"
+  ] ++ lib.optionals useLdGold [
+    "CFLAGS=-fuse-ld=gold"
+    "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"
+    "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"
+  ] ++ lib.optionals (disableLargeAddressSpace) [
+    "--disable-large-address-space"
+  ];
+
+  # Make sure we never relax`$PATH` and hooks support for compatibility.
+  strictDeps = true;
+
+  # Don’t add -liconv to LDFLAGS automatically so that GHC will add it itself.
+  dontAddExtraLibs = true;
+
+  nativeBuildInputs = [
+    perl autoconf automake m4 python3 sphinx
+    ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour
+  ];
+
+  # For building runtime libs
+  depsBuildTarget = toolsForTarget;
+
+  buildInputs = [ perl bash ] ++ (libDeps hostPlatform);
+
+  propagatedBuildInputs = [ targetPackages.stdenv.cc ]
+    ++ lib.optional useLLVM llvmPackages.llvm;
+
+  depsTargetTarget = map lib.getDev (libDeps targetPlatform);
+  depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);
+
+  # required, because otherwise all symbols from HSffi.o are stripped, and
+  # that in turn causes GHCi to abort
+  stripDebugFlags = [ "-S" ] ++ lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols";
+
+  checkTarget = "test";
+
+  hardeningDisable = [ "format" ] ++ lib.optional stdenv.targetPlatform.isMusl "pie";
+
+  postInstall = ''
+    # Install the bash completion file.
+    install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc
+
+    # Patch scripts to include "readelf" and "cat" in $PATH.
+    for i in "$out/bin/"*; do
+      test ! -h $i || continue
+      egrep --quiet '^#!' <(head -n 1 $i) || continue
+      sed -i -e '2i export PATH="$PATH:${lib.makeBinPath runtimeDeps}"' $i
+    done
+  '';
+
+  passthru = {
+    inherit bootPkgs targetPrefix;
+
+    inherit llvmPackages;
+    inherit enableShared;
+
+    # Our Cabal compiler name
+    haskellCompilerName = "ghc-${version}";
+  };
+
+  meta = {
+    homepage = "http://haskell.org/ghc";
+    description = "The Glasgow Haskell Compiler";
+    maintainers = with lib.maintainers; [ marcweber andres peti ];
+    timeout = 24 * 3600;
+    inherit (ghc.meta) license platforms;
+  };
+
+} // lib.optionalAttrs targetPlatform.useAndroidPrebuilt {
+  dontStrip = true;
+  dontPatchELF = true;
+  noAuditTmpdir = true;
+})

pkgs/development/compilers/ghcjs-ng/8.6/dep-overrides.nix

@@ -1,14 +0,0 @@
-{ haskellLib }:
-
-let inherit (haskellLib) doJailbreak dontHaddock dontCheck;
-in self: super: {
-  ghcjs = super.ghcjs.override {
-    shelly = super.shelly_1_8_1;
-  };
-  ghc-api-ghcjs = super.ghc-api-ghcjs.override
-  {
-    happy = self.happy_1_19_5;
-  };
-  haddock-library-ghcjs = doJailbreak (dontCheck super.haddock-library-ghcjs);
-  haddock-api-ghcjs = doJailbreak (dontHaddock super.haddock-api-ghcjs);
-}

pkgs/development/compilers/ghcjs-ng/8.6/git.json

@@ -1,6 +0,0 @@
-{
-  "url": "https://github.com/ghcjs/ghcjs",
-  "rev": "e87195eaa2bc7e320e18cf10386802bc90b7c874",
-  "sha256": "02mwkf7aagxqi142gcmq048244apslrr72p568akcab9s0fn2gvy",
-  "fetchSubmodules": true
-}

pkgs/development/compilers/ghcjs-ng/8.6/stage0.nix

@@ -1,177 +0,0 @@
-{ callPackage, configuredSrc }:
-
-{
-
-  ghcjs = callPackage
-    ({ mkDerivation, aeson, array, attoparsec, base, base16-bytestring
-    , base64-bytestring, binary, bytestring, Cabal, containers
-    , cryptohash, data-default, deepseq, directory, executable-path
-    , filepath, ghc-api-ghcjs, ghc-boot, ghc-paths, ghci-ghcjs
-    , ghcjs-th, haddock-api-ghcjs, hashable, haskell-src-exts
-    , haskell-src-meta, http-types, HUnit, lens, lifted-base, mtl
-    , network, optparse-applicative, parallel, parsec, process, random
-    , regex-posix, safe, shelly, split, lib, stringsearch, syb
-    , system-fileio, system-filepath, tar, template-haskell
-    , template-haskell-ghcjs, terminfo, test-framework
-    , test-framework-hunit, text, time, transformers
-    , transformers-compat, unix, unix-compat, unordered-containers
-    , vector, wai, wai-app-static, wai-extra, wai-websockets, warp
-    , webdriver, websockets, wl-pprint-text, yaml
-    }:
-    mkDerivation {
-      pname = "ghcjs";
-      version = "8.6.0.1";
-      src = configuredSrc + /.;
-      isLibrary = true;
-      isExecutable = true;
-      enableSeparateDataOutput = true;
-      setupHaskellDepends = [
-        base Cabal containers directory filepath process template-haskell
-        transformers
-      ];
-      libraryHaskellDepends = [
-        aeson array attoparsec base base16-bytestring base64-bytestring
-        binary bytestring Cabal containers cryptohash data-default deepseq
-        directory filepath ghc-api-ghcjs ghc-boot ghc-paths ghci-ghcjs
-        ghcjs-th hashable haskell-src-exts haskell-src-meta lens mtl
-        optparse-applicative parallel parsec process regex-posix safe split
-        stringsearch syb template-haskell template-haskell-ghcjs text time
-        transformers unordered-containers vector wl-pprint-text yaml
-      ];
-      executableHaskellDepends = [
-        aeson base binary bytestring Cabal containers directory
-        executable-path filepath ghc-api-ghcjs ghc-boot haddock-api-ghcjs
-        lens mtl optparse-applicative process shelly system-fileio
-        system-filepath tar terminfo text time transformers
-        transformers-compat unix unix-compat unordered-containers vector
-        yaml
-      ];
-      testHaskellDepends = [
-        aeson base bytestring data-default deepseq directory http-types
-        HUnit lens lifted-base network optparse-applicative process random
-        shelly system-fileio system-filepath test-framework
-        test-framework-hunit text time transformers unordered-containers
-        wai wai-app-static wai-extra wai-websockets warp webdriver
-        websockets yaml
-      ];
-      description = "Haskell to JavaScript compiler";
-      license = lib.licenses.mit;
-    }) {};
-
-  ghc-api-ghcjs = callPackage
-    ({ mkDerivation, alex, array, base, binary, bytestring, containers
-    , deepseq, directory, filepath, ghc-boot, ghc-boot-th, ghc-heap
-    , ghci-ghcjs, happy, hpc, process, lib, template-haskell-ghcjs
-    , terminfo, time, transformers, unix
-    }:
-    mkDerivation {
-      pname = "ghc-api-ghcjs";
-      version = "8.6.5";
-      src = configuredSrc + /lib/ghc-api-ghcjs;
-      libraryHaskellDepends = [
-        array base binary bytestring containers deepseq directory filepath
-        ghc-boot ghc-boot-th ghc-heap ghci-ghcjs hpc process
-        template-haskell-ghcjs terminfo time transformers unix
-      ];
-      libraryToolDepends = [ alex happy ];
-      homepage = "http://www.haskell.org/ghc/";
-      description = "The GHC API (customized for GHCJS)";
-      license = lib.licenses.bsd3;
-    }) {};
-
-  ghci-ghcjs = callPackage
-    ({ mkDerivation, array, base, binary, bytestring, containers
-    , deepseq, filepath, ghc-boot, ghc-boot-th, ghc-heap, lib
-    , template-haskell-ghcjs, transformers, unix
-    }:
-    mkDerivation {
-      pname = "ghci-ghcjs";
-      version = "8.6.1";
-      src = configuredSrc + /lib/ghci-ghcjs;
-      libraryHaskellDepends = [
-        array base binary bytestring containers deepseq filepath ghc-boot
-        ghc-boot-th ghc-heap template-haskell-ghcjs transformers unix
-      ];
-      description = "The library supporting GHC's interactive interpreter (customized for GHCJS)";
-      license = lib.licenses.bsd3;
-    }) {};
-
-  ghcjs-th = callPackage
-    ({ mkDerivation, base, binary, bytestring, containers, ghc-prim
-    , ghci-ghcjs, lib, template-haskell-ghcjs
-    }:
-    mkDerivation {
-      pname = "ghcjs-th";
-      version = "0.1.0.0";
-      src = configuredSrc + /lib/ghcjs-th;
-      libraryHaskellDepends = [
-        base binary bytestring containers ghc-prim ghci-ghcjs
-        template-haskell-ghcjs
-      ];
-      homepage = "https://github.com/ghcjs";
-      license = lib.licenses.mit;
-    }) {};
-
-  haddock-api-ghcjs = callPackage
-    ({ mkDerivation, array, base, bytestring, Cabal, containers, deepseq
-    , directory, filepath, ghc-api-ghcjs, ghc-boot, ghc-paths
-    , haddock-library-ghcjs, hspec, hspec-discover, QuickCheck, lib
-    , transformers, xhtml
-    }:
-    mkDerivation {
-      pname = "haddock-api-ghcjs";
-      version = "2.20.0";
-      src = configuredSrc + /lib/haddock-api-ghcjs;
-      enableSeparateDataOutput = true;
-      libraryHaskellDepends = [
-        array base bytestring Cabal containers deepseq directory filepath
-        ghc-api-ghcjs ghc-boot ghc-paths haddock-library-ghcjs transformers
-        xhtml
-      ];
-      testHaskellDepends = [
-        array base bytestring Cabal containers deepseq directory filepath
-        ghc-api-ghcjs ghc-boot ghc-paths haddock-library-ghcjs hspec
-        QuickCheck transformers xhtml
-      ];
-      testToolDepends = [ hspec-discover ];
-      homepage = "http://www.haskell.org/haddock/";
-      description = "A documentation-generation tool for Haskell libraries";
-      license = lib.licenses.bsd3;
-    }) {};
-
-  haddock-library-ghcjs = callPackage
-    ({ mkDerivation, base, base-compat, bytestring, containers, deepseq
-    , directory, filepath, haddock-library, hspec, hspec-discover
-    , optparse-applicative, parsec, QuickCheck, lib, text
-    , transformers, tree-diff
-    }:
-    mkDerivation {
-      pname = "haddock-library-ghcjs";
-      version = "1.6.0";
-      src = configuredSrc + /lib/haddock-library-ghcjs;
-      libraryHaskellDepends = [
-        base bytestring containers parsec text transformers
-      ];
-      testHaskellDepends = [
-        base base-compat bytestring containers deepseq directory filepath
-        haddock-library hspec optparse-applicative parsec QuickCheck text
-        transformers tree-diff
-      ];
-      testToolDepends = [ hspec-discover ];
-      homepage = "http://www.haskell.org/haddock/";
-      description = "Library exposing some functionality of Haddock";
-      license = lib.licenses.bsd3;
-    }) {};
-
-  template-haskell-ghcjs = callPackage
-    ({ mkDerivation, base, ghc-boot-th, pretty, lib }:
-    mkDerivation {
-      pname = "template-haskell-ghcjs";
-      version = "2.14.0.0";
-      src = configuredSrc + /lib/template-haskell-ghcjs;
-      libraryHaskellDepends = [ base ghc-boot-th pretty ];
-      description = "Support library for Template Haskell (customized for GHCJS)";
-      license = lib.licenses.bsd3;
-    }) {};
-
-}

pkgs/development/compilers/ghcjs-ng/README.md

@@ -1,21 +0,0 @@
-New build system for GHCJS 8.2
----
-
-`ghcjs-8.2` reworked the build system, and now comes with its own
-small package set of dependencies. This involves autogenerating
-several sources and cabal files, based on a GHC
-checkout. `callCabal2nix` is off limits, since we don't like "import
-from derivation" in nixpkgs. So there is a derivation that builds the
-nix expression that should be checked in whenever GHCJS is updated.
-
-Updating
----
-
-```
-$ nix-prefetch-git https://github.com/ghcjs/ghcjs --rev refs/heads/ghc-8.4 \
-  | jq '{ url, rev, fetchSubmodules, sha256 }' \
-  > 8.4/git.json
-$ cat $(nix-build ../../../.. -A haskell.compiler.ghcjs82.genStage0 --no-out-link) > 8.4/stage0.nix
-$ cabal2nix --compiler ghcjs git://github.com/ghcjs/ghcjs-base > ghcjs-base.nix
-```
-

pkgs/development/compilers/ghcjs-ng/common-overrides.nix

@@ -1,8 +0,0 @@
-{ haskellLib }:
-
-let inherit (haskellLib) addBuildTools appendConfigureFlag dontHaddock doJailbreak;
-in self: super: {
-  ghcjs = dontHaddock (appendConfigureFlag (doJailbreak super.ghcjs) "-fno-wrapper-install");
-  haddock-library-ghcjs = dontHaddock super.haddock-library-ghcjs;
-  system-fileio = doJailbreak super.system-fileio;
-}

pkgs/development/compilers/ghcjs-ng/configured-ghcjs-src.nix

@@ -1,51 +0,0 @@
-{ perl
-, autoconf
-, automake
-, python3
-, gcc
-, cabal-install
-, runCommand
-, lib
-, stdenv
-
-, ghc
-, happy
-, alex
-
-, ghcjsSrc
-}:
-
-runCommand "configured-ghcjs-src" {
-  nativeBuildInputs = [
-    perl
-    autoconf
-    automake
-    python3
-    ghc
-    happy
-    alex
-    cabal-install
-  ] ++ lib.optionals stdenv.isDarwin [
-    gcc # https://github.com/ghcjs/ghcjs/issues/663
-  ];
-  inherit ghcjsSrc;
-} ''
-  export HOME=$(pwd)
-  mkdir $HOME/.cabal
-  touch $HOME/.cabal/config
-  cp -r "$ghcjsSrc" "$out"
-  chmod -R +w "$out"
-  cd "$out"
-
-  # TODO: Find a better way to avoid impure version numbers
-  sed -i 's/RELEASE=NO/RELEASE=YES/' ghc/configure.ac
-
-  # TODO: How to actually fix this?
-  # Seems to work fine and produce the right files.
-  touch ghc/includes/ghcautoconf.h
-  mkdir -p ghc/compiler/vectorise
-  mkdir -p ghc/utils/haddock/haddock-library/vendor
-
-  patchShebangs .
-  ./utils/makePackages.sh copy
-''

pkgs/development/compilers/ghcjs-ng/mk-stage0.nix

@@ -1,25 +0,0 @@
-{ configuredSrc
-, runCommand
-, cabal2nix
-, yq
-}:
-
-runCommand "stage0.nix" {
-  buildInputs = [cabal2nix yq];
-} ''
-  (
-    printf '{ callPackage, configuredSrc }:\n\n{\n\n'
-    yq '.packages | .[]' ${configuredSrc}/stack.yaml -r | sed 's|^\.$|./.|' | sed 's|^\.||' | while read f; do
-      printf '  %s = callPackage\n' \
-        "$(find ${configuredSrc}/$f -name "*.cabal" -maxdepth 1 \
-          | xargs basename \
-          | sed 's/.cabal$//')"
-      printf '(%s) {};' \
-        "$(cabal2nix ${configuredSrc}/$f \
-          | sed 's|${configuredSrc}/|configuredSrc + |g')" \
-        | sed 's/^/    /'
-      printf '\n\n'
-    done
-    printf '}\n'
-  ) > $out
-''

pkgs/development/compilers/ghcjs/8.10/common-overrides.nix

@@ -0,0 +1,8 @@
+{ haskellLib }:
+
+let inherit (haskellLib) addBuildTools appendConfigureFlag dontHaddock doJailbreak;
+in self: super: {
+  ghcjs = doJailbreak (super.ghcjs.overrideScope (self: super: {
+    optparse-applicative = self.optparse-applicative_0_15_1_0;
+  }));
+}

pkgs/development/compilers/ghcjs/8.10/configured-ghcjs-src.nix

@@ -0,0 +1,60 @@
+{ perl
+, autoconf
+, automake
+, python3
+, gcc
+, cabal-install
+, runCommand
+, lib
+, stdenv
+
+, ghc
+, happy
+, alex
+
+, ghcjsSrc
+, version
+}:
+
+runCommand "configured-ghcjs-src" {
+  nativeBuildInputs = [
+    perl
+    autoconf
+    automake
+    python3
+    ghc
+    happy
+    alex
+    cabal-install
+  ] ++ lib.optionals stdenv.isDarwin [
+    gcc # https://github.com/ghcjs/ghcjs/issues/663
+  ];
+  inherit ghcjsSrc;
+} ''
+  export HOME=$(pwd)
+  mkdir $HOME/.cabal
+  touch $HOME/.cabal/config
+  cp -r "$ghcjsSrc" "$out"
+  chmod -R +w "$out"
+  cd "$out"
+
+  # TODO: Find a better way to avoid impure version numbers
+  sed -i 's/RELEASE=NO/RELEASE=YES/' ghc/configure.ac
+
+  # These files are needed by ghc-boot package, and these are generated by the
+  # make/hadrian build system when compiling ghc. Since we dont have access to
+  # the generated code of the ghc while it got built, here is a little hack to
+  # generate these again.
+  runhaskell ${./generate_host_version.hs}
+  mkdir -p utils/pkg-cache/ghc/libraries/ghc-boot/dist-install/build/GHC/Platform
+  mv Host.hs utils/pkg-cache/ghc/libraries/ghc-boot/dist-install/build/GHC/Platform/Host.hs
+  mv Version.hs utils/pkg-cache/ghc/libraries/ghc-boot/dist-install/build/GHC/Version.hs
+
+  # The ghcjs has the following hardcoded paths of lib dir in its code. Patching
+  # these to match the path expected by the nixpkgs's generic-builder, etc.
+  sed -i 's/libSubDir = "lib"/libSubDir = "lib\/ghcjs-${version}"/' src-bin/Boot.hs
+  sed -i 's@let libDir = takeDirectory haddockPath </> ".." </> "lib"@let libDir = takeDirectory haddockPath </> ".." </> "lib/ghcjs-${version}"@' src-bin/HaddockDriver.hs
+
+  patchShebangs .
+  ./utils/makePackages.sh copy
+''

pkgs/development/compilers/ghcjs/8.10/default.nix

@@ -17,15 +17,18 @@
 , lib
 , ghcjsDepOverrides ? (_:_:{})
 , haskell
+, linkFarm
+, buildPackages
 }:
 
 let
   passthru = {
     configuredSrc = callPackage ./configured-ghcjs-src.nix {
       inherit ghcjsSrc;
-      inherit (bootPkgs) ghc alex happy;
+      inherit (bootPkgs) ghc alex;
+      inherit (bootGhcjs) version;
+      happy = bootPkgs.happy_1_19_12;
     };
-    genStage0 = callPackage ./mk-stage0.nix { inherit (passthru) configuredSrc; };
     bootPkgs = bootPkgs.extend (lib.foldr lib.composeExtensions (_:_:{}) [
       (self: _: import stage0 {
         inherit (passthru) configuredSrc;
@@ -41,26 +44,22 @@ let
     targetPrefix = "";
     inherit bootGhcjs;
     inherit (bootGhcjs) version;
-    ghcVersion = bootPkgs.ghc.version;
     isGhcjs = true;
 
     enableShared = true;
 
     socket-io = pkgsHostHost.nodePackages."socket.io";
 
-    # Relics of the old GHCJS build system
-    stage1Packages = [];
-    mkStage2 = { callPackage }: {
-      # https://github.com/ghcjs/ghcjs-base/issues/110
-      # https://github.com/ghcjs/ghcjs-base/pull/111
-      ghcjs-base = haskell.lib.dontCheck (haskell.lib.doJailbreak (callPackage ./ghcjs-base.nix {}));
-    };
-
     haskellCompilerName = "ghcjs-${bootGhcjs.version}";
   };
 
   bootGhcjs = haskellLib.justStaticExecutables passthru.bootPkgs.ghcjs;
-  libexec = "${bootGhcjs}/libexec/${builtins.replaceStrings ["darwin" "i686"] ["osx" "i386"] stdenv.buildPlatform.system}-${passthru.bootPkgs.ghc.name}/${bootGhcjs.name}";
+
+  # This provides the stuff we need from the emsdk
+  emsdk = linkFarm "emsdk" [
+    { name = "upstream/bin"; path = buildPackages.clang + "/bin";}
+    { name = "upstream/emscripten"; path = buildPackages.emscripten + "/bin"; }
+  ];
 
 in stdenv.mkDerivation {
     name = bootGhcjs.name;
@@ -87,23 +86,29 @@ in stdenv.mkDerivation {
 
       mkdir -p $out/bin
       mkdir -p $out/lib/${bootGhcjs.name}
-      lndir ${libexec} $out/bin
+      lndir ${bootGhcjs}/bin $out/bin
+      chmod -R +w $out/bin
+      rm $out/bin/ghcjs-boot
+      cp ${bootGhcjs}/bin/ghcjs-boot $out/bin
+      rm $out/bin/haddock
+      cp ${bootGhcjs}/bin/haddock $out/bin
+      cp ${bootGhcjs}/bin/private-ghcjs-hsc2hs $out/bin/ghcjs-hsc2hs
+
+      wrapProgram $out/bin/ghcjs-boot --set ghcjs_libexecdir $out/bin
 
       wrapProgram $out/bin/ghcjs --add-flags "-B$out/lib/${bootGhcjs.name}"
-      wrapProgram $out/bin/haddock-ghcjs --add-flags "-B$out/lib/${bootGhcjs.name}"
+      wrapProgram $out/bin/haddock --add-flags "-B$out/lib/${bootGhcjs.name}"
       wrapProgram $out/bin/ghcjs-pkg --add-flags "--global-package-db=$out/lib/${bootGhcjs.name}/package.conf.d"
+      wrapProgram $out/bin/ghcjs-hsc2hs --add-flags "-I$out/lib/${bootGhcjs.name}/include --template=$out/lib/${bootGhcjs.name}/include/template-hsc.h"
 
-      env PATH=$out/bin:$PATH $out/bin/ghcjs-boot -j1 --with-ghcjs-bin $out/bin
+      env PATH=$out/bin:$PATH $out/bin/ghcjs-boot --with-emsdk=${emsdk} --no-haddock
     '';
 
-    # We hard code -j1 as a temporary workaround for
+    enableParallelBuilding = true;
-    # https://github.com/ghcjs/ghcjs/issues/654
-    # enableParallelBuilding = true;
 
     inherit passthru;
 
-    meta.platforms = passthru.bootPkgs.ghc.meta.platforms;
+    # The emscripten is broken on darwin
-    meta.maintainers = [lib.maintainers.elvishjerricco];
+    meta.platforms = lib.platforms.linux;
-    meta.hydraPlatforms = [];
+    meta.maintainers = with lib.maintainers; [ obsidian-systems-maintenance ];
-    meta.broken = true;    # https://hydra.nixos.org/build/129701778
   }

pkgs/development/compilers/ghcjs/8.10/generate_host_version.hs

@@ -0,0 +1,54 @@
+-- Generate the Host.hs and Version.hs as done by hadrian/src/Rules/Generate.hs
+
+import GHC.Platform.Host
+import GHC.Version
+
+main = do
+  writeFile "Version.hs" versionHs
+  writeFile "Host.hs" platformHostHs
+
+-- | Generate @Version.hs@ files.
+versionHs :: String
+versionHs = unlines
+        [ "module GHC.Version where"
+        , ""
+        , "import Prelude -- See Note [Why do we import Prelude here?]"
+        , ""
+        , "cProjectGitCommitId   :: String"
+        , "cProjectGitCommitId   = " ++ show cProjectGitCommitId
+        , ""
+        , "cProjectVersion       :: String"
+        , "cProjectVersion       = " ++ show cProjectVersion
+        , ""
+        , "cProjectVersionInt    :: String"
+        , "cProjectVersionInt    = " ++ show cProjectVersionInt
+        , ""
+        , "cProjectPatchLevel    :: String"
+        , "cProjectPatchLevel    = " ++ show cProjectPatchLevel
+        , ""
+        , "cProjectPatchLevel1   :: String"
+        , "cProjectPatchLevel1   = " ++ show cProjectPatchLevel1
+        , ""
+        , "cProjectPatchLevel2   :: String"
+        , "cProjectPatchLevel2   = " ++ show cProjectPatchLevel2
+        ]
+
+-- | Generate @Platform/Host.hs@ files.
+platformHostHs :: String
+platformHostHs = unlines
+        [ "module GHC.Platform.Host where"
+        , ""
+        , "import GHC.Platform"
+        , ""
+        , "cHostPlatformArch :: Arch"
+        , "cHostPlatformArch = " ++ show cHostPlatformArch
+        , ""
+        , "cHostPlatformOS   :: OS"
+        , "cHostPlatformOS   = " ++ show cHostPlatformOS
+        , ""
+        , "cHostPlatformMini :: PlatformMini"
+        , "cHostPlatformMini = PlatformMini"
+        , "  { platformMini_arch = cHostPlatformArch"
+        , "  , platformMini_os = cHostPlatformOS"
+        , "  }"
+        ]

pkgs/development/compilers/ghcjs/8.10/git.json

@@ -0,0 +1,6 @@
+{
+  "url": "https://github.com/obsidiansystems/ghcjs",
+  "rev": "9fc935f2c3ba6c33ec62eb83afc9f52a893eb68c",
+  "sha256": "sha256:063dmir39c4i1z8ypnmq86g1x2vhqndmdpzc4hyzsy5jjqcbx6i3",
+  "fetchSubmodules": true
+}

pkgs/development/compilers/ghcjs/8.10/stage0.nix

@@ -0,0 +1,77 @@
+{ callPackage, configuredSrc }:
+
+{
+
+  ghcjs = callPackage
+    ({ mkDerivation, aeson, alex, array, attoparsec, base, base16-bytestring
+     , base64-bytestring, binary, bytestring, Cabal, containers
+     , cryptohash, data-default, deepseq, directory, executable-path
+     , filepath, ghc-boot, ghc-boot-th, ghc-compact, ghc-heap, ghc-paths
+     , ghci, happy, hashable, hpc, http-types, HUnit, lens, lib
+     , lifted-base, mtl, network, optparse-applicative, parallel, parsec
+     , process, random, safe, shelly, split, stringsearch, syb, tar
+     , template-haskell, terminfo, test-framework, test-framework-hunit
+     , text, time, transformers, unix, unix-compat, unordered-containers
+     , vector, wai, wai-app-static, wai-extra, wai-websockets, warp
+     , webdriver, websockets, wl-pprint-text, xhtml, yaml
+     }:
+     mkDerivation {
+       pname = "ghcjs";
+       version = "8.10.7";
+       src = configuredSrc + /.;
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson array attoparsec base base16-bytestring base64-bytestring
+         binary bytestring Cabal containers cryptohash data-default deepseq
+         directory filepath ghc-boot ghc-boot-th ghc-compact ghc-heap
+         ghc-paths ghci hashable hpc lens mtl optparse-applicative parallel
+         parsec process safe split stringsearch syb template-haskell
+         terminfo text time transformers unix unordered-containers vector
+         wl-pprint-text yaml
+       ];
+       libraryToolDepends = [ alex happy ];
+       executableHaskellDepends = [
+         aeson array base binary bytestring Cabal containers deepseq
+         directory executable-path filepath ghc-boot lens mtl
+         optparse-applicative parsec process tar terminfo text time
+         transformers unix unix-compat unordered-containers vector xhtml
+         yaml
+       ];
+       testHaskellDepends = [
+         aeson base bytestring data-default deepseq directory filepath
+         http-types HUnit lens lifted-base network optparse-applicative
+         process random shelly test-framework test-framework-hunit text time
+         transformers unordered-containers wai wai-app-static wai-extra
+         wai-websockets warp webdriver websockets yaml
+       ];
+       description = "Haskell to JavaScript compiler";
+       license = lib.licenses.mit;
+     }) {};
+
+  ghcjs-th = callPackage
+    ({ mkDerivation, base, binary, bytestring, containers, ghc-prim
+    , ghci, lib, template-haskell
+    }:
+    mkDerivation {
+      pname = "ghcjs-th";
+      version = "0.1.0.0";
+      src = configuredSrc + /lib/ghcjs-th;
+      libraryHaskellDepends = [
+        base binary bytestring containers ghc-prim ghci template-haskell
+      ];
+      homepage = "http://github.com/ghcjs";
+      license = lib.licenses.mit;
+    }) {};
+
+  ghcjs-prim = callPackage
+    ({ mkDerivation, base, ghc-prim, lib }:
+    mkDerivation {
+      pname = "ghcjs-prim";
+      version = "0.1.1.0";
+      src = ./.;
+      libraryHaskellDepends = [ base ghc-prim ];
+      homepage = "http://github.com/ghcjs";
+      license = lib.licenses.mit;
+    }) {};
+}

pkgs/development/compilers/ghcjs/ghcjs-base.nix

@@ -8,11 +8,11 @@
 }:
 mkDerivation {
   pname = "ghcjs-base";
-  version = "0.2.0.0";
+  version = "0.2.0.3";
   src = fetchgit {
     url = "git://github.com/ghcjs/ghcjs-base";
-    sha256 = "0qr05m0djll3x38dhl85pl798arsndmwfhil8yklhb70lxrbvfrs";
+    sha256 = "15fdkjv0l7hpbbsn5238xxgzfdg61g666nzbv2sgxkwryn5rycv0";
-    rev = "01014ade3f8f5ae677df192d7c2a208bd795b96c";
+    rev = "85e31beab9beffc3ea91b954b61a5d04e708b8f2";
   };
   libraryHaskellDepends = [
     aeson attoparsec base binary bytestring containers deepseq dlist

pkgs/development/compilers/ghcjs/patches/vector-ghcjs-storable-set.patch

@@ -0,0 +1,14 @@
+diff --git a/Data/Vector/Storable/Mutable.hs b/Data/Vector/Storable/Mutable.hs
+index 8b538bc..2b74fce 100644
+--- a/Data/Vector/Storable/Mutable.hs
++++ b/Data/Vector/Storable/Mutable.hs
+@@ -197,7 +197,9 @@ storableSet (MVector n fp) x
+                   1 -> storableSetAsPrim n fp x (undefined :: Word8)
+                   2 -> storableSetAsPrim n fp x (undefined :: Word16)
+                   4 -> storableSetAsPrim n fp x (undefined :: Word32)
++#if !defined(ghcjs_HOST_OS)
+                   8 -> storableSetAsPrim n fp x (undefined :: Word64)
++#endif
+                   _ -> unsafeWithForeignPtr fp $ \p -> do
+                        poke p x
+ 

pkgs/development/haskell-modules/configuration-ghcjs.nix

@@ -0,0 +1,109 @@
+# GHCJS package fixes
+#
+# Please insert new packages *alphabetically*
+# in the OTHER PACKAGES section.
+{ pkgs, haskellLib }:
+
+let
+  removeLibraryHaskellDepends = pnames: depends:
+    builtins.filter (e: !(builtins.elem (e.pname or "") pnames)) depends;
+in
+
+with haskellLib;
+
+self: super:
+
+## GENERAL SETUP BASE PACKAGES
+{
+  inherit (self.ghc.bootPkgs)
+    jailbreak-cabal alex happy gtk2hs-buildtools rehoo hoogle;
+
+  ghcjs-base = dontCheck (self.callPackage ../compilers/ghcjs/ghcjs-base.nix {
+    fetchgit = pkgs.buildPackages.fetchgit;
+  });
+
+  # GHCJS does not ship with the same core packages as GHC.
+  # https://github.com/ghcjs/ghcjs/issues/676
+  stm = doJailbreak self.stm_2_5_0_0;
+  exceptions = dontCheck self.exceptions_0_10_4;
+
+## OTHER PACKAGES
+
+  # Runtime exception in tests, missing C API h$realloc
+  base-compat-batteries = dontCheck super.base-compat-batteries;
+
+  # nodejs crashes during test
+  ChasingBottoms = dontCheck super.ChasingBottoms;
+
+  # doctest doesn't work on ghcjs, but sometimes dontCheck doesn't seem to get rid of the dependency
+  doctest = pkgs.lib.warn "ignoring dependency on doctest" null;
+
+  ghcjs-dom = overrideCabal super.ghcjs-dom (drv: {
+    libraryHaskellDepends = with self; [
+      ghcjs-base ghcjs-dom-jsffi text transformers
+    ];
+    configureFlags = [ "-fjsffi" "-f-webkit" ];
+  });
+
+  ghcjs-dom-jsffi = overrideCabal super.ghcjs-dom-jsffi (drv: {
+    libraryHaskellDepends = (drv.libraryHaskellDepends or []) ++ [ self.ghcjs-base self.text ];
+    broken = false;
+  });
+
+  # https://github.com/Deewiant/glob/issues/39
+  Glob = dontCheck super.Glob;
+
+  # Test fails to compile during the hsc2hs stage
+  hashable = dontCheck super.hashable;
+
+  # uses doctest
+  http-types = dontCheck super.http-types;
+
+  jsaddle = overrideCabal super.jsaddle (drv: {
+    libraryHaskellDepends = (drv.libraryHaskellDepends or []) ++ [ self.ghcjs-base ];
+  });
+
+  # Tests hang, possibly some issue with tasty and race(async) usage in the nonTerminating tests
+  logict = dontCheck super.logict;
+
+  patch = dontCheck super.patch;
+
+  # TODO: tests hang
+  pcre-light = dontCheck super.pcre-light;
+
+  # Terminal test not supported on ghcjs
+  QuickCheck = dontCheck super.QuickCheck;
+
+  reflex = overrideCabal super.reflex (drv: {
+    libraryHaskellDepends = (drv.libraryHaskellDepends or []) ++ [ self.ghcjs-base ];
+  });
+
+  reflex-dom = overrideCabal super.reflex-dom (drv: {
+    libraryHaskellDepends = removeLibraryHaskellDepends ["jsaddle-webkit2gtk"] (drv.libraryHaskellDepends or []);
+  });
+
+  # https://github.com/dreixel/syb/issues/21
+  syb = dontCheck super.syb;
+
+  # nodejs crashes during test
+  scientific = dontCheck super.scientific;
+
+  # Tests use TH which gives error
+  tasty-quickcheck = dontCheck super.tasty-quickcheck;
+
+  temporary = dontCheck super.temporary;
+
+  # 2 tests fail, related to time precision
+  time-compat = dontCheck super.time-compat;
+
+  # TODO: The tests have a TH error, which has been fixed in ghc
+  # https://gitlab.haskell.org/ghc/ghc/-/issues/15481 but somehow the issue is
+  # still present here https://github.com/glguy/th-abstraction/issues/53
+  th-abstraction = dontCheck super.th-abstraction;
+
+  # https://github.com/haskell/vector/issues/410
+  vector = appendPatch super.vector (../compilers/ghcjs/patches/vector-ghcjs-storable-set.patch) ;
+
+  # Need hedgehog for tests, which fails to compile due to dep on concurrent-output
+  zenc = dontCheck super.zenc;
+}

pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml

@@ -102,6 +102,7 @@ extra-packages:
   - haddock-api == 2.23.*               # required on GHC < 8.10.x
   - haddock-library ==1.7.*             # required by stylish-cabal-0.5.0.0
   - happy == 1.19.9                     # for purescript
+  - happy == 1.19.12                    # for ghcjs
   - hinotify == 0.3.9                   # for xmonad-0.26: https://github.com/kolmodin/hinotify/issues/29
   - hlint < 3.3                         # We don‘t have ghc-lib-parser 9.0.X yet.
   - immortal == 0.2.2.1                 # required by Hasura 1.3.1, 2020-08-20

pkgs/development/haskell-modules/hackage-packages.nix

@@ -116710,6 +116710,22 @@ self: {
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "happy_1_19_12" = callPackage
+    ({ mkDerivation, array, base, containers, mtl, process }:
+     mkDerivation {
+       pname = "happy";
+       version = "1.19.12";
+       sha256 = "03xlmq6qmdx4zvzw8bp33kd9g7yvcq5cz4wg50xilw812kj276pv";
+       isLibrary = false;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       executableHaskellDepends = [ array base containers mtl ];
+       testHaskellDepends = [ base process ];
+       description = "Happy is a parser generator for Haskell";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "happy" = callPackage
     ({ mkDerivation, array, base, containers, mtl, process }:
      mkDerivation {

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

@@ -1,4 +1,4 @@
-{ lib, supportedGhcVersions ? [ "884" "8104" ], stdenv, haskellPackages
+{ lib, supportedGhcVersions ? [ "884" "8104" "8107" ], stdenv, haskellPackages
 , haskell }:
 #
 # The recommended way to override this package is

pkgs/os-specific/darwin/xattr/default.nix

@@ -0,0 +1,73 @@
+{ lib
+, stdenv
+, fetchzip
+, buildPythonPackage
+, python
+, ed
+, unifdef
+}:
+
+buildPythonPackage rec {
+  pname = "xattr";
+  version = "61.60.1";
+
+  src = fetchzip rec {
+    url = "https://opensource.apple.com/tarballs/python_modules/python_modules-${version}.tar.gz";
+    sha256 = "19kydl7w4vpdi7zmfd5z9vjkq24jfk2cv4j0pppw69j06czhdwwi";
+  };
+
+  sourceRoot = "${src.name}/Modules/xattr-0.6.4";
+  format = "other";
+
+  nativeBuildInputs = [
+    ed
+    unifdef
+  ];
+
+  makeFlags = [
+    "OBJROOT=$(PWD)"
+    "DSTROOT=${placeholder "out"}"
+    "OSL=${placeholder "doc"}/share/xattr/OpenSourceLicenses"
+    "OSV=${placeholder "doc"}/share/xattr/OpenSourceVersions"
+  ];
+
+  # need to use `out` instead of `bin` since buildPythonPackage ignores the latter
+  outputs = [ "out" "doc" "python" ];
+
+  # We need to patch a reference to gnutar in an included Makefile
+  postUnpack = ''
+    chmod u+w $sourceRoot/..
+  '';
+
+  postPatch = ''
+    substituteInPlace ../Makefile.inc --replace gnutar tar
+    substituteInPlace Makefile --replace "/usr" ""
+  '';
+
+  preInstall = ''
+    # prevent setup.py from trying to download setuptools
+    sed -i xattr-*/setup.py -e '/ez_setup/d'
+
+    # create our custom target dirs we patch in
+    mkdir -p "$doc/share/xattr/"OpenSource{Licenses,Versions}
+    mkdir -p "$python/lib/${python.libPrefix}"
+  '';
+
+  # move python package to its own output to reduce clutter
+  postInstall = ''
+    mv "$out/lib/python" "$python/${python.sitePackages}"
+    rmdir "$out/lib"
+  '';
+
+  makeWrapperArgs = [
+    "--prefix" "PYTHONPATH" ":" "${placeholder "python"}/${python.sitePackages}"
+  ];
+
+  meta = with lib; {
+    description = "Display and manipulate extended attributes";
+    license = [ licenses.psfl licenses.mit ]; # see $doc/share/xattr/OpenSourceLicenses
+    maintainers = [ maintainers.sternenseemann ];
+    homepage = "https://opensource.apple.com/source/python_modules/";
+    platforms = lib.platforms.darwin;
+  };
+}

pkgs/top-level/darwin-packages.nix

@@ -156,6 +156,8 @@ impure-cmds // appleSourcePackages // chooseLibs // {
 
   usr-include = callPackage ../os-specific/darwin/usr-include { };
 
+  xattr = pkgs.python3Packages.callPackage ../os-specific/darwin/xattr { };
+
   inherit (pkgs.callPackages ../os-specific/darwin/xcode { })
     xcode_8_1 xcode_8_2
     xcode_9_1 xcode_9_2 xcode_9_4 xcode_9_4_1

pkgs/top-level/haskell-packages.nix

@@ -6,6 +6,8 @@ let
     "ghc865Binary"
     "ghc8102Binary"
     "ghc8102BinaryMinimal"
+    "ghcjs"
+    "ghcjs810"
     "integer-simple"
     "native-bignum"
     "ghcHEAD"
@@ -75,6 +77,20 @@ in {
       buildLlvmPackages = buildPackages.llvmPackages_9;
       llvmPackages = pkgs.llvmPackages_9;
     };
+    ghc8107 = callPackage ../development/compilers/ghc/8.10.7.nix {
+      # aarch64 ghc865Binary gets SEGVs due to haskell#15449 or similar
+      bootPkgs = if stdenv.isAarch64 || stdenv.isAarch32 then
+          packages.ghc8102BinaryMinimal
+        else
+          packages.ghc865Binary;
+      inherit (buildPackages.python3Packages) sphinx;
+      # Need to use apple's patched xattr until
+      # https://github.com/xattr/xattr/issues/44 and
+      # https://github.com/xattr/xattr/issues/55 are solved.
+      inherit (buildPackages.darwin) xattr;
+      buildLlvmPackages = buildPackages.llvmPackages_9;
+      llvmPackages = pkgs.llvmPackages_9;
+    };
     ghc901 = callPackage ../development/compilers/ghc/9.0.1.nix {
       # aarch64 ghc8102Binary exceeds max output size on hydra
       bootPkgs = if stdenv.isAarch64 || stdenv.isAarch32 then
@@ -93,6 +109,13 @@ in {
       libffi = pkgs.libffi;
     };
 
+    ghcjs = compiler.ghcjs810;
+    ghcjs810 = callPackage ../development/compilers/ghcjs/8.10 {
+      bootPkgs = packages.ghc8107;
+      ghcjsSrcJson = ../development/compilers/ghcjs/8.10/git.json;
+      stage0 = ../development/compilers/ghcjs/8.10/stage0.nix;
+    };
+
     # The integer-simple attribute set contains all the GHC compilers
     # build with integer-simple instead of integer-gmp.
     integer-simple = let
@@ -148,6 +171,11 @@ in {
       ghc = bh.compiler.ghc8104;
       compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.10.x.nix { };
     };
+    ghc8107 = callPackage ../development/haskell-modules {
+      buildHaskellPackages = bh.packages.ghc8107;
+      ghc = bh.compiler.ghc8107;
+      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.10.x.nix { };
+    };
     ghc901 = callPackage ../development/haskell-modules {
       buildHaskellPackages = bh.packages.ghc901;
       ghc = bh.compiler.ghc901;
@@ -159,6 +187,14 @@ in {
       compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-head.nix { };
     };
 
+    ghcjs = packages.ghcjs810;
+    ghcjs810 = callPackage ../development/haskell-modules rec {
+      buildHaskellPackages = ghc.bootPkgs;
+      ghc = bh.compiler.ghcjs810;
+      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.10.x.nix { };
+      packageSetConfig = callPackage ../development/haskell-modules/configuration-ghcjs.nix { };
+    };
+
     # The integer-simple attribute set contains package sets for all the GHC compilers
     # using integer-simple instead of integer-gmp.
     integer-simple = let

pkgs/top-level/release-haskell.nix

@@ -47,6 +47,7 @@ let
   all = with compilerNames; [
     ghc884
     ghc8104
+    ghc8107
     ghc901
   ];
 
@@ -206,11 +207,11 @@ let
       # package sets (like Cabal, jailbreak-cabal) are
       # working as expected.
       cabal-install = all;
-      Cabal_3_4_0_0 = with compilerNames; [ ghc884 ghc8104 ];
+      Cabal_3_6_0_0 = with compilerNames; [ ghc884 ghc8104 ghc8107 ];
       funcmp = all;
       # Doesn't currently work on ghc-9.0:
       # https://github.com/haskell/haskell-language-server/issues/297
-      haskell-language-server = with compilerNames; [ ghc884 ghc8104 ];
+      haskell-language-server = with compilerNames; [ ghc884 ghc8104 ghc8107 ];
       hoogle = all;
       hsdns = all;
       jailbreak-cabal = all;