2018-01-04 21:18:02 +00:00
|
|
|
{ stdenv, buildPackages, buildHaskellPackages, ghc
|
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
|
|
|
, jailbreak-cabal, hscolour, cpphs, nodejs
|
|
|
|
, ghcWithHoogle, ghcWithPackages
|
2017-08-06 19:46:49 +00:00
|
|
|
}:
|
2017-09-10 19:36:48 +00:00
|
|
|
|
|
|
|
let
|
2018-08-20 18:43:41 +00:00
|
|
|
isCross = stdenv.buildPlatform != stdenv.hostPlatform;
|
2017-09-10 19:36:48 +00:00
|
|
|
inherit (buildPackages)
|
|
|
|
fetchurl removeReferencesTo
|
|
|
|
pkgconfig coreutils gnugrep gnused glibcLocales;
|
|
|
|
in
|
2015-01-07 19:31:32 +00:00
|
|
|
|
2015-01-10 08:12:37 +00:00
|
|
|
{ pname
|
2016-01-24 22:12:03 +00:00
|
|
|
, dontStrip ? (ghc.isGhcjs or false)
|
2015-03-24 19:09:49 +00:00
|
|
|
, version, revision ? null
|
2015-01-10 08:12:37 +00:00
|
|
|
, sha256 ? null
|
2015-01-07 19:31:32 +00:00
|
|
|
, src ? fetchurl { url = "mirror://hackage/${pname}-${version}.tar.gz"; inherit sha256; }
|
2016-06-09 21:27:57 +00:00
|
|
|
, buildDepends ? [], setupHaskellDepends ? [], libraryHaskellDepends ? [], executableHaskellDepends ? []
|
2015-01-16 19:54:35 +00:00
|
|
|
, buildTarget ? ""
|
2017-02-28 09:27:29 +00:00
|
|
|
, buildTools ? [], libraryToolDepends ? [], executableToolDepends ? [], testToolDepends ? [], benchmarkToolDepends ? []
|
2015-01-10 08:12:37 +00:00
|
|
|
, configureFlags ? []
|
2018-03-17 08:55:39 +00:00
|
|
|
, buildFlags ? []
|
2019-02-20 14:58:28 +00:00
|
|
|
, haddockFlags ? []
|
2015-01-10 08:12:37 +00:00
|
|
|
, description ? ""
|
2018-03-15 00:00:00 +00:00
|
|
|
, doCheck ? !isCross && stdenv.lib.versionOlder "7.4" ghc.version
|
2017-09-19 13:36:29 +00:00
|
|
|
, doBenchmark ? false
|
2015-01-09 18:35:17 +00:00
|
|
|
, doHoogle ? true
|
2019-12-19 13:41:11 +00:00
|
|
|
, doHaddockQuickjump ? doHoogle && stdenv.lib.versionAtLeast ghc.version "8.6"
|
2015-01-10 08:12:37 +00:00
|
|
|
, editedCabalFile ? null
|
2020-07-21 15:39:12 +00:00
|
|
|
# aarch64 outputs otherwise exceed 2GB limit
|
|
|
|
, enableLibraryProfiling ? !(ghc.isGhcjs or stdenv.targetPlatform.isAarch64 or false)
|
2015-08-06 14:13:10 +00:00
|
|
|
, enableExecutableProfiling ? false
|
2018-08-27 13:50:37 +00:00
|
|
|
, profilingDetail ? "exported-functions"
|
2016-11-18 15:44:53 +00:00
|
|
|
# TODO enable shared libs for cross-compiling
|
2018-03-16 20:44:17 +00:00
|
|
|
, enableSharedExecutables ? false
|
2018-06-20 21:57:35 +00:00
|
|
|
, enableSharedLibraries ? (ghc.enableShared or false)
|
2018-03-16 20:55:56 +00:00
|
|
|
, enableDeadCodeElimination ? (!stdenv.isDarwin) # TODO: use -dead_strip for darwin
|
2018-08-20 18:43:41 +00:00
|
|
|
, enableStaticLibraries ? !stdenv.hostPlatform.isWindows
|
|
|
|
, enableHsc2hsViaAsm ? stdenv.hostPlatform.isWindows && stdenv.lib.versionAtLeast ghc.version "8.4"
|
2015-06-17 14:40:21 +00:00
|
|
|
, extraLibraries ? [], librarySystemDepends ? [], executableSystemDepends ? []
|
2017-06-23 01:43:03 +00:00
|
|
|
# On macOS, statically linking against system frameworks is not supported;
|
|
|
|
# see https://developer.apple.com/library/content/qa/qa1118/_index.html
|
|
|
|
# They must be propagated to the environment of any executable linking with the library
|
|
|
|
, libraryFrameworkDepends ? [], executableFrameworkDepends ? []
|
2018-05-28 19:48:16 +00:00
|
|
|
, homepage ? "https://hackage.haskell.org/package/${pname}"
|
2019-11-24 23:07:20 +00:00
|
|
|
, platforms ? with stdenv.lib.platforms; all # GHC can cross-compile
|
2018-03-20 15:51:37 +00:00
|
|
|
, hydraPlatforms ? null
|
2015-01-10 08:12:37 +00:00
|
|
|
, hyperlinkSource ? true
|
|
|
|
, isExecutable ? false, isLibrary ? !isExecutable
|
|
|
|
, jailbreak ? false
|
|
|
|
, license
|
2020-07-21 15:39:12 +00:00
|
|
|
, enableParallelBuilding ? true
|
2015-01-07 19:31:32 +00:00
|
|
|
, maintainers ? []
|
2017-02-14 15:17:40 +00:00
|
|
|
, doCoverage ? false
|
2017-06-22 15:41:24 +00:00
|
|
|
, doHaddock ? !(ghc.isHaLVM or false)
|
2015-01-07 19:31:32 +00:00
|
|
|
, passthru ? {}
|
2017-02-28 09:27:29 +00:00
|
|
|
, pkgconfigDepends ? [], libraryPkgconfigDepends ? [], executablePkgconfigDepends ? [], testPkgconfigDepends ? [], benchmarkPkgconfigDepends ? []
|
2017-06-23 01:43:03 +00:00
|
|
|
, testDepends ? [], testHaskellDepends ? [], testSystemDepends ? [], testFrameworkDepends ? []
|
|
|
|
, benchmarkDepends ? [], benchmarkHaskellDepends ? [], benchmarkSystemDepends ? [], benchmarkFrameworkDepends ? []
|
2015-01-10 08:12:37 +00:00
|
|
|
, testTarget ? ""
|
|
|
|
, broken ? false
|
2016-02-18 03:07:32 +00:00
|
|
|
, preCompileBuildDriver ? "", postCompileBuildDriver ? ""
|
2015-01-19 15:24:12 +00:00
|
|
|
, preUnpack ? "", postUnpack ? ""
|
2015-04-05 07:58:37 +00:00
|
|
|
, patches ? [], patchPhase ? "", prePatch ? "", postPatch ? ""
|
2015-01-10 08:12:37 +00:00
|
|
|
, preConfigure ? "", postConfigure ? ""
|
|
|
|
, preBuild ? "", postBuild ? ""
|
2015-08-14 19:22:40 +00:00
|
|
|
, installPhase ? "", preInstall ? "", postInstall ? ""
|
2015-01-10 08:12:37 +00:00
|
|
|
, checkPhase ? "", preCheck ? "", postCheck ? ""
|
|
|
|
, preFixup ? "", postFixup ? ""
|
2015-09-09 17:58:28 +00:00
|
|
|
, shellHook ? ""
|
2015-01-13 21:15:29 +00:00
|
|
|
, coreSetup ? false # Use only core packages to build Setup.hs.
|
2015-01-15 21:36:01 +00:00
|
|
|
, useCpphs ? false
|
2017-09-10 19:36:48 +00:00
|
|
|
, hardeningDisable ? stdenv.lib.optional (ghc.isHaLVM or false) "all"
|
2019-03-29 08:10:42 +00:00
|
|
|
, enableSeparateBinOutput ? false
|
2017-07-25 01:22:19 +00:00
|
|
|
, enableSeparateDataOutput ? false
|
|
|
|
, enableSeparateDocOutput ? doHaddock
|
2018-12-15 18:31:08 +00:00
|
|
|
, # Don't fail at configure time if there are multiple versions of the
|
|
|
|
# same package in the (recursive) dependencies of the package being
|
|
|
|
# built. Will delay failures, if any, to compile time.
|
|
|
|
allowInconsistentDependencies ? false
|
2020-05-07 10:48:51 +00:00
|
|
|
, maxBuildCores ? 16 # more cores usually don't improve performance: https://ghc.haskell.org/trac/ghc/ticket/9221
|
2019-04-11 03:43:16 +00:00
|
|
|
, # If set to true, this builds a pre-linked .o file for this Haskell library.
|
|
|
|
# This can make it slightly faster to load this library into GHCi, but takes
|
|
|
|
# extra disk space and compile time.
|
|
|
|
enableLibraryForGhci ? false
|
2015-03-27 15:11:18 +00:00
|
|
|
} @ args:
|
2015-01-07 19:31:32 +00:00
|
|
|
|
2015-03-24 19:09:49 +00:00
|
|
|
assert editedCabalFile != null -> revision != null;
|
2015-01-07 19:31:32 +00:00
|
|
|
|
2018-03-11 09:13:25 +00:00
|
|
|
# --enable-static does not work on windows. This is a bug in GHC.
|
|
|
|
# --enable-static will pass -staticlib to ghc, which only works for mach-o and elf.
|
2018-08-20 18:43:41 +00:00
|
|
|
assert stdenv.hostPlatform.isWindows -> enableStaticLibraries == false;
|
2018-03-11 09:13:25 +00:00
|
|
|
|
2015-01-07 19:31:32 +00:00
|
|
|
let
|
|
|
|
|
2017-02-14 15:17:40 +00:00
|
|
|
inherit (stdenv.lib) optional optionals optionalString versionOlder versionAtLeast
|
2019-06-16 19:59:06 +00:00
|
|
|
concatStringsSep enableFeature optionalAttrs;
|
2015-01-07 19:31:32 +00:00
|
|
|
|
2015-03-13 03:20:56 +00:00
|
|
|
isGhcjs = ghc.isGhcjs or false;
|
2017-02-04 17:19:14 +00:00
|
|
|
isHaLVM = ghc.isHaLVM or false;
|
|
|
|
packageDbFlag = if isGhcjs || isHaLVM || versionOlder "7.6" ghc.version
|
2016-02-19 16:45:45 +00:00
|
|
|
then "package-db"
|
|
|
|
else "package-conf";
|
|
|
|
|
2018-01-04 21:18:02 +00:00
|
|
|
# GHC used for building Setup.hs
|
|
|
|
#
|
|
|
|
# Same as our GHC, unless we're cross, in which case it is native GHC with the
|
|
|
|
# same version, or ghcjs, in which case its the ghc used to build ghcjs.
|
|
|
|
nativeGhc = buildHaskellPackages.ghc;
|
2016-02-19 16:45:45 +00:00
|
|
|
nativePackageDbFlag = if versionOlder "7.6" nativeGhc.version
|
|
|
|
then "package-db"
|
|
|
|
else "package-conf";
|
2015-03-13 03:20:56 +00:00
|
|
|
|
2017-12-05 08:36:08 +00:00
|
|
|
# the target dir for haddock documentation
|
2018-06-22 10:50:54 +00:00
|
|
|
docdir = docoutput: docoutput + "/share/doc/" + pname + "-" + version;
|
2017-12-05 08:36:08 +00:00
|
|
|
|
2019-03-29 08:10:42 +00:00
|
|
|
binDir = if enableSeparateBinOutput then "$bin/bin" else "$out/bin";
|
|
|
|
|
2019-04-05 17:49:48 +00:00
|
|
|
newCabalFileUrl = "mirror://hackage/${pname}-${version}/revision/${revision}.cabal";
|
2015-01-16 19:54:35 +00:00
|
|
|
newCabalFile = fetchurl {
|
2015-04-01 11:52:21 +00:00
|
|
|
url = newCabalFileUrl;
|
2015-01-16 19:54:35 +00:00
|
|
|
sha256 = editedCabalFile;
|
2015-03-24 19:09:49 +00:00
|
|
|
name = "${pname}-${version}-r${revision}.cabal";
|
2015-01-16 19:54:35 +00:00
|
|
|
};
|
|
|
|
|
2015-01-07 19:31:32 +00:00
|
|
|
defaultSetupHs = builtins.toFile "Setup.hs" ''
|
|
|
|
import Distribution.Simple
|
|
|
|
main = defaultMain
|
|
|
|
'';
|
|
|
|
|
2020-01-28 23:44:11 +00:00
|
|
|
# This awk expression transforms a package conf file like
|
|
|
|
#
|
|
|
|
# author: John Doe <john-doe@example.com>
|
|
|
|
# description:
|
|
|
|
# The purpose of this library is to do
|
|
|
|
# foo and bar among other things
|
|
|
|
#
|
|
|
|
# into a more easily processeable form:
|
|
|
|
#
|
|
|
|
# author: John Doe <john-doe@example.com>
|
|
|
|
# description: The purpose of this library is to do foo and bar among other things
|
|
|
|
unprettyConf = builtins.toFile "unpretty-cabal-conf.awk" ''
|
|
|
|
/^[^ ]+:/ {
|
|
|
|
# When the line starts with a new field, terminate the previous one with a newline
|
|
|
|
if (started == 1) print ""
|
|
|
|
# to strip leading spaces
|
|
|
|
$1=$1
|
|
|
|
printf "%s", $0
|
|
|
|
started=1
|
|
|
|
}
|
|
|
|
|
|
|
|
/^ +/ {
|
|
|
|
# to strip leading spaces
|
|
|
|
$1=$1
|
|
|
|
printf " %s", $0
|
|
|
|
}
|
|
|
|
|
|
|
|
# Terminate the final field with a newline
|
|
|
|
END { print "" }
|
|
|
|
'';
|
|
|
|
|
2016-11-18 15:44:53 +00:00
|
|
|
crossCabalFlags = [
|
2019-12-25 18:14:48 +00:00
|
|
|
"--with-ghc=${ghcCommand}"
|
2017-09-10 19:36:48 +00:00
|
|
|
"--with-ghc-pkg=${ghc.targetPrefix}ghc-pkg"
|
2019-12-25 19:34:40 +00:00
|
|
|
# Pass the "wrong" C compiler rather than none at all so packages that just
|
|
|
|
# use the C preproccessor still work, see
|
|
|
|
# https://github.com/haskell/cabal/issues/6466 for details.
|
|
|
|
"--with-gcc=${(if stdenv.hasCC then stdenv else buildPackages.stdenv).cc.targetPrefix}cc"
|
2019-11-24 23:07:20 +00:00
|
|
|
] ++ optionals stdenv.hasCC [
|
2017-09-22 23:09:39 +00:00
|
|
|
"--with-ld=${stdenv.cc.bintools.targetPrefix}ld"
|
2018-09-18 22:49:58 +00:00
|
|
|
"--with-ar=${stdenv.cc.bintools.targetPrefix}ar"
|
2018-03-05 13:33:49 +00:00
|
|
|
# use the one that comes with the cross compiler.
|
|
|
|
"--with-hsc2hs=${ghc.targetPrefix}hsc2hs"
|
2017-09-22 23:09:39 +00:00
|
|
|
"--with-strip=${stdenv.cc.bintools.targetPrefix}strip"
|
2018-03-05 13:33:49 +00:00
|
|
|
] ++ optionals (!isHaLVM) [
|
|
|
|
"--hsc2hs-option=--cross-compile"
|
|
|
|
(optionalString enableHsc2hsViaAsm "--hsc2hs-option=--via-asm")
|
|
|
|
];
|
2016-11-18 15:44:53 +00:00
|
|
|
|
2020-05-07 10:48:51 +00:00
|
|
|
parallelBuildingFlags = "-j$NIX_BUILD_CORES" + optionalString stdenv.isLinux " +RTS -A64M -RTS";
|
|
|
|
|
2016-11-18 15:44:53 +00:00
|
|
|
crossCabalFlagsString =
|
|
|
|
stdenv.lib.optionalString isCross (" " + stdenv.lib.concatStringsSep " " crossCabalFlags);
|
|
|
|
|
2018-03-17 08:55:39 +00:00
|
|
|
buildFlagsString = optionalString (buildFlags != []) (" " + concatStringsSep " " buildFlags);
|
|
|
|
|
2015-01-07 19:31:32 +00:00
|
|
|
defaultConfigureFlags = [
|
2019-03-29 08:10:42 +00:00
|
|
|
"--verbose"
|
|
|
|
"--prefix=$out"
|
|
|
|
"--libdir=\\$prefix/lib/\\$compiler"
|
|
|
|
"--libsubdir=\\$abi/\\$libname"
|
2017-12-05 08:36:08 +00:00
|
|
|
(optionalString enableSeparateDataOutput "--datadir=$data/share/${ghc.name}")
|
|
|
|
(optionalString enableSeparateDocOutput "--docdir=${docdir "$doc"}")
|
2019-11-24 23:07:20 +00:00
|
|
|
] ++ optionals stdenv.hasCC [
|
2017-02-04 17:19:14 +00:00
|
|
|
"--with-gcc=$CC" # Clang won't work without that extra information.
|
2019-11-24 23:07:20 +00:00
|
|
|
] ++ [
|
2015-01-16 19:54:35 +00:00
|
|
|
"--package-db=$packageConfDir"
|
2017-12-05 08:36:08 +00:00
|
|
|
(optionalString (enableSharedExecutables && stdenv.isLinux) "--ghc-option=-optl=-Wl,-rpath=$out/lib/${ghc.name}/${pname}-${version}")
|
2015-01-16 19:54:35 +00:00
|
|
|
(optionalString (enableSharedExecutables && stdenv.isDarwin) "--ghc-option=-optl=-Wl,-headerpad_max_install_names")
|
2020-05-07 10:48:51 +00:00
|
|
|
(optionalString enableParallelBuilding "--ghc-options=${parallelBuildingFlags}")
|
2015-06-17 14:40:21 +00:00
|
|
|
(optionalString useCpphs "--with-cpphs=${cpphs}/bin/cpphs --ghc-options=-cpp --ghc-options=-pgmP${cpphs}/bin/cpphs --ghc-options=-optP--cpp")
|
2018-08-20 18:43:41 +00:00
|
|
|
(enableFeature (enableDeadCodeElimination && !stdenv.hostPlatform.isAarch32 && !stdenv.hostPlatform.isAarch64 && (versionAtLeast "8.0.1" ghc.version)) "split-objs")
|
2015-01-07 19:31:32 +00:00
|
|
|
(enableFeature enableLibraryProfiling "library-profiling")
|
2018-03-29 04:28:05 +00:00
|
|
|
(optionalString ((enableExecutableProfiling || enableLibraryProfiling) && versionOlder "8" ghc.version) "--profiling-detail=${profilingDetail}")
|
2016-01-17 09:54:04 +00:00
|
|
|
(enableFeature enableExecutableProfiling (if versionOlder ghc.version "8" then "executable-profiling" else "profiling"))
|
2015-01-07 19:31:32 +00:00
|
|
|
(enableFeature enableSharedLibraries "shared")
|
2017-02-14 15:17:40 +00:00
|
|
|
(optionalString (versionAtLeast ghc.version "7.10") (enableFeature doCoverage "coverage"))
|
2018-03-16 20:38:55 +00:00
|
|
|
(optionalString (versionOlder "8.4" ghc.version) (enableFeature enableStaticLibraries "static"))
|
2015-03-13 03:20:56 +00:00
|
|
|
(optionalString (isGhcjs || versionOlder "7.4" ghc.version) (enableFeature enableSharedExecutables "executable-dynamic"))
|
|
|
|
(optionalString (isGhcjs || versionOlder "7" ghc.version) (enableFeature doCheck "tests"))
|
2018-09-11 15:24:26 +00:00
|
|
|
(enableFeature doBenchmark "benchmarks")
|
2018-03-16 20:38:55 +00:00
|
|
|
"--enable-library-vanilla" # TODO: Should this be configurable?
|
2019-04-02 05:36:23 +00:00
|
|
|
(enableFeature enableLibraryForGhci "library-for-ghci")
|
2017-01-02 16:19:28 +00:00
|
|
|
] ++ optionals (enableDeadCodeElimination && (stdenv.lib.versionOlder "8.0.1" ghc.version)) [
|
|
|
|
"--ghc-option=-split-sections"
|
2018-07-14 01:41:39 +00:00
|
|
|
] ++ optionals dontStrip [
|
|
|
|
"--disable-library-stripping"
|
|
|
|
"--disable-executable-stripping"
|
2015-03-13 03:20:56 +00:00
|
|
|
] ++ optionals isGhcjs [
|
|
|
|
"--ghcjs"
|
2016-11-18 15:44:53 +00:00
|
|
|
] ++ optionals isCross ([
|
2018-08-20 18:43:41 +00:00
|
|
|
"--configure-option=--host=${stdenv.hostPlatform.config}"
|
2019-03-29 08:10:42 +00:00
|
|
|
] ++ crossCabalFlags
|
|
|
|
) ++ optionals enableSeparateBinOutput ["--bindir=${binDir}"];
|
2015-01-07 19:31:32 +00:00
|
|
|
|
2015-01-16 19:54:35 +00:00
|
|
|
setupCompileFlags = [
|
2018-06-13 17:44:16 +00:00
|
|
|
(optionalString (!coreSetup) "-${nativePackageDbFlag}=$setupPackageConfDir")
|
2020-05-07 10:48:51 +00:00
|
|
|
(optionalString enableParallelBuilding (parallelBuildingFlags))
|
|
|
|
"-threaded" # https://github.com/haskell/cabal/issues/2398
|
|
|
|
"-rtsopts" # allow us to pass RTS flags to the generated Setup executable
|
2015-01-16 19:54:35 +00:00
|
|
|
];
|
2015-01-07 19:31:32 +00:00
|
|
|
|
2018-09-17 21:11:59 +00:00
|
|
|
isHaskellPkg = x: x ? isHaskellLibrary;
|
2015-01-10 12:23:04 +00:00
|
|
|
|
2015-07-23 20:16:16 +00:00
|
|
|
allPkgconfigDepends = pkgconfigDepends ++ libraryPkgconfigDepends ++ executablePkgconfigDepends ++
|
2017-09-19 13:36:29 +00:00
|
|
|
optionals doCheck testPkgconfigDepends ++ optionals doBenchmark benchmarkPkgconfigDepends;
|
2015-07-23 20:16:16 +00:00
|
|
|
|
2018-06-19 13:40:37 +00:00
|
|
|
depsBuildBuild = [ nativeGhc ];
|
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
|
|
|
collectedToolDepends =
|
|
|
|
buildTools ++ libraryToolDepends ++ executableToolDepends ++
|
|
|
|
optionals doCheck testToolDepends ++
|
|
|
|
optionals doBenchmark benchmarkToolDepends;
|
|
|
|
nativeBuildInputs =
|
|
|
|
[ ghc removeReferencesTo ] ++ optional (allPkgconfigDepends != []) pkgconfig ++
|
|
|
|
setupHaskellDepends ++ collectedToolDepends;
|
2017-06-23 01:43:03 +00:00
|
|
|
propagatedBuildInputs = buildDepends ++ libraryHaskellDepends ++ executableHaskellDepends ++ libraryFrameworkDepends;
|
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
|
|
|
otherBuildInputsHaskell =
|
|
|
|
optionals doCheck (testDepends ++ testHaskellDepends) ++
|
|
|
|
optionals doBenchmark (benchmarkDepends ++ benchmarkHaskellDepends);
|
|
|
|
otherBuildInputsSystem =
|
|
|
|
extraLibraries ++ librarySystemDepends ++ executableSystemDepends ++ executableFrameworkDepends ++
|
|
|
|
allPkgconfigDepends ++
|
|
|
|
optionals doCheck (testSystemDepends ++ testFrameworkDepends) ++
|
|
|
|
optionals doBenchmark (benchmarkSystemDepends ++ benchmarkFrameworkDepends);
|
|
|
|
# TODO next rebuild just define as `otherBuildInputsHaskell ++ otherBuildInputsSystem`
|
|
|
|
otherBuildInputs =
|
|
|
|
extraLibraries ++ librarySystemDepends ++ executableSystemDepends ++ executableFrameworkDepends ++
|
|
|
|
allPkgconfigDepends ++
|
|
|
|
optionals doCheck (testDepends ++ testHaskellDepends ++ testSystemDepends ++ testFrameworkDepends) ++
|
|
|
|
optionals doBenchmark (benchmarkDepends ++ benchmarkHaskellDepends ++ benchmarkSystemDepends ++ benchmarkFrameworkDepends);
|
2015-01-16 19:54:35 +00:00
|
|
|
|
2016-02-18 08:11:42 +00:00
|
|
|
setupCommand = "./Setup";
|
2018-01-04 21:18:02 +00:00
|
|
|
|
2017-01-22 22:05:19 +00:00
|
|
|
ghcCommand' = if isGhcjs then "ghcjs" else "ghc";
|
2017-09-10 19:36:48 +00:00
|
|
|
ghcCommand = "${ghc.targetPrefix}${ghcCommand'}";
|
2015-03-13 03:20:56 +00:00
|
|
|
|
2018-01-04 21:18:02 +00:00
|
|
|
nativeGhcCommand = "${nativeGhc.targetPrefix}ghc";
|
|
|
|
|
2018-06-12 17:54:26 +00:00
|
|
|
buildPkgDb = ghcName: packageConfDir: ''
|
generic Haskell builder: don't copy packages from GHC
In order to build the package databases that we will use when compiling
a Haskell package, we iterate over the relevant dependencies, and if
they contain a package db, we copy its contents over.
So far so good, except when one of those dependencies is GHC. This
doesn't happen ordinarily, but it will happen when we construct the
package database for compiling `Setup.hs`. This is compiled for the
build architecture, so we get the build deps, including both the native
and the cross GHC (if there is one).
In this case, we end up copying the packages from the GHC's package
database. This is at best unnecessary, since we will get those packages
from the GHC when we compile with it.
At worst, however, this is semantically questionable. We can end up
having multiple copies of e.g. Cabal with the same version, but
(potentially) different contents. At the moment, GHC will expose one of
these at semi-random depending on which one it looks at "first".
However, there is a MR open [in
GHC](https://gitlab.haskell.org/ghc/ghc/merge_requests/545) which as a
side effect will instead expose both, leading to ambiguous module
warnings (which is not unreasonable, since it *is* ambiguous).
So what can we do about it? The simplest solution is just to not copy
the package databases from GHC. GHC is special in this regard, so I
think it's okay to treat it specially.
This PR should have no effect on anything now, but will prevent any
breakage when/if the GHC patch lands.
Closes https://github.com/NixOS/nixpkgs/pull/57706.
2019-03-15 17:15:20 +00:00
|
|
|
# If this dependency has a package database, then copy the contents of it,
|
|
|
|
# unless it is one of our GHCs. These can appear in our dependencies when
|
|
|
|
# we are doing native builds, and they have package databases in them, but
|
|
|
|
# we do not want to copy them over.
|
|
|
|
#
|
|
|
|
# We don't need to, since those packages will be provided by the GHC when
|
|
|
|
# we compile with it, and doing so can result in having multiple copies of
|
|
|
|
# e.g. Cabal in the database with the same name and version, which is
|
|
|
|
# ambiguous.
|
|
|
|
if [ -d "$p/lib/${ghcName}/package.conf.d" ] && [ "$p" != "${ghc}" ] && [ "$p" != "${nativeGhc}" ]; then
|
2018-06-12 17:54:26 +00:00
|
|
|
cp -f "$p/lib/${ghcName}/package.conf.d/"*.conf ${packageConfDir}/
|
2018-03-01 05:35:48 +00:00
|
|
|
continue
|
|
|
|
fi
|
|
|
|
'';
|
2018-09-17 21:20:29 +00:00
|
|
|
in stdenv.lib.fix (drv:
|
2015-07-23 20:16:16 +00:00
|
|
|
|
|
|
|
assert allPkgconfigDepends != [] -> pkgconfig != null;
|
|
|
|
|
2015-01-10 08:12:37 +00:00
|
|
|
stdenv.mkDerivation ({
|
2015-08-29 21:29:17 +00:00
|
|
|
name = "${pname}-${version}";
|
2015-01-07 19:31:32 +00:00
|
|
|
|
2019-03-29 08:10:42 +00:00
|
|
|
outputs = [ "out" ]
|
|
|
|
++ (optional enableSeparateDataOutput "data")
|
|
|
|
++ (optional enableSeparateDocOutput "doc")
|
|
|
|
++ (optional enableSeparateBinOutput "bin");
|
2017-07-25 01:22:19 +00:00
|
|
|
setOutputFlags = false;
|
|
|
|
|
2015-03-27 15:11:18 +00:00
|
|
|
pos = builtins.unsafeGetAttrPos "pname" args;
|
|
|
|
|
2015-01-16 19:54:35 +00:00
|
|
|
prePhases = ["setupCompilerEnvironmentPhase"];
|
2015-02-25 19:15:26 +00:00
|
|
|
preConfigurePhases = ["compileBuildDriverPhase"];
|
2015-01-16 19:54:35 +00:00
|
|
|
preInstallPhases = ["haddockPhase"];
|
|
|
|
|
2015-01-07 19:31:32 +00:00
|
|
|
inherit src;
|
|
|
|
|
2018-06-19 13:40:37 +00:00
|
|
|
inherit depsBuildBuild nativeBuildInputs;
|
2018-07-27 04:24:22 +00:00
|
|
|
buildInputs = otherBuildInputs ++ optionals (!isLibrary) propagatedBuildInputs;
|
|
|
|
propagatedBuildInputs = optionals isLibrary propagatedBuildInputs;
|
2015-01-07 19:31:32 +00:00
|
|
|
|
2015-01-16 19:54:35 +00:00
|
|
|
LANG = "en_US.UTF-8"; # GHC needs the locale configured during the Haddock phase.
|
2015-01-07 19:31:32 +00:00
|
|
|
|
2015-02-25 19:15:26 +00:00
|
|
|
prePatch = optionalString (editedCabalFile != null) ''
|
2015-04-01 11:52:21 +00:00
|
|
|
echo "Replace Cabal file with edited version from ${newCabalFileUrl}."
|
2015-02-25 19:15:26 +00:00
|
|
|
cp ${newCabalFile} ${pname}.cabal
|
2015-04-04 13:12:43 +00:00
|
|
|
'' + prePatch;
|
|
|
|
|
|
|
|
postPatch = optionalString jailbreak ''
|
2015-04-01 12:02:46 +00:00
|
|
|
echo "Run jailbreak-cabal to lift version restrictions on build inputs."
|
2017-12-05 08:36:08 +00:00
|
|
|
${jailbreak-cabal}/bin/jailbreak-cabal ${pname}.cabal
|
2015-04-04 13:12:43 +00:00
|
|
|
'' + postPatch;
|
2015-02-25 19:15:26 +00:00
|
|
|
|
2015-01-16 19:54:35 +00:00
|
|
|
setupCompilerEnvironmentPhase = ''
|
2019-01-08 21:40:12 +00:00
|
|
|
NIX_BUILD_CORES=$(( NIX_BUILD_CORES < ${toString maxBuildCores} ? NIX_BUILD_CORES : ${toString maxBuildCores} ))
|
2015-01-16 19:54:35 +00:00
|
|
|
runHook preSetupCompilerEnvironment
|
2015-01-07 19:31:32 +00:00
|
|
|
|
2015-04-01 12:02:46 +00:00
|
|
|
echo "Build with ${ghc}."
|
2018-07-27 04:24:22 +00:00
|
|
|
${optionalString (isLibrary && hyperlinkSource) "export PATH=${hscolour}/bin:$PATH"}
|
2015-01-07 19:31:32 +00:00
|
|
|
|
2018-03-01 05:35:48 +00:00
|
|
|
setupPackageConfDir="$TMPDIR/setup-package.conf.d"
|
|
|
|
mkdir -p $setupPackageConfDir
|
2015-02-23 10:45:49 +00:00
|
|
|
packageConfDir="$TMPDIR/package.conf.d"
|
2015-01-10 08:12:37 +00:00
|
|
|
mkdir -p $packageConfDir
|
|
|
|
|
2015-01-16 19:54:35 +00:00
|
|
|
setupCompileFlags="${concatStringsSep " " setupCompileFlags}"
|
|
|
|
configureFlags="${concatStringsSep " " defaultConfigureFlags} $configureFlags"
|
2018-03-01 05:35:48 +00:00
|
|
|
''
|
|
|
|
# We build the Setup.hs on the *build* machine, and as such should only add
|
|
|
|
# dependencies for the build machine.
|
|
|
|
#
|
|
|
|
# pkgs* arrays defined in stdenv/setup.hs
|
2018-06-13 17:44:16 +00:00
|
|
|
+ ''
|
2018-03-01 05:35:48 +00:00
|
|
|
for p in "''${pkgsBuildBuild[@]}" "''${pkgsBuildHost[@]}" "''${pkgsBuildTarget[@]}"; do
|
2018-06-12 17:54:26 +00:00
|
|
|
${buildPkgDb nativeGhc.name "$setupPackageConfDir"}
|
2018-03-01 05:35:48 +00:00
|
|
|
done
|
|
|
|
${nativeGhcCommand}-pkg --${nativePackageDbFlag}="$setupPackageConfDir" recache
|
2018-06-13 17:44:16 +00:00
|
|
|
''
|
|
|
|
# For normal components
|
2018-03-01 05:35:48 +00:00
|
|
|
+ ''
|
2017-08-12 16:41:49 +00:00
|
|
|
for p in "''${pkgsHostHost[@]}" "''${pkgsHostTarget[@]}"; do
|
2018-06-12 17:54:26 +00:00
|
|
|
${buildPkgDb ghc.name "$packageConfDir"}
|
2018-06-19 14:52:10 +00:00
|
|
|
if [ -d "$p/include" ]; then
|
|
|
|
configureFlags+=" --extra-include-dirs=$p/include"
|
|
|
|
fi
|
|
|
|
if [ -d "$p/lib" ]; then
|
|
|
|
configureFlags+=" --extra-lib-dirs=$p/lib"
|
|
|
|
fi
|
|
|
|
''
|
|
|
|
# It is not clear why --extra-framework-dirs does work fine on Linux
|
2018-08-20 18:43:41 +00:00
|
|
|
+ optionalString (!stdenv.buildPlatform.isDarwin || versionAtLeast nativeGhc.version "8.0") ''
|
2018-06-19 14:52:10 +00:00
|
|
|
if [[ -d "$p/Library/Frameworks" ]]; then
|
|
|
|
configureFlags+=" --extra-framework-dirs=$p/Library/Frameworks"
|
|
|
|
fi
|
|
|
|
'' + ''
|
2015-01-07 19:31:32 +00:00
|
|
|
done
|
2018-03-20 22:26:00 +00:00
|
|
|
''
|
|
|
|
# only use the links hack if we're actually building dylibs. otherwise, the
|
|
|
|
# "dynamic-library-dirs" point to nonexistent paths, and the ln command becomes
|
|
|
|
# "ln -s $out/lib/links", which tries to recreate the links dir and fails
|
2018-03-17 06:42:28 +00:00
|
|
|
+ (optionalString (stdenv.isDarwin && (enableSharedLibraries || enableSharedExecutables)) ''
|
2017-08-06 22:05:18 +00:00
|
|
|
# Work around a limit in the macOS Sierra linker on the number of paths
|
2017-05-05 16:53:08 +00:00
|
|
|
# referenced by any one dynamic library:
|
|
|
|
#
|
2017-08-06 22:05:18 +00:00
|
|
|
# Create a local directory with symlinks of the *.dylib (macOS shared
|
2017-05-05 16:53:08 +00:00
|
|
|
# libraries) from all the dependencies.
|
2017-12-05 08:36:08 +00:00
|
|
|
local dynamicLinksDir="$out/lib/links"
|
2017-05-05 16:53:08 +00:00
|
|
|
mkdir -p $dynamicLinksDir
|
2020-01-28 23:44:11 +00:00
|
|
|
|
|
|
|
# Unprettify all package conf files before reading/writing them
|
|
|
|
for d in "$packageConfDir/"*; do
|
|
|
|
# gawk -i inplace seems to strip the last newline
|
|
|
|
gawk -f ${unprettyConf} "$d" > tmp
|
|
|
|
mv tmp "$d"
|
|
|
|
done
|
|
|
|
|
|
|
|
for d in $(grep '^dynamic-library-dirs:' "$packageConfDir"/* | cut -d' ' -f2- | tr ' ' '\n' | sort -u); do
|
2020-02-15 16:37:24 +00:00
|
|
|
for lib in "$d/"*.{dylib,so}; do
|
2020-05-14 13:26:01 +00:00
|
|
|
# Allow overwriting because C libs can be pulled in multiple times.
|
|
|
|
ln -sf "$lib" "$dynamicLinksDir"
|
2020-01-28 23:44:11 +00:00
|
|
|
done
|
2017-05-05 16:53:08 +00:00
|
|
|
done
|
|
|
|
# Edit the local package DB to reference the links directory.
|
2017-07-18 18:57:24 +00:00
|
|
|
for f in "$packageConfDir/"*.conf; do
|
2020-01-28 23:44:11 +00:00
|
|
|
sed -i "s,dynamic-library-dirs: .*,dynamic-library-dirs: $dynamicLinksDir," "$f"
|
2017-05-05 16:53:08 +00:00
|
|
|
done
|
|
|
|
'') + ''
|
2015-03-13 03:20:56 +00:00
|
|
|
${ghcCommand}-pkg --${packageDbFlag}="$packageConfDir" recache
|
2015-01-16 19:54:35 +00:00
|
|
|
|
|
|
|
runHook postSetupCompilerEnvironment
|
|
|
|
'';
|
|
|
|
|
|
|
|
compileBuildDriverPhase = ''
|
|
|
|
runHook preCompileBuildDriver
|
|
|
|
|
2015-01-07 19:31:32 +00:00
|
|
|
for i in Setup.hs Setup.lhs ${defaultSetupHs}; do
|
|
|
|
test -f $i && break
|
|
|
|
done
|
|
|
|
|
2015-01-16 19:54:35 +00:00
|
|
|
echo setupCompileFlags: $setupCompileFlags
|
2018-06-12 17:54:26 +00:00
|
|
|
${nativeGhcCommand} $setupCompileFlags --make -o Setup -odir $TMPDIR -hidir $TMPDIR $i
|
2015-01-16 19:54:35 +00:00
|
|
|
|
|
|
|
runHook postCompileBuildDriver
|
|
|
|
'';
|
|
|
|
|
2017-02-02 16:44:11 +00:00
|
|
|
# Cabal takes flags like `--configure-option=--host=...` instead
|
|
|
|
configurePlatforms = [];
|
2017-09-10 19:36:48 +00:00
|
|
|
inherit configureFlags;
|
|
|
|
|
2015-01-16 19:54:35 +00:00
|
|
|
configurePhase = ''
|
|
|
|
runHook preConfigure
|
|
|
|
|
2015-01-10 08:12:37 +00:00
|
|
|
unset GHC_PACKAGE_PATH # Cabal complains if this variable is set during configure.
|
2015-01-16 19:54:35 +00:00
|
|
|
|
|
|
|
echo configureFlags: $configureFlags
|
2015-05-06 19:56:02 +00:00
|
|
|
${setupCommand} configure $configureFlags 2>&1 | ${coreutils}/bin/tee "$NIX_BUILD_TOP/cabal-configure.log"
|
2018-12-15 18:31:08 +00:00
|
|
|
${stdenv.lib.optionalString (!allowInconsistentDependencies) ''
|
|
|
|
if ${gnugrep}/bin/egrep -q -z 'Warning:.*depends on multiple versions' "$NIX_BUILD_TOP/cabal-configure.log"; then
|
|
|
|
echo >&2 "*** abort because of serious configure-time warning from Cabal"
|
|
|
|
exit 1
|
|
|
|
fi
|
|
|
|
''}
|
2015-01-10 08:12:37 +00:00
|
|
|
export GHC_PACKAGE_PATH="$packageConfDir:"
|
2015-01-07 19:31:32 +00:00
|
|
|
|
|
|
|
runHook postConfigure
|
|
|
|
'';
|
|
|
|
|
|
|
|
buildPhase = ''
|
|
|
|
runHook preBuild
|
2018-03-17 08:55:39 +00:00
|
|
|
${setupCommand} build ${buildTarget}${crossCabalFlagsString}${buildFlagsString}
|
2015-01-07 19:31:32 +00:00
|
|
|
runHook postBuild
|
|
|
|
'';
|
|
|
|
|
2018-03-15 00:00:00 +00:00
|
|
|
inherit doCheck;
|
|
|
|
|
2015-01-10 08:12:37 +00:00
|
|
|
checkPhase = ''
|
2015-01-07 19:31:32 +00:00
|
|
|
runHook preCheck
|
2015-05-06 19:56:02 +00:00
|
|
|
${setupCommand} test ${testTarget}
|
2015-01-07 19:31:32 +00:00
|
|
|
runHook postCheck
|
|
|
|
'';
|
|
|
|
|
2015-01-16 19:54:35 +00:00
|
|
|
haddockPhase = ''
|
|
|
|
runHook preHaddock
|
2018-07-27 04:24:22 +00:00
|
|
|
${optionalString (doHaddock && isLibrary) ''
|
2015-05-06 19:56:02 +00:00
|
|
|
${setupCommand} haddock --html \
|
2015-01-16 19:54:35 +00:00
|
|
|
${optionalString doHoogle "--hoogle"} \
|
2019-12-19 13:41:11 +00:00
|
|
|
${optionalString doHaddockQuickjump "--quickjump"} \
|
2019-02-20 14:58:28 +00:00
|
|
|
${optionalString (isLibrary && hyperlinkSource) "--hyperlink-source"} \
|
|
|
|
${stdenv.lib.concatStringsSep " " haddockFlags}
|
2015-01-16 19:54:35 +00:00
|
|
|
''}
|
|
|
|
runHook postHaddock
|
|
|
|
'';
|
|
|
|
|
2015-01-10 08:12:37 +00:00
|
|
|
installPhase = ''
|
2015-01-07 19:31:32 +00:00
|
|
|
runHook preInstall
|
|
|
|
|
2018-07-27 04:24:22 +00:00
|
|
|
${if !isLibrary then "${setupCommand} install" else ''
|
2015-05-06 19:56:02 +00:00
|
|
|
${setupCommand} copy
|
2017-12-05 08:36:08 +00:00
|
|
|
local packageConfDir="$out/lib/${ghc.name}/package.conf.d"
|
2015-01-10 08:12:37 +00:00
|
|
|
local packageConfFile="$packageConfDir/${pname}-${version}.conf"
|
|
|
|
mkdir -p "$packageConfDir"
|
2015-05-06 19:56:02 +00:00
|
|
|
${setupCommand} register --gen-pkg-config=$packageConfFile
|
2017-12-23 00:25:59 +00:00
|
|
|
if [ -d "$packageConfFile" ]; then
|
2018-01-31 16:41:03 +00:00
|
|
|
mv "$packageConfFile/"* "$packageConfDir"
|
2017-12-23 00:25:59 +00:00
|
|
|
rmdir "$packageConfFile"
|
|
|
|
fi
|
2018-01-31 16:41:03 +00:00
|
|
|
for packageConfFile in "$packageConfDir/"*; do
|
2020-01-28 23:44:11 +00:00
|
|
|
local pkgId=$(gawk -f ${unprettyConf} "$packageConfFile" \
|
|
|
|
| grep '^id:' | cut -d' ' -f2)
|
|
|
|
mv "$packageConfFile" "$packageConfDir/$pkgId.conf"
|
2017-12-23 00:25:59 +00:00
|
|
|
done
|
2018-07-16 15:23:32 +00:00
|
|
|
|
|
|
|
# delete confdir if there are no libraries
|
|
|
|
find $packageConfDir -maxdepth 0 -empty -delete;
|
2015-01-07 19:31:32 +00:00
|
|
|
''}
|
2017-03-25 04:23:01 +00:00
|
|
|
${optionalString isGhcjs ''
|
2019-03-29 08:10:42 +00:00
|
|
|
for exeDir in "${binDir}/"*.jsexe; do
|
2017-03-25 04:23:01 +00:00
|
|
|
exe="''${exeDir%.jsexe}"
|
2017-07-25 22:48:47 +00:00
|
|
|
printWords '#!${nodejs}/bin/node' > "$exe"
|
2018-03-26 00:43:23 +00:00
|
|
|
echo >> "$exe"
|
2017-03-25 04:23:01 +00:00
|
|
|
cat "$exeDir/all.js" >> "$exe"
|
|
|
|
chmod +x "$exe"
|
|
|
|
done
|
|
|
|
''}
|
2017-02-14 15:17:40 +00:00
|
|
|
${optionalString doCoverage "mkdir -p $out/share && cp -r dist/hpc $out/share"}
|
2015-05-31 07:18:13 +00:00
|
|
|
${optionalString (enableSharedExecutables && isExecutable && !isGhcjs && stdenv.isDarwin && stdenv.lib.versionOlder ghc.version "7.10") ''
|
2019-03-29 08:10:42 +00:00
|
|
|
for exe in "${binDir}/"* ; do
|
2017-12-05 08:36:08 +00:00
|
|
|
install_name_tool -add_rpath "$out/lib/ghc-${ghc.version}/${pname}-${version}" "$exe"
|
2015-01-07 19:31:32 +00:00
|
|
|
done
|
|
|
|
''}
|
|
|
|
|
2017-07-25 01:22:19 +00:00
|
|
|
${optionalString enableSeparateDocOutput ''
|
2018-01-31 16:41:03 +00:00
|
|
|
for x in ${docdir "$doc"}"/html/src/"*.html; do
|
2017-12-05 08:36:08 +00:00
|
|
|
remove-references-to -t $out $x
|
2017-07-25 01:22:19 +00:00
|
|
|
done
|
2017-12-05 08:36:08 +00:00
|
|
|
mkdir -p $doc
|
2017-07-25 01:22:19 +00:00
|
|
|
''}
|
2017-12-05 08:36:08 +00:00
|
|
|
${optionalString enableSeparateDataOutput "mkdir -p $data"}
|
2017-07-25 01:22:19 +00:00
|
|
|
|
2015-01-07 19:31:32 +00:00
|
|
|
runHook postInstall
|
|
|
|
'';
|
|
|
|
|
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
|
|
|
passthru = passthru // rec {
|
2015-01-10 12:23:04 +00:00
|
|
|
|
2017-03-01 18:56:59 +00:00
|
|
|
inherit pname version;
|
2015-01-10 12:23:04 +00:00
|
|
|
|
2017-12-29 02:29:23 +00:00
|
|
|
compiler = ghc;
|
|
|
|
|
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
|
|
|
# All this information is intended just for `shellFor`. It should be
|
|
|
|
# considered unstable and indeed we knew how to keep it private we would.
|
|
|
|
getCabalDeps = {
|
|
|
|
inherit
|
|
|
|
buildDepends
|
|
|
|
buildTools
|
|
|
|
executableFrameworkDepends
|
|
|
|
executableHaskellDepends
|
|
|
|
executablePkgconfigDepends
|
|
|
|
executableSystemDepends
|
|
|
|
executableToolDepends
|
|
|
|
extraLibraries
|
|
|
|
libraryFrameworkDepends
|
|
|
|
libraryHaskellDepends
|
|
|
|
libraryPkgconfigDepends
|
|
|
|
librarySystemDepends
|
|
|
|
libraryToolDepends
|
|
|
|
pkgconfigDepends
|
|
|
|
setupHaskellDepends
|
|
|
|
;
|
|
|
|
} // stdenv.lib.optionalAttrs doCheck {
|
|
|
|
inherit
|
|
|
|
testDepends
|
|
|
|
testFrameworkDepends
|
|
|
|
testHaskellDepends
|
|
|
|
testPkgconfigDepends
|
|
|
|
testSystemDepends
|
|
|
|
testToolDepends
|
|
|
|
;
|
|
|
|
} // stdenv.lib.optionalAttrs doBenchmark {
|
|
|
|
inherit
|
|
|
|
benchmarkDepends
|
|
|
|
benchmarkFrameworkDepends
|
|
|
|
benchmarkHaskellDepends
|
|
|
|
benchmarkPkgconfigDepends
|
|
|
|
benchmarkSystemDepends
|
|
|
|
benchmarkToolDepends
|
|
|
|
;
|
|
|
|
};
|
2018-09-17 21:11:59 +00:00
|
|
|
|
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
|
|
|
# Attributes for the old definition of `shellFor`. Should be removed but
|
|
|
|
# this predates the warning at the top of `getCabalDeps`.
|
|
|
|
getBuildInputs = rec {
|
2018-09-17 21:11:59 +00:00
|
|
|
inherit propagatedBuildInputs otherBuildInputs allPkgconfigDepends;
|
|
|
|
haskellBuildInputs = isHaskellPartition.right;
|
|
|
|
systemBuildInputs = isHaskellPartition.wrong;
|
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
|
|
|
isHaskellPartition = stdenv.lib.partition
|
|
|
|
isHaskellPkg
|
|
|
|
(propagatedBuildInputs ++ otherBuildInputs ++ depsBuildBuild ++ nativeBuildInputs);
|
2018-09-17 21:11:59 +00:00
|
|
|
};
|
|
|
|
|
2018-07-27 04:24:22 +00:00
|
|
|
isHaskellLibrary = isLibrary;
|
2015-02-22 19:42:08 +00:00
|
|
|
|
2017-08-06 19:48:22 +00:00
|
|
|
# TODO: ask why the split outputs are configurable at all?
|
|
|
|
# TODO: include tests for split if possible
|
|
|
|
# Given the haskell package, returns
|
|
|
|
# the directory containing the haddock documentation.
|
|
|
|
# `null' if no haddock documentation was built.
|
|
|
|
# TODO: fetch the self from the fixpoint instead
|
2017-12-05 08:36:08 +00:00
|
|
|
haddockDir = self: if doHaddock then "${docdir self.doc}/html" else null;
|
2017-08-06 19:48:22 +00:00
|
|
|
|
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
|
|
|
# Creates a derivation containing all of the necessary dependencies for building the
|
|
|
|
# parent derivation. The attribute set that it takes as input can be viewed as:
|
|
|
|
#
|
|
|
|
# { withHoogle }
|
|
|
|
#
|
|
|
|
# The derivation that it builds contains no outpaths because it is meant for use
|
|
|
|
# as an environment
|
|
|
|
#
|
|
|
|
# # Example use
|
|
|
|
# # Creates a shell with all of the dependencies required to build the "hello" package,
|
|
|
|
# # and with python:
|
|
|
|
#
|
|
|
|
# > nix-shell -E 'with (import <nixpkgs> {}); \
|
|
|
|
# > haskell.packages.ghc865.hello.envFunc { buildInputs = [ python ]; }'
|
|
|
|
envFunc = { withHoogle ? false }:
|
|
|
|
let
|
|
|
|
name = "ghc-shell-for-${drv.name}";
|
|
|
|
|
|
|
|
withPackages = if withHoogle then ghcWithHoogle else ghcWithPackages;
|
|
|
|
|
|
|
|
# We use the `ghcWithPackages` function from `buildHaskellPackages` if we
|
|
|
|
# want a shell for the sake of cross compiling a package. In the native case
|
|
|
|
# we don't use this at all, and instead put the setupDepends in the main
|
|
|
|
# `ghcWithPackages`. This way we don't have two wrapper scripts called `ghc`
|
|
|
|
# shadowing each other on the PATH.
|
|
|
|
ghcEnvForBuild =
|
|
|
|
assert isCross;
|
|
|
|
buildHaskellPackages.ghcWithPackages (_: setupHaskellDepends);
|
|
|
|
|
|
|
|
ghcEnv = withPackages (_:
|
|
|
|
otherBuildInputsHaskell ++
|
|
|
|
propagatedBuildInputs ++
|
|
|
|
stdenv.lib.optionals (!isCross) setupHaskellDepends);
|
|
|
|
|
|
|
|
ghcCommandCaps = stdenv.lib.toUpper ghcCommand';
|
|
|
|
in stdenv.mkDerivation ({
|
|
|
|
inherit name shellHook;
|
|
|
|
|
|
|
|
depsBuildBuild = stdenv.lib.optional isCross ghcEnvForBuild;
|
|
|
|
nativeBuildInputs =
|
|
|
|
[ ghcEnv ] ++ optional (allPkgconfigDepends != []) pkgconfig ++
|
|
|
|
collectedToolDepends;
|
|
|
|
buildInputs =
|
|
|
|
otherBuildInputsSystem;
|
|
|
|
phases = ["installPhase"];
|
|
|
|
installPhase = "echo $nativeBuildInputs $buildInputs > $out";
|
|
|
|
LANG = "en_US.UTF-8";
|
|
|
|
LOCALE_ARCHIVE = stdenv.lib.optionalString (stdenv.hostPlatform.libc == "glibc") "${buildPackages.glibcLocales}/lib/locale/locale-archive";
|
|
|
|
"NIX_${ghcCommandCaps}" = "${ghcEnv}/bin/${ghcCommand}";
|
|
|
|
"NIX_${ghcCommandCaps}PKG" = "${ghcEnv}/bin/${ghcCommand}-pkg";
|
|
|
|
# TODO: is this still valid?
|
|
|
|
"NIX_${ghcCommandCaps}_DOCDIR" = "${ghcEnv}/share/doc/ghc/html";
|
|
|
|
"NIX_${ghcCommandCaps}_LIBDIR" = if ghc.isHaLVM or false
|
|
|
|
then "${ghcEnv}/lib/HaLVM-${ghc.version}"
|
|
|
|
else "${ghcEnv}/lib/${ghcCommand}-${ghc.version}";
|
|
|
|
});
|
|
|
|
|
|
|
|
env = envFunc { };
|
2018-09-17 21:20:29 +00:00
|
|
|
|
2015-01-10 12:23:04 +00:00
|
|
|
};
|
2015-01-07 19:31:32 +00:00
|
|
|
|
2015-01-16 19:54:35 +00:00
|
|
|
meta = { inherit homepage license platforms; }
|
2015-01-10 08:12:37 +00:00
|
|
|
// optionalAttrs broken { inherit broken; }
|
|
|
|
// optionalAttrs (description != "") { inherit description; }
|
|
|
|
// optionalAttrs (maintainers != []) { inherit maintainers; }
|
2018-03-20 15:51:37 +00:00
|
|
|
// optionalAttrs (hydraPlatforms != null) { inherit hydraPlatforms; }
|
2015-01-10 08:12:37 +00:00
|
|
|
;
|
|
|
|
|
2015-01-07 19:31:32 +00:00
|
|
|
}
|
2016-02-18 03:07:32 +00:00
|
|
|
// optionalAttrs (preCompileBuildDriver != "") { inherit preCompileBuildDriver; }
|
|
|
|
// optionalAttrs (postCompileBuildDriver != "") { inherit postCompileBuildDriver; }
|
2015-01-19 15:24:12 +00:00
|
|
|
// optionalAttrs (preUnpack != "") { inherit preUnpack; }
|
|
|
|
// optionalAttrs (postUnpack != "") { inherit postUnpack; }
|
2015-01-10 08:12:37 +00:00
|
|
|
// optionalAttrs (patches != []) { inherit patches; }
|
|
|
|
// optionalAttrs (patchPhase != "") { inherit patchPhase; }
|
|
|
|
// optionalAttrs (preConfigure != "") { inherit preConfigure; }
|
|
|
|
// optionalAttrs (postConfigure != "") { inherit postConfigure; }
|
|
|
|
// optionalAttrs (preBuild != "") { inherit preBuild; }
|
|
|
|
// optionalAttrs (postBuild != "") { inherit postBuild; }
|
2017-09-19 13:36:29 +00:00
|
|
|
// optionalAttrs (doBenchmark) { inherit doBenchmark; }
|
2015-01-10 08:12:37 +00:00
|
|
|
// optionalAttrs (checkPhase != "") { inherit checkPhase; }
|
|
|
|
// optionalAttrs (preCheck != "") { inherit preCheck; }
|
|
|
|
// optionalAttrs (postCheck != "") { inherit postCheck; }
|
2015-01-20 14:48:51 +00:00
|
|
|
// optionalAttrs (preInstall != "") { inherit preInstall; }
|
2015-08-14 19:22:40 +00:00
|
|
|
// optionalAttrs (installPhase != "") { inherit installPhase; }
|
2015-01-20 14:48:51 +00:00
|
|
|
// optionalAttrs (postInstall != "") { inherit postInstall; }
|
2015-01-10 08:12:37 +00:00
|
|
|
// optionalAttrs (preFixup != "") { inherit preFixup; }
|
|
|
|
// optionalAttrs (postFixup != "") { inherit postFixup; }
|
2016-01-24 22:12:03 +00:00
|
|
|
// optionalAttrs (dontStrip) { inherit dontStrip; }
|
2016-09-14 16:58:46 +00:00
|
|
|
// optionalAttrs (hardeningDisable != []) { inherit hardeningDisable; }
|
2018-08-20 18:43:41 +00:00
|
|
|
// optionalAttrs (stdenv.buildPlatform.libc == "glibc"){ LOCALE_ARCHIVE = "${glibcLocales}/lib/locale/locale-archive"; }
|
2015-01-10 08:12:37 +00:00
|
|
|
)
|
2018-09-17 21:20:29 +00:00
|
|
|
)
|