Merge branch 'master' into support-cabal-doctest

Author: hamishmack

README.org

@@ -77,7 +77,7 @@ cabal new-repl your-package-name:library:your-package-name
 CI pushes to [[https://cachix.org][cachix]] so you can benefit from the cache
 if you pin a combination of =haskell.nix= and =nixpkgs= built by CI.
 
-You'll need to configure the [[https://nix-tools.cachix.org][nix-tools cachix]]
+You'll need to configure the [[https://iohk.cachix.org][iohk cachix]]
 as a =substituter= for =nix= and add the public key found at the url to
 =trusted-public-keys=.
 

builder/comp-builder.nix

@@ -26,7 +26,7 @@
 , dontStrip ? component.dontStrip
 
 , enableStatic ? component.enableStatic
-, enableShared ? component.enableShared && !stdenv.hostPlatform.isWindows && !stdenv.hostPlatform.useiOSPrebuilt
+, enableShared ? component.enableShared && !haskellLib.isCrossHost
 , enableDeadCodeElimination ? component.enableDeadCodeElimination
 
 # Options for Haddock generation
@@ -106,11 +106,20 @@ let
       (enableFeature enableExecutableProfiling "executable-profiling")
       (enableFeature enableStatic "static")
       (enableFeature enableShared "shared")
+    ] ++ lib.optionals (stdenv.hostPlatform.isMusl && (haskellLib.isExecutableType componentId)) [
+      # These flags will make sure the resulting executable is statically linked.
+      # If it uses other libraries it may be necessary for to add more
+      # `--ghc-option=-optl=-L` options to the `configurationFlags` of the
+      # component.
+      "--disable-executable-dynamic"
+      "--ghc-option=-optl=-pthread"
+      "--ghc-option=-optl=-static"
+      "--ghc-option=-optl=-L${gmp.override { withStatic = true; }}/lib"
     ] ++ lib.optional enableSeparateDataOutput "--datadir=$data/share/${ghc.name}"
       ++ lib.optional doHaddock' "--docdir=${docdir "$doc"}"
       ++ lib.optional (enableLibraryProfiling || enableExecutableProfiling) "--profiling-detail=${profilingDetail}"
       ++ lib.optional stdenv.hostPlatform.isLinux (enableFeature enableDeadCodeElimination "split-sections")
-      ++ lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) (
+      ++ lib.optionals haskellLib.isCrossHost (
         map (arg: "--hsc2hs-option=" + arg) (["--cross-compile"] ++ lib.optionals (stdenv.hostPlatform.isWindows) ["--via-asm"])
         ++ lib.optional (package.buildType == "Configure") "--configure-option=--host=${stdenv.hostPlatform.config}" )
       ++ component.configureFlags
@@ -142,7 +151,7 @@ let
 
   doHaddock' = doHaddock
     && (haskellLib.isLibrary componentId)
-    && stdenv.hostPlatform == stdenv.buildPlatform;
+    && !haskellLib.isCrossHost;
 
   exeExt = lib.optionalString stdenv.hostPlatform.isWindows ".exe";
   exeName = componentId.cname + exeExt;

builder/default.nix

@@ -39,10 +39,14 @@ let
 
 
   hoogleLocal = let
-    nixpkgsHoogleLocal = import (pkgs.path + /pkgs/development/haskell-modules/hoogle.nix);
-  in { packages ? [], hoogle ? pkgs.haskell-nix.haskellPackages.hoogle.components.exes.hoogle }:
+    # Use the latest default nixpkgs hoogle.nix, as the 19.03 one does not work with cross compilers
+    nixpkgsHoogleLocal = import ((import ../nixpkgs {}).path + /pkgs/development/haskell-modules/hoogle.nix);
+  in { packages ? [], hoogle ? pkgs.buildPackages.haskell-nix.haskellPackages.hoogle.components.exes.hoogle }:
     haskellLib.weakCallPackage pkgs nixpkgsHoogleLocal {
-      ghc = pkgs.haskell-nix.ghc;
+      # For musl we can use haddock from the buildGHC
+      ghc = if stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl
+        then ghc.buildGHC
+        else ghc;
       inherit packages hoogle;
     };
 

builder/ghc-for-component-wrapper.nix

@@ -15,14 +15,19 @@
 }:
 
 let
-  inherit (configFiles) ghcCommand ghcCommandCaps packageCfgDir;
+  inherit (configFiles) targetPrefix ghcCommand ghcCommandCaps packageCfgDir;
   libDir         = "$out/${configFiles.libDir}";
   docDir         = "$out/share/doc/ghc/html";
+  # For musl we can use haddock from the buildGHC
+  haddock        = if stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl
+    then ghc.buildGHC
+    else ghc;
 
 in runCommand "${componentName}-${ghc.name}-env" {
   preferLocalBuild = true;
   passthru = {
     inherit (ghc) version meta;
+    inherit targetPrefix;
     baseGhc = ghc;
   };
 } (
@@ -62,7 +67,7 @@ in runCommand "${componentName}-${ghc.name}-env" {
       fi
     done
 
-    for prg in runghc runhaskell; do
+    for prg in "${targetPrefix}runghc" "${targetPrefix}runhaskell"; do
       if [[ -x "${ghc}/bin/$prg" ]]; then
         rm -f $out/bin/$prg
         makeWrapper ${ghc}/bin/$prg $out/bin/$prg                           \
@@ -75,9 +80,9 @@ in runCommand "${componentName}-${ghc.name}-env" {
     done
 
     # Wrap haddock, if the base GHC provides it.
-    if [[ -x "${ghc}/bin/haddock" ]]; then
+    if [[ -x "${haddock}/bin/haddock" ]]; then
       rm -f $out/bin/haddock
-      makeWrapper ${ghc}/bin/haddock $out/bin/haddock    \
+      makeWrapper ${haddock}/bin/haddock $out/bin/haddock    \
         --add-flags '"-B$NIX_${ghcCommandCaps}_LIBDIR"'  \
         --set "NIX_${ghcCommandCaps}_LIBDIR" "${libDir}"
     fi

builder/make-config-files.nix

@@ -66,7 +66,8 @@ let
 in { identifier, component, fullName, flags ? {} }:
   # Filters out only library packages that for this GHC target
   # TODO investigate why this is needed
-  let libDeps = lib.filter (p: p.configFiles.targetPrefix == ghc.targetPrefix)
+  # TODO find out why p ? configFiles helps (for instance for `R1909.aarch64-unknown-linux-gnu.tests.cabal-22.run.x86_64-linux`)
+  let libDeps = lib.filter (p: (p ? configFiles) && p.configFiles.targetPrefix == ghc.targetPrefix)
         (map getLibComponent component.depends);
       cfgFiles =
         let xs = map

builder/shell-for.nix

@@ -12,6 +12,8 @@
 , ... } @ args:
 
 let
+  # TODO find out why hoogle index creation can be made to work for cross compilers
+  withHoogle' = withHoogle && !haskellLib.isCrossHost;
   selected = packages hsPkgs;
   additionalSelected = additional hsPkgs;
   selectedConfigs = map (p: p.components.all.config) selected;
@@ -53,7 +55,7 @@ let
   ghcEnv = ghcForComponent {
     inherit configFiles;
     componentName = name;
-    postInstall = lib.optionalString withHoogle ''
+    postInstall = lib.optionalString withHoogle' ''
       ln -s ${hoogleIndex}/bin/hoogle $out/bin
     '';
   };
@@ -79,7 +81,7 @@ in
 
     buildInputs = systemInputs
       ++ mkDrvArgs.buildInputs or []
-      ++ lib.optional withHoogle hoogleIndex;
+      ++ lib.optional withHoogle' hoogleIndex;
     nativeBuildInputs = [ ghcEnv ]
       ++ nativeBuildInputs
       ++ mkDrvArgs.nativeBuildInputs or [];

compiler/ghc/default.nix

@@ -3,7 +3,7 @@
 # haskell.nix ships its own version of the ghc expression as it needs more
 # control over the expression to isolate it against varying <nixpkgs> and
 # allow us to customize it to the way haskell.nix works.
-{ stdenv, targetPackages
+{ stdenv, haskell-nix, targetPackages
 
 # build-tools
 , bootPkgs
@@ -33,15 +33,24 @@
 
 , # 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
+  enableShared ? !haskell-nix.haskellLib.isCrossTarget
 
-, # Whetherto build terminfo.
-  enableTerminfo ? !stdenv.targetPlatform.isWindows
+, # Whetherto build terminfo.  Musl fails to build terminfo as ncurses seems to be linked to glibc
+  enableTerminfo ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.isMusl
 
 , # What flavour to build. An empty string indicates no
   # specific flavour and falls back to ghc default values.
-  ghcFlavour ? stdenv.lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform)
-    (if useLLVM then "quick-cross" else "perf-cross-ncg")
+  ghcFlavour ? stdenv.lib.optionalString haskell-nix.haskellLib.isCrossTarget (
+    if useLLVM
+      then (
+        # TODO check if the issues with qemu and Aarch32 persist. See
+        # https://github.com/input-output-hk/haskell.nix/pull/411/commits/1986264683067198e7fdc1d665351622b664712e
+        if stdenv.targetPlatform.isAarch32
+          then "quick-cross"
+          else "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/
@@ -59,9 +68,15 @@ assert !enableIntegerSimple -> gmp != null;
 
 let
   inherit (stdenv) buildPlatform hostPlatform targetPlatform;
+  inherit (haskell-nix.haskellLib) isCrossTarget;
 
   inherit (bootPkgs) ghc;
 
+  # TODO check if this posible fix for segfaults works or not.
+  libffiStaticEnabled = if libffi == null || !stdenv.targetPlatform.isMusl
+    then libffi
+    else targetPackages.libffi.overrideAttrs (old: { dontDisableStatic = true; });
+
   # TODO(@Ericson2314) Make unconditional
   targetPrefix = stdenv.lib.optionalString
     (targetPlatform != hostPlatform)
@@ -75,8 +90,9 @@ let
     DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}
     INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}
   '' + stdenv.lib.optionalString (targetPlatform != hostPlatform) ''
-    Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"}
     CrossCompilePrefix = ${targetPrefix}
+  '' + stdenv.lib.optionalString isCrossTarget ''
+    Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"}
     HADDOCK_DOCS = NO
     BUILD_SPHINX_HTML = NO
     BUILD_SPHINX_PDF = NO
@@ -88,11 +104,19 @@ let
   '' + stdenv.lib.optionalString useLLVM ''
     GhcStage2HcOpts += -fast-llvm
     GhcLibHcOpts += -fast-llvm
+  '' + stdenv.lib.optionalString (!enableTerminfo) ''
+    WITH_TERMINFO=NO
+  ''
+  # While split sections are now enabled by default in ghc 8.8 for windows,
+  # the seem to lead to `too many sections` errors when building base for
+  # profiling.
+  + stdenv.lib.optionalString targetPlatform.isWindows ''
+    SplitSections = NO
   '';
 
   # Splicer will pull out correct variations
   libDeps = platform: stdenv.lib.optional enableTerminfo [ ncurses ]
-    ++ [libffi]
+    ++ [libffiStaticEnabled]
     ++ stdenv.lib.optional (!enableIntegerSimple) gmp
     ++ stdenv.lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv;
 
@@ -184,7 +208,7 @@ in let configured-src = stdenv.mkDerivation (rec {
         configureFlags = [
             "--datadir=$doc/share/doc/ghc"
             "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib"
-        ] ++ stdenv.lib.optionals (libffi != null) ["--with-system-libffi" "--with-ffi-includes=${targetPackages.libffi.dev}/include" "--with-ffi-libraries=${targetPackages.libffi.out}/lib"
+        ] ++ stdenv.lib.optionals (libffiStaticEnabled != null) ["--with-system-libffi" "--with-ffi-includes=${libffiStaticEnabled.dev}/include" "--with-ffi-libraries=${libffiStaticEnabled.out}/lib"
         ] ++ stdenv.lib.optional (!enableIntegerSimple) [
             "--with-gmp-includes=${targetPackages.gmp.dev}/include" "--with-gmp-libraries=${targetPackages.gmp.out}/lib"
         ] ++ stdenv.lib.optional (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [
@@ -298,7 +322,12 @@ in let configured-src = stdenv.mkDerivation (rec {
     for i in "$out/bin/"*; do
       test ! -h $i || continue
       egrep --quiet '^#!' <(head -n 1 $i) || continue
-      sed -i -e '2i export PATH="$PATH:${stdenv.lib.makeBinPath [ targetPackages.stdenv.cc.bintools coreutils ]}"' $i
+      # The ghcprog fixup is for musl (where runhaskell script just needs to point to the correct
+      # ghc program to work).
+      sed -i \
+        -e '2i export PATH="$PATH:${stdenv.lib.makeBinPath [ targetPackages.stdenv.cc.bintools coreutils ]}"' \
+        -e 's/ghcprog="ghc-/ghcprog="${targetPrefix}ghc-/' \
+        $i
     done
   '' + installDeps targetPrefix;
 

docs/dev/pkg-map.md

@@ -28,11 +28,6 @@ nixpkgs.overlays = [
 ];
 ```
 
-### Haskell component/package configuration
-
-This is not implemented yet, tracked by issue
-[#198](https://github.com/input-output-hk/haskell.nix/issues/198).
-
 ### Mapping in Haskell.nix
 
 Alternatively, if the name is commonly used, an alias can be added to

hackage-src.json

@@ -1,7 +1,7 @@
 {
   "url": "https://github.com/input-output-hk/hackage.nix",
-  "rev": "d589a07318584bf4d8ff4b46711a9ef4dbade3c1",
-  "date": "2020-02-18T01:11:02+00:00",
-  "sha256": "1c5np00nm8rdh8yvl643fly5mk1a26g7f722z2jkny91kbwb98l7",
+  "rev": "18646b3296a596d712c4af6dd2b04de0e947cbbe",
+  "date": "2020-03-04T01:10:41+00:00",
+  "sha256": "11wlnjb4lcrnf4zkswincdbw41lry2gr3hmzb93pqdnv335vyfzx",
   "fetchSubmodules": false
 }

lib/default.nix

@@ -151,9 +151,18 @@ with haskellLib;
   #     to: tests.mypackage.unit-tests
   #
   collectComponents = group: packageSel: haskellPackages:
-    (lib.mapAttrs (_: package: package.components.${group} // { recurseForDerivations = true; })
-     (lib.filterAttrs (name: package: (package.isHaskell or false) && packageSel package) haskellPackages))
-    // { recurseForDerivations = true; };
+    let packageToComponents = name: package:
+          # look for the components with this group if there are any
+          let components = package.components.${group} or {};
+          # set recurseForDerivations unless it's a derivation itself (e.g. the "library" component) or an empty set
+          in if lib.isDerivation components || components == {}
+             then components
+             else pkgs.recurseIntoAttrs components;
+        packageFilter = name: package: (package.isHaskell or false) && packageSel package;
+        filteredPkgs = lib.filterAttrs packageFilter haskellPackages;
+        # at this point we can filter out packages that don't have any of the given kind of component
+        packagesByComponent = lib.filterAttrs (_: components: components != {}) (lib.mapAttrs packageToComponents filteredPkgs);
+    in pkgs.recurseIntoAttrs packagesByComponent;
 
   # Equivalent to collectComponents with (_: true) as selection function.
   # Useful for pre-filtered package-set.
@@ -180,4 +189,15 @@ with haskellLib;
   check = import ./check.nix {
     inherit stdenv lib haskellLib srcOnly;
   };
+
+  # Use `isCrossHost` to identify when we are cross compiling and
+  # the code we are producing will not run on the build system
+  # without an emulator.
+  # In most cases we do not want to treat musl as a cross compiler.
+  # For instance when building ghc we want to include ghci.
+  isCrossHost = stdenv.hostPlatform != stdenv.buildPlatform
+    && !(stdenv.buildPlatform.isLinux && stdenv.hostPlatform.isMusl);
+  # This is the same as isCrossHost but for use when building ghc itself
+  isCrossTarget = stdenv.targetPlatform != stdenv.hostPlatform
+    && !(stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl);
 }