74edd91...iko/ghcjs-patch-master · haskell.nix

.buildkite/pipeline.yml+21−4

since splitsnapshots

unifiedsplit

@@ -1,6 +1,6 @@

1steps:

2− - label: 'Run tests'

2+ - label: 'Run tests with ghc8107'

3− command: "./test/tests.sh"

3+ command: "./test/tests.sh ghc8107"

4 agents:

5 system: x86_64-linux

6

@@ -14,9 +14,9 @@ steps:

14 agents:

15 system: x86_64-linux

16

17− - label: 'Check closure size'

17+ - label: 'Check closure size with ghc8107'

18 command:

19− - nix-build build.nix -A maintainer-scripts.check-closure-size -o check-closure-size.sh

19+ - nix-build build.nix -A maintainer-scripts.check-closure-size --argstr compiler-nix-name ghc8107 -o check-closure-size.sh

20 - echo "+++ Closure size (MB)"

21 - ./check-closure-size.sh

22 agents:

@@ -33,3 +33,20 @@ steps:

33 command:

34 - nix-build build.nix -A maintainer-scripts.check-materialization-concurrency -o check-materialization-concurrency.sh

35 - ./check-materialization-concurrency.sh

36+

37+ - label: 'Make sure non store paths like can be used as src'

38+ command:

39+ - nix-build build.nix -A maintainer-scripts.check-path-support --argstr compiler-nix-name ghc8107 -o check-path-support.sh

40+ - ./check-path-support.sh

41+

42+ - label: 'Check that the haskell.nix roots do not require IFDs'

43+ command:

44+ - nix build .#roots.x86_64-linux --option allow-import-from-derivation false

45+ agents:

46+ system: x86_64-linux

47+

48+ - label: 'Check that evaluation of hydra jobs works without using remote builders'

49+ command:

50+ - nix-instantiate release.nix -A required-unstable-ghc8107-x86_64-darwin-native --show-trace --builders ''

51+ agents:

52+ system: x86_64-linux

.buildkite/updates.yml+3−10

@@ -1,21 +1,14 @@

1steps:

2− - label: 'Update hackage.nix'

2+ - label: 'Update hackage.nix and stackage.nix'

3 command:

4 - nix-build build.nix -A maintainer-scripts.update-hackage -o update-hackage.sh

5 - echo "+++ Updating hackage.nix"

6 - ./update-hackage.sh

7− artifact_paths:

8− - "hackage-src.json"

9− agents:

10− system: x86_64-linux

11−

12− - label: 'Update stackage.nix'

13− command:

14 - nix-build build.nix -A maintainer-scripts.update-stackage -o update-stackage.sh

7 - nix-build build.nix -A maintainer-scripts.update-stackage -o update-stackage.sh

15 - echo "+++ Updating stackage.nix"

8 - echo "+++ Updating stackage.nix"

16 - ./update-stackage.sh

9 - ./update-stackage.sh

17 artifact_paths:

10 artifact_paths:

18− - "stackage-src.json"

11+ - "flake.lock"

19 agents:

12 agents:

20 system: x86_64-linux

13 system: x86_64-linux

21

14

@@ -24,7 +17,7 @@ steps:

24

17

25 - label: 'Update pins'

18 - label: 'Update pins'

26 command:

19 command:

27− - 'buildkite-agent artifact download "*.json" .'

20+ - 'buildkite-agent artifact download "flake.lock" .'

28 - nix-build build.nix -A maintainer-scripts.update-pins -o update-pins.sh

21 - nix-build build.nix -A maintainer-scripts.update-pins -o update-pins.sh

29 - ./update-pins.sh

22 - ./update-pins.sh

30 agents:

23 agents:

.github/workflows/rebase.yamlnew file+28

@@ -0,0 +1,28 @@

1+name: Rebase on iohk/haskell.nix

2+

3+on:

4+ schedule:

5+ - cron: 0 0 * * *

6+

7+jobs:

8+ Linux:

9+ runs-on: ubuntu-latest

10+ steps:

11+ - uses: actions/checkout@v2.4.0

12+ with:

13+ fetch-depth: 0

14+ - name: Rebase and push

15+ run: |

16+ git config --global user.name "GitHub Actions"

17+

18+

19+ git remote add iohk https://github.com/input-output-hk/haskell.nix.git

20+ git fetch iohk

21+

22+ git checkout iko/ghcjs-patch-master

23+ git rebase iohk/master

24+ git push --force

25+

26+ git checkout --track origin/master

27+ git reset --hard iohk/master

28+ git push --force

.github/workflows/windows-secp256k1.ymlnew file+51

@@ -0,0 +1,51 @@

1+name: "Test secp256k1 on windows"

2+on: workflow_dispatch

3+jobs:

4+ tests:

5+ runs-on: windows-latest

6+

7+ defaults:

8+ run:

9+ shell: bash

10+

11+ steps:

12+

13+ - uses: haskell/actions/setup@v1

14+ id: setup-haskell

15+ with:

16+ ghc-version: 8.10.7

17+ cabal-version: 3.6.2.0

18+

19+ - name: Install pkgconfiglite

20+ run: choco install -y pkgconfiglite

21+

22+ - name: Install libsecp256k1

23+ run: |

24+ curl -Ls \

25+ --connect-timeout 5 \

26+ --max-time 10 \

27+ --retry 5 \

28+ --retry-delay 0 \

29+ --retry-max-time 40 \

30+ https://hydra.iohk.io/job/Cardano/haskell-nix/windows-secp256k1/latest/download/1 -o secp256k1.zip

31+ mkdir secp256k1

32+ cd secp256k1

33+ unzip ../secp256k1.zip

34+ cd ..

35+ export PKG_CONFIG_PATH="$PKG_CONFIG_PATH;$(readlink -f secp256k1/lib/pkgconfig | sed 's|^/d|D:|g' | tr / '\\')"

36+ echo "PKG_CONFIG_PATH=$PKG_CONFIG_PATH"

37+ echo "PKG_CONFIG_PATH=$PKG_CONFIG_PATH" >> $GITHUB_ENV

38+ export SECP256K1_PATH="$(readlink -f secp256k1/bin | sed 's|^/d|D:|g' | tr / '\\')"

39+ echo "SECP256K1_PATH=$SECP256K1_PATH"

40+ echo "$SECP256K1_PATH" >> $GITHUB_PATH

41+

42+ - name: Cabal update

43+ run: cabal update

44+

45+ - name: Build and run haskell-secp256k1 tests

46+ run: |

47+ cabal unpack secp256k1-haskell

48+ cd secp256k1-haskell-*

49+ cabal build --enable-tests

50+ cabal test

51+

README.md+33−6

@@ -1,3 +1,19 @@

1+# What is this fork?

2+

3+This fork contains a patched version of GHCJS 8.10 which improves performance and memory usage.

4+

5+For more info see this PR: https://github.com/input-output-hk/haskell.nix/pull/1306

6+

7+## Package versions

8+

9+This branch is updated every day with commits from https://github.com/input-output-hk/haskell.nix/tree/master. This means that it receives all of the updates the initial project does.

10+

11+## Caching

12+

13+Building the patched compiler itself takes around 2-3 hours. The [Typeable](https://typeable.io) public nix cache probably has a cached version of the compiler. You can follow these instruction to set it up: [app.cachix.org/organization/typeable/cache/typeable](https://app.cachix.org/organization/typeable/cache/typeable).

14+

15+---

16+

1# `haskell.nix` is infrastructure for building Haskell packages with Nix

17# `haskell.nix` is infrastructure for building Haskell packages with Nix

2

18

3[![](https://badge.buildkite.com/d453edcd29bd2f8f3f3b32c9b7d6777a33773d9671c37a6ccc.svg?branch=master)](https://buildkite.com/input-output-hk/haskell-dot-nix)

19[![](https://badge.buildkite.com/d453edcd29bd2f8f3f3b32c9b7d6777a33773d9671c37a6ccc.svg?branch=master)](https://buildkite.com/input-output-hk/haskell-dot-nix)

@@ -8,8 +24,23 @@ its dependencies into Nix code.

8

24

9## Documentation

25## Documentation

10

26

11−- [Introduction](https://input-output-hk.github.io/haskell.nix/)

27+- [Introduction](https://input-output-hk.github.io/haskell.nix/index.html)

12−- [Getting Started](https://input-output-hk.github.io/haskell.nix/tutorials/getting-started/)

28+- [Getting Started](https://input-output-hk.github.io/haskell.nix/tutorials/getting-started.html)

29+- [Troubleshooting](https://input-output-hk.github.io/haskell.nix/troubleshooting.html)

30+- Explore the documentation from there to find further topics.

31+

32+## Help! Something isn't working

33+

34+The #1 problem that people have when using `haskell.nix` is that they find themselves building GHC.

35+This should not happen, but you *must* follow the `haskell.nix` setup instructions properly to avoid it.

36+If you find this happening to you, please check that you have followed the

37+[getting started instructions](https://input-output-hk.github.io/haskell.nix/tutorials/getting-started.html#setting-up-the-binary-cache) and

38+consult the corresponding [troubleshooting section](https://input-output-hk.github.io/haskell.nix/troubleshooting.html#why-am-i-building-ghc).

39+

40+The troubleshooting documentation also contains some help for other common issues.

41+Please give it a read before asking on IRC or opening an issue.

42+

43+If you're still stuck, join the [#haskell.nix](https://www.irccloud.com/invite?channel=%23haskell.nix&hostname=irc.libera.chat&port=6697&ssl=1) channel on [irc.libera.chat](https://libera.chat/), or open an issue.

13

44

14## Related repos

45## Related repos

15

46

@@ -22,7 +53,3 @@ Haskell packages in Nix. It depends on other repos, which are:

22

53

23- [`stackage.nix`](https://github.com/input-output-hk/stackage.nix) — all of the [Stackage](https://www.stackage.org/) snapshots, converted to Nix expressions.

54- [`stackage.nix`](https://github.com/input-output-hk/stackage.nix) — all of the [Stackage](https://www.stackage.org/) snapshots, converted to Nix expressions.

24

55

25−## IRC Channel

26−

27−Join the [#haskell.nix](https://www.irccloud.com/invite?channel=%23haskell.nix&hostname=irc.freenode.net&port=6697&ssl=1) channel on [irc.freenode.net](https://freenode.net/) to get help or discuss

28−the development of `haskell.nix` and `nix-tools`.

build.nix+45−18

@@ -5,10 +5,14 @@

5let

6 haskellNix = (import ./default.nix {});

7in

8−{ nixpkgs ? haskellNix.sources.nixpkgs-default

8+{ nixpkgs ? haskellNix.sources.nixpkgs-2111

9, nixpkgsArgs ? haskellNix.nixpkgsArgs

10, pkgs ? import nixpkgs nixpkgsArgs

11+, evalPackages ? import nixpkgs nixpkgsArgs

12+, nixpkgsForHydra ? haskellNix.sources.nixpkgs-2105

13+, pkgsForHydra ? import nixpkgsForHydra (nixpkgsArgs // { inherit (pkgs) system; })

11, ifdLevel ? 1000

14, ifdLevel ? 1000

15+, compiler-nix-name ? throw "No `compiler-nix-name` passed to build.nix"

12}:

16}:

13

17

14let

18let

@@ -16,17 +20,23 @@ let

16 buildHaskell = pkgs.buildPackages.haskell-nix;

20 buildHaskell = pkgs.buildPackages.haskell-nix;

17 tool = buildHaskell.tool;

21 tool = buildHaskell.tool;

18in rec {

22in rec {

19− tests = import ./test/default.nix { inherit pkgs ifdLevel; };

23+ tests = import ./test/default.nix { inherit pkgs evalPackages ifdLevel compiler-nix-name; };

20

24

21 tools = pkgs.lib.optionalAttrs (ifdLevel >= 3) (

25 tools = pkgs.lib.optionalAttrs (ifdLevel >= 3) (

22− pkgs.recurseIntoAttrs {

26+ pkgs.recurseIntoAttrs ({

23− ghcide-020 = tool "ghcide" "0.2.0";

27+ cabal-latest = tool compiler-nix-name "cabal" { inherit evalPackages; };

24− } // pkgs.lib.optionalAttrs (buildHaskell.defaultCompilerNixName == "ghc865") {

28+ hlint-latest = tool compiler-nix-name "hlint" {

25− cabal-30 = tool "cabal" "3.0.0.0";

29+ inherit evalPackages;

26− } // pkgs.lib.optionalAttrs (buildHaskell.defaultCompilerNixName != "ghc8101") {

30+ version = {

27− cabal-32 = tool "cabal" "3.2.0.0";

31+ "ghc865" = "3.2.8";

28− ghcide-object-code = tool "ghcide" "object-code";

32+ "ghc882" = "3.3.6";

33+ "ghc883" = "3.3.6";

34+ "ghc884" = "3.3.6";

35+ }.compiler-nix-name or "latest";

36+ };

37+ } // pkgs.lib.optionalAttrs (!__elem compiler-nix-name ["ghc921" "ghc922" "ghc923" "ghc924"]) {

38+ hls-latest = tool compiler-nix-name "haskell-language-server" { inherit evalPackages; };

29− }

39+ })

30 );

40 );

31

41

32 # Scripts for keeping Hackage and Stackage up to date, and CI tasks.

42 # Scripts for keeping Hackage and Stackage up to date, and CI tasks.

@@ -34,8 +44,21 @@ in rec {

34 # as not all of them can work in restricted eval mode (as they

44 # as not all of them can work in restricted eval mode (as they

35 # are not pure).

45 # are not pure).

36 maintainer-scripts = pkgs.dontRecurseIntoAttrs {

46 maintainer-scripts = pkgs.dontRecurseIntoAttrs {

37− update-hackage = haskell.callPackage ./scripts/update-hackage.nix {};

47+ update-hackage = import ./scripts/update-hackage.nix {

48+ inherit (pkgs) stdenv lib writeScript coreutils glibc git

49+ openssh nixFlakes gawk bash curl findutils;

50+ # Update scripts use the internal nix-tools and cabal-install (compiled with a fixed GHC version)

51+ nix-tools = haskell.internal-nix-tools;

52+ cabal-install = haskell.internal-cabal-install;

53+ inherit (haskell) update-index-state-hashes;

54+ };

38− update-stackage = haskell.callPackage ./scripts/update-stackage.nix {};

55+ update-stackage = haskell.callPackage ./scripts/update-stackage.nix {

56+ inherit (pkgs) stdenv lib writeScript coreutils glibc git

57+ openssh nixFlakes gawk bash curl findutils;

58+ # Update scripts use the internal nix-tools and cabal-install (compiled with a fixed GHC version)

59+ nix-tools = haskell.internal-nix-tools;

60+ cabal-install = haskell.internal-cabal-install;

61+ };

39 update-pins = haskell.callPackage ./scripts/update-pins.nix {};

62 update-pins = haskell.callPackage ./scripts/update-pins.nix {};

40 update-docs = pkgs.buildPackages.callPackage ./scripts/update-docs.nix {

63 update-docs = pkgs.buildPackages.callPackage ./scripts/update-docs.nix {

41 generatedOptions = pkgs.callPackage ./scripts/options-doc.nix { };

64 generatedOptions = pkgs.callPackage ./scripts/options-doc.nix { };

@@ -45,22 +68,26 @@ in rec {

45 # it uses `pkgs.buildPackages.callPackage` not `haskell.callPackage`

68 # it uses `pkgs.buildPackages.callPackage` not `haskell.callPackage`

46 # (We could pull in darcs from a known good haskell.nix for hydra to

69 # (We could pull in darcs from a known good haskell.nix for hydra to

47 # use)

70 # use)

48− check-hydra = pkgs.buildPackages.callPackage ./scripts/check-hydra.nix {};

71+ check-hydra = pkgsForHydra.buildPackages.callPackage ./scripts/check-hydra.nix {};

49 check-closure-size = pkgs.buildPackages.callPackage ./scripts/check-closure-size.nix {

72 check-closure-size = pkgs.buildPackages.callPackage ./scripts/check-closure-size.nix {

50− # Includes cabal-install and hpack since these are commonly used.

73+ # Includes cabal-install since this is commonly used.

51 nix-tools = pkgs.linkFarm "common-tools" [

74 nix-tools = pkgs.linkFarm "common-tools" [

52− { name = "nix-tools"; path = haskell.nix-tools; }

75+ { name = "nix-tools"; path = haskell.nix-tools.${compiler-nix-name}; }

53− { name = "cabal-install"; path = haskell.cabal-install; }

76+ { name = "cabal-install"; path = haskell.cabal-install.${compiler-nix-name}; }

54− { name = "hpack"; path = haskell.haskellPackages.hpack.components.exes.hpack; }

55 ];

77 ];

56 };

78 };

57 check-materialization-concurrency = pkgs.buildPackages.callPackage ./scripts/check-materialization-concurrency/check.nix {};

79 check-materialization-concurrency = pkgs.buildPackages.callPackage ./scripts/check-materialization-concurrency/check.nix {};

80+ check-path-support = pkgs.buildPackages.callPackage ./scripts/check-path-support.nix {

81+ # TODO remove this when nixpkgs-2205 is released and used for `pkgs`

82+ # check-path-support fails unless we have nix 2.4 or newer.

83+ inherit (import haskellNix.sources.nixpkgs-unstable {}) nix;

84+ };

58 };

85 };

59

86

60 # These are pure parts of maintainer-script so they can be built by hydra

87 # These are pure parts of maintainer-script so they can be built by hydra

61 # and added to the cache to speed up buildkite.

88 # and added to the cache to speed up buildkite.

62 maintainer-script-cache = pkgs.recurseIntoAttrs (

89 maintainer-script-cache = pkgs.recurseIntoAttrs (

63− (pkgs.lib.optionalAttrs pkgs.stdenv.hostPlatform.isWindows {

90+ (pkgs.lib.optionalAttrs (pkgsForHydra.system == "x86_64-linux") {

64 inherit (maintainer-scripts) check-hydra;

91 inherit (maintainer-scripts) check-hydra;

65 })

92 })

66 // (pkgs.lib.optionalAttrs (ifdLevel > 2) {

93 // (pkgs.lib.optionalAttrs (ifdLevel > 2) {

builder/Setup.ghcjs.hsnew file+272

@@ -0,0 +1,272 @@

1+{-# language LambdaCase #-}

2+import Distribution.Simple

3+import Distribution.Simple.Setup

4+import Distribution.Types.PackageDescription

5+import Distribution.Types.LocalBuildInfo

6+import Distribution.Simple.PackageIndex

7+import Distribution.Types.InstalledPackageInfo hiding (includeDirs)

8+import qualified Distribution.Types.InstalledPackageInfo as IPI

9+import Distribution.Types.PackageName

10+import System.FilePath

11+import Control.Monad (filterM, forM_, forM, unless)

12+import System.Directory (doesFileExist)

13+import Distribution.Types.Library (libBuildInfo, Library(..))

14+import Distribution.Types.BuildInfo (cSources, jsSources, includeDirs, emptyBuildInfo, options, extraBundledLibs)

15+import Distribution.Simple.BuildTarget (readBuildTargets, BuildTarget(..), readUserBuildTargets)

16+import Distribution.Verbosity (silent, verbose)

17+import Distribution.Types.ComponentName

18+import Distribution.Simple.Program.Types (programPath)

19+import Distribution.Simple.Program.Db (lookupKnownProgram, lookupProgram, knownPrograms)

20+import Distribution.Simple.Program (Program, gccProgram, arProgram, runDbProgram, simpleProgram, ghcProgram)

21+import Distribution.Simple.Utils (createDirectoryIfMissingVerbose)

22+import Distribution.Types.HookedBuildInfo

23+import Data.List (isPrefixOf, isSuffixOf, intercalate)

24+import System.Environment (getArgs, getProgName)

25+import Distribution.Simple.LocalBuildInfo (Component (..), withAllComponentsInBuildOrder, componentBuildDir)

26+import Distribution.Types.TestSuite (TestSuite(..))

27+import Distribution.Types.TestSuiteInterface (TestSuiteInterface(..) )

28+import Distribution.Simple.Test.LibV09 (stubName)

29+import Distribution.Types.Executable (exeName, Executable(..))

30+import Distribution.Types.Benchmark (Benchmark(..))

31+import Distribution.Types.TestSuite (TestSuite(..))

32+import Distribution.Types.UnqualComponentName (unUnqualComponentName, mkUnqualComponentName)

33+

34+

35+emarProgram :: Program

36+emarProgram = simpleProgram "emar"

37+

38+buildEMCCLib :: PackageDescription -> LocalBuildInfo -> IO ()

39+buildEMCCLib desc lbi = do

40+ let verbosity = verbose

41+ -- get build dir

42+ createDirectoryIfMissingVerbose verbosity True ((buildDir lbi) </> "emcc")

43+ --

44+ case library desc of

45+ Just lib -> do

46+ -- Let's see if we are going to export anything. If not there is likely no point in compiling anything

47+ -- from the C code.

48+ names <- forM (jsSources . libBuildInfo $ lib) $ \src -> do

49+ unwords . concatMap (drop 2 . words) . filter (isPrefixOf "// EMCC:EXPORTED_FUNCTIONS") . lines <$> readFile src

50+

51+ unless (null names) $ do

52+ let depIncludeDirs = concatMap IPI.includeDirs (topologicalOrder $ installedPkgs lbi)

53+ -- alright, let's compile all .c files into .o files with emcc, which is the `gcc` program.

54+ forM_ (cSources . libBuildInfo $ lib) $ \src -> do

55+ let dst = (buildDir lbi) </> "emcc" </> (src -<.> "o")

56+ createDirectoryIfMissingVerbose verbosity True (takeDirectory dst)

57+ runDbProgram verbosity gccProgram (withPrograms lbi) $

58+ ["-c", src, "-o", dst] ++ ["-I" <> incDir | incDir <- (includeDirs . libBuildInfo $ lib) ++ depIncludeDirs]

59+

60+ -- and now construct a canonical `.js_a` file, *if* we have any cSources we turned into objects.

61+ unless (null . cSources . libBuildInfo $ lib) $ do

62+ let dstLib = (buildDir lbi) </> "libEMCC" <> (unPackageName . pkgName . package $ desc) <> ".js_a"

63+ runDbProgram verbosity emarProgram (withPrograms lbi) $

64+ [ "-r", dstLib ] ++ [ (buildDir lbi) </> "emcc" </> (src -<.> "o") | src <- cSources . libBuildInfo $ lib ]

65+

66+ let expLib = (buildDir lbi) </> "libEMCC" <> (unPackageName . pkgName . package $ desc) <> ".exported.js_a"

67+ writeFile expLib (unwords names)

68+

69+ -- if there's no lib, this is a fairly pointless exercise

70+ Nothing -> return ()

71+

72+-- This is here so that we can link multiple libEMCC* libraries fromd ependencies together with emcc.

73+-- however we don't have figured out how to get the EXPORTED_FUNCTIONS from each dependency merged yet.

74+--

75+linkEMCCLib :: PackageDescription -> LocalBuildInfo -> IO ()

76+linkEMCCLib desc lbi = linkCLib ("emcc" </> "lib.js") desc lbi

77+

78+linkEMCCTHLib :: PackageDescription -> LocalBuildInfo -> IO ()

79+linkEMCCTHLib desc lbi = linkCLib ("th-support.js") desc lbi

80+

81+linkCLib :: String -> PackageDescription -> LocalBuildInfo -> IO ()

82+linkCLib libname desc lbi = do

83+ withAllComponentsInBuildOrder desc lbi $ \comp clbi -> do

84+ let extraLibs = [ "-l" <> l | l <- concatMap IPI.extraLibraries (topologicalOrder $ installedPkgs lbi)

85+ , l /= "m"

86+ , l /= "dl" ]

87+ libDirs = [ "-L" <> path | path <- concatMap IPI.libraryDirs (topologicalOrder $ installedPkgs lbi) ]

88+

89+ let verbosity = verbose

90+ libs <- filterM doesFileExist $

91+ concatMap (\x -> [ libDir </> "libEMCC" <> (unPackageName . pkgName . sourcePackageId $ x) <> ".js_a"

92+ | libDir <- libraryDirs x ])

93+ (topologicalOrder $ installedPkgs lbi)

94+ exff <- filterM doesFileExist $

95+ concatMap (\x -> [ libDir </> "libEMCC" <> (unPackageName . pkgName . sourcePackageId $ x) <> ".exported.js_a"

96+ | libDir <- libraryDirs x ])

97+ (topologicalOrder $ installedPkgs lbi)

98+ print exff

99+ exfns <- concat <$> forM exff (fmap words . readFile)

100+ unless (null libs && null exfns) $ do

101+ libs <- case libs of

102+ [] -> do writeFile (buildDir lbi </> "emcc_linking_dummy.c") ""

103+ runDbProgram verbosity gccProgram (withPrograms lbi) $

104+ ["-c", buildDir lbi </> "emcc_linking_dummy.c", "-o", buildDir lbi </> "emcc_linking_dummy.o"]

105+ return [(buildDir lbi </> "emcc_linking_dummy.o")]

106+ _ -> return libs

107+

108+ let dst = if libname == "emcc" </> "lib.js" then buildDir lbi

109+ -- who designed this shit in cabal?

110+ else case comp of

111+ (CTest test@(TestSuite { testInterface = TestSuiteLibV09 _ _ })) -> buildDir lbi </> stubName test </> stubName test ++ "-tmp"

112+ (CTest test@(TestSuite { testInterface = TestSuiteExeV10 _ _ })) -> buildDir lbi </> unUnqualComponentName (testName test) </> unUnqualComponentName (testName test) ++ "-tmp"

113+ (CExe exe) -> buildDir lbi </> unUnqualComponentName (exeName exe) </> unUnqualComponentName (exeName exe) ++ "-tmp"

114+ _ -> componentBuildDir lbi clbi

115+ dst' = dst </> libname

116+ createDirectoryIfMissingVerbose verbosity True (takeDirectory dst')

117+ runDbProgram verbosity gccProgram (withPrograms lbi) $

118+ [ "-o", dst'

119+ , "-s", "WASM=0"

120+ , "-s", "ALLOW_TABLE_GROWTH" -- we need this for addFunction/removeFunction

121+ -- addFunction, removeFunction are for dynamic functions.

122+ -- getTempRet0/setTempRet0 are for 64bit legalization.

123+ , "-s", "EXPORTED_RUNTIME_METHODS=['printErr','addFunction','removeFunction','getTempRet0','setTempRet0']"

124+ --

125+ , "-s", "EXPORTED_FUNCTIONS=['" <> intercalate "', '" exfns <> "']"

126+ ] ++ libs ++ libDirs ++ extraLibs

127+

128+postBuildHook :: Args -> BuildFlags -> PackageDescription -> LocalBuildInfo -> IO ()

129+postBuildHook args flags desc lbi = do

130+ case (takeFileName . programPath <$> lookupProgram ghcProgram (withPrograms lbi)) of

131+ Just "js-unknown-ghcjs-ghc" ->

132+ readBuildTargets silent desc (buildArgs flags) >>= \case

133+ [BuildTargetComponent (CLibName _)] -> print "OK. Lib (Build)" >> buildEMCCLib desc lbi

134+ [BuildTargetComponent (CExeName _)] -> print "OK. Exe"

135+ [BuildTargetComponent (CTestName _)] -> print "OK. Test"

136+ [BuildTargetComponent (CBenchName _)] -> print "OK. Bench"

137+ _ -> print "EEk!"

138+ _ -> return ()

139+

140+postConfHook :: Args -> ConfigFlags -> PackageDescription -> LocalBuildInfo -> IO ()

141+postConfHook args flags desc lbi = do

142+ case (takeFileName . programPath <$> lookupProgram ghcProgram (withPrograms lbi)) of

143+ Just "js-unknown-ghcjs-ghc" -> do

144+ -- always link the TH lib

145+ -- this is technically only needed if the package uses TH somewhere.

146+ linkEMCCTHLib desc lbi

147+ -- only link the final lib if we want to produce an output.

148+ readBuildTargets silent desc (configArgs flags) >>= \case

149+ [BuildTargetComponent (CLibName _)] -> print "OK. Lib" >> postConf simpleUserHooks args flags desc lbi

150+ [BuildTargetComponent (CExeName _)] -> print "OK. Exe (Link)" >> linkEMCCLib desc lbi

151+ [BuildTargetComponent (CTestName _)] -> print "OK. Test (Link)" >> linkEMCCLib desc lbi

152+ [BuildTargetComponent (CBenchName _)] -> print "OK. Bench (Link)" >> linkEMCCLib desc lbi

153+ _ -> print "EEk!"

154+ -- defer to default postConf. XXX we should do this for the above cases in linkEMCCLib as well!

155+ _ -> postConf simpleUserHooks args flags desc lbi

156+

157+--

158+-- Injecting emcc/lib.js as needed.

159+--

160+-- We inject jsSources: dist/build/emcc/lib.js, the amalgamated emcc library,

161+-- into Executables, Tests and Benchmarks.

162+emccBuildHook :: PackageDescription -> LocalBuildInfo -> UserHooks -> BuildFlags -> IO ()

163+emccBuildHook desc lbi hooks flags = do

164+ let lbi' = lbi { localPkgDescr = updatePackageDescription (localPkgDescr lbi) }

165+ -- for some reason tests/benchmarks seem to rely on the description, whereas libraries and executables depend on the local build info...

166+ desc' = updatePackageDescription desc

167+ doesFileExist jsLib >>= \x -> print $ jsLib <> " " <> (if x then "exists" else "doesn't exist!")

168+ doesFileExist jsLib >>= \case

169+ True -> buildHook simpleUserHooks desc' lbi' hooks flags

170+ False -> buildHook simpleUserHooks desc lbi hooks flags

171+

172+ where

173+ jsLib = "dist/build" </> "emcc" </> "lib.js"

174+ extraOpts = PerCompilerFlavor [jsLib] []

175+ -- don't inject it for libraries, only for exe, test, bench.

176+ updateLibrary :: Library -> Library

177+ updateLibrary = id -- lib@Library{ libBuildInfo = bi } = lib { libBuildInfo = bi { options = options bi <> extraOpts } }

178+ updateExe :: Executable -> Executable

179+ updateExe exe@Executable{ buildInfo = bi } = exe { buildInfo = bi { options = options bi <> extraOpts } }

180+ updateTest :: TestSuite -> TestSuite

181+ updateTest test@TestSuite{ testBuildInfo = bi } = test { testBuildInfo = bi { options = options bi <> extraOpts } }

182+ updateBench :: Benchmark -> Benchmark

183+ updateBench bench@Benchmark{ benchmarkBuildInfo = bi } = bench { benchmarkBuildInfo = bi { options = options bi <> extraOpts } }

184+ updatePackageDescription :: PackageDescription -> PackageDescription

185+ updatePackageDescription desc = desc

186+ { library = updateLibrary <$> library desc

187+ , executables = updateExe <$> executables desc

188+ , testSuites = updateTest <$> testSuites desc

189+ , benchmarks = updateBench <$> benchmarks desc

190+ }

191+

192+--

193+-- Injecting EMCC<name> extra libraries as needed

194+-- this one we only need alongside library components; as it's shipped and installed

195+-- into the package databse. This is not necesary for executables/test/benchmarks, that

196+-- are not installed into the package database

197+--

198+emccCopyHook :: PackageDescription -> LocalBuildInfo -> UserHooks -> CopyFlags -> IO ()

199+emccCopyHook desc lbi hooks flags = do

200+ emccLibs <- filterM (\l -> doesFileExist (buildDir lbi </> "lib" <> l <> ".js_a"))

201+ [ "EMCC" <> (unPackageName . pkgName . package $ desc)

202+ , "EMCC" <> (unPackageName . pkgName . package $ desc) <> ".exported" ]

203+ print $ "EMCC extra lib files: " ++ intercalate ", " emccLibs

204+ let lbi' = lbi { localPkgDescr = updatePackageDescription emccLibs (localPkgDescr lbi) }

205+ desc' = updatePackageDescription emccLibs desc

206+ copyHook simpleUserHooks desc' lbi' hooks flags

207+ where

208+ emccLib = (buildDir lbi) </> "libEMCC" <> (unPackageName . pkgName . package $ desc) <> ".js_a"

209+ -- don't inject it for libraries, only for exe, test, bench.

210+ updateLibrary :: [String] -> Library -> Library

211+ updateLibrary extraLibs lib@Library{ libBuildInfo = bi } = lib { libBuildInfo = bi { extraBundledLibs = extraBundledLibs bi <> extraLibs } }

212+ updatePackageDescription :: [String] -> PackageDescription -> PackageDescription

213+ updatePackageDescription extraLibs desc = desc { library = updateLibrary extraLibs <$> library desc }

214+

215+emccRegHook :: PackageDescription -> LocalBuildInfo -> UserHooks -> RegisterFlags -> IO ()

216+emccRegHook desc lbi hooks flags = do

217+ emccLibs <- filterM (\l -> doesFileExist (buildDir lbi </> "lib" <> l <> ".js_a"))

218+ [ "EMCC" <> (unPackageName . pkgName . package $ desc)

219+ , "EMCC" <> (unPackageName . pkgName . package $ desc) <> ".exported" ]

220+ print $ "EMCC extra lib files: " ++ intercalate ", " emccLibs

221+ let lbi' = lbi { localPkgDescr = updatePackageDescription emccLibs (localPkgDescr lbi) }

222+ desc' = updatePackageDescription emccLibs desc

223+ regHook simpleUserHooks desc' lbi' hooks flags

224+ where

225+ emccLib = (buildDir lbi) </> "libEMCC" <> (unPackageName . pkgName . package $ desc) <> ".js_a"

226+ -- don't inject it for libraries, only for exe, test, bench.

227+ updateLibrary :: [String] -> Library -> Library

228+ updateLibrary extraLibs lib@Library{ libBuildInfo = bi } = lib { libBuildInfo = bi { extraBundledLibs = extraBundledLibs bi <> extraLibs } }

229+ updatePackageDescription :: [String] -> PackageDescription -> PackageDescription

230+ updatePackageDescription extraLibs desc = desc { library = updateLibrary extraLibs <$> library desc }

231+

232+emccUnregHook :: PackageDescription -> LocalBuildInfo -> UserHooks -> RegisterFlags -> IO ()

233+emccUnregHook desc lbi hooks flags = do

234+ emccLibs <- filterM (\l -> doesFileExist (buildDir lbi </> "lib" <> l <> ".js_a"))

235+ [ "EMCC" <> (unPackageName . pkgName . package $ desc)

236+ , "EMCC" <> (unPackageName . pkgName . package $ desc) <> ".exported" ]

237+ print $ "EMCC extra lib files: " ++ intercalate ", " emccLibs

238+ let lbi' = lbi { localPkgDescr = updatePackageDescription emccLibs (localPkgDescr lbi) }

239+ desc' = updatePackageDescription emccLibs desc

240+ unregHook simpleUserHooks desc' lbi' hooks flags

241+ where

242+ emccLib = (buildDir lbi) </> "libEMCC" <> (unPackageName . pkgName . package $ desc) <> ".js_a"

243+ -- don't inject it for libraries, only for exe, test, bench.

244+ updateLibrary :: [String] -> Library -> Library

245+ updateLibrary extraLibs lib@Library{ libBuildInfo = bi } = lib { libBuildInfo = bi { extraBundledLibs = extraBundledLibs bi <> extraLibs } }

246+ updatePackageDescription :: [String] -> PackageDescription -> PackageDescription

247+ updatePackageDescription extraLibs desc = desc { library = updateLibrary extraLibs <$> library desc }

248+--

249+-- Main

250+--

251+main :: IO ()

252+main = do

253+ args <- getArgs

254+ defaultMainWithHooksArgs emccHooks (injectEmar args)

255+ where

256+ injectEmar :: [String] -> [String]

257+ injectEmar [] = []

258+ injectEmar (x:xs) | "--with-gcc=" `isPrefixOf` x

259+ , "emcc" `isSuffixOf` x

260+ = x:("--with-emar="<> (takeDirectory $ drop 11 $ x) </> "emar"):injectEmar xs

261+ injectEmar (x:xs) = x:injectEmar xs

262+

263+ emccHooks :: UserHooks

264+ emccHooks = simpleUserHooks

265+ { postConf = postConfHook

266+ , buildHook = emccBuildHook

267+ , postBuild = postBuildHook

268+ , copyHook = emccCopyHook

269+ , regHook = emccRegHook

270+ , unregHook = emccUnregHook

271+ , hookedPrograms = [emarProgram]

272+ }

builder/Setup.hsnew file+2

@@ -0,0 +1,2 @@

1+import Distribution.Simple

2+main = defaultMain

builder/comp-builder.nix+455−252

@@ -1,13 +1,6 @@

1−{ stdenv, buildPackages, ghc, lib, gobject-introspection ? null, haskellLib, makeConfigFiles, ghcForComponent, hsPkgs, runCommand, libffi, gmp, zlib, ncurses, numactl, nodejs }:

1+{ pkgs, stdenv, buildPackages, ghc, lib, gobject-introspection ? null, haskellLib, makeConfigFiles, haddockBuilder, ghcForComponent, hsPkgs, compiler, runCommand, libffi, gmp, zlib, ncurses, nodejs }@defaults:

2−let

3− # These are here to avoid multiple calls to override

4− gmpStatic = gmp.override { withStatic = true; };

5− zlibStatic = zlib.static;

6− ncursesStatic = ncurses.override { enableStatic = true; };

7− numactlStatic = numactl.overrideAttrs (_: { configureFlags = "--enable-static"; });

8−in

9lib.makeOverridable (

2lib.makeOverridable (

10−let self =

3+let self =

11{ componentId

4{ componentId

12, component

5, component

13, package

6, package

@@ -30,6 +23,14 @@ let self =

30, preInstall ? component.preInstall , postInstall ? component.postInstall

23, preInstall ? component.preInstall , postInstall ? component.postInstall

31, preHaddock ? component.preHaddock , postHaddock ? component.postHaddock

24, preHaddock ? component.preHaddock , postHaddock ? component.postHaddock

32, shellHook ? ""

25, shellHook ? ""

26+, configureAllComponents ? component.configureAllComponents ||

27+ # When set, configure all the components in the package

28+ # (not just the one we are building).

29+ # Enable for tests in packages that use cabal-doctest.

30+ ( haskellLib.isTest componentId &&

31+ lib.any (x: x.identifier.name or "" == "cabal-doctest") package.setup-depends

32+ )

33+, allComponent # Used when `configureAllComponents` is set to get a suitable configuration.

33

34

34, build-tools ? component.build-tools

35, build-tools ? component.build-tools

35, pkgconfig ? component.pkgconfig

36, pkgconfig ? component.pkgconfig

@@ -38,46 +39,106 @@ let self =

38

39

39, dontPatchELF ? component.dontPatchELF

40, dontPatchELF ? component.dontPatchELF

40, dontStrip ? component.dontStrip

41, dontStrip ? component.dontStrip

42+, hardeningDisable ? component.hardeningDisable

41

43

42, enableStatic ? component.enableStatic

44, enableStatic ? component.enableStatic

43−, enableShared ? component.enableShared && !haskellLib.isCrossHost

45+, enableShared ? ghc.enableShared && component.enableShared && !haskellLib.isCrossHost

46+ # on x86 we'll use shared libraries, even with musl m(

47+ # ghc's internal linker seems to be broken on x86.

48+ && !(stdenv.hostPlatform.isMusl && !stdenv.hostPlatform.isx86)

44, enableDeadCodeElimination ? component.enableDeadCodeElimination

49, enableDeadCodeElimination ? component.enableDeadCodeElimination

50+, writeHieFiles ? component.writeHieFiles

51+

52+, ghcOptions ? component.ghcOptions

53+, contentAddressed ? component.contentAddressed

45

54

46# Options for Haddock generation

55# Options for Haddock generation

47, doHaddock ? component.doHaddock # Enable haddock and hoogle generation

56, doHaddock ? component.doHaddock # Enable haddock and hoogle generation

48, doHoogle ? component.doHoogle # Also build a hoogle index

57, doHoogle ? component.doHoogle # Also build a hoogle index

49, hyperlinkSource ? component.doHyperlinkSource # Link documentation to the source code

58, hyperlinkSource ? component.doHyperlinkSource # Link documentation to the source code

59+, quickjump ? component.doQuickjump # Generate an index for interactive documentation navigation

50−, keepSource ? component.keepSource # Build from `source` output in the store then delete `dist`

60+, keepSource ? component.keepSource || configureAllComponents # Build from `source` output in the store then delete `dist`

51, setupHaddockFlags ? component.setupHaddockFlags

61, setupHaddockFlags ? component.setupHaddockFlags

52

62

53# Profiling

63# Profiling

54, enableLibraryProfiling ? component.enableLibraryProfiling

64, enableLibraryProfiling ? component.enableLibraryProfiling

55−, enableExecutableProfiling ? component.enableExecutableProfiling

65+, enableProfiling ? component.enableProfiling

56, profilingDetail ? component.profilingDetail

66, profilingDetail ? component.profilingDetail

57

67

68+# Coverage

69+, doCoverage ? component.doCoverage

70+

58# Data

71# Data

59, enableSeparateDataOutput ? component.enableSeparateDataOutput

72, enableSeparateDataOutput ? component.enableSeparateDataOutput

60

73

74+# Prelinked ghci libraries; will make iserv faster; especially for static builds.

75+, enableLibraryForGhci ? true

76+

61# Debug

77# Debug

62, enableDebugRTS ? false

78, enableDebugRTS ? false

79+, enableDWARF ? false

80+

81+# This will only work with a custom TSan way enabled custom compiler

82+, enableTSanRTS ? false

83+

84+# LLVM

85+, useLLVM ? ghc.useLLVM

86+, smallAddressSpace ? false

87+

63}@drvArgs:

88}@drvArgs:

64

89

65let

90let

66− # TODO fix cabal wildcard support so hpack wildcards can be mapped to cabal wildcards

91+ componentForSetup =

67− cleanSrc = if cabal-generator == "hpack" && !(package.cleanHpack or false)

92+ if configureAllComponents

68− then builtins.trace ("Cleaning component source not supported for hpack package: " + name) src

93+ then allComponent

69− else haskellLib.cleanCabalComponent package component src;

94+ else component;

95+

96+ # Ignore attempts to include DWARF info when it is not possible

97+ enableDWARF = drvArgs.enableDWARF or false

98+ && stdenv.hostPlatform.isLinux

99+ && !haskellLib.isCrossHost

100+ && !stdenv.hostPlatform.isMusl

101+ && builtins.compareVersions defaults.ghc.version "8.10.2" >= 0;

102+

103+ ghc = (if enableDWARF then (x: x.dwarf) else (x: x)) (

104+ (if smallAddressSpace then (x: x.smallAddressSpace) else (x: x)) defaults.ghc);

105+ setup = (if enableDWARF then (x: x.dwarf) else (x: x)) (

106+ (if smallAddressSpace then (x: x.smallAddressSpace) else (x: x)) drvArgs.setup);

70

107

71− nameOnly = if haskellLib.isAll componentId

108+ # TODO fix cabal wildcard support so hpack wildcards can be mapped to cabal wildcards

72− then "${package.identifier.name}-all"

109+ canCleanSource = !(cabal-generator == "hpack" && !(package.cleanHpack or false));

110+ # In order to support relative references to other packages we need to use

111+ # the `origSrc` diretory as the root `src` for the derivation.

112+ # We use `rootAndSubDir` here to split the cleaned source into a `cleanSrc.root`

113+ # path (that respects the filtering) and a `cleanSrc.subDir` that

114+ # is the sub directory in that root path that contains the package.

115+ # `cleanSrc.subDir` is used in `prePatch` and `lib/cover.nix`.

116+ cleanSrc = haskellLib.rootAndSubDir (if canCleanSource

117+ then haskellLib.cleanCabalComponent package componentForSetup "${componentId.ctype}-${componentId.cname}" src

118+ else

119+ # We can clean out the siblings though to at least avoid changes to other packages

120+ # from triggering a rebuild of this one.

121+ # Passing `subDir` but not `includeSiblings = true;` will exclude anything not

122+ # in the `subDir`.

123+ if src ? origSrc && src ? filter && src.origSubDir or "" != ""

124+ then haskellLib.cleanSourceWith {

125+ name = src.name or "source";

126+ src = src.origSrc;

127+ subDir = lib.removePrefix "/" src.origSubDir;

128+ inherit (src) filter;

129+ }

130+ else src);

131+

73− else "${package.identifier.name}-${componentId.ctype}-${componentId.cname}";

132+ nameOnly = "${package.identifier.name}-${componentId.ctype}-${componentId.cname}";

74

133

75 fullName = "${nameOnly}-${package.identifier.version}";

134 fullName = "${nameOnly}-${package.identifier.version}";

76

135

136+ needsProfiling = enableProfiling || enableLibraryProfiling;

137+

77 configFiles = makeConfigFiles {

138 configFiles = makeConfigFiles {

139+ component = componentForSetup;

78 inherit (package) identifier;

140 inherit (package) identifier;

79− inherit component fullName flags;

141+ inherit fullName flags needsProfiling enableDWARF;

80− needsProfiling = enableExecutableProfiling || enableLibraryProfiling;

81 };

142 };

82

143

83 enableFeature = enable: feature:

144 enableFeature = enable: feature:

@@ -87,18 +148,39 @@ let

87

148

88 finalConfigureFlags = lib.concatStringsSep " " (

149 finalConfigureFlags = lib.concatStringsSep " " (

89 [ "--prefix=$out"

150 [ "--prefix=$out"

151+ ] ++

152+ # We don't specify this in 'commonConfigureFlags', as these are also

153+ # used by haddock-builder.nix. If we do specify these options in

154+ # commonConfigureFlags, then the haddock-builder will fail, because it

155+ # sets its own outputs which *don't* include $hie

156+ lib.optionals writeHieFiles [

157+ "--ghc-option=-fwrite-ide-info" "--ghc-option=-hiedir$hie"

158+ ] ++

159+ (

160+ # If configureAllComponents is set we should not specify the component

161+ # and Setup will attempt to configure them all.

162+ if configureAllComponents

163+ then ["--enable-tests" "--enable-benchmarks"]

90− "${haskellLib.componentTarget componentId}"

164+ else ["${haskellLib.componentTarget componentId}"]

91− "$(cat ${configFiles}/configure-flags)"

165+ ) ++ [ "$(cat ${configFiles}/configure-flags)"

166+ ] ++ commonConfigureFlags);

167+

168+ # From nixpkgs 20.09, the pkg-config exe has a prefix matching the ghc one

169+ pkgConfigHasPrefix = builtins.compareVersions lib.version "20.09pre" >= 0;

170+

171+ commonConfigureFlags = ([

92 # GHC

172 # GHC

93 "--with-ghc=${ghc.targetPrefix}ghc"

173 "--with-ghc=${ghc.targetPrefix}ghc"

94 "--with-ghc-pkg=${ghc.targetPrefix}ghc-pkg"

174 "--with-ghc-pkg=${ghc.targetPrefix}ghc-pkg"

95 "--with-hsc2hs=${ghc.targetPrefix}hsc2hs"

175 "--with-hsc2hs=${ghc.targetPrefix}hsc2hs"

176+ ] ++ lib.optional (pkgConfigHasPrefix && pkgconfig != [])

177+ "--with-pkg-config=${ghc.targetPrefix}pkg-config"

96− ] ++ lib.optionals (stdenv.hasCC or (stdenv.cc != null))

178+ ++ lib.optionals (stdenv.hasCC or (stdenv.cc != null))

97 ( # CC

179 ( # CC

98 [ "--with-gcc=${stdenv.cc.targetPrefix}cc"

180 [ "--with-gcc=${stdenv.cc.targetPrefix}cc"

99 ] ++

181 ] ++

100 # BINTOOLS

182 # BINTOOLS

101− (if stdenv.hostPlatform.isLinux

183+ (if stdenv.hostPlatform.isLinux && !stdenv.hostPlatform.isAndroid # might be better check to see if cc is clang/llvm?

102 # use gold as the linker on linux to improve link times

184 # use gold as the linker on linux to improve link times

103 then [

185 then [

104 "--with-ld=${stdenv.cc.bintools.targetPrefix}ld.gold"

186 "--with-ld=${stdenv.cc.bintools.targetPrefix}ld.gold"

@@ -115,24 +197,21 @@ let

115 (disableFeature dontStrip "executable-stripping")

197 (disableFeature dontStrip "executable-stripping")

116 (disableFeature dontStrip "library-stripping")

198 (disableFeature dontStrip "library-stripping")

117 (enableFeature enableLibraryProfiling "library-profiling")

199 (enableFeature enableLibraryProfiling "library-profiling")

118− (enableFeature enableExecutableProfiling "executable-profiling")

200+ (enableFeature enableProfiling "profiling")

119 (enableFeature enableStatic "static")

201 (enableFeature enableStatic "static")

120 (enableFeature enableShared "shared")

202 (enableFeature enableShared "shared")

203+ (enableFeature doCoverage "coverage")

204+ (enableFeature enableLibraryForGhci "library-for-ghci")

121 ] ++ lib.optionals (stdenv.hostPlatform.isMusl && (haskellLib.isExecutableType componentId)) [

205 ] ++ lib.optionals (stdenv.hostPlatform.isMusl && (haskellLib.isExecutableType componentId)) [

122 # These flags will make sure the resulting executable is statically linked.

206 # These flags will make sure the resulting executable is statically linked.

123 # If it uses other libraries it may be necessary for to add more

207 # If it uses other libraries it may be necessary for to add more

124− # `--ghc-option=-optl=-L` options to the `configurationFlags` of the

208+ # `--ghc-option=-optl=-L` options to the `configureFlags` of the

125 # component.

209 # component.

126 "--disable-executable-dynamic"

210 "--disable-executable-dynamic"

127 "--ghc-option=-optl=-pthread"

211 "--ghc-option=-optl=-pthread"

128 "--ghc-option=-optl=-static"

212 "--ghc-option=-optl=-static"

129− "--ghc-option=-optl=-L${gmpStatic}/lib"

130− "--ghc-option=-optl=-L${zlibStatic}/lib"

131− "--ghc-option=-optl=-L${ncursesStatic}/lib"

132− "--ghc-option=-optl=-L${numactlStatic}/lib"

133 ] ++ lib.optional enableSeparateDataOutput "--datadir=$data/share/${ghc.name}"

213 ] ++ lib.optional enableSeparateDataOutput "--datadir=$data/share/${ghc.name}"

134− ++ lib.optional doHaddock' "--docdir=${docdir "$doc"}"

135− ++ lib.optional (enableLibraryProfiling || enableExecutableProfiling) "--profiling-detail=${profilingDetail}"

214+ ++ lib.optional (enableLibraryProfiling || enableProfiling) "--profiling-detail=${profilingDetail}"

136 ++ lib.optional stdenv.hostPlatform.isLinux (enableFeature enableDeadCodeElimination "split-sections")

215 ++ lib.optional stdenv.hostPlatform.isLinux (enableFeature enableDeadCodeElimination "split-sections")

137 ++ lib.optionals haskellLib.isCrossHost (

216 ++ lib.optionals haskellLib.isCrossHost (

138 map (arg: "--hsc2hs-option=" + arg) (["--cross-compile"] ++ lib.optionals (stdenv.hostPlatform.isWindows) ["--via-asm"])

217 map (arg: "--hsc2hs-option=" + arg) (["--cross-compile"] ++ lib.optionals (stdenv.hostPlatform.isWindows) ["--via-asm"])

@@ -140,10 +219,22 @@ let

140 ++ configureFlags

219 ++ configureFlags

141 ++ (ghc.extraConfigureFlags or [])

220 ++ (ghc.extraConfigureFlags or [])

142 ++ lib.optional enableDebugRTS "--ghc-option=-debug"

221 ++ lib.optional enableDebugRTS "--ghc-option=-debug"

222+ ++ lib.optional enableTSanRTS "--ghc-option=-tsan"

223+ ++ lib.optional enableDWARF "--ghc-option=-g3"

224+ ++ lib.optionals useLLVM [

225+ "--ghc-option=-fPIC" "--gcc-option=-fPIC"

226+ ]

227+ ++ map (o: ''--ghc${lib.optionalString (stdenv.hostPlatform.isGhcjs) "js"}-options="${o}"'') ghcOptions

228+ ++ lib.optional (

229+ # GHC 9.2 cross compiler built with older versions of GHC seem to have problems

230+ # with unique conters. Perhaps because the name changed for the counters.

231+ # TODO This work around to use `-j1` should be removed once we are able to build 9.2 with 9.2.

232+ haskellLib.isCrossHost

233+ && builtins.compareVersions defaults.ghc.version "9.2.1" >= 0

234+ && builtins.compareVersions defaults.ghc.version "9.3" < 0)

235+ "--ghc-options=-j1"

143 );

236 );

144

237

145− setupGhcOptions = lib.optional (package.ghcOptions != null) '' --ghc-options="${package.ghcOptions}"'';

146−

147 executableToolDepends =

238 executableToolDepends =

148 (lib.concatMap (c: if c.isHaskell or false

239 (lib.concatMap (c: if c.isHaskell or false

149 then builtins.attrValues (c.components.exes or {})

240 then builtins.attrValues (c.components.exes or {})

@@ -154,7 +245,8 @@ let

154 # work in the nix-shell. See ../doc/removing-with-package-wrapper.md.

245 # work in the nix-shell. See ../doc/removing-with-package-wrapper.md.

155 shellWrappers = ghcForComponent {

246 shellWrappers = ghcForComponent {

156 componentName = fullName;

247 componentName = fullName;

157− inherit configFiles;

248+ inherit configFiles enableDWARF;

249+ inherit (component) plugins;

158 };

250 };

159

251

160 # In order to let shell hooks make package-specific things like Hoogle databases

252 # In order to let shell hooks make package-specific things like Hoogle databases

@@ -162,232 +254,343 @@ let

162 if builtins.isFunction shellHook then shellHook { inherit package shellWrappers; }

254 if builtins.isFunction shellHook then shellHook { inherit package shellWrappers; }

163 else abort "shellHook should be a string or a function";

255 else abort "shellHook should be a string or a function";

164

256

165− # the target dir for haddock documentation

166− docdir = docoutput: docoutput + "/share/doc/" + componentId.cname;

167−

168− doHaddock' = doHaddock

169− && (haskellLib.isLibrary componentId)

170− && !haskellLib.isCrossHost;

171−

172 exeExt = if stdenv.hostPlatform.isGhcjs then ".jsexe/all.js" else

257 exeExt = if stdenv.hostPlatform.isGhcjs then ".jsexe/all.js" else

173− if stdenv.hostPlatform.isWindows then ".exe" else "";

258+ stdenv.hostPlatform.extensions.executable;

174 exeName = componentId.cname + exeExt;

259 exeName = componentId.cname + exeExt;

175 testExecutable = "dist/build/${componentId.cname}/${exeName}";

260 testExecutable = "dist/build/${componentId.cname}/${exeName}";

176

261

177−in stdenv.lib.fix (drv:

262+ # Attributes that are common to both the build and haddock derivations

178−

263+ commonAttrs = {

179−stdenv.mkDerivation ({

264+ src = cleanSrc.root;

180− pname = nameOnly;

265+

266+ LANG = "en_US.UTF-8"; # GHC needs the locale configured during the Haddock phase.

267+ LC_ALL = "en_US.UTF-8";

268+

269+ enableParallelBuilding = true;

270+

271+ SETUP_HS = setup + /bin/Setup;

272+

273+ prePatch =

274+ # If the package is in a sub directory `cd` there first.

275+ # In some cases the `cleanSrc.subDir` will be empty and the `.cabal`

276+ # file will be in the root of `src` (`cleanSrc.root`). This

277+ # will happen when:

278+ # * the .cabal file is in the projects `src.origSrc or src`

279+ # * the package src was overridden with a value that does not

280+ # include an `origSubDir`

281+ (lib.optionalString (cleanSrc.subDir != "") ''

282+ cd ${lib.removePrefix "/" cleanSrc.subDir}

283+ ''

284+ ) +

285+ (if cabalFile != null

286+ then ''cat ${cabalFile} > ${package.identifier.name}.cabal''

287+ else

288+ # When building hpack package we use the internal nix-tools

289+ # (compiled with a fixed GHC version)

290+ lib.optionalString (cabal-generator == "hpack") ''

291+ ${buildPackages.haskell-nix.internal-nix-tools}/bin/hpack

292+ ''

293+ );

294+ }

295+ # patches can (if they like) depend on the version and revision of the package.

296+ // lib.optionalAttrs (patches != []) {

297+ patches = map (p:

298+ if builtins.isFunction p

181− inherit (package.identifier) version;

299+ then p { inherit (package.identifier) version; inherit revision; }

182−

300+ else p

183− src = cleanSrc;

301+ ) patches;

184−

302+ }

185− doCheck = false;

303+ // haskellLib.optionalHooks {

186− doCrossCheck = false;

304+ # These are hooks are needed to set up the source for building and running haddock

305+ inherit preUnpack postUnpack preConfigure postConfigure;

306+ }

307+ // lib.optionalAttrs (stdenv.buildPlatform.libc == "glibc") {

308+ LOCALE_ARCHIVE = "${buildPackages.glibcLocales}/lib/locale/locale-archive";

309+ };

187

310

188− inherit dontPatchELF dontStrip;

311+ haddock = haddockBuilder {

312+ inherit componentId component package flags commonConfigureFlags

313+ commonAttrs revision doHaddock

314+ doHoogle hyperlinkSource quickjump setupHaddockFlags

315+ needsProfiling configFiles preHaddock postHaddock pkgconfig;

189

316

190− passthru = {

317+ componentDrv = drv;

191− inherit (package) identifier;

192− config = component;

193− inherit configFiles executableToolDepends cleanSrc exeName;

194− env = shellWrappers;

195−

196− # The directory containing the haddock documentation.

197− # `null' if no haddock documentation was built.

198− haddockDir = if doHaddock' then "${docdir drv.doc}/html" else null;

199− profiled = self (drvArgs // { enableLibraryProfiling = true; });

200 };

318 };

201

319

202− meta = {

320+ contentAddressedAttrs = lib.optionalAttrs contentAddressed {

203− homepage = package.homepage;

321+ __contentAddressed = true;

204− description = package.synopsis;

322+ outputHashMode = "recursive";

205− license =

323+ outputHashAlgo = "sha256";

206− let

207− license-map = import ../lib/cabal-licenses.nix lib;

208− in license-map.${package.license} or

209− (builtins.trace "WARNING: license \"${package.license}\" not found" license-map.LicenseRef-OtherLicense);

210− platforms = if platforms == null then stdenv.lib.platforms.all else platforms;

211 };

324 };

325+

326+ drv = stdenv.mkDerivation (commonAttrs // contentAddressedAttrs // {

327+ pname = nameOnly;

328+ inherit (package.identifier) version;

329+

330+ doCheck = false;

331+ doCrossCheck = false;

332+

333+ inherit dontPatchELF dontStrip;

334+

335+ passthru = {

336+ inherit (package) identifier;

337+ config = component;

338+ srcSubDir = cleanSrc.subDir;

339+ srcSubDirPath = cleanSrc.root + cleanSrc.subDir;

340+ inherit configFiles executableToolDepends exeName enableDWARF;

341+ exePath = drv + "/bin/${exeName}";

342+ env = shellWrappers;

343+ profiled = self (drvArgs // { enableLibraryProfiling = true; });

344+ dwarf = self (drvArgs // { enableDWARF = true; });

345+ } // lib.optionalAttrs (haskellLib.isLibrary componentId) ({

346+ inherit haddock;

347+ inherit (haddock) haddockDir; # This is null if `doHaddock = false`

348+ } // lib.optionalAttrs (haddock ? doc) {

349+ # `doHaddock = false` turns the doc of haddock output off

350+ inherit (haddock) doc;

351+ }

352+ );

212

353

213− LANG = "en_US.UTF-8"; # GHC needs the locale configured during the Haddock phase.

354+ meta = {

214− LC_ALL = "en_US.UTF-8";

355+ homepage = package.homepage or "";

215−

356+ description = package.synopsis or "";

216− enableParallelBuilding = true;

357+ license = haskellLib.cabalToNixpkgsLicense package.license;

217−

358+ platforms = if platforms == null then lib.platforms.all else platforms;

359+ } // lib.optionalAttrs (haskellLib.isExecutableType componentId) {

360+ # Set main executable name for executable components, so that `nix run` in

361+ # nix flakes will work correctly. When not set, `nix run` would (typically

362+ # erroneously) deduce the executable name from the derivation name and

363+ # attempt to run, for example,

364+ # `/nix/store/...-project-exe-app-0.1.0.0/bin/project-exe-app` instead of

365+ # `/nix/store/...-project-exe-app-0.1.0.0/bin/app`.

366+ mainProgram = exeName;

367+ };

368+

218− propagatedBuildInputs =

369+ propagatedBuildInputs =

219− frameworks # Frameworks will be needed at link time

370+ frameworks # Frameworks will be needed at link time

220− # Not sure why pkgconfig needs to be propagatedBuildInputs but

371+ # Not sure why pkgconfig needs to be propagatedBuildInputs but

221− # for gi-gtk-hs it seems to help.

372+ # for gi-gtk-hs it seems to help.

222− ++ builtins.concatLists pkgconfig;

373+ ++ builtins.concatLists pkgconfig

223−

374+ ++ lib.optionals (stdenv.hostPlatform.isWindows)

375+ (lib.flatten component.libs

376+ ++ map haskellLib.dependToLib component.depends);

377+

378+ buildInputs = lib.optionals (!stdenv.hostPlatform.isWindows)

224− buildInputs = component.libs

379+ (lib.flatten component.libs

225− ++ map (d: d.components.library or d) component.depends;

380+ ++ map haskellLib.dependToLib component.depends);

226−

381+

227− nativeBuildInputs =

382+ nativeBuildInputs =

228− [shellWrappers buildPackages.removeReferencesTo]

383+ [shellWrappers buildPackages.removeReferencesTo]

229− ++ executableToolDepends;

384+ ++ executableToolDepends;

230−

385+

231− SETUP_HS = setup + /bin/Setup;

232−

233− outputs = ["out" ]

386+ outputs = ["out" ]

234− ++ (lib.optional enableSeparateDataOutput "data")

387+ ++ (lib.optional enableSeparateDataOutput "data")

235− ++ (lib.optional doHaddock' "doc")

388+ ++ (lib.optional keepSource "source")

236− ++ (lib.optional keepSource "source");

389+ ++ (lib.optional writeHieFiles "hie");

237−

390+

238− # Phases

391+ prePatch =

239− preInstallPhases = lib.optional doHaddock' "haddockPhase";

392+ # emcc is very slow if it cannot cache stuff in $HOME

240−

393+ (lib.optionalString (stdenv.hostPlatform.isGhcjs) ''

241− prePatch = if (cabalFile != null)

394+ export HOME=$(mktemp -d)

242− then ''cat ${cabalFile} > ${package.identifier.name}.cabal''

395+ '') +

243− else lib.optionalString (cabal-generator == "hpack") ''

396+ (lib.optionalString (!canCleanSource) ''

244− ${buildPackages.haskell-nix.haskellPackages.hpack.components.exes.hpack}/bin/hpack

397+ echo "Cleaning component source not supported, leaving it un-cleaned"

245− '';

398+ '') +

246−

247− configurePhase =

248− (lib.optionalString keepSource ''

399+ (lib.optionalString keepSource ''

249− cp -r . $source

400+ cp -r . $source

250− cd $source

401+ cd $source

251− chmod -R +w .

402+ chmod -R +w .

252− '') + ''

403+ '') + commonAttrs.prePatch;

404+

405+ configurePhase = ''

253− runHook preConfigure

406+ runHook preConfigure

254− echo Configure flags:

407+ echo Configure flags:

255− printf "%q " ${finalConfigureFlags}

408+ printf "%q " ${finalConfigureFlags}

256− echo

409+ echo

257− $SETUP_HS configure ${finalConfigureFlags}

410+ $SETUP_HS configure ${finalConfigureFlags}

258− runHook postConfigure

411+ runHook postConfigure

259− '';

412+ '';

260−

413+

261− buildPhase = ''

414+ buildPhase =

415+ # It seems that by the time the iserv wrapper specifiec by `--ghc-option=-pgmi` runs

416+ # all the array environment variables are removed from the environment. To get a list

417+ # of all the locations a DLLs might be present we need access to pkgsHostTarget.

418+ # Adding a string version of the list array of nix store paths allows us to get that

419+ # list when we need it.

420+ (lib.optionalString stdenv.hostPlatform.isWindows ''

421+ export pkgsHostTargetAsString="''${pkgsHostTarget[@]}"

422+ '') +

423+ # The following could be refactored but would lead to many rebuilds

424+

425+ # In case of content addressed components we need avoid parallel building (passing -j1)

426+ # in order to have a deterministic output and therefore avoid potential situations

427+ # where the binary cache becomes useless

428+ # See also https://gitlab.haskell.org/ghc/ghc/-/issues/12935

429+ (if contentAddressed then ''

430+ runHook preBuild

431+ $SETUP_HS build ${haskellLib.componentTarget componentId} -j1 ${lib.concatStringsSep " " setupBuildFlags}

432+ runHook postBuild

433+ '' else if stdenv.hostPlatform.isGhcjs then ''

262− runHook preBuild

434+ runHook preBuild

263− # https://gitlab.haskell.org/ghc/ghc/issues/9221

435+ # https://gitlab.haskell.org/ghc/ghc/issues/9221

436+ $SETUP_HS build ${haskellLib.componentTarget componentId} ${lib.concatStringsSep " " setupBuildFlags}

437+ runHook postBuild

438+ '' else ''

439+ runHook preBuild

440+ # https://gitlab.haskell.org/ghc/ghc/issues/9221

264− $SETUP_HS build ${haskellLib.componentTarget componentId} -j$(($NIX_BUILD_CORES > 4 ? 4 : $NIX_BUILD_CORES)) ${lib.concatStringsSep " " (setupBuildFlags ++ setupGhcOptions)}

441+ $SETUP_HS build ${haskellLib.componentTarget componentId} -j$(($NIX_BUILD_CORES > 4 ? 4 : $NIX_BUILD_CORES)) ${lib.concatStringsSep " " setupBuildFlags}

265− runHook postBuild

442+ runHook postBuild

266− '';

443+ '');

267−

444+

268− checkPhase = "notice: Tests are only executed by building the .run sub-derivation of this component.";

269−

270− haddockPhase = ''

271− runHook preHaddock

272− # If we don't have any source files, no need to run haddock

273− [[ -n $(find . -name "*.hs" -o -name "*.lhs") ]] && {

274− docdir="${docdir "$doc"}"

275− mkdir -p "$docdir"

276−

277− $SETUP_HS haddock \

278− "--html" \

279− ${lib.optionalString doHoogle "--hoogle"} \

280− ${lib.optionalString hyperlinkSource "--hyperlink-source"} \

281− ${lib.concatStringsSep " " (setupHaddockFlags ++ setupGhcOptions)}

282−

283− html="dist/doc/html/${componentId.cname}"

284−

285− if [ -d "$html" ]; then

286− # Ensure that libraries are not pulled into the docs closure.

287− # As an example, the prettified source code of a

288− # Paths_package module will contain store paths of the library package.

289− for x in "$html/src/"*.html; do

290− remove-references-to -t $out $x

291− done

292−

293− cp -R "$html" "$docdir"/html

294− fi

295− }

296− runHook postHaddock

297− '';

298−

299− # Note: Cabal does *not* copy test executables during the `install` phase.

445+ # Note: Cabal does *not* copy test executables during the `install` phase.

300− #

446+ #

301− # Note 2: if a package contains multiple libs (lib + sublibs) SETUP register will generate a

447+ # Note 2: if a package contains multiple libs (lib + sublibs) SETUP register will generate a

302− # folder isntead of a file for the configuration. Therfore if the result is a folder,

448+ # folder instead of a file for the configuration. Therefore if the result is a folder,

303− # we need to register each and every element of that folder.

449+ # we need to register each and every element of that folder.

304− #

450+ #

305− # Note 3: if a package has no libs SETUP will not generate anything. This can

451+ # Note 3: if a package has no libs SETUP will not generate anything. This can

306− # happen when building the `all` component of a package.

452+ # happen when building the `all` component of a package.

307− installPhase = let

453+ installPhase = let

308− target-pkg-and-db = "${ghc.targetPrefix}ghc-pkg -v0 --package-db $out/package.conf.d";

454+ target-pkg-and-db = "${ghc.targetPrefix}ghc-pkg -v0 --package-db $out/package.conf.d";

309− in ''

455+ in ''

310− runHook preInstall

456+ runHook preInstall

311− $SETUP_HS copy ${lib.concatStringsSep " " setupInstallFlags}

457+ $SETUP_HS copy ${lib.concatStringsSep " " (

458+ setupInstallFlags

459+ ++ lib.optional configureAllComponents

460+ (haskellLib.componentTarget componentId)

461+ )}

312− ${lib.optionalString (haskellLib.isLibrary componentId || haskellLib.isAll componentId) ''

462+ ${lib.optionalString (haskellLib.isLibrary componentId) ''

313− $SETUP_HS register --gen-pkg-config=${name}.conf

463+ $SETUP_HS register --gen-pkg-config=${name}.conf

314− ${ghc.targetPrefix}ghc-pkg -v0 init $out/package.conf.d

464+ ${ghc.targetPrefix}ghc-pkg -v0 init $out/package.conf.d

315− if [ -d "${name}.conf" ]; then

316− for pkg in ${name}.conf/*; do

317− ${ghc.targetPrefix}ghc-pkg -v0 --package-db ${configFiles}/${configFiles.packageCfgDir} -f $out/package.conf.d register "$pkg"

318− done

319− elif [ -e "${name}.conf" ]; then

320 ${ghc.targetPrefix}ghc-pkg -v0 --package-db ${configFiles}/${configFiles.packageCfgDir} -f $out/package.conf.d register ${name}.conf

465 ${ghc.targetPrefix}ghc-pkg -v0 --package-db ${configFiles}/${configFiles.packageCfgDir} -f $out/package.conf.d register ${name}.conf

321− fi

322−

323− mkdir -p $out/exactDep

324− touch $out/exactDep/configure-flags

325− touch $out/exactDep/cabal.config

326−

327− if id=$(${target-pkg-and-db} field ${package.identifier.name} id --simple-output); then

328− echo "--dependency=${package.identifier.name}=$id" >> $out/exactDep/configure-flags

329− elif id=$(${target-pkg-and-db} field "z-${package.identifier.name}-z-*" id --simple-output); then

330− name=$(${target-pkg-and-db} field "z-${package.identifier.name}-z-*" name --simple-output)

331− # so we are dealing with a sublib. As we build sublibs separately, the above

332− # query should be safe.

333− echo "--dependency=''${name#z-${package.identifier.name}-z-}=$id" >> $out/exactDep/configure-flags

334− fi

335− if ver=$(${target-pkg-and-db} field ${package.identifier.name} version --simple-output); then

336− echo "constraint: ${package.identifier.name} == $ver" >> $out/exactDep/cabal.config

337− echo "constraint: ${package.identifier.name} installed" >> $out/exactDep/cabal.config

338− fi

339

466

467+ mkdir -p $out/exactDep

468+ touch $out/exactDep/configure-flags

469+ touch $out/exactDep/cabal.config

340− touch $out/envDep

470+ touch $out/envDep

471+

472+ ${ # The main library in a package has the same name as the package

473+ if package.identifier.name == componentId.cname

474+ then ''

341− if id=$(${target-pkg-and-db} field ${package.identifier.name} id --simple-output); then

475+ if id=$(${target-pkg-and-db} field ${package.identifier.name} id --simple-output); then

476+ echo "--dependency=${package.identifier.name}=$id" >> $out/exactDep/configure-flags

342− echo "package-id $id" >> $out/envDep

477+ echo "package-id $id" >> $out/envDep

343− fi

478+ else

344− ''}

479+ echo 'ERROR: ${package.identifier.name} id could not be found with ${target-pkg-and-db}'

480+ exit 1

481+ fi

482+ if ver=$(${target-pkg-and-db} field ${package.identifier.name} version --simple-output); then

483+ echo "constraint: ${package.identifier.name} == $ver" >> $out/exactDep/cabal.config

484+ echo "constraint: ${package.identifier.name} installed" >> $out/exactDep/cabal.config

485+ else

486+ echo 'ERROR: ${package.identifier.name} version could not be found with ${target-pkg-and-db}'

487+ exit 1

488+ fi

489+ ''

490+ else

491+ # If the component name is not the package name this must be a sublib.

492+ # As we build sublibs separately, the following query should be safe.

493+ (''

494+ if id=$(${target-pkg-and-db} field "z-${package.identifier.name}-z-*" id --simple-output); then

495+ name=$(${target-pkg-and-db} field "z-${package.identifier.name}-z-*" name --simple-output)

496+ echo "--dependency=''${name#z-${package.identifier.name}-z-}=$id" >> $out/exactDep/configure-flags

497+ ''

498+ # Allow `package-name:sublib-name` to work in `build-depends`

499+ # by adding the same `--dependency` again, but with the package

500+ # name added.

501+ + ''

502+ echo "--dependency=${package.identifier.name}:''${name#z-${package.identifier.name}-z-}=$id" >> $out/exactDep/configure-flags

503+ else

504+ echo 'ERROR: ${package.identifier.name} id could not be found with ${target-pkg-and-db}'

505+ exit 1

506+ fi

507+ '')

508+ }

509+ ''}

345− ${(lib.optionalString (haskellLib.isTest componentId || haskellLib.isBenchmark componentId || haskellLib.isAll componentId) ''

510+ ${(lib.optionalString (haskellLib.isTest componentId || haskellLib.isBenchmark componentId) ''

346− mkdir -p $out/bin

511+ mkdir -p $out/bin

347− if [ -f ${testExecutable} ]; then

512+ if [ -f ${testExecutable} ]; then

348− mkdir -p $(dirname $out/bin/${exeName})

513+ mkdir -p $(dirname $out/bin/${exeName})

349− ${if stdenv.hostPlatform.isGhcjs then ''

514+ ${if stdenv.hostPlatform.isGhcjs then ''

350− cat <(echo \#!${lib.getBin buildPackages.nodejs}/bin/node) ${testExecutable} >| $out/bin/${exeName}

515+ cat <(echo \#!${lib.getBin buildPackages.nodejs-12_x}/bin/node) ${testExecutable} >| $out/bin/${exeName}

351− chmod +x $out/bin/${exeName}

516+ chmod +x $out/bin/${exeName}

352− '' else ''

517+ '' else ''

353− cp -r ${testExecutable} $(dirname $out/bin/${exeName})

518+ cp -r ${testExecutable} $(dirname $out/bin/${exeName})

354− ''}

519+ ''}

355− fi

356− '')

357− # In case `setup copy` did not creat this

358− + (lib.optionalString enableSeparateDataOutput "mkdir -p $data")

359− + (lib.optionalString (stdenv.hostPlatform.isWindows && (haskellLib.mayHaveExecutable componentId)) ''

360− echo "Symlink libffi and gmp .dlls ..."

361− for p in ${lib.concatStringsSep " " [ libffi gmp ]}; do

362− find "$p" -iname '*.dll' -exec ln -s {} $out/bin \;

363− done

364− # symlink all .dlls into the local directory.

365− # we ask ghc-pkg for *all* dynamic-library-dirs and then iterate over the unique set

366− # to symlink over dlls as needed.

367− echo "Symlink library dependencies..."

368− for libdir in $(x86_64-pc-mingw32-ghc-pkg --package-db=$packageConfDir field "*" dynamic-library-dirs --simple-output|xargs|sed 's/ /\n/g'|sort -u); do

369− if [ -d "$libdir" ]; then

370− find "$libdir" -iname '*.dll' -exec ln -s {} $out/bin \;

371 fi

520 fi

521+ '')

522+ # In case `setup copy` did not create this

523+ + (lib.optionalString enableSeparateDataOutput ''

524+ mkdir -p $data

525+ '')

526+ + (lib.optionalString (stdenv.hostPlatform.isWindows && (haskellLib.mayHaveExecutable componentId)) (''

527+ echo "Symlink libffi and gmp .dlls ..."

528+ for p in ${lib.concatStringsSep " " [ libffi gmp ]}; do

529+ find "$p" -iname '*.dll' -exec ln -s {} $out/bin \;

372− done

530+ done

373− '')

531+ ''

532+ # symlink all .dlls into the local directory.

533+ + ''

534+ for p in $pkgsHostTargetAsString; do

535+ find "$p" -iname '*.dll' -exec ln -s {} $out/bin \;

536+ find "$p" -iname '*.dll.a' -exec ln -s {} $out/bin \;

537+ done

538+ ''))

539+ + (lib.optionalString doCoverage ''

540+ mkdir -p $out/share

541+ cp -r dist/hpc $out/share

542+ cp dist/setup-config $out/

543+ '')

374− }

544+ }

375− runHook postInstall

545+ runHook postInstall

546+ '' + (

547+ # Keep just the autogen files and package.conf.inplace package

548+ # DB (probably empty unless this is a library component).

549+ # We also have to remove any refernces to $out to avoid

550+ # circular references.

376− '' + (lib.optionalString keepSource ''

551+ lib.optionalString (configureAllComponents || keepSource) ''

552+ mv dist dist-tmp-dir

553+ mkdir -p dist/build

554+ if [ -d dist-tmp-dir/build/${componentId.cname}/autogen ]; then

555+ mv dist-tmp-dir/build/${componentId.cname}/autogen dist/build/

556+ elif [ -d dist-tmp-dir/build/autogen ]; then

557+ mv dist-tmp-dir/build/autogen dist/build/

558+ fi

559+ mv dist-tmp-dir/package.conf.inplace dist/

560+ if [ -d dist/build/autogen ]; then

561+ remove-references-to -t $out dist/build/autogen/*

562+ fi

377− rm -rf dist

563+ rm -rf dist-tmp-dir

564+ ''

565+ ) + (lib.optionalString (keepSource && haskellLib.isLibrary componentId) ''

566+ remove-references-to -t $out ${name}.conf

567+ '') + (lib.optionalString (haskellLib.isTest componentId) ''

568+ echo The test ${package.identifier.name}.components.tests.${componentId.cname} was built. To run the test build ${package.identifier.name}.checks.${componentId.cname}.

378− '');

569+ '');

379−

570+

571+ doInstallCheck = true;

572+ installCheckPhase = lib.optionalString (haskellLib.isLibrary componentId) ''

573+ if test -n "$(shopt -s nullglob; echo $out/package.conf.d/${name}-*.conf)"; then

574+ echo $out/package.conf.d/${name}-*.conf " is present"

575+ else

576+ echo "ERROR: $out/package.conf.d/${name}-*.conf was not created"

577+ exit 1

578+ fi

579+ '';

580+

380− shellHook = ''

581+ shellHook = ''

381− export PATH="${shellWrappers}/bin:$PATH"

582+ export PATH="${shellWrappers}/bin:$PATH"

382− ${shellHookApplied}

583+ ${shellHookApplied}

383− '';

584+ '';

384−}

585+ }

385−# patches can (if they like) depend on the version and revision of the package.

386−// lib.optionalAttrs (patches != []) { patches = map (p: if builtins.isFunction p then p { inherit (package.identifier) version; inherit revision; } else p) patches; }

387−// haskellLib.optionalHooks {

586+ // haskellLib.optionalHooks {

388− inherit preUnpack postUnpack preConfigure postConfigure

587+ # These are the hooks that are not needed by haddock (see commonAttrs for the ones that

588+ # are shared with the haddock derivation)

589+ inherit

389− preBuild postBuild

590+ preBuild postBuild

390− preInstall postInstall preHaddock postHaddock;

591+ preInstall postInstall;

391−}

592+ }

392−// lib.optionalAttrs (stdenv.buildPlatform.libc == "glibc"){ LOCALE_ARCHIVE = "${buildPackages.glibcLocales}/lib/locale/locale-archive"; }

593+ // lib.optionalAttrs (hardeningDisable != [] || stdenv.hostPlatform.isMusl) {

594+ hardeningDisable = hardeningDisable ++ lib.optional stdenv.hostPlatform.isMusl "pie";

595+ });

393−)); in self)

596+in drv; in self)

builder/default.nix+35−20

@@ -1,20 +1,24 @@

1−{ pkgs, buildPackages, stdenv, lib, haskellLib, ghc, fetchurl, pkgconfig, nonReinstallablePkgs, hsPkgs }:

1+{ pkgs, buildPackages, evalPackages, stdenv, lib, haskellLib, ghc, compiler-nix-name, fetchurl, pkgconfig, nonReinstallablePkgs, hsPkgs, compiler }:

2

3let

4 # Builds a single component of a package.

5 comp-builder = haskellLib.weakCallPackage pkgs ./comp-builder.nix {

6− inherit ghc haskellLib makeConfigFiles ghcForComponent hsPkgs;

6+ inherit ghc haskellLib makeConfigFiles haddockBuilder ghcForComponent hsPkgs compiler;

7+ };

8+

9+ haddockBuilder = haskellLib.weakCallPackage pkgs ./haddock-builder.nix {

10+ inherit ghc ghcForComponent haskellLib makeConfigFiles nonReinstallablePkgs;

7 };

11 };

8

12

9 setup-builder = haskellLib.weakCallPackage pkgs ./setup-builder.nix {

13 setup-builder = haskellLib.weakCallPackage pkgs ./setup-builder.nix {

10 ghc = (ghc.passthru.buildGHC or ghc);

14 ghc = (ghc.passthru.buildGHC or ghc);

11 hsPkgs = hsPkgs.buildPackages;

15 hsPkgs = hsPkgs.buildPackages;

12 # We need to use the buildPackages stdenv to build the setup-builder.

16 # We need to use the buildPackages stdenv to build the setup-builder.

13− # in the native case, it would be the same in the corss case however

17+ # in the native case, it would be the same in the cross case however

14− # re *really* want to build the Setup.hs on the build machine and not

18+ # we *really* want to build the Setup.hs on the build machine and not

15 # have the stdenv confuse it with the target/host env.

19 # have the stdenv confuse it with the target/host env.

16− inherit (buildPackages) stdenv;

20+ inherit (buildPackages) stdenv pkgconfig;

17− inherit buildPackages pkgconfig;

21+ inherit buildPackages;

18 inherit haskellLib nonReinstallablePkgs makeSetupConfigFiles;

22 inherit haskellLib nonReinstallablePkgs makeSetupConfigFiles;

19 };

23 };

20

24

@@ -22,8 +26,9 @@ let

22 # component builder and for nix-shells.

26 # component builder and for nix-shells.

23 ghcForComponent = import ./ghc-for-component-wrapper.nix {

27 ghcForComponent = import ./ghc-for-component-wrapper.nix {

24 inherit lib ghc haskellLib;

28 inherit lib ghc haskellLib;

25− inherit (buildPackages) stdenv runCommand makeWrapper;

29+ inherit (buildPackages) stdenv;

30+ inherit (buildPackages.buildPackages) runCommand makeWrapper;

26− inherit (buildPackages.xorg) lndir;

31+ inherit (buildPackages.buildPackages.xorg) lndir;

27 };

32 };

28

33

29 # Builds a derivation which contains a ghc package-db of

34 # Builds a derivation which contains a ghc package-db of

@@ -40,20 +45,30 @@ let

40

45

41 hoogleLocal = let

46 hoogleLocal = let

42 nixpkgsHoogle = import (pkgs.path + /pkgs/development/haskell-modules/hoogle.nix);

47 nixpkgsHoogle = import (pkgs.path + /pkgs/development/haskell-modules/hoogle.nix);

43− in { packages ? [], hoogle ? pkgs.buildPackages.haskell-nix.tool "hoogle" "5.0.17.15" }:

48+ in { packages ? [], hoogle ? pkgs.buildPackages.haskell-nix.tool "ghc8107" "hoogle" {

44− haskellLib.weakCallPackage pkgs nixpkgsHoogle {

49+ inherit evalPackages;

50+ version = "5.0.18.3";

51+ index-state = pkgs.haskell-nix.internalHackageIndexState;

52+ }

53+ }:

54+ let

55+ haskellPackages = {

45− # For musl we can use haddock from the buildGHC

56+ # For musl we can use haddock from the buildGHC

46− ghc = if stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl && !haskellLib.isNativeMusl

57+ ghc = if stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl && !haskellLib.isNativeMusl

47− then ghc.buildGHC

58+ then ghc.buildGHC

48− else ghc;

59+ else ghc;

49− inherit packages hoogle;

60+ inherit packages hoogle;

50− };

61+ };

62+ in if lib.versionAtLeast lib.trivial.release "22.05"

63+ then haskellLib.weakCallPackage pkgs nixpkgsHoogle {

64+ inherit haskellPackages;

65+ } (p: p.packages)

66+ else haskellLib.weakCallPackage pkgs nixpkgsHoogle haskellPackages;

51

67

52 # Same as haskellPackages.shellFor in nixpkgs.

68 # Same as haskellPackages.shellFor in nixpkgs.

53 shellFor = haskellLib.weakCallPackage pkgs ./shell-for.nix {

69 shellFor = haskellLib.weakCallPackage pkgs ./shell-for.nix {

54− inherit hsPkgs ghcForComponent makeConfigFiles hoogleLocal haskellLib buildPackages;

70+ inherit hsPkgs ghcForComponent makeConfigFiles hoogleLocal haskellLib buildPackages evalPackages compiler;

55 inherit (buildPackages) glibcLocales;

71 inherit (buildPackages) glibcLocales;

56− buildGHC = ghc.passthru.buildGHC or ghc;

57 };

72 };

58

73

59 # Same as haskellPackages.ghcWithPackages and ghcWithHoogle in nixpkgs.

74 # Same as haskellPackages.ghcWithPackages and ghcWithHoogle in nixpkgs.

@@ -68,10 +83,10 @@ in {

68 # Build a Haskell package from its config.

83 # Build a Haskell package from its config.

69 # TODO: this pkgs is the adjusted pkgs, but pkgs.pkgs is unadjusted

84 # TODO: this pkgs is the adjusted pkgs, but pkgs.pkgs is unadjusted

70 build-package = haskellLib.weakCallPackage pkgs ./hspkg-builder.nix {

85 build-package = haskellLib.weakCallPackage pkgs ./hspkg-builder.nix {

71− inherit haskellLib ghc comp-builder setup-builder;

86+ inherit haskellLib ghc compiler-nix-name comp-builder setup-builder;

72 };

87 };

73

88

74− inherit shellFor;

89+ inherit shellFor makeConfigFiles;

75

90

76 ghcWithPackages = withPackages { withHoogle = false; };

91 ghcWithPackages = withPackages { withHoogle = false; };

77 ghcWithHoogle = withPackages { withHoogle = true; };

92 ghcWithHoogle = withPackages { withHoogle = true; };

builder/ghc-for-component-wrapper.nix+65−13

@@ -7,14 +7,18 @@

7# database.

8

9{ lib, stdenv, ghc, runCommand, lndir, makeWrapper, haskellLib

10−}:

10+}@defaults:

11

12{ componentName # Full derivation name of the component

13, configFiles # The component's "config" derivation

14, postInstall ? ""

15+, enableDWARF

16+, plugins

15}:

17}:

16

18

17let

19let

20+ ghc = if enableDWARF then defaults.ghc.dwarf else defaults.ghc;

21+

18 inherit (configFiles) targetPrefix ghcCommand ghcCommandCaps packageCfgDir;

22 inherit (configFiles) targetPrefix ghcCommand ghcCommandCaps packageCfgDir;

19 libDir = "$out/${configFiles.libDir}";

23 libDir = "$out/${configFiles.libDir}";

20 docDir = "$out/share/doc/ghc/html";

24 docDir = "$out/share/doc/ghc/html";

@@ -34,27 +38,70 @@ in runCommand "${componentName}-${ghc.name}-env" {

34 ''

38 ''

35 . ${makeWrapper}/nix-support/setup-hook

39 . ${makeWrapper}/nix-support/setup-hook

36

40

41+ ''

37− # Start with a ghc...

42+ # Start with a ghc and remove all of the package directories

43+ + ''

38 mkdir -p $out/bin

44 mkdir -p $out/bin

39 ${lndir}/bin/lndir -silent ${ghc} $out

45 ${lndir}/bin/lndir -silent ${ghc} $out

40− # ... remove all of the package directories

41 rm -rf ${libDir}/*/

46 rm -rf ${libDir}/*/

47+ ''

42− # ... but retain the lib/ghc/bin directory. This contains `unlit' and friends.

48+ # ... but retain the lib/ghc/bin directory. This contains `unlit' and friends.

49+ + ''

43 ln -s ${ghc}/lib/${ghcCommand}-${ghc.version}/bin ${libDir}

50 ln -s ${ghc}/lib/${ghcCommand}-${ghc.version}/bin ${libDir}

51+ ''

44− # ... and the ghcjs shim's if they are available ...

52+ # ... and the ghcjs shim's if they are available ...

53+ + ''

45 if [ -d ${ghc}/lib/${ghcCommand}-${ghc.version}/shims ]; then

54 if [ -d ${ghc}/lib/${ghcCommand}-${ghc.version}/shims ]; then

46 ln -s ${ghc}/lib/${ghcCommand}-${ghc.version}/shims ${libDir}

55 ln -s ${ghc}/lib/${ghcCommand}-${ghc.version}/shims ${libDir}

47 fi

56 fi

57+ ''

48− # ... and node modules ...

58+ # ... and node modules ...

59+ + ''

49 if [ -d ${ghc}/lib/${ghcCommand}-${ghc.version}/ghcjs-node ]; then

60 if [ -d ${ghc}/lib/${ghcCommand}-${ghc.version}/ghcjs-node ]; then

50 ln -s ${ghc}/lib/${ghcCommand}-${ghc.version}/ghcjs-node ${libDir}

61 ln -s ${ghc}/lib/${ghcCommand}-${ghc.version}/ghcjs-node ${libDir}

51 fi

62 fi

63+ ''

52− # Replace the package database with the one from target package config.

64+ # Replace the package database with the one from target package config.

65+ + ''

53 ln -s ${configFiles}/${packageCfgDir} $out/${packageCfgDir}

66 ln -s ${configFiles}/${packageCfgDir} $out/${packageCfgDir}

54

67

55− # Wrap compiler executables with correct env variables.

68+ ''

56− # The NIX_ variables are used by the patched Paths_ghc module.

69+ # Set the GHC_PLUGINS environment variable according to the plugins for the component.

70+ # GHC will automatically load the relevant symbols from the given libraries and

71+ # initialize them with the given arguments.

72+ #

73+ # GHC_PLUGINS is a `read`able [(FilePath,String,String,[String])], where the

74+ # first component is a path to the shared library, the second is the package ID,

75+ # the third is the module name, and the fourth is the plugin arguments.

76+ + ''

77+ GHC_PLUGINS="["

78+ LIST_PREFIX=""

79+ ${builtins.concatStringsSep "\n" (map (plugin: ''

80+ id=$(${ghc}/bin/ghc-pkg --package-db ${plugin.library}/package.conf.d field ${plugin.library.package.identifier.name} id --simple-output)

81+ lib_dir=$(${ghc}/bin/ghc-pkg --package-db ${plugin.library}/package.conf.d field ${plugin.library.package.identifier.name} dynamic-library-dirs --simple-output)

82+ lib_base=$(${ghc}/bin/ghc-pkg --package-db ${plugin.library}/package.conf.d field ${plugin.library.package.identifier.name} hs-libraries --simple-output)

83+ lib="$(echo ''${lib_dir}/lib''${lib_base}*)"

84+ GHC_PLUGINS="''${GHC_PLUGINS}''${LIST_PREFIX}(\"''${lib}\",\"''${id}\",\"${plugin.moduleName}\",["

85+ LIST_PREFIX=""

86+ ${builtins.concatStringsSep "\n" (map (arg: ''

87+ GHC_PLUGINS="''${GHC_PLUGINS}''${LIST_PREFIX}\"${arg}\""

88+ LIST_PREFIX=","

89+ '') plugin.args)}

90+ GHC_PLUGINS="''${GHC_PLUGINS}])"

91+ LIST_PREFIX=","

92+ '') plugins)}

93+ GHC_PLUGINS="''${GHC_PLUGINS}]"

94+

95+ ''

96+ # now the tricky bit. For GHCJS (to make plugins work), we need a special

97+ # file called ghc_libdir. That points to the build ghc's lib.

98+ + ''

99+ echo "${ghc.buildGHC or ghc}/lib/${(ghc.buildGHC or ghc).name}" > "${libDir}/ghc_libdir"

57

100

101+ ''

102+ # Wrap compiler executables with correct env variables.

103+ # The NIX_ variables are used by the patched Paths_ghc module.

104+ + ''

58 for prg in ${ghcCommand} ${ghcCommand}i ${ghcCommand}-${ghc.version} ${ghcCommand}i-${ghc.version}; do

105 for prg in ${ghcCommand} ${ghcCommand}i ${ghcCommand}-${ghc.version} ${ghcCommand}i-${ghc.version}; do

59 if [[ -x "${ghc}/bin/$prg" ]]; then

106 if [[ -x "${ghc}/bin/$prg" ]]; then

60 rm -f $out/bin/$prg

107 rm -f $out/bin/$prg

@@ -63,6 +110,7 @@ in runCommand "${componentName}-${ghc.name}-env" {

63 --set "NIX_${ghcCommandCaps}" "$out/bin/${ghcCommand}" \

110 --set "NIX_${ghcCommandCaps}" "$out/bin/${ghcCommand}" \

64 --set "NIX_${ghcCommandCaps}PKG" "$out/bin/${ghcCommand}-pkg" \

111 --set "NIX_${ghcCommandCaps}PKG" "$out/bin/${ghcCommand}-pkg" \

65 --set "NIX_${ghcCommandCaps}_DOCDIR" "${docDir}" \

112 --set "NIX_${ghcCommandCaps}_DOCDIR" "${docDir}" \

113+ --set "GHC_PLUGINS" "$GHC_PLUGINS" \

66 --set "NIX_${ghcCommandCaps}_LIBDIR" "${libDir}"

114 --set "NIX_${ghcCommandCaps}_LIBDIR" "${libDir}"

67 fi

115 fi

68 done

116 done

@@ -75,11 +123,14 @@ in runCommand "${componentName}-${ghc.name}-env" {

75 --set "NIX_${ghcCommandCaps}" "$out/bin/${ghcCommand}" \

123 --set "NIX_${ghcCommandCaps}" "$out/bin/${ghcCommand}" \

76 --set "NIX_${ghcCommandCaps}PKG" "$out/bin/${ghcCommand}-pkg" \

124 --set "NIX_${ghcCommandCaps}PKG" "$out/bin/${ghcCommand}-pkg" \

77 --set "NIX_${ghcCommandCaps}_DOCDIR" "${docDir}" \

125 --set "NIX_${ghcCommandCaps}_DOCDIR" "${docDir}" \

126+ --set "GHC_PLUGINS" "$GHC_PLUGINS" \

78 --set "NIX_${ghcCommandCaps}_LIBDIR" "${libDir}"

127 --set "NIX_${ghcCommandCaps}_LIBDIR" "${libDir}"

79 fi

128 fi

80 done

129 done

81

130

131+ ''

82− # Wrap haddock, if the base GHC provides it.

132+ # Wrap haddock, if the base GHC provides it.

133+ + ''

83 if [[ -x "${haddock}/bin/haddock" ]]; then

134 if [[ -x "${haddock}/bin/haddock" ]]; then

84 rm -f $out/bin/haddock

135 rm -f $out/bin/haddock

85 makeWrapper ${haddock}/bin/haddock $out/bin/haddock \

136 makeWrapper ${haddock}/bin/haddock $out/bin/haddock \

@@ -87,9 +138,10 @@ in runCommand "${componentName}-${ghc.name}-env" {

87 --set "NIX_${ghcCommandCaps}_LIBDIR" "${libDir}"

138 --set "NIX_${ghcCommandCaps}_LIBDIR" "${libDir}"

88 fi

139 fi

89

140

141+ ''

90− # Point ghc-pkg to the package database of the component using the

142+ # Point ghc-pkg to the package database of the component using the

91− # --global-package-db flag.

143+ # --global-package-db flag.

92−

144+ + ''

93 for prg in ${ghcCommand}-pkg ${ghcCommand}-pkg-${ghc.version}; do

145 for prg in ${ghcCommand}-pkg ${ghcCommand}-pkg-${ghc.version}; do

94 if [[ -x "${ghc}/bin/$prg" ]]; then

146 if [[ -x "${ghc}/bin/$prg" ]]; then

95 rm -f $out/bin/$prg

147 rm -f $out/bin/$prg

builder/haddock-builder.nixnew file+158

@@ -0,0 +1,158 @@

1+{ stdenv, buildPackages, lib, haskellLib, ghc, ghcForComponent, nonReinstallablePkgs, runCommand, writeText, writeScript, makeConfigFiles }:

2+

3+{ componentId

4+, component

5+, package

6+, flags

7+, revision

8+, commonAttrs

9+, preHaddock

10+, postHaddock

11+, pkgconfig

12+, commonConfigureFlags

13+

14+, doHaddock

15+, doHoogle

16+, hyperlinkSource

17+, quickjump

18+, setupHaddockFlags

19+

20+, needsProfiling

21+, componentDrv

22+, configFiles # component config files

23+}:

24+

25+let

26+ doHaddock' = doHaddock

27+ && (haskellLib.isLibrary componentId)

28+ && !haskellLib.isCrossHost;

29+

30+ # the target dir for haddock documentation

31+ docdir = docoutput: docoutput + "/share/doc/" + componentId.cname;

32+

33+ packageCfgDir = configFiles.packageCfgDir;

34+

35+ fullName = "${componentDrv.name}-haddock";

36+

37+ # These config files are like the one used in the build derivation,

38+ # but `chooseDrv` will be used to map all the references to libraries

39+ # to their haddock derivation.

40+ docsConfigFiles = makeConfigFiles {

41+ inherit (package) identifier;

42+ inherit component fullName flags needsProfiling;

43+ chooseDrv = p: p.haddock;

44+ inherit (componentDrv) enableDWARF;

45+ };

46+

47+ finalConfigureFlags = lib.concatStringsSep " " (

48+ [ "--prefix=${componentDrv}"

49+ "${haskellLib.componentTarget componentId}"

50+ "$(cat ${docsConfigFiles}/configure-flags)"

51+ ]

52+ ++ commonConfigureFlags

53+ ++ lib.optional doHaddock' " --docdir=${docdir "$doc"}");

54+

55+ shellWrappers = ghcForComponent {

56+ componentName = fullName;

57+ configFiles = docsConfigFiles;

58+ inherit (componentDrv) enableDWARF;

59+ inherit (component) plugins;

60+ };

61+

62+ drv = stdenv.mkDerivation (commonAttrs // {

63+ name = fullName;

64+

65+ passthru = {

66+ configFiles = docsConfigFiles;

67+

68+ # The directory containing the haddock documentation.

69+ haddockDir = if doHaddock' then "${docdir drv.doc}/html" else null;

70+ };

71+

72+ # `out` contains the `package.conf.d` files used for building the

73+ # haddock files.

74+ # `doc` contains just the haddock output files.

75+ outputs = ["out"]

76+ ++ lib.optional doHaddock' "doc";

77+

78+ propagatedBuildInputs = builtins.concatLists pkgconfig;

79+

80+ buildInputs = component.libs

81+ ++ map (d: d.components.library.haddock or d) component.depends;

82+

83+ nativeBuildInputs =

84+ [ shellWrappers buildPackages.removeReferencesTo ]

85+ ++ componentDrv.executableToolDepends;

86+

87+ configurePhase = ''

88+ runHook preConfigure

89+ echo Configure flags:

90+ printf "%q " ${finalConfigureFlags}

91+ echo

92+ $SETUP_HS configure ${finalConfigureFlags}

93+ runHook postConfigure

94+ '';

95+

96+ buildPhase = ''

97+ mkdir -p $out

98+ '' + lib.optionalString doHaddock' ''

99+ runHook preHaddock

100+

101+ docdir="${docdir "$doc"}"

102+ # This mkdir needed for packages like base-noprelude and bytestring-builder

103+ # (which is also empty when `bytestring >= 0.10.4`)

104+ mkdir -p "$docdir"

105+

106+ # If we don't have any source files, no need to run haddock

107+ [[ -n $(find . -name "*.hs" -o -name "*.lhs") ]] && {

108+ $SETUP_HS haddock \

109+ "--html" \

110+ ${lib.optionalString doHoogle "--hoogle"} \

111+ ${lib.optionalString hyperlinkSource "--hyperlink-source"} \

112+ ${lib.optionalString quickjump "--quickjump"} \

113+ ${lib.concatStringsSep " " setupHaddockFlags}

114+ }

115+ runHook postHaddock

116+ '';

117+

118+ installPhase =

119+ let

120+ target-pkg-and-db = "${ghc.targetPrefix}ghc-pkg -v0 --package-db $out/package.conf.d";

121+ in ''

122+ html="dist/doc/html/${package.identifier.name}"

123+

124+ if [ -d "$html" ]; then

125+ # Ensure that libraries are not pulled into the docs closure.

126+ # As an example, the prettified source code of a

127+ # Paths_package module will contain store paths of the library package.

128+ for x in "$html/src/"*.html; do

129+ remove-references-to -t $out $x

130+ remove-references-to -t ${componentDrv} $x

131+ done

132+

133+ docdir="${docdir "$doc"}"

134+ mkdir -p "$docdir"

135+

136+ cp -R "$html" "$docdir"/html

137+ fi

138+

139+ ${ghc.targetPrefix}ghc-pkg -v0 init $out/package.conf.d

140+

141+ for i in "${componentDrv}/package.conf.d"/*.conf; do

142+ # Copy the .conf files from the build derivation, but replace the `haddock-intefaces:`

143+ # field with correct location for haddocks (now it is known). This will insure that

144+ # the other haddock derivations build to reference this one will have the correct

145+ # working hyper links.

146+ pkg=$(basename "$i")

147+ sed -e "s|haddock-interfaces:.*|haddock-interfaces: $docdir/html/${componentId.cname}.haddock|" -e "s|haddock-html:.*|haddock-html: $docdir/html/|" "$i" > "$pkg"

148+ ${ghc.targetPrefix}ghc-pkg -v0 --package-db ${docsConfigFiles}/${configFiles.packageCfgDir} -f $out/package.conf.d register "$pkg"

149+ done

150+

151+ ln -s ${componentDrv}/exactDep $out/exactDep

152+ ln -s ${componentDrv}/envDep $out/envDep

153+ '';

154+ }

155+ // haskellLib.optionalHooks {

156+ inherit preHaddock postHaddock;

157+ });

158+in drv

builder/hspkg-builder.nix+44−14

@@ -1,4 +1,4 @@

1−{ pkgs, buildPackages, stdenv, lib, haskellLib, ghc, fetchurl, runCommand, comp-builder, setup-builder }:

1+{ pkgs, buildPackages, stdenv, lib, haskellLib, ghc, compiler-nix-name, fetchurl, runCommand, comp-builder, setup-builder }:

2

3config:

4{ flags

@@ -23,21 +23,44 @@ assert (if ghc.isHaskellNixCompiler or false then true

23 + pkgs.lib.optionalString (name != null) (" for " + name)));

24

25let

26+ # Some packages bundled with GHC are not the same as they are in hackage.

27+ bundledSrc = {

28+ # These are problematic because the hackage versions will not install and are part of LTS.

29+ "ghc902/stm-2.5.0.0" = "/libraries/stm";

30+ "ghc902/filepath-1.4.2.1" = "/libraries/filepath";

31+ }."${compiler-nix-name}/${name}" or null;

32+ src = if bundledSrc == null then pkg.src else ghc.configured-src + bundledSrc;

26− cabalFile = if revision == null || revision == 0 then null else

33+ cabalFile = if revision == null || revision == 0 || bundledSrc != null then null else

27 fetchurl {

34 fetchurl {

28 name = "${name}-${toString revision}.cabal";

35 name = "${name}-${toString revision}.cabal";

29 url = "https://hackage.haskell.org/package/${name}/revision/${toString revision}.cabal";

36 url = "https://hackage.haskell.org/package/${name}/revision/${toString revision}.cabal";

30 sha256 = revisionSha256;

37 sha256 = revisionSha256;

31 };

38 };

32

39

33− defaultSetupSrc = builtins.toFile "Setup.hs" ''

40+ defaultSetupSrc = if stdenv.hostPlatform.isGhcjs then ./Setup.ghcjs.hs else ./Setup.hs;

34− import Distribution.Simple

41+

35− main = defaultMain

42+ # This is the `Cabal` library that was built for `cabal-install` to use.

36− '';

43+ # It makes sense to use this version (when possible) because it will match the behavior of

44+ # building with `cabal-install` (including fixes that may not be in the

45+ # version of Cabal bundled with GHC).

46+ cabalFromCabalInstall = buildPackages.haskell-nix.cabal-install-unchecked.${compiler-nix-name}.project.hsPkgs.Cabal.components.library;

47+

48+ # Check there is no chance we are building `cabalFromCabalInstall`. Using `cabalFromCabalInstall`

49+ # to build itseld would cause infinite recursion.

50+ useCabalFromCabalInstall =

51+ # `cabalFromCabalInstall` is not cross compiled

52+ stdenv.buildPlatform != stdenv.hostPlatform

53+ ||

54+ # These are the dependencies of `Cabal`

55+ !builtins.elem package.identifier.name

56+ ["nix-tools" "alex" "happy" "hscolour" "Cabal" "bytestring" "aeson" "time"

57+ "filepath" "base-compat-batteries" "base-compat" "unix" "directory" "transformers"

58+ "containers" "binary" "mtl" "text" "process" "parsec"];

59+

37− defaultSetup = setup-builder {

60+ defaultSetup = setup-builder ({

38 name = "${ghc.targetPrefix}default-Setup";

61 name = "${ghc.targetPrefix}default-Setup";

39 component = {

62 component = {

40− depends = config.setup-depends;

63+ depends = config.setup-depends ++ lib.optional useCabalFromCabalInstall cabalFromCabalInstall;

41 libs = [];

64 libs = [];

42 frameworks = [];

65 frameworks = [];

43 doExactConfig = false;

66 doExactConfig = false;

@@ -65,12 +88,19 @@ let

65 synopsis = null;

88 synopsis = null;

66 license = "MIT";

89 license = "MIT";

67 };

90 };

91+ src = null;

68− src = null; cleanSrc = buildPackages.runCommand "default-Setup-src" {} ''

92+ cleanSrc = buildPackages.runCommand "default-Setup-src" {} ''

69 mkdir $out

93 mkdir $out

70 cat ${defaultSetupSrc} > $out/Setup.hs

94 cat ${defaultSetupSrc} > $out/Setup.hs

71 '';

95 '';

72 inherit defaultSetupSrc;

96 inherit defaultSetupSrc;

97+ } // lib.optionalAttrs useCabalFromCabalInstall {

98+ # This is needed so that we don't get duplicate packages when we

99+ # add a custom Cabal package to the dependencies. That way custom

100+ # setups won't complain about e.g. binary from the Cabal dependencies

101+ # and binary from the global package-db.

102+ nonReinstallablePkgs = [];

73− };

103+ });

74

104

75 # buildPackages.runCommand "default-Setup" { nativeBuildInputs = [(ghc.passthru.buildGHC or ghc)]; } ''

105 # buildPackages.runCommand "default-Setup" { nativeBuildInputs = [(ghc.passthru.buildGHC or ghc)]; } ''

76 # cat ${defaultSetupSrc} > Setup.hs

106 # cat ${defaultSetupSrc} > Setup.hs

@@ -90,18 +120,18 @@ let

90 inherit (pkg) preUnpack postUnpack;

120 inherit (pkg) preUnpack postUnpack;

91 };

121 };

92

122

93− buildComp = componentId: component: comp-builder {

123+ buildComp = allComponent: componentId: component: comp-builder {

94− inherit componentId component package name src flags setup cabalFile cabal-generator patches revision

124+ inherit allComponent componentId component package name src flags setup cabalFile cabal-generator patches revision

95 shellHook

125 shellHook

96 ;

126 ;

97 };

127 };

98

128

99in rec {

129in rec {

100− components = haskellLib.applyComponents buildComp pkg;

130+ components = haskellLib.applyComponents (buildComp pkg.allComponent) pkg;

101 checks = pkgs.recurseIntoAttrs (builtins.mapAttrs

131 checks = pkgs.recurseIntoAttrs (builtins.mapAttrs

102 (_: d: haskellLib.check d)

132 (_: d: haskellLib.check d)

103 (lib.filterAttrs (_: d: d.config.doCheck) components.tests));

133 (lib.filterAttrs (_: d: d.config.doCheck) components.tests));

104− inherit (package) identifier detailLevel isLocal;

134+ inherit (package) identifier detailLevel isLocal isProject buildType;

105 inherit setup cabalFile;

135 inherit setup cabalFile;

106 isHaskell = true;

136 isHaskell = true;

107 inherit src;

137 inherit src;

builder/make-config-files.nix+66−30

@@ -1,6 +1,14 @@

1−{ stdenv, lib, haskellLib, ghc, nonReinstallablePkgs, runCommand, writeText, writeScript }:

1+{ stdenv, lib, haskellLib, ghc, nonReinstallablePkgs, runCommand, writeText, writeScript }@defaults:

2+

3+{ identifier, component, fullName, flags ? {}, needsProfiling ? false, enableDWARF ? false, chooseDrv ? drv: drv, nonReinstallablePkgs ? defaults.nonReinstallablePkgs }:

2

4

3let

5let

6+ # Sort and remove duplicates from nonReinstallablePkgs.

7+ # That way changes to the order of nonReinstallablePkgs does not require rebuilds.

8+ nonReinstallablePkgs' = __attrNames (lib.genAttrs nonReinstallablePkgs (x: x));

9+

10+ ghc = if enableDWARF then defaults.ghc.dwarf else defaults.ghc;

11+

4 flagsAndConfig = field: xs: lib.optionalString (xs != []) ''

12 flagsAndConfig = field: xs: lib.optionalString (xs != []) ''

5 echo ${lib.concatStringsSep " " (map (x: "--${field}=${x}") xs)} >> $out/configure-flags

13 echo ${lib.concatStringsSep " " (map (x: "--${field}=${x}") xs)} >> $out/configure-flags

6 echo "${field}: ${lib.concatStringsSep " " xs}" >> $out/cabal.config

14 echo "${field}: ${lib.concatStringsSep " " xs}" >> $out/cabal.config

@@ -8,18 +16,18 @@ let

8

16

9 target-pkg = "${ghc.targetPrefix}ghc-pkg";

17 target-pkg = "${ghc.targetPrefix}ghc-pkg";

10

18

11− # This is a bit of a hack. So we'll have a slightly longer explaination here:

19+ # This is a bit of a hack. So we'll have a slightly longer explanation here:

12

20

13 # Every library component built with `comp-builder.nix` includes an `exactDep`

21 # Every library component built with `comp-builder.nix` includes an `exactDep`

14 # and `envDep` directory with precomputed values used here.

22 # and `envDep` directory with precomputed values used here.

15 # GHC derivations include `exactDep` and `envDep` directories that have

23 # GHC derivations include `exactDep` and `envDep` directories that have

16 # the same information for each of the built in packages.

24 # the same information for each of the built in packages.

17

25

18− # exactDep will pass --exact-configuration to the `SETUP_HS confiugre` command.

26+ # exactDep will pass --exact-configuration to the `SETUP_HS configure` command.

19 # This requires us to pass --dependency={dep name}={pkg id}. The dependency

27 # This requires us to pass --dependency={dep name}={pkg id}. The dependency

20 # name will usually be the name of the package `p`, which we can locate in the

28 # name will usually be the name of the package `p`, which we can locate in the

21 # package-db, passed in via `pdbArg`. Thus querying the package-db for the

29 # package-db, passed in via `pdbArg`. Thus querying the package-db for the

22− # id field for package `p`, will unsually provide is with the right value. Sublibs

30+ # id field for package `p`, will usually provide us with the right value. Sublibs

23 # need a bit of special handling:

31 # need a bit of special handling:

24 #

32 #

25 # - Sublibs: if the dependency is a sublibrary of a package, we need to use

33 # - Sublibs: if the dependency is a sublibrary of a package, we need to use

@@ -41,25 +49,35 @@ let

41 libDir = "lib/${ghcCommand}-${ghc.version}";

49 libDir = "lib/${ghcCommand}-${ghc.version}";

42 packageCfgDir = "${libDir}/package.conf.d";

50 packageCfgDir = "${libDir}/package.conf.d";

43

51

44−in { identifier, component, fullName, flags ? {}, needsProfiling ? false }:

45 # Filters out only library packages that for this GHC target

52 # Filters out only library packages that for this GHC target

46 # TODO investigate why this is needed

53 # TODO investigate why this is needed

47 # TODO find out why p ? configFiles helps (for instance for `R1909.aarch64-unknown-linux-gnu.tests.cabal-22.run.x86_64-linux`)

54 # TODO find out why p ? configFiles helps (for instance for `R1909.aarch64-unknown-linux-gnu.tests.cabal-22.run.x86_64-linux`)

55+ libDeps = map chooseDrv (

56+ (if enableDWARF then (x: map (p: p.dwarf or p) x) else x: x)

48− let libDeps = (if needsProfiling then (x: map (p: p.profiled or p) x) else x: x)

57+ ((if needsProfiling then (x: map (p: p.profiled or p) x) else x: x)

49− (lib.filter (p: (p ? configFiles) && p.configFiles.targetPrefix == ghc.targetPrefix)

58+ (lib.filter (p: (p ? configFiles) && p.configFiles.targetPrefix == ghc.targetPrefix)

50− (map getLibComponent component.depends));

59+ (map getLibComponent component.depends)))

60+ );

51− cfgFiles =

61+ cfgFiles =

52− let xs = map

62+ let xs = map

53− (p: "${p.configFiles}")

63+ (p: "${p.configFiles}")

54− libDeps;

64+ libDeps;

55− in lib.concatStringsSep "\" \"" xs;

65+ in lib.concatStringsSep "\" \"" xs;

56− libs = lib.concatMapStringsSep "\" \"" (p: "${p}") libDeps;

66+ libs = lib.concatMapStringsSep "\" \"" (p: "${p}") libDeps;

57− in

58− runCommand "${ghc.targetPrefix}${fullName}-config" {

67+ drv = runCommand "${ghc.targetPrefix}${fullName}-config" {

59 nativeBuildInputs = [ghc];

68 nativeBuildInputs = [ghc];

60 passthru = {

69 passthru = {

61 inherit (ghc) targetPrefix;

70 inherit (ghc) targetPrefix;

62− inherit ghcCommand ghcCommandCaps libDir packageCfgDir;

71+ inherit ghcCommand ghcCommandCaps libDir packageCfgDir component;

72+ # Use ''${pkgroot} relative paths so that we can relocate the package database

73+ # along with referenced packages and still have it work on systems with

74+ # or without nix installed.

75+ relocatableConfigFiles = runCommand "${ghc.targetPrefix}${fullName}-relocatable-config" ''

76+ cp -r ${drv} $out

77+ chmod -R +w $out

78+ sed -i 's|/nix/store/|''${pkgroot}/../../../|' $out/${packageCfgDir}/*.conf

79+ ${target-pkg} -v0 --package-db $out/${packageCfgDir} recache

80+ '';

63 };

81 };

64 } (''

82 } (''

65 mkdir -p $out

83 mkdir -p $out

@@ -67,27 +85,44 @@ in { identifier, component, fullName, flags ? {}, needsProfiling ? false }:

67 ${target-pkg} init $out/${packageCfgDir}

85 ${target-pkg} init $out/${packageCfgDir}

68

86

69 ${lib.concatStringsSep "\n" (lib.mapAttrsToList flagsAndConfig {

87 ${lib.concatStringsSep "\n" (lib.mapAttrsToList flagsAndConfig {

70− "extra-lib-dirs" = map (p: "${lib.getLib p}/lib") component.libs;

88+ "extra-lib-dirs" = map (p: "${lib.getLib p}/lib") (lib.flatten component.libs)

89+ # On windows also include `bin` directories that may contain DLLs

90+ ++ lib.optionals (stdenv.hostPlatform.isWindows)

91+ (map (p: "${lib.getBin p}/bin")

92+ (lib.flatten component.libs ++ lib.concatLists component.pkgconfig));

71− "extra-include-dirs" = map (p: "${lib.getDev p}/include") component.libs;

93+ "extra-include-dirs" = map (p: "${lib.getDev p}/include") (lib.flatten component.libs);

94+ "extra-framework-dirs" = lib.optionals (stdenv.hostPlatform.isDarwin)

72− "extra-framework-dirs" = map (p: "${p}/Library/Frameworks") component.frameworks;

95+ (map (p: "${p}/Library/Frameworks") component.frameworks);

73 })}

96 })}

74

97

75 ghc=${ghc}

98 ghc=${ghc}

76 ${ # Copy over the nonReinstallablePkgs from the global package db.

99 ${ # Copy over the nonReinstallablePkgs from the global package db.

77 ''

100 ''

78− for p in ${lib.concatStringsSep " " nonReinstallablePkgs}; do

101+ for p in ${lib.concatStringsSep " " nonReinstallablePkgs'}; do

79 find $ghc/lib/${ghc.name}/package.conf.d -name $p'*.conf' -exec cp -f {} $out/${packageCfgDir} \;

102 find $ghc/lib/${ghc.name}/package.conf.d -name $p'*.conf' -exec cp -f {} $out/${packageCfgDir} \;

80 done

103 done

81 ''}

104 ''}

82

105

83 for l in "${cfgFiles}"; do

106 for l in "${cfgFiles}"; do

84 if [ -n "$l" ]; then

107 if [ -n "$l" ]; then

108+ files=("$l/${packageCfgDir}/"*.conf)

109+ if (( ''${#files[@]} )); then

85− cp -f "$l/${packageCfgDir}/"*.conf $out/${packageCfgDir}

110+ cp -f "''${files[@]}" $out/${packageCfgDir}

111+ else

112+ echo "$l/${packageCfgDir} didn't contain any *.conf files!"

113+ exit 1

114+ fi

86 fi

115 fi

87 done

116 done

88 for l in "${libs}"; do

117 for l in "${libs}"; do

89 if [ -n "$l" ]; then

118 if [ -n "$l" ]; then

119+ files=("$l/package.conf.d/"*.conf)

120+ if (( ''${#files[@]} )); then

90− cp -f "$l/package.conf.d/"*.conf $out/${packageCfgDir}

121+ cp -f "''${files[@]}" $out/${packageCfgDir}

122+ else

123+ echo "$l/package.conf.d didn't contain any *.conf files!"

124+ exit 1

125+ fi

91 fi

126 fi

92 done

127 done

93

128

@@ -122,26 +157,26 @@ in { identifier, component, fullName, flags ? {}, needsProfiling ? false }:

122 cat $p/exactDep/cabal.config >> $out/cabal.config

157 cat $p/exactDep/cabal.config >> $out/cabal.config

123 ''}

158 ''}

124 done

159 done

125− for p in ${lib.concatStringsSep " " (lib.remove "ghc" nonReinstallablePkgs)}; do

160+ for p in ${lib.concatStringsSep " " (lib.remove "ghc" nonReinstallablePkgs')}; do

126 if [ -e $ghc/envDeps/$p ]; then

161 if [ -e $ghc/envDeps/$p ]; then

127 cat $ghc/envDeps/$p >> $out/ghc-environment

162 cat $ghc/envDeps/$p >> $out/ghc-environment

128 fi

163 fi

129 done

164 done

130 '' + lib.optionalString component.doExactConfig ''

165 '' + lib.optionalString component.doExactConfig ''

131− for p in ${lib.concatStringsSep " " nonReinstallablePkgs}; do

166+ for p in ${lib.concatStringsSep " " nonReinstallablePkgs'}; do

132 if [ -e $ghc/exactDeps/$p ]; then

167 if [ -e $ghc/exactDeps/$p ]; then

133 cat $ghc/exactDeps/$p/configure-flags >> $out/configure-flags

168 cat $ghc/exactDeps/$p/configure-flags >> $out/configure-flags

134 cat $ghc/exactDeps/$p/cabal.config >> $out/cabal.config

169 cat $ghc/exactDeps/$p/cabal.config >> $out/cabal.config

135 fi

170 fi

136− done

171+ done

137 ''

172 ''

138 # This code originates in the `generic-builder.nix` from nixpkgs. However GHC has been fixed

173 # This code originates in the `generic-builder.nix` from nixpkgs. However GHC has been fixed

139− # to drop unused libraries referneced from libraries; and this patch is usually included in the

174+ # to drop unused libraries referenced from libraries; and this patch is usually included in the

140− # nixpkgs's GHC builds. This doesn't sadly make this stupid hack unnecessary. It resurfes in

175+ # nixpkgs's GHC builds. This doesn't sadly make this stupid hack unnecessary. It resurfaces in

141 # the form of Cabal trying to be smart. Cabal when linking a library figures out that you likely

176 # the form of Cabal trying to be smart. Cabal when linking a library figures out that you likely

142 # need those `rpath` entries, and passes `-optl-Wl,-rpath,...` for each dynamic library path to

177 # need those `rpath` entries, and passes `-optl-Wl,-rpath,...` for each dynamic library path to

143 # GHC, thus subverting the linker and forcing it to insert all those RPATHs weather or not they

178 # GHC, thus subverting the linker and forcing it to insert all those RPATHs weather or not they

144− # are needed. We therfore reuse the linker hack here to move all al dynamic lirbaries into a

179+ # are needed. We therefore reuse the linker hack here to move all dynamic libraries into a

145 # common folder (as links) and thus prevent Cabal from going nuts.

180 # common folder (as links) and thus prevent Cabal from going nuts.

146 #

181 #

147 # TODO: Fix Cabal.

182 # TODO: Fix Cabal.

@@ -183,4 +218,5 @@ in { identifier, component, fullName, flags ? {}, needsProfiling ? false }:

183 done

218 done

184 '' + ''

219 '' + ''

185 ${target-pkg} -v0 --package-db $out/${packageCfgDir} recache

220 ${target-pkg} -v0 --package-db $out/${packageCfgDir} recache

186− '')

221+ '');

222+in drv

builder/setup-builder.nix+37−22

@@ -1,21 +1,29 @@

1−{ stdenv, lib, buildPackages, haskellLib, ghc, nonReinstallablePkgs, hsPkgs, makeSetupConfigFiles, pkgconfig }:

1+{ pkgs, stdenv, lib, buildPackages, haskellLib, ghc, nonReinstallablePkgs, hsPkgs, makeSetupConfigFiles, pkgconfig }@defaults:

2

3+let self =

3−{ component, package, name, src, flags ? {}, revision ? null, patches ? [], defaultSetupSrc

4+{ component, package, name, src, enableDWARF ? false, flags ? {}, revision ? null, patches ? [], defaultSetupSrc

4, preUnpack ? component.preUnpack, postUnpack ? component.postUnpack

5, preUnpack ? component.preUnpack, postUnpack ? component.postUnpack

5, prePatch ? null, postPatch ? null

6, prePatch ? null, postPatch ? null

6, preBuild ? component.preBuild , postBuild ? component.postBuild

7, preBuild ? component.preBuild , postBuild ? component.postBuild

7, preInstall ? component.preInstall , postInstall ? component.postInstall

8, preInstall ? component.preInstall , postInstall ? component.postInstall

8−, cleanSrc ? haskellLib.cleanCabalComponent package component src

9+, cleanSrc ? haskellLib.cleanCabalComponent package component "setup" src

9−}:

10+, nonReinstallablePkgs ? defaults.nonReinstallablePkgs

11+, smallAddressSpace ? false

12+}@drvArgs:

10

13

11let

14let

15+ ghc = (if enableDWARF then (x: x.dwarf) else (x: x)) (

16+ (if smallAddressSpace then (x: x.smallAddressSpace) else (x: x)) defaults.ghc);

17+

18+ cleanSrc' = haskellLib.rootAndSubDir cleanSrc;

19+

12 fullName = "${name}-setup";

20 fullName = "${name}-setup";

13

21

14 includeGhcPackage = lib.any (p: p.identifier.name == "ghc") component.depends;

22 includeGhcPackage = lib.any (p: p.identifier.name == "ghc") component.depends;

15

23

16 configFiles = makeSetupConfigFiles {

24 configFiles = makeSetupConfigFiles {

17 inherit (package) identifier;

25 inherit (package) identifier;

18− inherit fullName flags component;

26+ inherit fullName flags component enableDWARF nonReinstallablePkgs;

19 };

27 };

20 hooks = haskellLib.optionalHooks {

28 hooks = haskellLib.optionalHooks {

21 inherit

29 inherit

@@ -32,11 +40,10 @@ let

32 else [c]) component.build-tools) ++

40 else [c]) component.build-tools) ++

33 lib.optional (component.pkgconfig != []) pkgconfig;

41 lib.optional (component.pkgconfig != []) pkgconfig;

34

42

35−in

43+ drv =

36− stdenv.lib.fix (drv:

37 stdenv.mkDerivation ({

44 stdenv.mkDerivation ({

38 name = "${ghc.targetPrefix}${fullName}";

45 name = "${ghc.targetPrefix}${fullName}";

39− src = cleanSrc;

46+ src = cleanSrc'.root;

40 buildInputs = component.libs

47 buildInputs = component.libs

41 ++ component.frameworks

48 ++ component.frameworks

42 ++ builtins.concatLists component.pkgconfig;

49 ++ builtins.concatLists component.pkgconfig;

@@ -45,18 +52,19 @@ in

45 passthru = {

52 passthru = {

46 inherit (package) identifier;

53 inherit (package) identifier;

47 config = component;

54 config = component;

55+ srcSubDir = cleanSrc'.subDir;

56+ srcSubDirPath = cleanSrc'.root + cleanSrc'.subDir;

57+ cleanSrc = cleanSrc';

48− inherit configFiles cleanSrc;

58+ inherit configFiles;

59+ dwarf = self (drvArgs // { enableDWARF = true; });

60+ smallAddressSpace = self (drvArgs // { smallAddressSpace = true; });

49 };

61 };

50

62

51 meta = {

63 meta = {

52− homepage = package.homepage;

64+ homepage = package.homepage or "";

53− description = package.synopsis;

65+ description = package.synopsis or "";

54− license =

66+ license = haskellLib.cabalToNixpkgsLicense package.license;

55− let

56− license-map = import ../lib/cabal-licenses.nix lib;

57− in license-map.${package.license} or

58− (builtins.trace "WARNING: license \"${package.license}\" not found" license-map.LicenseRef-OtherLicense);

59− platforms = if component.platforms == null then stdenv.lib.platforms.all else component.platforms;

67+ platforms = if component.platforms == null then lib.platforms.all else component.platforms;

60 };

68 };

61

69

62 phases = ["unpackPhase" "patchPhase" "buildPhase" "installPhase"];

70 phases = ["unpackPhase" "patchPhase" "buildPhase" "installPhase"];

@@ -68,13 +76,12 @@ in

68 for f in Setup.hs Setup.lhs; do

76 for f in Setup.hs Setup.lhs; do

69 if [ -f $f ]; then

77 if [ -f $f ]; then

70 echo Compiling package $f

78 echo Compiling package $f

71− ghc $f -threaded '' + (if includeGhcPackage then "-package ghc " else "")

79+ ghc $f -threaded ${if includeGhcPackage then "-package ghc " else ""

72− + ''-package-db ${configFiles}/${configFiles.packageCfgDir} --make -o ./Setup

80+ }-package-db ${configFiles}/${configFiles.packageCfgDir} --make -o ./Setup

73− setup=$(pwd)/Setup

74 fi

81 fi

75 done

82 done

76 [ -f ./Setup ] || (echo Failed to build Setup && exit 1)

83 [ -f ./Setup ] || (echo Failed to build Setup && exit 1)

77− runHook preBuild

84+ runHook postBuild

78 '';

85 '';

79

86

80 installPhase = ''

87 installPhase = ''

@@ -84,6 +91,14 @@ in

84 runHook postInstall

91 runHook postInstall

85 '';

92 '';

86 }

93 }

94+ // (lib.optionalAttrs (cleanSrc'.subDir != "") {

95+ prePatch =

96+ # If the package is in a sub directory `cd` there first

97+ ''

98+ cd ${lib.removePrefix "/" cleanSrc'.subDir}

99+ '';

100+ })

87 // (lib.optionalAttrs (patches != []) { patches = map (p: if builtins.isFunction p then p { inherit (package.identifier) version; inherit revision; } else p) patches; })

101 // (lib.optionalAttrs (patches != []) { patches = map (p: if builtins.isFunction p then p { inherit (package.identifier) version; inherit revision; } else p) patches; })

88 // hooks

102 // hooks

89− ))

103+ );

104+in drv; in self

builder/shell-for.nix+124−47

@@ -1,64 +1,113 @@

1−{ lib, stdenv, glibcLocales, pkgconfig, ghcForComponent, makeConfigFiles, hsPkgs, hoogleLocal, haskellLib, buildPackages, buildGHC }:

1+{ lib, stdenv, mkShell, glibcLocales, pkgconfig, ghcForComponent, makeConfigFiles, hsPkgs, hoogleLocal, haskellLib, buildPackages, evalPackages, compiler }:

2−

2+

3−{ packages ? ps:

3+{ # `packages` function selects packages that will be worked on in the shell itself.

4− let

4+ # These packages will not be built by `shellFor`, but their

5+ # dependencies will be included in the shell's `ghc-pkg list`.

5− selected = haskellLib.selectLocalPackages ps;

6+ packages ? ps: builtins.attrValues (haskellLib.selectLocalPackages ps)

6− in

7+ # `components` function selects components that will be worked on in the shell itself.

7− builtins.trace ("Shell for " + toString (builtins.attrNames selected))

8+ # By default `shellFor` will include the dependencies of all of the components

8− (builtins.attrValues selected)

9+ # in the selected packages. If only as subset of the components will be

10+ # worked on in the shell then we can pass a different `components` function

11+ # to select those.

12+, components ? ps: lib.concatMap haskellLib.getAllComponents (packages ps)

13+ # Additional packages to be added unconditionally

9, additional ? _: []

14, additional ? _: []

10, withHoogle ? true

15, withHoogle ? true

16+, withHaddock ? withHoogle

11, exactDeps ? false

17, exactDeps ? false

12, tools ? {}

18, tools ? {}

19+, packageSetupDeps ? true

20+, enableDWARF ? false

13, ... } @ args:

21, ... } @ args:

14

22

15let

23let

16 # TODO find out why hoogle index creation can be made to work for cross compilers

24 # TODO find out why hoogle index creation can be made to work for cross compilers

17 withHoogle' = withHoogle && !haskellLib.isCrossHost;

25 withHoogle' = withHoogle && !haskellLib.isCrossHost;

18− selected = packages hsPkgs;

19− additionalSelected = additional hsPkgs;

20− selectedConfigs = map (p: p.components.all.config) selected;

21

26

27+ selectedPackages = packages hsPkgs;

28+ additionalPackages = additional hsPkgs;

29+ directlySelectedComponents = components hsPkgs;

30+

31+ # Given `directlySelectedComponents = [ a b ]`, we construct a shell that includes all of their dependencies

32+ #

33+ # But we want to exclude `a` if it is a transitive dependecy of `b`

34+ # because:

35+ # - cabal will end up ignoring that built version;

36+ # - The user has indicated that's what they're working on, so they probably don't want to have to build

37+ # it first (and it will change often).

38+ # Generally we never want to include any of `directlySelectedComponents` as dependencies.

39+ #

40+ # We do this by defining a set of `selectedComponents`, where `x` is in `selectedComponents` if and only if:

41+ # - `x` is in `directlySelectedComponents`

42+ # - `x` is a transitive dependency of something in `directlySelectedComponents`

43+ # and `x` transitively depends on something in `directlySelectedComponents`

44+ # We use the dependencies of `selectedComponents` filtering out members of `selectedComponents`

45+ #

46+ # Furthermore, if `a` depends on `b`, `a` will include the library component of `b` in its `buildInputs`

47+ # (to make `propagatedBuildInputs` of `pkgconfig-depends` work). So we also need to filter those

48+ # (the pkgconfig depends of `b` will still be included in the

49+ # system shell's `buildInputs` via `b`'s own `buildInputs`).

50+

51+

52+ # all packages that are indirectly depended on by `directlySelectedComponents`

53+ # including `directlySelectedComponents`

54+ transitiveDependenciesComponents =

55+ builtins.listToAttrs

56+ (builtins.map (x: lib.nameValuePair (x.name) x)

57+ (haskellLib.flatLibDepends {depends = directlySelectedComponents;}));

58+

59+ isSelectedComponent =

60+ comp: selectedComponentsBitmap."${((haskellLib.dependToLib comp).name or null)}" or false;

61+ selectedComponentsBitmap =

62+ lib.mapAttrs

63+ (_: x: (builtins.any isSelectedComponent x.config.depends))

64+ transitiveDependenciesComponents

65+ // builtins.listToAttrs (map (x: lib.nameValuePair x.name true) directlySelectedComponents); # base case

66+

67+ selectedComponents =

68+ lib.filter isSelectedComponent (lib.attrValues transitiveDependenciesComponents);

69+

70+ # Given a list of `depends`, removes those which are selected components

71+ removeSelectedInputs =

72+ lib.filter (input: !(isSelectedComponent input));

73+

74+ # The configs of all the selected components.

75+ # This excludes the `setup` dependencies of `Simple` packages, because

76+ # `cabal-install` does not build a `Setup` executable for `Simple` packages.

77+ selectedConfigs = map (c: c.config) selectedComponents

78+ ++ lib.optionals packageSetupDeps (map (p: p.setup.config)

79+ (lib.filter (p: p.buildType != "Simple") selectedPackages));

80+

22− name = if lib.length selected == 1

81+ name = if lib.length selectedPackages == 1

23− then "ghc-shell-for-${(lib.head selected).identifier.name}"

82+ then "ghc-shell-for-${(lib.head selectedPackages).identifier.name}"

24 else "ghc-shell-for-packages";

83 else "ghc-shell-for-packages";

25

84

26− # Removes the selected packages from a list of packages.

85+ # We need to remove any dependencies which would bring in selected components (see above).

27− # If `packages = [ a b ]` and `a` depends on `b`, don't build `b`,

28− # because cabal will end up ignoring that built version;

29− removeSelected = lib.filter

30− (input: lib.all (cfg: (input.identifier or null) != cfg.identifier) selected);

31− # Also since a will include the library component of b in its buildInputs

32− # (to make `propagatedBuildInputs` of `pkgconfig-depends` work) those should

33− # also be excluded (the pkgconfig depends of b will still be included in the

34− # system shells buildInputs via b's own buildInputs).

35− removeSelectedInputs = lib.filter

36− (input: lib.all (cfg: input != cfg.components.library or null) selected);

37−

38− packageInputs = removeSelected

39− (lib.concatMap (cfg: cfg.depends) selectedConfigs

86+ packageInputs = removeSelectedInputs (lib.concatMap (cfg: cfg.depends) selectedConfigs)

40− ++ additionalSelected

87+ ++ additionalPackages;

41− ++ lib.concatMap (cfg: cfg.setup.config.depends or []) selected

88+

42− );

43−

44− # Add the system libraries and build tools of the selected haskell

89+ # Add the system libraries and build tools of the selected haskell packages to the shell.

45− # packages to the shell.

90+ # We need to remove any inputs which are selected components (see above).

91+ # `buildInputs`, `propagatedBuildInputs`, and `executableToolDepends` contain component

92+ # derivations, not packages, so we use `removeSelectedInputs`).

46 systemInputs = removeSelectedInputs (lib.concatMap

93 systemInputs = removeSelectedInputs (lib.concatMap

47− (p: p.components.all.buildInputs ++ p.components.all.propagatedBuildInputs) selected);

94+ (c: c.buildInputs ++ c.propagatedBuildInputs) selectedComponents);

48− nativeBuildInputs = removeSelected

95+ nativeBuildInputs = removeSelectedInputs

49− (lib.concatMap (p: p.components.all.executableToolDepends) selected);

96+ (lib.concatMap (c: c.executableToolDepends) selectedComponents);

50

97

51 # Set up a "dummy" component to use with ghcForComponent.

98 # Set up a "dummy" component to use with ghcForComponent.

52 component = {

99 component = {

53 depends = packageInputs;

100 depends = packageInputs;

54 libs = [];

101 libs = [];

102+ pkgconfig = [];

55 frameworks = [];

103 frameworks = [];

56 doExactConfig = false;

104 doExactConfig = false;

57 };

105 };

58 configFiles = makeConfigFiles {

106 configFiles = makeConfigFiles {

59 fullName = args.name or name;

107 fullName = args.name or name;

60 identifier.name = name;

108 identifier.name = name;

61− inherit component;

109+ inherit component enableDWARF;

110+ chooseDrv = p: if withHaddock && p ? haddock then p.haddock else p;

62 };

111 };

63 ghcEnv = ghcForComponent {

112 ghcEnv = ghcForComponent {

64 inherit configFiles;

113 inherit configFiles;

@@ -66,6 +115,8 @@ let

66 postInstall = lib.optionalString withHoogle' ''

115 postInstall = lib.optionalString withHoogle' ''

67 ln -s ${hoogleIndex}/bin/hoogle $out/bin

116 ln -s ${hoogleIndex}/bin/hoogle $out/bin

68 '';

117 '';

118+ inherit enableDWARF;

119+ plugins = [];

69 };

120 };

70

121

71 hoogleIndex = let

122 hoogleIndex = let

@@ -75,29 +126,55 @@ let

75 pname = p.identifier.name;

126 pname = p.identifier.name;

76 haddockDir = lib.const p.haddockDir;

127 haddockDir = lib.const p.haddockDir;

77 };

128 };

78− in hoogleLocal {

129+ in hoogleLocal ({

79 packages = map docPackage (haskellLib.flatLibDepends component);

130 packages = map docPackage (haskellLib.flatLibDepends component);

80

131

81 # Need to add hoogle to hsPkgs.

132 # Need to add hoogle to hsPkgs.

82 # inherit (hsPkgs) hoogle;

133 # inherit (hsPkgs) hoogle;

134+ } // (

135+ lib.optionalAttrs (args ? tools && args.tools ? hoogle) {

136+ hoogle = buildPackages.haskell-nix.hackage-tool (

137+ haskellLib.versionOrModToMods args.tools.hoogle ++ [{

138+ name = "hoogle";

139+ compiler-nix-name = compiler.nix-name;

140+ inherit evalPackages;

141+ }]);

142+ }

83− };

143+ ));

84

144

85− mkDrvArgs = builtins.removeAttrs args ["packages" "additional" "withHoogle" "tools"];

145+ mkDrvArgs = builtins.removeAttrs args ["packages" "components" "additional" "withHoogle" "tools"];

86in

146in

87− stdenv.mkDerivation (mkDrvArgs // {

147+ mkShell (mkDrvArgs // {

88 name = mkDrvArgs.name or name;

148 name = mkDrvArgs.name or name;

89

149

90 buildInputs = systemInputs

150 buildInputs = systemInputs

91− ++ mkDrvArgs.buildInputs or []

151+ ++ mkDrvArgs.buildInputs or [];

92− ++ lib.optional withHoogle' hoogleIndex;

93 nativeBuildInputs = [ ghcEnv ]

152 nativeBuildInputs = [ ghcEnv ]

94 ++ nativeBuildInputs

153 ++ nativeBuildInputs

95 ++ mkDrvArgs.nativeBuildInputs or []

154 ++ mkDrvArgs.nativeBuildInputs or []

96− ++ lib.attrValues (buildPackages.haskell-nix.toolsForGhc buildGHC tools);

155+ ++ lib.attrValues (buildPackages.haskell-nix.tools' evalPackages compiler.nix-name tools)

156+ # If this shell is a cross compilation shell include

157+ # wrapper script for running cabal build with appropriate args.

158+ # Includes `--with-compiler` in case the `cabal.project` file has `with-compiler:` in it.

159+ ++ lib.optional (ghcEnv.targetPrefix != "") (

160+ buildPackages.writeShellScriptBin "${ghcEnv.targetPrefix}cabal" ''

161+ exec cabal \

162+ --with-ghc=${ghcEnv.targetPrefix}ghc \

163+ --with-compiler=${ghcEnv.targetPrefix}ghc \

164+ --with-ghc-pkg=${ghcEnv.targetPrefix}ghc-pkg \

165+ --with-hsc2hs=${ghcEnv.targetPrefix}hsc2hs \

166+ ${lib.optionalString (ghcEnv.targetPrefix == "js-unknown-ghcjs-") ''

167+ --with-ghcjs=${ghcEnv.targetPrefix}ghc \

168+ --with-ghcjs-pkg=${ghcEnv.targetPrefix}ghc-pkg \

169+ --ghcjs \

170+ ''} $(builtin type -P "${ghcEnv.targetPrefix}pkg-config" &> /dev/null && echo "--with-pkg-config=${ghcEnv.targetPrefix}pkg-config") \

171+ "$@"

172+ '');

97 phases = ["installPhase"];

173 phases = ["installPhase"];

174+ installPhase = ''

175+ echo "${"Shell for " + toString (builtins.map (p : p.identifier.name) selectedPackages)}"

98− installPhase = "echo $nativeBuildInputs $buildInputs > $out";

176+ echo $nativeBuildInputs $buildInputs > $out

99− LANG = "en_US.UTF-8";

177+ '';

100− LOCALE_ARCHIVE = lib.optionalString (stdenv.hostPlatform.libc == "glibc") "${glibcLocales}/lib/locale/locale-archive";

101

178

102 # This helps tools like `ghcide` (that use the ghc api) to find

179 # This helps tools like `ghcide` (that use the ghc api) to find

103 # the correct global package DB.

180 # the correct global package DB.

changelog.md+159

@@ -1,6 +1,165 @@

1This file contains a summary of changes to Haskell.nix and `nix-tools`

2that will impact users.

3

4+## Jul 27, 2022

5+* Removed reliance on `builtins.currentSystem`. It was used it to provide

6+ `pkgs.evalPackages` via an overlay that it used to run derivations

7+ used in imports from derivation (IFDs).

8+

9+ These derivations are now run on `buildPackages` by default.

10+

11+ Passsing `evalPackages` to a project function will change where all the

12+ derivations used in IFDs are run for that project (including shell tools):

13+ evalPackages = import nixpkgs haskellNix.nixpkgsArgs;

14+

15+ Passing `evalSystem` instead will use create a suitable `nixpkgs` using `pkgs.path`

16+ and `pkgs.overlay`:

17+ evalSystem = "x86_64-linux";

18+ or

19+ evalSystem = builtins.currentSystem;

20+

21+ The `haskellLib.cleanGit` function is also affected by this change. If you are cross

22+ compiling and using `cleanGit` you should probably do something like:

23+ pkgs = import nixpkgs haskellNix.nixpkgsArgs;

24+ evalPackages = import nixpkgs (haskellNix.nixpkgsArgs // { system = evalSystem; });

25+ p = pkgs.pkgsCross.mingwW64.haskell-nix.cabalProject {

26+ inherit evalPackages;

27+ src = evalPackages.haskell-nix.haskellLib.cleanGit { src = ./.; };

28+ };

29+

30+## Feb 16, 2022

31+* Removed lookupSha256 argument from project functions.

32+ Pass a `sha256map` instead.

33+* Added better support for `repository` in `cabal.project`. These

34+ blocks should now work without the need for passing `extra-hackages` and

35+ `extra-hackage-tarballs`.

36+

37+## Aug 6, 2021

38+* Included dependencies of haskell.nix that were tracked in `nix/sources.json`

39+ as flake inputs (`flake.lock` replaces `nix/sources.json`).

40+* Uses `flake-compat` to continue to provide a compatible interface for non

41+ flake projects.

42+

43+## Jul 23, 2021

44+* `source-repository-package` references in `cabal.project` files are now

45+ left as a `source-repository-package` when calculating the the `plan-nix` for

46+ `cabalProject` based functions.

47+ This makes haskell.nix match the behaviour of `cabal` better.

48+ Materialized files for projects that use `source-repository-package`

49+ references will need to be updated.

50+* Only planned components are included in a haskell.nix cabal project.

51+ If cabal solver does not include the component in the `plan.json` file it

52+ will not be present in `hsPkgs.pkg.components`.

53+* When the same package occurs more than once in a plan.json file

54+ the latest version is picked by haskell.nix.

55+

56+## Apr 8, 2021

57+* Project arguments are now validated with the Nix module system.

58+ If unexpected argments are passed to a project function this may now

59+ result in an error.

60+

61+## Feb 22, 2021

62+* Add `.dwarf` to build any component with DWARF dubug info on linux

63+ (ghc >=8.10.2).

64+* Pass `enableDWARF` to `shellFor` for to get a shell where all the

65+ components are the `.dwarf` ones.

66+

67+## Feb 18, 2021

68+* `ghcOptions` has been moved from package and is now a list of strings.

69+ old: packages.x.package.ghcOptions = "someGHCoption";

70+ new: packages.x.ghcOptions = ["someGHCoption"];

71+ To specify ghcOptions for all packages:

72+ ghcOptions = ["someGHCoption"];

73+ For a single component:

74+ packages.x.compoents.library.ghcOptions = ["someGHCoption"];

75+

76+## Feb 8, 2021

77+* Removed older versions of haskell-language-server from custom-tools

78+ (0.8.0 is in hackage so we can still get that version).

79+

80+## Jan 14, 2021

81+* Added support for cross package refs (with a project). Relative

82+ directory references between packages within a project should now

83+ work.

84+* Added `includeSiblings` to `cleanSourceWith`. When `true` it

85+ prevents the `subDir` arg from causing filtering of other directories.

86+* Added `keepGitDir` to `cleanGit` to allow `.git` directory to be kept

87+ (useful for components that use the `githash` package).

88+

89+## Nov 26, 2020

90+* Renamed `otherShells` arg for `shellFor` to `inputsFrom

91+

92+## Nov 25, 2020

93+* The `shellFor` `makeConfigFiles` `ghcWithHoogle` and `ghcWithPackages`

94+ functions have been removed from `project.hsPkgs`. Instead access

95+ them from `project` itself (e.g. change `p.hsPkgs.shellFor` to `p.shellFor`).

96+* The reflex-platform like `project.shells.ghc` has been removed.

97+ If needed, add something like `p // { shells.ghc = p.shellFor {} }`

98+ to `shell.nix`.

99+

100+## Nov 24, 2020

101+* Added `${targetPrefix}cabal` wrapper script for running cross

102+ compilers in `shellFor`.

103+* `otherShells` arg added to `shellFor`.

104+

105+## Oct 31, 2020

106+* Passing `tools.hoogle` to `shellFor` with a value suitable for `haskel-nix.tool` will

107+ use the specified `hoogle` inside `shellFor`. This allows for materialization

108+ of `hoogle`.

109+

110+## Oct 28, 2020

111+* Passing `compiler-nix-name` to project functions for `stack.yaml`

112+ based projects now overrides the compiler used (was ignored before).

113+

114+## Sep 8, 2020

115+* Added the ability to generate coverage reports for packages and

116+ projects.

117+* Added the `doCoverage` module option that allows users to choose

118+ packages to enable coverage for.

119+* Added a `doCoverage` flag to the component builder that outputs HPC

120+ information when coverage is enabled.

121+* Added test for coverage.

122+

123+## July 21, 2020

124+* Removed `components.all`, use `symlinkJoin` on components.exes or

125+ `shellFor` if you need a shell.

126+* Added `components` argument to `shellFor`.

127+

128+## July 21, 2020

129+* Added GHC 8.8.4 and replaced 8.8.3 in tests and as the ghc

130+ used to build nix-tools for stack projects.

131+

132+## July 20, 2020

133+* Changed `haskell-nix.roots` and `p.roots` to single derivations.

134+

135+## July 8, 2020

136+* Removed `sources.nixpkgs-default`, use `sources.nixpkgs` instead.

137+* Removed `./nixpkgs` directory, use `(import ./. {}).sources`

138+ or `./nix/sources.nix` instead.

139+* Removes V1 interface for details on how to fix old code see:

140+ https://github.com/input-output-hk/haskell.nix/issues/709

141+* Removed defaultCompilerNixName.

142+* cabalProject, cabalProject', hackage-project and hackage-package

143+ now require a `compiler-nix-name` argument.

144+* `haskell-nix.tool` and `.tools` now require a `compiler-nix-name` argument.

145+ New functions `p.tool` and `p.tools` (where p is a project) do not.

146+ Like `shellFor { tools = ... }` they will use the compiler nix name

147+ from the project (including stack projects where it is derived from

148+ the resolver).

149+* `haskell-nix.alex` and `haskell-nix.happy` have been removed. Use

150+ `p.tool "alex" "3.2.5"` or `shellFor { tools = { alex = "3.2.5"; } }`.

151+* `haskell-nix.nix-tools` -> `haskell-nix.nix-tools.ghc883` (it includes

152+ the hpack exe now).

153+* `haskell-nix.cabal-install` ->

154+ `p.tool "cabal" "3.2.0.0"` or `shellFor { tools = { cabal = "3.2.0.0"; } }`

155+* `haskell-nix.haskellNixRoots` -> `haskell-nix.roots ghc883` or `p.roots`

156+

157+## June 25, 2020

158+* Haddock docs are now built in their own derivation when needed (not as part

159+ of the component build).

160+ They should build automatically when something (such as `shellFor`) attempts

161+ to accesses the `.doc` attribute of component.

162+

4## December 27, 2019

163## December 27, 2019

5* Fix overlays/bootstrap.nix to provide LLVM 6, not LLVM 5, to ghc-8.6.X compilers.

164* Fix overlays/bootstrap.nix to provide LLVM 6, not LLVM 5, to ghc-8.6.X compilers.

6

165

ci-lib.nix+4−4

@@ -1,8 +1,8 @@

1−let

1+{

2 # Generic nixpkgs, use *only* for lib functions that are stable across versions

3− pkgs = import (import ./nixpkgs/default.nix).nixpkgs-default {};

3+ pkgs ? (import ./. {}).pkgs,

4− lib = pkgs.lib;

4+ lib ? pkgs.lib

5−in rec {

5+}: rec {

6 inherit (import ./dimension.nix) dimension;

7

8 # A filter for removing packages that aren't supported on the current platform

ci.nix+89−52

@@ -1,89 +1,126 @@

1−# 'supportedSystems' restricts the set of systems that we will evaluate for. Useful when you're evaluting

1+# 'supportedSystems' restricts the set of systems that we will evaluate for. Useful when you're evaluating

2−# on a machine with e.g. no way to build the Darwin IFDs you need!

2+# on a machine with e.g. no way to build the Darwin IFDs you need!

3{ supportedSystems ? [ "x86_64-linux" "x86_64-darwin" ]

4, ifdLevel ? 3

5# Whether or not we are evaluating in restricted mode. This is true in Hydra, but not in Hercules.

6, restrictEval ? false

7−, checkMaterialization ? false }:

7+, checkMaterialization ? false

8+, pkgs ? (import ./. {}).pkgs }:

8 let

9 let

9− inherit (import ./ci-lib.nix) dimension platformFilterGeneric filterAttrsOnlyRecursive;

10+ inherit (import ./ci-lib.nix { inherit pkgs; }) dimension platformFilterGeneric filterAttrsOnlyRecursive;

10− sources = import ./nix/sources.nix {};

11+ inherit (pkgs.haskell-nix) sources;

11 nixpkgsVersions = {

12 nixpkgsVersions = {

13+ "R2111" = "nixpkgs-2111";

12− "R1909" = "nixpkgs-1909";

14+ "R2205" = "nixpkgs-2205";

13− "R2003" = "nixpkgs-2003";

15+ "unstable" = "nixpkgs-unstable";

14 };

16 };

15− compilerNixNames = nixpkgsName: nixpkgs: builtins.mapAttrs (defaultCompilerNixName: _:

16− (import ./default.nix { inherit checkMaterialization defaultCompilerNixName; }).nixpkgsArgs) ({

17+ haskellNix = import ./default.nix { inherit checkMaterialization; };

17− ghc865 = {};

18+ nixpkgsArgs = haskellNix.nixpkgsArgs // {

18− } // nixpkgs.lib.optionalAttrs (nixpkgsName == "R2003") {

19+ # Needed for dwarf tests

19− ghc883 = {};

20+ config = haskellNix.nixpkgsArgs.config // {

20− ghc8101 = {};

21+ permittedInsecurePackages = ["libdwarf-20210528" "libdwarf-20181024" "dwarfdump-20181024"];

21− });

22+ };

22− systems = nixpkgs: nixpkgs.lib.filterAttrs (_: v: builtins.elem v supportedSystems) {

23− # I wanted to take these from 'lib.systems.examples', but apparently there isn't one for linux!

24− linux = "x86_64-linux";

25− darwin = "x86_64-darwin";

26 };

23 };

24+ compilerNixNames = nixpkgsName: nixpkgs: builtins.mapAttrs (compiler-nix-name: runTests: {

25+ inherit runTests;

26+ }) (

27+ # GHC version to cache and whether to run the tests against them.

28+ # This list of GHC versions should include everything for which we

29+ # have a ./materialized/ghcXXX directory containing the materialized

30+ # cabal-install and nix-tools plans. When removing a ghc version

31+ # from here (so that is no longer cached) also remove ./materialized/ghcXXX.

32+ # Update supported-ghc-versions.md to reflect any changes made here.

33+ nixpkgs.lib.optionalAttrs (nixpkgsName == "R2111") {

34+ ghc865 = false;

35+ ghc8107 = true;

36+ } // nixpkgs.lib.optionalAttrs (nixpkgsName == "R2205") {

37+ ghc865 = false;

38+ ghc8107 = true;

39+ } // nixpkgs.lib.optionalAttrs (nixpkgsName == "unstable") {

40+ ghc865 = false;

41+ ghc884 = false; # Native version is used to boot 9.0.1

42+ ghc8107 = true;

43+ ghc902 = true;

44+ ghc924 = true;

45+ });

46+ systems = nixpkgsName: nixpkgs: compiler-nix-name: nixpkgs.lib.genAttrs (

47+ nixpkgs.lib.filter (v:

48+ # We have less x86_64-darwin build capacity so build fewer GhC versions

49+ (v != "x86_64-darwin" || (

50+ !__elem compiler-nix-name ["ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901" "ghc921" "ghc922"]))

51+ &&

52+ # aarch64-darwin requires ghc 8.10.7

53+ (v != "aarch64-darwin" || (

54+ !__elem compiler-nix-name ["ghc865" "ghc884" "ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901" "ghc921" "ghc922"]))

55+ &&

56+ # aarch64-linux requires ghc 8.8.4

57+ (v != "aarch64-linux" || (

58+ !__elem compiler-nix-name ["ghc865" "ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901" "ghc921" "ghc922"]

59+ ))) supportedSystems) (v: v);

27− crossSystems = nixpkgsName: nixpkgs: compilerNixName: system:

60+ crossSystems = nixpkgsName: nixpkgs: compiler-nix-name: system:

28 # We need to use the actual nixpkgs version we're working with here, since the values

61 # We need to use the actual nixpkgs version we're working with here, since the values

29 # of 'lib.systems.examples' are not understood between all versions

62 # of 'lib.systems.examples' are not understood between all versions

30 let lib = nixpkgs.lib;

63 let lib = nixpkgs.lib;

31− in lib.optionalAttrs (system == "x86_64-linux" && compilerNixName != "ghc8101") {

64+ in lib.optionalAttrs (nixpkgsName == "unstable"

32− # Windows cross compilation is currently broken on macOS

65+ && ((system == "x86_64-linux" && __elem compiler-nix-name ["ghc865" "ghc884" "ghc8107"])

66+ || (system == "x86_64-darwin" && __elem compiler-nix-name ["ghc8107"]))) {

67+ inherit (lib.systems.examples) ghcjs;

68+ } // lib.optionalAttrs (nixpkgsName == "unstable"

69+ && ((system == "x86_64-linux" && __elem compiler-nix-name ["ghc8107" "ghc902" "ghc924"])

70+ || (system == "x86_64-darwin" && __elem compiler-nix-name []))) { # TODO add ghc versions when we have more darwin build capacity

33 inherit (lib.systems.examples) mingwW64;

71 inherit (lib.systems.examples) mingwW64;

34− } // lib.optionalAttrs (system == "x86_64-linux") {

72+ } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && __elem compiler-nix-name ["ghc8107" "ghc902" "ghc922" "ghc923" "ghc924"]) {

35 # Musl cross only works on linux

73 # Musl cross only works on linux

36 # aarch64 cross only works on linux

74 # aarch64 cross only works on linux

37 inherit (lib.systems.examples) musl64 aarch64-multiplatform;

75 inherit (lib.systems.examples) musl64 aarch64-multiplatform;

38 };

76 };

77+ isDisabled = d: d.meta.disabled or false;

39in

78in

40dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:

79dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:

41 let pinnedNixpkgsSrc = sources.${nixpkgs-pin};

80 let pinnedNixpkgsSrc = sources.${nixpkgs-pin};

42− # We need this for generic nixpkgs stuff at the right version

43− genericPkgs = import pinnedNixpkgsSrc {};

81+ evalPackages = import pinnedNixpkgsSrc nixpkgsArgs;

44− in dimension "GHC version" (compilerNixNames nixpkgsName genericPkgs) (compilerNixName: nixpkgsArgs:

82+ in dimension "GHC version" (compilerNixNames nixpkgsName evalPackages) (compiler-nix-name: {runTests}:

45− dimension "System" (systems genericPkgs) (systemName: system:

83+ dimension "System" (systems nixpkgsName evalPackages compiler-nix-name) (systemName: system:

46 let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system; });

84 let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system; });

47− build = import ./build.nix { inherit pkgs ifdLevel; };

85+ build = import ./build.nix { inherit pkgs evalPackages ifdLevel compiler-nix-name; };

48 platformFilter = platformFilterGeneric pkgs system;

86 platformFilter = platformFilterGeneric pkgs system;

49− in filterAttrsOnlyRecursive (_: v: platformFilter v) {

87+ in filterAttrsOnlyRecursive (_: v: platformFilter v && !(isDisabled v)) ({

50 # Native builds

88 # Native builds

51 # TODO: can we merge this into the general case by picking an appropriate "cross system" to mean native?

89 # TODO: can we merge this into the general case by picking an appropriate "cross system" to mean native?

52 native = pkgs.recurseIntoAttrs ({

90 native = pkgs.recurseIntoAttrs ({

91+ roots = pkgs.haskell-nix.roots' compiler-nix-name ifdLevel;

92+ ghc = pkgs.buildPackages.haskell-nix.compiler."${compiler-nix-name}";

93+ } // pkgs.lib.optionalAttrs runTests {

53 inherit (build) tests tools maintainer-scripts maintainer-script-cache;

94 inherit (build) tests tools maintainer-scripts maintainer-script-cache;

54− ghc = pkgs.buildPackages.haskell-nix.compiler."${compilerNixName}";

55 } // pkgs.lib.optionalAttrs (ifdLevel >= 1) {

95 } // pkgs.lib.optionalAttrs (ifdLevel >= 1) {

56− iserv-proxy = pkgs.ghc-extra-packages."${compilerNixName}".iserv-proxy.components.exes.iserv-proxy;

96+ iserv-proxy = pkgs.ghc-extra-projects."${compiler-nix-name}".getComponent "iserv-proxy:exe:iserv-proxy";

57 } // pkgs.lib.optionalAttrs (ifdLevel >= 3) {

97 } // pkgs.lib.optionalAttrs (ifdLevel >= 3) {

58− hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; }).components.exes.hello;

98+ hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; inherit evalPackages compiler-nix-name; }).getComponent "exe:hello";

59 });

99 });

60 }

100 }

61 //

101 //

62− dimension "Cross system" (crossSystems nixpkgsName genericPkgs compilerNixName system) (crossSystemName: crossSystem:

102+ dimension "Cross system" (crossSystems nixpkgsName evalPackages compiler-nix-name system) (crossSystemName: crossSystem:

63 # Cross builds

103 # Cross builds

64 let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system crossSystem; });

104 let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system crossSystem; });

65− build = import ./build.nix { inherit pkgs ifdLevel; };

105+ build = import ./build.nix { inherit pkgs evalPackages ifdLevel compiler-nix-name; };

66− in pkgs.recurseIntoAttrs (pkgs.lib.optionalAttrs (ifdLevel >= 1) {

106+ in pkgs.recurseIntoAttrs (pkgs.lib.optionalAttrs (ifdLevel >= 1) ({

107+ roots = pkgs.haskell-nix.roots' compiler-nix-name ifdLevel;

67− ghc = pkgs.buildPackages.haskell-nix.compiler."${compilerNixName}";

108+ ghc = pkgs.buildPackages.haskell-nix.compiler."${compiler-nix-name}";

68− # TODO: look into cross compiling ghc itself

109+ # TODO: look into cross compiling ghc itself

69− # ghc = pkgs.haskell-nix.compiler."${compilerNixName}";

110+ # ghc = pkgs.haskell-nix.compiler."${compiler-nix-name}";

70− # TODO: look into making tools work when cross compiling

111+ # TODO: look into making tools work when cross compiling

71− # inherit (build) tools;

112+ # inherit (build) tools;

113+ } // pkgs.lib.optionalAttrs (runTests && crossSystemName != "aarch64-multiplatform") {

72− # Tests are broken on aarch64 cross https://github.com/input-output-hk/haskell.nix/issues/513

114+ # Tests are broken on aarch64 cross https://github.com/input-output-hk/haskell.nix/issues/513

73− tests =

74− if (crossSystemName != "aarch64-multiplatform")

75− then build.tests

76− else pkgs.recurseIntoAttrs {

77− # Even on aarch64 we still want to build the pinned files

78− inherit (build.tests) haskellNixRoots;

115+ inherit (build) tests;

79− };

80− } // pkgs.lib.optionalAttrs (ifdLevel >= 2) {

116+ }) // pkgs.lib.optionalAttrs (ifdLevel >= 2 && crossSystemName != "ghcjs") {

117+ # GHCJS builds its own template haskell runner.

81− remote-iserv = pkgs.ghc-extra-packages."${compilerNixName}".remote-iserv.components.exes.remote-iserv;

118+ remote-iserv = pkgs.ghc-extra-projects."${compiler-nix-name}".getComponent "remote-iserv:exe:remote-iserv";

82− iserv-proxy = pkgs.ghc-extra-packages."${compilerNixName}".iserv-proxy.components.exes.iserv-proxy;

119+ iserv-proxy = pkgs.ghc-extra-projects."${compiler-nix-name}".getComponent "iserv-proxy:exe:iserv-proxy";

83 } // pkgs.lib.optionalAttrs (ifdLevel >= 3) {

120 } // pkgs.lib.optionalAttrs (ifdLevel >= 3) {

84− hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; }).components.exes.hello;

121+ hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; inherit compiler-nix-name; }).getComponent "exe:hello";

85 })

122 })

86− )

123+ ))

87 )

124 )

88 )

125 )

89)

126)

compiler/bootstrap/cabal-install.nix+2−2

@@ -1,4 +1,4 @@

1−{ fetchurl, hackage, stdenv, ghc, zlib, src, version }:

1+{ fetchurl, hackage, stdenv, lib, ghc, zlib, src, version }:

2let dependencies =

3 [ { name = "deepseq"; version = "1.4.3.0"; }

4 { name = "binary"; version = "0.8.5.1"; }

@@ -42,7 +42,7 @@ in stdenv.mkDerivation ({

42 };

43

44 meta = {

45− platforms = stdenv.lib.platforms.all;

45+ platforms = lib.platforms.all;

46 };

47

48 nativeBuildInputs = [ ghc zlib ];

compiler/ghc/default.nix+290−188

@@ -3,15 +3,19 @@

3# haskell.nix ships its own version of the ghc expression as it needs more

4# control over the expression to isolate it against varying <nixpkgs> and

5# allow us to customize it to the way haskell.nix works.

6+let self =

6−{ stdenv, haskell-nix, targetPackages

7+{ stdenv, lib, haskell-nix, targetPackages

7

8

8# build-tools

9# build-tools

9, bootPkgs

10, bootPkgs

11+, buildPackages

10−, autoconf, automake, coreutils, fetchurl, fetchpatch, perl, python3, m4, sphinx, numactl

12+, autoconf, automake, coreutils, fetchurl, fetchpatch, perl, python3, m4, sphinx, numactl, elfutils

11, autoreconfHook

13, autoreconfHook

12, bash

14, bash

13

15

14−, libiconv ? null, ncurses

16+, libiconv ? null

17+

18+, ncurses # TODO remove this once the cross compilers all work without

15

19

16, installDeps

20, installDeps

17

21

@@ -19,14 +23,17 @@

19 libffi ? null

23 libffi ? null

20

24

21, useLLVM ? !stdenv.targetPlatform.isx86

25, useLLVM ? !stdenv.targetPlatform.isx86

22−, # LLVM is conceptually a run-time-only depedendency, but for

26+, # LLVM is conceptually a run-time-only dependency, but for

23 # non-x86, we need LLVM to bootstrap later stages, so it becomes a

27 # non-x86, we need LLVM to bootstrap later stages, so it becomes a

24 # build-time dependency too.

28 # build-time dependency too.

25 buildLlvmPackages, llvmPackages

29 buildLlvmPackages, llvmPackages

26

30

27, # If enabled, GHC will be built with the GPL-free but slower integer-simple

31, # If enabled, GHC will be built with the GPL-free but slower integer-simple

28 # library instead of the faster but GPLed integer-gmp library.

32 # library instead of the faster but GPLed integer-gmp library.

33+ enableIntegerSimple ? !(lib.any (lib.meta.platformMatch stdenv.hostPlatform) gmp.meta.platforms), gmp

34+, # If enabled, GHC will be built with the GPL-free native backend of the

35+ # bignum library that is nearly as fast as GMP

29− enableIntegerSimple ? !(stdenv.lib.any (stdenv.lib.meta.platformMatch stdenv.hostPlatform) gmp.meta.platforms), gmp

36+ enableNativeBignum ? !((lib.any (lib.meta.platformMatch stdenv.hostPlatform) gmp.meta.platforms) || enableIntegerSimple)

30

37

31, # If enabled, use -fPIC when compiling static libs.

38, # If enabled, use -fPIC when compiling static libs.

32 enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform && !stdenv.targetPlatform.isAarch32

39 enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform && !stdenv.targetPlatform.isAarch32

@@ -37,12 +44,18 @@

37

44

38, enableLibraryProfiling ? true

45, enableLibraryProfiling ? true

39

46

40−, # Whetherto build terminfo. Musl fails to build terminfo as ncurses seems to be linked to glibc

47+, enableDWARF ? false

41− enableTerminfo ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.isMusl

48+

49+, enableTerminfo ?

50+ # Terminfo does not work on older ghc cross arm and windows compilers

51+ (!haskell-nix.haskellLib.isCrossTarget || !(stdenv.targetPlatform.isAarch64 || stdenv.targetPlatform.isWindows) || builtins.compareVersions ghc-version "8.10" >= 0)

52+

53+, # Wheter to build in NUMA support

54+ enableNUMA ? true

42

55

43, # What flavour to build. An empty string indicates no

56, # What flavour to build. An empty string indicates no

44 # specific flavour and falls back to ghc default values.

57 # specific flavour and falls back to ghc default values.

45− ghcFlavour ? stdenv.lib.optionalString haskell-nix.haskellLib.isCrossTarget (

58+ ghcFlavour ? lib.optionalString haskell-nix.haskellLib.isCrossTarget (

46 if useLLVM

59 if useLLVM

47 then "perf-cross"

60 then "perf-cross"

48 else "perf-cross-ncg"

61 else "perf-cross-ncg"

@@ -53,14 +66,19 @@

53 disableLargeAddressSpace ? stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64

66 disableLargeAddressSpace ? stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64

54

67

55, ghc-version ? src-spec.version

68, ghc-version ? src-spec.version

69+, ghc-version-date ? null

56, src-spec

70, src-spec

57, ghc-patches ? []

71, ghc-patches ? []

58

72

59# extra values we want to have available as passthru values.

73# extra values we want to have available as passthru values.

60, extra-passthru ? {}

74, extra-passthru ? {}

61−}:

75+}@args:

76+

77+assert !(enableIntegerSimple || enableNativeBignum) -> gmp != null;

62

78

79+# Early check to make sure only one of these is enabled

63−assert !enableIntegerSimple -> gmp != null;

80+assert enableNativeBignum -> !enableIntegerSimple;

81+assert enableIntegerSimple -> !enableNativeBignum;

64

82

65let

83let

66 inherit (stdenv) buildPlatform hostPlatform targetPlatform;

84 inherit (stdenv) buildPlatform hostPlatform targetPlatform;

@@ -68,7 +86,18 @@ let

68

86

69 inherit (bootPkgs) ghc;

87 inherit (bootPkgs) ghc;

70

88

89+ ghcHasNativeBignum = builtins.compareVersions ghc-version "9.0" >= 0;

90+

91+ bignumSpec =

92+ assert ghcHasNativeBignum -> !enableIntegerSimple;

93+ assert !ghcHasNativeBignum -> !enableNativeBignum;

94+ if ghcHasNativeBignum then ''

95+ BIGNUM_BACKEND = ${if enableNativeBignum then "native" else "gmp"}

96+ '' else ''

97+ INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}

98+ '';

99+

71− # TODO check if this posible fix for segfaults works or not.

100+ # TODO check if this possible fix for segfaults works or not.

72 targetLibffi =

101 targetLibffi =

73 # on native platforms targetPlatform.{libffi, gmp} do not exist; thus fall back

102 # on native platforms targetPlatform.{libffi, gmp} do not exist; thus fall back

74 # to the non-targetPlatform version in those cases.

103 # to the non-targetPlatform version in those cases.

@@ -80,8 +109,12 @@ let

80

109

81 targetGmp = targetPackages.gmp or gmp;

110 targetGmp = targetPackages.gmp or gmp;

82

111

112+ targetIconv = targetPackages.libiconv or libiconv;

113+

114+ targetNumactl = targetPackages.numactl or numactl;

115+

83 # TODO(@Ericson2314) Make unconditional

116 # TODO(@Ericson2314) Make unconditional

84− targetPrefix = stdenv.lib.optionalString

117+ targetPrefix = lib.optionalString

85 (targetPlatform != hostPlatform)

118 (targetPlatform != hostPlatform)

86 "${targetPlatform.config}-";

119 "${targetPlatform.config}-";

87

120

@@ -91,197 +124,177 @@ let

91 include mk/flavours/\$(BuildFlavour).mk

124 include mk/flavours/\$(BuildFlavour).mk

92 endif

125 endif

93 DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}

126 DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}

94− INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}

127+ '' + bignumSpec + ''

128+ EXTRA_HADDOCK_OPTS += --quickjump --hyperlinked-source

95− '' + stdenv.lib.optionalString (targetPlatform != hostPlatform) ''

129+ '' + lib.optionalString (targetPlatform != hostPlatform) ''

96 CrossCompilePrefix = ${targetPrefix}

130 CrossCompilePrefix = ${targetPrefix}

97− '' + stdenv.lib.optionalString isCrossTarget ''

131+ '' + lib.optionalString isCrossTarget ''

98 Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"}

132 Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"}

133+ ''

134+ # GHC 9.0.1 fails to compile for musl unless HADDOC_DOCS = NO

135+ + lib.optionalString (isCrossTarget || (targetPlatform.isMusl && builtins.compareVersions ghc-version "9.0.1" >= 0)) ''

99 HADDOCK_DOCS = NO

136 HADDOCK_DOCS = NO

100 BUILD_SPHINX_HTML = NO

137 BUILD_SPHINX_HTML = NO

101 BUILD_SPHINX_PDF = NO

138 BUILD_SPHINX_PDF = NO

102− '' + stdenv.lib.optionalString enableRelocatedStaticLibs ''

139+ '' + lib.optionalString enableRelocatedStaticLibs ''

103 GhcLibHcOpts += -fPIC

140 GhcLibHcOpts += -fPIC

104 GhcRtsHcOpts += -fPIC

141 GhcRtsHcOpts += -fPIC

142+ GhcRtsCcOpts += -fPIC

143+ '' + lib.optionalString (enableRelocatedStaticLibs && targetPlatform.isx86_64 && !targetPlatform.isWindows) ''

144+ GhcLibHcOpts += -fexternal-dynamic-refs

145+ GhcRtsHcOpts += -fexternal-dynamic-refs

146+ '' + lib.optionalString enableDWARF ''

147+ GhcLibHcOpts += -g3

148+ GhcRtsHcOpts += -g3

105− '' + stdenv.lib.optionalString targetPlatform.useAndroidPrebuilt ''

149+ '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''

106 EXTRA_CC_OPTS += -std=gnu99

150 EXTRA_CC_OPTS += -std=gnu99

107− '' + stdenv.lib.optionalString (!enableTerminfo) ''

151+ '' + lib.optionalString (!enableTerminfo) ''

108 WITH_TERMINFO=NO

152 WITH_TERMINFO=NO

109 ''

153 ''

154+ # musl doesn't have a system-linker. Only on x86, and on x86 we need it, as

155+ # our elf linker for x86_64 is broken.

156+ + lib.optionalString (targetPlatform.isAndroid || (targetPlatform.isMusl && !targetPlatform.isx86)) ''

157+ compiler_CONFIGURE_OPTS += --flags=-dynamic-system-linker

158+ ''

110 # While split sections are now enabled by default in ghc 8.8 for windows,

159 # While split sections are now enabled by default in ghc 8.8 for windows,

111 # the seem to lead to `too many sections` errors when building base for

160 # the seem to lead to `too many sections` errors when building base for

112 # profiling.

161 # profiling.

162+ #

163+ # It appears that loading split sections through iserv on qemu-aarch64, is

164+ # particularly slow. Let's disable them for now.

113− + stdenv.lib.optionalString targetPlatform.isWindows ''

165+ + lib.optionalString (targetPlatform.isWindows || targetPlatform.isAndroid) ''

114 SplitSections = NO

166 SplitSections = NO

115− '' + stdenv.lib.optionalString (!enableLibraryProfiling) ''

167+ '' + lib.optionalString (!enableLibraryProfiling) ''

116 BUILD_PROF_LIBS = NO

168 BUILD_PROF_LIBS = NO

117 '';

169 '';

118

170

119 # Splicer will pull out correct variations

171 # Splicer will pull out correct variations

120− libDeps = platform: stdenv.lib.optional enableTerminfo [ ncurses ]

172+ libDeps = platform: lib.optional enableTerminfo [ targetPackages.ncurses targetPackages.ncurses.dev ]

121 ++ [targetLibffi]

173 ++ [targetLibffi]

122− ++ stdenv.lib.optional (!enableIntegerSimple) gmp

174+ ++ lib.optional (!enableIntegerSimple) gmp

123− ++ stdenv.lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv

175+ ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv

124− ++ stdenv.lib.optional platform.isLinux numactl;

176+ ++ lib.optional (enableNUMA && platform.isLinux && !platform.isAarch32 && !platform.isAndroid) numactl

177+ # Even with terminfo disabled some older ghc cross arm and windows compilers do not build unless `ncurses` is found and they seem to want the buildPlatform version

178+ ++ lib.optional (!enableTerminfo && haskell-nix.haskellLib.isCrossTarget && (stdenv.targetPlatform.isAarch64 || stdenv.targetPlatform.isWindows) && builtins.compareVersions ghc-version "8.10" < 0) ncurses.dev;

125

179

126 toolsForTarget =

180 toolsForTarget =

127 if hostPlatform == buildPlatform then

181 if hostPlatform == buildPlatform then

128− [ targetPackages.stdenv.cc ] ++ stdenv.lib.optional useLLVM llvmPackages.llvm

182+ [ targetPackages.stdenv.cc ] ++ lib.optional useLLVM llvmPackages.llvm

129 else assert targetPlatform == hostPlatform; # build != host == target

183 else assert targetPlatform == hostPlatform; # build != host == target

130− [ stdenv.cc ] ++ stdenv.lib.optional useLLVM buildLlvmPackages.llvm;

184+ [ stdenv.cc ] ++ lib.optional useLLVM buildLlvmPackages.llvm;

131

185

132 targetCC = builtins.head toolsForTarget;

186 targetCC = builtins.head toolsForTarget;

133

187

134−in let configured-src = stdenv.mkDerivation (rec {

188+in

135−

136− version = ghc-version;

137−

138− patches = ghc-patches;

139−

140− name = "${targetPrefix}ghc-${ghc-version}-configured-src";

141−

142− # Make sure we never relax`$PATH` and hooks support for compatability.

143− strictDeps = true;

144−

145− nativeBuildInputs = [

146− perl autoconf automake m4 python3 sphinx

147− ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour

148− ] ++ stdenv.lib.optional (patches != []) autoreconfHook;

149−

150− # For building runtime libs

151− depsBuildTarget = toolsForTarget;

152−

153− buildInputs = [ perl bash ] ++ (libDeps hostPlatform);

154−

155− propagatedBuildInputs = [ targetPackages.stdenv.cc ]

156− ++ stdenv.lib.optional useLLVM llvmPackages.llvm;

157−

158− depsTargetTarget = map stdenv.lib.getDev (libDeps targetPlatform);

159− depsTargetTargetPropagated = map (stdenv.lib.getOutput "out") (libDeps targetPlatform);

160−

161− postPatch = "patchShebangs .";

162−

163− src = fetchurl { inherit (src-spec) url sha256; };

164−

165− # GHC is a bit confused on its cross terminology.

166− preConfigure = ''

167− for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do

168− export "''${env#TARGET_}=''${!env}"

169− done

170− # GHC is a bit confused on its cross terminology, as these would normally be

171− # the *host* tools.

172− export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"

173− export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"

174− # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177

175− export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${stdenv.lib.optionalString targetPlatform.isAarch32 ".gold"}"

176− export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"

177− export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"

178− export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"

179− export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"

180− export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"

181− export STRIP="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}strip"

182−

183− echo -n "${buildMK}" > mk/build.mk

184− sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure

185− '' + stdenv.lib.optionalString (!stdenv.isDarwin) ''

186− export NIX_LDFLAGS+=" -rpath $out/lib/${targetPrefix}ghc-${version}"

187− '' + stdenv.lib.optionalString stdenv.isDarwin ''

188− export NIX_LDFLAGS+=" -no_dtrace_dof"

189− '' + stdenv.lib.optionalString targetPlatform.useAndroidPrebuilt ''

190− 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

191− '' + stdenv.lib.optionalString targetPlatform.isMusl ''

192− echo "patching llvm-targets for musl targets..."

193− echo "Cloning these existing '*-linux-gnu*' targets:"

194− grep linux-gnu llvm-targets | sed 's/^/ /'

195− echo "(go go gadget sed)"

196− sed -i 's,$^.*linux-$gnu$.*$$,\0\n\1musl\2,' llvm-targets

197− echo "llvm-targets now contains these '*-linux-musl*' targets:"

198− grep linux-musl llvm-targets | sed 's/^/ /'

199−

200− echo "And now patching to preserve '-musleabi' as done with '-gnueabi'"

201− # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen)

202− for x in configure aclocal.m4; do

203− substituteInPlace $x \

204− --replace '*-android*|*-gnueabi*)' \

205− '*-android*|*-gnueabi*|*-musleabi*)'

206− done

207− '';

208−

209− configurePlatforms = [ "build" "host" "target" ];

210− # `--with` flags for libraries needed for RTS linker

211− configureFlags = [

212− "--datadir=$doc/share/doc/ghc"

213− "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib"

214− ] ++ stdenv.lib.optionals (targetLibffi != null) ["--with-system-libffi" "--with-ffi-includes=${targetLibffi.dev}/include" "--with-ffi-libraries=${targetLibffi.out}/lib"

215− ] ++ stdenv.lib.optional (!enableIntegerSimple) [

216− "--with-gmp-includes=${targetGmp.dev}/include" "--with-gmp-libraries=${targetGmp.out}/lib"

217− ] ++ stdenv.lib.optional (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [

218− "--with-iconv-includes=${libiconv}/include" "--with-iconv-libraries=${libiconv}/lib"

219− ] ++ stdenv.lib.optionals (targetPlatform != hostPlatform) [

220− "--enable-bootstrap-with-devel-snapshot"

221− ] ++ stdenv.lib.optionals (disableLargeAddressSpace) [

222− "--disable-large-address-space"

223− ] ++ stdenv.lib.optionals (targetPlatform.isAarch32) [

224− "CFLAGS=-fuse-ld=gold"

225− "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"

226− "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"

227− ] ;

228−

229− outputs = [ "out" ];

230− phases = [ "unpackPhase" "patchPhase" ]

231− ++ stdenv.lib.optional (ghc-patches != []) "autoreconfPhase"

232− ++ [ "configurePhase" "installPhase" ];

233− installPhase = "cp -r . $out";

234− });

235−

236− drv =stdenv.mkDerivation (rec {

189+stdenv.mkDerivation (rec {

237 version = ghc-version;

190 version = ghc-version;

238 name = "${targetPrefix}ghc-${version}";

191 name = "${targetPrefix}ghc-${version}";

239

192

240 patches = ghc-patches;

193 patches = ghc-patches;

241

194

242− # for this to properly work (with inheritance of patches, postPatch, ...)

195+ src = if src-spec ? file

243− # this needs to be a function over the values we want to inherit and then called

196+ then src-spec.file

244− # accordingly. Most trivial might be to just have args, and mash them into the

197+ else fetchurl { inherit (src-spec) url sha256; };

245− # attrset.

246− src = configured-src;

247

198

248 # configure was run by configured-src already.

199 # configure was run by configured-src already.

249− phases = [ "unpackPhase" "buildPhase"

200+ phases = [ "unpackPhase" "patchPhase" ]

201+ ++ lib.optional (ghc-patches != []) "autoreconfPhase"

202+ ++ [ "configurePhase" "buildPhase"

250 "checkPhase" "installPhase"

203 "checkPhase" "installPhase"

251 "fixupPhase"

204 "fixupPhase"

252 "installCheckPhase"

205 "installCheckPhase"

253 "distPhase"

206 "distPhase"

254 ];

207 ];

255

208

256− # ghc hardcodes the TOP dir durcing config, this breaks when

209+ # GHC is a bit confused on its cross terminology.

257− # splitting the configured src from the the build process.

210+ preConfigure =

258− postUnpack = ''

211+ # This code is only included when cross compiling as it breaks aarch64-darwin native compilation

259− (cd $sourceRoot

212+ lib.optionalString (targetPlatform != hostPlatform) ''

260− TOP=$(cat mk/config.mk|grep ^TOP|awk -F\ '{ print $3 }')

213+ for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do

261− PREFIX=$(cat mk/install.mk|grep ^prefix|awk -F\ '{ print $3 }')

214+ export "''${env#TARGET_}=''${!env}"

262−

215+ done

263− # these two are required

216+ # GHC is a bit confused on its cross terminology, as these would normally be

264− substituteInPlace mk/config.mk --replace "$TOP" "$PWD" \

217+ # the *host* tools.

265− --replace "$PREFIX" "$out"

218+ export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"

266−

219+ export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"

267− substituteInPlace mk/install.mk --replace "$TOP" "$PWD" \

220+ # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177

268− --replace "$PREFIX" "$out"

221+ export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString targetPlatform.isAarch32 ".gold"}"

269−

222+ export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"

270− # these two only for convencience.

223+ export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"

271− substituteInPlace config.log --replace "$TOP" "$PWD"\

224+ export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"

272− --replace "$PREFIX" "$out"

225+ export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"

273− substituteInPlace config.status --replace "$TOP" "$PWD"\

226+ export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"

274− --replace "$PREFIX" "$out")

227+ export STRIP="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}strip"

275−

228+ '' + ''

276−

229+ echo -n "${buildMK}" > mk/build.mk

230+ sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure

231+ '' + lib.optionalString useLLVM ''

232+ export LLC="${llvmPackages.llvm}/bin/llc"

233+ export OPT="${llvmPackages.llvm}/bin/opt"

234+ '' + lib.optionalString (!stdenv.isDarwin) ''

235+ export NIX_LDFLAGS+=" -rpath $out/lib/${targetPrefix}ghc-${ghc-version}"

236+ '' + lib.optionalString stdenv.isDarwin ''

237+ export NIX_LDFLAGS+=" -no_dtrace_dof"

238+ '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''

239+ 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

240+ '' + lib.optionalString targetPlatform.isMusl ''

241+ echo "patching llvm-targets for musl targets..."

242+ echo "Cloning these existing '*-linux-gnu*' targets:"

243+ grep linux-gnu llvm-targets | sed 's/^/ /'

244+ echo "(go go gadget sed)"

245+ sed -i 's,$^.*linux-$gnu$.*$$,\0\n\1musl\2,' llvm-targets

246+ echo "llvm-targets now contains these '*-linux-musl*' targets:"

247+ grep linux-musl llvm-targets | sed 's/^/ /'

248+

249+ echo "And now patching to preserve '-musleabi' as done with '-gnueabi'"

250+ # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen)

251+ for x in configure aclocal.m4; do

252+ substituteInPlace $x \

253+ --replace '*-android*|*-gnueabi*)' \

254+ '*-android*|*-gnueabi*|*-musleabi*)'

255+ done

256+ '' + lib.optionalString (src-spec.version != ghc-version) ''

257+ substituteInPlace configure --replace 'RELEASE=YES' 'RELEASE=NO'

258+ echo '${ghc-version}' > VERSION

259+ '' + lib.optionalString (ghc-version-date != null) ''

260+ substituteInPlace configure --replace 'RELEASE=YES' 'RELEASE=NO'

261+ echo '${ghc-version-date}' > VERSION_DATE

262+ '' + lib.optionalString (builtins.compareVersions ghc-version "9.2.3" >= 0) ''

263+ ./boot

264+ '';

265+

266+ configurePlatforms = [ "build" "host" "target" ];

267+ # `--with` flags for libraries needed for RTS linker

268+ configureFlags = [

269+ "--datadir=$doc/share/doc/ghc"

270+ "--with-curses-includes=${targetPackages.ncurses.dev}/include" "--with-curses-libraries=${targetPackages.ncurses.out}/lib"

271+ ] ++ lib.optionals (targetLibffi != null) ["--with-system-libffi" "--with-ffi-includes=${targetLibffi.dev}/include" "--with-ffi-libraries=${targetLibffi.out}/lib"

272+ ] ++ lib.optional (!enableIntegerSimple) [

273+ "--with-gmp-includes=${targetGmp.dev}/include" "--with-gmp-libraries=${targetGmp.out}/lib"

274+ ] ++ lib.optional (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [

275+ "--with-iconv-includes=${libiconv}/include" "--with-iconv-libraries=${libiconv}/lib"

276+ ] ++ lib.optional (targetPlatform != hostPlatform) [

277+ "--with-iconv-includes=${targetIconv}/include" "--with-iconv-libraries=${targetIconv}/lib"

278+ ] ++ lib.optionals (targetPlatform != hostPlatform) [

279+ "--enable-bootstrap-with-devel-snapshot"

280+ ] ++ lib.optionals (disableLargeAddressSpace) [

281+ "--disable-large-address-space"

282+ ] ++ lib.optionals (targetPlatform.isAarch32) [

283+ "CFLAGS=-fuse-ld=gold"

284+ "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"

285+ "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"

286+ ] ++ lib.optionals enableDWARF [

287+ "--enable-dwarf-unwind"

288+ "--with-libdw-includes=${lib.getDev elfutils}/include"

289+ "--with-libdw-libraries=${lib.getLib elfutils}/lib"

277− '';

290+ ];

278

291

279 enableParallelBuilding = true;

292 enableParallelBuilding = true;

280 postPatch = "patchShebangs .";

293 postPatch = "patchShebangs .";

281

294

282 outputs = [ "out" "doc" "generated" ];

295 outputs = [ "out" "doc" "generated" ];

283

296

284− # Make sure we never relax`$PATH` and hooks support for compatability.

297+ # Make sure we never relax`$PATH` and hooks support for compatibility.

285 strictDeps = true;

298 strictDeps = true;

286

299

287 # Don’t add -liconv to LDFLAGS automatically so that GHC will add it itself.

300 # Don’t add -liconv to LDFLAGS automatically so that GHC will add it itself.

@@ -290,22 +303,19 @@ in let configured-src = stdenv.mkDerivation (rec {

290 nativeBuildInputs = [

303 nativeBuildInputs = [

291 perl autoconf automake m4 python3 sphinx

304 perl autoconf automake m4 python3 sphinx

292 ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour

305 ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour

293− ] ++ stdenv.lib.optional (patches != []) autoreconfHook;

306+ ] ++ lib.optional (patches != []) autoreconfHook;

294

307

295 # For building runtime libs

308 # For building runtime libs

296 depsBuildTarget = toolsForTarget;

309 depsBuildTarget = toolsForTarget;

297

310

298 buildInputs = [ perl bash ] ++ (libDeps hostPlatform);

311 buildInputs = [ perl bash ] ++ (libDeps hostPlatform);

299

312

300− propagatedBuildInputs = [ targetPackages.stdenv.cc ]

301− ++ stdenv.lib.optional useLLVM llvmPackages.llvm;

302−

303− depsTargetTarget = map stdenv.lib.getDev (libDeps targetPlatform);

313+ depsTargetTarget = map lib.getDev (libDeps targetPlatform);

304− depsTargetTargetPropagated = map (stdenv.lib.getOutput "out") (libDeps targetPlatform);

314+ depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);

305

315

306 # required, because otherwise all symbols from HSffi.o are stripped, and

316 # required, because otherwise all symbols from HSffi.o are stripped, and

307 # that in turn causes GHCi to abort

317 # that in turn causes GHCi to abort

308− stripDebugFlags = [ "-S" ] ++ stdenv.lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols";

318+ stripDebugFlags = [ "-S" ] ++ lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols";

309

319

310 # See #63511 - the only unstripped file is the debug rts which isn't meant to

320 # See #63511 - the only unstripped file is the debug rts which isn't meant to

311 # be stripped.

321 # be stripped.

@@ -314,10 +324,21 @@ in let configured-src = stdenv.mkDerivation (rec {

314 checkTarget = "test";

324 checkTarget = "test";

315

325

316 hardeningDisable = [ "format" ]

326 hardeningDisable = [ "format" ]

317− ++ stdenv.lib.optional stdenv.targetPlatform.isAarch32 "pic"

327+ ++ lib.optional stdenv.targetPlatform.isAarch32 "pic"

318− ++ stdenv.lib.optional stdenv.targetPlatform.isMusl "pie";

328+ ++ lib.optional stdenv.targetPlatform.isMusl "pie";

319−

329+

320− postInstall = ''

330+ postInstall = lib.optionalString (enableNUMA && targetPlatform.isLinux) ''

331+ # Patch rts.conf to ensure libnuma can be found

332+

333+ for file in $(find "$out/lib" -name "rts*.conf"); do

334+ if grep -q numa $file; then

335+ substituteInPlace $file \

336+ --replace "library-dirs:" "library-dirs: ${targetNumactl}/lib" \

337+ --replace "include-dirs:" "include-dirs: ${targetNumactl}/include"

338+ "$out/bin/${targetPrefix}ghc-pkg" recache

339+ fi

340+ done

341+ '' + ''

321 # Install the bash completion file.

342 # Install the bash completion file.

322 install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc

343 install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc

323

344

@@ -328,16 +349,14 @@ in let configured-src = stdenv.mkDerivation (rec {

328 # The ghcprog fixup is for musl (where runhaskell script just needs to point to the correct

349 # The ghcprog fixup is for musl (where runhaskell script just needs to point to the correct

329 # ghc program to work).

350 # ghc program to work).

330 sed -i \

351 sed -i \

331− -e '2i export PATH="$PATH:${stdenv.lib.makeBinPath [ targetPackages.stdenv.cc.bintools coreutils ]}"' \

352+ -e '2i export PATH="$PATH:${lib.makeBinPath [ targetPackages.stdenv.cc.bintools coreutils ]}"' \

332 -e 's/ghcprog="ghc-/ghcprog="${targetPrefix}ghc-/' \

353 -e 's/ghcprog="ghc-/ghcprog="${targetPrefix}ghc-/' \

333 $i

354 $i

334 done

355 done

335

356

336− # Save generated files for needed when building ghcjs

357+ # Save generated files for needed when building ghc and ghcjs

337 mkdir -p $generated/includes/dist-derivedconstants/header

358 mkdir -p $generated/includes/dist-derivedconstants/header

338− cp includes/dist-derivedconstants/header/GHCConstantsHaskellExports.hs \

359+ cp includes/dist-derivedconstants/header/GHCConstantsHaskell*.hs \

339− includes/dist-derivedconstants/header/GHCConstantsHaskellType.hs \

340− includes/dist-derivedconstants/header/GHCConstantsHaskellWrappers.hs \

341 $generated/includes/dist-derivedconstants/header

360 $generated/includes/dist-derivedconstants/header

342 if [[ -f includes/ghcplatform.h ]]; then

361 if [[ -f includes/ghcplatform.h ]]; then

343 cp includes/ghcplatform.h $generated/includes

362 cp includes/ghcplatform.h $generated/includes

@@ -346,6 +365,15 @@ in let configured-src = stdenv.mkDerivation (rec {

346 fi

365 fi

347 mkdir -p $generated/compiler/stage2/build

366 mkdir -p $generated/compiler/stage2/build

348 cp compiler/stage2/build/Config.hs $generated/compiler/stage2/build || true

367 cp compiler/stage2/build/Config.hs $generated/compiler/stage2/build || true

368+ if [[ -f compiler/stage2/build/GHC/Platform/Constants.hs ]]; then

369+ mkdir -p $generated/compiler/stage2/build/GHC/Platform

370+ cp compiler/stage2/build/GHC/Platform/Constants.hs $generated/compiler/stage2/build/GHC/Platform

371+ fi

372+ if [[ -f compiler/stage2/build/GHC/Settings/Config.hs ]]; then

373+ mkdir -p $generated/compiler/stage2/build/GHC/Settings

374+ cp compiler/stage2/build/GHC/Settings/Config.hs $generated/compiler/stage2/build/GHC/Settings

375+ fi

376+ cp compiler/stage2/build/*.hs-incl $generated/compiler/stage2/build || true

349 mkdir -p $generated/rts/build

377 mkdir -p $generated/rts/build

350 cp rts/build/config.hs-incl $generated/rts/build || true

378 cp rts/build/config.hs-incl $generated/rts/build || true

351

379

@@ -361,22 +389,22 @@ in let configured-src = stdenv.mkDerivation (rec {

361 ${installDeps targetPrefix}

389 ${installDeps targetPrefix}

362

390

363 # Sanity checks for https://github.com/input-output-hk/haskell.nix/issues/660

391 # Sanity checks for https://github.com/input-output-hk/haskell.nix/issues/660

364− if [[ ! -f "$out/bin/${targetPrefix}ghc" ]]; then

392+ if ! "$out/bin/${targetPrefix}ghc" --version; then

365 echo "ERROR: Missing file $out/bin/${targetPrefix}ghc"

393 echo "ERROR: Missing file $out/bin/${targetPrefix}ghc"

366− exit 0

394+ exit 1

367 fi

395 fi

368− if [[ ! -f "$out/bin/${targetPrefix}ghc-pkg" ]]; then

396+ if ! "$out/bin/${targetPrefix}ghc-pkg" --version; then

369 echo "ERROR: Missing file $out/bin/${targetPrefix}ghc-pkg"

397 echo "ERROR: Missing file $out/bin/${targetPrefix}ghc-pkg"

370− exit 0

398+ exit 1

371− fi

399+ fi

372 if [[ ! -d "$out/lib/${targetPrefix}ghc-${version}" ]]; then

400 if [[ ! -d "$out/lib/${targetPrefix}ghc-${version}" ]]; then

373 echo "ERROR: Missing directory $out/lib/${targetPrefix}ghc-${version}"

401 echo "ERROR: Missing directory $out/lib/${targetPrefix}ghc-${version}"

374− exit 0

402+ exit 1

375− fi

403+ fi

376 if (( $(ls -1 "$out/lib/${targetPrefix}ghc-${version}" | wc -l) < 30 )); then

404 if (( $(ls -1 "$out/lib/${targetPrefix}ghc-${version}" | wc -l) < 30 )); then

377 echo "ERROR: Expected more files in $out/lib/${targetPrefix}ghc-${version}"

405 echo "ERROR: Expected more files in $out/lib/${targetPrefix}ghc-${version}"

378− exit 0

406+ exit 1

379− fi

407+ fi

380 '';

408 '';

381

409

382 passthru = {

410 passthru = {

@@ -384,14 +412,59 @@ in let configured-src = stdenv.mkDerivation (rec {

384

412

385 inherit llvmPackages;

413 inherit llvmPackages;

386 inherit enableShared;

414 inherit enableShared;

415+ inherit useLLVM;

387

416

388 # Our Cabal compiler name

417 # Our Cabal compiler name

389 haskellCompilerName = "ghc-${version}";

418 haskellCompilerName = "ghc-${version}";

390

419

420+ # This uses a similar trick to `pkgs.srcOnly` to get the configured src

421+ # We could add `configured-src` as an output of the ghc derivation, but

422+ # having it as its own derivation means it can be accessed quickly without

423+ # building GHC.

424+ configured-src = stdenv.mkDerivation ({

391− configured-src = configured-src;

425+ name = name + "-configured-src";

426+ inherit

427+ buildInputs

428+ version

429+ nativeBuildInputs

430+ patches

431+ src

432+ strictDeps

433+ depsBuildTarget

434+ depsTargetTarget

435+ depsTargetTargetPropagated

436+ postPatch

437+ preConfigure

438+ configurePlatforms

439+ configureFlags

440+ outputs

441+ ;

442+

443+ # Including all the outputs (not just $out) causes `mkDerivation` to use the nixpkgs multiple-outputs.sh hook.

444+ # This hook changes the arguments passed to `configure`.

445+ installPhase = ''

446+ cp -r . $out

447+ mkdir $doc

448+ mkdir $generated

449+ '';

450+ phases = [ "unpackPhase" "patchPhase" ]

451+ ++ lib.optional (ghc-patches != []) "autoreconfPhase"

452+ ++ [ "configurePhase" "installPhase"];

453+ });

392

454

393− # Used to detect non haskell-nix compilers (accedental use of nixpkgs compilers can lead to unexpected errors)

455+ # Used to detect non haskell-nix compilers (accidental use of nixpkgs compilers can lead to unexpected errors)

394 isHaskellNixCompiler = true;

456 isHaskellNixCompiler = true;

457+

458+ # The same GHC, but with debug enabled (if it can be)

459+ dwarf = lib.makeOverridable self (args // {

460+ enableDWARF = stdenv.targetPlatform.isLinux

461+ && builtins.compareVersions ghc-version "8.10.2" >= 0;

462+ });

463+

464+ # The same GHC, but without the large (1TB) address space reservation

465+ smallAddressSpace = lib.makeOverridable self (args // {

466+ disableLargeAddressSpace = true;

467+ });

395 } // extra-passthru;

468 } // extra-passthru;

396

469

397 meta = {

470 meta = {

@@ -401,10 +474,39 @@ in let configured-src = stdenv.mkDerivation (rec {

401 inherit (ghc.meta) license platforms;

474 inherit (ghc.meta) license platforms;

402 };

475 };

403

476

477+ # Needed for `haddock` to work on source that includes non ASCII chars

478+ LANG = "en_US.UTF-8";

479+ LC_ALL = "en_US.UTF-8";

480+} // lib.optionalAttrs (stdenv.buildPlatform.libc == "glibc") {

481+ LOCALE_ARCHIVE = "${buildPackages.glibcLocales}/lib/locale/locale-archive";

404−} // stdenv.lib.optionalAttrs targetPlatform.useAndroidPrebuilt {

482+} // lib.optionalAttrs targetPlatform.useAndroidPrebuilt {

405 dontStrip = true;

483 dontStrip = true;

406 dontPatchELF = true;

484 dontPatchELF = true;

407 noAuditTmpdir = true;

485 noAuditTmpdir = true;

486+} // lib.optionalAttrs (stdenv.buildPlatform.isDarwin || stdenv.targetPlatform.isWindows) {

487+ # ghc install on macOS wants to run `xattr -r -c`

488+ # The macOS version fails because it wants python 2.

489+ # The nix version of xattr does not support those args.

490+ # Luckily setting the path to something that does not exist will skip the step.

491+ preBuild = lib.optionalString stdenv.buildPlatform.isDarwin ''

492+ export XATTR=$(mktemp -d)/nothing

493+ ''

494+ # We need to point at a stand in `windows.h` header file so that the RTS headers can

495+ # work on the hostPlatform. We also need to work around case sensitve file system issues.

496+ + lib.optionalString stdenv.targetPlatform.isWindows ''

497+ export NIX_CFLAGS_COMPILE_${

498+ # We want this only to apply to the non windows hostPlatform (the

499+ # windows gcc cross compiler has a full `windows.h`).

500+ # This matches the way `suffixSalt` is calculated in nixpkgs.

501+ # See https://github.com/NixOS/nixpkgs/blob/8411006d6bcd7f6e6a8a1a80ce8fcdccdd16c6ab/pkgs/build-support/cc-wrapper/default.nix#L58

502+ lib.replaceStrings ["-" "."] ["_" "_"] stdenv.hostPlatform.config

503+ }+=" -I${../windows/include}"

504+ if [[ -f libraries/base/include/winio_structs.h ]]; then

505+ substituteInPlace libraries/base/include/winio_structs.h --replace Windows.h windows.h

506+ fi

507+ if [[ -f rts/win32/ThrIOManager.c ]]; then

508+ substituteInPlace rts/win32/ThrIOManager.c --replace rts\\OSThreads.h rts/OSThreads.h

509+ fi

510+ '';

408});

511});

409−

512+in self

410−in drv

compiler/ghc/source-dist.nixnew file+40

@@ -0,0 +1,40 @@

1+{ src, stdenv, pkgs, version, ghc, alex, happy, hscolour }:

2+stdenv.mkDerivation {

3+

4+ inherit version;

5+

6+ name = "ghc-source-dist";

7+

8+ buildInputs = [ ghc alex happy hscolour ] ++ (with pkgs; [ automake bash git cacert python3 autoconf xorg.lndir ]);

9+

10+ inherit src;

11+

12+ phases = [ "unpackPhase" "buildPhase" "installPhase" ];

13+

14+ buildPhase = ''

15+ # Happy and Alex are confused about their data dirs. See

16+ # https://github.com/haskell/cabal/issues/5862 for details.

17+ #

18+ # This is fixed in more recent builds. We can't rely on

19+ # custom built tools as computing the source-dist is pretty

20+ # much in the bootstrap lane.

21+

22+ export alex_datadir=$(find ${alex}/share -name "alex-*" -type d -and -not -path "*doc*")

23+ export happy_datadir=$(find ${happy}/share -name "happy-*" -type d -and -not -path "*doc*")

24+

25+ # We need to --skip-url-rewrites, ghc is a bit too strict here.

26+ python3 ./boot --skip-url-rewrites

27+ # let's not flood the screen with garbage.

28+ ./configure --silent

29+

30+ # this folder ends up being needed for the windows dists; just mock it.

31+ mkdir ghc-tarballs

32+ make sdist --silent

33+ '';

34+

35+ installPhase = ''

36+ mkdir -p $out

37+ install -Dm644 sdistprep/ghc-$(cat VERSION)-src.tar.xz $out/src.tar.xz

38+ install -Dm644 sdistprep/ghc-$(cat VERSION)-testsuite.tar.xz $out/testsuite.tar.xz

39+ '';

40+}

compiler/ghcjs/ghcjs-src.json+2−2

@@ -1,6 +1,6 @@

1{

2 "url": "https://github.com/ghcjs/ghcjs",

3− "rev": "e87195eaa2bc7e320e18cf10386802bc90b7c874",

3+ "rev": "58ed01e77028108c2b1da10d52cb331788b6a466",

4− "sha256": "02mwkf7aagxqi142gcmq048244apslrr72p568akcab9s0fn2gvy",

4+ "sha256": "1lr3grk5jjm8bvvkndilm06ry1dj7i66k4g27fr009bggdy9q6ws",

5 "fetchSubmodules": true

6}

compiler/ghcjs/ghcjs.nix+264−31

@@ -1,18 +1,28 @@

1{ pkgs

2, ghcjsSrcJson ? ./ghcjs-src.json

3, ghcjsSrc ? pkgs.buildPackages.fetchgit (builtins.fromJSON (builtins.readFile ghcjsSrcJson))

4−, ghcjsVersion ? "8.6.0.1"

4+, ghcjsVersion ? "8.6.0.0.10"

5, ghcVersion ? "8.6.5"

6+, compiler-nix-name ? if builtins.compareVersions ghcjsVersion "8.8.0.0" > 0

7+ then "ghc884"

8+ else "ghc865"

6, ghc ? pkgs.buildPackages.ghc

9, ghc ? pkgs.buildPackages.ghc

7−, happy ? pkgs.buildPackages.haskellPackages.happy

10+, overrideBootPackages ? [] # adds if not present, overrides if present.

8−, alex ? pkgs.buildPackages.haskellPackages.alex

9−, cabal-install ? pkgs.buildPackages.cabal-install

10}:

11}:

11let

12let

13+ isGhcjs88 = builtins.compareVersions ghcjsVersion "8.8.0.0" >= 0;

14+ isGhcjs810 = builtins.compareVersions ghcjsVersion "8.10.0.0" >= 0;

15+

12 project = pkgs.buildPackages.haskell-nix.ghcjsProject {

16 project = pkgs.buildPackages.haskell-nix.ghcjsProject {

13 src = ghcjsSrc;

17 src = ghcjsSrc;

14− inherit ghc ghcjsVersion ghcVersion happy alex cabal-install;

18+ inherit ghcjsVersion compiler-nix-name overrideBootPackages;

15− index-state = "2019-12-10T00:00:00Z";

19+ index-state = "2020-04-25T00:00:00Z";

20+ patches = if isGhcjs810

21+ then [

22+ ./patches/810/fast-weak.patch

23+ ./patches/810/boot-optimization-flags.patch

24+ ]

25+ else [];

16# plan-sha256 = "1wy2lr08maxyi7r8jiwf2gj6pdayk5vxxwh42bj4s2gg4035z0yc";

26# plan-sha256 = "1wy2lr08maxyi7r8jiwf2gj6pdayk5vxxwh42bj4s2gg4035z0yc";

17# materialized = ../../materialized/ghcjs;

27# materialized = ../../materialized/ghcjs;

18 };

28 };

@@ -22,47 +32,270 @@ let

22 all-ghcjs = pkgs.buildPackages.symlinkJoin {

32 all-ghcjs = pkgs.buildPackages.symlinkJoin {

23 name = "ghcjs-${ghcjsVersion}-symlinked";

33 name = "ghcjs-${ghcjsVersion}-symlinked";

24 paths = [

34 paths = [

25− ghcjs.components.exes.ghcjs

35+ (ghcjs.getComponent "exe:ghcjs-boot")

26− ghcjs.components.exes.ghcjs-pkg

36+ ] ++ (if isGhcjs88

27− ghcjs.components.exes.haddock-ghcjs

37+ then [

28− ghcjs.components.exes.hsc2hs-ghcjs

38+ (ghcjs.getComponent "exe:ghcjs")

29− ghcjs.components.exes.ghcjs-boot

39+ (ghcjs.getComponent "exe:ghcjs-pkg")

30− ghcjs.components.exes.ghcjs-run

40+ (ghcjs.getComponent "exe:private-ghcjs-hsc2hs")

31− ghcjs.components.exes.ghcjs-dumparchive

41+ (ghcjs.getComponent "exe:haddock")

42+ (ghcjs.getComponent "exe:ghcjs-dumparchive")

43+ (ghcjs.getComponent "exe:private-ghcjs-run")

44+ (ghcjs.getComponent "exe:private-ghcjs-unlit")

45+ ]

46+ else [

47+ (ghcjs.getComponent "exe:private-ghcjs-ghcjs")

48+ (ghcjs.getComponent "exe:private-ghcjs-ghcjs-pkg")

49+ (ghcjs.getComponent "exe:private-ghcjs-run")

50+ (ghcjs.getComponent "exe:private-ghcjs-unlit")

51+ (ghcjs.getComponent "exe:private-ghcjs-hsc2hs")

52+ (ghcjs.getComponent "exe:private-ghcjs-haddock")

53+ (ghcjs.getComponent "exe:private-ghcjs-ghcjs-dumparchive")

32− ];

54+ ]);

33 };

55 };

34 libexec = "libexec/${builtins.replaceStrings ["darwin" "i686"] ["osx" "i386"] pkgs.stdenv.buildPlatform.system}-${ghc.name}/ghcjs-${ghcVersion}";

56 libexec = "libexec/${builtins.replaceStrings ["darwin" "i686"] ["osx" "i386"] pkgs.stdenv.buildPlatform.system}-${ghc.name}/ghcjs-${ghcVersion}";

35 booted-ghcjs = pkgs.stdenv.mkDerivation {

57 booted-ghcjs = pkgs.stdenv.mkDerivation {

36 name = "ghcjs-${ghcVersion}";

58 name = "ghcjs-${ghcVersion}";

37 src = project.configured-src;

59 src = project.configured-src;

38

60

39− nativeBuildInputs = project.bootInputs;

61+ nativeBuildInputs = project.bootInputs

62+ ++ pkgs.lib.optional isGhcjs88 pkgs.buildPackages.procps;

40 passthru = {

63 passthru = {

41− inherit all-ghcjs;

64+ inherit all-ghcjs bundled-ghcjs project;

42− inherit (project) configured-src;

65+ configured-src = project.configured-src + "/ghc";

43− # Used to detect non haskell-nix compilers (accedental use of nixpkgs compilers can lead to unexpected errors)

66+ # Used to detect non haskell-nix compilers (accidental use of nixpkgs compilers can lead to unexpected errors)

44 isHaskellNixCompiler = true;

67 isHaskellNixCompiler = true;

45 } // ghcjs.components.exes;

68 } // ghcjs.components.exes;

69+ dontUpdateAutotoolsGnuConfigScripts = true;

46 dontConfigure = true;

70 dontConfigure = true;

47 dontInstall = true;

71 dontInstall = true;

48 buildPhase = ''

72 buildPhase = ''

49− export HOME=$TMP

73+ export HOME=$TMP

50− mkdir $HOME/.cabal

74+ mkdir $HOME/.cabal

51− touch $HOME/.cabal/config

75+ touch $HOME/.cabal/config

52− cd lib/boot

76+ cd lib/boot

53−

77+ ${if isGhcjs88

78+ then ''

54− mkdir -p $out/bin

79+ mkdir -p $out/bin

55− mkdir -p $out/lib/ghcjs-${ghcVersion}

80+ mkdir -p $out/lib

56− lndir ${all-ghcjs}/${libexec} $out/bin

81+ lndir ${all-ghcjs}/bin $out/bin

82+ chmod -R +w $out/bin

83+ rm $out/bin/ghcjs-boot

84+ cp ${ghcjs.getComponent "exe:ghcjs-boot"}/bin/ghcjs-boot $out/bin

85+ rm $out/bin/haddock

86+ cp ${ghcjs.getComponent "exe:haddock"}/bin/haddock $out/bin

57

87

58− wrapProgram $out/bin/ghcjs --add-flags "-B$out/lib/ghcjs-${ghcVersion}"

88+ wrapProgram $out/bin/ghcjs --add-flags "-B$out/lib"

59− wrapProgram $out/bin/haddock-ghcjs --add-flags "-B$out/lib/ghcjs-${ghcVersion}"

89+ wrapProgram $out/bin/haddock --add-flags "-B$out/lib"

60− wrapProgram $out/bin/ghcjs-pkg --add-flags "--global-package-db=$out/lib/ghcjs-${ghcVersion}/package.conf.d"

90+ wrapProgram $out/bin/ghcjs-pkg --add-flags "--global-package-db=$out/lib/package.conf.d"

91+ ''

92+ else ''

93+ mkdir -p $out

94+ lndir ${all-ghcjs} $out

95+ mkdir -p $out/lib/ghcjs-${ghcVersion}

96+ rm $out/bin/ghcjs-boot

97+ cp ${ghcjs.getComponent "exe:ghcjs-boot"}/bin/ghcjs-boot $out/bin

98+ wrapProgram $out/bin/ghcjs-boot --set ghcjs_libexecdir $out/bin

99+ mv $out/${libexec}/* $out/bin

61

100

101+ wrapProgram $out/bin/private-ghcjs-ghcjs --add-flags "-B$out/lib"

102+ wrapProgram $out/bin/private-ghcjs-haddock --add-flags "-B$out/lib"

103+ wrapProgram $out/bin/private-ghcjs-ghcjs-pkg --add-flags "--global-package-db=$out/lib/package.conf.d"

104+ ''

105+ }

106+ # Avoid timeouts while unix package runs hsc2hs (it does not print anything

107+ # for more than 900 seconds).

108+ {

109+ for n in {1..50}; do

110+ if [ ! -f $TMP/done ]; then

111+ sleep 300

112+ echo Keep alive $n

113+ fi

114+ done

115+ } &

116+ ${

117+ # Unsets NIX_CFLAGS_COMPILE so the osx version of iconv.h is not used by mistake

118+ if isGhcjs810 then ''

119+ env -u NIX_CFLAGS_COMPILE PATH=$out/bin:$PATH \

120+ $out/bin/ghcjs-boot --with-emsdk=${project.emsdk} --no-haddock \

121+ || (echo failed > $TMP/done; false)

122+ ''

123+ else if isGhcjs88 then ''

124+ env -u NIX_CFLAGS_COMPILE PATH=$out/bin:$PATH \

62− env PATH=$out/bin:$PATH $out/bin/ghcjs-boot -j1 --with-ghcjs-bin $out/bin

125+ $out/bin/ghcjs-boot -j1 --with-emsdk=${project.emsdk} --no-prof --no-haddock \

126+ || (echo failed > $TMP/done; false)

127+ ''

128+ else ''

129+ env -u NIX_CFLAGS_COMPILE PATH=$out/bin:$PATH \

130+ $out/bin/ghcjs-boot -j1 --with-ghcjs-libdir=$out --with-emsdk=${project.emsdk} \

131+ || (echo failed > $TMP/done; false)

132+ ''

133+ }

134+ echo ok > $TMP/done

63 '';

135 '';

64 # We hard code -j1 as a temporary workaround for

136 # We hard code -j1 as a temporary workaround for

65 # https://github.com/ghcjs/ghcjs/issues/654

137 # https://github.com/ghcjs/ghcjs/issues/654

66 # enableParallelBuilding = true;

138 # enableParallelBuilding = true;

67 };

139 };

140+ ghcjs-relocatable-bin = pkgs.stdenv.mkDerivation {

141+ name = "ghcjs-relocatable-bin-${ghcVersion}";

142+ src = all-ghcjs;

143+ dontConfigure = true;

144+ dontInstall = true;

145+ dontPatchShebangs = true;

146+ dontPatchELF = true;

147+ buildPhase = ''

148+ # Copy the ghcjs exectuables

149+ mkdir -p $out/bin

150+ cp $src/${libexec}/* $out/bin

151+

152+ # Add readlink (needed by bundleRootDir)

153+ cp ${pkgs.coreutils}/bin/readlink $out/bin

154+

155+ '' + (pkgs.lib.optionalString pkgs.stdenv.isDarwin ''

156+ # Make the executables location independent using install_name_tool and @executable_path

157+

158+ # Copy the libraries needed into place

159+ cp ${pkgs.gmp}/lib/libgmp.10.dylib $out/bin

160+ cp ${pkgs.ncurses}/lib/libncursesw.6.dylib $out/bin

161+ cp ${pkgs.libffi}/lib/libffi.6.dylib $out/bin

162+

163+ # Set the ID of the libraries

164+ chmod -R +w $out/bin

165+ install_name_tool -id "@executable_path/libgmp.10.dylib" "$out/bin/libgmp.10.dylib"

166+ install_name_tool -id "@executable_path/libncursesw.6.dylib" "$out/bin/libncursesw.6.dylib"

167+ install_name_tool -id "@executable_path/libffi.6.dylib" "$out/bin/libffi.6.dylib"

168+

169+ # Modify all the references so we look for the libraries in the system location or

170+ # @executable_path (the directory containin the exetubable itself).

171+ for fn in $out/bin/*; do

172+ install_name_tool -change "${pkgs.libiconv}/lib/libiconv.dylib" /usr/lib/libiconv.dylib "$fn"

173+ install_name_tool -change "${pkgs.stdenv.libc}/lib/libSystem.B.dylib" /usr/lib/libSystem.B.dylib "$fn"

174+ install_name_tool -change "${pkgs.gmp}/lib/libgmp.10.dylib" "@executable_path/libgmp.10.dylib" "$fn"

175+ install_name_tool -change "${pkgs.ncurses}/lib/libncursesw.6.dylib" "@executable_path/libncursesw.6.dylib" "$fn"

176+ install_name_tool -change "${pkgs.libffi}/lib/libffi.6.dylib" "@executable_path/libffi.6.dylib" "$fn"

177+ done

178+ '')

179+

180+ + (pkgs.lib.optionalString pkgs.stdenv.isLinux ''

181+ # Make the executables location independent using patchelf and $ORIGIN.

182+ chmod -R +w $out/bin

183+ # This interpreter setting will not work on nixOS, but this bundle is

184+ # not really needed on nixOS systems.

185+ patchelf --set-interpreter /lib64/ld-linux-x86-64.so.2 $out/bin/*

186+ patchelf --set-rpath '$ORIGIN' $out/bin/*

187+ # Link the libraries needed into place

188+ ln -s ${pkgs.gmp}/lib/libgmp.so.* $out/bin

189+ ln -s ${pkgs.ncurses}/lib/libncursesw.so.* $out/bin

190+ ln -s ${pkgs.libffi}/lib/libffi.so.* $out/bin

191+ '');

192+ };

193+ # This is a way to find the location of the root directory of this bundle

194+ # when one of the wrapper scripts runs. By using readlink (to avoid

195+ # issues with symlinks that might be made to the script) and dirname

196+ # we can find the directory even when it may have been moved.

197+ bundleRootDir = ''"$(dirname "$(dirname "$(readlink -f "$0")")")"'';

198+ bundled-ghcjs = {

199+ compilerName ? "ghcjs", # Name for the compiler wrapper

200+ db ? null, # A ghcjs package database this argument should can

201+ # be `project.(shellFor { ... }).configFiles` or

202+ # the result of a `makeConfigFiles` call.

203+ hostDb ? null # Like db, but this will be passed as the `-host-package-db`.

204+ }:

205+ let

206+ libDeps = pkgs.lib.concatMapStrings (lib: "${lib} ") (pkgs.lib.unique (

207+ [booted-ghcjs ghc db hostDb pkgs.ncurses pkgs.gmp pkgs.libffi]

208+ ++ (pkgs.haskell-nix.haskellLib.flatLibDepends db.component)

209+ ++ (pkgs.haskell-nix.haskellLib.flatLibDepends hostDb.component)

210+ ));

211+ in pkgs.stdenv.mkDerivation {

212+ name = "${compilerName}-${ghcVersion}-bundle";

213+ src = booted-ghcjs;

214+ nativeBuildInputs = [ pkgs.makeWrapper pkgs.xorg.lndir ];

215+ dontConfigure = true;

216+ dontInstall = true;

217+ dontPatchShebangs = true;

218+ dontPatchELF = true;

219+ buildPhase = ''

220+ # Copy the ghcjs exectuables

221+ mkdir -p $out/bin

222+ lndir ${ghcjs-relocatable-bin}/bin $out/bin

223+

224+ # Make the executables writeable for patchelf and install_name_tool

225+ chmod -R +w $out/bin

226+

227+ # And links for the /lib directory of all the dependencies

228+ # including the booted ghcjs

229+ for lib in ${ libDeps }; do

230+ if [ -d $lib/lib ]; then

231+ mkdir -p $out/$(basename $lib)

232+ lndir -silent $lib $out/$(basename $lib)

233+ fi

234+ done

235+

236+ '' + (pkgs.lib.optionalString pkgs.stdenv.isDarwin ''

237+ rm -rf $out/$(basename ${hostDb})/lib/links

238+ cp -rL ${hostDb}/lib/links $out/$(basename ${hostDb})/lib

239+ chmod -R +w $out/$(basename ${hostDb})/lib/links

240+

241+ # Modify all the references so we look for the libraries in the system location or

242+ # @executable_path (the directory containin the exetubable itself).

243+ for fn in $out/$(basename ${hostDb})/lib/links/*; do

244+ install_name_tool -change "${pkgs.libiconv}/lib/libiconv.dylib" /usr/lib/libiconv.dylib "$fn"

245+ install_name_tool -change "${pkgs.stdenv.libc}/lib/libSystem.B.dylib" /usr/lib/libSystem.B.dylib "$fn"

246+ install_name_tool -change "${pkgs.gmp}/lib/libgmp.10.dylib" "@executable_path/libgmp.10.dylib" "$fn"

247+ install_name_tool -change "${pkgs.ncurses}/lib/libncursesw.6.dylib" "@executable_path/libncursesw.6.dylib" "$fn"

248+ install_name_tool -change "${pkgs.libffi}/lib/libffi.6.dylib" "@executable_path/libffi.6.dylib" "$fn"

249+ done

250+ '') + ''

251+

252+ # Wrap the programs to add the ghcjs library dir and package DB directories

253+ wrapProgram $out/bin/ghcjs \

254+ --add-flags '"-B${bundleRootDir}/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}"' \

255+ --add-flags '"-package-db ${db}/${db.packageCfgDir}"' ${

256+ pkgs.lib.optionalString (hostDb != null)

257+ " --add-flags '-host-package-db=${hostDb}/${hostDb.packageCfgDir}'"

258+ }

259+ wrapProgram $out/bin/ghcjs-pkg --add-flags '"--global-package-db=${db}/${db.packageCfgDir}"'

260+ wrapProgram $out/bin/haddock-ghcjs --add-flags '"-B${bundleRootDir}/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}"'

261+

262+ # Fix the bang pattern to use the systems bash.

263+ # Replace the absolute output path ($out) with bundleRootDir

264+ # (this will fix the references to the unwarpped executables).

265+ # Replace the `/nix/store` refs (in the package DB paths) with

266+ # bundleRootDir.

267+ sed -i \

268+ -e 's|${pkgs.stdenv.shell}|/usr/bin/env -S bash|' \

269+ -e "s|$out/|"'${bundleRootDir}/|g' \

270+ -e 's|/nix/store/|${bundleRootDir}/|g' \

271+ $out/bin/ghcjs $out/bin/haddock-ghcjs $out/bin/ghcjs-pkg

272+

273+ # Update the ghcjs and ghc settings files so that `cc` looked up in the PATH.

274+ rm $out/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}/settings

275+ sed -e 's|/nix/store/.*/bin/cc|cc|' \

276+ < ${booted-ghcjs}/lib/ghcjs-${ghcVersion}/settings \

277+ > $out/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}/settings

278+ rm $out/$(basename ${ghc})/lib/ghc-${ghcVersion}/settings

279+ sed -e 's|/nix/store/.*/bin/cc|cc|' \

280+ < ${ghc}/lib/ghc-${ghcVersion}/settings \

281+ > $out/$(basename ${ghc})/lib/ghc-${ghcVersion}/settings

282+

283+ # Update the ghcjs settings files so that `node` looked up in the PATH.

284+ rm $out/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}/nodeSettings.json

285+ sed -e 's|/nix/store/.*/bin/node|node|' \

286+ < ${booted-ghcjs}/lib/ghcjs-${ghcVersion}/nodeSettings.json \

287+ > $out/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}/nodeSettings.json

288+

289+ # Update the ghcjs settings files so that `node` looked up in the PATH.

290+ rm $out/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}/ghc_libdir

291+ sed -e 's|/nix/store/|../../../|' \

292+ < ${booted-ghcjs}/lib/ghcjs-${ghcVersion}/ghc_libdir \

293+ > $out/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}/ghc_libdir

294+ '' + (pkgs.lib.optionalString (compilerName != "ghcjs") ''

295+ # Rename the wrappers based on the `compilerName` arg

296+ mv $out/bin/ghcjs $out/bin/${compilerName}

297+ mv $out/bin/ghcjs-pkg $out/bin/${compilerName}-pkg

298+ mv $out/bin/haddock-ghcjs $out/bin/haddock-${compilerName}

299+ '');

300+ };

68−in booted-ghcjs

301+in booted-ghcjs

compiler/ghcjs/ghcjs810-patched-boot-packages/aeson.patchnew file+13

@@ -0,0 +1,13 @@

1+diff --git a/aeson.cabal b/aeson.cabal

2+index a0ebd59..552f160 100755

3+--- a/aeson.cabal

4++++ b/aeson.cabal

5+@@ -150,7 +150,7 @@ library

6+ dlist >= 0.8.0.4 && < 0.9,

7+ hashable >= 1.2.7.0 && < 1.4,

8+ scientific >= 0.3.6.2 && < 0.4,

9+- th-abstraction >= 0.2.8.0 && < 0.4,

10++ th-abstraction >= 0.2.8.0 && < 0.5,

11+ uuid-types >= 1.0.3 && < 1.1,

12+ vector >= 0.12.0.1 && < 0.13

13+

compiler/ghcjs/ghcjs810-patched-boot-packages/default.nixnew file+176

@@ -0,0 +1,176 @@

1+{ pkgs

2+, ...

3+}:

4+let

5+ patch = p: path: pkgs.runCommand "patched" { buildInputs = [ pkgs.gnupatch ]; } ''

6+ cp -r ${path} $out

7+ chmod -R +w $out

8+ cd $out

9+ patch -p1 <${p}

10+ '';

11+ getSubdir = d: path: pkgs.runCommand "subdir" { } ''

12+ cp -r ${path}/${d} $out

13+ '';

14+in

15+[

16+ {

17+ name = "primitive";

18+ src = pkgs.fetchgit {

19+ url = "https://github.com/haskell/primitive.git";

20+ rev = "11ff865fd2157a1dfd7dfd525b1cf27e1a300633";

21+ sha256 = "1skim1vlmf0v4ixm8h8ja3m1pz0h10xrfdh1rfzawsy8rvrp2cc0";

22+ };

23+ }

24+ {

25+ name = "dlist";

26+ src = pkgs.fetchgit {

27+ url = "https://github.com/spl/dlist.git";

28+ rev = "567cfeb2f5da30f2e5faf167895b3ee04c698ca0";

29+ sha256 = "0b8ij3ls7bccbp9rlm8dnflnf1wim9xsg42wmirvwxwmh2c0r0hg";

30+ };

31+ }

32+ {

33+ name = "vector";

34+ src = pkgs.fetchgit {

35+ url = "https://github.com/haskell/vector.git";

36+ rev = "de10fd281fa5d8beee3623e809a71385a5ef6864";

37+ sha256 = "09vhbvrkw90xgqfrybmhy120rwcy4snw2f97004alr3n96lwpg1q";

38+ };

39+ }

40+ {

41+ name = "ghcjs-base";

42+ src = patch ./ghcjs-base.patch (pkgs.fetchgit {

43+ url = "https://github.com/ghcjs/ghcjs-base.git";

44+ rev = "85e31beab9beffc3ea91b954b61a5d04e708b8f2";

45+ sha256 = "15fdkjv0l7hpbbsn5238xxgzfdg61g666nzbv2sgxkwryn5rycv0";

46+ });

47+ }

48+ {

49+ name = "text";

50+ src = pkgs.fetchgit {

51+ url = "https://github.com/dfordivam/text.git";

52+ rev = "126174753ea8e5f45df8fcbba609e3f1c453bf27";

53+ sha256 = "0l7nbln2w77s12fm4ybhi0jsfnxkyiwskfx3b682pfisa6n32rgm";

54+ };

55+ }

56+ {

57+ name = "hashable";

58+ src = patch ./hashable.patch (pkgs.fetchgit {

59+ url = "https://github.com/haskell-unordered-containers/hashable.git";

60+ rev = "819fdbeaeeb62ed1344fb057de17fa29b10fa3e1";

61+ sha256 = "0xnwfwnnh0bxq16wx0qmdakvgvj8i22km3bhvvki15rd9jil04cc";

62+ });

63+ }

64+ {

65+ name = "integer-logarithms";

66+ src = pkgs.fetchgit {

67+ url = "https://github.com/haskellari/integer-logarithms.git";

68+ rev = "df09cef2c8eb0d5899e2bcccee2a4fad413bdc11";

69+ sha256 = "1k17hjnjmy44dfywx9nr804qiqmjjhkpfpll5bsfvzvpnl5r75nj";

70+ };

71+ }

72+ {

73+ name = "scientific";

74+ src = pkgs.fetchgit {

75+ url = "https://github.com/basvandijk/scientific.git";

76+ rev = "1d049cdf04e2d92ab187754044b0df933c5e6b0d";

77+ sha256 = "1v4fmfq8hyhdb5ck5r2b45s1izr7hx97v4g7s597ajbv72ldvilq";

78+ };

79+ }

80+ {

81+ name = "attoparsec";

82+ src = pkgs.fetchgit {

83+ url = "https://github.com/dfordivam/attoparsec.git";

84+ rev = "cbfb944aeff61144059a28ada93c579e93ccf7d2";

85+ sha256 = "0bbr4943439sy3grwpwbna4mk7iv87ijaiv3jjfhxhp7y67z51h8";

86+ };

87+ }

88+ {

89+ name = "splitmix";

90+ src = pkgs.fetchgit {

91+ url = "https://github.com/haskellari/splitmix.git";

92+ rev = "d8c1b57bb75178675423f87b1ff58429f37bc9fe";

93+ sha256 = "1m8v439vlwqpqw28dbr04n6m0j2cfb169ly285lp0bjmzcwlr289";

94+ };

95+ }

96+ {

97+ name = "random";

98+ src = pkgs.fetchgit {

99+ url = "https://github.com/haskell/random.git";

100+ rev = "8c59bd0fda84fa581d53069b45100d810f5a778f";

101+ sha256 = "1drdipfbmpg2g2cdrnq1k8yysh86i7ljwm6zkrrs3g8l47n4ha4d";

102+ };

103+ }

104+ {

105+ name = "uuid-types";

106+ src = getSubdir "uuid-types" (pkgs.fetchgit {

107+ url = "https://github.com/haskell-hvr/uuid.git";

108+ rev = "e8dc7126582ba4d3abc5e0f26dc1d8477caab01e";

109+ sha256 = "037cnfz7rhkw383rn117b994jzs93i3bwdv47x5qiza5h5syd76f";

110+ });

111+ }

112+ {

113+ name = "unordered-containers";

114+ src = pkgs.fetchgit {

115+ url = "https://github.com/haskell-unordered-containers/unordered-containers.git";

116+ rev = "db9ddde2b243366976a1bdfbb12a5e257ca762c3";

117+ sha256 = "1wd5hxppj1gg9fa1ihcn3s2y0i70ykv2sf8sym6dlf3r4snda9zi";

118+ };

119+ }

120+ {

121+ name = "base-orphans";

122+ src = pkgs.fetchgit {

123+ url = "https://github.com/haskell-compat/base-orphans.git";

124+ rev = "1af3a3512efbcc12e0c34637a0e433ab6e195932";

125+ sha256 = "14b6qwc3dbnmrhqk66a2cn4pvv3nf6kb3h7ym1hjn5xs7n62zhw1";

126+ };

127+ }

128+ {

129+ name = "time-compat";

130+ src = pkgs.fetchgit {

131+ url = "https://github.com/haskellari/time-compat.git";

132+ rev = "67b8b063295601fb1db185baad363a3f33ed63a9";

133+ sha256 = "0nbjsn7yrygv4i1fd8x90mnf4janq536ffvkjd5zsnyzm8qk8k3j";

134+ };

135+ }

136+ {

137+ name = "th-abstraction";

138+ src = pkgs.fetchgit {

139+ url = "https://github.com/glguy/th-abstraction.git";

140+ rev = "d75761bc5a0f912aeeb508e2c227b9fd830153fd";

141+ sha256 = "070ihxncymzsbrgvwmrm717n0qq5bf9nvc2k210nkil1cwrsnhvc";

142+ };

143+ }

144+ {

145+ name = "tagged";

146+ src = pkgs.fetchgit {

147+ url = "https://github.com/ekmett/tagged.git";

148+ rev = "15fcfe90c779efea951ecf4d451d709aed5f7d32";

149+ sha256 = "1x1wr4zf7k1kvd6rj06h9shw7p5di1jra9fysyw0jx7riiq0v3ch";

150+ };

151+ }

152+ {

153+ name = "base-compat";

154+ src = getSubdir "base-compat" (pkgs.fetchgit {

155+ url = "https://github.com/haskell-compat/base-compat.git";

156+ rev = "e8dbac72251e898fc4b1c1abb34d6578da12f476";

157+ sha256 = "1gs15g8h7p8gab9j5fjvjlhrfv112w91plraf9chq80c5slvk016";

158+ });

159+ }

160+ {

161+ name = "base-compat-batteries";

162+ src = getSubdir "base-compat-batteries" (pkgs.fetchgit {

163+ url = "https://github.com/haskell-compat/base-compat.git";

164+ rev = "e8dbac72251e898fc4b1c1abb34d6578da12f476";

165+ sha256 = "1gs15g8h7p8gab9j5fjvjlhrfv112w91plraf9chq80c5slvk016";

166+ });

167+ }

168+ {

169+ name = "aeson";

170+ src = patch ./aeson.patch (pkgs.fetchgit {

171+ url = "https://github.com/dfordivam/aeson.git";

172+ rev = "9a8f57a52eb748a030bc2bcf5c3159a5e2e696b2";

173+ sha256 = "1y8j3ddxxddpnb7c0vi73ijb08sr09z1gdzfg1rfyzn82d6i38zv";

174+ });

175+ }

176+]

compiler/ghcjs/ghcjs810-patched-boot-packages/ghcjs-base.patchnew file+471

@@ -0,0 +1,471 @@

1+diff --git a/Data/JSString.hs b/Data/JSString.hs

2+index 176aad4..9ca6693 100644

3+--- a/Data/JSString.hs

4++++ b/Data/JSString.hs

5+@@ -99,6 +99,7 @@ module Data.JSString ( JSString

6+ , breakOnEnd

7+ , break

8+ , span

9++ , span_

10+ , group

11+ , group'

12+ , groupBy

13+@@ -1231,19 +1232,23 @@ splitAt (I# n) x = case js_splitAt n x of (# y, z #) -> (y, z)

14+ -- of @t@ of elements that satisfy @p@, and whose second is the

15+ -- remainder of the list.

16+ span :: (Char -> Bool) -> JSString -> (JSString, JSString)

17+-span p x = case js_length x of

18+- 0# -> (empty, empty)

19+- l -> let c0 = js_uncheckedIndex 0# x

20+- in if p (C# (chr# c0)) then loop 0# l else (empty, x)

21++span p x = let (# a, b #) = span_ p x in (a, b)

22++{-# INLINE span #-}

23++

24++span_ :: (Char -> Bool) -> JSString -> (# JSString, JSString #)

25++span_ p x = case js_length x of

26++ 0# -> (# empty, empty #)

27++ l -> let c0 = js_uncheckedIndex 0# x

28++ in if p (C# (chr# c0)) then loop 0# l else (# empty, x #)

29+ where

30+ loop i l

31+- | isTrue# (i >=# l) = (x, empty)

32++ | isTrue# (i >=# l) = (# x, empty #)

33+ | otherwise =

34+ let c = js_uncheckedIndex i x

35+ in if p (C# (chr# c))

36+ then loop (i +# charWidth c) l

37+- else (js_substr 0# i x, js_substr1 i x)

38+-{-# INLINE span #-}

39++ else (# js_substr 0# i x, js_substr1 i x #)

40++{-# INLINE span_ #-}

41+

42+ -- | /O(n)/ 'break' is like 'span', but the prefix returned is

43+ -- over elements that fail the predicate @p@.

44+diff --git a/GHCJS/Foreign.hs b/GHCJS/Foreign.hs

45+index 5bbc5c5..b128f24 100644

46+--- a/GHCJS/Foreign.hs

47++++ b/GHCJS/Foreign.hs

48+@@ -82,7 +82,7 @@ import GHCJS.Marshal

49+ import GHCJS.Marshal.Pure

50+ -}

51+ import Data.String (IsString(..))

52+-import qualified Data.Text as T

53++-- import qualified Data.Text as T

54+

55+

56+ class ToJSString a where

57+diff --git a/GHCJS/Foreign/Internal.hs b/GHCJS/Foreign/Internal.hs

58+index 5ac81f0..449bfe4 100644

59+--- a/GHCJS/Foreign/Internal.hs

60++++ b/GHCJS/Foreign/Internal.hs

61+@@ -100,10 +100,10 @@ import Data.Typeable (Typeable)

62+ import Data.ByteString (ByteString)

63+ import Data.ByteString.Unsafe (unsafePackAddressLen)

64+

65+-import qualified Data.Text.Array as A

66+-import qualified Data.Text as T

67+-import qualified Data.Text.Internal as T

68+-import qualified Data.Text.Lazy as TL (Text, toStrict, fromStrict)

69++-- import qualified Data.Text.Array as A

70++-- import qualified Data.Text as T

71++-- import qualified Data.Text.Internal as T

72++-- import qualified Data.Text.Lazy as TL (Text, toStrict, fromStrict)

73+

74+ import Unsafe.Coerce

75+

76+diff --git a/GHCJS/Marshal.hs b/GHCJS/Marshal.hs

77+index a36aca2..6256a73 100644

78+--- a/GHCJS/Marshal.hs

79++++ b/GHCJS/Marshal.hs

80+@@ -16,7 +16,7 @@

81+

82+ module GHCJS.Marshal ( FromJSVal(..)

83+ , ToJSVal(..)

84+- , toJSVal_aeson

85++ -- , toJSVal_aeson

86+ , toJSVal_pure

87+ ) where

88+

89+@@ -24,17 +24,17 @@ import Control.Applicative

90+ import Control.Monad

91+ import Control.Monad.Trans.Maybe (MaybeT(..), runMaybeT)

92+

93+-import qualified Data.Aeson as AE

94+-import Data.Attoparsec.Number (Number(..))

95++-- import qualified Data.Aeson as AE

96++-- import Data.Attoparsec.Number (Number(..))

97+ import Data.Bits ((.&.))

98+ import Data.Char (chr, ord)

99+-import qualified Data.HashMap.Strict as H

100++-- import qualified Data.HashMap.Strict as H

101+ import Data.Int (Int8, Int16, Int32)

102+ import qualified Data.JSString as JSS

103+-import qualified Data.JSString.Text as JSS

104++-- import qualified Data.JSString.Text as JSS

105+ import Data.Maybe

106+-import Data.Scientific (Scientific, scientific, fromFloatDigits)

107+-import Data.Text (Text)

108++-- import Data.Scientific (Scientific, scientific, fromFloatDigits)

109++-- import Data.Text (Text)

110+ import qualified Data.Vector as V

111+ import Data.Word (Word8, Word16, Word32, Word)

112+ import Data.Primitive.ByteArray

113+@@ -85,11 +85,11 @@ instance FromJSVal JSString where

114+ {-# INLINE fromJSValUnchecked #-}

115+ fromJSVal = fromJSVal_pure

116+ {-# INLINE fromJSVal #-}

117+-instance FromJSVal Text where

118+- fromJSValUnchecked = fromJSValUnchecked_pure

119+- {-# INLINE fromJSValUnchecked #-}

120+- fromJSVal = fromJSVal_pure

121+- {-# INLINE fromJSVal #-}

122++-- instance FromJSVal Text where

123++-- fromJSValUnchecked = fromJSValUnchecked_pure

124++-- {-# INLINE fromJSValUnchecked #-}

125++-- fromJSVal = fromJSVal_pure

126++-- {-# INLINE fromJSVal #-}

127+ instance FromJSVal Char where

128+ fromJSValUnchecked = fromJSValUnchecked_pure

129+ {-# INLINE fromJSValUnchecked #-}

130+@@ -154,24 +154,24 @@ instance FromJSVal Double where

131+ {-# INLINE fromJSValUnchecked #-}

132+ fromJSVal = fromJSVal_pure

133+ {-# INLINE fromJSVal #-}

134+-instance FromJSVal AE.Value where

135+- fromJSVal r = case jsonTypeOf r of

136+- JSONNull -> return (Just AE.Null)

137+- JSONInteger -> liftM (AE.Number . flip scientific 0 . (toInteger :: Int -> Integer))

138+- <$> fromJSVal r

139+- JSONFloat -> liftM (AE.Number . (fromFloatDigits :: Double -> Scientific))

140+- <$> fromJSVal r

141+- JSONBool -> liftM AE.Bool <$> fromJSVal r

142+- JSONString -> liftM AE.String <$> fromJSVal r

143+- JSONArray -> liftM (AE.Array . V.fromList) <$> fromJSVal r

144+- JSONObject -> do

145+- props <- OI.listProps (OI.Object r)

146+- runMaybeT $ do

147+- propVals <- forM props $ \p -> do

148+- v <- MaybeT (fromJSVal =<< OI.getProp p (OI.Object r))

149+- return (JSS.textFromJSString p, v)

150+- return (AE.Object (H.fromList propVals))

151+- {-# INLINE fromJSVal #-}

152++-- instance FromJSVal AE.Value where

153++-- fromJSVal r = case jsonTypeOf r of

154++-- JSONNull -> return (Just AE.Null)

155++-- JSONInteger -> liftM (AE.Number . flip scientific 0 . (toInteger :: Int -> Integer))

156++-- <$> fromJSVal r

157++-- JSONFloat -> liftM (AE.Number . (fromFloatDigits :: Double -> Scientific))

158++-- <$> fromJSVal r

159++-- JSONBool -> liftM AE.Bool <$> fromJSVal r

160++-- JSONString -> liftM AE.String <$> fromJSVal r

161++-- JSONArray -> liftM (AE.Array . V.fromList) <$> fromJSVal r

162++-- JSONObject -> do

163++-- props <- OI.listProps (OI.Object r)

164++-- runMaybeT $ do

165++-- propVals <- forM props $ \p -> do

166++-- v <- MaybeT (fromJSVal =<< OI.getProp p (OI.Object r))

167++-- return (JSS.textFromJSString p, v)

168++-- return (AE.Object (H.fromList propVals))

169++-- {-# INLINE fromJSVal #-}

170+ instance (FromJSVal a, FromJSVal b) => FromJSVal (a,b) where

171+ fromJSVal r = runMaybeT $ (,) <$> jf r 0 <*> jf r 1

172+ {-# INLINE fromJSVal #-}

173+@@ -204,15 +204,15 @@ jf r n = MaybeT $ do

174+ instance ToJSVal JSVal where

175+ toJSVal = toJSVal_pure

176+ {-# INLINE toJSVal #-}

177+-instance ToJSVal AE.Value where

178+- toJSVal = toJSVal_aeson

179+- {-# INLINE toJSVal #-}

180++-- instance ToJSVal AE.Value where

181++-- toJSVal = toJSVal_aeson

182++-- {-# INLINE toJSVal #-}

183+ instance ToJSVal JSString where

184+ toJSVal = toJSVal_pure

185+ {-# INLINE toJSVal #-}

186+-instance ToJSVal Text where

187+- toJSVal = toJSVal_pure

188+- {-# INLINE toJSVal #-}

189++-- instance ToJSVal Text where

190++-- toJSVal = toJSVal_pure

191++-- {-# INLINE toJSVal #-}

192+ instance ToJSVal Char where

193+ toJSVal = return . pToJSVal

194+ {-# INLINE toJSVal #-}

195+@@ -285,21 +285,21 @@ foreign import javascript unsafe "[$1,$2,$3,$4,$5]" arr5 :: JSVal -> J

196+ foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6]" arr6 :: JSVal -> JSVal -> JSVal -> JSVal -> JSVal -> JSVal -> IO JSVal

197+ foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7]" arr7 :: JSVal -> JSVal -> JSVal -> JSVal -> JSVal -> JSVal -> JSVal -> IO JSVal

198+

199+-toJSVal_aeson :: AE.ToJSON a => a -> IO JSVal

200+-toJSVal_aeson x = cv (AE.toJSON x)

201+- where

202+- cv = convertValue

203++-- toJSVal_aeson :: AE.ToJSON a => a -> IO JSVal

204++-- toJSVal_aeson x = cv (AE.toJSON x)

205++-- where

206++-- cv = convertValue

207+

208+- convertValue :: AE.Value -> IO JSVal

209+- convertValue AE.Null = return jsNull

210+- convertValue (AE.String t) = return (pToJSVal t)

211+- convertValue (AE.Array a) = (\(AI.SomeJSArray x) -> x) <$>

212+- (AI.fromListIO =<< mapM convertValue (V.toList a))

213+- convertValue (AE.Number n) = toJSVal (realToFrac n :: Double)

214+- convertValue (AE.Bool b) = return (toJSBool b)

215+- convertValue (AE.Object o) = do

216+- obj@(OI.Object obj') <- OI.create

217+- mapM_ (\(k,v) -> convertValue v >>= \v' -> OI.setProp (JSS.textToJSString k) v' obj) (H.toList o)

218+- return obj'

219++-- convertValue :: AE.Value -> IO JSVal

220++-- convertValue AE.Null = return jsNull

221++-- convertValue (AE.String t) = return (pToJSVal t)

222++-- convertValue (AE.Array a) = (\(AI.SomeJSArray x) -> x) <$>

223++-- (AI.fromListIO =<< mapM convertValue (V.toList a))

224++-- convertValue (AE.Number n) = toJSVal (realToFrac n :: Double)

225++-- convertValue (AE.Bool b) = return (toJSBool b)

226++-- convertValue (AE.Object o) = do

227++-- obj@(OI.Object obj') <- OI.create

228++-- mapM_ (\(k,v) -> convertValue v >>= \v' -> OI.setProp (JSS.textToJSString k) v' obj) (H.toList o)

229++-- return obj'

230+

231+

232+diff --git a/GHCJS/Marshal/Pure.hs b/GHCJS/Marshal/Pure.hs

233+index 902fa20..268489d 100644

234+--- a/GHCJS/Marshal/Pure.hs

235++++ b/GHCJS/Marshal/Pure.hs

236+@@ -28,11 +28,11 @@ import Data.Data

237+ import Data.Int (Int8, Int16, Int32)

238+ import Data.JSString.Internal.Type

239+ import Data.Maybe

240+-import Data.Text (Text)

241++-- import Data.Text (Text)

242+ import Data.Typeable

243+ import Data.Word (Word8, Word16, Word32, Word)

244+ import Data.JSString

245+-import Data.JSString.Text

246++-- import Data.JSString.Text

247+ import Data.Bits ((.&.))

248+ import Unsafe.Coerce (unsafeCoerce)

249+ import GHC.Int

250+@@ -65,8 +65,8 @@ instance PFromJSVal JSString where pFromJSVal = JSString

251+ {-# INLINE pFromJSVal #-}

252+ instance PFromJSVal [Char] where pFromJSVal = Prim.fromJSString

253+ {-# INLINE pFromJSVal #-}

254+-instance PFromJSVal Text where pFromJSVal = textFromJSVal

255+- {-# INLINE pFromJSVal #-}

256++-- instance PFromJSVal Text where pFromJSVal = textFromJSVal

257++-- {-# INLINE pFromJSVal #-}

258+ instance PFromJSVal Char where pFromJSVal x = C# (jsvalToChar x)

259+ {-# INLINE pFromJSVal #-}

260+ instance PFromJSVal Bool where pFromJSVal = isTruthy

261+@@ -103,8 +103,8 @@ instance PToJSVal JSString where pToJSVal = jsval

262+ {-# INLINE pToJSVal #-}

263+ instance PToJSVal [Char] where pToJSVal = Prim.toJSString

264+ {-# INLINE pToJSVal #-}

265+-instance PToJSVal Text where pToJSVal = jsval . textToJSString

266+- {-# INLINE pToJSVal #-}

267++-- instance PToJSVal Text where pToJSVal = jsval . textToJSString

268++-- {-# INLINE pToJSVal #-}

269+ instance PToJSVal Char where pToJSVal (C# c) = charToJSVal c

270+ {-# INLINE pToJSVal #-}

271+ instance PToJSVal Bool where pToJSVal True = jsTrue

272+diff --git a/JavaScript/JSON/Types/Instances.hs b/JavaScript/JSON/Types/Instances.hs

273+index 2b288ec..6d7074c 100644

274+--- a/JavaScript/JSON/Types/Instances.hs

275++++ b/JavaScript/JSON/Types/Instances.hs

276+@@ -57,7 +57,7 @@ import Control.Applicative ((<$>), (<*>), (<|>), pure, empty)

277+

278+ import Data.JSString (JSString)

279+ import qualified Data.JSString as JSS

280+-import qualified Data.JSString.Text as JSS

281++-- import qualified Data.JSString.Text as JSS

282+

283+ import JavaScript.Array (JSArray)

284+ import qualified JavaScript.Array as JSA

285+@@ -335,21 +335,21 @@ instance FromJSON JSString where

286+ parseJSON = withJSString "JSString" pure

287+ {-# INLINE parseJSON #-}

288+

289+-instance ToJSON Text where

290+- toJSON = stringValue . JSS.textToJSString

291+- {-# INLINE toJSON #-}

292++-- instance ToJSON Text where

293++-- toJSON = stringValue . JSS.textToJSString

294++-- {-# INLINE toJSON #-}

295+

296+-instance FromJSON Text where

297+- parseJSON = withJSString "Text" ( pure . JSS.textFromJSString )

298+- {-# INLINE parseJSON #-}

299++-- instance FromJSON Text where

300++-- parseJSON = withJSString "Text" ( pure . JSS.textFromJSString )

301++-- {-# INLINE parseJSON #-}

302+

303+-instance ToJSON LT.Text where

304+- toJSON = stringValue . JSS.textToJSString . LT.toStrict

305+- {-# INLINE toJSON #-}

306++-- instance ToJSON LT.Text where

307++-- toJSON = stringValue . JSS.textToJSString . LT.toStrict

308++-- {-# INLINE toJSON #-}

309+

310+-instance FromJSON LT.Text where

311+- parseJSON = withJSString "Lazy Text" $ pure . LT.fromStrict . JSS.textFromJSString

312+- {-# INLINE parseJSON #-}

313++-- instance FromJSON LT.Text where

314++-- parseJSON = withJSString "Lazy Text" $ pure . LT.fromStrict . JSS.textFromJSString

315++-- {-# INLINE parseJSON #-}

316+

317+ instance (ToJSON a) => ToJSON [a] where

318+ toJSON = arrayValue . arrayValueList . map toJSON

319+diff --git a/JavaScript/Web/Canvas.hs b/JavaScript/Web/Canvas.hs

320+index 0a7684c..74490c2 100644

321+--- a/JavaScript/Web/Canvas.hs

322++++ b/JavaScript/Web/Canvas.hs

323+@@ -69,7 +69,7 @@ import Control.Monad

324+

325+ import Data.Data

326+ import Data.Maybe (fromJust)

327+-import Data.Text (Text)

328++-- import Data.Text (Text)

329+ import Data.Typeable

330+

331+ import GHCJS.Foreign

332+diff --git a/ghcjs-base.cabal b/ghcjs-base.cabal

333+index 4a64694..acf8806 100644

334+--- a/ghcjs-base.cabal

335++++ b/ghcjs-base.cabal

336+@@ -55,7 +55,7 @@ library

337+ Data.JSString.RealFloat

338+ Data.JSString.RegExp

339+ Data.JSString.Internal

340+- Data.JSString.Text

341++ -- Data.JSString.Text

342+ Data.JSString.Internal.Fusion

343+ Data.JSString.Internal.Fusion.Types

344+ Data.JSString.Internal.Fusion.Common

345+@@ -78,12 +78,12 @@ library

346+ JavaScript.Array.Internal

347+ JavaScript.Array.ST

348+ JavaScript.Cast

349+- JavaScript.JSON

350+- JavaScript.JSON.Types

351+- JavaScript.JSON.Types.Class

352+- JavaScript.JSON.Types.Generic

353+- JavaScript.JSON.Types.Instances

354+- JavaScript.JSON.Types.Internal

355++ -- JavaScript.JSON

356++ -- JavaScript.JSON.Types

357++ -- JavaScript.JSON.Types.Class

358++ -- JavaScript.JSON.Types.Generic

359++ -- JavaScript.JSON.Types.Instances

360++ -- JavaScript.JSON.Types.Internal

361+ JavaScript.Number

362+ JavaScript.Object

363+ JavaScript.Object.Internal

364+@@ -115,11 +115,11 @@ library

365+ JavaScript.Web.Storage

366+ JavaScript.Web.Storage.Internal

367+ JavaScript.Web.StorageEvent

368+- JavaScript.Web.XMLHttpRequest

369++ -- JavaScript.Web.XMLHttpRequest

370+ JavaScript.Web.WebSocket

371+ JavaScript.Web.Worker

372+- other-modules: GHCJS.Internal.Types

373+ Data.JSString.Internal.Type

374++ other-modules: GHCJS.Internal.Types

375+ JavaScript.TypedArray.Internal.Types

376+ JavaScript.TypedArray.ArrayBuffer.Internal

377+ JavaScript.TypedArray.DataView.Internal

378+@@ -144,15 +144,15 @@ library

379+ integer-gmp,

380+ binary >= 0.8 && < 0.11,

381+ bytestring >= 0.10 && < 0.11,

382+- text >= 1.1 && < 1.3,

383+- aeson >= 0.8 && < 1.6,

384+- scientific >= 0.3 && < 0.4,

385++ -- text >= 1.1 && < 1.3,

386++ -- aeson >= 0.8 && < 1.6,

387++ -- scientific >= 0.3 && < 0.4,

388+ vector >= 0.10 && < 0.13,

389+ containers >= 0.5 && < 0.7,

390+ time >= 1.5 && < 1.10,

391+- hashable >= 1.2 && < 1.4,

392+- unordered-containers >= 0.2 && < 0.3,

393+- attoparsec >= 0.11 && < 0.15,

394++ -- hashable >= 1.2 && < 1.4,

395++ -- unordered-containers >= 0.2 && < 0.3,

396++ -- attoparsec >= 0.11 && < 0.15,

397+ transformers >= 0.3 && < 0.6,

398+ primitive >= 0.5 && < 0.8,

399+ deepseq >= 1.3 && < 1.5,

400+@@ -161,37 +161,37 @@ library

401+ if !impl(ghcjs) && !os(ghcjs)

402+ buildable: False

403+

404+-test-suite tests

405+- type: exitcode-stdio-1.0

406+- hs-source-dirs: test

407+- main-is: Tests.hs

408+- other-modules: Tests.Marshal

409+- Tests.Properties

410+- Tests.Properties.Numeric

411+- Tests.SlowFunctions

412+- Tests.QuickCheckUtils

413+- Tests.Regressions

414+- Tests.Utils

415+- ghc-options:

416+- -Wall -rtsopts

417+- build-depends:

418+- HUnit >= 1.2,

419+- QuickCheck >= 2.7,

420+- array,

421+- text,

422+- base,

423+- bytestring,

424+- deepseq,

425+- directory,

426+- ghc-prim,

427+- ghcjs-prim,

428+- ghcjs-base,

429+- primitive,

430+- quickcheck-unicode,

431+- random,

432+- test-framework >= 0.4,

433+- test-framework-hunit >= 0.2,

434+- test-framework-quickcheck2 >= 0.2

435+- default-language: Haskell2010

436+- if !impl(ghcjs) && !os(ghcjs)

437+- buildable: False

438++-- test-suite tests

439++-- type: exitcode-stdio-1.0

440++-- hs-source-dirs: test

441++-- main-is: Tests.hs

442++-- other-modules: Tests.Marshal

443++-- Tests.Properties

444++-- Tests.Properties.Numeric

445++-- Tests.SlowFunctions

446++-- Tests.QuickCheckUtils

447++-- Tests.Regressions

448++-- Tests.Utils

449++-- ghc-options:

450++-- -Wall -rtsopts

451++-- build-depends:

452++-- HUnit >= 1.2,

453++-- QuickCheck >= 2.7,

454++-- array,

455++-- text,

456++-- base,

457++-- bytestring,

458++-- deepseq,

459++-- directory,

460++-- ghc-prim,

461++-- ghcjs-prim,

462++-- ghcjs-base,

463++-- primitive,

464++-- quickcheck-unicode,

465++-- random,

466++-- test-framework >= 0.4,

467++-- test-framework-hunit >= 0.2,

468++-- test-framework-quickcheck2 >= 0.2

469++-- default-language: Haskell2010

470++-- if !impl(ghcjs) && !os(ghcjs)

471++-- buildable: False

compiler/ghcjs/ghcjs810-patched-boot-packages/hashable.patchnew file+99

@@ -0,0 +1,99 @@

1+diff --git a/hashable.cabal b/hashable.cabal

2+index 4197060..8c339b1 100755

3+--- a/hashable.cabal

4++++ b/hashable.cabal

5+@@ -88,6 +88,8 @@ library

6+ build-depends: ghc-bignum ==1.0.* || ==1.2.*

7+

8+ else

9++ if impl(ghcjs)

10++ build-depends: ghcjs-base

11+ if flag(integer-gmp)

12+ build-depends: integer-gmp >=0.4 && <1.1

13+

14+diff --git a/src/Data/Hashable/Class.hs b/src/Data/Hashable/Class.hs

15+index c7dd8c5..0e3bbe7 100755

16+--- a/src/Data/Hashable/Class.hs

17++++ b/src/Data/Hashable/Class.hs

18+@@ -5,6 +5,10 @@

19+

20+ {-# LANGUAGE Trustworthy #-}

21+

22++#ifdef __GHCJS__

23++{-# LANGUAGE JavaScriptFFI, UnboxedTuples, GHCForeignImportPrim #-}

24++#endif

25++

26+ #if __GLASGOW_HASKELL__ >= 801

27+ {-# LANGUAGE PolyKinds #-} -- For TypeRep instances

28+ #endif

29+@@ -72,7 +76,9 @@ import Data.Int (Int8, Int16, Int32, Int64)

30+ import Data.List (foldl')

31+ import Data.Ratio (Ratio, denominator, numerator)

32+ import qualified Data.Text as T

33++#ifndef __GHCJS__

34+ import qualified Data.Text.Array as TA

35++#endif

36+ import qualified Data.Text.Internal as T

37+ import qualified Data.Text.Lazy as TL

38+ import Data.Version (Version(..))

39+@@ -152,7 +158,11 @@ import GHC.Exts (Int (..), sizeofByteArray#)

40+ # define MIN_VERSION_integer_gmp_1_0_0

41+ # endif

42+

43++#ifndef __GHCJS__

44+ import GHC.Exts (Int(..))

45++#else

46++import GHC.Exts (Int(..), Int#)

47++#endif

48+ import GHC.Integer.GMP.Internals (Integer(..))

49+ # if defined(MIN_VERSION_integer_gmp_1_0_0)

50+ import GHC.Exts (sizeofByteArray#)

51+@@ -195,6 +205,10 @@ import Data.Kind (Type)

52+ import Data.Hashable.Imports

53+ import Data.Hashable.LowLevel

54+

55++#ifdef __GHCJS__

56++import Data.JSString (JSString)

57++#endif

58++

59+ #include "MachDeps.h"

60+

61+ infixl 0 `hashWithSalt`

62+@@ -676,17 +690,18 @@ instance Hashable BSI.ShortByteString where

63+ #endif

64+

65+ instance Hashable T.Text where

66++#ifndef __GHCJS__

67+ hashWithSalt salt (T.Text arr off len) =

68+ hashByteArrayWithSalt (TA.aBA arr) (off `shiftL` 1) (len `shiftL` 1)

69+ (hashWithSalt salt len)

70++#else

71++ hashWithSalt salt (T.Text txt) =

72++ let (# ba, len #) = js_textFromJSString txt

73++ in hashByteArrayWithSalt ba (0 `shiftL` 1) (I# len `shiftL` 1) salt

74++#endif

75+

76+ instance Hashable TL.Text where

77+- hashWithSalt salt = finalise . TL.foldlChunks step (SP salt 0)

78+- where

79+- finalise (SP s l) = hashWithSalt s l

80+- step (SP s l) (T.Text arr off len) = SP

81+- (hashByteArrayWithSalt (TA.aBA arr) (off `shiftL` 1) (len `shiftL` 1) s)

82+- (l + len)

83++ hashWithSalt = TL.foldlChunks hashWithSalt

84+

85+ -- | Compute the hash of a ThreadId.

86+ hashThreadId :: ThreadId -> Int

87+@@ -880,6 +895,12 @@ instance Hashable1 Option where liftHashWithSalt h salt (Option a) = liftHashWit

88+ #endif

89+ #endif

90+

91++#ifdef __GHCJS__

92++foreign import javascript unsafe

93++ "h$textFromString"

94++ js_textFromJSString :: JSString -> (# ByteArray#, Int# #)

95++#endif

96++

97+ -- instances for @Data.Functor.{Product,Sum,Compose}@, present

98+ -- in base-4.9 and onward.

99+ #if MIN_VERSION_base(4,9,0)

compiler/ghcjs/ghcjs810-src.jsonnew file+6

@@ -0,0 +1,6 @@

1+{

2+ "url": "https://github.com/ghcjs/ghcjs",

3+ "rev": "bb403ec3a1506831aae2d608b7b21c1937e4fb20",

4+ "sha256": "0bs3hijwn0p4wvphwg78mwbz8qyi10wqgfh8yfaszaj1766892ba",

5+ "fetchSubmodules": true

6+}

compiler/ghcjs/ghcjs88-src.jsonnew file+6

@@ -0,0 +1,6 @@

1+{

2+ "url": "https://github.com/ghcjs/ghcjs",

3+ "rev": "1af48a877fdf1f647a3b81e828a1e61adb0baceb",

4+ "sha256": "sha256-B4LFpd1nl96SO6/gsTjkizMGSglMkrujmwgXVjahC68=",

5+ "fetchSubmodules": true

6+}

compiler/ghcjs/patches/810/boot-optimization-flags.patchnew file+14

@@ -0,0 +1,14 @@

1+diff --git a/src-bin/Boot.hs b/src-bin/Boot.hs

2+index 2e35a26..5db2f9b 100755

3+--- a/src-bin/Boot.hs

4++++ b/src-bin/Boot.hs

5+@@ -721,6 +721,9 @@ cabalConfigureFlags = do

6+ , "--prefix", T.pack (locs ^. blGhcjsTopDir)

7+ , "--configure-option", "--host=js-unknown-ghcjs"

8+ , "--ghcjs-options=-fwrite-ide-info"

9++ , "--ghcjs-options=-O2"

10++ , "--ghcjs-options=-fexpose-all-unfoldings"

11++ , "--ghcjs-options=-fspecialise-aggressively"

12+ , "--enable-debug-info"

13+ , "--disable-library-stripping"

14+ , "--disable-executable-stripping"

compiler/ghcjs/patches/810/fast-weak.patchnew file+87

@@ -0,0 +1,87 @@

1+diff --git a/lib/boot/shims/src/gc.js.pp b/lib/boot/shims/src/gc.js.pp

2+index 76321b2..a2cf416 100644

3+--- a/lib/boot/shims/src/gc.js.pp

4++++ b/lib/boot/shims/src/gc.js.pp

5+@@ -444,6 +444,50 @@ function h$follow(obj, sp) {

6+ } else if(typeof c.len === 'number' && c.buf instanceof ArrayBuffer) {

7+ TRACE_GC("marking ByteArray");

8+ MARK_OBJ(c);

9++ } else if(c instanceof h$FastWeak) {

10++ MARK_OBJ(c);

11++ if(c.ticket !== null && !IS_MARKED(c.ticket)) {

12++ c.ticket = null; // If the ticket isn't reachable, this will let it get cleaned up by the JS gc; if it is reachable, it'll fill this back in

13++ }

14++ } else if(c instanceof h$FastWeakTicket) {

15++ MARK_OBJ(c);

16++ if(!IS_MARKED(c.val)) {

17++ ADDW(c.val);

18++ }

19++ if(IS_MARKED(c.weak)) {

20++ // In this case, the weak side has been marked first, which means it's been cleared; restore it

21++ c.weak.ticket = c;

22++ }

23++ } else if(c instanceof h$FastWeakBag) {

24++ MARK_OBJ(c);

25++ var j = 0; // j should always be equal to the number of not-yet-necessarily-dead tickets that have been traversed; this should always be less than or equal to i

26++ for(i = 0; i < c.tickets.length; i++) {

27++ // Any nulls left in the array prior to checking on the tickets must be tickets that died in the last GC, so we ignore them

28++ if(c.tickets[i] !== null) {

29++ if(j !== i) {

30++ c.tickets[i].pos = j;

31++ }

32++ if(!IS_MARKED(c.tickets[i])) {

33++ // If the ticket isn't reachable, this will let it get cleaned up by the JS gc; if it is reachable, it'll fill this back in

34++ c.tickets[j] = null;

35++ } else if(j !== i) {

36++ // We need to move the item

37++ c.tickets[j] = c.tickets[i];

38++ } // If it's marked and not moving, don't do anything

39++ j++;

40++ }

41++ }

42++ c.tickets.length = j; // Shrink the array if any nulls have been dropped

43++ } else if(c instanceof h$FastWeakBagTicket) {

44++ MARK_OBJ(c);

45++ if(!IS_MARKED(c.val)) {

46++ ADDW(c.val);

47++ }

48++ if(IS_MARKED(c.bag)) {

49++ // In this case, the weak side has been marked first, which means it's been cleared; restore it

50++ c.bag.tickets[c.pos] = c;

51++ }

52++

53+ } else if(c instanceof h$Weak) {

54+ MARK_OBJ(c);

55+ } else if(c instanceof h$MVar) {

56+diff --git a/lib/boot/shims/src/weak.js.pp b/lib/boot/shims/src/weak.js.pp

57+index 8df313b..d537027 100644

58+--- a/lib/boot/shims/src/weak.js.pp

59++++ b/lib/boot/shims/src/weak.js.pp

60+@@ -87,3 +87,27 @@ function h$finalizeWeak(w) {

61+ RETURN_UBX_TUP2(r, 1);

62+ }

63+ }

64++

65++function h$FastWeak(ticket) {

66++ this.ticket = ticket;

67++ this.m = 0;

68++}

69++

70++function h$FastWeakTicket(val) {

71++ this.val = val;

72++ this.weak = new h$FastWeak(this);

73++ this.m = 0;

74++}

75++

76++function h$FastWeakBag() {

77++ this.tickets = [];

78++ this.m = 0;

79++}

80++

81++function h$FastWeakBagTicket(bag, val) {

82++ this.val = val;

83++ this.bag = bag;

84++ this.pos = bag.tickets.length;

85++ bag.tickets.push(this);

86++ this.m = 0;

87++};

compiler/old-ghc-nix/default.nixdeleted−10

@@ -1,10 +0,0 @@

1−{ pkgs ? import <nixpkgs> {} }:

2−let

3− fetch = jsonFile:

4− with builtins;

5− let spec = fromJSON (readFile jsonFile);

6− in pkgs.fetchgit {

7− name = "old-ghc-nix";

8− inherit (spec) sha256 url rev;

9− };

10−in import (fetch ./old-ghc-nix.json) { inherit pkgs; }

compiler/old-ghc-nix/old-ghc-nix.jsondeleted−7

@@ -1,7 +0,0 @@

1−{

2− "url": "https://github.com/angerman/old-ghc-nix",

3− "rev": "2a41a09127f6dc7a6384823d1acd51ba257f95bd",

4− "date": "2020-06-03T12:50:09+08:00",

5− "sha256": "1cp6aksb6ldgjb5zyqikyjrjij79n9z7wd86migph0wp19vmszkf",

6− "fetchSubmodules": false

7−}

compiler/windows/include/synchapi.hnew file+1

@@ -0,0 +1 @@

1+#include <windows.h>

compiler/windows/include/windows.hnew file+18

@@ -0,0 +1,18 @@

1+// Just enoough windows.h stuff to make rts headers usable when building GHC cross compiler.

2+// See compiler/ghc/default.nix for where this is used.

3+#ifndef _WINDOWS_

4+#define _WINDOWS_

5+

6+#define __stdcall

7+

8+typedef unsigned long DWORD;

9+typedef void * PVOID;

10+

11+typedef struct _RTL_CONDITION_VARIABLE { PVOID Ptr; } RTL_CONDITION_VARIABLE;

12+typedef RTL_CONDITION_VARIABLE CONDITION_VARIABLE;

13+

14+typedef struct _RTL_SRWLOCK { PVOID Ptr; } RTL_SRWLOCK;

15+typedef RTL_SRWLOCK SRWLOCK;

16+

17+#endif

18+

config.nix−13

@@ -2,20 +2,7 @@

2 # allow building for windows

3 allowUnsupportedSystem = true;

4 # we want the 64bit wine version

5− # See overlays/wine.nix as well!

6 wine.build = "wine64";

5 wine.build = "wine64";

7 wine.release = "stable";

6 wine.release = "stable";

8−

9− # This is marked insecure on 20.03, but many packages still depend on it

10− permittedInsecurePackages = [ "openssl-1.0.2u" ];

11−

12− # sadly we need to patch GHC a bit.

13− packageOverrides = ps: with ps; let

14− in rec {

15− rocksdb = with ps.stdenv;

16− if hostPlatform.isWindows

17− then pkgs.callPackage ./pkgs/rocksdb-prebuilt.nix { inherit (buildPackages) fetchurl unzip; }

18− else ps.rocksdb;

19− };

20}

7}

21

8

default.nix+27−54

@@ -1,56 +1,29 @@

1−let haskellNix = {

2− checkMaterialization ? false, # Allows us to easily switch on materialization checking

3− defaultCompilerNixName ? null, # Quick way to override the default compiler e.g. "ghc883"

4− system ? builtins.currentSystem,

5− sourcesOverride ? {},

6− ... }@args: rec {

1+{...}@args:

7− sources = (import ./nix/sources.nix) // sourcesOverride;

8

2

9− config = import ./config.nix;

3+let

10− overlays = [ allOverlays.combined ] ++ (

4+ nixpkgsSrc =

11− if checkMaterialization == true

5+ builtins.fetchTarball {

12− then [(

6+ url = "https://github.com/NixOS/nixpkgs/archive/110a2c9ebbf5d4a94486854f18a37a938cfacbbb.tar.gz";

13− final: prev: {

7+ sha256 = "sha256-leWXLchbAbqOlLT6tju631G40SzQWPqaAXQG3zH1Imw=";

14− haskell-nix = prev.haskell-nix // {

15− checkMaterialization = true;

16− };

17− }

18− )]

19− else []

20− ) ++ (

21− if defaultCompilerNixName != null

22− then [(

23− final: prev: {

24− haskell-nix = prev.haskell-nix // {

25− inherit defaultCompilerNixName;

26− };

8+ };

27− }

9+ pkgs = args.pkgs or (import nixpkgsSrc {});

28− )]

10+ flake-compat =

29− else []

11+ pkgs.fetchzip {

30− );

12+ url = "https://github.com/edolstra/flake-compat/archive/5523c47f13259b981c49b26e28499724a5125fd8.tar.gz";

31− allOverlays = import ./overlays args;

13+ sha256 = "sha256-7IySNHriQjzOZ88DDk6VDPf1GoUaOrOeUdukY62o52o=";

32− nixpkgsArgs = { inherit config overlays system; };

14+ };

33− pkgs = import sources.nixpkgs-default nixpkgsArgs;

15+ self = import flake-compat {

16+ # We bypass flake-compat's rootSrc cleaning by evading its detection of this as a git

17+ # repo.

18+ # This is done for 3 reasons:

19+ # * To workaround https://github.com/edolstra/flake-compat/issues/25

20+ # * Make `updateMaterilized` scripts work (if filtering is done by `flake-compat`

21+ # the `updateMaterilized` scripts will try to update the copy in the store).

22+ # * Allow more granular filtering done by the tests (the use of `cleanGit` and `cleanSourceWith`

23+ # in `test/default.nix`). If `flake-compat` copies the whole git repo, any change to the

24+ # repo causes a change of input for all tests.

25+ src = { outPath = ./.; };

26+ inherit pkgs;

34 };

27 };

35−

28+in self.defaultNix // (self.defaultNix.internal.compat

36− v1DeprecationMessage = "Version 1 is deprecated: use version 2 (nixpkgs arguments are available as the `nixpkgsArgs` attribute of version 2)";

37− haskellNixV1 = (haskellNix {}).nixpkgsArgs // {

38− overlays = builtins.trace v1DeprecationMessage (haskellNix {}).nixpkgsArgs.overlays;

39− };

40− haskellNixV2 = haskellNix;

41−

42−# If no arguments, then you get V1

43−in haskellNixV1 // {

44− __functor = _: {

45− version ? 2,

46− checkMaterialization ? false, # Allows us to easily switch on materialization checking

47− defaultCompilerNixName ? null, # Quick way to override the default compiler e.g. "ghc883"

48− system ? builtins.currentSystem,

29+({ system = args.pkgs.system or builtins.currentSystem; } // args))

49− sourcesOverride ? {},

50− ... }@args:

51− if version == 1

52− then haskellNixV1

53− else if version == 2

54− then haskellNixV2 args

55− else builtins.throw ("haskell.nix: unknown version: " + (builtins.toString version));

56−}

docs/architecture.md+1−1

@@ -61,7 +61,7 @@ of packages available on hackage.

61[stackage.nix][] is similar to hackage.nix but provides all stackage

62snapshots (lts, and nightly) as nix expressions. It naturally depends

63on hackage.nix to resolve package names, versions and revisions to the

64−repsective packages from hackage.nix.

64+respective packages from hackage.nix.

65

66[haskell.nix]: https://github.com/input-output-hk/haskell.nix

67[hackage.nix]: https://github.com/input-output-hk/hackage.nix

docs/dev/adding-new-ghc.mdnew file+34

@@ -0,0 +1,34 @@

1+# Adding a new GHC version to haskell.nix

2+

3+## Update `overlays/bootstrap.nix`

4+

5+Each ghc version is defined in this file. Duplicate one of the existing

6+ghc version definitions and replace the version numbers. Make sure

7+you update the `spec.sha256` or the other versions source will be used.

8+Check the LLVM version that should be used in the

9+[ghc wiki](https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/compiler/backends/llvm/installing).

10+

11+## Update the list of cached GHC versions in `ci.nix`

12+

13+## Update [supported ghc versions](../reference/supported-ghc-versions.md) document

14+

15+## Add the materialized files

16+

17+In the haskell.nix repo run:

18+

19+```

20+mkdir materialized/ghc884

21+nix-build scripts/check-compiler-materialization --argstr compiler-nix-name ghc884

22+```

23+

24+The `nix-build` command will fail with something like:

25+

26+```

27+Materialized nix used for dummy-data-x86_64-unknown-linux-musl-ghc-8.10.1 incorrect. To fix run: /nix/store/wnwpyrhv4nxgyljz3f20gdpspjxvm7h4-updateMaterialized

28+```

29+

30+Run the `updateMaterialized` script and repeat the `nix-build` until it no longer fails.

31+If the failure is not a problem with materialization and no `updateMaterialized` script

32+is provided then you may need to fix the failure another way or (if it only relates to

33+one of the cross compilers) modify `scripts/check-compiler-materialization/default.nix`

34+so that it skips that compiler.

docs/dev/coverage.mdnew file+180

@@ -0,0 +1,180 @@

1+# Developer Coverage Overview

2+

3+## Building

4+

5+The implementation of coverage starts with the "doCoverage" flag on

6+the builder in `comp-builder.nix`. The doCoverage flag enables and

7+disables the Cabal coverage flag and copies any generated coverage

8+data to "$out/share/hpc".

9+

10+### Mix and tix files

11+

12+The coverage information for any derivation consists of "mix" and

13+"tix" files.

14+

15+Mix files record static information about a source file and are

16+generated at build time. They primarily contain a path to the source

17+file and information about expressions and regions of the source file,

18+which are later referenced by tix files.

19+

20+Tix files contain dynamic information about a test run, recording when

21+a portion of a source file is touched by a test. These are generated

22+when the test is run.

23+

24+### Multiple local packages

25+

26+In the context of multiple local packages, there are a few types of

27+coverage we might be interested in:

28+ - How well does the tests for this package cover the package library?

29+ - How well does the tests for this package cover the libraries of

30+ other packages in this project?

31+ - Both of the above.

32+

33+To facilitate expressing any of these classifications of coverage, the

34+`lib/cover.nix` function provides the `mixLibraries` argument. If

35+you're just interested in how the tests cover the package library, you

36+provide that library as an argument to `mixLibraries`. If you're

37+interested in how the tests also cover other local packages in the

38+project, you can also provide those libraries as arguments to

39+mixLibraries.

40+

41+The `projectCoverageReport` and `coverageReport` attributes that are

42+provided by default on projects and packages respectively provide

43+coverage information for *all* local packages in the project. This is

44+to mimic the behaviour of Stack, which seems to be the expectation of

45+most people. Of course, you can use the `projectCoverageReport` and

46+`coverageReport` functions to construct your own custom coverage

47+reports (as detailed in the [coverage tutorial](../tutorials/coverage.md#custom)).

48+

49+## Coverage reports

50+

51+### Package reports

52+

53+The coverage information generated will look something like this:

54+

55+```bash

56+/nix/store/...-my-project-0.1.0.0-coverage-report/

57+└── share

58+ └── hpc

59+ └── vanilla

60+ ├── html

61+ │ └── my-library-0.1.0.0

62+ │ ├── my-library-0.1.0.0-48EVZBwW9Kj29VTaRMhBDf

63+ │ │ ├── My.Lib.Config.hs.html

64+ │ │ ├── My.Lib.Types.hs.html

65+ │ │ └── My.Lib.Util.hs.html

66+ │ ├── hpc_index_alt.html

67+ │ ├── hpc_index_exp.html

68+ │ ├── hpc_index_fun.html

69+ │ └── hpc_index.html

70+ ├── mix

71+ │ └── my-library-0.1.0.0

72+ │ └── my-library-0.1.0.0-48EVZBwW9Kj29VTaRMhBDf

73+ │ ├── My.Lib.Config.mix

74+ │ ├── My.Lib.Types.mix

75+ │ └── My.Lib.Util.mix

76+ └── tix

77+ └── my-library-0.1.0.0

78+ ├── my-library-0.1.0.0.tix

79+ ├── my-test-1

80+ │ └── my-test-1.tix

81+ └── unit-test

82+ └── unit-test.tix

83+```

84+

85+- The mix files are copied verbatim from the library built with

86+ coverage.

87+- The tix files for each test are copied from the check run verbatim

88+ and are output to ".../tix/<libraryname>/<testname>/<testname>.tix".

89+- The tix files for each library are generated by summing the tix

90+ files for each test, but excluding any test modules. This tix file

91+ is output to ".../tix/<libraryname>/<libraryname>.tix".

92+ - Test modules are determined by inspecting the plan for the project

93+ (i.e. for the project "my-project" and test-suite "my-test-1", the

94+ test modules are read from:

95+ `my-project.checks.my-test-1.config.modules`)

96+- The hpc HTML reports for each library are generated from their

97+ respective tix files (i.e. the

98+ `share/hpc/vanilla/html/my-library-0.1.0.0` report is generated from

99+ the

100+ `share/hpc/vanilla/tix/my-library-0.1.0.0/my-library-0.1.0.0.tix`

101+ file)

102+

103+### Project-wide reports

104+

105+The coverage information for an entire project will look something

106+like this:

107+

108+```bash

109+/nix/store/...-coverage-report

110+└── share

111+ └── hpc

112+ └── vanilla

113+ ├── html

114+ │ ├── index.html

115+ │ ├── all

116+ │ │ ├── my-library-0.1.0.0-ERSaOroBZhe9awsoBkhmcV

117+ │ │ │ ├── My.Lib.Config.hs.html

118+ │ │ │ ├── My.Lib.Types.hs.html

119+ │ │ │ └── My.Lib.Util.hs.html

120+ │ │ ├── other-library-0.1.0.0-48EVZBwW9Kj29VTaRMhBDf

121+ │ │ │ ├── Other.Lib.A.hs.html

122+ │ │ │ └── Other.Lib.B.hs.html

123+ │ │ ├── hpc_index_alt.html

124+ │ │ ├── hpc_index_exp.html

125+ │ │ ├── hpc_index_fun.html

126+ │ │ └── hpc_index.html

127+ │ ├── my-library-0.1.0.0

128+ │ │ ├── my-library-0.1.0.0-ERSaOroBZhe9awsoBkhmcV

129+ │ │ │ ├── My.Lib.Config.hs.html

130+ │ │ │ ├── My.Lib.Types.hs.html

131+ │ │ │ └── My.Lib.Util.hs.html

132+ │ │ ├── hpc_index_alt.html

133+ │ │ ├── hpc_index_exp.html

134+ │ │ ├── hpc_index_fun.html

135+ │ │ └── hpc_index.html

136+ │ └── other-libray-0.1.0.0

137+ │ ├── other-library-0.1.0.0-48EVZBwW9Kj29VTaRMhBDf

138+ │ │ ├── Other.Lib.A.hs.html

139+ │ │ └── Other.Lib.B.hs.html

140+ │ ├── hpc_index_alt.html

141+ │ ├── hpc_index_exp.html

142+ │ ├── hpc_index_fun.html

143+ │ └── hpc_index.html

144+ ├── mix

145+ │ ├── my-library-0.1.0.0-ERSaOroBZhe9awsoBkhmcV

146+ │ │ ├── My.Lib.Config.mix

147+ │ │ ├── My.Lib.Types.mix

148+ │ │ └── My.Lib.Util.mix

149+ │ └── other-library-0.1.0.0-48EVZBwW9Kj29VTaRMhBDf

150+ │ ├── Other.Lib.A.mix

151+ │ └── Other.Lib.B.mix

152+ └── tix

153+ ├── all

154+ │ └── all.tix

155+ ├── my-library-0.1.0.0

156+ │ ├── my-library-0.1.0.0.tix

157+ │ ├── my-test-1

158+ │ │ └── my-test-1.tix

159+ │ └── unit-test

160+ │ └── unit-test.tix

161+ └── another-library-0.1.0.0

162+ ├── another-library-0.1.0.0.tix

163+ ├── my-test-2

164+ │ └── my-test-2.tix

165+ └── unit-test

166+ └── unit-test.tix

167+```

168+

169+All of the coverage information is copied verbatim from the coverage

170+reports for each of the constituent packages. A few additions are

171+made:

172+ - `tix/all/all.tix` is generated from the union of all the library

173+ tix files.

174+ - We use this file when generating coverage reports for

175+ "coveralls.io".

176+ - An index page (`html/index.html`) is generated which links to the

177+ HTML coverage reports of the constituent packages.

178+ - A synthetic HTML report is generated from the `tix/all/all.tix`

179+ file. This shows the union of all the coverage information

180+ generated by each constituent coverage report.

docs/dev/dev-architecture.md+1−1

@@ -77,7 +77,7 @@ nixpkgs (*This has undergone substantially less testing*).

77

78### Component builder

79

80−To prevent depending on mutliple instances of the same libraries, the

80+To prevent depending on multiple instances of the same libraries, the

81component builder will try to build every package from scratch and

82rely as little as possible on packages that are shipped with the GHC

83distribution. The exceptions are packages that are known to not be

docs/dev/hix.mdnew file+27

@@ -0,0 +1,27 @@

1+# Making changes to Hix

2+

3+When making changes to the way Hix works it is often useful to be able to

4+test the changes locally before uploading them to github.

5+

6+## Hix Command Wrappers

7+

8+Install the hix command wrappers after making changes to a local clone of haskell.nix:

9+

10+```

11+nix-env -iA hix -f /path/to/local/haskell.nix

12+hix-shell

13+```

14+

15+Or override the version of haskell.nix used by the commands with the `HIX_ROOT` environment variable:

16+

17+```

18+HIX_ROOT=/path/to/local/haskell.nix hix-shell

19+```

20+

21+## Flakes

22+

23+For flakes use `--override-input` to point to the modified haskell.nix:

24+

25+```

26+nix develop --override-input haskellNix /path/to/local/haskell.nix

27+```

docs/dev/installing-nix-tools.md+4−2

@@ -3,7 +3,7 @@

3To build the latest `nix-tools` and store the result at `./nt`, run:

4

5```bash

6−nix build -f https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz pkgs.haskell-nix.nix-tools --out-link nt

6+nix build -f https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz pkgs.haskell-nix.nix-tools.ghc884 --out-link nt

7```

8

9If you would like to then install `nix-tools` into your profile, run:

@@ -22,5 +22,7 @@ understand something that the documentation doesn't cover.

22git clone https://github.com/input-output-hk/nix-tools

23git clone https://github.com/input-output-hk/haskell.nix

24cd haskell.nix

25−nix build -f . pkgs.haskell-nix.nix-tools --arg sourcesOverride '{ nix-tools = ../nix-tools; }' --out-link nt

25+nix build -f . pkgs.haskell-nix.nix-tools.ghc884 --arg sourcesOverride '{ nix-tools = ../nix-tools; }' --out-link nt

26```

27+

28+[haskell.nix]: https://github.com/input-output-hk/haskell.nix

docs/dev/manually-generating-nix-expressions.md+1−1

@@ -1,7 +1,7 @@

1# Manually generating Nix expressions

2

3We believe that imports from derivations (IFDs) provide tremendous

4−value in nix and the aversion towards them stems mostly from

4+value in nix and the aversion towards them stems mostly from

5poor tooling and ci support for them. We do not believe

6that poor tooling or ci support should cripple nix capability

7of abstraction. Hence haskell.nix makes excessive use of

docs/dev/nix-tools-pin.mdnew file+16

@@ -0,0 +1,16 @@

1+## How to update [`nix-tools`](https://github.com/input-output-hk/nix-tools)

2+

3+1. Use niv to update the sources.json:

4+

5+ ```

6+ niv update nix-tools

7+ ```

8+

9+

10+2. If `nix-tools.cabal` or `plan-to-nix` have changed, check the

11+ materialized files for each of the compiler nix name in

12+ `ls -d materialized/ghc*/nix-tools` with:

13+

14+ ```

15+ nix-build scripts/check-compiler-materialization --argstr compiler-nix-name ghc884

16+ ```

docs/dev/nixpkgs-pin.md+7−15

@@ -1,25 +1,17 @@

1# Haskell.nix Nixpkgs Pin

2

3−Haskell.nix contains a Nixpkgs pin in

3+Haskell.nix contains several Nixpkgs pins imanaged by `niv` in

4−[`nixpkgs/github.json`](https://github.com/input-output-hk/haskell.nix/blob/master/nixpkgs/github.json).

4+`nix/sources.json`.

5−This is the version of Nixpkgs used for builds of `nix-tools` and

5+

6−running the tests.

6+These are used in testing various versions of nixpkgs.

7

8To use haskell.nix the `config` and `overlays` need to be applied to

9Nixpkgs. Users should probably pin a suitable version of nixpkgs, although things might not work for them if their Nixpkgs version is

10too different.

11

12We aim to keep this pin somewhere on a channel of the **Nixpkgs latest

13−stable release**. That is currently 19.09.

13+stable release**. That is currently 20.09.

14

15We also execute tests on MacOS (darwin). The darwin channel is usually

16−behind the NixOS channel. So we choose the `nixpkgs-19.09-darwin`

16+behind the NixOS channel. So we follow the `nixpkgs-20.09-darwin`

17−channel:

17+channel.

18−

19−```

20−nix-prefetch-git https://github.com/NixOS/nixpkgs-channels refs/heads/nixpkgs-19.09-darwin

21−```

22−

23−Keep the URL in `github.json` pointing at

24−<https://github.com/NixOS/nixpkgs>. Case matters because the Hydra

25−trusted URL whitelist is case-sensitive.

docs/index.md+1−1

@@ -10,6 +10,6 @@

10- Overridable configuration

11- Cross compile Haskell packages

12

13−[^1]: See [Nixpkgs current Users' Guide to Haskell Infrastructure](https://nixos.org/nixpkgs/manual/#users-guide-to-the-haskell-infrastructure) for comparison.

13+[^1]: See [Nixpkgs current Users' Guide to Haskell Infrastructure](https://haskell4nix.readthedocs.io/) for comparison.

14

15

docs/motivation.md+2−2

@@ -1,9 +1,9 @@

1# Motivation

2

3−Why do we need another Haskell infrastructure for Nix?

3+Why do we need another Haskell infrastructure for Nix?

4

5Doesn't nixpkgs

6−provide a sufficiently good Haskell infrastructure already?

6+provide a sufficiently good Haskell infrastructure already?

7

8Problems with

9the nixpkgs haskell infrastructure are covered in the following sections:

docs/reference/commands.md+7−3

@@ -1,4 +1,8 @@

1+# Command line tools

2+

3+To install the command line tools refer to the [Installing nix-tools](https://input-output-hk.github.io/haskell.nix/dev/manually-generating-nix-expressions/) section.

4+

1−# stack-to-nix

5+## stack-to-nix

2

6

3```

7```

4stack-to-nix - a stack to nix converter

8stack-to-nix - a stack to nix converter

@@ -28,7 +32,7 @@ output directory, it will create a basic one with a

28

32

29[cache-issue]: https://github.com/input-output-hk/haskell.nix/issues/57

33[cache-issue]: https://github.com/input-output-hk/haskell.nix/issues/57

30

34

31−# plan-to-nix

35+## plan-to-nix

32

36

33```

37```

34plan-to-nix - a stack to nix converter

38plan-to-nix - a stack to nix converter

@@ -65,7 +69,7 @@ these files.

65 generated, remove `.nix-tools.cache`

69 generated, remove `.nix-tools.cache`

66 (The open issue is [#57][cache-issue]).

70 (The open issue is [#57][cache-issue]).

67

71

68−# cabal-to-nix

72+## cabal-to-nix

69

73

70```

74```

71Usage: cabal-to-nix FILE.cabal

75Usage: cabal-to-nix FILE.cabal

docs/reference/library.md+90−22

@@ -4,11 +4,11 @@ what you get when importing [Haskell.nix][]. It might be helpful to

4load the library in the [Nix REPL](../tutorials/development.md#using-nix-repl) to

5test things.

6

7− * [Types](#types) — the kinds of data that you will encounter working with [Haskell.nix][].

7+ * [Data structures](#data-structures) — the kinds of data that you will encounter working with [Haskell.nix][].

8 * [Top-level attributes](#top-level-attributes) — Functions and derivations defined in the Haskell.nix attrset.

9 * [Package-set functions](#package-set-functions) — Helper functions defined on the `hsPkgs` package set.

10

11−# Types

11+# Data structures

12

13## Package Set

14

@@ -70,7 +70,6 @@ components = {

70 exes = { NAME = COMPONENT; };

71 tests = { NAME = COMPONENT; };

72 benchmarks = { NAME = COMPONENT; };

73− all = COMPONENT;

74}

73}

75```

74```

76

75

@@ -80,9 +79,6 @@ In [Haskell.nix][], a _component_ is a derivation corresponding to a

80[Cabal component](https://www.haskell.org/cabal/users-guide/developing-packages.html)

79[Cabal component](https://www.haskell.org/cabal/users-guide/developing-packages.html)

81of a package.

80of a package.

82

81

83−[Haskell.nix][] also defines a special `all` component, which is the

84−union of all components in the package.

85−

86## Identifier

82## Identifier

87

83

88A package identifier is an attrset pair of `name` and `version`.

84A package identifier is an attrset pair of `name` and `version`.

@@ -116,6 +112,70 @@ will be passed to it:

116

112

117# Top-level attributes

113# Top-level attributes

118

114

115+## project'

116+

117+Function that accepts attribute set with a `src` attribute and looks for `stack.yaml` file relative to it.

118+

119+If file exists, it calls [stackProject](#stackproject') function. Otherwise it will call [cabalProject](#cabalproject') function.

120+

121+**Example**:

122+

123+```nix

124+pkgs.haskell-nix.project' {

125+ # 'cleanGit' cleans a source directory based on the files known by git

126+ src = pkgs.haskell-nix.haskellLib.cleanGit {

127+ name = "haskell-nix-project";

128+ src = ./.;

129+ };

130+}

131+```

132+

133+## stackProject'

134+

135+A function calling [callStackToNix](#callstacktonix) with all arguments.

136+

137+Then feeding its result into [mkStackPkgSet](#mkstackpkgset) passing also

138+`pkg-def-extras` and `modules` arguments.

139+

140+**Return value**:

141+

142+| Attribute | Type | Description |

143+|-------------------|--------------------------------------------------|----------------------------------------------------------------------------|

144+| `hsPkgs` | Attrset of [Haskell Packages](#haskell-package) | Buildable packages, created from `packages` |

145+| `stack-nix` | | `projectNix` attribute of [`callStackToNix`](#callstacktonix) return value |

146+| `shellFor` | Function | [`shellFor`](#shellfor) |

147+| `ghcWithHoogle` | Function | [`ghcWithHoogle`](#ghcwithhoogle) |

148+| `ghcWithPackages` | Function | [`ghcWithPackages`](#ghcwithpackages) |

149+

150+

151+## cabalProject'

152+

153+A function calling [callCabalProjectToNix](#callcabalprojecttonix) with all arguments.

154+

155+Then feeding its result into [mkCabalProjectPkgSet](#mkcabalprojectpkgset) passing also

156+`pkg-def-extras`, `extra-hackages` and `modules` arguments.

157+

158+**Return value**:

159+

160+| Attribute | Type | Description |

161+|-------------------|--------------------------------------------------|-----------------------------------------------------------------------------|

162+| `hsPkgs` | Attrset of [Haskell Packages](#haskell-package) | Buildable packages, created from `packages` |

163+| `plan-nix` | | `projectNix` attribute of [`callCabalProjectToNix`](#callcabalprojecttonix) return value |

164+| `index-state` | | `index-state` attribute of [`callCabalProjectToNix`](#callcabalprojecttonix) return value |

165+| `shellFor` | Function | [`shellFor`](#shellfor) |

166+| `ghcWithHoogle` | Function | [`ghcWithHoogle`](#ghcwithhoogle) |

167+| `ghcWithPackages` | Function | [`ghcWithPackages`](#ghcwithpackages) |

168+| `projectCross` | Attrset | Like `pkgs.pkgsCross.<system>` from nixpkgs `p.projectCross.<system>` returns the project results for cross compilation (where system is a member of nixpkgs lib.systems.examples). So `p.projectCross.ghcjs.hsPkgs` is the same as `hsPkgs` but compiled with ghcjs |

169+| `appendModule` | Function | Re-eval the project with an extra module (or module list). |

170+| `extend` and `appendOverlays` | Function | Modify a project, or add attributes, through overlays: `p.extend(final: prev: { })`. The overlays are carried-over `projectCross` and `appendModule` invocations. |

171+

172+## project, cabalProject and stackProject

173+

174+These versions of the function are the same as project', cabalProject'

175+and stackProject', but `hsPkgs` attributes are also included in the

176+return value directly. That way a package can be referenced as

177+`(project {...}).foo` instead of `(project' {...}).hsPkgs.foo`.

178+

119## mkStackPkgSet

179## mkStackPkgSet

120

180

121Creates a [package set](#package-set) based on the `pkgs.nix` output

181Creates a [package set](#package-set) based on the `pkgs.nix` output

@@ -208,19 +268,22 @@ needed for `importAndFilterProject`.

208 })).pkgs;

268 })).pkgs;

209```

269```

210

270

211−| Argument | Type | Description |

271+| Argument | Type | Description |

212−|------------------|------|---------------------|

272+|----------------------|------|---------------------|

213−| `name` | String | Optional name for better error messages. |

273+| `name` | String | Optional name for better error messages. |

214−| `src` | Path | Location of the cabal project files. |

274+| `src` | Path | Location of the cabal project files. |

275+| `compiler-nix-name` | String | The name of the ghc compiler to use eg. "ghc884" |

215−| `index-state` | Timestamp | Optional hackage index-state, eg. "2019-10-10T00:00:00Z". |

276+| `index-state` | Timestamp | Optional hackage index-state, eg. "2019-10-10T00:00:00Z". |

216−| `index-sha256` | Sha256 | Optional hash of the truncated hackage index-state. |

277+| `index-sha256` | Sha256 | Optional hash of the truncated hackage index-state. |

217−| `plan-sha256` | Sha256 | Optional hash of the plan-to-nix output (makes the plan-to-nix step a fixed output derivation). |

278+| `plan-sha256` | Sha256 | Optional hash of the plan-to-nix output (makes the plan-to-nix step a fixed output derivation). |

279+| `cabalProject` | String | Optional cabal project file contents (defaults to readFile "${src}/cabal.project"). |

280+| `cabalProjectLocal` | String | Optional cabal project file contents (defaults to readFile "${src}/cabal.project.local"). |

218−| `cabalProject` | Path | Optional cabal project file (defaults to "${src}/cabal.project"). |

281+| `cabalProjectFreeze` | String | Optional cabal project file contents (defaults to readFile "${src}/cabal.project.freeze"). |

219−| `ghc` | | Optional ghc to use |

282+| `ghc` | | Deprecated. Use `compiler-nix-name` instead. Optional ghc to use |

220−| `nix-tools` | | Optional nix-tools to use |

283+| `nix-tools` | | Optional nix-tools to use |

221−| `hpack` | | Optional hpack to use |

284+| `hpack` | | Optional hpack to use |

222−| `cabal-install` | | Optional cabal-install to use |

285+| `cabal-install` | | Optional cabal-install to use |

223−| `configureArgs` | String | Optional extra arguments to pass to `cabal new-configure` (--enable-tests is included by default, include `--disable-tests` to override that). |

286+| `configureArgs` | String | Optional extra arguments to pass to `cabal new-configure` (--enable-tests is included by default, include `--disable-tests` to override that). |

224

287

225## importAndFilterProject

288## importAndFilterProject

226

289

@@ -347,9 +410,11 @@ Sub-component types identify [components](#component) and are one of:

347 - `tests`

410 - `tests`

348 - `benchmarks`

411 - `benchmarks`

349

412

350−# Package-set functions

413+# Project functions

351

414

352−These functions exist within the `hsPkgs` package set.

415+These functions are included in the `project` return values.

416+In the past they also existed within `project.hsPkgs`,

417+but have now been removed from there.

353

418

354## shellFor

419## shellFor

355

420

@@ -366,10 +431,13 @@ shellFor =

366| Argument | Type | Description |

431| Argument | Type | Description |

367|----------------|------|---------------------|

432|----------------|------|---------------------|

368| `packages` | Function | Package selection function. It takes a list of [Haskell packages](#haskell-package) and returns a subset of these packages. |

433| `packages` | Function | Package selection function. It takes a list of [Haskell packages](#haskell-package) and returns a subset of these packages. |

434+| `components` | Function | Similar to `packages`, by default all the components of the selected packages are selected. |

369| `additional` | Function | Similar to `packages`, but the selected packages are built and included in `ghc-pkg list` (not just their dependencies). |

435| `additional` | Function | Similar to `packages`, but the selected packages are built and included in `ghc-pkg list` (not just their dependencies). |

370| `withHoogle` | Boolean | Whether to build a Hoogle documentation index and provide the `hoogle` command. |

436| `withHoogle` | Boolean | Whether to build a Hoogle documentation index and provide the `hoogle` command. |

371| `exactDeps` | Boolean | Prevents the Cabal solver from choosing any package dependency other than what are in the package set. |

437| `exactDeps` | Boolean | Prevents the Cabal solver from choosing any package dependency other than what are in the package set. |

372−| `tools` | Function | AttrSet of tools to make available e.g. `{ cabal = "3.2.0.0"; }` or `{ cabal = { version = "3.2.0.0"; }; }` |

438+| `tools` | Function | AttrSet of tools to make available e.g. `{ cabal = "3.2.0.0"; }` or `{ cabal = { version = "3.2.0.0"; }; }`. If an AttrSet is provided for a tool, the additional arguments will be passed to the function creating the derivation for that tool. So you can provide an `index-state` or a `materialized` argument like that `{ cabal = { version = "3.2.0.0"; index-state = "2020-10-30T00:00:00Z"; materialized = ./cabal.materialized; }; }` for example. You can specify and materialize the version of hoogle used to construct the hoogle index by including something like `{ hoogle = { version = "5.0.17.15"; index-state = "2020-05-31T00:00:00Z"; materialized = ./hoogle.materialized; }`. Uses a default version of hoogle if omitted. |

439+| `inputsFrom` | List | List of other shells to include in this one. The `buildInputs` and `nativeBuildInputs` of each will be included using [mkShell](https://nixos.org/manual/nixpkgs/stable/#sec-pkgs-mkShell).

440+| `crossPlatforms` | Function | Platform selection function for cross compilation targets to support eg. `ps: with ps; [ghcjs mingwW64]` (see nixpkgs lib.systems.examples for list of platform names). |

373| `{ ... }` | Attrset | All the other arguments are passed to [`mkDerivation`](https://nixos.org/nixpkgs/manual/#sec-using-stdenv). |

441| `{ ... }` | Attrset | All the other arguments are passed to [`mkDerivation`](https://nixos.org/nixpkgs/manual/#sec-using-stdenv). |

374

442

375**Return value**: a derivation

443**Return value**: a derivation

docs/reference/supported-ghc-versions.mdnew file+49

@@ -0,0 +1,49 @@

1+# Supported GHC Versions

2+

3+The following GHC versions are defined in `haskell.nix` (there is a derivation

4+for each, though not all are cached or tested by CI):

5+- 8.4.4

6+- 8.6.{1,2,3,4,5}

7+- 8.8.{1,2,3,4}

8+- 8.10.{1,2,3,4,5}

9+- 9.0.1

10+- 9.2.1

11+- 9.2.2

12+

13+The following table shows the Nixpkgs/GHC versions which are built/cached, and

14+which of those are further tested. If you use a combination of Nixpkgs version

15+and GHC version which is in this table, you should hit our cache, saving

16+considering time by not building GHC and a few additional tools.

17+

18+Note that if you try to use `haskell.nix` as an overlay over Nixpkgs from a

19+standard Nixpkgs channel you will likely get a cache miss. To hit our cache you

20+really should use an instance of Nixpkgs provided by `haskell.nix` itself.

21+

23+|------------------|--------------------|-------------|-----------------------|---------------|

24+| 21.11 | `nixpkgs-2111` | 8.6.5 | `ghc865` | No |

25+| 21.11 | `nixpkgs-2111` | 8.10.7 | `ghc8107` | Yes |

26+| unstable | `nixpkgs-unstable` | 8.6.5 | `ghc865` | No |

27+| unstable | `nixpkgs-unstable` | 8.8.4 | `ghc884` | No |

28+| unstable | `nixpkgs-unstable` | 8.10.7 | `ghc8107` | Yes |

29+| unstable | `nixpkgs-unstable` | 9.0.2 | `ghc902` | Yes |

30+| unstable | `nixpkgs-unstable` | 9.2.4 | `ghc924` | Yes |

31+

32+See [ci.nix](https://github.com/input-output-hk/haskell.nix/blob/master/ci.nix)

33+for the source of truth about what is built and tested (in the off chance this

34+document is out-of-sync with your checkout).

35+

36+See the [getting started guide](../tutorials/getting-started.md) for

37+instructions on how to set up Nix to take advantage of our cache when building.

38+This guide also covers where to use the Nixpkgs pinning and `compiler-nix-name`

39+settings from the table above. For further information, see the [instructions

40+for how to pin Nixpkgs](../dev/nixpkgs-pin.md).

41+

42+See

43+[overlays/bootstrap.nix](https://github.com/input-output-hk/haskell.nix/blob/master/overlays/bootstrap.nix)

44+for a full list of all the valid `compiler-nix-name`s beyond what's

45+cached/tested in CI. You're free to use these, but be ready for longer build

46+times.

47+

48+Lastly, see [instructions on adding new GHC versions](../dev/adding-new-ghc.md)

49+in the event that what's in `haskell.nix` doesn't suit your needs.

docs/troubleshooting.mdnew file+90

@@ -0,0 +1,90 @@

1+# Troubleshooting

2+

3+## Issues with building and garbage-collection

4+

5+### Why am I building GHC?

6+

7+It's easier to list the reverse: when will you *not* build GHC?

8+

9+- You have configured the [binary cache](tutorials/getting-started.md) correctly.

10+- You are using one of the GHC versions which [we support](reference/supported-ghc-versions.md).

11+- You are using one of the nixpkgs versions used by our CI (you can access the sources for these [through haskell.nix](tutorials/getting-started.md).

12+

13+If you think you are doing all of these and you still find you're building GHC, drop us a line.

14+

15+### Why am I building lots of Haskell packages?

16+

17+We don't generally cache much of Hackage (there's a lot of it!), except for the parts which are used by our tests.

18+So this is expected, unfortunately.

19+

20+### How do I prevent the evaluation-time dependencies of my project from being garbage-collected?

21+

22+The `haskell-nix.roots "ghc884"` should include all the evaluation-time dependencies

23+and the main build time dependencies of a project using ghc 8.8.4.

24+So you can add that to the relevant GC root.

25+In practice, if you're using a CI system like Hydra/Hercules, this means adding it to a job in `release.nix`/`ci.nix`.

26+

27+## General troubleshooting when using `cabalProject`/`stackProject`/`project`

28+

29+### Does the cabal/stack build work?

30+

31+In `haskell.nix`, we strive to take the build configuration from the cabal/stack configuration files.

32+So if you have a problem with your cabal/stack configuration, it is likely that you will have a problem with the `haskell.nix` build too.

33+

34+So the first thing to do is make sure that the build works with `cabal` or `stack` as normal.

35+If it *does* work, then the `haskell.nix` one should as well.

36+If, on the other hand, there is a failure, the `cabal` or `stack` build is usually easier to debug (or at least it is no longer a `haskell.nix` problem).

37+

38+### Is the `haskell.nix` configuration completely in line with the cabal/stack configuration?

39+

40+The `haskell.nix` configuration can come apart from the cabal/stack configuration in a number of ways:

41+

42+#### Compiler version

43+

44+(Cabal users only. For stack users this comes from the snapshot, so stack and `haskell.nix` will agree.)

45+

46+The compiler version used by `haskell.nix` is selected by the `compiler-nix-name` argument; or if you do not specify it, by some default version (we recommend specifying it!).

47+Cabal does not provide an easy way to pin a *version* of the compiler (`with-compiler` lets you pick a particular executable, which is nearly but not quite what we want).

48+Hence, the two can come apart.

49+

50+Make sure you are using the same compiler for the cabal build as for the `haskell.nix` build.

51+

52+#### Hackage index state

53+

54+(Cabal users only. For stack users, package versions come from the snapshot, so stack and `haskell.nix` will agree.)

55+

56+Cabal has the concept of the Hackage "index state".

57+This is a timestamp, and it tells Cabal to behave "as if" it was seeing Hackage at that point in time.

58+Pinning it is generally good for reproducibility regardless of whether you use `haskell.nix` (you can do so in `cabal.project`).

59+

60+If you do not set an `index-state` in `cabal.project`, then Cabal will use the latest one based on when you last called `cabal update`, and `haskell.nix` will use the latest one it knows about from `hackage.nix`.

61+These may not be the same!

62+So if you use `haskell.nix` we strongly recommend pinning the `index-state`.

63+

64+#### Nix-only configuration options

65+

66+You can set configuration options in your Nix code that are not present in the cabal/stack configuration.

67+For example, you might enable profiling.

68+

69+Where possible, try to do the configuration in your cabal/stack configuration, e.g. setting `profiling: true` in `cabal.project`.

70+This will ensure that the two builds agree.

71+

72+If you want or need to set some of them in Nix, try bringing the two into sync temporarily for troubleshooting.

73+

74+## Other specific issues

75+

76+### Why does the build complain about some files being missing?

77+

78+Sometimes your build works fine outside `haskell.nix`, but inside the `haskell.nix` build, cabal complains that some file is missing.

79+What is going on?

80+

81+The answer is that `haskell.nix` *thoroughly* cleans the source *by following what is mentioned as required in the cabal file*.

82+So we only include Haskell sources if they appear in a `hs-source-dirs` somewhere; and we only include non-Haskell files if they are included in `extra-source-files` or similar.

83+

84+This is good practice anyway: if you do not include such files in `extra-source-files` then they will not be included in `cabal sdist`, which will cause problems if you ever upload your package to Hackage.

85+But `haskell.nix` is very picky about it.

86+

87+### Why does my executable depend on GHC/GCC?

88+

89+You may want to set the `dontStrip` option to `false` (see https://github.com/input-output-hk/haskell.nix/issues/829).

90+This is not set by default because it can occasionally cause breakage.

docs/tutorials/building-package-from-stackage-hackage.md+27−22

@@ -1,38 +1,43 @@

1

2−# Build a specific package from hackage or a [stackage][] lts or nightly set.

2+# Build a specific package from Hackage or Stackage

3

4+## From a [Stackage][] snapshot

5+

4−To build a package, say [lens][], from a stackage snapshot, say [lts-13.28][],

6+To build a package, say [lens][], from a Stackage snapshot, say

5−you could run

7+[lts-13.28][], you could run:

6```bash

8```bash

7−nix build '(with import <nixpkgs> (import ./. {}).nixpkgsArgs; haskell-nix.snapshots."lts-13.28").lens.components.library'

9+nix build '(with import <nixpkgs> (import (builtins.fetchTarball "https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz") {}).nixpkgsArgs; haskell-nix.snapshots."lts-13.28").lens.components.library'

8```

10```

9−which would build the [lens][] library component from the lens package as fixed

11+This would build the (public) library component of the [lens][] package as

10−by the [lts-13.28][] stackage snapshot.

12+fixed by the [lts-13.28][] stackage snapshot. Nightly snapshots like

13+`nightly-2020-06-21` are also available.

11

14

12−## Specific version

15+## A specific version from Hackage

13

16

14−To build any package from hackage, say [lens][], in version, say 4.17.1, you

17+To build any package from hackage, say [lens][], at any version, say 4.17.1,

15−could run

18+you could run:

16```bash

19```bash

17−nix build '(with import <nixpkgs> (import ./. {}).nixpkgsArgs; (haskell-nix.hackage-package { name = "lens"; version = "4.17.1"; })).components.library'

20+nix build '(with import <nixpkgs> (import (builtins.fetchTarball "https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz") {}).nixpkgsArgs; (haskell-nix.hackage-package { name = "lens"; version = "4.17.1"; compiler-nix-name = "ghc8102"; })).components.library'

18```

21```

19−which would build the [lens][] library component from the [lens-4.17.1][] package

22+This would build the (public) library component of the [lens-4.17.1][] package

20−from hackage.

23+from hackage.

21

24

22−## Pinning hackage index

25+### Pinning hackage index

23

26

24−The dependencies would be solved against the most recent

27+The dependencies would be resolved against the most recent

25−[hackage-index-state][] that comes via the [hackage.nix][] pin with your

28+[hackage-index-state][] which comes with your [haskell.nix][] checkout via the

26−[haskell.nix][] checkout. A specific one can be specified as well:

29+[hackage.nix][] pin. A specific one can be specified as well:

27```bash

30```bash

28−nix build '(with import <nixpkgs> (import ./. {}).nixpkgsArgs; (haskell-nix.hackage-package { name = "lens"; version = "4.17.1"; index-state = "2019-07-14T00:00:00Z"; })).components.library'

31+nix build '(with import <nixpkgs> (import (builtins.fetchTarball "https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz") {}).nixpkgsArgs; (haskell-nix.hackage-package { name = "lens"; version = "4.17.1"; compiler-nix-name = "ghc8102"; index-state = "2019-07-14T00:00:00Z"; })).components.library'

29```

32```

30−which would use the hackage index as of `2019-07-14T00:00:00Z` to produce a build plan

33+This would use the hackage index as of `2019-07-14T00:00:00Z` to produce a

31−for the [lens-4.17.1][] package.

34+build plan for the [lens-4.17.1][] package.

32−

35+

33−[stackage]: https://stackage.org

36+[Stackage]: https://stackage.org

37+[Hackage]: https://hackage.haskell.org

34[hackage.nix]: https://github.com/input-output-hk/hackage.nix

38[hackage.nix]: https://github.com/input-output-hk/hackage.nix

39+[haskell.nix]: https://github.com/input-output-hk/haskell.nix

35[lts-13.28]: https://www.stackage.org/lts-13.28

40[lts-13.28]: https://www.stackage.org/lts-13.28

36[lens]: https://hackage.haskell.org/package/lens

41[lens]: https://hackage.haskell.org/package/lens

37[lens-4.17.1]: https://hackage.haskell.org/package/lens-4.17.1

42[lens-4.17.1]: https://hackage.haskell.org/package/lens-4.17.1

38−[hackage-index-state]: https://github.com/input-output-hk/hackage.nix/blob/master/index-state-hashes.nix

43+[hackage-index-state]: https://github.com/input-output-hk/hackage.nix/blob/master/index-state-hashes.nix

docs/tutorials/ca-derivations.mdnew file+65

@@ -0,0 +1,65 @@

1+# Content addressed derivations

2+## Introduction

3+

4+Floating content addressed derivations (from now *CA derivations*) is an experimental feature which substantially change how the hashes in the store paths are calculated.

5+Indeed, normally derivations are input addressed i.e. the outputs store paths depends only on the derivation inputs, instead with CA derivations they depend on the content of the outputs.

6+

7+This has two main advantages:

8+

9+- The so-called "early cutoff", namely the ability of Nix to stop a build if the build outputs would be something already built.

10+For example suppose you add a comment in an Haskell source, at this point Nix will rebuild the component depending on this source but since the output will be the same (adding a comment is an "output-invariant" change for `ghc`) every other component that depends on that will not be rebuilt.

11+- Users of the same Nix store does not need to trust each other when using substituters.

12+

13+You can find more information in the [ca-derivations page on the wiki](https://nixos.wiki/wiki/Ca-derivations) (and in the other resources linked there).

14+

15+## Usage

16+### Enable CA derivations in your system

17+First of all your Nix installation must support the `ca-derivations` experimental feature, this can done by adding the following in your `nix.conf`:

18+

19+```

20+experimental-features = ca-derivations

21+```

22+

23+Or if you use NixOS:

24+```

25+nix.extraOptions = ''

26+ experimental-features = ca-derivations

27+'';

28+```

29+

30+## Enable CA derivations in your project

31+At this point you can pass a new module to `project'` that tells `haskell.nix` to build every component in the project as CA derivation.

32+

33+```

34+haskell-nix.project' {

35+ # ...

36+

37+ modules = [{

38+ contentAddressed = true;

39+ # packages.project-name.components.exes.executable.contentAddressed = true;

40+ }];

41+};

42+```

43+

44+Optionally you can also specify which components you don't want to be content addressed.

45+

46+## Known problems

47+### Limitation of the current CA derivations implementation

48+

49+As explained in the [RFC 62](https://github.com/tweag/rfcs/blob/cas-rfc/rfcs/0062-content-addressed-paths.md)

50+

51+> The current implementation has a naive approach that just forbids fetching a path if the local system has a different realisation for the same drv output. This approach is simple and correct, but it's possible that it might not be good-enough in practice as it can result in a totally useless binary cache in some pathological cases.

52+

53+For example, suppose that your machine builds a derivation `A` producing an output `A.out` in your store and that after that a CI machine builds the same derivation `A` but producing a different output `A.out'` and populating a cache with this output.

54+At this point, if you need to build a derivation `B` that depends on `A`, since you already have the realisation `A.out` in your local store and you can't get `B.out` from the cache and you will end up building `B` even if one of its realisation is in the cache.

55+

56+This means that, in some cases, enabling CA derivations would lead to more rebuilds than not having it.

57+

58+### Hydra

59+Hydra currently doesn't support CA derivations, efforts are being made in this direction.

60+

61+

62+### GHC is not deterministic

63+Currently `ghc` is determinstic only disabling the parallel building i.e. passing `-j1`. [Here](https://gitlab.haskell.org/ghc/ghc/-/issues/12935) the upstream issue.

64+

65+Having a deterministic `ghc` would be a dream since it will automatically fix all the pathological cases about substituters discussed above and would allow `haskell.nix` to parallel build even when using CA derivations.

docs/tutorials/clean-git.md+2−2

@@ -29,7 +29,7 @@ in a change to the `.cabal` file the test will still be built the same).

29```

30components.tests.test.extraSrcFiles = [ "subdir-needed-by-test" ];

31```

32−Or alternatively, override the source with a suitable filter function.

32+Or alternatively, override the source with a suitable filter function.

33```

34components.tests.test.src = haskell-nix.haskellLib.cleanSourceWith {

35 inherit src;

@@ -64,7 +64,7 @@ sub directories containing git repos.

64

65For example if `repoA` and `repoB` are two git repos with

66cabal packages and want to use the `repoB` package when building

67−`repoA. First we can add `../repoB` to `repoA/cabal.project`:

67+`repoA`. First we can add `../repoB` to `repoA/cabal.project`:

68

69```

70packages:

docs/tutorials/coverage.mdnew file+123

@@ -0,0 +1,123 @@

1+# Coverage

2+

3+haskell.nix can generate coverage information for your package or

4+project using Cabal's inbuilt hpc support.

5+

6+## Prerequisites

7+

8+To get a sensible coverage report, you need to enable coverage on each

9+of the packages of your project:

10+

11+```nix

12+pkgs.haskell-nix.project {

13+ src = pkgs.haskell-nix.haskellLib.cleanGit {

14+ name = "haskell-nix-project";

15+ src = ./.;

16+ };

17+ compiler-nix-name = "ghc884";

18+

19+ modules = [{

20+ packages.$pkg.components.library.doCoverage = true;

21+ }];

22+}

23+```

24+

25+If you would like to make coverage optional, add an argument to your nix expression:

26+

27+```nix

28+{ withCoverage ? false }:

29+

30+pkgs.haskell-nix.project {

31+ src = pkgs.haskell-nix.haskellLib.cleanGit {

32+ name = "haskell-nix-project";

33+ src = ./.;

34+ };

35+ compiler-nix-name = "ghc884";

36+

37+ modules = pkgs.lib.optional withCoverage [{

38+ packages.$pkg.components.library.doCoverage = true;

39+ }];

40+}

41+```

42+

43+## Per-package

44+

45+```bash

46+nix-build default.nix -A "projectWithCoverage.$pkg.coverageReport"

47+```

48+

49+This will generate a coverage report for the package you requested.

50+All tests that are enabled (configured with `doCheck == true`) are

51+included in the coverage report.

52+

53+See the [developer coverage docs](../dev/coverage.md#package-reports) for more information.

54+

55+## Project-wide

56+

57+```bash

58+nix-build default.nix -A "projectWithCoverage.projectCoverageReport"

59+```

60+

61+This will generate a coverage report for all the local packages in

62+your project.

63+

64+See the [developer coverage docs](../dev/coverage.md#project-wide-reports) for more information.

65+

66+## Custom

67+

68+By default, the behaviour of the `coverageReport` attribute is to

69+generate a coverage report that describes how that package affects the

70+coverage of all local packages (including itself) in the project.

71+

72+The default behaviour of `projectCoverageReport` is to sum the

73+default coverage reports (produced by the above process) of all local

74+packages in the project.

75+

76+You can modify this behaviour by using the `coverageReport` and

77+`projectCoverageReport` functions found in the haskell.nix library:

78+

79+```nix

80+let

81+ inherit (pkgs.haskell-nix) haskellLib;

82+

83+ project = haskellLib.project {

84+ src = pkgs.haskell-nix.haskellLib.cleanGit {

85+ name = "haskell-nix-project";

86+ src = ./.;

87+ };

88+ compiler-nix-name = "ghc884";

89+

90+ modules = [{

91+ packages.$pkgA.components.library.doCoverage = true;

92+ packages.$pkgB.components.library.doCoverage = true;

93+ }];

94+ };

95+

96+ # Generate a coverage report for $pkgA that only includes the

97+ # unit-test check and only shows coverage information for $pkgA, not

98+ # $pkgB.

99+ custom$pkgACoverageReport = haskellLib.coverageReport rec {

100+ name = "$pkgA-unit-tests-only"

101+ inherit (project.$pkgA.components) library;

102+ checks = [project.$pkgA.components.checks.unit-test];

103+ # Note that this is the default value of the "mixLibraries"

104+ # argument and so this line isn't really necessary.

105+ mixLibraries = [project.$pkgA.components.library];

106+ };

107+

108+ custom$pkgBCoverageReport = haskellLib.coverageReport rec {

109+ name = "$pkgB-unit-tests-only"

110+ inherit (project.$pkgB.components) library;

111+ checks = [project.$pkgB.components.checks.unit-test];

112+ mixLibraries = [project.$pkgB.components.library];

113+ };

114+

115+ # Generate a project coverage report that only includes the unit

116+ # tests of the project, and only shows how each unit test effects

117+ # the coverage of it's package, and not other packages in the

118+ # project.

119+ allUnitTestsProjectReport = haskellLib.projectCoverageReport [custom$pkgACoverageReport custom$pkgBCoverageReport];

120+in {

121+ inherit project custom$pkgACoverageReport custom$pkgBCoverageReport allUnitTestsProjectCoverageReport;

122+}

123+```

docs/tutorials/cross-compilation.md+1−1

@@ -90,7 +90,7 @@ executables you must add package overrides to:

90```nix

91{

92 packages.bench.components.exes.bench.configureFlags =

93− stdenv.lib.optionals stdenv.hostPlatform.isMusl [

93+ lib.optionals stdenv.hostPlatform.isMusl [

94 "--disable-executable-dynamic"

95 "--disable-shared"

96 "--ghc-option=-optl=-pthread"

docs/tutorials/development.md+34−39

@@ -4,8 +4,8 @@ your Haskell package dependencies, but also the required system

4libraries and build tools.

5

6Inside the development shell, you can run commands such as `ghc`,

7+`ghci`, or `cabal new‑build` (`cabal build` on Cabal 3.0),

7−`ghci`, or `cabal new‑build`, and they will have all dependencies

8+and they will have all dependencies available.

8−available.

9

10Every dependency will be cached in your Nix store. If you have set up

11Hydra CI, then your team can share pre-built dependencies.

@@ -21,27 +21,12 @@ it exists in a file called `default.nix`.

21 rebuild all dependencies, even though they are available in the

22 shell. However, if you have a Stack project, you can generate the

23 package set with Haskell.nix, then use `cabal new‑build` to work

24− on it.

24+ on it. Starting Cabal 3.0 `cabal build` will work out of the box, as

25+ new style builds are the default.

25

26

26−## How to get a development shell for a package

27+## How to get a development shell

27

28

28−Run a `nix‑shell` on `components.all` of your package. `all` is a

29−synthetic component whose dependencies are the union of the

30−dependencies of all components in the package. Therefore, you will be

31−able to build the test suites because their dependencies will be

32−included.

33−

34−```nix

35−# shell.nix

36−let

37− hsPkgs = import ./default.nix {};

38−in

39− hsPkgs.my-package.components.all

40−```

41−

42−## How to get a development shell for a multi-package project

43−

44−If you have a Cabal or Stack project with multiple packages

29+If you have a Cabal or Stack project with one or more packages

45(i.e. multiple `.cabal` files, not a single package with multiple

30(i.e. multiple `.cabal` files, not a single package with multiple

46components), then you will need a development environment that

31components), then you will need a development environment that

47contains the _dependencies_ of your packages, but not the packages

32contains the _dependencies_ of your packages, but not the packages

@@ -49,13 +34,14 @@ themselves. This is what the [`shellFor`][shellFor] function does.

49

34

50```nix

35```nix

51# shell.nix

36# shell.nix

52−{ pkgs ? import <nixpkgs> {} }:

53−

54let

37let

55− hsPkgs = import ./default.nix { inherit pkgs; };

38+ project = import ./default.nix;

56in

39in

57− hsPkgs.shellFor {

40+ project.shellFor {

58− # Include only the *local* packages of your project.

41+ # ALL of these arguments are optional.

42+

43+ # List of packages from the project you want to work on in

44+ # the shell (default is all the projects local packages).

59 packages = ps: with ps; [

45 packages = ps: with ps; [

60 pkga

46 pkga

61 pkgb

47 pkgb

@@ -65,15 +51,22 @@ in

65 # and provides a "hoogle" command to search the index.

51 # and provides a "hoogle" command to search the index.

66 withHoogle = true;

52 withHoogle = true;

67

53

68− # You might want some extra tools in the shell (optional).

69−

70 # Some common tools can be added with the `tools` argument

54 # Some common tools can be added with the `tools` argument

55+ tools = {

71− tools = { cabal = "3.2.0.0"; hlint = "2.2.11"; };

56+ cabal = "3.2.0.0";

57+ hlint = "latest"; # Selects the latest version in the hackage.nix snapshot

58+ haskell-language-server = "latest";

59+ };

72 # See overlays/tools.nix for more details

60 # See overlays/tools.nix for more details

73

61

74 # Some you may need to get some other way.

62 # Some you may need to get some other way.

75− buildInputs = with pkgs.haskellPackages;

63+ buildInputs = [ (import <nixpkgs> {}).git ];

64+

65+ # Sellect cross compilers to include.

66+ crossPlatforms = ps: with ps; [

67+ ghcjs # Adds support for `js-unknown-ghcjs-cabal build` in the shell

68+ # mingwW64 # Adds support for `x86_64-W64-mingw32-cabal build` in the shell

76− [ ghcid ];

69+ ];

77

70

78 # Prevents cabal from choosing alternate plans, so that

71 # Prevents cabal from choosing alternate plans, so that

79 # *all* dependencies are provided by Nix.

72 # *all* dependencies are provided by Nix.

@@ -92,15 +85,15 @@ If you need a local Hoogle for all the dependencies of your project create this

92```nix

85```nix

93# shell-hoogle.nix

86# shell-hoogle.nix

94let

87let

95− hsPkgs = import ./default.nix {};

88+ project = import ./default.nix {};

96in

89in

97− hsPkgs.shellFor {

90+ project.shellFor {

98 packages = ps: [ps.my-package];

91 packages = ps: [ps.my-package];

99 withHoogle = true;

92 withHoogle = true;

100 }

93 }

101```

94```

102

95

103−and run `nix-shell shell-hoogle.nix --run "hoogle server --local"`.

96+and run `nix-shell shell-hoogle.nix --run "hoogle server --local"`.

104This will open a local Hoogle server at `http://127.0.0.1:8080`.

97This will open a local Hoogle server at `http://127.0.0.1:8080`.

105

98

106

99

@@ -115,7 +108,7 @@ selects packages from the larger package set.

115# shell.nix

108# shell.nix

116let

109let

117 haskellNix = import (builtins.fetchTarball https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz) {};

110 haskellNix = import (builtins.fetchTarball https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz) {};

118− nixpkgs = import haskellNix.sources.nixpkgs-1909 haskellNix.nixpkgsArgs;

111+ nixpkgs = import haskellNix.sources.nixpkgs haskellNix.nixpkgsArgs;

119 haskell = nixpkgs.haskell-nix;

112 haskell = nixpkgs.haskell-nix;

120in

113in

121 haskell.haskellPackages.ghcWithPackages (ps: with ps;

114 haskell.haskellPackages.ghcWithPackages (ps: with ps;

@@ -134,7 +127,7 @@ project.

134```nix

127```nix

135let

128let

136 haskellNix = import (builtins.fetchTarball https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz) {};

129 haskellNix = import (builtins.fetchTarball https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz) {};

137− nixpkgs = import haskellNix.sources.nixpkgs-1909 haskellNix.nixpkgsArgs;

130+ nixpkgs = import haskellNix.sources.nixpkgs haskellNix.nixpkgsArgs;

138 haskell = nixpkgs.haskell-nix;

131 haskell = nixpkgs.haskell-nix;

139in

132in

140 haskell.snapshots."lts-13.18".alex.components.exes.alex

133 haskell.snapshots."lts-13.18".alex.components.exes.alex

@@ -161,7 +154,7 @@ get a shell with some packages.

161Once you have a development shell, then you can begin configuring

154Once you have a development shell, then you can begin configuring

162Emacs to use it. The way I do it is:

155Emacs to use it. The way I do it is:

163

156

164−1. Run [lorri watch](https://github.com/target/lorri) to continously

157+1. Run [lorri watch](https://github.com/target/lorri) to continuously

165 build the shell environment and maintain GC roots.

158 build the shell environment and maintain GC roots.

166

159

1672. Use [emacs‑direnv](https://github.com/wbolster/emacs-direnv) to

1602. Use [emacs‑direnv](https://github.com/wbolster/emacs-direnv) to

@@ -183,7 +176,7 @@ Emacs to use it. The way I do it is:

183## Using `nix repl`

176## Using `nix repl`

184

177

185It's sometimes useful to load [Haskell.nix][] in the REPL to explore

178It's sometimes useful to load [Haskell.nix][] in the REPL to explore

186−attrsets and try examples.

179+attrsets and try examples.

187

180

188```

181```

189# example.nix

182# example.nix

@@ -209,8 +202,10 @@ Added 2 variables.

209nix-repl> lib.take 5 pkgNames

202nix-repl> lib.take 5 pkgNames

210[ "ALUT" "ANum" "Allure" "Boolean" "BoundedChan" ]

203[ "ALUT" "ANum" "Allure" "Boolean" "BoundedChan" ]

211

204

212−nix-repl>

205+nix-repl>

213```

206```

214

207

215Now that you have `nix-tools` and are able to import [Haskell.nix][],

208Now that you have `nix-tools` and are able to import [Haskell.nix][],

216you can continue to the next chapter.

209you can continue to the next chapter.

210+

211+[haskell.nix]: https://github.com/input-output-hk/haskell.nix

docs/tutorials/getting-started-flakes.mdnew file+142

@@ -0,0 +1,142 @@

1+# Getting started with flakes

2+

3+This version of the getting started guide is for users who

4+are using [Nix Flakes](https://nixos.wiki/wiki/Flakes).

5+The non flakes version of the guide is [here](getting-started.md).

6+

7+`haskell.nix` can automatically translate your

8+[Cabal](https://cabal.readthedocs.io/en/latest/cabal-project.html)

9+or [Stack](https://docs.haskellstack.org/en/stable/README/#quick-start-guide)

10+project and its dependencies into Nix code.

11+

12+Assuming you have [Nix](https://nixos.org/download.html) installed, you can

13+start setting up your project.

14+

15+## Setting up the binary cache

16+

17+IMPORTANT: you *must* do this or you *will* build several copies of GHC!

18+

19+You can configure Nix to use our binary cache, which is pushed to by CI, so should contain the artifacts that you need.

20+

21+You need to add the following sections to `/etc/nix/nix.conf` or, if you are a trusted user, `~/.config/nix/nix.conf` (if you don't know what a "trusted user" is, you probably want to do the former).

22+

23+```

24+trusted-public-keys = [...] hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ= [...]

25+substituters = [...] https://cache.iog.io [...]

26+```

27+

28+If you're running NixOS, you need to add/update the following in your `/etc/nixos/configuration.nix` files instead.

29+

30+```

31+# Binary Cache for Haskell.nix

32+nix.settings.trusted-public-keys = [

33+ "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

34+];

35+nix.settings.substituters = [

36+ "https://cache.iog.io"

37+];

38+```

39+

40+NixOS-21.11 and older use slightly different settings.

41+

42+```

43+# Binary Cache for Haskell.nix

44+nix.binaryCachePublicKeys = [

45+ "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

46+];

47+nix.binaryCaches = [

48+ "https://cache.iog.io"

49+];

50+```

51+

52+This can be tricky to get setup properly. If you're still having trouble getting cache hits, consult the corresponding [troubleshooting section](../troubleshooting.md#why-am-i-building-ghc).

53+

54+## Scaffolding

55+

56+The following work with `stack.yaml` and `cabal.project` based

57+projects.

58+

59+Add `flake.nix`:

60+

61+```nix

62+{

63+ description = "A very basic flake";

64+ inputs.haskellNix.url = "github:input-output-hk/haskell.nix";

65+ inputs.nixpkgs.follows = "haskellNix/nixpkgs-unstable";

66+ inputs.flake-utils.url = "github:numtide/flake-utils";

67+ outputs = { self, nixpkgs, flake-utils, haskellNix }:

68+ flake-utils.lib.eachSystem [ "x86_64-linux" "x86_64-darwin" ] (system:

69+ let

70+ overlays = [ haskellNix.overlay

71+ (final: prev: {

72+ # This overlay adds our project to pkgs

73+ helloProject =

74+ final.haskell-nix.project' {

75+ src = ./.;

76+ compiler-nix-name = "ghc8104";

77+ # This is used by `nix develop .` to open a shell for use with

78+ # `cabal`, `hlint` and `haskell-language-server`

79+ shell.tools = {

80+ cabal = {};

81+ hlint = {};

82+ haskell-language-server = {};

83+ };

84+ # Non-Haskell shell tools go here

85+ shell.buildInputs = with pkgs; [

86+ nixpkgs-fmt

87+ ];

88+ # This adds `js-unknown-ghcjs-cabal` to the shell.

89+ # shell.crossPlatforms = p: [p.ghcjs];

90+ };

91+ })

92+ ];

93+ pkgs = import nixpkgs { inherit system overlays; inherit (haskellNix) config; };

94+ flake = pkgs.helloProject.flake {

95+ # This adds support for `nix build .#js-unknown-ghcjs-cabal:hello:exe:hello`

96+ # crossPlatforms = p: [p.ghcjs];

97+ };

98+ in flake // {

99+ # Built by `nix build .`

100+ defaultPackage = flake.packages."hello:exe:hello";

101+ });

102+}

103+```

104+

105+!!! note "git dependencies"

106+ If you have git dependencies in your project, you'll need

107+ to [calculate sha256 hashes for them](./source-repository-hashes.md).

108+

109+### Working with a project

110+

111+Top-level attributes are Haskell packages (incl. dependencies) part of your project.

112+

113+To build the library component of a package in the project run:

114+

115+```shell

116+nix build .#your-package-name:lib:your-package-name

117+```

118+

119+There are also other components such as `exe`, `test` and `benchmark`.

120+To build an executable:

121+

122+```shell

123+nix build .#your-package-name:exe:your-exe-name

124+```

125+

126+To use the `devShell` provided by the flake run:

127+

128+```shell

129+nix develop .

130+cabal repl your-package-name:lib:your-package-name

131+cabal build your-package-name

132+```

133+

134+To open a shell for use with `stack` see [the following issue](https://github.com/input-output-hk/haskell.nix/issues/689#issuecomment-643832619).

135+

136+## Going forward

137+

138+Read through [project](../reference/library.md#project) function reference to see how the API works.

139+

140+There are a number of things to explore further in the tutorials section.

141+

142+[haskell.nix]: https://github.com/input-output-hk/haskell.nix

docs/tutorials/getting-started-hix.mdnew file+227

@@ -0,0 +1,227 @@

1+# Getting started with Hix

2+

3+The `hix` tools are wrappers for the various `nix` tools that

4+use `haskell.nix` without the need to add any `.nix` files.

5+

6+This is useful for:

7+

8+* A quick way to try out haskell.nix for new users.

9+

10+* Using haskell.nix to work on projects that do not have

11+ `.nix` files.

12+

13+* Testing to see if `haskell.nix` can build a project.

14+

15+* Making `flake` and `non flake` configurations to check `haskell.nix`

16+ treats them the same.

17+

18+## Installing Nix

19+

20+To use Hix you will need to install [Nix](https://nixos.org/download.html).

21+

22+## Setting up the binary cache

23+

24+IMPORTANT: you *must* do this or you *will* build several copies of GHC!

25+

26+You can configure Nix to use our binary cache, which is pushed to by CI, so should contain the artifacts that you need.

27+

28+You need to add the following sections to `/etc/nix/nix.conf` or, if you are a trusted user, `~/.config/nix/nix.conf` (if you don't know what a "trusted user" is, you probably want to do the former).

29+

30+```

31+trusted-public-keys = [...] hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ= [...]

32+substituters = [...] https://cache.iog.io [...]

33+```

34+

35+If you're running NixOS, you need to add/update the following in your `/etc/nixos/configuration.nix` files instead.

36+

37+```

38+# Binary Cache for Haskell.nix

39+nix.settings.trusted-public-keys = [

40+ "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

41+];

42+nix.settings.substituters = [

43+ "https://cache.iog.io"

44+];

45+```

46+

47+NixOS-21.11 and older use slightly different settings.

48+

49+```

50+# Binary Cache for Haskell.nix

51+nix.binaryCachePublicKeys = [

52+ "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

53+];

54+nix.binaryCaches = [

55+ "https://cache.iog.io"

56+];

57+```

58+

59+This can be tricky to get setup properly. If you're still having trouble getting cache hits, consult the corresponding [troubleshooting section](../troubleshooting.md#why-am-i-building-ghc).

60+

61+## Installing Hix

62+

63+```

64+nix-env -iA hix -f https://github.com/input-output-hk/haskell.nix/tarball/master

65+```

66+

67+## Updating Hix (also updates hackage)

68+

69+```

70+hix update

71+```

72+

73+This is also necessary to make the latest nightly snapshot of hackage

74+avaiable to nix.

75+

76+## Building with Hix

77+

78+To run `cabal build` in a nix-shell with all the dependencies required:

79+

80+```

81+cabal unpack hello

82+cd hello-1.0.0.2

83+hix-shell --run 'cabal build'

84+```

85+

86+Build with nix:

87+

88+```

89+hix-build -A hsPkgs.hello.components.exes.hello

90+```

91+

92+Cross compile to JavaScript:

93+

94+```

95+hix-build -A projectCross.ghcjs.hsPkgs.hello.components.exes.hello

96+```

97+

98+## Configuring Hix

99+

100+The configuration arguments for `Hix` can be (from highest precedence to lowest):

101+

102+* Passed on the command line with `--arg` (or `--argstr` for string args).

103+

104+* Placed in `nix/hix.nix` file in the project dir.

105+

106+* Placed in `~/.config/hix/hix.conf`

107+

108+For example to build with GHC 8.10.7:

109+

110+```

111+hix-shell --argstr compiler-nix-name ghc8107 --run 'cabal build'

112+```

113+

114+or add a `nix/hix.nix` or `~/.config/hix/hix.conf` file:

115+

116+```nix

117+{ compiler-nix-name = "ghc8107"; }

118+```

119+

120+Here are just a few of the other configuration arguments you could use

121+in the files or on the command line (they are all optional):

122+

123+```nix

124+{ name = "hello"; # for better error messages and derivation names

125+ nixpkgsPin = "nixpkgs-unstable"; # or nixpkgs-2111 or nixpkgs-2105

126+ nixpkgs = <nixpkgs>; # use this instead of nixpkgsPin

127+ subDir = "some/sub/dir"; # sub dir containing the haskell project

128+ projectFileName = "stack.yaml"; # use this project file

129+ tools.haskell-language-server = "latest";

130+ tools.hlint = "latest"; # Include the latest hls and hlint in the shell

131+ index-state = "2021-02-22T00:00:00Z"; # It is normally best to put this in `cabal.project` (not here)

132+

133+# PLUS MANY MORE! Almost any argument you can pass to the project functions

134+# or to `shellFor` can be used in as a Hix configuration argument.

135+

136+}

137+```

138+

139+## Adding Nix Support with Niv

140+

141+If you have a `nix/hix.nix` file with suitable configuration that

142+you want to make available to users with Nix (without having to

143+install Hix).

144+

145+[Niv](https://github.com/nmattia/niv) is a command line tool for keeping track of Nix project dependencies.

146+

147+After installing niv you can initialize niv and pin the latest haskell.nix

148+commit by running the following in the root directory of the project:

149+

150+```

151+niv init

152+niv add input-output-hk/haskell.nix -n haskellNix

153+```

154+

155+Add `default.nix`:

156+

157+```nix

158+(import (import nix/sources.nix).haskellNix {}).hix.project { src = ./.; }

159+```

160+

161+If you want to also pin `nixpkgs` with Niv use:

162+

163+```nix

164+let

165+ sources = import nix/sources.nix;

166+in

167+ (import sources.haskellNix {}).hix.project {

168+ inherit (sources) nixpkgs;

169+ src = ./.;

170+ }

171+```

172+

173+Add `shell.nix`:

174+

175+```nix

176+(import ./.).shell

177+```

178+

179+When you want to update to the latest version of haskell.nix use:

180+

181+```

182+niv update haskellNix

183+```

184+

185+## Adding Nix Flake Support

186+

187+To add flake support that uses the `nix/hix.nix` configuration in your

188+follow the [Getting started with flakes](getting-started.md) guide, but

189+use `haskell-nix.hix.project` instead of `haskell-nix.project'`

190+

191+The `nixpkgs` used will need to be selected as a flake input (any selection

192+made in `nix/hix.nix` will be ignored).

193+

194+Example `flake.nix` file:

195+

196+```nix

197+{

198+ description = "A very basic flake";

199+ inputs.haskellNix.url = "github:input-output-hk/haskell.nix";

200+ inputs.nixpkgs.follows = "haskellNix/nixpkgs-unstable";

201+ inputs.flake-utils.url = "github:numtide/flake-utils";

202+ outputs = { self, nixpkgs, flake-utils, haskellNix }:

203+ flake-utils.lib.eachSystem [ "x86_64-linux" "x86_64-darwin" ] (system:

204+ let

205+ overlays = [ haskellNix.overlay

206+ (final: prev: {

207+ # This overlay adds our project to pkgs

208+ helloProject =

209+ final.haskell-nix.hix.project {

210+ src = ./.;

211+ # Other project options can be put in `nix/hix.nix`

212+ };

213+ })

214+ ];

215+ pkgs = import nixpkgs { inherit system overlays; inherit (haskellNix) config; };

216+ flake = pkgs.helloProject.flake {

217+ # This adds support for `nix build .#js-unknown-ghcjs:hello:exe:hello`

218+ crossPlatforms = p: [p.ghcjs];

219+ };

220+ in flake // {

221+ # Built by `nix build .`

222+ defaultPackage = flake.packages."hello:exe:hello";

223+ });

224+}

225+```

226+

227+

docs/tutorials/getting-started.md+127−38

@@ -5,21 +5,73 @@

5or [Stack](https://docs.haskellstack.org/en/stable/README/#quick-start-guide)

6project and its dependencies into Nix code.

7

8−Assuming you have [Nix installed](https://nixos.org/download.html), you can start setting up your project.

8+Assuming you have [Nix](https://nixos.org/download.html) installed, you can

9+start setting up your project.

9

10

10−## Setting up the Cachix binary cache

11+## Setting up the binary cache

11

12

12−You can **avoid compiling GHC and nix-tools** by configuring [Cachix](https://cachix.org)

13+IMPORTANT: you *must* do this or you *will* build several copies of GHC!

13−so you can benefit from the binary cache built by CI:

14

15−```bash

15+You can configure Nix to use our binary cache, which is pushed to by CI, so should contain the artifacts that you need.

16−$ nix-env -iA cachix -f https://cachix.org/api/v1/install

16+

17−installing 'cachix-0.3.8'

17+You need to add the following sections to `/etc/nix/nix.conf` or, if you are a trusted user, `~/.config/nix/nix.conf` (if you don't know what a "trusted user" is, you probably want to do the former).

18−building '/nix/store/bh176xhpk4wrjm56iahm86wf85jaz23v-user-environment.drv'...

18+

19−created 42 symlinks in user environment

19+```

20+trusted-public-keys = [...] hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ= [...]

21+substituters = [...] https://cache.iog.io [...]

22+```

23+

24+If you're running NixOS, you need to add/update the following in your `/etc/nixos/configuration.nix` files instead.

25+

26+```

27+# Binary Cache for Haskell.nix

28+nix.settings.trusted-public-keys = [

29+ "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

30+];

31+nix.settings.substituters = [

32+ "https://cache.iog.io"

33+];

34+```

35+

36+NixOS-21.11 and older use slightly different settings.

37+

38+```

39+# Binary Cache for Haskell.nix

40+nix.binaryCachePublicKeys = [

41+ "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

42+];

43+nix.binaryCaches = [

44+ "https://cache.iog.io"

45+];

46+```

47+

48+This can be tricky to get setup properly. If you're still having trouble getting cache hits, consult the corresponding [troubleshooting section](../troubleshooting.md#why-am-i-building-ghc).

49+

50+## Niv

51+

52+[Niv](https://github.com/nmattia/niv) is a command line tool for keeping track of Nix project dependencies.

53+

54+This guide assumes that the `sources.haskellNix` will be set to point

55+a pinned copy of the haskell.nix github repo. One easy way to do this

56+is to use Niv. If you prefer not to use Niv another option is described

57+in the in the "Using haskell.nix without niv" section of this document.

58+

59+If you want to use Nix Flakes to pin your dependencies then you should

60+consider following the [Getting started with flakes](./getting-started-flakes.md)

61+document instead of this one.

62+

63+After installing niv you can initialize niv and pin the latest haskell.nix

64+commit by running the following in the root directory of the project:

65+

66+```

67+niv init

68+niv add input-output-hk/haskell.nix -n haskellNix

69+```

70+

71+Then when you want to update to the latest version of haskellNix use:

20

72

21−$ cachix use iohk

73+```

22−Configured https://iohk.cachix.org binary cache in ~/.config/nix/nix.conf

74+niv update haskellNix

23```

75```

24

76

25## Scaffolding

77## Scaffolding

@@ -30,26 +82,35 @@ projects.

30Add `default.nix`:

82Add `default.nix`:

31

83

32```nix

84```nix

85+let

86+ # Read in the Niv sources

87+ sources = import ./nix/sources.nix {};

88+ # If ./nix/sources.nix file is not found run:

89+ # niv init

90+ # niv add input-output-hk/haskell.nix -n haskellNix

91+

33−{ # Fetch the latest haskell.nix and import its default.nix

92+ # Fetch the haskell.nix commit we have pinned with Niv

34− haskellNix ? import (builtins.fetchTarball "https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz") {}

93+ haskellNix = import sources.haskellNix {};

35−

94+ # If haskellNix is not found run:

95+ # niv add input-output-hk/haskell.nix -n haskellNix

96+

97+ # Import nixpkgs and pass the haskell.nix provided nixpkgsArgs

98+ pkgs = import

36−# haskell.nix provides access to the nixpkgs pins which are used by our CI, hence

99+ # haskell.nix provides access to the nixpkgs pins which are used by our CI,

37−# you will be more likely to get cache hits when using these.

100+ # hence you will be more likely to get cache hits when using these.

38−# But you can also just use your own, e.g. '<nixpkgs>'

101+ # But you can also just use your own, e.g. '<nixpkgs>'.

39−, nixpkgsSrc ? haskellNix.sources.nixpkgs-2003

102+ haskellNix.sources.nixpkgs-unstable

40−

41−# haskell.nix provides some arguments to be passed to nixpkgs, including some patches

103+ # These arguments passed to nixpkgs, include some patches and also

42−# and also the haskell.nix functionality itself as an overlay.

104+ # the haskell.nix functionality itself as an overlay.

43−, nixpkgsArgs ? haskellNix.nixpkgsArgs

105+ haskellNix.nixpkgsArgs;

44−

45−# import nixpkgs with overlays

46−, pkgs ? import nixpkgsSrc nixpkgsArgs

47−}: pkgs.haskell-nix.project {

106+in pkgs.haskell-nix.project {

48 # 'cleanGit' cleans a source directory based on the files known by git

107 # 'cleanGit' cleans a source directory based on the files known by git

49 src = pkgs.haskell-nix.haskellLib.cleanGit {

108 src = pkgs.haskell-nix.haskellLib.cleanGit {

50 name = "haskell-nix-project";

109 name = "haskell-nix-project";

51 src = ./.;

110 src = ./.;

52 };

111 };

112+ # Specify the GHC version to use.

113+ compiler-nix-name = "ghc8102"; # Not required for `stack.yaml` based projects.

53}

114}

54```

115```

55

116

@@ -74,33 +135,59 @@ To build an executable:

74nix-build -A your-package-name.components.exes.your-exe-name

135nix-build -A your-package-name.components.exes.your-exe-name

75```

136```

76

137

138+To cross compile use the `projectCross` attribute:

139+

140+```

141+nix-build -A projectCross.ghcjs.hsPkgs.your-package-name.components.exes.your-exe-name

142+nix-build -A projectCross.mingwW64.hsPkgs.your-package-name.components.exes.your-exe-name

143+```

144+

77−To open a shell for use with `cabal` run:

145+To open a shell for use with `cabal`, `hlint` and `haskell-language-server` add `shell.nix`:

146+

147+```nix

148+(import ./default.nix).shellFor {

149+ tools = {

150+ cabal = "3.2.0.0";

151+ hlint = "latest";

152+ haskell-language-server = "latest";

153+ };

154+}

155+```

156+

157+Then run:

78

158

79```shell

159```shell

80−nix-shell -A shellFor

160+nix-shell

81cabal new-repl your-package-name:library:your-package-name

161cabal new-repl your-package-name:library:your-package-name

82cabal new-build your-package-name

162cabal new-build your-package-name

83```

163```

84

164

85To open a shell for use with `stack` see [the following issue](https://github.com/input-output-hk/haskell.nix/issues/689#issuecomment-643832619).

165To open a shell for use with `stack` see [the following issue](https://github.com/input-output-hk/haskell.nix/issues/689#issuecomment-643832619).

86

166

87−### Pinning the [Haskell.nix][] version

167+## Using haskell.nix without Niv

88

168

89−For simplicity's sake we will use `fetchTarball` for the examples in

169+If you would prefer not to use niv you can replace

170+`sources = import ./nix/sources.nix {};` in the examples with:

171+

172+```nix

173+let sources = {

174+ haskellNix = builtins.fetchTarball "https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz";

175+ };

176+```

177+

90−this documentation. This will always get the latest version, and is

178+The `fetchTarball` call above will always get the latest version, and is

91similar to an auto-updating Nix channel.

179similar to an auto-updating Nix channel.

92

180

93−However, in your own project, you may wish to pin [Haskell.nix][] (as

181+However, in your own project, you may wish to pin [haskell.nix][] (as

94you would pin Nixpkgs). This will make your builds reproducible, more

182you would pin Nixpkgs). This will make your builds reproducible, more

95predictable, and faster (because the fixed version is cached).

183predictable, and faster (because the fixed version is cached).

96

184

97−Straightforward way of doing this is to change branch name to a revision.

185+Straightforward way of doing this is to change the branch name to a revision.

98

186

99```nix

187```nix

100−{ # Fetch the latest haskell.nix and import its default.nix

188+let sources = {

101− haskellNix ? import (builtins.fetchTarball "https://github.com/input-output-hk/haskell.nix/archive/f1a94a4c82a2ab999a67c3b84269da78d89f0075.tar.gz") {}

189+ haskellNix = builtins.fetchTarball "https://github.com/input-output-hk/haskell.nix/archive/f1a94a4c82a2ab999a67c3b84269da78d89f0075.tar.gz";

102−

190+ };

103−...

104```

191```

105

192

106There are other possible schemes for pinning. See

193There are other possible schemes for pinning. See

@@ -109,6 +196,8 @@ There are other possible schemes for pinning. See

109

196

110## Going forward

197## Going forward

111

198

199+Read through [project](../reference/library.md#project) function reference to see how the API works.

200+

112There are a number of things to explore further in the tutorials section.

201There are a number of things to explore further in the tutorials section.

113

202

114−[haskell.nix]: https://github.com/input-output-hk/haskell.nix

203+[haskell.nix]: https://github.com/input-output-hk/haskell.nix

docs/tutorials/hackage-stackage.md+6−4

@@ -6,14 +6,14 @@ If your project depends on a Hackage package, then the `hackage.nix` revision us

6

7## Updating and pinning `hackage.nix` and `stackage.nix`

8

9−`haskell.nix` pins particular revisions of these repositories internally, both for our own usage in testing, and so that users have a sensible default when getting started.

9+`haskell.nix` pins particular revisions of these repositories internally, both for our own usage in testing, and so that users have a sensible default when getting started.

10These revisions are updated nightly, so you can get newer revisions of `hackage.nix` and `stackage.nix` by updating your revision of `haskell.nix` itself.

11

12However, this exposes you to changes in `haskell.nix` which you may not want, such as changes that force compiler rebuilds, or the occasional bug.

13Instead, you can pin `hackage.nix` and `stackage.nix` independently. For example:

14

15```nix

16−let

16+let

17 # You can use a tool like `niv` to manage this boilerplate

18 hackageSrc = builtins.fetchTarball https://github.com/input-output-hk/hackage.nix/archive/master.tar.gz;

19 stackageSrc = builtins.fetchTarball https://github.com/input-output-hk/stackage.nix/archive/master.tar.gz;

@@ -29,6 +29,8 @@ let

29in ...

30```

31

32−This way you can change the revisions of `hackage.nix` and `stackage.nix` are fetched from without changing `haskell.nix`.

32+This way you can change the revisions of `hackage.nix` and `stackage.nix`

33+without changing `haskell.nix`.

33

34

34−However, bear in mind that Stackage refers to Hackage, so your Stackage should never be newer than Hackage.

35+However, bear in mind that Stackage refers to Hackage, so your Stackage pin

36+should never be newer than your Hackage pin.

docs/tutorials/materialization.md+109−118

@@ -2,9 +2,9 @@

2

3## What is materialization?

4

5−Capturing and storing the nix files for a project so that they do

5+Capturing and storing the Nix files for a project so that they do

6not need to be built (or checked). This allows us to cache the input

7−of an IFD (import from derviation).

7+of an IFD (import from derivation).

8

9## Why use materialization?

10

@@ -16,207 +16,198 @@ dependencies of nix-tools for instance).

16 is not unusual for it to take 5 seconds per project).

17

18* They can be slow to build (or download) on machines that do not

19− yet have them in the nix store.

19+ yet have them in the Nix store.

20

21−* Hydra does not show progress because it does not provide feedback

21+* Hydra does not show progress because it does not provide feedback until it

22− until it has a list of jobs and the list of jobs cannot depends

22+ has a list of jobs and the list of jobs cannot depend on the Nix expressions

23− on the nix being present (although this is often blamed on IFD

23+ being present (although this is often blamed on IFD it would be the same if

24− it would be the same if it wrote out JSON files and read them in)

24+ it wrote out JSON files and read them in)

25

26−## When is it ok to materialize?

26+## When is it OK to materialize?

27

28−* The nix is unlikely to change frequently (and when it does you

28+* The Nix expressions are unlikely to change frequently (and when it does you

29 are happy to manually update it).

30

31−* You are happy to script something to update the materialized

31+* You are happy to script something to update the materialized Nix files

32− nix files automatically.

32+ automatically.

33−* You are certain that the IFD you materialize is not `system`-dependent. If it was you'd

34− obtain different nix expressions depending on which `system` the IFD was evaluated.

35−

36−## How can we materialize the nix files?

37

33

34+* You are certain that the IFD you materialize is not `system`-dependent. If it

35+ was you'd obtain different Nix expressions depending on which `system` the

36+ IFD was evaluated.

37+

38+## How can we materialize the Nix files?

39+

38−Lets say we want to build `hlint`. We might start with an `hlint`

40+Lets say we want to build `hlint`. We might start with an `hlint.nix`

39file that looks like this:

41file that looks like this:

40

42

41```nix

43```nix

42let inherit (import ./. {}) sources nixpkgsArgs;

44let inherit (import ./. {}) sources nixpkgsArgs;

43− pkgs = import sources.nixpkgs-default nixpkgsArgs;

45+ pkgs = import sources.nixpkgs nixpkgsArgs;

44 hlint = pkgs.haskell-nix.hackage-package {

46 hlint = pkgs.haskell-nix.hackage-package {

47+ compiler-nix-name = "ghc8102";

45 name = "hlint";

48 name = "hlint";

46 version = "2.2.11";

49 version = "2.2.11";

47 };

50 };

48−in hlint.components.exes.hlint

51+in hlint

49```

52```

50

53

51Building this may result in a lot of output, but if you build

54Building this may result in a lot of output, but if you build

52it again it should give just:

55it again it should give just:

53

56

54```

57```

55−$ nix-build hlint.nix

58+$ nix-build hlint.nix -A components.exes.hlint

56−trace: Using latest index state for hlint!

59+trace: No index state specified for hlint, using the latest index state that we know about (2021-01-04T00:00:00Z)!

57−trace: Using index-state: 2020-04-15T00:00:00Z for hlint

60+/nix/store/2ybrfmcp79gg75ad4pr1cbxjak70yg8b-hlint-exe-hlint-2.2.11

58−/nix/store/rnfz66v7k8i38c8rsmchzsyqjrmrbdpk-hlint-2.2.11-exe-hlint

59```

61```

60

62

61−To materialize the nix files we need to take care to pin down the

63+To materialize the Nix files we need to take care to pin down the inputs. Stack

64+projects have their inputs pinned through specifying the snapshot. For cabal

62−inputs. For cabal projects this means we must specify the

65+projects this means we must specify the `index-state` of hackage we want to

63−`index-state` of hackage we want to use:

66+use:

64

67

65```nix

68```nix

66let inherit (import ./. {}) sources nixpkgsArgs;

69let inherit (import ./. {}) sources nixpkgsArgs;

67− pkgs = import sources.nixpkgs-default nixpkgsArgs;

70+ pkgs = import sources.nixpkgs nixpkgsArgs;

68 hlint = pkgs.haskell-nix.hackage-package {

71 hlint = pkgs.haskell-nix.hackage-package {

72+ compiler-nix-name = "ghc8102";

69 name = "hlint";

73 name = "hlint";

70 version = "2.2.11";

74 version = "2.2.11";

71− index-state = "2020-04-15T00:00:00Z";

75+ index-state = "2021-01-04T00:00:00Z";

72 };

76 };

73−in hlint.components.exes.hlint

77+in hlint

74```

78```

75

79

76−Now if we build again we get a hint telling use how to

80+Now if we build again we get a hint telling use how to calculate a suitable

77−calculate a suitable sha256 hash to turn the derivation

78−containing the nix files into a fixed output derivation:

81+sha256 hash to turn the derivation containing the Nix files into a fixed-output

82+derivation:

79

83

80```

84```

81−$ nix-build hlint.nix

85+$ nix-build hlint.nix -A components.exes.hlint

82−trace: Using index-state: 2020-04-15T00:00:00Z for hlint

86+trace: To make project.plan-nix for hlint a fixed-output derivation but not materialized, set `plan-sha256` to the output of the 'calculateMaterializedSha' script in 'passthru'.

83−trace: Get `plan-sha256` with `nix-hash --base32 --type sha256 /nix/store/8z6p4237rin3c6c1lmjwshmj8rdqrhw2-hlint-plan-to-nix-pkgs/`

87+trace: To materialize project.plan-nix for hlint entirely, pass a writable path as the `materialized` argument and run the 'updateMaterialized' script in 'passthru'.

84−/nix/store/rnfz66v7k8i38c8rsmchzsyqjrmrbdpk-hlint-2.2.11-exe-hlint

88+/nix/store/2ybrfmcp79gg75ad4pr1cbxjak70yg8b-hlint-exe-hlint-2.2.11

85−

89+

86−$ nix-hash --base32 --type sha256 /nix/store/8z6p4237rin3c6c1lmjwshmj8rdqrhw2-hlint-plan-to-nix-pkgs/

90+$ nix-build hlint.nix -A project.plan-nix.passthru.calculateMaterializedSha | bash

87−02hasr27a994sml1fzf8swb716lm6lgixxr53y0gxkhw437xkck4

91+trace: To make project.plan-nix for hlint a fixed-output derivation but not materialized, set `plan-sha256` to the output of the 'calculateMaterializedSha' script in 'passthru'.

92+trace: To materialize project.plan-nix for hlint entirely, pass a writable path as the `materialized` argument and run the 'updateMaterialized' script in 'passthru'.

93+04hdgqwpaswmyb0ili7fwi6czzihd6x0jlvivw52d1i7wv4gaqy7

88```

94```

89

95

90−We can add the hash as `plan-sha256` or (`stack-sha256` for

96+For a Stack project all occurences of `plan-nix` and `plan-sha256` are replaced

91−stack projects)

97+by `stack-nix` and `stack-sha256`, respectively. We can add the hash as

98+`plan-sha256`:

92

99

93```nix

100```nix

94let inherit (import ./. {}) sources nixpkgsArgs;

101let inherit (import ./. {}) sources nixpkgsArgs;

95− pkgs = import sources.nixpkgs-default nixpkgsArgs;

102+ pkgs = import sources.nixpkgs nixpkgsArgs;

96 hlint = pkgs.haskell-nix.hackage-package {

103 hlint = pkgs.haskell-nix.hackage-package {

104+ compiler-nix-name = "ghc8102";

97 name = "hlint";

105 name = "hlint";

98 version = "2.2.11";

106 version = "2.2.11";

99− index-state = "2020-04-15T00:00:00Z";

107+ index-state = "2021-01-04T00:00:00Z";

100− plan-sha256 = "02hasr27a994sml1fzf8swb716lm6lgixxr53y0gxkhw437xkck4";

108+ plan-sha256 = "04hdgqwpaswmyb0ili7fwi6czzihd6x0jlvivw52d1i7wv4gaqy7";

101 };

109 };

102−in hlint.components.exes.hlint

110+in hlint

103```

111```

104

112

105−Just adding the hash might help reuse of the cached nix, but nix will

113+Just adding the hash might help reuse of the cached Nix expressions, but Nix

106−still calculate all the dependencies (which can add seconds to

114+will still calculate all the dependencies (which can add seconds to `nix-build`

107−`nix-build` and `nix-shell` commands when no other work is needed)

115+and `nix-shell` commands when no other work is needed) and users who do not yet

108−and users who do not yet have the dependencies in their store will have

116+have the dependencies in their store will have to wait while they are built or

109−to wait while they are built or downloaded.

117+downloaded.

110

118

111−Running nix build again gives us a hint on what we can do next:

119+Running `nix-build` again gives us a hint on what we can do next:

112

120

113```

121```

114−$ nix-build hlint.nix

122+$ nix-build hlint.nix -A components.exes.hlint

115−trace: Using index-state: 2020-04-15T00:00:00Z for hlint

123+trace: To materialize project.plan-nix for hlint entirely, pass a writable path as the `materialized` argument and run the 'updateMaterialized' script in 'passthru'.

116−trace: To materialize, point `materialized` to a copy of /nix/store/kk047cqsjvbj4w8psv4l05abdcnyrqdc-hlint-plan-to-nix-pkgs

124+/nix/store/2ybrfmcp79gg75ad4pr1cbxjak70yg8b-hlint-exe-hlint-2.2.11

117−/nix/store/rnfz66v7k8i38c8rsmchzsyqjrmrbdpk-hlint-2.2.11-exe-hlint

118```

125```

119

126

120−To capture the nix we can do something like:

127+To capture the Nix expressions we can do something like:

121

128

122```nix

129```nix

123let inherit (import ./. {}) sources nixpkgsArgs;

130let inherit (import ./. {}) sources nixpkgsArgs;

124− pkgs = import sources.nixpkgs-default nixpkgsArgs;

131+ pkgs = import sources.nixpkgs nixpkgsArgs;

125 hlint = pkgs.haskell-nix.hackage-package {

132 hlint = pkgs.haskell-nix.hackage-package {

133+ compiler-nix-name = "ghc8102";

126 name = "hlint";

134 name = "hlint";

127 version = "2.2.11";

135 version = "2.2.11";

128− index-state = "2020-04-15T00:00:00Z";

136+ index-state = "2021-01-04T00:00:00Z";

129− plan-sha256 = "02hasr27a994sml1fzf8swb716lm6lgixxr53y0gxkhw437xkck4";

137+ plan-sha256 = "04hdgqwpaswmyb0ili7fwi6czzihd6x0jlvivw52d1i7wv4gaqy7";

130 materialized = ./hlint.materialized;

138 materialized = ./hlint.materialized;

131 };

139 };

132−in hlint.components.exes.hlint

140+in hlint

133```

141```

134

142

135−Now we can copy the nix files needed and build with:

143+Now we can copy the Nix files needed and build with:

136

144

137```

145```

138−$ cp -r /nix/store/8z6p4237rin3c6c1lmjwshmj8rdqrhw2-hlint-plan-to-nix-pkgs hlint.materialized

146+$ nix-build hlint.nix 2>&1 | grep -om1 '/nix/store/.*-updateMaterialized' | bash

139−$ nix-build hlint.nix

147+$ nix-build hlint.nix -A components.exes.hlint

140−/nix/store/rnfz66v7k8i38c8rsmchzsyqjrmrbdpk-hlint-2.2.11-exe-hlint

148+building '/nix/store/wpxsgzl1z4jnhfqzmzg3xxv3ljpmzr5h-hlint-plan-to-nix-pkgs.drv'...

149+/nix/store/2ybrfmcp79gg75ad4pr1cbxjak70yg8b-hlint-exe-hlint-2.2.11

141```

150```

142

151

143−We may want to run `chmod -R +w hlint.materialized` as the files copied from the

144−store will be read only.

145−

146## How can we check `sha256` and `materialized` are up to date?

152## How can we check `sha256` and `materialized` are up to date?

147

153

148Let's pretend we had to go back to `hlint` version `2.2.10`.

154Let's pretend we had to go back to `hlint` version `2.2.10`.

149−We can tell haskell.nix to check the materialiazation either by:

155+We can tell haskell.nix to check the materialization either by:

150

156

151* Removing the materialization files with `rm -rf hlint.materialized`

157* Removing the materialization files with `rm -rf hlint.materialized`

158+

152* Temporarily adding `checkMaterialization = true;`

159* Temporarily adding `checkMaterialization = true;`

153

160

154If we choose to add the `checkMaterialization` flag you would have:

161If we choose to add the `checkMaterialization` flag you would have:

155

162

156```nix

163```nix

157let inherit (import ./. {}) sources nixpkgsArgs;

164let inherit (import ./. {}) sources nixpkgsArgs;

158− pkgs = import sources.nixpkgs-default nixpkgsArgs;

165+ pkgs = import sources.nixpkgs nixpkgsArgs;

159 hlint = pkgs.haskell-nix.hackage-package {

166 hlint = pkgs.haskell-nix.hackage-package {

167+ compiler-nix-name = "ghc8102";

160 name = "hlint";

168 name = "hlint";

161 version = "2.2.10";

169 version = "2.2.10";

162− index-state = "2020-04-15T00:00:00Z";

170+ index-state = "2021-01-04T00:00:00Z";

163− plan-sha256 = "02hasr27a994sml1fzf8swb716lm6lgixxr53y0gxkhw437xkck4";

171+ plan-sha256 = "04hdgqwpaswmyb0ili7fwi6czzihd6x0jlvivw52d1i7wv4gaqy7";

164 materialized = ./hlint.materialized;

172 materialized = ./hlint.materialized;

165 checkMaterialization = true;

173 checkMaterialization = true;

166 };

174 };

167−in hlint.components.exes.hlint

175+in hlint

168```

176```

169

177

170This will fail and report the details of what is wrong and how to fix it:

178This will fail and report the details of what is wrong and how to fix it:

171

179

172```

180```

173−$ nix-build hlint.nix

181+$ nix-build hlint.nix -A components.exes.hlint

174

182

175...

183...

176

184

177−Calculated hash for hlint-plan-to-nix-pkgs was not 02hasr27a994sml1fzf8swb716lm6lgixxr53y0gxkhw437xkck4. New hash is :

185+Calculated hash for hlint-plan-to-nix-pkgs was not 04hdgqwpaswmyb0ili7fwi6czzihd6x0jlvivw52d1i7wv4gaqy7. New hash is :

178− plan-sha256 = "0zsi3wv92qax33ic4n5dfsqd1r9qam1k75za3c5jqgdxl3hy8vph";

186+ plan-sha256 = "0jsgdmii0a6b35sd42cpbc83s4sp4fbx8slphzvamq8n9x49i5b6";

179−Materialized nix used for hlint-plan-to-nix-pkgs incorrect. To fix run :

187+Materialized nix used for hlint-plan-to-nix-pkgs incorrect. To fix run: /nix/store/6wp0zzal40ls874f5ddpaac7qmii9y4z-updateMaterialized

180− rm -rf /Users/hamish/iohk/haskell.nix/hlint.materialized

181− cp -r /nix/store/ywdhbx9rzzkfc60c5vzk7cins2hnvkgx-hlint-plan-to-nix-pkgs /Users/hamish/iohk/haskell.nix/hlint.materialized

182− chmod -R +w /Users/hamish/iohk/haskell.nix/hlint.materialized

183−builder for '/nix/store/a5zmgfjfxahapw0q8hd2da5bg7knqvbx-hlint-plan-to-nix-pkgs.drv' failed with exit code 1

188+builder for '/nix/store/61a0vginv76w4p9ycyd628pjanav06pl-hlint-plan-to-nix-pkgs.drv' failed with exit code 1

184−error: build of '/nix/store/a5zmgfjfxahapw0q8hd2da5bg7knqvbx-hlint-plan-to-nix-pkgs.drv' failed

189+error: build of '/nix/store/61a0vginv76w4p9ycyd628pjanav06pl-hlint-plan-to-nix-pkgs.drv' failed

185(use '--show-trace' to show detailed location information)

190(use '--show-trace' to show detailed location information)

186```

191```

187

192

188−Checking the materialization requires nix to do all the work that materialization

193+Checking the materialization requires Nix to do all the work that

189−avoids. So while it might be tempting to leave `checkMaterialization = true` all

194+materialization avoids. So while it might be tempting to leave

195+`checkMaterialization = true` all the time, we would be better off just

190−the time, we would be better off just removing `materialized` and `plan-sha256`.

196+removing `materialized` and `plan-sha256`.

191

197

192−## How can we update the nix files with a script?

198+## How can we update the Nix files with a script?

193

199

194−There are versions of the functions (`project'`, `cabalProject'`,

200+We can simply put the commands we used earlier in a script:

195−`stackProject'` and `hackage-project`) that also return the nix as

196−`plan-nix` or `stack-nix`. By calling one of these functions without

197−the hash and materialized nix we can find out what nix files should be.

198−For instance:

199

201

200```nix

202```nix

201−let inherit (import ./. {}) sources nixpkgsArgs;

203+#!/bin/sh

202− pkgs = import sources.nixpkgs-default nixpkgsArgs;

203− hlint = pkgs.haskell-nix.hackage-project {

204− name = "hlint";

205− version = "2.2.10";

206− index-state = "2020-04-15T00:00:00Z";

207− };

208−in hlint

209−```

210

204

211−```

205+# Output new plan-sha256

212−$ nix-build hlint.nix -A plan-nix

206+nix-build hlint.nix -A project.plan-nix.passthru.calculateMaterializedSha | bash

213−trace: Using index-state: 2020-04-15T00:00:00Z for hlint

214−trace: Get `plan-sha256` with `nix-hash --base32 --type sha256 /nix/store/ywdhbx9rzzkfc60c5vzk7cins2hnvkgx-hlint-plan-to-nix-pkgs/`

215−/nix/store/ywdhbx9rzzkfc60c5vzk7cins2hnvkgx-hlint-plan-to-nix-pkgs

216−```

217

207

218−We can have the script copy `$(nix-build hlint.nix -A plan-nix --no-out-link)`

208+# Update materialized Nix expressions

219−and use `nix-hash` to calculate the new value for `plan-sha256`.

209+nix-build hlint.nix 2>&1 | grep -om1 '/nix/store/.*-updateMaterialized' | bash

210+```

220

211

221## Can we skip making a copy and use `materialized = /nix/store/...`?

212## Can we skip making a copy and use `materialized = /nix/store/...`?

222

213

@@ -225,41 +216,41 @@ Yes and it gives us the same speed improvement, however:

225* It does not help at all in `restricted-eval` mode (Hydra).

216* It does not help at all in `restricted-eval` mode (Hydra).

226

217

227* Users will still wind up building or downloading the dependencies

218* Users will still wind up building or downloading the dependencies

228− needed to build the nix fileds (if they do not have them).

219+ needed to build the Nix files (if they do not have them).

229

220

230For those reasons it might be best to make a copy instead

221For those reasons it might be best to make a copy instead

231of using the `/nix/store/...` path directly.

222of using the `/nix/store/...` path directly.

232

223

233If you really want to use the `/nix/store/...` path directly

224If you really want to use the `/nix/store/...` path directly

234−you should gaurd against the path not existing as passing in

225+you should guard against the path not existing as passing in

235a non-existing path is now an error:

226a non-existing path is now an error:

236

227

237```nix

228```nix

238let inherit (import ./. {}) sources nixpkgsArgs;

229let inherit (import ./. {}) sources nixpkgsArgs;

239− pkgs = import sources.nixpkgs-default nixpkgsArgs;

230+ pkgs = import sources.nixpkgs nixpkgsArgs;

240− hlintPlan = /nix/store/kk047cqsjvbj4w8psv4l05abdcnyrqdc-hlint-plan-to-nix-pkgs;

231+ hlintPlan = /nix/store/63k3f8bvsnag7v36vb3149208jyx61rk-hlint-plan-to-nix-pkgs;

241 hlint = pkgs.haskell-nix.hackage-package {

232 hlint = pkgs.haskell-nix.hackage-package {

233+ compiler-nix-name = "ghc8102";

242 name = "hlint";

234 name = "hlint";

243 version = "2.2.11";

235 version = "2.2.11";

244− index-state = "2020-04-15T00:00:00Z";

236+ index-state = "2021-01-04T00:00:00Z";

245− plan-sha256 = "02hasr27a994sml1fzf8swb716lm6lgixxr53y0gxkhw437xkck4";

237+ plan-sha256 = "04hdgqwpaswmyb0ili7fwi6czzihd6x0jlvivw52d1i7wv4gaqy7";

246 materialized = if __pathExists hlintPlan then hlintPlan else null;

238 materialized = if __pathExists hlintPlan then hlintPlan else null;

247 };

239 };

248−in hlint.components.exes.hlint

240+in hlint

249```

241```

250

242

251Running when no building is needed is still slow in restricted evaluation mode.

243Running when no building is needed is still slow in restricted evaluation mode.

252

244

253```

245```

254−$ time nix-build --option restrict-eval true -I . --option allowed-uris "https://github.com/NixOS https://github.com/input-output-hk" hlint.nix --show-trace

246+$ time nix-build --option restrict-eval true -I . --option allowed-uris "https://github.com/NixOS https://github.com/input-output-hk" hlint.nix -A components.exes.hlint --show-trace

255−trace: Using index-state: 2020-04-15T00:00:00Z for hlint

247+/nix/store/2ybrfmcp79gg75ad4pr1cbxjak70yg8b-hlint-exe-hlint-2.2.11

256−/nix/store/rnfz66v7k8i38c8rsmchzsyqjrmrbdpk-hlint-2.2.11-exe-hlint

257

248

258real 0m4.463s

249real 0m4.463s

259user 0m4.440s

250user 0m4.440s

260sys 0m0.461s

251sys 0m0.461s

261−$ time nix-build hlint.nix

252+$ time nix-build hlint.nix -A components.exes.hlint

262−/nix/store/rnfz66v7k8i38c8rsmchzsyqjrmrbdpk-hlint-2.2.11-exe-hlint

253+/nix/store/2ybrfmcp79gg75ad4pr1cbxjak70yg8b-hlint-exe-hlint-2.2.11

263

254

264real 0m2.206s

255real 0m2.206s

265user 0m1.665s

256user 0m1.665s

docs/tutorials/pkg-map.md+33−6

@@ -2,10 +2,11 @@

2

3Cabal files may contain dependencies to external non-Haskell

4dependencies via:

5+

5−* [`build-tool-depends`](https://cabal.readthedocs.io/en/latest/developing-packages.html#pkg-field-build-tool-depends)

6+* [`build-tool-depends`](https://cabal.readthedocs.io/en/latest/cabal-package.html#pkg-field-build-tool-depends)

6−* [`pkgconfig-depends`](https://cabal.readthedocs.io/en/latest/developing-packages.html#pkg-field-pkgconfig-depends).

7+* [`pkgconfig-depends`](https://cabal.readthedocs.io/en/latest/cabal-package.html#pkg-field-pkgconfig-depends)

7−* [`frameworks`](https://cabal.readthedocs.io/en/latest/developing-packages.html#pkg-field-frameworks)

8+* [`frameworks`](https://cabal.readthedocs.io/en/latest/cabal-package.html#pkg-field-frameworks)

8−* [`extra-libraries`](https://cabal.readthedocs.io/en/latest/developing-packages.html#pkg-field-extra-libraries)

9+* [`extra-libraries`](https://cabal.readthedocs.io/en/latest/cabal-package.html#pkg-field-extra-libraries)

9

10

10If there is a `pkgs` attribute in Nixpkgs that matches the name given

11If there is a `pkgs` attribute in Nixpkgs that matches the name given

11in the Cabal file, then it will be added as a dependency (see the

12in the Cabal file, then it will be added as a dependency (see the

@@ -28,13 +29,39 @@ nixpkgs.overlays = [

28];

29];

29```

30```

30

31

32+### Replace libraries of components

33+

34+If a component is missing a dependency it can be added via modules. For example:

35+

36+``` nix

37+project = pkgs.haskell-nix.project' {

38+ src = self;

39+ compiler-nix-name = "ghc8102";

40+ modules = [{

41+ # Replace `extra-libraries` dependencies

42+ packages.X11.components.library.libs = pkgs.lib.mkForce (with pkgs.xorg;

43+ [ libX11 libXrandr libXext libXScrnSaver libXinerama ]);

44+ }];

45+};

46+```

47+

31### Mapping in Haskell.nix

48### Mapping in Haskell.nix

32

49

33Alternatively, if the name is commonly used, an alias can be added to

50Alternatively, if the name is commonly used, an alias can be added to

34the Haskell.nix sources, so that it's solved for all users.

51the Haskell.nix sources, so that it's solved for all users.

35

52

36−* [`lib/pkgconf-nixpkgs-map.nix`](https://github.com/input-output-hk/haskell.nix/blob/master/lib/pkgconf-nixpkgs-map.nix) - for `pkgconfig-depends`

53+* [`lib/pkgconf-nixpkgs-map.nix`](https://github.com/input-output-hk/haskell.nix/blob/master/lib/pkgconf-nixpkgs-map.nix)

54+ — for `pkgconfig-depends`.

55+

56+ Each mapping entry is a list of packages.

57+

37−* [`lib/system-nixpkgs-map.nix`](https://github.com/input-output-hk/haskell.nix/blob/master/lib/system-nixpkgs-map.nix) - for `build-tool-depends`, `frameworks`, `extra-libraries`, etc.

58+* [`lib/system-nixpkgs-map.nix`](https://github.com/input-output-hk/haskell.nix/blob/master/lib/system-nixpkgs-map.nix)

59+ — for `build-tool-depends`, `frameworks`, `extra-libraries`, etc.

60+

61+ Each name can be mapped to:

62+ 1. A single package from nixkpgs.

63+ 2. `null` — eliminates the dependency

64+ 3. A list of packages — sometimes needed for dependencies such as `X11`.

38

65

39!!! tip "Open a PR"

66!!! tip "Open a PR"

40 Please go ahead and open a [pull request](https://github.com/input-output-hk/haskell.nix/pulls)

67 Please go ahead and open a [pull request](https://github.com/input-output-hk/haskell.nix/pulls)

docs/tutorials/source-repository-hashes.md+6−6

@@ -5,7 +5,7 @@ to git repositories containing the version of a particular package

5that we wish to use. This is mostly handled automatically by

6`nix-tools` and `haskell.nix` however when we want to use a nix

7system that is configured to use restricted mode (typically hydra)

8−it will need an aditionaly hash.

8+it will need additional hashes for the referenced repositories.

9

10When using `project`, `cabalProject` or `stackProject` functions

11you can include the hash needed in a comment.

@@ -50,12 +50,12 @@ extra-deps:

50 # nix-sha256: 003lm3pm024vhbfmii7xcdd9v2rczpflxf7gdl2pyxia7p014i8z

51```

52

53−## Avoding modifying cabal.project and stack.yaml

53+## Avoiding modifying cabal.project and stack.yaml

54

55−In some cases we cannot modify the `cabal.project` or `stack.yaml` file

55+In some cases we cannot modify the `cabal.project` or `stack.yaml` file to add

56−to add sha256 comments. As an alternative we can pass in a `sha256map`

56+sha256 comments. As an alternative we can pass in a `sha256map`. For instance,

57−For instance pandoc includes a `cabal.project` file in hackage includes a

57+pandoc includes a `cabal.project` file on hackage which includes a

58−`source-package-reference` to `pandoc-citeproc`:

58+`source-repository-package` stanza for `pandoc-citeproc`:

59

60```nix

61{ haskell-nix, testSrc } :

examples/Cabal-install-folder.diffdeleted−41

@@ -1,41 +0,0 @@

1−diff --git a/Distribution/Simple/GHC.hs b/Distribution/Simple/GHC.hs

2−index 547776046..176e59111 100644

3−--- a/Distribution/Simple/GHC.hs

4−+++ b/Distribution/Simple/GHC.hs

5−@@ -1,6 +1,7 @@

6− {-# LANGUAGE FlexibleContexts #-}

7− {-# LANGUAGE RankNTypes #-}

8− {-# LANGUAGE TupleSections #-}

9−+{-# LANGUAGE LambdaCase #-}

10− {-# LANGUAGE CPP #-}

11−

12− -----------------------------------------------------------------------------

13−@@ -1755,13 +1756,27 @@ installExe verbosity lbi binDir buildPref

14− let exeName' = unUnqualComponentName $ exeName exe

15− exeFileName = exeTargetName (hostPlatform lbi) exe

16− fixedExeBaseName = progprefix ++ exeName' ++ progsuffix

17−- installBinary dest = do

18−+ exePath = buildPref </> exeName' </> exeFileName

19−+ installBinary dest = doesFileExist exePath >>= \case

20−+ True -> do

21− installExecutableFile verbosity

22− (buildPref </> exeName' </> exeFileName)

23− (dest <.> exeExtension (hostPlatform lbi))

24− when (stripExes lbi) $

25− Strip.stripExe verbosity (hostPlatform lbi) (withPrograms lbi)

26− (dest <.> exeExtension (hostPlatform lbi))

27−+ False -> do

28−+ putStrLn "Hello!"

29−+ -- The executable exists but is not a simple file.

30−+ -- Deligate installation to the compiler

31−+ runDbProgram verbosity ghcProgram (withPrograms lbi) $

32−+ [ "--install-executable"

33−+ , buildPref </> exeName' </> exeFileName

34−+ , "-o", dest

35−+ ] ++

36−+ case (stripExes lbi, lookupProgram stripProgram $ withPrograms lbi) of

37−+ (True, Just strip) -> ["-strip-program", programPath strip]

38−+ _ -> []

39− installBinary (binDir </> fixedExeBaseName)

40−

41− -- |Install foreign library for GHC.

examples/cardano-sl-args.nixdeleted−150

@@ -1,150 +0,0 @@

1−let iohk-archive = name: hash: "https://github.com/input-output-hk/${name}/archive/${hash}.tar.gz";

2−in rec {

3− src = builtins.fetchTarball (iohk-archive "cardano-sl" "1a792d7cd0f0c93a0f0c28f66372bce3c3808dbd");

4− pkgs = [

5− "cardano-sl-crypto-test"

6− "cardano-sl-crypto"

7− "cardano-sl-cluster"

8− "cardano-sl-infra"

9− "cardano-sl-infra-test"

10− "cardano-sl-tools"

11− "cardano-sl-tools-post-mortem"

12− "cardano-sl-core"

13− "cardano-sl-core-test"

14− "cardano-sl-util-test"

15− "cardano-sl-util"

16− "cardano-sl-script-runner"

17− "cardano-sl-auxx"

18− "cardano-sl-networking"

19− "cardano-sl-explorer"

20− "cardano-sl-chain-test"

21− "cardano-sl-chain"

22− "cardano-sl-mnemonic"

23− "cardano-sl-generator"

24− "cardano-sl-x509"

25− "cardano-sl-utxo"

26− "cardano-sl-node-ipc"

27− "cardano-wallet"

28− "cardano-sl"

29− "cardano-sl-db-test"

30− "cardano-sl-db"

31− "cardano-sl-faucet"

32− "cardano-sl-binary-test"

33− "cardano-sl-binary"

34− "cardano-sl-node"

35− "cardano-sl-client"

36− ];

37− cache = [

38− { name = "cardano-crypto";

39− url = "https://github.com/input-output-hk/cardano-crypto";

40− rev = "4590efa638397e952a51a8994b5543e4ea3c1ecd";

41− sha256 = "0hl2n3bba5v2j0lmxhs7hs01z3aznh2bwf9cb434icq2g0bl8ms3"; }

42− { name = "haskell-ip";

43− cabal-file = "ip.cabal";

44− url = "https://github.com/andrewthad/haskell-ip";

45− rev = "9bb453139aa82cc973125091800422a523e1eb8f";

46− sha256 = "199mfpbgca7rvwvwk2zsmcpibc0sk0ni7c5zlf4gk3cps8s85gyr"; }

47− { name = "time-units";

48− url = "https://github.com/serokell/time-units.git";

49− rev = "6c3747c1ac794f952de996dd7ba8a2f6d63bf132";

50− sha256 = "0psdr1if0rgnn24698x3583m0603rwd3sd7yb9whj03hskmkwpgs";

51− }

52− { name = "kademlia";

53− url = "https://github.com/serokell/kademlia.git";

54− rev = "7120bb4d28e708acd52dfd61d3dca7914fac7d7f";

55− sha256 = "1k1wp9dwhzzqfivxc28vhxfqplnyh916crr7bhsiv829d6qifhw1";

56− }

57− { name = "network-transport";

58− url = "https://github.com/serokell/network-transport";

59− rev = "018a50b9042c2115c3ec9c9fd5ca5f28737dd29c";

60− sha256 = "0lqa26l2ikpq6a4s7qm9b2favx59w82i0wngakhfyax66fpixp8q";

61− }

62− { name = "network-transport-tcp";

63− url = "https://github.com/avieth/network-transport-tcp";

64− rev = "2634e5e32178bb0456d800d133f8664321daa2ef";

65− sha256 = "03shp9prflhgqzw7pymw1pq2q7s1wf46pyjm2csx8646snrhf35i";

66− }

67− { name = "network-transport-inmemory";

68− url = "https://github.com/avieth/network-transport-inmemory";

69− rev = "5d8ff2b07b9df35cf61329a3d975e2c8cf95c12a";

70− sha256 = "0ak64rks3lk3kk5wyndrrk2swmd84h9diribzix305xwz1jhjj9w";

71− }

72− { name = "acid-state";

73− url = "https://github.com/parsonsmatt/acid-state";

74− rev = "a1b23e2056f134e53f705a694ab85deeecabec5c";

75− sha256 = "0mgdk8252g7wbb0afyn21pcn3bwh4vainy3h2d0xsv4hlpgqgnw8";

76− }

77− { name = "socket-io";

78− url = "https://github.com/input-output-hk/engine.io";

79− rev = "d3c55f51bb81cee7d0d551de930ce65fe7d76756";

80− sha256 = "139c0yfnj57cpwg4k0am2rp35sh959394nvlb98011rjy68200qc";

81− subdir = "socket-io";

82− }

83− { name = "engine-io";

84− url = "https://github.com/input-output-hk/engine.io";

85− rev = "d3c55f51bb81cee7d0d551de930ce65fe7d76756";

86− sha256 = "139c0yfnj57cpwg4k0am2rp35sh959394nvlb98011rjy68200qc";

87− subdir = "engine-io";

88− }

89− { name = "engine-io-wai";

90− url = "https://github.com/input-output-hk/engine.io";

91− rev = "d3c55f51bb81cee7d0d551de930ce65fe7d76756";

92− sha256 = "139c0yfnj57cpwg4k0am2rp35sh959394nvlb98011rjy68200qc";

93− subdir = "engine-io-wai";

94− }

95− { name = "canonical-json";

96− url = "https://github.com/well-typed/canonical-json.git";

97− rev = "ddfe3593b80b5ceb88842bb7a6f2268df75d2c2f";

98− sha256 = "02fzn1xskis1lc1pkz0j92v6ipd89ww0k2p3dvwpm3yap5dpnm7k";

99− }

100− { name = "clock";

101− url = "https://github.com/corsis/clock.git";

102− rev = "ef60bd51a3587a173adf565c33bf2886df6e3842";

103− sha256 = "1r4n9imls483f7wd61fi1jk16z2k7w36gpx798sqidvwbnc831q1";

104− }

105− { name = "rocksdb-haskell-ng";

106− url = "https://github.com/input-output-hk/rocksdb-haskell-ng.git";

107− rev = "49f501a082d745f3b880677220a29cafaa181452";

108− sha256 = "02jvri8ik8jgrxwa6qmh3xcwqvm4s27iv3sxpjpny79nlhlxvfzp";

109− }

110− { name = "log-warper";

111− url = "https://github.com/input-output-hk/log-warper";

112− rev = "5271ab6c33541b8155ca203e714875974ec116be";

113− sha256 = "1h14004a8iwr8nw31pqq6kfdhfsyzzl8a50hrmj2acjqq6mbdl2m";

114− }

115− { name = "universum";

116− url = "https://github.com/input-output-hk/universum";

117− rev = "15f7db758ff5a24b874de2247f6f7a4576562da5";

118− sha256 = "127bs29zpjcc40777dv7figk05gd00b9ja57sp11w440qr5h72hk";

119− }

120− { name = "serokell-util";

121− url = "https://github.com/input-output-hk/serokell-util";

122− rev = "457f1d149c6e238841f283a1faf7bc8fb021b27d";

123− sha256 = "0llbryqna9p03db3ka4933vzf4jw1yxdbsf7cqi2pivsy1vp6kp0";

124− }

125− { name = "inspector";

126− url = "https://github.com/primetype/inspector.git";

127− rev = "c975f4329365f0379c04358138e616fb96fb0b79";

128− sha256 = "12q1v7a8kcw7qi4lws4j3mvxwfkhni6zmp870kmnkgbgwvrax9gs";

129− }

130− ];

131− # This is needed due to some deficiencies in stackage snapshots.

132− # maybe we should make this part of some `stack-default-pkg-def-extras`?

133− # We have similar logic in the snapshots.nix file to deal with this in

134− # snapshots.

135− #

136− # TODO: move this somewhere into stackProject

137− pkg-def-extras = [

138− (hackage: {

139− packages = {

140− "transformers" = (((hackage.transformers)."0.5.6.2").revisions).default;

141− "process" = (((hackage.process)."1.6.5.0").revisions).default;

142− };

143− })

144− (hackage: {

145− packages = {

146− "hsc2hs" = (((hackage.hsc2hs)."0.68.4").revisions).default;

147− };

148− })

149− ];

150−}

examples/cardano-sl-mingw32.nixdeleted−3

@@ -1,3 +0,0 @@

1−let inherit (import ../. {}) sources nixpkgsArgs;

2− pkgs = import sources.nixpkgs-default (nixpkgsArgs // { crossSystem.config = "x86_64-pc-mingw32"; });

3−in (pkgs.haskell-nix.stackProject (import ./cardano-sl-args.nix)).cardano-sl.components.all

examples/cardano-sl.nixdeleted−3

@@ -1,3 +0,0 @@

1−let inherit (import ../. {}) sources nixpkgsArgs;

2− pkgs = import sources.nixpkgs-default nixpkgsArgs;

3−in (pkgs.haskell-nix.stackProject (import ./cardano-sl-args.nix)).cardano-sl.components.all

examples/cardano-wallet-args.nixdeleted−103

@@ -1,103 +0,0 @@

1−let iohk-archive = name: hash: "https://github.com/input-output-hk/${name}/archive/${hash}.tar.gz";

2− src = builtins.fetchTarball (iohk-archive "cardano-wallet" "1fbd206bf6b368f08d603db130648ebd4efcedbc");

3− iohkLib = import (src + "/nix/iohk-common.nix") {};

4− jmPkgs = import (src + "/nix/jormungandr.nix") { inherit iohkLib; };

5−

6−in rec {

7− inherit src;

8− pkgs = [

9− "bech32"

10− "text-class"

11− "cardano-wallet-http-bridge"

12− "cardano-wallet-launcher"

13− "cardano-wallet-test-utils"

14− "cardano-wallet-core"

15− "cardano-wallet-jormungandr"

16− "cardano-wallet-cli"

17− "cardano-crypto"

18− "cardano-wallet-core-integration"

19− ];

20− # wee need these, as they are referenced in the stack.yaml file; however we can't

21− # fetch them at IFD time as they don't provide the sha256. Hence we use the cache-file

22− # facility on stack-to-nix and pre-populate the cache file with the relevant hashes.

23− cache = [

24− { name = "cardano-crypto";

25− url = "https://github.com/input-output-hk/cardano-crypto";

26− rev = "3c5db489c71a4d70ee43f5f9b979fcde3c797f2a";

27− sha256 = "0lss4x41m0ylhximqjc56ps0y3pag3x58wm480pzfa48lpk4gqpk"; }

28− { name = "persistent";

29− url = "https://github.com/input-output-hk/persistent";

30− rev = "107787ecc4c8a112375493cd66574f788f950fce";

31− sha256 = "1livmfslqzadir5sc523r111wrd14s5k2nmvsxayk45hx3nnngfb";

32− subdir = "persistent"; }

33− { name = "persistent-sqlite";

34− url = "https://github.com/input-output-hk/persistent";

35− rev = "107787ecc4c8a112375493cd66574f788f950fce";

36− sha256 = "1livmfslqzadir5sc523r111wrd14s5k2nmvsxayk45hx3nnngfb";

37− subdir = "persistent-sqlite"; }

38− { name = "persistent-template";

39− url = "https://github.com/input-output-hk/persistent";

40− rev = "107787ecc4c8a112375493cd66574f788f950fce";

41− sha256 = "1livmfslqzadir5sc523r111wrd14s5k2nmvsxayk45hx3nnngfb";

42− subdir = "persistent-template"; }

43− { name = "iohk-monitoring";

44− url = "https://github.com/input-output-hk/iohk-monitoring-framework";

45− rev = "bd31cd2f3922010ddb76bb869f29c4e63bb8001b";

46− subdir = "iohk-monitoring";

47− sha256 = "1dfk505qbpk6p3gcpxa31wmg98qvx9hlrxlf0khaj7hizf3b8b60"; }

48− { name = "contra-tracer";

49− url = "https://github.com/input-output-hk/iohk-monitoring-framework";

50− rev = "bd31cd2f3922010ddb76bb869f29c4e63bb8001b";

51− subdir = "contra-tracer";

52− sha256 = "1dfk505qbpk6p3gcpxa31wmg98qvx9hlrxlf0khaj7hizf3b8b60"; }

53− ];

54− # This is needed due to some deficiencies in stackage snapshots.

55− # maybe we should make this part of some `stack-default-pkg-def-extras`?

56− # We have similar logic in the snapshots.nix file to deal with this in

57− # snapshots.

58− #

59− # TODO: move this somewhere into stackProject

60− pkg-def-extras = [

61− (hackage: {

62− packages = {

63− "hsc2hs" = (((hackage.hsc2hs)."0.68.4").revisions).default;

64− };

65− })

66− ];

67−

68− modules = [

69− # Add dependencies

70− {

71− packages.cardano-wallet-jormungandr.components.tests = {

72− # Some tests want to write ~/.local/share/cardano-wallet

73− integration.preBuild = "export HOME=`pwd`";

74− # provide jormungandr command to test suites

75− integration.build-tools = [

76− jmPkgs.jormungandr

77− jmPkgs.jormungandr-cli

78− ];

79− unit.build-tools = [ jmPkgs.jormungandr ];

80− };

81−

82− packages.cardano-wallet-core.components.tests.unit.preBuild = ''

83− export SWAGGER_YAML=${src + "/specifications/api/swagger.yaml"}

84− '';

85− }

86−

87− # Misc. build fixes for dependencies

88− {

89− # Cut down iohk-monitoring deps

90− packages.iohk-monitoring.flags = {

91− disable-ekg = true;

92− disable-examples = true;

93− disable-graylog = true;

94− disable-gui = true;

95− disable-prometheus = true;

96− disable-systemd = true;

97− };

98−

99− # Katip has Win32 (>=2.3 && <2.6) constraint

100− packages.katip.doExactConfig = true;

101− }

102− ];

103−}

examples/cardano-wallet-ghcjs.nixdeleted−39

@@ -1,39 +0,0 @@

1−let inherit (import ../. {}) sources nixpkgsArgs;

2− pkgs = import sources.nixpkgs-default (nixpkgsArgs // { crossSystem.config = "js-unknown-ghcjs"; });

3− Cabal = pkgs.buildPackages.haskell-nix.hackage-package {

4− name = "Cabal"; version = "2.4.1.0";

5− modules = [

6− { packages.Cabal.patches = [ ./Cabal-install-folder.diff ]; }

7− ];

8−}; in

9−# (haskell-nix.stackProject {

10−# src = ../cardano-wallet;

11−# modules = [

12−# ({config, ... }:{ packages.hello.package.setup-depends = [ Cabal ]; })

13−# ];}).cardano-wallet.components.all

14−(let stack-pkgs = import ../cardano-wallet/flags-test/pkgs.nix;

15− in let pkg-set = pkgs.haskell-nix.mkStackPkgSet

16− { inherit stack-pkgs;

17− pkg-def-extras = [(hackage: {

18− packages = {

19− "transformers" = (((hackage.transformers)."0.5.6.2").revisions).default;

20− "process" = (((hackage.process)."1.6.5.0").revisions).default;

21− Win32 = hackage.Win32."2.8.3.0".revisions.default;

22− };

23− })

24− (hackage: {

25− packages = {

26− "hsc2hs" = (((hackage.hsc2hs)."0.68.4").revisions).default;

27− };

28− })];

29− modules = [

30− { packages.Cabal.patches = [ ./overlays/patches/Cabal/fix-data-dir.patch ]; }

31− { packages.alex.package.setup-depends = [pkg-set.config.hsPkgs.Cabal]; }

32− { packages.happy.package.setup-depends = [pkg-set.config.hsPkgs.Cabal]; }

33− { doHaddock = false; }

34− ];

35− # ++ (args.modules or [])

36− # ++ self.lib.optional (args ? ghc) { ghc.package = args.ghc; };

37− };

38− in pkg-set.config.hsPkgs

39−).cardano-wallet.components.all

examples/cardano-wallet-mingw32.nixdeleted−3

@@ -1,3 +0,0 @@

1−let inherit (import ../. {}) sources nixpkgsArgs;

2− pkgs = import sources.nixpkgs-default (nixpkgsArgs // { crossSystem.config = "x86_64-pc-mingw32"; });

3−in (pkgs.haskell-nix.stackProject (import ./cardano-wallet-args.nix)).cardano-wallet.components.all

examples/cardano-wallet-rpi.nixdeleted−39

@@ -1,39 +0,0 @@

1−let inherit (import ../. {}) sources nixpkgsArgs;

2− pkgs = import sources.nixpkgs-default (nixpkgsArgs // { crossSystem.config = "armv6l-unknown-linux-gnueabihf"; });

3− Cabal = pkgs.buildPackages.haskell-nix.hackage-package {

4− name = "Cabal"; version = "2.4.1.0";

5− modules = [

6− { packages.Cabal.patches = [ ./Cabal-install-folder.diff ]; }

7− ];

8−}; in

9−# (haskell-nix.stackProject {

10−# src = ../cardano-wallet;

11−# modules = [

12−# ({config, ... }:{ packages.hello.package.setup-depends = [ Cabal ]; })

13−# ];}).cardano-wallet.components.all

14−(let stack-pkgs = import ../cardano-wallet/flags-test/pkgs.nix;

15− in let pkg-set = pkgs.haskell-nix.mkStackPkgSet

16− { inherit stack-pkgs;

17− pkg-def-extras = [(hackage: {

18− packages = {

19− "transformers" = (((hackage.transformers)."0.5.6.2").revisions).default;

20− "process" = (((hackage.process)."1.6.5.0").revisions).default;

21− Win32 = hackage.Win32."2.8.3.0".revisions.default;

22− };

23− })

24− (hackage: {

25− packages = {

26− "hsc2hs" = (((hackage.hsc2hs)."0.68.4").revisions).default;

27− };

28− })];

29− modules = [

30− { packages.Cabal.patches = [ ./overlays/patches/Cabal/fix-data-dir.patch ]; }

31− { packages.alex.package.setup-depends = [pkg-set.config.hsPkgs.Cabal]; }

32− { packages.happy.package.setup-depends = [pkg-set.config.hsPkgs.Cabal]; }

33− { doHaddock = false; }

34− ];

35− # ++ (args.modules or [])

36− # ++ self.lib.optional (args ? ghc) { ghc.package = args.ghc; };

37− };

38− in pkg-set.config.hsPkgs

39−).cardano-wallet.components.all

examples/cardano-wallet.nixdeleted−3

@@ -1,3 +0,0 @@

1−let inherit (import ../. {}) sources nixpkgsArgs;

2− pkgs = import sources.nixpkgs-default nixpkgsArgs;

3−in (pkgs.haskell-nix.stackProject (import ./cardano-wallet-args.nix)).cardano-wallet.components.all

examples/plutus-args.nixdeleted−74

@@ -1,74 +0,0 @@

1−let iohk-archive = name: hash: "https://github.com/input-output-hk/${name}/archive/${hash}.tar.gz";

2−in rec {

3− src = builtins.fetchTarball (iohk-archive "plutus" "0d76e98ab267d621ad15002b5f824cad71797754");

4− pkgs = [

5− "language-plutus-core"

6− "plutus-core-interpreter"

7− "plutus-exe"

8− "plutus-ir"

9− "plutus-tx"

10− "plutus-use-cases"

11− "playground-common"

12− "marlowe"

13− "marlowe-playground-server"

14− "plutus-wallet-api"

15− "plutus-playground-server"

16− "plutus-playground-lib"

17− "plutus-tutorial"

18− "plutus-book"

19− "plutus-contract"

20− "plutus-emulator"

21− "deployment-server"

22− "iots-export"

23− "marlowe-symbolic"

24− ];

25− cache = [

26− { name = "row-types";

27− url = "https://github.com/target/row-types";

28− rev = "1e8d5e084ffd46f6c7842826a1f62c60820885df";

29− sha256 = "0ly5m4r8wkm8gdqyrqzsjfmp189yxsd4qp0zi3idrbgfaf45sk9k"; }

30− { name = "purescript-bridge";

31− url = "https://github.com/shmish111/purescript-bridge.git";

32− rev = "0042602f8a195b1fe185138f9ccca02020b8dd62";

33− sha256 = "1vl88g41f4vvgw9iyn7zd7i52qshpnk02z0y6czg4zy7wk3q12gz"; }

34− { name = "servant-purescript";

35− url = "https://github.com/shmish111/servant-purescript.git";

36− rev = "ece5d1dad16a5731ac22040075615803796c7c21";

37− sha256 = "1axcbsaym64q67hvjc7b3izd48cgqwi734l7f7m22jpdc80li5f6"; }

38− { name = "cardano-crypto";

39− url = "https://github.com/input-output-hk/cardano-crypto.git";

40− rev = "f5cecb6e424cc84f85b6a3e1f803517bb7b4cfb1";

41− sha256 = "1jyzai4sn9hi3p6r97h54f9a7an7vk38lwrbl4mds9zmdsw5f5ad"; }

42− { name = "unlit";

43− url = "https://github.com/michaelpj/unlit.git";

44− rev = "9ca1112093c5ffd356fc99c7dafa080e686dd748";

45− sha256 = "145sffn8gbdn6xp9q5b75yd3m46ql5bnc02arzmpfs6wgjslfhff"; }

46− { name = "prometheus";

47− url = "https://github.com/bitnomial/prometheus.git";

48− rev = "69e4cefeb7d04d61a54cb0ae9fd57e2de134badb";

49− sha256 = "0h836qp0ic587gfyfkj9a53p8rczja50sfy2y8ymx8wwkmq9zdgc"; }

50− { name = "github";

51− url = "https://github.com/shmish111/github.git";

52− rev = "cc27b9de4d5d0939235fa9a8b418de3ea4807bab";

53− sha256 = "0jx65x4c8s561nbxa0hv7mp8fvndfhs8i8gzxng7ym808n4n538i"; }

54− ];

55− # This is needed due to some deficiencies in stackage snapshots.

56− # maybe we should make this part of some `stack-default-pkg-def-extras`?

57− # We have similar logic in the snapshots.nix file to deal with this in

58− # snapshots.

59− #

60− # TODO: move this somewhere into stackProject

61− pkg-def-extras = [

62− (hackage: {

63− packages = {

64− "transformers" = (((hackage.transformers)."0.5.6.2").revisions).default;

65− "process" = (((hackage.process)."1.6.5.0").revisions).default;

66− };

67− })

68− (hackage: {

69− packages = {

70− "hsc2hs" = (((hackage.hsc2hs)."0.68.4").revisions).default;

71− };

72− })

73− ];

74−}

examples/plutus-mingw32.nixdeleted−3

@@ -1,3 +0,0 @@

1−let inherit (import ../. {}) sources nixpkgsArgs;

2− pkgs = import sources.nixpkgs-default (nixpkgsArgs // { crossSystem.config = "x86_64-pc-mingw32"; });

3−in (pkgs.haskell-nix.stackProject (import ./plutus-args.nix)).language-plutus-core.components.all

examples/plutus.nixdeleted−3

@@ -1,3 +0,0 @@

1−let inherit (import ../. {}) sources nixpkgsArgs;

2− pkgs = import sources.nixpkgs-default nixpkgsArgs;

3−in (pkgs.haskell-nix.stackProject (import ./plutus-args.nix)).language-plutus-core.components.all

flake.locknew file+396

@@ -0,0 +1,396 @@

1+{

2+ "nodes": {

3+ "HTTP": {

4+ "flake": false,

5+ "locked": {

6+ "lastModified": 1451647621,

7+ "narHash": "sha256-oHIyw3x0iKBexEo49YeUDV1k74ZtyYKGR2gNJXXRxts=",

8+ "owner": "phadej",

9+ "repo": "HTTP",

10+ "rev": "9bc0996d412fef1787449d841277ef663ad9a915",

11+ "type": "github"

12+ },

13+ "original": {

14+ "owner": "phadej",

15+ "repo": "HTTP",

16+ "type": "github"

17+ }

18+ },

19+ "cabal-32": {

20+ "flake": false,

21+ "locked": {

22+ "lastModified": 1603716527,

23+ "narHash": "sha256-X0TFfdD4KZpwl0Zr6x+PLxUt/VyKQfX7ylXHdmZIL+w=",

24+ "owner": "haskell",

25+ "repo": "cabal",

26+ "rev": "48bf10787e27364730dd37a42b603cee8d6af7ee",

27+ "type": "github"

28+ },

29+ "original": {

30+ "owner": "haskell",

31+ "ref": "3.2",

32+ "repo": "cabal",

33+ "type": "github"

34+ }

35+ },

36+ "cabal-34": {

37+ "flake": false,

38+ "locked": {

39+ "lastModified": 1640353650,

40+ "narHash": "sha256-N1t6M3/wqj90AEdRkeC8i923gQYUpzSr8b40qVOZ1Rk=",

41+ "owner": "haskell",

42+ "repo": "cabal",

43+ "rev": "942639c18c0cd8ec53e0a6f8d120091af35312cd",

44+ "type": "github"

45+ },

46+ "original": {

47+ "owner": "haskell",

48+ "ref": "3.4",

49+ "repo": "cabal",

50+ "type": "github"

51+ }

52+ },

53+ "cabal-36": {

54+ "flake": false,

55+ "locked": {

56+ "lastModified": 1641652457,

57+ "narHash": "sha256-BlFPKP4C4HRUJeAbdembX1Rms1LD380q9s0qVDeoAak=",

58+ "owner": "haskell",

59+ "repo": "cabal",

60+ "rev": "f27667f8ec360c475027dcaee0138c937477b070",

61+ "type": "github"

62+ },

63+ "original": {

64+ "owner": "haskell",

65+ "ref": "3.6",

66+ "repo": "cabal",

67+ "type": "github"

68+ }

69+ },

70+ "cardano-shell": {

71+ "flake": false,

72+ "locked": {

73+ "lastModified": 1608537748,

74+ "narHash": "sha256-PulY1GfiMgKVnBci3ex4ptk2UNYMXqGjJOxcPy2KYT4=",

75+ "owner": "input-output-hk",

76+ "repo": "cardano-shell",

77+ "rev": "9392c75087cb9a3d453998f4230930dea3a95725",

78+ "type": "github"

79+ },

80+ "original": {

81+ "owner": "input-output-hk",

82+ "repo": "cardano-shell",

83+ "type": "github"

84+ }

85+ },

86+ "flake-utils": {

87+ "locked": {

88+ "lastModified": 1644229661,

89+ "narHash": "sha256-1YdnJAsNy69bpcjuoKdOYQX0YxZBiCYZo4Twxerqv7k=",

90+ "owner": "numtide",

91+ "repo": "flake-utils",

92+ "rev": "3cecb5b042f7f209c56ffd8371b2711a290ec797",

93+ "type": "github"

94+ },

95+ "original": {

96+ "owner": "numtide",

97+ "repo": "flake-utils",

98+ "type": "github"

99+ }

100+ },

101+ "ghc-8.6.5-iohk": {

102+ "flake": false,

103+ "locked": {

104+ "lastModified": 1600920045,

105+ "narHash": "sha256-DO6kxJz248djebZLpSzTGD6s8WRpNI9BTwUeOf5RwY8=",

106+ "owner": "input-output-hk",

107+ "repo": "ghc",

108+ "rev": "95713a6ecce4551240da7c96b6176f980af75cae",

109+ "type": "github"

110+ },

111+ "original": {

112+ "owner": "input-output-hk",

113+ "ref": "release/8.6.5-iohk",

114+ "repo": "ghc",

115+ "type": "github"

116+ }

117+ },

118+ "hackage": {

119+ "flake": false,

120+ "locked": {

121+ "lastModified": 1659402819,

122+ "narHash": "sha256-1ghmulyIk+obGnyFeouVHBQXxUHMBmgCIRazLfEoT34=",

123+ "owner": "input-output-hk",

124+ "repo": "hackage.nix",

125+ "rev": "2f6f97ca3db96f91eea674ef46f4a0785d1e9d9c",

126+ "type": "github"

127+ },

128+ "original": {

129+ "owner": "input-output-hk",

130+ "repo": "hackage.nix",

131+ "type": "github"

132+ }

133+ },

134+ "hpc-coveralls": {

135+ "flake": false,

136+ "locked": {

137+ "lastModified": 1607498076,

138+ "narHash": "sha256-8uqsEtivphgZWYeUo5RDUhp6bO9j2vaaProQxHBltQk=",

139+ "owner": "sevanspowell",

140+ "repo": "hpc-coveralls",

141+ "rev": "14df0f7d229f4cd2e79f8eabb1a740097fdfa430",

142+ "type": "github"

143+ },

144+ "original": {

145+ "owner": "sevanspowell",

146+ "repo": "hpc-coveralls",

147+ "type": "github"

148+ }

149+ },

150+ "hydra": {

151+ "inputs": {

152+ "nix": "nix",

153+ "nixpkgs": [

154+ "hydra",

155+ "nix",

156+ "nixpkgs"

157+ ]

158+ },

159+ "locked": {

160+ "lastModified": 1646878427,

161+ "narHash": "sha256-KtbrofMtN8GlM7D+n90kixr7QpSlVmdN+vK5CA/aRzc=",

162+ "owner": "NixOS",

163+ "repo": "hydra",

164+ "rev": "28b682b85b7efc5cf7974065792a1f22203a5927",

165+ "type": "github"

166+ },

167+ "original": {

168+ "id": "hydra",

169+ "type": "indirect"

170+ }

171+ },

172+ "lowdown-src": {

173+ "flake": false,

174+ "locked": {

175+ "lastModified": 1633514407,

176+ "narHash": "sha256-Dw32tiMjdK9t3ETl5fzGrutQTzh2rufgZV4A/BbxuD4=",

177+ "owner": "kristapsdz",

178+ "repo": "lowdown",

179+ "rev": "d2c2b44ff6c27b936ec27358a2653caaef8f73b8",

180+ "type": "github"

181+ },

182+ "original": {

183+ "owner": "kristapsdz",

184+ "repo": "lowdown",

185+ "type": "github"

186+ }

187+ },

188+ "nix": {

189+ "inputs": {

190+ "lowdown-src": "lowdown-src",

191+ "nixpkgs": "nixpkgs",

192+ "nixpkgs-regression": "nixpkgs-regression"

193+ },

194+ "locked": {

195+ "lastModified": 1643066034,

196+ "narHash": "sha256-xEPeMcNJVOeZtoN+d+aRwolpW8mFSEQx76HTRdlhPhg=",

197+ "owner": "NixOS",

198+ "repo": "nix",

199+ "rev": "a1cd7e58606a41fcf62bf8637804cf8306f17f62",

200+ "type": "github"

201+ },

202+ "original": {

203+ "owner": "NixOS",

204+ "ref": "2.6.0",

205+ "repo": "nix",

206+ "type": "github"

207+ }

208+ },

209+ "nix-tools": {

210+ "flake": false,

211+ "locked": {

212+ "lastModified": 1658968505,

213+ "narHash": "sha256-UnbQ/Ig/23e9hUdDOBwYHwHgHmQawZ2uazpJ8DLIJgE=",

214+ "owner": "input-output-hk",

215+ "repo": "nix-tools",

216+ "rev": "8a754bdcf20b20e116409c2341cf69065d083053",

217+ "type": "github"

218+ },

219+ "original": {

220+ "owner": "input-output-hk",

221+ "repo": "nix-tools",

222+ "type": "github"

223+ }

224+ },

225+ "nixpkgs": {

226+ "locked": {

227+ "lastModified": 1632864508,

228+ "narHash": "sha256-d127FIvGR41XbVRDPVvozUPQ/uRHbHwvfyKHwEt5xFM=",

229+ "owner": "NixOS",

230+ "repo": "nixpkgs",

231+ "rev": "82891b5e2c2359d7e58d08849e4c89511ab94234",

232+ "type": "github"

233+ },

234+ "original": {

235+ "id": "nixpkgs",

236+ "ref": "nixos-21.05-small",

237+ "type": "indirect"

238+ }

239+ },

240+ "nixpkgs-2003": {

241+ "locked": {

242+ "lastModified": 1620055814,

243+ "narHash": "sha256-8LEHoYSJiL901bTMVatq+rf8y7QtWuZhwwpKE2fyaRY=",

244+ "owner": "NixOS",

245+ "repo": "nixpkgs",

246+ "rev": "1db42b7fe3878f3f5f7a4f2dc210772fd080e205",

247+ "type": "github"

248+ },

249+ "original": {

250+ "owner": "NixOS",

251+ "ref": "nixpkgs-20.03-darwin",

252+ "repo": "nixpkgs",

253+ "type": "github"

254+ }

255+ },

256+ "nixpkgs-2105": {

257+ "locked": {

258+ "lastModified": 1655034179,

259+ "narHash": "sha256-rf1/7AbzuYDw6+8Xvvf3PtEOygymLBrFsFxvext5ZjI=",

260+ "owner": "NixOS",

261+ "repo": "nixpkgs",

262+ "rev": "046ee4af7a9f016a364f8f78eeaa356ba524ac31",

263+ "type": "github"

264+ },

265+ "original": {

266+ "owner": "NixOS",

267+ "ref": "nixpkgs-21.05-darwin",

268+ "repo": "nixpkgs",

269+ "type": "github"

270+ }

271+ },

272+ "nixpkgs-2111": {

273+ "locked": {

274+ "lastModified": 1656782578,

275+ "narHash": "sha256-1eMCBEqJplPotTo/SZ/t5HU6Sf2I8qKlZi9MX7jv9fw=",

276+ "owner": "NixOS",

277+ "repo": "nixpkgs",

278+ "rev": "573603b7fdb9feb0eb8efc16ee18a015c667ab1b",

279+ "type": "github"

280+ },

281+ "original": {

282+ "owner": "NixOS",

283+ "ref": "nixpkgs-21.11-darwin",

284+ "repo": "nixpkgs",

285+ "type": "github"

286+ }

287+ },

288+ "nixpkgs-2205": {

289+ "locked": {

290+ "lastModified": 1657876628,

291+ "narHash": "sha256-URmf0O2cQ/3heg2DJOeLyU/JmfVMqG4X5t9crQXMaeY=",

292+ "owner": "NixOS",

293+ "repo": "nixpkgs",

294+ "rev": "549d82bdd40f760a438c3c3497c1c61160f3de55",

295+ "type": "github"

296+ },

297+ "original": {

298+ "owner": "NixOS",

299+ "ref": "nixpkgs-22.05-darwin",

300+ "repo": "nixpkgs",

301+ "type": "github"

302+ }

303+ },

304+ "nixpkgs-regression": {

305+ "locked": {

306+ "lastModified": 1643052045,

307+ "narHash": "sha256-uGJ0VXIhWKGXxkeNnq4TvV3CIOkUJ3PAoLZ3HMzNVMw=",

308+ "owner": "NixOS",

309+ "repo": "nixpkgs",

310+ "rev": "215d4d0fd80ca5163643b03a33fde804a29cc1e2",

311+ "type": "github"

312+ },

313+ "original": {

314+ "id": "nixpkgs",

315+ "rev": "215d4d0fd80ca5163643b03a33fde804a29cc1e2",

316+ "type": "indirect"

317+ }

318+ },

319+ "nixpkgs-unstable": {

320+ "locked": {

321+ "lastModified": 1657888067,

322+ "narHash": "sha256-GnwJoFBTPfW3+mz7QEeJEEQ9OMHZOiIJ/qDhZxrlKh8=",

323+ "owner": "NixOS",

324+ "repo": "nixpkgs",

325+ "rev": "65fae659e31098ca4ac825a6fef26d890aaf3f4e",

326+ "type": "github"

327+ },

328+ "original": {

329+ "owner": "NixOS",

330+ "ref": "nixpkgs-unstable",

331+ "repo": "nixpkgs",

332+ "type": "github"

333+ }

334+ },

335+ "old-ghc-nix": {

336+ "flake": false,

337+ "locked": {

338+ "lastModified": 1631092763,

339+ "narHash": "sha256-sIKgO+z7tj4lw3u6oBZxqIhDrzSkvpHtv0Kki+lh9Fg=",

340+ "owner": "angerman",

341+ "repo": "old-ghc-nix",

342+ "rev": "af48a7a7353e418119b6dfe3cd1463a657f342b8",

343+ "type": "github"

344+ },

345+ "original": {

346+ "owner": "angerman",

347+ "ref": "master",

348+ "repo": "old-ghc-nix",

349+ "type": "github"

350+ }

351+ },

352+ "root": {

353+ "inputs": {

354+ "HTTP": "HTTP",

355+ "cabal-32": "cabal-32",

356+ "cabal-34": "cabal-34",

357+ "cabal-36": "cabal-36",

358+ "cardano-shell": "cardano-shell",

359+ "flake-utils": "flake-utils",

360+ "ghc-8.6.5-iohk": "ghc-8.6.5-iohk",

361+ "hackage": "hackage",

362+ "hpc-coveralls": "hpc-coveralls",

363+ "hydra": "hydra",

364+ "nix-tools": "nix-tools",

365+ "nixpkgs": [

366+ "nixpkgs-unstable"

367+ ],

368+ "nixpkgs-2003": "nixpkgs-2003",

369+ "nixpkgs-2105": "nixpkgs-2105",

370+ "nixpkgs-2111": "nixpkgs-2111",

371+ "nixpkgs-2205": "nixpkgs-2205",

372+ "nixpkgs-unstable": "nixpkgs-unstable",

373+ "old-ghc-nix": "old-ghc-nix",

374+ "stackage": "stackage"

375+ }

376+ },

377+ "stackage": {

378+ "flake": false,

379+ "locked": {

380+ "lastModified": 1659402917,

381+ "narHash": "sha256-zRDOtN4A2KmfzmZiqqxOAIw1YVPhnoIaszKKd+qCEcQ=",

382+ "owner": "input-output-hk",

383+ "repo": "stackage.nix",

384+ "rev": "778df3c4b35eac853d57fac7bafc7c9f2dde917f",

385+ "type": "github"

386+ },

387+ "original": {

388+ "owner": "input-output-hk",

389+ "repo": "stackage.nix",

390+ "type": "github"

391+ }

392+ }

393+ },

394+ "root": "root",

395+ "version": 7

396+}

flake.nix+143−23

@@ -1,28 +1,148 @@

1{

2 description = "Alternative Haskell Infrastructure for Nixpkgs";

3

4− edition = 201909;

4+ inputs = {

5−

5+ nixpkgs.follows = "nixpkgs-unstable";

6− outputs = { self }: {

6+ nixpkgs-2003 = { url = "github:NixOS/nixpkgs/nixpkgs-20.03-darwin"; };

7− # Using the eval-on-build version here as the plan is that

7+ nixpkgs-2105 = { url = "github:NixOS/nixpkgs/nixpkgs-21.05-darwin"; };

8− # `builtins.currentSystem` will not be supported in flakes.

8+ nixpkgs-2111 = { url = "github:NixOS/nixpkgs/nixpkgs-21.11-darwin"; };

9− # https://github.com/NixOS/rfcs/pull/49/files#diff-a5a138ca225433534de8d260f225fe31R429

9+ nixpkgs-2205 = { url = "github:NixOS/nixpkgs/nixpkgs-22.05-darwin"; };

10− overlay = (self.overlays {}).combined-eval-on-build;

10+ nixpkgs-unstable = { url = "github:NixOS/nixpkgs/nixpkgs-unstable"; };

11− overlays = import ./overlays;

11+ flake-utils = { url = "github:numtide/flake-utils"; };

12− config = import ./config.nix;

12+ hydra.url = "hydra";

13− sources = import ./nixpkgs;

13+ hackage = {

14− nixpkgsArgs = {

14+ url = "github:input-output-hk/hackage.nix";

15− inherit (self) config;

15+ flake = false;

16− overlays = [ self.overlay ];

16+ };

17− };

17+ stackage = {

18− legacyPackages = let

18+ url = "github:input-output-hk/stackage.nix";

19− genAttrs = lst: f:

19+ flake = false;

20− builtins.listToAttrs (map (name: {

20+ };

21− inherit name;

21+ cabal-32 = {

22− value = f name;

22+ url = "github:haskell/cabal/3.2";

23− }) lst);

23+ flake = false;

24− in genAttrs [ "x86_64-linux" "x86_64-darwin" ] (system:

24+ };

25− import self.sources.nixpkgs-default

25+ cabal-34 = {

26− (self.nixpkgsArgs // { localSystem = { inherit system; }; }));

26+ url = "github:haskell/cabal/3.4";

27+ flake = false;

28+ };

29+ cabal-36 = {

30+ url = "github:haskell/cabal/3.6";

31+ flake = false;

32+ };

33+ cardano-shell = {

34+ url = "github:input-output-hk/cardano-shell";

35+ flake = false;

36+ };

37+ "ghc-8.6.5-iohk" = {

38+ type = "github";

39+ owner = "input-output-hk";

40+ repo = "ghc";

41+ ref = "release/8.6.5-iohk";

42+ flake = false;

43+ };

44+ hpc-coveralls = {

45+ url = "github:sevanspowell/hpc-coveralls";

46+ flake = false;

47+ };

48+ nix-tools = {

49+ url = "github:input-output-hk/nix-tools";

50+ flake = false;

51+ };

52+ old-ghc-nix = {

53+ url = "github:angerman/old-ghc-nix/master";

54+ flake = false;

55+ };

56+ HTTP = {

57+ url = "github:phadej/HTTP";

58+ flake = false;

59+ };

27 };

60 };

61+

62+ outputs = { self, nixpkgs, nixpkgs-unstable, nixpkgs-2105, nixpkgs-2111, nixpkgs-2205, flake-utils, ... }@inputs:

63+ let compiler = "ghc924";

64+ config = import ./config.nix;

65+ in {

66+ inherit config;

67+ overlay = self.overlays.combined;

68+ overlays = import ./overlays { sources = inputs; };

69+ internal = rec {

70+ nixpkgsArgs = {

71+ inherit config;

72+ overlays = [ self.overlay ];

73+ };

74+

75+ sources = inputs;

76+

77+ overlaysOverrideable = import ./overlays;

78+ # Compatibility with old default.nix

79+ compat = { checkMaterialization ?

80+ false # Allows us to easily switch on materialization checking

81+ , system, sourcesOverride ? { }, ... }@args: rec {

82+ sources = inputs // sourcesOverride;

83+ allOverlays = import ./overlays (args // { inherit sources; });

84+ inherit config;

85+ # We are overriding 'overlays' and 'nixpkgsArgs' from the

86+ # flake outputs so that we can incorporate the args passed

87+ # to the compat layer (e.g. sourcesOverride).

88+ overlays = [ allOverlays.combined ]

89+ ++ (if checkMaterialization == true then

90+ [

91+ (final: prev: {

92+ haskell-nix = prev.haskell-nix // {

93+ checkMaterialization = true;

94+ };

95+ })

96+ ]

97+ else

98+ [ ]);

99+ nixpkgsArgs = {

100+ inherit config overlays;

101+ };

102+ pkgs = import nixpkgs

103+ (nixpkgsArgs // { localSystem = { inherit system; }; });

104+ pkgs-2105 = import nixpkgs-2105

105+ (nixpkgsArgs // { localSystem = { inherit system; }; });

106+ pkgs-2111 = import nixpkgs-2111

107+ (nixpkgsArgs // { localSystem = { inherit system; }; });

108+ pkgs-2205 = import nixpkgs-2205

109+ (nixpkgsArgs // { localSystem = { inherit system; }; });

110+ pkgs-unstable = import nixpkgs-unstable

111+ (nixpkgsArgs // { localSystem = { inherit system; }; });

112+ hix = import ./hix/default.nix { inherit pkgs; };

113+ };

114+ };

115+

116+ # Note: `nix flake check` evaluates outputs for all platforms, and haskell.nix

117+ # uses IFD heavily, you have to have the ability to build for all platforms

118+ # supported by haskell.nix, e.g. with remote builders, in order to check this flake.

119+ # If you want to run the tests for just your platform, run `./test/tests.sh` or

120+ # `nix-build -A checks.$PLATFORM`

121+ } // flake-utils.lib.eachSystem [ "x86_64-linux" "x86_64-darwin" "aarch64-linux" "aarch64-darwin" ] (system: rec {

122+ legacyPackages = (self.internal.compat { inherit system; }).pkgs;

123+ legacyPackagesUnstable = (self.internal.compat { inherit system; }).pkgs-unstable;

124+

125+ # FIXME: Currently `nix flake check` requires `--impure` because coverage-golden

126+ # (and maybe other tests) import projects that use builtins.currentSystem

127+ checks = builtins.listToAttrs (map (pkg: {

128+ name = pkg.name;

129+ value = pkg;

130+ }) (nixpkgs.lib.collect nixpkgs.lib.isDerivation (import ./test rec {

131+ haskellNix = self.internal.compat { inherit system; };

132+ compiler-nix-name = compiler;

133+ pkgs = haskellNix.pkgs;

134+ })));

135+ # Exposed so that buildkite can check that `allow-import-from-derivation=false` works for core of haskell.nix

136+ roots = legacyPackagesUnstable.haskell-nix.roots compiler;

137+

138+ devShell = with self.legacyPackages.${system};

139+ mkShell {

140+ buildInputs = [

141+ nixUnstable

142+ cabal-install

143+ haskell-nix.compiler.${compiler}

144+ haskell-nix.nix-tools.${compiler}

145+ ];

146+ };

147+ });

28}

148}

hackage-src.json+7−4

@@ -1,7 +1,10 @@

1{

2 "url": "https://github.com/input-output-hk/hackage.nix",

3− "rev": "7d25e265119d93663868b4a92e52d38b735dbda2",

3+ "rev": "9bdefa51c864bbef48a2758b05b4b568f0ded62b",

4− "date": "2020-06-21T01:33:53+00:00",

4+ "date": "2021-08-06T01:11:48+00:00",

5− "sha256": "0xdchjl15lv5ji7i1wwn271hqwcpp13dihcqjn228mpn1dm9igv1",

5+ "path": "/nix/store/isypgnv4qa5398z6vjc3fi620l4y87c4-hackage.nix-9bdefa5",

6− "fetchSubmodules": false

6+ "sha256": "0pm3m864wwgf76isjwb8244xh8xykc94b5az6zb1h38q30s9xjji",

7+ "fetchSubmodules": false,

8+ "deepClone": false,

9+ "leaveDotGit": false

7}

10}

hix/default.nixnew file+43

@@ -0,0 +1,43 @@

1+{ pkgs }:

2+let

3+ args = '' --arg userDefaults "$HOME/.config/hix/hix.conf" --arg src ./.'';

4+ # Use HIX_ROOT to override the version of hix used when developing new hix features.

5+ # See docs/dev/hix.md for details.

6+ hixProject = "\${HIX_ROOT:-${./..}}/hix/project.nix";

7+in pkgs.symlinkJoin {

8+ name = "hix";

9+ paths = [

10+ (pkgs.writeScriptBin "hix-shell" ''

11+ nix-shell ${hixProject} ${args} -A shell "$@"

12+ '')

13+ (pkgs.writeScriptBin "hix-build" ''

14+ nix-build ${hixProject} ${args} "$@"

15+ '')

16+ (pkgs.writeScriptBin "hix-instantiate" ''

17+ nix-instantiate ${hixProject} ${args} "$@"

18+ '')

19+ (pkgs.writeScriptBin "hix-env" ''

20+ nix-env -f ${hixProject} ${args} "$@"

21+ '')

22+ (pkgs.writeScriptBin "hix" ''

23+ cmd=$1

24+ shift

25+ case $cmd in

26+ update)

27+ nix-env -iA hix -f https://github.com/input-output-hk/haskell.nix/tarball/master

28+ ;;

30+ nix $cmd -f ${hixProject} ${args} "$@"

31+ ;;

32+ repl)

33+ nix $cmd ${hixProject} ${args} "$@"

34+ ;;

35+ *)

36+ nix $cmd "$@"

37+ ;;

38+ esac

39+ '')

40+ ];

41+} // {

42+ project = import ./project.nix;

43+}

hix/project.nixnew file+77

@@ -0,0 +1,77 @@

1+{ src

2+, userDefaults ? {}

3+, nixpkgs ? null

4+, nixpkgsPin ? null

5+, pkgs ? null

6+, checkMaterialization ? null

7+, compiler-nix-name ? null

8+, shell ? null

9+, ...}@commandArgs:

10+let

11+ inherit ((lib.evalModules {

12+ modules = [

13+ (import ../modules/project-common.nix)

14+ (import ../modules/stack-project.nix)

15+ (import ../modules/cabal-project.nix)

16+ (import ../modules/project.nix)

17+ (import ../modules/hix-project.nix)

18+ projectDefaults

19+ commandArgs'

20+ { _module.args.pkgs = {}; }

21+ ];

22+ }).config) name;

23+ inherit (import ./.. {}) sources;

24+ lib = import (sources.nixpkgs-unstable + "/lib");

25+ commandArgs' =

26+ builtins.listToAttrs (

27+ builtins.concatMap (

28+ name:

29+ if commandArgs.${name} == null || name == "src" || name == "userDefaults" || name == "inNixShell"

30+ then []

31+ else [{ inherit name; value = commandArgs.${name}; }]

32+ ) (builtins.attrNames commandArgs));

33+ defaultArgs = {

34+ nixpkgsPin = "nixpkgs-unstable";

35+ };

36+ importDefaults = src:

37+ if src == null || !(__pathExists src)

38+ then {}

39+ else import src;

40+ userDefaults = importDefaults (commandArgs.userDefaults or null);

41+ projectDefaults = importDefaults (toString (src.origSrcSubDir or src) + "/nix/hix.nix");

42+ inherit ((lib.evalModules {

43+ modules = [

44+ (import ../modules/project-common.nix)

45+ (import ../modules/stack-project.nix)

46+ (import ../modules/cabal-project.nix)

47+ (import ../modules/project.nix)

48+ (import ../modules/hix-project.nix)

49+ userDefaults

50+ projectDefaults

51+ commandArgs'

52+ ({config, pkgs, ...}: {

53+ haskellNix = import ./.. { inherit checkMaterialization; };

54+ nixpkgsPin = "nixpkgs-unstable";

55+ nixpkgs = config.haskellNix.sources.${config.nixpkgsPin};

56+ nixpkgsArgs = config.haskellNix.nixpkgsArgs // {

57+ overlays = config.haskellNix.nixpkgsArgs.overlays ++ config.overlays;

58+ };

59+ _module.args.pkgs = import config.nixpkgs config.nixpkgsArgs;

60+ project = pkgs.haskell-nix.project [

61+ (import ../modules/hix-project.nix)

62+ userDefaults

63+ projectDefaults

64+ commandArgs'

65+ ({config, ...}: {

66+ src =

67+ if __pathExists (toString (src.origSrcSubDir or src) + "/.git")

68+ then config.evalPackages.haskell-nix.haskellLib.cleanGit {

69+ inherit src name;

70+ }

71+ else src;

72+ })

73+ ];

74+ })

75+ ];

76+ }).config) project shell;

77+in project

lib/cabal-licenses.nix+18−20

@@ -1,23 +1,21 @@

1−lib: with lib.licenses;

1+pkgs:

2−{ BSD-3-Clause = bsd3;

2+let licenses = import spdx/licenses.nix pkgs;

3− BSD-2-Clause = bsd2;

3+in licenses // {

4− MIT = mit;

5− "MPL-2.0" = mpl20;

6− ISC = isc;

7− "LGPL-2.1-only" = lgpl21;

8− "LGPL-3.0-only" = lgpl3;

9− "GPL-2.0-only" = gpl2;

10− "GPL-2.0-or-later" = gpl2Plus;

11− "GPL-3.0-only" = gpl3;

12− "AGPL-3.0-only" = agpl3;

13− "AGPL-3.0-or-later" = agpl3Plus;

14− "Apache-2.0" = asl20;

15 # Generic

4 # Generic

16− LicenseRef-Apache = "Apache";

5+ LicenseRef-PublicDomain = {

17− LicenseRef-GPL = "GPL";

6+ spdxId = "LicenseRef-PublicDomain";

18− LicenseRef-LGPL = "LGPL";

7+ shortName = "Public Domain";

19− LicenseRef-NCSA = ncsa;

8+ fullName = "This work is dedicated to the Public Domain";

20− LicenseRef-PublicDomain = publicDomain;

9+ url = "https://wikipedia.org/wiki/Public_domain";

21− LicenseRef-OtherLicense = null;

10+ free = true;

11+ };

12+ LicenseRef-OtherLicense = {

13+ spdxId = "LicenseRef-OtherLicense";

14+ shortName = "Other License";

15+ fullName = "Unidentified Other License";

16+ url = "https://spdx.github.io/spdx-spec/appendix-IV-SPDX-license-expressions/";

17+ # Not setting `free` here. The license may or may not be `free`.

18+ # See https://github.com/input-output-hk/haskell.nix/pull/1006

19+ };

22 NONE = null;

20 NONE = null;

23}

21}

lib/cabal-os-arch-comp.nix+1−1

@@ -43,7 +43,7 @@

43 isPPC64 = false;

44 isSparc = false;

45 isArm = false;

46− isAArch64= false;

46+ isAarch64= false;

47 isMips = false;

48 isSH = false;

49 isIA64 = false;

lib/cabal-project-parser.nixnew file+213

@@ -0,0 +1,213 @@

1+{ pkgs }:

2+let

3+ span = pred: list:

4+ let n = pkgs.lib.lists.foldr (x: acc: if pred x then acc + 1 else 0) 0 list;

5+ in { fst = pkgs.lib.lists.take n list; snd = pkgs.lib.lists.drop n list; };

6+

7+ # Look for a index-state: field in the cabal.project file

8+ parseIndexState = rawCabalProject:

9+ let

10+ indexState = pkgs.lib.lists.concatLists (

11+ pkgs.lib.lists.filter (l: l != null)

12+ (builtins.map (l: builtins.match "^index-state: *(.*)" l)

13+ (pkgs.lib.splitString "\n" rawCabalProject)));

14+ in

15+ pkgs.lib.lists.head (indexState ++ [ null ]);

16+

17+ # Remove the indentation of the first line from all the lines

18+ unindent = blockLines: (pkgs.lib.foldl' ({matchString, out}: s:

19+ let

20+ m = builtins.match matchString s;

21+ in

22+ if m != null

23+ then {

24+ matchString = "(${builtins.head m})(.*)";

25+ out = out ++ [(builtins.elemAt m 1)];

26+ }

27+ else {

28+ inherit matchString out;

29+ }

30+ ) { matchString = "( *)(.*)"; out = []; } blockLines).out;

31+

32+ # Strip comments except `--sha256`

33+ stripComments = blockLines: pkgs.lib.filter (s: s != "") (

34+ pkgs.lib.foldl' (out: s:

35+ let

36+ m = builtins.match "(.*)--.*" s;

37+ in

38+ if !(pkgs.lib.hasPrefix "--sha256" s) && m != null

39+ then out ++ [(builtins.head m)]

40+ else out ++ [s]

41+ ) [] blockLines

42+ );

43+

44+ # Parse lines of a source-repository-package block

45+ parseBlockLines = blockLines: (pkgs.lib.foldl' ({name, attrs}: s:

46+ let

47+ # Look for a new attribute name

48+ pair = builtins.match "([^ :]*): *(.*)" s;

49+

50+ # Function to build the next parse state when the attribute name is known

51+ nextState = name: value: {

52+ inherit name;

53+ # Support multi line attributes by appending the value to the named attribute

54+ attrs = attrs // {

55+ ${name} =

56+ if attrs ? ${name}

57+ then attrs.${name} + " " + value

58+ else value;

59+ };

60+ };

61+ in

62+ if pair != null

63+ then

64+ # First line of a new attribute

65+ nextState (builtins.head pair) (builtins.elemAt pair 1)

66+ else

67+ if name != null

68+ then nextState name s # Append another line to the current attribute

69+ else __trace "Expected attribute but found `${s}`" { inherit name attrs; }

70+ ) { name = null; attrs = {}; } (stripComments (unindent blockLines))).attrs;

71+

72+ # Gets data for all the repositories to fetch

73+ # A comment like

74+ # --shar256: 003lm3pm0000hbfmii7xcdd9v20000flxf7gdl2pyxia7p014i8z

75+ # will be trated like a field and returned here

76+ # (used in call-cabal-project-to-nix.nix to create a fixed-output derivation)

77+ extractSourceRepoPackageData = cabalProjectFileName: sha256map: repo: {

78+ url = repo.location;

79+ ref = repo.tag;

80+ sha256 = repo."--sha256" or (

81+ if sha256map != null

82+ then sha256map."${repo.location}"."${repo.tag}"

83+ else null);

84+ subdirs = if repo ? subdir

85+ then pkgs.lib.filter (x: x != "") (pkgs.lib.splitString " " repo.subdir)

86+ else ["."];

87+ };

88+

89+ # Parse a source-repository-package and return data of `type: git` repositories

90+ # See tests/unit.nix for examples of input and output.

91+ parseSourceRepositoryPackageBlock = cabalProjectFileName: sha256map: block:

92+ let

93+ x = span (pkgs.lib.strings.hasPrefix " ") (pkgs.lib.splitString "\n" block);

94+ attrs = parseBlockLines x.fst;

95+ in

96+ if attrs."type" or "" != "git"

97+ then {

98+ sourceRepo = [];

99+ otherText = "\nsource-repository-package\n" + block;

100+ }

101+ else {

102+ sourceRepo = extractSourceRepoPackageData cabalProjectFileName sha256map attrs;

103+ otherText = pkgs.lib.strings.concatStringsSep "\n" x.snd;

104+ };

105+

106+ parseSourceRepositoryPackages = cabalProjectFileName: sha256map: source-repo-override: projectFile:

107+ let

108+ blocks = pkgs.lib.splitString "\nsource-repository-package\n" ("\n" + projectFile);

109+ initialText = pkgs.lib.lists.take 1 blocks;

110+ repoBlocks = builtins.map (parseSourceRepositoryPackageBlock cabalProjectFileName sha256map) (pkgs.lib.lists.drop 1 blocks);

111+ overrideSourceRepo = sourceRepo: (source-repo-override.${sourceRepo.url} or (pkgs.lib.id)) sourceRepo;

112+ in {

113+ sourceRepos = pkgs.lib.lists.map (block: overrideSourceRepo block.sourceRepo) repoBlocks;

114+ otherText = pkgs.lib.strings.concatStringsSep "\n" (

115+ initialText

116+ ++ (builtins.map (x: x.otherText) repoBlocks));

117+ };

118+

119+ # Parse and replace repository

120+ # This works in a similar way to the `source-repository-package` but we are

121+ # able to simply replace the `repository` blocks with local `file:/nix/store` ones.

122+ # This works because `cabal configure` does not include any of the `/nix/sore/`

123+ # paths in the `plan.json` (so materialized plan-nix will still work as expeced).

124+ # See tests/unit.nix for examples of input and output.

125+ parseRepositoryBlock = evalPackages: cabalProjectFileName: sha256map: inputMap: cabal-install: nix-tools: block:

126+ let

127+ lines = pkgs.lib.splitString "\n" block;

128+ # The first line will contain the repository name.

129+ x = span (pkgs.lib.strings.hasPrefix " ") (__tail lines);

130+ attrs = parseBlockLines x.fst;

131+ sha256 = attrs."--sha256" or (

132+ if sha256map != null

133+ then sha256map."${attrs.url}"

134+ else null);

135+ in rec {

136+ # This is `some-name` from the `repository some-name` line in the `cabal.project` file.

137+ name = __head lines;

138+ # The $HOME/.cabal/packages/${name} after running `cabal v2-update` to download the repository

139+ repoContents = if inputMap ? ${attrs.url}

140+ # If there is an input use it to make `file:` url and create a suitable `.cabal/packages/${name}` directory

141+ then evalPackages.runCommand name ({

142+ nativeBuildInputs = [ cabal-install ];

143+ preferLocalBuild = true;

144+ }) ''

145+ HOME=$(mktemp -d)

146+ mkdir -p $HOME/.cabal/packages/${name}

147+ cat <<EOF > $HOME/.cabal/config

148+ repository ${name}

149+ url: file:${inputMap.${attrs.url}}

150+ ${pkgs.lib.optionalString (attrs ? secure) "secure: ${attrs.secure}"}

151+ ${pkgs.lib.optionalString (attrs ? root-keys) "root-keys: ${attrs.root-keys}"}

152+ ${pkgs.lib.optionalString (attrs ? key-threshold) "key-threshold: ${attrs.key-threshold}"}

153+ EOF

154+

155+ cabal v2-update ${name}

156+ cp -r $HOME/.cabal/packages/${name} $out

157+ ''

158+ else evalPackages.runCommand name ({

159+ nativeBuildInputs = [ cabal-install evalPackages.curl nix-tools ];

160+ LOCALE_ARCHIVE = pkgs.lib.optionalString (evalPackages.stdenv.buildPlatform.libc == "glibc") "${evalPackages.glibcLocales}/lib/locale/locale-archive";

161+ LANG = "en_US.UTF-8";

162+ preferLocalBuild = true;

163+ } // pkgs.lib.optionalAttrs (sha256 != null) {

164+ outputHashMode = "recursive";

165+ outputHashAlgo = "sha256";

166+ outputHash = sha256;

167+ }) ''

168+ HOME=$(mktemp -d)

169+ mkdir -p $HOME/.cabal/packages/${name}

170+ cat <<EOF > $HOME/.cabal/config

171+ repository ${name}

172+ url: ${attrs.url}

173+ ${pkgs.lib.optionalString (attrs ? secure) "secure: ${attrs.secure}"}

174+ ${pkgs.lib.optionalString (attrs ? root-keys) "root-keys: ${attrs.root-keys}"}

175+ ${pkgs.lib.optionalString (attrs ? key-threshold) "key-threshold: ${attrs.key-threshold}"}

176+ EOF

177+

178+ export SSL_CERT_FILE=${evalPackages.cacert}/etc/ssl/certs/ca-bundle.crt

179+ cabal v2-update ${name}

180+ cp -r $HOME/.cabal/packages/${name} $out

181+ '';

182+ # Output of hackage-to-nix

183+ hackage = import (

184+ evalPackages.runCommand ("hackage-to-nix-" + name) {

185+ nativeBuildInputs = [ cabal-install evalPackages.curl nix-tools ];

186+ LOCALE_ARCHIVE = pkgs.lib.optionalString (evalPackages.stdenv.buildPlatform.libc == "glibc") "${evalPackages.glibcLocales}/lib/locale/locale-archive";

187+ LANG = "en_US.UTF-8";

188+ preferLocalBuild = true;

189+ } ''

190+ mkdir -p $out

191+ hackage-to-nix $out ${repoContents}/01-index.tar ${attrs.url}

192+ '');

193+ # Directory to `lndir` when constructing a suitable $HOME/.cabal dir

194+ repo = {

195+ ${name} = repoContents;

196+ };

197+ };

198+

199+ parseRepositories = evalPackages: cabalProjectFileName: sha256map: inputMap: cabal-install: nix-tools: projectFile:

200+ let

201+ # This will leave the name of repository in the first line of each block

202+ blocks = pkgs.lib.splitString "\nrepository " ("\n" + projectFile);

203+ repoBlocks = builtins.map (parseRepositoryBlock evalPackages cabalProjectFileName sha256map inputMap cabal-install nix-tools) (pkgs.lib.lists.drop 1 blocks);

204+ in {

205+ extra-hackages = pkgs.lib.lists.map (block: block.hackage) repoBlocks;

206+ repos = pkgs.lib.lists.foldl' (x: block: x // block.repo) {} repoBlocks;

207+ };

208+

209+in {

210+ inherit parseIndexState parseSourceRepositoryPackages parseRepositories

211+ # These are only exposed for tests

212+ parseSourceRepositoryPackageBlock parseRepositoryBlock;

213+}

lib/call-cabal-project-to-nix.nix+314−166

@@ -1,4 +1,4 @@

1−{ dotCabal, pkgs, runCommand, nix-tools, cabal-install, ghc, hpack, symlinkJoin, cacert, index-state-hashes, haskellLib, materialize }@defaults:

1+{ pkgs, runCommand, cacert, index-state-hashes, haskellLib }@defaults:

2let readIfExists = src: fileName:

3 let origSrcDir = src.origSrcSubDir or src;

4 in

@@ -8,6 +8,7 @@ let readIfExists = src: fileName:

8in

9{ name ? src.name or null # optional name for better error messages

10, src

11+, compiler-nix-name # The name of the ghc compiler to use eg. "ghc884"

11, index-state ? null # Hackage index-state, eg. "2019-10-10T00:00:00Z"

12, index-state ? null # Hackage index-state, eg. "2019-10-10T00:00:00Z"

12, index-sha256 ? null # The hash of the truncated hackage index-state

13, index-sha256 ? null # The hash of the truncated hackage index-state

13, plan-sha256 ? null # The hash of the plan-to-nix output (makes the plan-to-nix step a fixed output derivation)

14, plan-sha256 ? null # The hash of the plan-to-nix output (makes the plan-to-nix step a fixed output derivation)

@@ -17,33 +18,71 @@ in

17, cabalProject ? readIfExists src cabalProjectFileName

18, cabalProject ? readIfExists src cabalProjectFileName

18, cabalProjectLocal ? readIfExists src "${cabalProjectFileName}.local"

19, cabalProjectLocal ? readIfExists src "${cabalProjectFileName}.local"

19, cabalProjectFreeze ? readIfExists src "${cabalProjectFileName}.freeze"

20, cabalProjectFreeze ? readIfExists src "${cabalProjectFileName}.freeze"

20−, compiler-nix-name ? null # Nix name of the ghc compiler as a string eg. "ghc883"

21+, caller ? "callCabalProjectToNix" # Name of the calling function for better warning messages

21, ghc ? null # Deprecated in favour of `compiler-nix-name`

22, ghc ? null # Deprecated in favour of `compiler-nix-name`

22, ghcOverride ? null # Used when we need to set ghc explicitly during bootstrapping

23, ghcOverride ? null # Used when we need to set ghc explicitly during bootstrapping

23−, nix-tools ? defaults.nix-tools

24−, hpack ? defaults.hpack

25−, cabal-install ? defaults.cabal-install

26, configureArgs ? "" # Extra arguments to pass to `cabal v2-configure`.

24, configureArgs ? "" # Extra arguments to pass to `cabal v2-configure`.

27 # `--enable-tests --enable-benchmarks` are included by default.

25 # `--enable-tests --enable-benchmarks` are included by default.

28 # If the tests and benchmarks are not needed and they

26 # If the tests and benchmarks are not needed and they

29− # causes the wrong plan to be choosen, then we can use

27+ # cause the wrong plan to be chosen, then we can use

30 # `configureArgs = "--disable-tests --disable-benchmarks";`

28 # `configureArgs = "--disable-tests --disable-benchmarks";`

31, sha256map ? null

29, sha256map ? null

32 # An alternative to adding `--sha256` comments into the

30 # An alternative to adding `--sha256` comments into the

33 # cabal.project file:

31 # cabal.project file:

34 # sha256map =

32 # sha256map =

35− # { "https://github.com/jgm/pandoc-citeproc"."0.17"

33+ # { # For a `source-repository-package` use the `location` and `tag` as the key

36− # = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q"; };

34+ # "https://github.com/jgm/pandoc-citeproc"."0.17"

37−, lookupSha256 ?

35+ # = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q";

38− if sha256map != null

36+ # # For a `repository` use the `url` as the key

39− then { location, tag, ...}: sha256map."${location}"."${tag}"

37+ # "https://raw.githubusercontent.com/input-output-hk/hackage-overlay-ghcjs/bfc363b9f879c360e0a0460ec0c18ec87222ec32"

40− else _: null

38+ # = "sha256-g9xGgJqYmiczjxjQ5JOiK5KUUps+9+nlNGI/0SpSOpg=";

41−, extra-hackage-tarballs ? []

39+ # };

40+, inputMap ? {}

41+ # An alternative to providing a `sha256` handy for flakes

42+ # cabal.project file:

43+ # inputs.pandoc-citeproc.url = "github:jgm/pandoc-citeproc/0.17";

44+ # inputs.pandoc-citeproc.flake = false;

45+ # outputs = inputs:

46+ # ...

47+ # inputMap."https://github.com/jgm/pandoc-citeproc" = inputs.inputs.pandoc-citeproc;

48+, extra-hackage-tarballs ? {}

49+, source-repo-override ? {} # Cabal seems to behave incoherently when

50+ # two source-repository-package entries

51+ # provide the same packages, making it

52+ # impossible to override cabal.project

53+ # with e.g. a cabal.project.local. In CI,

54+ # we want to be able to test against the

55+ # latest versions of various dependencies.

56+ #

57+ # This argument is a map from url to

58+ # a function taking the existing repoData

59+ # and returning the new repoData in its

60+ # place. E.g.

61+ #

62+ # { "https://github.com/input-output-hk/plutus-apps" = orig: orig // { subdirs = (orig.subdirs or [ "." ]) ++ [ "foo" ]; }; }

63+ #

64+ # would result in the "foo" subdirectory of

65+ # any plutus-apps input being used for a

66+ # package.

67+, evalPackages

42, ...

68, ...

43}@args:

69}@args:

44

70

45let

71let

72+ inherit (evalPackages.haskell-nix) materialize dotCabal;

73+

74+ # These defaults are hear rather than in modules/cabal-project.nix to make them

75+ # lazy enough to avoid infinite recursion issues.

76+ # Using null as the default also improves performance as they are not forced by the

77+ # nix module system for `nix-tools-unchecked` and `cabal-install-unchecked`.

78+ nix-tools = if args.nix-tools or null != null

79+ then args.nix-tools

80+ else evalPackages.haskell-nix.nix-tools-unchecked.${compiler-nix-name};

81+ cabal-install = if args.cabal-install or null != null

82+ then args.cabal-install

83+ else evalPackages.haskell-nix.cabal-install-unchecked.${compiler-nix-name};

46 forName = pkgs.lib.optionalString (name != null) (" for " + name);

84 forName = pkgs.lib.optionalString (name != null) (" for " + name);

85+ nameAndSuffix = suffix: if name == null then suffix else name + "-" + suffix;

47

86

48 ghc' =

87 ghc' =

49 if ghcOverride != null

88 if ghcOverride != null

@@ -52,11 +91,10 @@ let

52 if ghc != null

91 if ghc != null

53 then __trace ("WARNING: A `ghc` argument was passed" + forName

92 then __trace ("WARNING: A `ghc` argument was passed" + forName

54 + " this has been deprecated in favour of `compiler-nix-name`. "

93 + " this has been deprecated in favour of `compiler-nix-name`. "

55− + "Using `ghc` will break cross compilation setups, as haskell.nix can not"

94+ + "Using `ghc` will break cross compilation setups, as haskell.nix cannot "

56 + "pick the correct `ghc` package from the respective buildPackages. "

95 + "pick the correct `ghc` package from the respective buildPackages. "

57− + "For example use `compiler-nix-name = \"ghc865\";` for ghc 8.6.5") ghc

96+ + "For example, use `compiler-nix-name = \"ghc865\";` for GHC 8.6.5.") ghc

58 else

97 else

59− if compiler-nix-name != null

60 # Do note that `pkgs = final.buildPackages` in the `overlays/haskell.nix`

98 # Do note that `pkgs = final.buildPackages` in the `overlays/haskell.nix`

61 # call to this file. And thus `pkgs` here is the proper `buildPackages`

99 # call to this file. And thus `pkgs` here is the proper `buildPackages`

62 # set and we do not need, nor should pick the compiler from another level

100 # set and we do not need, nor should pick the compiler from another level

@@ -65,8 +103,7 @@ let

65 #

103 #

66 # > The option `packages.Win32.package.identifier.name' is used but not defined.

104 # > The option `packages.Win32.package.identifier.name' is used but not defined.

67 #

105 #

68− then pkgs.haskell-nix.compiler."${compiler-nix-name}"

106+ pkgs.haskell-nix.compiler."${compiler-nix-name}";

69− else defaults.ghc;

70

107

71in

108in

72 assert (if ghc'.isHaskellNixCompiler or false then true

109 assert (if ghc'.isHaskellNixCompiler or false then true

@@ -77,15 +114,13 @@ let

77 ghc = ghc';

114 ghc = ghc';

78 subDir' = src.origSubDir or "";

115 subDir' = src.origSubDir or "";

79 subDir = pkgs.lib.strings.removePrefix "/" subDir';

116 subDir = pkgs.lib.strings.removePrefix "/" subDir';

80− maybeCleanedSource =

117+

81− if haskellLib.canCleanSource src

118+ cleanedSource = haskellLib.cleanSourceWith {

82− then (haskellLib.cleanSourceWith {

119+ name = if name != null then "${name}-root-cabal-files" else "source-root-cabal-files";

83− name = src.name + "-root-cabal-files";

120+ src = src.origSrc or src;

84− src = src.origSrc;

121+ filter = path: type: (!(src ? filter) || src.filter path type) && (

85− filter = path: type: src.filter path type && (

122+ type == "directory" ||

86− type == "directory" ||

123+ pkgs.lib.any (i: (pkgs.lib.hasSuffix i path)) [ ".cabal" "package.yaml" ]); };

87− pkgs.lib.any (i: (pkgs.lib.hasSuffix i path)) [ ".cabal" "package.yaml" ]); })

88− else src.origSrc or src;

89

124

90 # Using origSrcSubDir bypasses any cleanSourceWith so that it will work when

125 # Using origSrcSubDir bypasses any cleanSourceWith so that it will work when

91 # access to the store is restricted. If origSrc was already in the store

126 # access to the store is restricted. If origSrc was already in the store

@@ -103,27 +138,21 @@ let

103 )

138 )

104 else null;

139 else null;

105

140

106− # Look for a index-state: field in the cabal.project file

141+ cabalProjectIndexState =

107− parseIndexState = rawCabalProject:

142+ if rawCabalProject != null

108− let

143+ then pkgs.haskell-nix.haskellLib.parseIndexState rawCabalProject

109− indexState = pkgs.lib.lists.concatLists (

144+ else null;

110− pkgs.lib.lists.filter (l: l != null)

111− (builtins.map (l: builtins.match "^index-state: *(.*)" l)

112− (pkgs.lib.splitString "\n" rawCabalProject)));

113− in

114− pkgs.lib.lists.head (indexState ++ [ null ]);

115

145

116− index-state-found = if index-state != null

146+ index-state-found =

147+ if index-state != null

117 then index-state

148 then index-state

149+ else if cabalProjectIndexState != null

150+ then cabalProjectIndexState

118 else

151 else

119− let cabalProjectIndexState = if rawCabalProject != null

152+ let latest-index-state = pkgs.lib.last (builtins.attrNames index-state-hashes);

120− then parseIndexState rawCabalProject

153+ in builtins.trace ("No index state specified" + (if name == null then "" else " for " + name) + ", using the latest index state that we know about (${latest-index-state})!") latest-index-state;

121− else null;

154+

122− in

155+ index-state-pinned = index-state != null || cabalProjectIndexState != null;

123− if cabalProjectIndexState != null

124− then cabalProjectIndexState

125− else builtins.trace ("Using latest index state" + (if name == null then "" else " for " + name) + "!")

126− (pkgs.lib.last (builtins.attrNames index-state-hashes));

127

156

128in

157in

129 assert (if index-state-found == null

158 assert (if index-state-found == null

@@ -162,103 +191,115 @@ in

162 then throw "Unknown index-state ${index-state-found}, the latest index-state I know about is ${pkgs.lib.last (builtins.attrNames index-state-hashes)}. You may need to update to a newer hackage.nix." else true);

191 then throw "Unknown index-state ${index-state-found}, the latest index-state I know about is ${pkgs.lib.last (builtins.attrNames index-state-hashes)}. You may need to update to a newer hackage.nix." else true);

163

192

164let

193let

165− span = pred: list:

194+ # Deal with source-repository-packages in a way that will work in

166− let n = pkgs.lib.lists.foldr (x: acc: if pred x then acc + 1 else 0) 0 list;

195+ # restricted-eval mode (as long as a sha256 is included).

167− in { fst = pkgs.lib.lists.take n list; snd = pkgs.lib.lists.drop n list; };

196+ # Replace source-repository-package blocks that have a sha256 with

168−

197+ # packages: block containing nix store paths of the fetched repos.

169− # Parse lines of a source-repository-package block

170− parseBlockLines = blockLines: builtins.listToAttrs (builtins.concatMap (s:

171− let pair = builtins.match " *([^:]*): *(.*)" s;

172− in pkgs.lib.optional (pair != null) (pkgs.lib.attrsets.nameValuePair

173− (builtins.head pair)

174− (builtins.elemAt pair 1))) blockLines);

175

198

176 hashPath = path:

199 hashPath = path:

177 builtins.readFile (pkgs.runCommand "hash-path" { preferLocalBuild = true; }

200 builtins.readFile (pkgs.runCommand "hash-path" { preferLocalBuild = true; }

178 "echo -n $(${pkgs.nix}/bin/nix-hash --type sha256 --base32 ${path}) > $out");

201 "echo -n $(${pkgs.nix}/bin/nix-hash --type sha256 --base32 ${path}) > $out");

179

202

180− # Use pkgs.fetchgit if we have a sha256. Add comment like this

203+ replaceSourceRepos = projectFile:

181− # --shar256: 003lm3pm0000hbfmii7xcdd9v20000flxf7gdl2pyxia7p014i8z

182− # otherwise use __fetchGit.

183− fetchRepo = repo:

184− let sha256 = repo."--sha256" or (lookupSha256 repo);

185− in (if sha256 != null

186− then pkgs.evalPackages.fetchgit {

187− url = repo.location;

188− rev = repo.tag;

189− inherit sha256;

190− }

191− else

192− let drv = builtins.fetchGit {

193− url = repo.location;

194− ref = repo.tag;

195− };

196− in __trace "WARNING: No sha256 found for source-repository-package ${repo.location} ${repo.tag} download may fail in restricted mode (hydra)"

197− (__trace "Consider adding `--sha256: ${hashPath drv}` to the ${cabalProjectFileName} file or passing in a lookupSha256 argument"

198− drv)

199− ) + (if repo.subdir or "" == "" then "" else "/" + repo.subdir);

200−

201− # Parse a source-repository-package and fetch it if has `type: git`

202− parseBlock = block:

203 let

204 let

204− x = span (pkgs.lib.strings.hasPrefix " ") (pkgs.lib.splitString "\n" block);

205+ fetchPackageRepo = fetchgit: repoData:

205− attrs = parseBlockLines x.fst;

206+ let

206− in

207+ fetched =

207− if attrs."type" or "" != "git"

208+ if inputMap ? "${repoData.url}/${repoData.ref}"

208− then {

209+ then inputMap."${repoData.url}/${repoData.ref}"

209− sourceRepo = [];

210+ else if inputMap ? ${repoData.url}

210− otherText = "\nsource-repository-package\n" + block;

211+ then

211− }

212+ (if inputMap.${repoData.url}.rev != repoData.ref

212− else {

213+ then throw "${inputMap.${repoData.url}.rev} may not match ${repoData.ref} for ${repoData.url} use \"${repoData.url}/${repoData.ref}\" as the inputMap key if ${repoData.ref} is a branch or tag that points to ${inputMap.${repoData.url}.rev}."

213− sourceRepo = [ (fetchRepo attrs) ];

214+ else inputMap.${repoData.url})

214− otherText = pkgs.lib.strings.concatStringsSep "\n" x.snd;

215+ else if repoData.sha256 != null

216+ then fetchgit { inherit (repoData) url sha256; rev = repoData.ref; }

217+ else

218+ let drv = builtins.fetchGit { inherit (repoData) url ref; };

219+ in __trace "WARNING: No sha256 found for source-repository-package ${repoData.url} ${repoData.ref} download may fail in restricted mode (hydra)"

220+ (__trace "Consider adding `--sha256: ${hashPath drv}` to the ${cabalProjectFileName} file or passing in a sha256map argument"

221+ drv);

222+ in {

223+ # Download the source-repository-package commit and add it to a minimal git

224+ # repository that `cabal` will be able to access from a non fixed output derivation.

225+ location = evalPackages.runCommand "source-repository-package" {

226+ nativeBuildInputs = [ evalPackages.rsync evalPackages.gitMinimal ];

227+ } ''

228+ mkdir $out

229+ rsync -a --prune-empty-dirs "${fetched}/" "$out/"

230+ cd $out

231+ chmod -R +w .

232+ git init -b minimal

233+ git add --force .

234+ GIT_COMMITTER_NAME='No One' GIT_COMMITTER_EMAIL= git commit -m "Minimal Repo For Haskell.Nix" --author 'No One <>'

235+ '';

236+ inherit (repoData) subdirs;

237+ inherit fetched;

238+ tag = "minimal";

215 };

239 };

216

240

217− # Deal with source-repository-packages in a way that will work in

241+ # Parse the `source-repository-package` blocks

218− # restricted-eval mode (as long as a sha256 is included).

242+ sourceRepoPackageResult = pkgs.haskell-nix.haskellLib.parseSourceRepositoryPackages

219− # Replace source-repository-package blocks that have a sha256 with

243+ cabalProjectFileName sha256map source-repo-override projectFile;

220− # packages: block containing nix sotre paths of the fetched repos.

244+

221− replaceSoureRepos = projectFile:

245+ # Parse the `repository` blocks

222− let

246+ repoResult = pkgs.haskell-nix.haskellLib.parseRepositories

223− blocks = pkgs.lib.splitString "\nsource-repository-package\n" projectFile;

247+ evalPackages cabalProjectFileName sha256map inputMap cabal-install nix-tools sourceRepoPackageResult.otherText;

224− initialText = pkgs.lib.lists.take 1 blocks;

248+

225− repoBlocks = builtins.map parseBlock (pkgs.lib.lists.drop 1 blocks);

249+ # we need the repository content twice:

226− sourceRepos = pkgs.lib.lists.concatMap (x: x.sourceRepo) repoBlocks;

250+ # * at eval time (below to build the fixed project file)

227− otherText = pkgs.evalPackages.writeText "cabal.project" (pkgs.lib.strings.concatStringsSep "\n" (

251+ # Here we want to use evalPackages.fetchgit, so one can calculate

228− initialText

252+ # the build plan for any target without a remote builder

229− ++ (builtins.map (x: x.otherText) repoBlocks)));

253+ # * at built time (passed out)

254+ # Here we want to use plain pkgs.fetchgit, which is what a builder

255+ # on the target system would use, so that the derivation is unaffected

256+ # and, say, a linux release build job can identify the derivation

257+ # as built by a darwin builder, and fetch it from a cache

258+ sourceReposEval = builtins.map (fetchPackageRepo evalPackages.fetchgit) sourceRepoPackageResult.sourceRepos;

259+ sourceReposBuild = builtins.map (x: (fetchPackageRepo pkgs.fetchgit x).fetched) sourceRepoPackageResult.sourceRepos;

230 in {

260 in {

231− inherit sourceRepos;

261+ sourceRepos = sourceReposBuild;

262+ inherit (repoResult) repos extra-hackages;

232 makeFixedProjectFile = ''

263 makeFixedProjectFile = ''

233− cp -f ${otherText} ./cabal.project

264+ cp -f ${evalPackages.writeText "cabal.project" sourceRepoPackageResult.otherText} ./cabal.project

265+ '' +

266+ pkgs.lib.optionalString (builtins.length sourceReposEval != 0) (''

234 chmod +w -R ./cabal.project

267 chmod +w -R ./cabal.project

235− echo "packages:" >> ./cabal.project

268+ # The newline here is important in case cabal.project does not have one at the end

236− mkdir -p ./.source-repository-packages

269+ echo >> ./cabal.project

237 '' +

270 '' +

238− ( pkgs.lib.strings.concatStrings (

271+ # Add replacement `source-repository-package` blocks pointing to the minimal git repos

272+ ( pkgs.lib.strings.concatMapStrings (f: ''

273+ echo "source-repository-package" >> ./cabal.project

274+ echo " type: git" >> ./cabal.project

275+ echo " location: file://${f.location}" >> ./cabal.project

276+ echo " subdir: ${builtins.concatStringsSep " " f.subdirs}" >> ./cabal.project

277+ echo " tag: ${f.tag}" >> ./cabal.project

278+ '') sourceReposEval

279+ ));

280+ # This will be used to replace refernces to the minimal git repos with just the index

281+ # of the repo. The index will be used in lib/import-and-filter-project.nix to

282+ # lookup the correct repository in `sourceReposBuild`. This avoids having

283+ # `/nix/store` paths in the `plan-nix` output so that it can be materialized safely.

284+ replaceLocations = pkgs.lib.strings.concatStrings (

239 pkgs.lib.lists.zipListsWith (n: f: ''

285 pkgs.lib.lists.zipListsWith (n: f: ''

240− mkdir -p ./.source-repository-packages/${builtins.toString n}

286+ (cd $out${subDir'}

241− rsync -a --prune-empty-dirs \

287+ substituteInPlace $tmp${subDir'}/dist-newstyle/cache/plan.json --replace file://${f.location} ${builtins.toString n}

242− --include '*/' --include '*.cabal' --include 'package.yaml' \

288+ for a in $(grep -rl file://${f.location} .plan.nix/*.nix); do

243− --exclude '*' \

289+ substituteInPlace $a --replace file://${f.location} ${builtins.toString n}

244− "${f}/" "./.source-repository-packages/${builtins.toString n}/"

290+ done)

245− echo " ./.source-repository-packages/${builtins.toString n}" >> ./cabal.project

246 '')

291 '')

247− (pkgs.lib.lists.range 0 ((builtins.length fixedProject.sourceRepos) - 1))

292+ (pkgs.lib.lists.range 0 ((builtins.length sourceReposEval) - 1))

248− sourceRepos

293+ sourceReposEval

249− )

294+ );

250− );

251 };

295 };

252

296

253 fixedProject =

297 fixedProject =

254 if rawCabalProject == null

298 if rawCabalProject == null

255− then {

299+ then { sourceRepos = []; repos = {}; extra-hackages = []; makeFixedProjectFile = ""; replaceLocations = ""; }

256− sourceRepos = [];

300+ else replaceSourceRepos rawCabalProject;

257− makeFixedProjectFile = "";

258− }

259− else replaceSoureRepos rawCabalProject;

260

301

261− # The use of a the actual GHC can cause significant problems:

302+ # The use of the actual GHC can cause significant problems:

262 # * For hydra to assemble a list of jobs from `components.tests` it must

303 # * For hydra to assemble a list of jobs from `components.tests` it must

263 # first have GHC that will be used. If a patch has been applied to the

304 # first have GHC that will be used. If a patch has been applied to the

264 # GHC to be used it must be rebuilt before the list of jobs can be assembled.

305 # GHC to be used it must be rebuilt before the list of jobs can be assembled.

@@ -276,14 +317,21 @@ let

276 # The solution here is to capture the GHC outputs that `cabal v2-configure`

317 # The solution here is to capture the GHC outputs that `cabal v2-configure`

277 # requests and materialize it so that the real GHC is only needed

318 # requests and materialize it so that the real GHC is only needed

278 # when `checkMaterialization` is set.

319 # when `checkMaterialization` is set.

279− dummy-ghc-data = pkgs.haskell-nix.materialize ({

320+ dummy-ghc-data =

280− sha256 = null;

321+ let

281− sha256Arg = "sha256";

322+ materialized = ../materialized/dummy-ghc + "/${ghc.targetPrefix}${ghc.name}-${pkgs.stdenv.buildPlatform.system}";

282− materialized = ../materialized/dummy-ghc + "/${ghc.targetPrefix}${ghc.name}-${pkgs.stdenv.buildPlatform.system}";

323+ in pkgs.haskell-nix.materialize ({

283− reasonNotSafe = null;

324+ sha256 = null;

284− } // pkgs.lib.optionalAttrs (checkMaterialization != null) {

325+ sha256Arg = "sha256";

285− inherit checkMaterialization;

326+ materialized = if __pathExists materialized

286− }) (

327+ then materialized

328+ else __trace ("WARNING: No materialized dummy-ghc-data for "

329+ + "${ghc.targetPrefix}${ghc.name}-${pkgs.stdenv.buildPlatform.system}.")

330+ null;

331+ reasonNotSafe = null;

332+ } // pkgs.lib.optionalAttrs (checkMaterialization != null) {

333+ inherit checkMaterialization;

334+ }) (

287 runCommand ("dummy-data-" + ghc.name) {

335 runCommand ("dummy-data-" + ghc.name) {

288 nativeBuildInputs = [ ghc ];

336 nativeBuildInputs = [ ghc ];

289 } ''

337 } ''

@@ -294,6 +342,11 @@ let

294 ${ghc.targetPrefix}ghc --info | grep -v /nix/store > $out/ghc/info

342 ${ghc.targetPrefix}ghc --info | grep -v /nix/store > $out/ghc/info

295 ${ghc.targetPrefix}ghc --supported-languages > $out/ghc/supported-languages

343 ${ghc.targetPrefix}ghc --supported-languages > $out/ghc/supported-languages

296 ${ghc.targetPrefix}ghc-pkg --version > $out/ghc-pkg/version

344 ${ghc.targetPrefix}ghc-pkg --version > $out/ghc-pkg/version

345+ ${pkgs.lib.optionalString (ghc.targetPrefix == "js-unknown-ghcjs-") ''

346+ ${ghc.targetPrefix}ghc --numeric-ghc-version > $out/ghc/numeric-ghc-version

347+ ${ghc.targetPrefix}ghc --numeric-ghcjs-version > $out/ghc/numeric-ghcjs-version

348+ ${ghc.targetPrefix}ghc-pkg --numeric-ghcjs-version > $out/ghc-pkg/numeric-ghcjs-version

349+ ''}

297 # The order of the `ghc-pkg dump` output seems to be non

350 # The order of the `ghc-pkg dump` output seems to be non

298 # deterministic so we need to sort it so that it is always

351 # deterministic so we need to sort it so that it is always

299 # the same.

352 # the same.

@@ -315,12 +368,12 @@ let

315 '');

368 '');

316

369

317 # Dummy `ghc` that uses the captured output

370 # Dummy `ghc` that uses the captured output

318− dummy-ghc = pkgs.evalPackages.writeTextFile {

371+ dummy-ghc = evalPackages.writeTextFile {

319 name = "dummy-" + ghc.name;

372 name = "dummy-" + ghc.name;

320 executable = true;

373 executable = true;

321 destination = "/bin/${ghc.targetPrefix}ghc";

374 destination = "/bin/${ghc.targetPrefix}ghc";

322 text = ''

375 text = ''

323− #!${pkgs.evalPackages.runtimeShell}

376+ #!${evalPackages.runtimeShell}

324 case "$*" in

377 case "$*" in

325 --version*)

378 --version*)

326 cat ${dummy-ghc-data}/ghc/version

379 cat ${dummy-ghc-data}/ghc/version

@@ -328,6 +381,14 @@ let

328 --numeric-version*)

381 --numeric-version*)

329 cat ${dummy-ghc-data}/ghc/numeric-version

382 cat ${dummy-ghc-data}/ghc/numeric-version

330 ;;

383 ;;

384+ ${pkgs.lib.optionalString (ghc.targetPrefix == "js-unknown-ghcjs-") ''

385+ --numeric-ghc-version*)

386+ cat ${dummy-ghc-data}/ghc/numeric-ghc-version

387+ ;;

388+ --numeric-ghcjs-version*)

389+ cat ${dummy-ghc-data}/ghc/numeric-ghcjs-version

390+ ;;

391+ ''}

331 --supported-languages*)

392 --supported-languages*)

332 cat ${dummy-ghc-data}/ghc/supported-languages

393 cat ${dummy-ghc-data}/ghc/supported-languages

333 ;;

394 ;;

@@ -350,16 +411,21 @@ let

350 };

411 };

351

412

352 # Dummy `ghc-pkg` that uses the captured output

413 # Dummy `ghc-pkg` that uses the captured output

353− dummy-ghc-pkg = pkgs.evalPackages.writeTextFile {

414+ dummy-ghc-pkg = evalPackages.writeTextFile {

354 name = "dummy-pkg-" + ghc.name;

415 name = "dummy-pkg-" + ghc.name;

355 executable = true;

416 executable = true;

356 destination = "/bin/${ghc.targetPrefix}ghc-pkg";

417 destination = "/bin/${ghc.targetPrefix}ghc-pkg";

357 text = ''

418 text = ''

358− #!${pkgs.evalPackages.runtimeShell}

419+ #!${evalPackages.runtimeShell}

359 case "$*" in

420 case "$*" in

360 --version)

421 --version)

361 cat ${dummy-ghc-data}/ghc-pkg/version

422 cat ${dummy-ghc-data}/ghc-pkg/version

362 ;;

423 ;;

424+ ${pkgs.lib.optionalString (ghc.targetPrefix == "js-unknown-ghcjs-") ''

425+ --numeric-ghcjs-version)

426+ cat ${dummy-ghc-data}/ghc-pkg/numeric-ghcjs-version

427+ ;;

428+ ''}

363 'dump --global -v0')

429 'dump --global -v0')

364 cat ${dummy-ghc-data}/ghc-pkg/dump-global

430 cat ${dummy-ghc-data}/ghc-pkg/dump-global

365 ;;

431 ;;

@@ -378,70 +444,131 @@ let

378 inherit materialized;

444 inherit materialized;

379 sha256 = plan-sha256;

445 sha256 = plan-sha256;

380 sha256Arg = "plan-sha256";

446 sha256Arg = "plan-sha256";

447+ this = "project.plan-nix" + (if name != null then " for ${name}" else "");

381 # Before pinning stuff down we need an index state to use

448 # Before pinning stuff down we need an index state to use

382 reasonNotSafe =

449 reasonNotSafe =

383− if index-state == null

450+ if !index-state-pinned

384− then "index-state is not set"

451+ then "index-state is not pinned by an argument or the cabal project file"

385 else null;

452 else null;

386 } // pkgs.lib.optionalAttrs (checkMaterialization != null) {

453 } // pkgs.lib.optionalAttrs (checkMaterialization != null) {

387 inherit checkMaterialization;

454 inherit checkMaterialization;

388− }) (pkgs.evalPackages.runCommand (if name == null then "plan-to-nix-pkgs" else name + "-plan-to-nix-pkgs") {

455+ }) (evalPackages.runCommand (nameAndSuffix "plan-to-nix-pkgs") {

389− nativeBuildInputs = [ nix-tools dummy-ghc dummy-ghc-pkg hpack cabal-install pkgs.evalPackages.rsync ];

456+ nativeBuildInputs = [ nix-tools dummy-ghc dummy-ghc-pkg cabal-install evalPackages.rsync evalPackages.gitMinimal ];

390 # Needed or stack-to-nix will die on unicode inputs

457 # Needed or stack-to-nix will die on unicode inputs

391− LOCALE_ARCHIVE = pkgs.lib.optionalString (pkgs.stdenv.hostPlatform.libc == "glibc") "${pkgs.glibcLocales}/lib/locale/locale-archive";

458+ LOCALE_ARCHIVE = pkgs.lib.optionalString (evalPackages.stdenv.buildPlatform.libc == "glibc") "${evalPackages.glibcLocales}/lib/locale/locale-archive";

392 LANG = "en_US.UTF-8";

459 LANG = "en_US.UTF-8";

393 meta.platforms = pkgs.lib.platforms.all;

460 meta.platforms = pkgs.lib.platforms.all;

394 preferLocalBuild = false;

461 preferLocalBuild = false;

462+ outputs = [

463+ "out" # The results of plan-to-nix

464+ # These two output will be present if in cabal configure failed.

465+ # They are used to provide passthru.json and passthru.freeze that

466+ # check first for cabal configure failure.

467+ "maybeJson" # The `plan.json` file generated by cabal and used for `plan-to-nix` input

468+ "maybeFreeze" # The `cabal.project.freeze` file created by `cabal v2-freeze`

469+ ];

470+ passthru =

471+ let

472+ checkCabalConfigure = ''

473+ if [[ -f ${plan-nix}/cabal-configure.out ]]; then

474+ cat ${plan-nix}/cabal-configure.out

475+ exit 1

476+ fi

477+ '';

478+ in {

479+ # These check for cabal configure failure

480+ json = evalPackages.runCommand (nameAndSuffix "plan-json") {} ''

481+ ${checkCabalConfigure}

482+ cp ${plan-nix.maybeJson} $out

483+ '';

484+ freeze = evalPackages.runCommand (nameAndSuffix "plan-freeze") {} ''

485+ ${checkCabalConfigure}

486+ cp ${plan-nix.maybeFreeze} $out

487+ '';

488+ };

395 } ''

489 } ''

396 tmp=$(mktemp -d)

490 tmp=$(mktemp -d)

397 cd $tmp

491 cd $tmp

398− # if maybeCleanedSource is empty, this means it's a new

492+ # if cleanedSource is empty, this means it's a new

399 # project where the files haven't been added to the git

493 # project where the files haven't been added to the git

400 # repo yet. We fail early and provide a useful error

494 # repo yet. We fail early and provide a useful error

401 # message to prevent headaches (#290).

495 # message to prevent headaches (#290).

402− if [ -z "$(ls -A ${maybeCleanedSource})" ]; then

496+ if [ -z "$(ls -A ${cleanedSource})" ]; then

403− echo "cleaned source is empty. Did you forget to 'git add -A'?"; exit 1;

497+ echo "cleaned source is empty. Did you forget to 'git add -A'?"

498+ ${pkgs.lib.optionalString (__length fixedProject.sourceRepos == 0) ''

499+ exit 1

500+ ''}

501+ else

502+ cp -r ${cleanedSource}/* .

404 fi

503 fi

405− cp -r ${maybeCleanedSource}/* .

406 chmod +w -R .

504 chmod +w -R .

407− # warning: this may not generate the proper cabal file.

505+ # Decide what to do for each `package.yaml` file.

408− # hpack allows globbing, and turns that into module lists

506+ for hpackFile in $(find . -name package.yaml); do (

409− # without the source available (we cleaneSourceWith'd it),

507+ # Look to see if a `.cabal` file exists

410− # this may not produce the right result.

508+ shopt -u nullglob

411− find . -name package.yaml -exec hpack "{}" \;

509+ for cabalFile in $(dirname $hpackFile)/*.cabal; do

510+ if [ -e "$cabalFile" ]; then

511+ echo Ignoring $hpackFile as $cabalFile exists

512+ else

513+ # warning: this may not generate the proper cabal file.

514+ # hpack allows globbing, and turns that into module lists

515+ # without the source available (we cleaneSourceWith'd it),

516+ # this may not produce the right result.

517+ echo No .cabal file found, running hpack on $hpackFile

518+ hpack $hpackFile

519+ fi

520+ done

521+ )

522+ done

412 ${pkgs.lib.optionalString (subDir != "") "cd ${subDir}"}

523 ${pkgs.lib.optionalString (subDir != "") "cd ${subDir}"}

413 ${fixedProject.makeFixedProjectFile}

524 ${fixedProject.makeFixedProjectFile}

414 ${pkgs.lib.optionalString (cabalProjectFreeze != null) ''

525 ${pkgs.lib.optionalString (cabalProjectFreeze != null) ''

415− cp ${pkgs.evalPackages.writeText "cabal.project.freeze" cabalProjectFreeze} \

526+ cp ${evalPackages.writeText "cabal.project.freeze" cabalProjectFreeze} \

416 cabal.project.freeze

527 cabal.project.freeze

528+ chmod +w cabal.project.freeze

417 ''}

529 ''}

418 export SSL_CERT_FILE=${cacert}/etc/ssl/certs/ca-bundle.crt

530 export SSL_CERT_FILE=${cacert}/etc/ssl/certs/ca-bundle.crt

419 export GIT_SSL_CAINFO=${cacert}/etc/ssl/certs/ca-bundle.crt

531 export GIT_SSL_CAINFO=${cacert}/etc/ssl/certs/ca-bundle.crt

420− HOME=${

532+

533+ # Using `cabal v2-freeze` will configure the project (since

534+ # it is not configured yet), taking the existing `cabal.project.freeze`

535+ # file into account. Then it "writes out a freeze file which

536+ # records all of the versions and flags that are picked" (from cabal docs).

537+ echo "Using index-state ${index-state-found}"

538+ if(HOME=${

421 # This creates `.cabal` directory that is as it would have

539 # This creates `.cabal` directory that is as it would have

422 # been at the time `cached-index-state`. We may include

540 # been at the time `cached-index-state`. We may include

423 # some packages that will be excluded by `index-state-found`

541 # some packages that will be excluded by `index-state-found`

424− # which is used by cabal (cached-index-state >= index-state-found).

542+ # which is used by cabal (cached-index-state >= index-state-found).

425 dotCabal {

543 dotCabal {

426 inherit cabal-install nix-tools extra-hackage-tarballs;

544 inherit cabal-install nix-tools extra-hackage-tarballs;

545+ extra-hackage-repos = fixedProject.repos;

427 index-state = cached-index-state;

546 index-state = cached-index-state;

428 sha256 = index-sha256-found;

547 sha256 = index-sha256-found;

429 }

548 }

430− } cabal v2-configure \

549+ } cabal v2-freeze ${

431− --index-state=${

550+ # Setting the desired `index-state` here in case it is not

432− # Setting the desired `index-state` here in case it was not

551+ # in the cabal.project file. This will further restrict the

433− # from the cabal.project file. This will further restrict the

552+ # packages used by the solver (cached-index-state >= index-state-found).

434− # packages used by the solver (cached-index-state >= index-state-found).

553+ pkgs.lib.optionalString (index-state != null) "--index-state=${index-state}"

435− builtins.trace ("Using index-state: ${index-state-found}" + (if name == null then "" else " for " + name))

554+ } \

436− index-state-found} \

555+ -w ${

437− --with-ghc=${ghc.targetPrefix}ghc \

556+ # We are using `-w` rather than `--with-ghc` here to override

557+ # the `with-compiler:` in the `cabal.project` file.

558+ ghc.targetPrefix}ghc \

438 --with-ghc-pkg=${ghc.targetPrefix}ghc-pkg \

559 --with-ghc-pkg=${ghc.targetPrefix}ghc-pkg \

439 --enable-tests \

560 --enable-tests \

440 --enable-benchmarks \

561 --enable-benchmarks \

441− ${configureArgs}

562+ ${pkgs.lib.optionalString (ghc.targetPrefix == "js-unknown-ghcjs-")

563+ "--ghcjs --with-ghcjs=js-unknown-ghcjs-ghc --with-ghcjs-pkg=js-unknown-ghcjs-ghc-pkg"} \

564+ ${configureArgs} 2>&1 | tee -a cabal-configure.out); then

442

565

443 mkdir -p $out

566 mkdir -p $out

444

567

568+ cp cabal.project.freeze $maybeFreeze

569+ # Not needed any more (we don't want it to wind up in the $out hash)

570+ rm cabal.project.freeze

571+

445 # ensure we have all our .cabal files (also those generated from package.yaml) files.

572 # ensure we have all our .cabal files (also those generated from package.yaml) files.

446 # otherwise we'd need to be careful about putting the `cabal-generator = hpack` into

573 # otherwise we'd need to be careful about putting the `cabal-generator = hpack` into

447 # the nix expression. As we already called `hpack` on all `package.yaml` files we can

574 # the nix expression. As we already called `hpack` on all `package.yaml` files we can

@@ -462,23 +589,44 @@ let

462 # proper relative paths.

589 # proper relative paths.

463 (cd $out${subDir'} && plan-to-nix --full --plan-json $tmp${subDir'}/dist-newstyle/cache/plan.json -o .)

590 (cd $out${subDir'} && plan-to-nix --full --plan-json $tmp${subDir'}/dist-newstyle/cache/plan.json -o .)

464

591

592+ # Replace the /nix/store paths to minimal git repos with indexes (that will work with materialization).

593+ ${fixedProject.replaceLocations}

594+

595+ # Make the plan.json file available in case we need to debug plan-to-nix

596+ cp $tmp${subDir'}/dist-newstyle/cache/plan.json $maybeJson

597+

465 # Remove the non nix files ".project" ".cabal" "package.yaml" files

598 # Remove the non nix files ".project" ".cabal" "package.yaml" files

466 # as they should not be in the output hash (they may change slightly

599 # as they should not be in the output hash (they may change slightly

467 # without affecting the nix).

600 # without affecting the nix).

468− if [ -d $out${subDir'}/.source-repository-packages ]; then

469− chmod +w -R $out${subDir'}/.source-repository-packages

470− rm -rf $out${subDir'}/.source-repository-packages

471− fi

472 find $out $ -type f -or -type l $ ! -name '*.nix' -delete

601 find $out $ -type f -or -type l $ ! -name '*.nix' -delete

473 # Remove empty dirs

602 # Remove empty dirs

474 find $out -type d -empty -delete

603 find $out -type d -empty -delete

475

604

476 # move pkgs.nix to default.nix ensure we can just nix `import` the result.

605 # move pkgs.nix to default.nix ensure we can just nix `import` the result.

477 mv $out${subDir'}/pkgs.nix $out${subDir'}/default.nix

606 mv $out${subDir'}/pkgs.nix $out${subDir'}/default.nix

607+ else

608+ # Check that this was a solver failure that (not some other

609+ # possibly non deterministic failure).

610+ # TODO replace grep once https://github.com/haskell/cabal/issues/5191

611+ # is fixed.

612+ grep "cabal: Could not resolve dependencies" cabal-configure.out

613+

614+ # When cabal configure fails copy the output that we captured above and

615+ # use `failed-cabal-configure.nix` to make a suitable derviation with.

616+ mkdir -p $out${subDir'}

617+ cp cabal-configure.out $out${subDir'}

618+ cp ${./failed-cabal-configure.nix} $out${subDir'}/default.nix

619+

620+ # These should only be used indirectly by `passthru.json` and `passthru.freeze`.

621+ # Those derivations will check for `cabal-configure.out` out first to see if

622+ # it is ok to use these files.

623+ echo "Cabal configure failed see $out${subDir'}/cabal-configure.out for details" > $maybeJson

624+ echo "Cabal configure failed see $out${subDir'}/cabal-configure.out for details" > $maybeFreeze

625+ fi

478 '');

626 '');

479in {

627in {

480 projectNix = plan-nix;

628 projectNix = plan-nix;

481 index-state = index-state-found;

629 index-state = index-state-found;

482 inherit src;

630 inherit src;

483− inherit (fixedProject) sourceRepos;

631+ inherit (fixedProject) sourceRepos extra-hackages;

484}

632}

lib/call-stack-to-nix.nix+49−11

@@ -5,21 +5,37 @@

5 *

6 * see also `call-cabal-project-to-nix`!

7 */

8−{ runCommand, nix-tools, pkgs, mkCacheFile, materialize }:

9{ name ? src.name or null # optional name for better error messages

8{ name ? src.name or null # optional name for better error messages

10, src

9, src

11−, stackYaml ? null

10+, stackYaml ? "stack.yaml"

12, ignorePackageYaml ? false

11, ignorePackageYaml ? false

13, cache ? null

12, cache ? null

14, stack-sha256 ? null

13, stack-sha256 ? null

14+, resolverSha256 ? null

15, materialized ? null # Location of a materialized copy of the nix files

16, checkMaterialization ? null # If true the nix files will be generated used to check plan-sha256 and material

17−, ... }:

17+, nix-tools

18+, evalPackages

19+, ... }@args:

18let

20let

21+ inherit (evalPackages) runCommand;

22+ inherit (evalPackages.haskell-nix) mkCacheFile materialize haskellLib;

23+ inherit (haskellLib.fetchResolver {

24+ inherit src stackYaml resolverSha256;

25+ }) resolver fetchedResolver;

26+

19 subDir' = src.origSubDir or "";

27 subDir' = src.origSubDir or "";

28+ subDir = evalPackages.lib.strings.removePrefix "/" subDir';

29+ cleanedSource = (haskellLib.cleanSourceWith {

30+ name = if name != null then "${name}-root-cabal-files" else "source-root-cabal-files";

31+ src = src.origSrc or src;

32+ filter = path: type: (!(src ? filter) || src.filter path type) && (

33+ type == "directory" ||

34+ evalPackages.lib.any (i: (evalPackages.lib.hasSuffix i path)) [ stackYaml ".cabal" "package.yaml" ]); });

35+

20 stackToNixArgs = builtins.concatStringsSep " " [

36 stackToNixArgs = builtins.concatStringsSep " " [

21 "--full"

37 "--full"

22− "--stack-yaml=${src}/${if stackYaml == null then "stack.yaml" else stackYaml}"

38+ "--stack-yaml=$SRC${subDir'}/${stackYaml}"

23 (if ignorePackageYaml then "--ignore-package-yaml" else "")

39 (if ignorePackageYaml then "--ignore-package-yaml" else "")

24 "-o ."

40 "-o ."

25 ];

41 ];

@@ -28,26 +44,48 @@ let

28 sha256 = stack-sha256;

44 sha256 = stack-sha256;

29 sha256Arg = "stack-sha256";

45 sha256Arg = "stack-sha256";

30 reasonNotSafe = null;

46 reasonNotSafe = null;

31− } // pkgs.lib.optionalAttrs (checkMaterialization != null) {

47+ this = "project.stack-nix" + (if name != null then " for ${name}" else "");

48+ } // evalPackages.lib.optionalAttrs (checkMaterialization != null) {

32 inherit checkMaterialization;

49 inherit checkMaterialization;

33 }) (runCommand (if name == null then "stack-to-nix-pkgs" else name + "-stack-to-nix-pkgs") {

50 }) (runCommand (if name == null then "stack-to-nix-pkgs" else name + "-stack-to-nix-pkgs") {

34− nativeBuildInputs = [ nix-tools pkgs.nix-prefetch-git pkgs.cacert ];

51+ nativeBuildInputs = [ nix-tools evalPackages.nix-prefetch-git evalPackages.cacert evalPackages.xorg.lndir ];

35 # Needed or stack-to-nix will die on unicode inputs

52 # Needed or stack-to-nix will die on unicode inputs

36− LOCALE_ARCHIVE = pkgs.lib.optionalString (pkgs.stdenv.hostPlatform.libc == "glibc") "${pkgs.glibcLocales}/lib/locale/locale-archive";

53+ LOCALE_ARCHIVE = evalPackages.lib.optionalString (evalPackages.stdenv.hostPlatform.libc == "glibc") "${evalPackages.glibcLocales}/lib/locale/locale-archive";

37 LANG = "en_US.UTF-8";

54 LANG = "en_US.UTF-8";

38 LC_ALL = "en_US.UTF-8";

55 LC_ALL = "en_US.UTF-8";

39 preferLocalBuild = false;

56 preferLocalBuild = false;

40 } (''

57 } (''

41 mkdir -p $out${subDir'}

58 mkdir -p $out${subDir'}

42− '' + pkgs.lib.optionalString (cache != null) ''

59+ SRC=$(mktemp -d)

43− cp ${mkCacheFile cache}/.stack-to-nix.cache* $out${subDir'}

60+ cd $SRC

44− '' + ''

61+ # if cleanedSource is empty, this means it's a new

62+ # project where the files haven't been added to the git

63+ # repo yet. We fail early and provide a useful error

64+ # message to prevent headaches (#290).

65+ if [ -z "$(ls -A ${cleanedSource})" ]; then

66+ echo "cleaned source is empty. Did you forget to 'git add -A'?"; exit 1;

67+ fi

68+ lndir -silent "${cleanedSource}/." $SRC

69+ ${evalPackages.lib.optionalString (subDir != "") "cd ${subDir}"}

70+ ${

71+ # If a resolver was fetched use the it instead of the original stack.yaml

72+ evalPackages.lib.optionalString (fetchedResolver != null)

73+ # Replace the resolver path in the stack.yaml with the fetched version

74+ ''

75+ rm ${stackYaml}

76+ cp ${src}/${stackYaml} .

77+ chmod +w ${stackYaml}

78+ substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

79+ ''}

80+ ${evalPackages.lib.optionalString (cache != null) ''

81+ cp ${mkCacheFile cache}/.stack-to-nix.cache* $out${subDir'}

82+ ''}

45 (cd $out${subDir'} && stack-to-nix ${stackToNixArgs})

83 (cd $out${subDir'} && stack-to-nix ${stackToNixArgs})

46

84

47 # We need to strip out any references to $src, as those won't

85 # We need to strip out any references to $src, as those won't

48 # be accessable in restricted mode.

86 # be accessable in restricted mode.

49 for nixf in $(find $out -name "*.nix" -type f); do

87 for nixf in $(find $out -name "*.nix" -type f); do

50− substituteInPlace $nixf --replace "${src}" "."

88+ substituteInPlace $nixf --replace "$SRC${subDir'}" "."

51 done

89 done

52

90

53 # move pkgs.nix to default.nix ensure we can just nix `import` the result.

91 # move pkgs.nix to default.nix ensure we can just nix `import` the result.

lib/check.nix+25−11

@@ -1,4 +1,4 @@

1−{ stdenv, lib, haskellLib, srcOnly }:

1+{ stdenv, lib, haskellLib }:

2drv:

3

4let

@@ -7,31 +7,45 @@ let

7# This derivation can be used to execute test component.

8# The $out of the derivation is a file containing the resulting

9# stdout output.

10−in stdenv.mkDerivation ({

10+in stdenv.mkDerivation ((

11+ if drv ? source

12+ then {

13+ src = drv.source;

14+ patchPhase =

15+ # This `cd` is normally done in the `prePatch` of the drv

16+ lib.optionalString (drv.srcSubDir != "") ''

17+ cd ${lib.removePrefix "/" drv.srcSubDir}

18+ '';

19+ }

20+ else

21+ # This makes the derivation work a bit like `srcOnly`,

22+ # using the original derivation, but replacing the `buildPhase`.

23+ (drv.drvAttrs or drv) // {

24+ outputs = [ "out" ];

25+ separateDebugInfo = false;

26+ }) // {

11 name = (drv.name + "-check");

27 name = (drv.name + "-check");

12

28

13− # Useing `srcOnly` (rather than getting the `src` via a `drv.passthru`)

14− # should correctly apply the patches from `drv` (if any).

15− src = drv.source or (srcOnly drv);

16−

17 passthru = {

29 passthru = {

18− inherit (drv) identifier config configFiles executableToolDepends cleanSrc env;

30+ inherit (drv) identifier config configFiles executableToolDepends cleanSrc env exeName;

19 };

31 };

20

32

21 inherit (drv) meta LANG LC_ALL buildInputs nativeBuildInputs;

33 inherit (drv) meta LANG LC_ALL buildInputs nativeBuildInputs;

22

34

23 inherit (component) doCheck doCrossCheck;

35 inherit (component) doCheck doCrossCheck;

24

36

25− phases = ["unpackPhase" "buildPhase"];

37+ phases = ["unpackPhase" "patchPhase" "buildPhase"];

26

38

27 # If doCheck or doCrossCheck are false we may still build this

39 # If doCheck or doCrossCheck are false we may still build this

28 # component and we want it to quietly succeed.

40 # component and we want it to quietly succeed.

29 buildPhase = ''

41 buildPhase = ''

30− touch $out

42+ mkdir $out

31−

32 runHook preCheck

43 runHook preCheck

33

44

34− ${toString component.testWrapper} ${drv}/bin/${drv.exeName} ${lib.concatStringsSep " " component.testFlags} | tee $out

45+ ${toString component.testWrapper} ${drv}/bin/${drv.exeName} ${lib.concatStringsSep " " component.testFlags} | tee $out/test-stdout

46+

47+ # Copy over tix files, if they exist

48+ find . -iname '${drv.exeName}.tix' -exec mkdir -p $out/share/hpc/vanilla/tix/${drv.exeName} \; -exec cp {} $out/share/hpc/vanilla/tix/${drv.exeName}/ \;

35

49

36 runHook postCheck

50 runHook postCheck

37 '';

51 '';

lib/clean-cabal-component.nix+106−57

@@ -1,19 +1,55 @@

1# Use cleanSourceWith to filter just the files needed for a particular

2# component of the package

3−{ lib, cleanSourceWith }: package: component: src:

3+{ lib, cleanSourceWith }: package: component: componentName: src:

4let

5− srcStr' = src.origSrcSubDir or src.origSrc or null;

5+ srcStr' = src.origSrc or null;

6+ subDir = if src.origSubDir or "" == ""

7+ then ""

8+ else lib.removePrefix "/" src.origSubDir + "/";

9+ # Remove a directory for each .. part of a path.

10+ removeDotDots = parts: lib.reverseList (

11+ builtins.foldl' (a: b:

12+ if b == ".."

13+ then builtins.tail a

14+ else builtins.concatLists [ [b] a ]) [] parts);

6 # Transform

15 # Transform

7− # "." -> ""

16+ # "." -> ""

8− # "./." -> ""

17+ # "./." -> ""

9− # "./xyz" -> "xyz"

18+ # "./xyz" -> "xyz"

10− normalizeRelativePath = rel:

19+ # "../abc" -> ERROR

11− if rel == "." || rel == "./."

20+ # "abc/.." -> ""

12− then ""

21+ # "abc/../xyz" -> "xyz"

13− else lib.strings.removePrefix "./" rel;

22+ # "abc/./xyz" -> "abc/xyz"

14− # Like normalizeRelativePath but with a trailing / when needed

23+ # "abc/./../xyz" -> "xyz"

15− normalizeRelativeDir = dir:

24+ # "abc/.././xyz" -> "xyz"

16− let p = normalizeRelativePath dir;

25+ # "abc/" -> "abc/"

26+ normalizeRelativePath = path:

27+ let

28+ # Split the path into component parts and remove the empty ones and single dots.

29+ nonEmptyParts = lib.filter (x: x != "" && x != ".") (lib.splitString "/" path);

30+ in lib.concatStringsSep "/" (removeDotDots nonEmptyParts)

31+ # Keep the trailing slash if there was one.

32+ + (if lib.hasSuffix "/" path then "/" else "");

33+ isAbsolutePath = path: lib.hasPrefix "/" path;

34+ isRelativePath = path: !(isAbsolutePath path);

35+ normalizePath = path:

36+ (if isAbsolutePath path

37+ then "/"

38+ else ""

39+ ) + normalizeRelativePath path;

40+ combinePaths = a: b:

41+ if isAbsolutePath b

42+ then b

43+ else normalizePath (

44+ if a == ""

45+ then b

46+ else if b == ""

47+ then a

48+ else a + "/" + b

49+ );

50+ # Like normalizePath but with a trailing / when needed

51+ normalizeDir = dir:

52+ let p = normalizePath dir;

17 in if p == "" || p == "/"

53 in if p == "" || p == "/"

18 then ""

54 then ""

19 else if lib.hasSuffix "/" p

55 else if lib.hasSuffix "/" p

@@ -25,65 +61,78 @@ in

25 else

61 else

26 let

62 let

27 srcStr = toString srcStr';

63 srcStr = toString srcStr';

28− dataDir = normalizeRelativeDir package.dataDir;

64+ dataDir = combinePaths subDir package.dataDir;

29− hsSourceDirs = builtins.map normalizeRelativeDir component.hsSourceDirs

65+ hsSourceDirs = builtins.map (d: combinePaths subDir d) component.hsSourceDirs

30− ++ (if component.hsSourceDirs == [] then [""] else []);

66+ ++ (if component.hsSourceDirs == [] then [subDir] else []);

31− includeDirs = builtins.map normalizeRelativeDir component.includeDirs;

67+ includeDirs = builtins.map (d: combinePaths subDir d) component.includeDirs;

32− dirsNeeded = [dataDir]

68+ # paths that will be needed (used to check if a parent dir should be included)

69+ dirsNeeded =

70+ # These already include subDir

71+ [dataDir]

33 ++ hsSourceDirs

72 ++ hsSourceDirs

34− ++ includeDirs;

73+ ++ includeDirs

74+ ++ builtins.map (f: combinePaths dataDir f) package.dataFiles

75+ ++ otherSourceFiles

76+ ++ builtins.map (d: combinePaths subDir d) (

77+ # These need the subDir added

78+ package.licenseFiles

79+ ++ package.extraSrcFiles

80+ ++ component.extraSrcFiles

81+ ++ package.extraDocFiles);

35 fileMatch = dir: list:

82 fileMatch = dir: list:

36 let

83 let

37− prefixes = builtins.map (f: dir + f) (

84+ prefixes = builtins.map (f: combinePaths dir f) (

38 lib.lists.remove null (lib.lists.flatten (

85 lib.lists.remove null (lib.lists.flatten (

39 builtins.map (f: builtins.match "([^*]*)[*].*" f) list)));

86 builtins.map (f: builtins.match "([^*]*)[*].*" f) list)));

40− exactMatches = builtins.map (f: dataDir + f) (

87+ exactMatches = builtins.map (f: combinePaths dir f) (

41 lib.lists.remove null (lib.lists.flatten (

88 lib.lists.remove null (lib.lists.flatten (

42 builtins.map (f: builtins.match "([^*]*)" f) list)));

89 builtins.map (f: builtins.match "([^*]*)" f) list)));

43 in rPath: lib.any (d: lib.strings.hasPrefix d rPath) prefixes

90 in rPath: lib.any (d: lib.strings.hasPrefix d rPath) prefixes

44 || lib.any (d: d == rPath) exactMatches;

91 || lib.any (d: d == rPath) exactMatches;

45 dataFileMatch = fileMatch dataDir package.dataFiles;

92 dataFileMatch = fileMatch dataDir package.dataFiles;

46− licenseMatch = fileMatch "" package.licenseFiles;

93+ licenseMatch = fileMatch subDir package.licenseFiles;

47− extraSrcMatch = fileMatch "" (

94+ extraSrcMatch = fileMatch subDir (

48 package.extraSrcFiles

95 package.extraSrcFiles

49 ++ component.extraSrcFiles);

96 ++ component.extraSrcFiles);

50− extraDocMatch = fileMatch "" package.extraDocFiles;

97+ extraDocMatch = fileMatch subDir package.extraDocFiles;

51− otherSourceFiles =

98+ otherSourceFiles = builtins.map (f: combinePaths subDir f) (

52 component.asmSources

99 component.asmSources

53 ++ component.cmmSources

100 ++ component.cmmSources

54 ++ component.cSources

101 ++ component.cSources

55 ++ component.cxxSources

102 ++ component.cxxSources

56− ++ component.jsSources;

103+ ++ component.jsSources);

57 in cleanSourceWith {

104 in cleanSourceWith {

58− inherit src;

105+ name = src.name or "source" + "-${componentName}";

59− filter = path: type:

106+ subDir = lib.removePrefix "/" (src.origSubDir or "");

60− assert (if !lib.strings.hasPrefix (srcStr + "/") (path + "/")

107+ includeSiblings = true;

61− then throw ("Unexpected path " + path + " (expected something in " + srcStr + "/)")

108+ src = cleanSourceWith {

62− else true);

109+ src = src.origSrc or src;

63− let

110+ filter = path: type:

64− srcStrLen = lib.strings.stringLength srcStr;

111+ (!(src ? filter) || src.filter path type) && (

65− rPath = lib.strings.substring (srcStrLen + 1) (lib.strings.stringLength path - srcStrLen - 1) path;

112+ assert (if !lib.strings.hasPrefix (srcStr + "/") (path + "/")

66− # This is a handy way to find out why different files are included

113+ then throw ("Unexpected path " + path + " (expected something in " + srcStr + "/)")

67− # traceReason = reason: v: if v then builtins.trace (rPath + " : " + reason) true else false;

114+ else true);

68− traceReason = reason: v: v;

115+ let

69− in

116+ srcStrLen = lib.strings.stringLength srcStr;

70− traceReason "directory is needed" (

117+ rPath = lib.strings.substring (srcStrLen + 1) (lib.strings.stringLength path - srcStrLen - 1) path;

71− lib.any (d: lib.strings.hasPrefix (rPath + "/") d) (

118+ # This is a handy way to find out why different files are included

72− dirsNeeded

119+ # traceReason = reason: v: if v then builtins.trace (rPath + " : " + reason) true else false;

73− ++ package.licenseFiles

120+ traceReason = reason: v: v;

74− ++ package.extraSrcFiles

121+ in

75− ++ component.extraSrcFiles

122+ traceReason "directory is needed" (

76− ++ package.extraDocFiles

123+ lib.any (d: lib.strings.hasPrefix (rPath + "/") d) dirsNeeded)

77− ++ builtins.map (f: dataDir + f) package.dataFiles

124+ || traceReason "cabal package definition" (lib.strings.hasPrefix subDir rPath

78− ++ otherSourceFiles))

125+ && lib.strings.hasSuffix ".cabal" rPath)

79− || traceReason "cabal package definition" (lib.strings.hasSuffix ".cabal" rPath)

126+ || traceReason "hpack package defintion" (lib.strings.hasPrefix subDir rPath

80− || traceReason "hpack package defintion" (rPath == "package.yaml")

127+ && rPath == "package.yaml")

81− || traceReason "data file" (lib.strings.hasPrefix dataDir rPath

128+ || traceReason "data file" (lib.strings.hasPrefix dataDir rPath

82− && dataFileMatch rPath)

129+ && dataFileMatch rPath)

83− || traceReason "haskell source dir" (lib.any (d: lib.strings.hasPrefix d rPath) hsSourceDirs)

130+ || traceReason "haskell source dir" (lib.any (d: lib.strings.hasPrefix d rPath) hsSourceDirs)

84− || traceReason "include dir" (lib.any (d: lib.strings.hasPrefix d rPath) includeDirs)

131+ || traceReason "include dir" (lib.any (d: lib.strings.hasPrefix d rPath) includeDirs)

85− || traceReason "license file" (licenseMatch rPath)

132+ || traceReason "license file" (licenseMatch rPath)

86− || traceReason "extra source file" (extraSrcMatch rPath)

133+ || traceReason "extra source file" (extraSrcMatch rPath)

87− || traceReason "extra doc file" (extraDocMatch rPath)

134+ || traceReason "extra doc file" (extraDocMatch rPath)

88− || traceReason "other source file" (lib.any (f: f == rPath) otherSourceFiles);

135+ || traceReason "other source file" (lib.any (f: f == rPath) otherSourceFiles)

89− }

136+ );

137+ };

138+ }

lib/clean-git.nix+97−54

@@ -1,6 +1,6 @@

1# From https://github.com/NixOS/nix/issues/2944

2{ lib, runCommand, git, cleanSourceWith }:

3−{ name ? null, src, subDir ? "" }:

3+{ name ? null, src, subDir ? "", includeSiblings ? false, keepGitDir ? false }:

4

5# The function call

6#

@@ -24,26 +24,6 @@ with builtins;

24# is shared among multiple invocations of gitSource:

25

26let

27− filter_from_list = root: files:

28− let

29− all_paren_dirs = p:

30− if p == "." || p == "/"

31− then []

32− else [ p ] ++ all_paren_dirs (dirOf p);

33−

34− whitelist_set = listToAttrs (

35− concatMap (p:

36− # Using `origSrcSubDir` (if present) makes it possible to cleanGit src that

37− # has already been cleaned with cleanSrcWith.

38− let full_path = root.origSrcSubDir or (toString root) + "/${p}"; in

39− map (p': { name = p'; value = true; }) (all_paren_dirs full_path)

40− ) files

41− );

42− in

43− p: t: hasAttr (toString p) whitelist_set;

44−

45− has_prefix = prefix: s:

46− prefix == builtins.substring 0 (builtins.stringLength prefix) s;

47 remove_prefix = prefix: s:

27 remove_prefix = prefix: s:

48 builtins.substring

28 builtins.substring

49 (builtins.stringLength prefix)

29 (builtins.stringLength prefix)

@@ -51,13 +31,15 @@ let

51 s;

31 s;

52

32

53 lines = s: filter (x : x != [] && x != "") (split "\n" s);

33 lines = s: filter (x : x != [] && x != "") (split "\n" s);

34+

35+ origSrcSubDir = toString (src.origSrcSubDir or src);

54in

36in

55

37

56−if builtins.pathExists (toString src + "/.git")

38+if builtins.pathExists (origSrcSubDir + "/.git")

57then

39then

58 let

40 let

59− hasIndex = builtins.pathExists (toString src + "/.git/index");

41+ hasIndex = builtins.pathExists (origSrcSubDir + "/.git/index");

60− isWorktree = (builtins.readDir (toString src)).".git" == "regular";

42+ isWorktree = (builtins.readDir origSrcSubDir).".git" == "regular";

61

43

62 # Identify the .git directory and filter just the files that we need.

44 # Identify the .git directory and filter just the files that we need.

63 gitDir = cleanSourceWith ({

45 gitDir = cleanSourceWith ({

@@ -74,19 +56,23 @@ then

74 if hasIndex

56 if hasIndex

75 then { inherit src; subDir = ".git"; }

57 then { inherit src; subDir = ".git"; }

76 else if !isWorktree

58 else if !isWorktree

77− then abort "cleanGit: ${toString src + "/.git"} has no index file"

59+ then abort "cleanGit: ${origSrcSubDir + "/.git"} has no index file"

78 else {

60 else {

79 # likely a git worktree, so follow the indirection

61 # likely a git worktree, so follow the indirection

80 src =

62 src =

81 let

63 let

82− git_content = lines (readFile (toString src + "/.git"));

64+ git_content = lines (readFile (origSrcSubDir + "/.git"));

83 first_line = head git_content;

65 first_line = head git_content;

84 prefix = "gitdir: ";

66 prefix = "gitdir: ";

85− ok = length git_content == 1 && has_prefix prefix first_line;

67+ ok = length git_content == 1 && lib.hasPrefix prefix first_line;

68+ raw_path = remove_prefix prefix first_line;

86 in

69 in

87 if ok

70 if ok

88− then /. + remove_prefix prefix first_line

71+ then

89− else abort "gitSource.nix: Cannot parse ${toString src + "/.git"}";

72+ if lib.hasPrefix "/" raw_path

73+ then /. + raw_path

74+ else /. + builtins.toPath (origSrcSubDir + "/" + raw_path)

75+ else abort "gitSource.nix: Cannot parse ${origSrcSubDir + "/.git"}";

90 }));

76 }));

91

77

92 # Worktrees have a commondir pointing to the common `.git` dir. We need the

78 # Worktrees have a commondir pointing to the common `.git` dir. We need the

@@ -102,35 +88,40 @@ then

102 else gitDir + "/config";

88 else gitDir + "/config";

103

89

104 # We need the .gitmodules file for submoules to work.

90 # We need the .gitmodules file for submoules to work.

105− gitModulesStr = toString src + "/.gitmodules";

91+ gitModulesStr = origSrcSubDir + "/.gitmodules";

106 gitModules = builtins.path { name = "gitmodules"; path = gitModulesStr; };

92 gitModules = builtins.path { name = "gitmodules"; path = gitModulesStr; };

107

93

108− gitSubmoduleFiles = cleanSourceWith {

94+ # Files from the git repository related knownSubmoduleDirs.

109− caller = "cleanGit";

95+ gitSubmoduleFiles = knownSubmoduleDirs:

110− name = (if name == null then "" else name + "-") + "gitSubmoduleFiles";

96+ let pathsNeeded = map (p: toString (src.origSrcSubDir or src) + "/${p}") (

111− inherit src;

97+ lib.concatMap (x: all_paren_dirs (x + "/.git")) knownSubmoduleDirs);

112− filter = path: type:

98+ in cleanSourceWith {

113− type == "directory" # TODO get sudmodule directories from `.gitmodules`

99+ caller = "cleanGit";

114− # and use that to filter directory tree here

100+ name = (if name == null then "" else name + "-") + "gitSubmoduleFiles";

115− ||

101+ inherit src;

116− lib.any (i: (lib.hasSuffix i path)) [

102+ filter = path: type:

117− "/.git" ".gitmodules" ".git/config" ".git/index" ".git/HEAD" ".git/objects" ".git/refs" ] ||

103+ elem path pathsNeeded

118− (lib.strings.hasInfix ".git/modules/" path &&

104+ ||

119 lib.any (i: (lib.hasSuffix i path)) [

105 lib.any (i: (lib.hasSuffix i path)) [

120− "config" "index" "HEAD" "objects" "refs" ]);

106+ ".gitmodules" ".git/config" ".git/index" ".git/HEAD" ".git/objects" ".git/refs" ]

121− };

107+ ||

108+ (lib.strings.hasInfix ".git/modules/" path &&

109+ lib.any (i: (lib.hasSuffix i path)) [

110+ "config" "index" "HEAD" "objects" "refs" ]);

111+ };

112+

113+ hasSubmodules = !isWorktree && builtins.pathExists gitModulesStr;

122

114

123 # Make a temporary dir that looks enough like the real thing for

115 # Make a temporary dir that looks enough like the real thing for

124 # `git ls-files --recurse-submodules` to give us an accurate list

116 # `git ls-files --recurse-submodules` to give us an accurate list

125 # of all the files in the index.

117 # of all the files in the index.

126− whitelist_file =

118+ whitelist_files = knownSubmoduleDirs:

127− runCommand "git-ls-files" {envVariable = true;} ''

119+ runCommand "git-ls-files" { preferLocalBuild = true; } ''

128 tmp=$(mktemp -d)

120 tmp=$(mktemp -d)

129 cd $tmp

121 cd $tmp

130− ${ lib.optionalString (!isWorktree && builtins.pathExists gitModulesStr) ''

122+ ${ lib.optionalString hasSubmodules ''

131− cp -ra ${gitSubmoduleFiles}/. $tmp

123+ cp -ra ${gitSubmoduleFiles knownSubmoduleDirs}/. $tmp

132 chmod +w -R $tmp

124 chmod +w -R $tmp

133− rm -rf .git

134 ''}

125 ''}

135 cp -r ${gitDir} .git

126 cp -r ${gitDir} .git

136 chmod +w -R .git

127 chmod +w -R .git

@@ -141,22 +132,74 @@ then

141 ${ lib.optionalString (isWorktree && builtins.pathExists gitModulesStr) ''

132 ${ lib.optionalString (isWorktree && builtins.pathExists gitModulesStr) ''

142 cp ${gitModules} ./.gitmodules

133 cp ${gitModules} ./.gitmodules

143 ''}

134 ''}

144− ${git}/bin/git ls-files --recurse-submodules > $out

135+ mkdir $out

136+ ${ lib.optionalString hasSubmodules ''

137+ ${git}/bin/git submodule status --recursive | awk '{ print $2 }' > $out/submoduleDirs

138+ ''}

139+ ${git}/bin/git ls-files --recurse-submodules > $out/files

145 '';

140 '';

146

141

147− whitelist = lines (readFile (whitelist_file.out));

142+ # Find the submodules

143+ whitelist_recursive = knownSubmoduleDirs:

144+ let

145+ # Get the new list of submoduleDirs and files

146+ # (useing the submoduleDirs we already know about)

147+ files = whitelist_files knownSubmoduleDirs;

148+ new = {

149+ submoduleDirs = lines (readFile (files + "/submoduleDirs"));

150+ files = lines (readFile (files + "/files"));

151+ };

152+ in

153+ # If we are not expecting submodules or if the new list does not

154+ # contain any additional submodules we are done.

155+ if !hasSubmodules || lib.all (x: elem x knownSubmoduleDirs) new.submoduleDirs

156+ then new

157+ else

158+ # Look again using what we know now about the submodules

159+ whitelist_recursive new.submoduleDirs;

160+

161+ # Use empty as a starting point for looking for submodules.

162+ # We could allow a list to be passed into cleanGit, but when testing

163+ # on the `ghcjs` repo (one with a lot of submodules) it did not

164+ # make much of a difference to the speed of `cleanGit`.

165+ whitelist = whitelist_recursive [];

166+

167+ all_paren_dirs = p:

168+ if p == "." || p == "/"

169+ then []

170+ else [ p ] ++ all_paren_dirs (dirOf p);

171+

172+ # All the paths that we need to keep as a set (including parent dirs)

173+ whitelist_set = listToAttrs (

174+ concatMap (p:

175+ # Using `origSrcSubDir` (if present) makes it possible to cleanGit src that

176+ # has already been cleaned with cleanSrcWith.

177+ let full_path = toString (src.origSrcSubDir or src) + "/${p}"; in

178+ map (p': { name = p'; value = true; }) (all_paren_dirs full_path)

179+ ) whitelist.files

180+ );

181+

182+ # Identify files in the `.git` dir

183+ isGitDirPath = path:

184+ path == origSrcSubDir + "/.git"

185+ || lib.hasPrefix (origSrcSubDir + "/.git/") path;

148

186

149− filter = filter_from_list src whitelist;

187+ filter = path: type:

188+ hasAttr (toString path) whitelist_set

189+ || (keepGitDir && isGitDirPath path);

150 in

190 in

151 cleanSourceWith {

191 cleanSourceWith {

152 caller = "cleanGit";

192 caller = "cleanGit";

153− inherit name src subDir filter;

193+ inherit name src subDir includeSiblings filter;

194+ } // {

195+ # For testing

196+ # inherit whitelist whitelist_set;

154 }

197 }

155

198

156else

199else

157− trace "gitSource.nix: ${toString src} does not seem to be a git repository,\nassuming it is a clean checkout." (

200+ trace "haskell-nix.haskellLib.cleanGit: ${origSrcSubDir} does not seem to be a git repository,\nassuming it is a clean checkout." (

158 cleanSourceWith {

201 cleanSourceWith {

159 caller = "cleanGit";

202 caller = "cleanGit";

160− inherit name src subDir;

203+ inherit name src subDir includeSiblings;

161 }

204 }

162 )

205 )

lib/clean-source-haskell.nix+2−16

@@ -1,7 +1,7 @@

1# This is a source filter function which cleans common build products

2# and files not needed to do a haskell build from a source directory.

3#

4−# This can avoid unecessary builds when these files change.

4+# This can avoid unnecessary builds when these files change.

5#

6# It should be used with "pkgs.lib.cleanSourceWith". Alternatively,

7# use the convenience function "cleanSourceHaskell".

@@ -35,21 +35,7 @@ rec {

35 src = lib.cleanSource src;

36 inherit name;

37 };

38− # Copy function from 19.09 for compatibility with 19.03.

39− # Does require at least Nix 2.0.

40− compat = let

41− isFiltered = src ? _isLibCleanSourceWith;

42− origSrc = if isFiltered then src.origSrc else src;

43− filter' = name: type: haskellSourceFilter name type && lib.cleanSourceFilter name type;

44− name' = if name != null then name else if isFiltered then src.name else baseNameOf src;

45− in {

46− inherit origSrc;

47− filter = filter';

48− outPath = builtins.path { filter = filter'; path = origSrc; name = name'; };

49− _isLibCleanSourceWith = true;

50− name = name';

51− };

52 in

38 in

53 if (builtins.typeOf src) == "path"

39 if (builtins.typeOf src) == "path"

54− then (if lib.versionAtLeast lib.version "19.09" then clean else compat) else src;

40+ then clean else src;

55}

41}

lib/clean-source-with.nix+38−11

@@ -40,7 +40,7 @@

40 # relative references to those siblings will work.

41 #

42 # name: Optional name to use as part of the store path.

43− # If you do not provide a `name` it wil be derived

43+ # If you do not provide a `name` it will be derived

44 # from the `subDir`. You should provide `name` or

45 # `subDir`. If you do not a warning will be displayed

46 # and the name used will be `source`.

@@ -50,6 +50,33 @@

50 # (and forward a `name` argument) can use this to make

51 # the message to the use more meaningful.

52 #

53+ # Nix <2.4 Suport with filterPath

54+ #

55+ # As of Nix >=2.4 filtering is now possible on all paths (including those in the store).

56+ # If you still need to support older versions of Nix and want to maximise cache hits for your project

57+ # you may want to consider using setting the `filterPath` attribute on `src` (must be done on

58+ # the original src not the output of another `cleanSourceWith`).

59+ #

60+ # To disable filtering completely replace:

61+ #

62+ # src = ./.;

63+ #

64+ # with:

65+ #

66+ # src = { outPath = ./.; filterPath = { path, ... }: path; };

67+ #

68+ # To disable filtering only when the path is in the store use (when Nix <2.4 is unable to filter it):

69+ #

70+ # src = {

71+ # outPath = ./.;

72+ # filterPath = { path, ... }@args:

73+ # if builtins.hasContext (toString path) then path else builtins.path args;

74+ # };

75+ #

76+ # Currently `haskell-nix.hackage-project` (used by `hackage-package`, `tool` and `tools`) disables

77+ # filtering. See `overlays/haskell.nix` for details.

78+ #

79+ # For more see https://github.com/input-output-hk/haskell.nix/pull/1418

53 cleanSourceWith = { filter ? _path: _type: true, src, subDir ? "", name ? null

80 cleanSourceWith = { filter ? _path: _type: true, src, subDir ? "", name ? null

54 , caller ? "cleanSourceWith", includeSiblings ? false }:

81 , caller ? "cleanSourceWith", includeSiblings ? false }:

55 let

82 let

@@ -80,7 +107,7 @@

80 else

107 else

81 if subDirName != ""

108 if subDirName != ""

82 then if src ? name

109 then if src ? name

83− then src.name + "-" + subDirName

110+ then src.name + "-" + subDirName

84 else "source-" + subDirName

111 else "source-" + subDirName

85 else if src ? name

112 else if src ? name

86 then src.name

113 then src.name

@@ -103,21 +130,21 @@

103 __trace (

130 __trace (

104 "WARNING: `${caller}` called on ${toString src} without a `name`. "

131 "WARNING: `${caller}` called on ${toString src} without a `name`. "

105 + "Consider adding `name = \"${baseNameOf src}\";`") "source";

132 + "Consider adding `name = \"${baseNameOf src}\";`") "source";

133+ filterPath = origSrc.filterPath or (

134+ if builtins.compareVersions builtins.nixVersion "2.4" >= 0

135+ then builtins.path

136+ else __trace "WARNING: Using nix <2.4 will result in inconsistent filtering of ${toString origSrc} (see lib/clean-source-with.nix)"

137+ (if builtins.hasContext or (lib.hasPrefix builtins.storeDir) (toString origSrc)

138+ then { path, ... }: path

139+ else builtins.path));

106 in {

140 in {

107 inherit origSrc origSubDir origSrcSubDir;

141 inherit origSrc origSubDir origSrcSubDir;

108 filter = filter';

142 filter = filter';

109− outPath = (builtins.path { filter = filter'; path = origSrc; name = name'; }) + origSubDir;

143+ outPath = (filterPath { filter = filter'; path = origSrc; name = name'; }) + origSubDir;

110 _isLibCleanSourceWithEx = true;

144 _isLibCleanSourceWithEx = true;

111 # It is only safe for older cleanSourceWith to filter this one

145 # It is only safe for older cleanSourceWith to filter this one

112 # if the we are still looking at the root of origSrc

146 # if the we are still looking at the root of origSrc

113 _isLibCleanSourceWith = origSubDir == "";

147 _isLibCleanSourceWith = origSubDir == "";

114 name = name';

148 name = name';

115 };

149 };

116−

150+}

117− pathHasContext = builtins.hasContext or (lib.hasPrefix builtins.storeDir);

118−

119− canCleanSource = src:

120− src ? _isLibCleanSourceWithEx

121− || src ? _isLibCleanSourceWith

122− || !(pathHasContext (toString src));

123−}

lib/cover-project.nixnew file+150

@@ -0,0 +1,150 @@

1+# A project coverage report is a composition of package coverage

2+# reports

3+{ stdenv, pkgs, lib, haskellLib }:

4+

5+# haskell.nix project

6+project:

7+# List of coverage reports to accumulate

8+coverageReports:

9+

10+let

11+ toBashArray = arr: "(" + (lib.concatStringsSep " " arr) + ")";

12+

13+ # Create a list element for a project coverage index page.

14+ coverageListElement = coverageReport:

15+ ''

16+ <li>

17+ <a href="${coverageReport.passthru.name}/hpc_index.html">${coverageReport.passthru.name}</a>

18+ </li>

19+ '';

20+

21+ projectIndexHtml = pkgs.writeText "index.html" ''

22+ <html>

23+ <head>

24+ <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

25+ </head>

26+ <body>

27+ <div>

28+ WARNING: Modules with no coverage are not included in any of these reports, this is just how HPC works under the hood.

29+ </div>

30+ <div>

31+ <h2>Union Report</h2>

32+ <p>The following report shows how each module is covered by any test in the project:</p>

33+ <ul>

34+ <li>

35+ <a href="all/hpc_index.html">all</a>

36+ </li>

37+ </ul>

38+ </div>

39+ <div>

40+ <h2>Individual Reports</h2>

41+ <p>The following reports show how the tests of each package cover modules in the project:</p>

42+ <ul>

43+ ${with lib; concatStringsSep "\n" (map coverageListElement coverageReports)}

44+ </ul>

45+ </div>

46+ </body>

47+ </html>

48+ '';

49+

50+ ghc = project.pkg-set.config.ghc.package;

51+

52+ libs = lib.unique (lib.concatMap (r: r.mixLibraries) coverageReports);

53+

54+ mixDirs =

55+ map

56+ (l: "${l}/share/hpc/vanilla/mix/${l.identifier.name}-${l.identifier.version}")

57+ libs;

58+

59+ srcDirs = map (l: l.srcSubDirPath) libs;

60+

61+ allCoverageReport = haskellLib.coverageReport {

62+ name = "all";

63+ checks = lib.flatten (lib.concatMap

64+ (pkg: lib.optional (pkg ? checks) (lib.filter lib.isDerivation (lib.attrValues pkg.checks)))

65+ (lib.attrValues (haskellLib.selectProjectPackages project.hsPkgs)));

66+ mixLibraries = lib.concatMap

67+ (pkg: lib.optional (pkg.components ? library) pkg.components.library)

68+ (lib.attrValues (haskellLib.selectProjectPackages project.hsPkgs));

69+ ghc = project.pkg-set.config.ghc.package;

70+ };

71+

72+in pkgs.runCommand "project-coverage-report"

73+ ({ nativeBuildInputs = [ (ghc.buildGHC or ghc) pkgs.buildPackages.zip ];

74+ LANG = "en_US.UTF-8";

75+ LC_ALL = "en_US.UTF-8";

76+ } // lib.optionalAttrs (stdenv.buildPlatform.libc == "glibc") {

77+ LOCALE_ARCHIVE = "${pkgs.buildPackages.glibcLocales}/lib/locale/locale-archive";

78+ })

79+ ''

80+ function markup() {

81+ local -n srcDs=$1

82+ local -n mixDs=$2

83+ local -n includedModules=$3

84+ local destDir=$4

85+ local tixFile=$5

86+

87+ local hpcMarkupCmd=("hpc" "markup" "--destdir=$destDir")

88+ for srcDir in "''${srcDs[@]}"; do

89+ hpcMarkupCmd+=("--srcdir=$srcDir")

90+ done

91+

92+ for mixDir in "''${mixDs[@]}"; do

93+ hpcMarkupCmd+=("--hpcdir=$mixDir")

94+ done

95+

96+ for module in "''${includedModules[@]}"; do

97+ hpcMarkupCmd+=("--include=$module")

98+ done

99+

100+ hpcMarkupCmd+=("$tixFile")

101+

102+ echo "''${hpcMarkupCmd[@]}"

103+ eval "''${hpcMarkupCmd[@]}"

104+ }

105+

106+ function findModules() {

107+ local searchDir=$2

108+ local pattern=$3

109+

110+ pushd $searchDir

111+ mapfile -d $'\0' $1 < <(find ./ -type f \

112+ -wholename "$pattern" -not -name "Paths*" \

113+ -exec basename {} \; \

114+ | sed "s/\.mix$//" \

115+ | tr "\n" "\0")

116+ popd

117+ }

118+

119+ mkdir -p $out/nix-support

120+ mkdir -p $out/share/hpc/vanilla/tix/all

121+ mkdir -p $out/share/hpc/vanilla/mix/

122+ mkdir -p $out/share/hpc/vanilla/html/

123+

124+ # Find all tix files in each package

125+ tixFiles=()

126+ ${with lib; concatStringsSep "\n" (map (coverageReport: ''

127+ identifier="${coverageReport.name}"

128+ report=${coverageReport}

129+ tix="$report/share/hpc/vanilla/tix/$identifier/$identifier.tix"

130+ if test -f "$tix"; then

131+ tixFiles+=("$tix")

132+ fi

133+

134+ # Copy mix, tix, and html information over from each report

135+ cp -Rn $report/share/hpc/vanilla/mix/$identifier $out/share/hpc/vanilla/mix/

136+ cp -R $report/share/hpc/vanilla/tix/* $out/share/hpc/vanilla/tix/

137+ cp -R $report/share/hpc/vanilla/html/* $out/share/hpc/vanilla/html/

138+ '') coverageReports)}

139+

140+ # Copy out "all" coverage report

141+ cp -R ${allCoverageReport}/share/hpc/vanilla/tix/all $out/share/hpc/vanilla/tix

142+ cp -R ${allCoverageReport}/share/hpc/vanilla/html/all $out/share/hpc/vanilla/html

143+

144+ # Markup a HTML coverage summary report for the entire project

145+ cp ${projectIndexHtml} $out/share/hpc/vanilla/html/index.html

146+

147+ echo "report coverage $out/share/hpc/vanilla/html/index.html" >> $out/nix-support/hydra-build-products

148+ ( cd $out/share/hpc/vanilla/html ; zip -r $out/share/hpc/vanilla/html.zip . )

149+ echo "file zip $out/share/hpc/vanilla/html.zip" >> $out/nix-support/hydra-build-products

150+ ''

lib/cover.nixnew file+204

@@ -0,0 +1,204 @@

1+# The following collects coverage information from a set of given "checks" and

2+# provides a coverage report showing how those "checks" cover a set of given

3+# "mixLibraries".

4+{ stdenv, lib, haskellLib, pkgs }:

5+

6+# Name of the coverage report, which should be unique.

7+{ name

8+# List of check derivations that generate coverage.

9+, checks ? []

10+# List of libraries to include in the coverage report. If one of the above

11+# checks generates coverage for a particular library, coverage will only

12+# be included if that library is in this list.

13+, mixLibraries ? []

14+# Hack for project-less projects.

15+, ghc ? if mixLibraries == [] then null else (lib.head mixLibraries).project.pkg-set.config.ghc.package

16+}:

17+

18+let

19+ toBashArray = arr: "(" + (lib.concatStringsSep " " arr) + ")";

20+

21+ mixDir = l: "${l}/share/hpc/vanilla/mix/${l.identifier.name}-${l.identifier.version}";

22+ mixDirs = map mixDir mixLibraries;

23+

24+ srcDirs = map (l: l.srcSubDirPath) mixLibraries;

25+

26+in pkgs.runCommand (name + "-coverage-report")

27+ ({nativeBuildInputs = [ (ghc.buildGHC or ghc) pkgs.buildPackages.zip ];

28+ passthru = {

29+ inherit name checks mixLibraries;

30+ };

31+ # HPC will fail if the Haskell file contains non-ASCII characters,

32+ # unless our locale is set correctly. This has been fixed, but we

33+ # don't know what version of HPC we will be using, hence we should

34+ # always use the workaround.

35+ # https://gitlab.haskell.org/ghc/ghc/-/issues/17073

36+ LANG = "en_US.UTF-8";

37+ LC_ALL = "en_US.UTF-8";

38+ } // lib.optionalAttrs (stdenv.buildPlatform.libc == "glibc") {

39+ LOCALE_ARCHIVE = "${pkgs.buildPackages.glibcLocales}/lib/locale/locale-archive";

40+ })

41+ ''

42+ function markup() {

43+ local -n srcDs=$1

44+ local -n mixDs=$2

45+ local -n includedModules=$3

46+ local destDir=$4

47+ local tixFile=$5

48+

49+ local hpcMarkupCmd=("hpc" "markup" "--destdir=$destDir")

50+ for srcDir in "''${srcDs[@]}"; do

51+ hpcMarkupCmd+=("--srcdir=$srcDir")

52+ done

53+

54+ for mixDir in "''${mixDs[@]}"; do

55+ hpcMarkupCmd+=("--hpcdir=$mixDir")

56+ done

57+

58+ for module in "''${includedModules[@]}"; do

59+ hpcMarkupCmd+=("--include=$module")

60+ done

61+

62+ hpcMarkupCmd+=("$tixFile")

63+

64+ echo "''${hpcMarkupCmd[@]}"

65+ eval "''${hpcMarkupCmd[@]}"

66+ }

67+

68+ function sumTix() {

69+ local -n includedModules=$1

70+ local -n tixFs=$2

71+ local outFile="$3"

72+

73+ if (( "''${#tixFs[@]}" > 0 )); then

74+ local hpcSumCmd=("hpc" "sum" "--union" "--output=$outFile")

75+

76+ for module in "''${includedModules[@]}"; do

77+ hpcSumCmd+=("--include=$module")

78+ done

79+

80+ for tixFile in "''${tixFs[@]}"; do

81+ hpcSumCmd+=("$tixFile")

82+ done

83+

84+ echo "''${hpcSumCmd[@]}"

85+ eval "''${hpcSumCmd[@]}"

86+ else

87+ # If there are no tix files we output an empty tix file so that we can

88+ # markup an empty HTML coverage report. This is preferable to failing to

89+ # output a HTML report.

90+ echo 'Tix []' > $outFile

91+ fi

92+ }

93+

94+ function findModules() {

95+ local -n result=$1

96+ local -n searchDirs=$2

97+ local pattern=$3

98+

99+ for dir in "''${searchDirs[@]}"; do

100+ pushd $dir

101+ local temp=()

102+ mapfile -d $'\0' temp < <(find ./ -type f \

103+ -wholename "$pattern" -not -name "Paths*" \

104+ -exec basename {} \; \

105+ | sed "s/\.mix$//" \

106+ | tr "\n" "\0")

107+ result+=("''${temp[@]}")

108+ popd

109+ done

110+ }

111+

112+ mkdir -p $out/nix-support

113+ mkdir -p $out/share/hpc/vanilla/mix/

114+ mkdir -p $out/share/hpc/vanilla/tix/${name}

115+ mkdir -p $out/share/hpc/vanilla/html/${name}

116+

117+ local srcDirs=${toBashArray srcDirs}

118+ local mixDirs=${toBashArray mixDirs}

119+

120+ # Copy out mix files used for this report

121+ for dir in "''${mixDirs[@]}"; do

122+ if [ -d "$dir" ]; then

123+ cp -R "$dir" $out/share/hpc/vanilla/mix/

124+ fi

125+ done

126+

127+ local mixModules=()

128+ # Mix modules for all packages in "mixLibraries"

129+ findModules mixModules mixDirs "*.mix"

130+

131+ # We need to make a distinction between library "exposed-modules" and

132+ # "other-modules" used in test suites:

133+ # - "exposed-modules" are addressed as "$library-$version-$hash/module"

134+ # - "other-modules" are addressed as "module"

135+ #

136+ # This complicates the code required to find the mix modules. For a given mix directory:

137+ #

138+ # mix

139+ # └── ntp-client-0.0.1

140+ # └── ntp-client-0.0.1-gYjRsBHUCaHX7ENcjHnw5

141+ # ├── Network.NTP.Client.mix

142+ # ├── Network.NTP.Client.Packet.mix

143+ # └── Network.NTP.Client.Query.mix

144+ #

145+ # Iff ntp-client uses "other-modules" in a test suite, both:

146+ # - "mix/ntp-client-0.0.1", and

147+ # - "mix/ntp-client-0.0.1/ntp-client-0.0.1-gYjRsBHUCaHX7ENcjHnw5"

148+ # need to be provided to hpc as search directories.

149+ #

150+ # I'd prefer to just exclude "other-modules", but I can't think of an easy

151+ # way to do that in bash.

152+ #

153+ # Here we expand the search dirs and modify the mix dirs accordingly:

154+ for dir in "''${mixDirs[@]}"; do

155+ local otherModulesSearchDirs=()

156+ # Simply consider any directory with a mix file as a search directory.

157+ mapfile -d $'\0' otherModulesSearchDirs < <(find $dir -type f \

158+ -wholename "*.mix" \

159+ -exec dirname {} \; \

160+ | uniq \

161+ | tr "\n" "\0")

162+ mixDirs+=("''${otherModulesSearchDirs[@]}")

163+ done

164+

165+ local tixFiles=()

166+ ${lib.concatStringsSep "\n" (builtins.map (check: ''

167+ if [ -d "${check}/share/hpc/vanilla/tix" ]; then

168+ pushd ${check}/share/hpc/vanilla/tix

169+

170+ tixFile="$(find . -iwholename "*.tix" -type f -print -quit)"

171+ local newTixFile=$out/share/hpc/vanilla/tix/${check.name}/"$(basename $tixFile)"

172+

173+ mkdir -p "$(dirname $newTixFile)"

174+ # Copy over the tix file verbatim

175+ cp "$tixFile" "$newTixFile"

176+

177+ # Add the tix file to our list

178+ tixFiles+=("$newTixFile")

179+

180+ # Create a coverage report for *just that check* affecting any of the

181+ # "mixLibraries"

182+ markup srcDirs mixDirs mixModules "$out/share/hpc/vanilla/html/${check.name}/" "$newTixFile"

183+

184+ popd

185+ fi

186+ '') checks)

187+ }

188+

189+ # Sum tix files to create a tix file with tix information from all tests in

190+ # the package and markup a HTML report from this info.

191+ local sumTixFile="$out/share/hpc/vanilla/tix/${name}/${name}.tix"

192+ local markupOutDir="$out/share/hpc/vanilla/html/${name}"

193+

194+ # Sum all of our tix files

195+ sumTix mixModules tixFiles "$sumTixFile"

196+

197+ # Markup a HTML report

198+ markup srcDirs mixDirs mixModules "$markupOutDir" "$sumTixFile"

199+

200+ # Provide a HTML zipfile and Hydra links

201+ ( cd "$markupOutDir" ; zip -r $out/share/hpc/vanilla/${name}-html.zip . )

202+ echo "report coverage $markupOutDir/hpc_index.html" >> $out/nix-support/hydra-build-products

203+ echo "file zip $out/share/hpc/vanilla/${name}-html.zip" >> $out/nix-support/hydra-build-products

204+ ''

lib/default.nix+122−40

@@ -4,11 +4,8 @@

4with haskellLib;

5

6let

7− # Why `final.evalPackages.buildPackages.gitMinimal`?

7+ # Why `final.buildPackages.buildPackages.gitMinimal`?

8− # Why not just final.evalPackages.gitMinimal?

8+ # Why not just final.buildPackages.gitMinimal?

9− #

10− # A problem arises when `evalPackages` is `buildPackages`.i

11− # As may be the case in a flake.

12 #

9 #

13 # It turns out `git` depends on `gdb` in a round about way:

10 # It turns out `git` depends on `gdb` in a round about way:

14 # git -> openssh -> libfido2 -> systemd -> python libxml -> Cython -> gdb

11 # git -> openssh -> libfido2 -> systemd -> python libxml -> Cython -> gdb

@@ -24,7 +21,7 @@ let

24 # * When `gdb` does not exist for `js`, so when cross

21 # * When `gdb` does not exist for `js`, so when cross

25 # compiling with ghcjs `final.buildPackages.git` fails

22 # compiling with ghcjs `final.buildPackages.git` fails

26 # to build at all.

23 # to build at all.

27− inherit (pkgs.evalPackages.buildPackages) gitMinimal;

24+ inherit (pkgs.buildPackages.buildPackages) gitMinimal;

28

25

29in {

26in {

30 # Within the package components, these are the attribute names of

27 # Within the package components, these are the attribute names of

@@ -52,8 +49,7 @@ in {

52 tys;

49 tys;

53 in libComp (subComps z);

50 in libComp (subComps z);

54

51

55− getAllComponents = foldComponents subComponentTypes (c: acc:

52+ getAllComponents = foldComponents subComponentTypes (c: acc: [c] ++ acc) [];

56− lib.optional c.buildable c ++ acc) [];

57

53

58 componentPrefix = {

54 componentPrefix = {

59 sublibs = "lib";

55 sublibs = "lib";

@@ -63,24 +59,31 @@ in {

63 benchmarks = "bench";

59 benchmarks = "bench";

64 };

60 };

65

61

62+ # For looking up the components attribute based on the cabal component type

63+ prefixComponent =

64+ lib.listToAttrs (

65+ lib.mapAttrsToList (value: name: { inherit name value; })

66+ componentPrefix);

67+

66 applyComponents = f: config:

68 applyComponents = f: config:

67 let

69 let

68 comps = config.components;

70 comps = config.components;

69 applyLibrary = cname: f { cname = config.package.identifier.name; ctype = "lib"; };

71 applyLibrary = cname: f { cname = config.package.identifier.name; ctype = "lib"; };

70 applySubComp = ctype: cname: f { inherit cname; ctype = componentPrefix.${ctype} or (throw "Missing component mapping for ${ctype}."); };

72 applySubComp = ctype: cname: f { inherit cname; ctype = componentPrefix.${ctype} or (throw "Missing component mapping for ${ctype}."); };

71− applyAllComp = f { cname = config.package.identifier.name; ctype = "all"; };

73+ isBuildable = comp:

72− buildableAttrs = lib.filterAttrs (n: comp: comp.buildable or true);

74+ config.package.buildable # Set manually in a module (allows whole packages to be disabled)

73− libComp = if comps.library == null || !(comps.library.buildable or true)

75+ && comp.buildable # Set based on `buildable` in `.cabal` files

76+ && comp.planned; # Set if the component was in the `plan.json`

77+ buildableAttrs = lib.filterAttrs (n: isBuildable);

78+ libComp = if comps.library == null || !(isBuildable comps.library)

74 then {}

79 then {}

75− else lib.mapAttrs applyLibrary (removeAttrs comps (subComponentTypes ++ [ "all" "setup" ]));

80+ else lib.mapAttrs applyLibrary (removeAttrs comps (subComponentTypes ++ [ "setup" ]));

76 subComps = lib.mapAttrs

81 subComps = lib.mapAttrs

77 (ctype: attrs: lib.mapAttrs (applySubComp ctype) (buildableAttrs attrs))

82 (ctype: attrs: lib.mapAttrs (applySubComp ctype) (buildableAttrs attrs))

78 (builtins.intersectAttrs (lib.genAttrs subComponentTypes (_: null)) comps);

83 (builtins.intersectAttrs (lib.genAttrs subComponentTypes (_: null)) comps);

79− allComp = { all = applyAllComp comps.all; };

84+ in subComps // libComp;

80− in subComps // libComp // allComp;

81

85

82 isLibrary = componentId: componentId.ctype == "lib";

86 isLibrary = componentId: componentId.ctype == "lib";

83− isAll = componentId: componentId.ctype == "all";

84 isExe = componentId: componentId.ctype == "exe";

87 isExe = componentId: componentId.ctype == "exe";

85 isTest = componentId: componentId.ctype == "test";

88 isTest = componentId: componentId.ctype == "test";

86 isBenchmark = componentId: componentId.ctype == "bench";

89 isBenchmark = componentId: componentId.ctype == "bench";

@@ -89,8 +92,7 @@ in {

89 || isTest componentId

92 || isTest componentId

90 || isBenchmark componentId;

93 || isBenchmark componentId;

91 mayHaveExecutable = componentId:

94 mayHaveExecutable = componentId:

92− isExecutableType componentId

95+ isExecutableType componentId;

93− || isAll componentId;

94

96

95 # Was there a reference to the package source in the `cabal.project` or `stack.yaml` file.

97 # Was there a reference to the package source in the `cabal.project` or `stack.yaml` file.

96 # This is used to make the default `packages` list for `shellFor`.

98 # This is used to make the default `packages` list for `shellFor`.

@@ -99,14 +101,12 @@ in {

99

101

100 # if it's a project package it has a src attribute set with an origSubDir attribute.

102 # if it's a project package it has a src attribute set with an origSubDir attribute.

101 # project packages are a subset of localPackages

103 # project packages are a subset of localPackages

102− isProjectPackage = p: p ? src && p.src ? origSubDir;

104+ isProjectPackage = p: p.isProject or false;

103 selectProjectPackages = ps: lib.filterAttrs (n: p: p != null && isLocalPackage p && isProjectPackage p) ps;

105 selectProjectPackages = ps: lib.filterAttrs (n: p: p != null && isLocalPackage p && isProjectPackage p) ps;

104

106

105 # Format a componentId as it should appear as a target on the

107 # Format a componentId as it should appear as a target on the

106 # command line of the setup script.

108 # command line of the setup script.

107− componentTarget = componentId:

109+ componentTarget = componentId:"${componentId.ctype}:${componentId.cname}";

108− if componentId.ctype == "all" then ""

109− else "${componentId.ctype}:${componentId.cname}";

110

111 # Remove null or empty values from an attrset.

112 optionalHooks = lib.filterAttrs (_: hook: hook != null && hook != "");

@@ -133,14 +133,7 @@ in {

133 ## flatLibDepends :: Component -> [Package]

134 flatLibDepends = component:

135 let

136− # this is a minor improvement over the "cannot coerce set to string"

136+ makePairs = map (p: rec { key=val.name; val=(p.components.library or p); });

137− # error. It will now say:

138− #

139− # > The option `packages.Win32.package.identifier.name' is used but not defined.

140− #

141− # which indicates that the package.Win32 is missing and not defined.

142− getKey = x: if x ? "outPath" then "${x}" else (throw x.identifier.name);

143− makePairs = map (p: rec { key=getKey val; val=(p.components.library or p); });

144 closure = builtins.genericClosure {

137 closure = builtins.genericClosure {

145 startSet = makePairs component.depends;

138 startSet = makePairs component.depends;

146 operator = {val,...}: makePairs val.config.depends;

139 operator = {val,...}: makePairs val.config.depends;

@@ -196,7 +189,7 @@ in {

196 collectChecks' = collectChecks (_: true);

189 collectChecks' = collectChecks (_: true);

197

190

198 # Replacement for lib.cleanSourceWith that has a subDir argument.

191 # Replacement for lib.cleanSourceWith that has a subDir argument.

199− inherit (import ./clean-source-with.nix { inherit lib; }) cleanSourceWith canCleanSource;

192+ inherit (import ./clean-source-with.nix { inherit lib; }) cleanSourceWith;

200

193

201 # Use cleanSourceWith to filter just the files needed for a particular

194 # Use cleanSourceWith to filter just the files needed for a particular

202 # component of a package

195 # component of a package

@@ -206,7 +199,7 @@ in {

206 cleanGit = import ./clean-git.nix {

199 cleanGit = import ./clean-git.nix {

207 inherit lib cleanSourceWith;

200 inherit lib cleanSourceWith;

208 git = gitMinimal;

201 git = gitMinimal;

209− inherit (pkgs.evalPackages) runCommand;

202+ inherit (pkgs.buildPackages.buildPackages) runCommand;

210 };

203 };

211

204

212 # Some times it is handy to temporarily use a relative path between git

205 # Some times it is handy to temporarily use a relative path between git

@@ -236,7 +229,17 @@ in {

236

229

237 # Check a test component

230 # Check a test component

238 check = import ./check.nix {

231 check = import ./check.nix {

239− inherit stdenv lib haskellLib srcOnly;

232+ inherit stdenv lib haskellLib;

233+ };

234+

235+ # Do coverage of a package

236+ coverageReport = import ./cover.nix {

237+ inherit stdenv lib haskellLib pkgs;

238+ };

239+

240+ # Do coverage of a project

241+ projectCoverageReport = import ./cover-project.nix {

242+ inherit stdenv lib haskellLib pkgs;

240 };

243 };

241

244

242 # Use `isCrossHost` to identify when we are cross compiling and

245 # Use `isCrossHost` to identify when we are cross compiling and

@@ -245,20 +248,99 @@ in {

245 # In most cases we do not want to treat musl as a cross compiler.

248 # In most cases we do not want to treat musl as a cross compiler.

246 # For instance when building ghc we want to include ghci.

249 # For instance when building ghc we want to include ghci.

247 isCrossHost = stdenv.hostPlatform != stdenv.buildPlatform

250 isCrossHost = stdenv.hostPlatform != stdenv.buildPlatform

248− && !(stdenv.buildPlatform.isLinux && stdenv.hostPlatform.isMusl && stdenv.buildPlatform.isx86 && stdenv.hostPlatform.isx86);

251+ && !(stdenv.buildPlatform.isLinux && stdenv.hostPlatform.isMusl && stdenv.buildPlatform.linuxArch == stdenv.hostPlatform.linuxArch);

249 # This is the same as isCrossHost but for use when building ghc itself

252 # This is the same as isCrossHost but for use when building ghc itself

250 isCrossTarget = stdenv.targetPlatform != stdenv.hostPlatform

253 isCrossTarget = stdenv.targetPlatform != stdenv.hostPlatform

251− && !(stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl && stdenv.hostPlatform.isx86 && stdenv.targetPlatform.isx86);

254+ && !(stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl && stdenv.hostPlatform.linuxArch == stdenv.targetPlatform.linuxArch);

252 # Native musl build-host-target combo

255 # Native musl build-host-target combo

253 isNativeMusl = stdenv.hostPlatform.isMusl

256 isNativeMusl = stdenv.hostPlatform.isMusl

254 && stdenv.buildPlatform == stdenv.hostPlatform

257 && stdenv.buildPlatform == stdenv.hostPlatform

255 && stdenv.hostPlatform == stdenv.targetPlatform;

258 && stdenv.hostPlatform == stdenv.targetPlatform;

256

259

257− # Takes a version number or attr set of arguments (for cabalProject)

260+ # Takes a version number, module or list of modules (for cabalProject)

258− # and conversios it to an attr set of argments. This allows

261+ # and converts it to an list of project modules. This allows

259 # the use of "1.0.0.0" or { version = "1.0.0.0"; ... }

262 # the use of "1.0.0.0" or { version = "1.0.0.0"; ... }

260− versionOrArgsToArgs = versionOrArgs:

263+ versionOrModToMods = versionOrMod:

261− if lib.isAttrs versionOrArgs

264+ if lib.isString versionOrMod

262− then versionOrArgs

265+ then [{ version = versionOrMod; }]

263− else { version = versionOrArgs; };

266+ else if lib.isList versionOrMod

267+ then versionOrMod

268+ else [versionOrMod];

269+

270+ # Find the resolver in the stack.yaml file and fetch it if a sha256 value is provided

271+ fetchResolver = import ./fetch-resolver.nix {

272+ inherit (pkgs.buildPackages) pkgs;

273+ };

274+

275+ inherit (import ./cabal-project-parser.nix {

276+ inherit pkgs;

277+ }) parseIndexState parseSourceRepositoryPackages parseRepositories parseSourceRepositoryPackageBlock parseRepositoryBlock;

278+

279+

280+ cabalToNixpkgsLicense = import ./spdx/cabal.nix pkgs;

281+

282+ # This function is like

283+ # `src + (if subDir == "" then "" else "/" + subDir)`

284+ # however when `includeSiblings` is set it maintains

285+ # `src.origSrc` if there is one and instead adds to

286+ # `src.origSubDir`. It uses `cleanSourceWith` when possible

287+ # to keep `cleanSourceWith` support in the result.

288+ appendSubDir = { src, subDir, includeSiblings ? false }:

289+ if subDir == ""

290+ then src

291+ else

292+ haskellLib.cleanSourceWith {

293+ inherit src subDir includeSiblings;

294+ };

295+

296+ # Givin a `src` split it into a `root` path (based on `src.origSrc` if

297+ # present) and `subDir` (based on `src.origSubDir). The

298+ # `root` will still use the `filter` of `src` if there was one.

299+ rootAndSubDir = src: rec {

300+ subDir = src.origSubDir or "";

301+ root =

302+ if subDir == ""

303+ then src # if there was no subdir use the original src

304+ else

305+ # Use `cleanSourceWith` to make sure the `filter` is still used

306+ if src ? origSrc && src ? filter

307+ then haskellLib.cleanSourceWith {

308+ name = src.name or "source" + "-root";

309+ src = src.origSrc;

310+ # Not passing src.origSubDir so that the result points `origSrc`

311+ inherit (src) filter;

312+ }

313+ else src.origSrc or src; # If there is a subDir and origSrc (but no filter) use origSrc

314+ };

315+

316+ # Run evalModules passing the project function argument (m) as a module along with

317+ # the the a projectType module (../modules/cabal-project.nix or ../modules/stack-project.nix).

318+ # The resulting config is then passed to the project function's implementation.

319+ evalProjectModule = projectType: m: f:

320+ let project = f

321+ (lib.evalModules {

322+ modules = (if builtins.isList m then m else [m]) ++ [

323+ # Include ../modules/cabal-project.nix or ../modules/stack-project.nix

324+ (import ../modules/project-common.nix)

325+ (import projectType)

326+ # Pass the pkgs and the buildProject to the modules

327+ ({ config, lib, ... }: {

328+ _module.args = {

329+ inherit pkgs;

330+ # to make it easy to depends on build packages in, eg., shell definition:

331+ inherit (project) buildProject;

332+ };

333+ inherit (project) hsPkgs;

334+ })

335+ ];

336+ }).config;

337+ in project;

338+

339+ # Converts from a `compoent.depends` value to a library derivation.

340+ # In the case of sublibs the `depends` value should already be the derivation.

341+ dependToLib = d: d.components.library or d;

342+

343+ projectOverlays = import ./project-overlays.nix {

344+ inherit lib haskellLib;

345+ };

264}

346}

lib/failed-cabal-configure.nixnew file+9

@@ -0,0 +1,9 @@

1+let

2+ configurationError = ./cabal-configure.out;

3+in

4+ # Trace the error output to make sure the user has a chance to see it

5+ # (even if the choose not to build anything from the project)

6+ __trace ''

7+ ERROR: cabal configure failed with:

8+ ${__readFile configurationError}

9+ '' { inherit configurationError; }

lib/fetch-resolver.nixnew file+37

@@ -0,0 +1,37 @@

1+# Find the resolver in the stack.yaml file and fetch it if a sha256 value is provided

2+{ pkgs }:

3+{ src

4+, stackYaml ? "stack.yaml"

5+, resolverSha256 ? null

6+}:

7+let

8+ srcDir = src.origSrcSubDir or src;

9+

10+ # Using origSrcSubDir bypasses any cleanSourceWith so that it will work when

11+ # access to the store is restricted. If origSrc was already in the store

12+ # you can pass the project in as a string.

13+ rawStackYaml = builtins.readFile (srcDir + "/${stackYaml}");

14+

15+ # Determine the resolver as it may point to another file we need

16+ # to look at.

17+ resolver =

18+ let

19+ rs = pkgs.lib.lists.concatLists (

20+ pkgs.lib.lists.filter (l: l != null)

21+ (builtins.map (l: builtins.match "^resolver: *(.*)" l)

22+ (pkgs.lib.splitString "\n" rawStackYaml)));

23+ in

24+ pkgs.lib.lists.head (rs ++ [ null ]);

25+

26+ # If we found a resolver and we have a resolverSha256 then we should download it.

27+ fetchedResolver =

28+ if resolver != null && resolverSha256 != null

29+ then pkgs.fetchurl {

30+ url = resolver;

31+ sha256 = resolverSha256;

32+ }

33+ else if resolver != null && __pathExists (srcDir + "/${resolver}")

34+ then pkgs.copyPathToStore (srcDir + "/${resolver}")

35+ else null;

36+

37+in { inherit resolver fetchedResolver; }

lib/ghcjs-project.nix+119−32

@@ -1,3 +1,7 @@

1+# IMPORTANT: This is for building ghcjs, not for building with

2+# ghcjs. To build with ghcjs then just replace `haskell-nix`

3+# with `pkgsCross.ghcjs.haskell-nix`.

4+#

1# For the time being we can't really treat ghcjs like a

5# For the time being we can't really treat ghcjs like a

2# regular ghc (with different target). We need this as a

6# regular ghc (with different target). We need this as a

3# stop-gap measure until ghcjs can be treated like a regular

7# stop-gap measure until ghcjs can be treated like a regular

@@ -17,15 +21,45 @@

17# of the project.

21# of the project.

18{ pkgs }:

22{ pkgs }:

19{ src

23{ src

20−, ghc ? pkgs.ghc

24+, compiler-nix-name

21−, ghcjsVersion ? "8.6.0.1" # TODO get this from the source?

25+, ghc ? pkgs.buildPackages.haskell-nix.compiler.${compiler-nix-name}

22−, ghcVersion ? "8.6.5" # TODO get this from the ghc arg?

26+, ghcjsVersion # Version in the ghcjs.cabal file (that we will replace)

23−, happy ? pkgs.haskellPackages.happy

27+, ghcVersion ? ghc.version

24−, alex ? pkgs.haskellPackages.alex

28+, happy ? pkgs.haskell-nix.tool compiler-nix-name "happy" {

25−, cabal-install ? pkgs.cabal-install

29+ index-state = pkgs.haskell-nix.internalHackageIndexState;

30+ version = "1.19.12";

31+ materialized = ../materialized/ghcjs/happy + "/${compiler-nix-name}";

32+ }

33+, alex ? pkgs.haskell-nix.tool compiler-nix-name "alex" {

34+ index-state = pkgs.haskell-nix.internalHackageIndexState;

35+ version = "3.2.5";

36+ materialized = ../materialized/ghcjs/alex + "/${compiler-nix-name}";

37+ }

38+, cabal-install ?

39+ if (builtins.compareVersions ghcjsVersion "8.10.0.0" >= 0)

40+ then pkgs.haskell-nix.tool compiler-nix-name "cabal" {

41+ index-state = pkgs.haskell-nix.internalHackageIndexState;

42+ version = "3.6.2.0";

43+ materialized = ../materialized/ghcjs/cabal + "/${compiler-nix-name}";

44+ }

45+ else pkgs.haskell-nix.tool compiler-nix-name "cabal" {

46+ index-state = pkgs.haskell-nix.internalHackageIndexState;

47+ version = "3.2.0.0";

48+ # Cabal 3.2.1.0 no longer supports he mix of `cabal-version`,

49+ # lack of `custom-setup` and `v1-install` used by ghcjs boot.

50+ cabalProjectLocal = ''

51+ constraints: Cabal <3.2.1.0

52+ '';

53+ materialized = ../materialized/ghcjs/cabal + "/${compiler-nix-name}";

54+ }

55+, overrideBootPackages ? []

56+, patches ? []

26, ...

57, ...

27}@args:

58}@args:

28let

59let

60+ isGhcjs88 = builtins.compareVersions ghcjsVersion "8.8.0.0" >= 0;

61+ isGhcjs810 = builtins.compareVersions ghcjsVersion "8.10.0.0" >= 0;

62+

29 # Inputs needed to configure the GHCJS source tree

63 # Inputs needed to configure the GHCJS source tree

30 configureInputs = with pkgs; [

64 configureInputs = with pkgs; [

31 perl

65 perl

@@ -38,22 +72,26 @@ let

38 alex

72 alex

39 cabal-install

73 cabal-install

40 ];

74 ];

75+

76+ inherit (pkgs.buildPackages) emscriptenupstream emscripten emsdk;

77+

41 # Inputs needed to boot the GHCJS compiler

78 # Inputs needed to boot the GHCJS compiler

42− bootInputs = with pkgs; [

79+ bootInputs = with pkgs.buildPackages; [

43− nodejs

80+ # We used to pin nodejs to the 12 series, as strings can only be half the length in node 14+

81+ # see https://github.com/nodejs/node/issues/33960

82+ # Large TH splices are likely broken.

83+ # TODO reinstate the pin of find a work around for ghcjs to send TH splice in chunks.

84+ nodejs-18_x

44 makeWrapper

85 makeWrapper

45 xorg.lndir

86 xorg.lndir

46 gmp

87 gmp

47 pkgconfig

88 pkgconfig

48 ]

89 ]

49− ++ [ ghc cabal-install ]

90+ ++ [ ghc cabal-install emsdk ];

50− ++ lib.optionals stdenv.isDarwin [

51− pkgs.buildPackages.gcc # https://github.com/ghcjs/ghcjs/issues/663

52− ];

53 # Configured the GHCJS source

91 # Configured the GHCJS source

54− configured-src = pkgs.runCommand "configured-ghcjs-src" {

92+ configured-src = (pkgs.runCommandCC "configured-ghcjs-src" {

55 buildInputs = configureInputs;

93 buildInputs = configureInputs;

56− inherit src;

94+ inherit src patches;

57 } ''

95 } ''

58 export HOME=$(pwd)

96 export HOME=$(pwd)

59 mkdir $HOME/.cabal

97 mkdir $HOME/.cabal

@@ -62,35 +100,80 @@ let

62 chmod -R +w "$out"

100 chmod -R +w "$out"

63 cd "$out"

101 cd "$out"

64

102

103+ for p in $patches

104+ do

105+ patch -p1 <$p

106+ done

107+

65 # TODO: Find a better way to avoid impure version numbers

108 # TODO: Find a better way to avoid impure version numbers

66 sed -i 's/RELEASE=NO/RELEASE=YES/' ghc/configure.ac

109 sed -i 's/RELEASE=NO/RELEASE=YES/' ghc/configure.ac

67 sed -i 's/${ghcjsVersion}/${ghcVersion}/' ghcjs.cabal

110 sed -i 's/${ghcjsVersion}/${ghcVersion}/' ghcjs.cabal

68

111

69− # TODO: How to actually fix this?

112+ ${

70− # Seems to work fine and produce the right files.

113+ # TODO: How to actually fix this?

71− touch ghc/includes/ghcautoconf.h

114+ # Seems to work fine and produce the right files.

72− mkdir -p ghc/compiler/vectorise

115+ pkgs.lib.optionalString (!isGhcjs88) ''

73− mkdir -p ghc/utils/haddock/haddock-library/vendor

116+ touch ghc/includes/ghcautoconf.h

117+ mkdir -p ghc/compiler/vectorise

118+ mkdir -p ghc/utils/haddock/haddock-library/vendor

119+ ''

120+ }

121+

122+ rm -rf utils/pkg-cache/ghc

123+ cp -r ${ghc.generated} utils/pkg-cache/ghc

124+

125+ for a in integer-gmp base unix; do

126+ cp ${../overlays/patches/config.sub} ghc/libraries/$a/config.sub

127+ cp ${../overlays/patches/config.guess} ghc/libraries/$a/config.guess

128+ chmod +w ghc/libraries/$a/config.*

129+ done

130+

131+ sed -i 's/_AC_PROG_CC_C99/AC_PROG_CC_C99/' ghc/aclocal.m4

74

132

75 patchShebangs .

133 patchShebangs .

76 sed -i 's/gcc /cc /g' utils/makePackages.sh

134 sed -i 's/gcc /cc /g' utils/makePackages.sh

77− cat utils/makePackages.sh

78 ./utils/makePackages.sh copy

135 ./utils/makePackages.sh copy

79

136

80− echo " build-tool-depends: alex:alex, happy:happy <= 1.19.9" >> lib/ghc-api-ghcjs/ghc-api-ghcjs.cabal

137+ for a in integer-gmp base unix; do

138+ cp ${../overlays/patches/config.sub} lib/boot/pkg/$a/config.sub

139+ done

140+ ${ # it just so happens that all existing uses of overriding boot packages

141+ # need to be installed right after template-haskell

142+ # if at some point we would need to insert them at different points

143+ # then we will have gto come up with something more clever

144+ builtins.concatStringsSep "\n" (map ({name, src}: ''

145+ rm -rf $out/lib/boot/pkg/${name}

146+ cp -r ${src} $out/lib/boot/pkg/${name}

147+ sed -i 's/^ - ${name}$//g' $out/lib/boot/boot.yaml

148+ sed -i 's/^ - template-haskell$/ - template-haskell\n - ${name}/g' $out/lib/boot/boot.yaml

149+ echo "Added ${name} to boot.yaml"

150+ ''

151+ ) (pkgs.lib.reverseList overrideBootPackages))

152+ }

81

153

82− # nuke the HsBaseConfig.h from base.buildinfo.in; this will

154+ chmod -R +w $out/lib/boot/pkg

83− # prevent it from being installed and provide incorrect values.

155+ '') // {

84− sed -i 's/HsBaseConfig.h//g' lib/boot/pkg/base/base.buildinfo.in

156+ # The configured source includes /nix/store paths and so filtering can fail.

85− cat lib/boot/pkg/base/base.buildinfo.in

157+ filterPath = { path, ... }: path;

86− '';

158+ };

87 # see https://github.com/ghcjs/ghcjs/issues/751 for the happy upper bound.

159 # see https://github.com/ghcjs/ghcjs/issues/751 for the happy upper bound.

88

160

89 ghcjsProject = pkgs.haskell-nix.cabalProject' (

161 ghcjsProject = pkgs.haskell-nix.cabalProject' (

90− (pkgs.lib.filterAttrs

162+ (pkgs.lib.filterAttrs

91− (n: _: builtins.any (x: x == n)

163+ (n: _: !(builtins.any (x: x == n)

92− ["src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"]) args) // {

164+ [ "src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"

165+ "overrideBootPackages" "patches"])) args) // {

93 src = configured-src;

166 src = configured-src;

167+ index-state = "2021-03-20T00:00:00Z";

168+ inherit compiler-nix-name;

169+ configureArgs = pkgs.lib.optionalString (isGhcjs88 && !isGhcjs810) "--constraint='Cabal >=3.0.2.0 && <3.1'";

170+ # If a package is in both build-depends and build-tool-depends multiple versions may

171+ # be in the `plan.json` file. Haskell.nix will pick the newer one, but when nbuilding

172+ # ghcjs 8.6 we need to use the older happy version.

173+ pkg-def-extras = pkgs.lib.optional (!isGhcjs88) (hackage: {

174+ packages.happy.revision = hackage.happy."1.19.9".revisions.default;

175+ });

176+ materialized = ../materialized + "/ghcjs/${compiler-nix-name}";

94 modules = [

177 modules = [

95 {

178 {

96 # we need ghc-boot in here for ghcjs.

179 # we need ghc-boot in here for ghcjs.

@@ -99,8 +182,11 @@ let

99 "ghc-boot" "binary" "bytestring" "filepath" "directory" "containers"

182 "ghc-boot" "binary" "bytestring" "filepath" "directory" "containers"

100 "time" "unix" "Win32" ];

183 "time" "unix" "Win32" ];

101 }

184 }

102− {

185+ (pkgs.lib.optionalAttrs (!isGhcjs88) {

103 packages.Cabal.patches = [ ./../overlays/patches/Cabal/fix-data-dir.patch ];

186 packages.Cabal.patches = [ ./../overlays/patches/Cabal/fix-data-dir.patch ];

187+ })

188+ {

189+ ghcOptions = ["-O2"];

104 packages.ghcjs.doHaddock = false;

190 packages.ghcjs.doHaddock = false;

105 packages.haddock-ghcjs.doHaddock = false;

191 packages.haddock-ghcjs.doHaddock = false;

106 packages.haddock-api-ghcjs.doHaddock = false;

192 packages.haddock-api-ghcjs.doHaddock = false;

@@ -114,6 +200,7 @@ let

114 packages.ghc.flags.ghci = true;

200 packages.ghc.flags.ghci = true;

115 packages.ghci.flags.ghci = true;

201 packages.ghci.flags.ghci = true;

116 # packages.ghcjs.components.library.configureFlags = [ "-fno-wrapper-install" ];

202 # packages.ghcjs.components.library.configureFlags = [ "-fno-wrapper-install" ];

203+ packages.ghcjs.components.library.build-tools = [ alex ];

117 }

204 }

118 ];

205 ];

119 });

206 });

@@ -124,8 +211,8 @@ in ghcjsProject // {

124 shellFor = args: (ghcjsProject.hsPkgs.shellFor args).overrideAttrs (drv: {

211 shellFor = args: (ghcjsProject.hsPkgs.shellFor args).overrideAttrs (drv: {

125 buildInputs = (drv.buildInputs or []) ++ configureInputs;

212 buildInputs = (drv.buildInputs or []) ++ configureInputs;

126 nativeBuildInputs = (drv.nativeBuildInputs or []) ++ bootInputs;

213 nativeBuildInputs = (drv.nativeBuildInputs or []) ++ bootInputs;

214+ EMSDK = emsdk;

127 });

215 });

128 };

216 };

129− inherit configureInputs bootInputs configured-src;

217+ inherit configureInputs bootInputs configured-src emscriptenupstream emscripten emsdk;

130}

218}

131−

lib/import-and-filter-project.nix+40−26

@@ -4,16 +4,13 @@

4{ pkgs, haskellLib }:

5{ projectNix, sourceRepos, src }:

6let

7− # Full source including possible relartive paths form the

7+ # Full source including possible relative paths form the

8 # project directory.

9− srcRoot =

9+ srcRoot = haskellLib.cleanSourceWith {

10− if haskellLib.canCleanSource src

10+ name = if src ? name then "${src.name}-root" else "source-root";

11− then haskellLib.cleanSourceWith {

11+ src = src.origSrc or src;

12− name = src.name + "-root";

12+ filter = src.filter or (_: _: true);

13− src = src.origSrc or src;

13+ };

14− inherit (src) filter;

15− }

16− else src.origSrc or src;

17 # The sub directory containing the cabal.project or stack.yaml file

14 # The sub directory containing the cabal.project or stack.yaml file

18 projectSubDir' = src.origSubDir or ""; # With leading /

15 projectSubDir' = src.origSubDir or ""; # With leading /

19 projectSubDir = pkgs.lib.strings.removePrefix "/" projectSubDir'; # Without /

16 projectSubDir = pkgs.lib.strings.removePrefix "/" projectSubDir'; # Without /

@@ -24,24 +21,41 @@ in project // {

24 packages = pkgs.lib.attrsets.mapAttrs (name: value:

21 packages = pkgs.lib.attrsets.mapAttrs (name: value:

25 if builtins.isFunction value

22 if builtins.isFunction value

26 then value

23 then value

27− else {...}@args:

24+ else {...}@args: with pkgs.lib.strings;

28− let oldPkg = import value args;

25+ let

29− packageSrc = if !pkgs.lib.strings.hasPrefix (toString projectNix) (toString oldPkg.src.content)

26+ oldPkg = import value args;

30− then toString oldPkg.src.content

27+ packageInfo =

31− else let

28+ if oldPkg.src ? url

32− subDir = pkgs.lib.strings.removePrefix "/" (

29+ then {

33− pkgs.lib.strings.removePrefix (toString projectNix)

30+ # The source is from a source-repository-package in a cabal.project file

34− (toString oldPkg.src.content));

31+ # and lib/call-cabal-project-to-nix.nix should have replaced the url with

35− srcRepoPrefix = projectSubDir'' + ".source-repository-packages/";

32+ # an index into the sourceRepos list.

36− in if pkgs.lib.strings.hasPrefix srcRepoPrefix subDir

33+ isProject = false;

37− then

34+ packageSrc = pkgs.lib.lists.elemAt sourceRepos (toInt oldPkg.src.url);

38− pkgs.lib.lists.elemAt sourceRepos (

35+ }

39− pkgs.lib.strings.toInt (pkgs.lib.strings.removePrefix srcRepoPrefix subDir))

36+ else if !hasPrefix "${projectNix}" (toString oldPkg.src.content)

40− else if haskellLib.canCleanSource srcRoot

37+ then {

41− then haskellLib.cleanSourceWith { src = srcRoot; inherit subDir; }

38+ # Source location does not match project prefix

42− else srcRoot + (if subDir == "" then "" else "/" + subDir);

39+ isProject = false;

40+ packageSrc = toString oldPkg.src.content;

41+ }

42+ else {

43+ # Source does match project prefix and it is not from a source repository

44+ isProject = true;

45+ packageSrc = haskellLib.appendSubDir {

46+ src = srcRoot;

47+ subDir = removePrefix "/" (removePrefix "${projectNix}"

48+ (toString oldPkg.src.content));

49+ includeSiblings = true; # Filtering sibling dirs of the package dir is done in the

50+ # component builder so that relative paths can be used to

51+ # reference project directories not in the package subDir.

52+ };

53+ };

43 in oldPkg // {

54 in oldPkg // {

44− src = (pkgs.lib).mkDefault packageSrc;

55+ src = (pkgs.lib).mkDefault packageInfo.packageSrc;

56+ package = oldPkg.package // {

57+ isProject = (pkgs.lib).mkDefault packageInfo.isProject;

58+ };

45 }) old;

59 }) old;

46 };

60 };

47 }

61 }

lib/materialize.nix+23−11

@@ -7,6 +7,9 @@

7 # the output. If this is set but does not exist

8 # the derivation will fail but with a message

9 # advising how to populate it.

10+, this ? "this"

11+ # A name to use when referring to the thing currently being

12+ # materialized. Clients can pass in an attribute name or similar.

10, reasonNotSafe ? null

13, reasonNotSafe ? null

11 # Some times there a reasont the derivation will

14 # Some times there a reasont the derivation will

12 # not produce output that can be safely materialized.

15 # not produce output that can be safely materialized.

@@ -21,7 +24,7 @@

21}: derivation:

24}: derivation:

22

25

23let

26let

24− inherit (derivation) name;

27+ name = derivation.name + pkgs.lib.optionalString (derivation ? version) "-${derivation.version}";

25

28

26 traceIgnoringSha256 = reason: x:

29 traceIgnoringSha256 = reason: x:

27 if sha256 != null

30 if sha256 != null

@@ -33,10 +36,15 @@ let

33 then builtins.trace ("Warning: ignoring materialized for " + name + " " + reason) x

36 then builtins.trace ("Warning: ignoring materialized for " + name + " " + reason) x

34 else x;

37 else x;

35

38

39+ traceWhenChecking = message: x:

40+ if checkMaterialization

41+ then builtins.trace message x

42+ else x;

43+

36 unchecked =

44 unchecked =

37 let

45 let

38− sha256message = "To make this a fixed-output derivation but not materialized, set `${sha256Arg}` to the output of ${calculateMaterializedSha}";

46+ sha256message = "${name}: To make ${this} a fixed-output derivation but not materialized, set `${sha256Arg}` to the output of the 'calculateMaterializedSha' script in 'passthru'.";

39− materializeMessage = "To materialize the output entirely, pass a writable path as the `materialized` argument and pass that path to ${generateMaterialized}";

47+ materializeMessage = "${name}: To materialize ${this} entirely, pass a writable path as the `materialized` argument and run the 'updateMaterialized' script in 'passthru'.";

40 in if reasonNotSafe != null

48 in if reasonNotSafe != null

41 then

49 then

42 # Warn the user if they tried to pin stuff down when it is not safe

50 # Warn the user if they tried to pin stuff down when it is not safe

@@ -47,13 +55,20 @@ let

47 else if sha256 != null

55 else if sha256 != null

48 then

56 then

49 # Let the user know how to materialize if they want to.

57 # Let the user know how to materialize if they want to.

50− builtins.trace materializeMessage calculateUseHash

58+ traceWhenChecking materializeMessage calculateUseHash

51 else # materialized == null && sha256 == null

59 else # materialized == null && sha256 == null

52 # Let the user know how to calculate a sha256 or materialize if they want to.

60 # Let the user know how to calculate a sha256 or materialize if they want to.

53− builtins.trace sha256message (builtins.trace materializeMessage calculateNoHash);

61+ traceWhenChecking sha256message (traceWhenChecking materializeMessage calculateNoHash);

54

62

55 # Build fully and check the hash and materialized versions

63 # Build fully and check the hash and materialized versions

56− checked = runCommand name {} (''

64+ checked =

65+ # Let the user know what we are checking. This is useful for debugging issues

66+ # where materialization fails to prevent infinite recurstion when:

67+ # checkMaterialization = true;

68+ (if materialized != null

69+ then __trace "Checking materialization in ${toString materialized}"

70+ else x: x)

71+ runCommand name {} (''

57 ERR=$(mktemp -d)/errors.txt

72 ERR=$(mktemp -d)/errors.txt

58 ''

73 ''

59 + (pkgs.lib.optionalString (sha256 != null) ''

74 + (pkgs.lib.optionalString (sha256 != null) ''

@@ -113,11 +128,7 @@ let

113 calculateUseMaterialized =

128 calculateUseMaterialized =

114 assert materialized != null;

129 assert materialized != null;

115 assert __pathExists materialized;

130 assert __pathExists materialized;

116− runCommand name (pkgs.lib.optionalAttrs (sha256 == null) hashArgs) ''

131+ { outPath = materialized; inherit name; };

117− cp -Lr ${materialized} $out

118− # Make sure output files can be removed from the sandbox

119− chmod -R +w $out

120− '';

121 calculateMaterializedSha =

132 calculateMaterializedSha =

122 writeShellScript "calculateSha" ''${nix}/bin/nix-hash --base32 --type sha256 ${calculateNoHash}'';

133 writeShellScript "calculateSha" ''${nix}/bin/nix-hash --base32 --type sha256 ${calculateNoHash}'';

123

134

@@ -133,6 +144,7 @@ let

133 fi

144 fi

134

145

135 # Generate the files

146 # Generate the files

147+ mkdir -p $TARGET

136 rm -rf $TARGET

148 rm -rf $TARGET

137 cp -r ${calculateNoHash} "$TARGET"

149 cp -r ${calculateNoHash} "$TARGET"

138 chmod -R +w "$TARGET"

150 chmod -R +w "$TARGET"

lib/pkgconf-nixpkgs-map.nix+30−17

@@ -21,18 +21,18 @@ pkgs:

21 "cairo-ps" = [ pkgs."cairo" ];

22 "cairo-svg" = [ pkgs."cairo" ];

23 "crypt" = []; # provided by glibc

24− "crypto" = [ pkgs."openssl" ];

25 "curses" = [ pkgs."ncurses" ];

24 "curses" = [ pkgs."ncurses" ];

26 "dbusmenu-glib-0.4" = [ pkgs."libdbusmenu" ];

25 "dbusmenu-glib-0.4" = [ pkgs."libdbusmenu" ];

27 "dbusmenu-gtk3-0.4" = [ pkgs."libdbusmenu-gtk3" ]; # do we also need pkgs."gtk3"

26 "dbusmenu-gtk3-0.4" = [ pkgs."libdbusmenu-gtk3" ]; # do we also need pkgs."gtk3"

28 "dl" = []; # provided by glibc

27 "dl" = []; # provided by glibc

29 "fftw3" = [ pkgs."fftw" ];

28 "fftw3" = [ pkgs."fftw" ];

30 "fftw3f" = [ pkgs."fftwFloat" ];

29 "fftw3f" = [ pkgs."fftwFloat" ];

30+ "freetype2" = [ pkgs."freetype" ];

31 "gconf" = [ pkgs."GConf" ];

32 "gconf-2.0" = [ pkgs."GConf" ];

33 "gdk-2.0" = [ pkgs."gtk2" ];

34 "gdk-3.0" = [ pkgs."gtk3" ];

35− "gdk-pixbuf-2.0" = [ pkgs."gdk_pixbuf" ];

35+ "gdk-pixbuf-2.0" = [ (pkgs."gdk-pixbuf" or pkgs."gdk_pixbuf") ];

36 "gdk-x11-2.0" = [ pkgs."gdk_x11" ];

37 "gdk-x11-3.0" = [ pkgs."gtk3" ];

38 "gio-2.0" = [ pkgs."glib" ];

@@ -45,7 +45,9 @@ pkgs:

45 "gnome-vfs-2.0" = [ pkgs."gnome-vfs" ];

46 "gnome-vfs-module-2.0" = [ pkgs."gnome-vfs_module" ];

47 "gobject-2.0" = [ pkgs."glib" ];

48+ "gmodule-2.0" = [ pkgs."glib" ];

48 "gobject-introspection-1.0" = [ pkgs."gobject-introspection" ];

49 "gobject-introspection-1.0" = [ pkgs."gobject-introspection" ];

50+ "graphene-gobject-1.0" = [ pkgs."graphene" ];

49 "gstreamer-audio-0.10" = [ pkgs."gst-plugins-base" ];

51 "gstreamer-audio-0.10" = [ pkgs."gst-plugins-base" ];

50 "gstreamer-audio-1.0" = [ pkgs."gst-plugins-base" ];

52 "gstreamer-audio-1.0" = [ pkgs."gst-plugins-base" ];

51 "gstreamer-base-0.10" = [ pkgs."gst-plugins-base" ];

53 "gstreamer-base-0.10" = [ pkgs."gst-plugins-base" ];

@@ -61,9 +63,11 @@ pkgs:

61 "gtk-x11-2.0" = [ pkgs."gtk_x11" ];

63 "gtk-x11-2.0" = [ pkgs."gtk_x11" ];

62 "gtkglext-1.0" = [ pkgs.gnome2.gtkglext pkgs.gtk2 ];

64 "gtkglext-1.0" = [ pkgs.gnome2.gtkglext pkgs.gtk2 ];

63 "gtksourceview-3.0" = [ pkgs."gtksourceview3" ];

65 "gtksourceview-3.0" = [ pkgs."gtksourceview3" ];

66+ "harfbuzz-gobject" = [ pkgs."harfbuzz" ];

64 "hidapi-libusb" = [ pkgs."hidapi" ];

67 "hidapi-libusb" = [ pkgs."hidapi" ];

65 "icudata" = [ pkgs."icu" ];

68 "icudata" = [ pkgs."icu" ];

66 "icui18n" = [ pkgs."icu" ];

69 "icui18n" = [ pkgs."icu" ];

70+ "icu-i18n" = [ pkgs."icu" ];

67 "icuuc" = [ pkgs."icu" ];

71 "icuuc" = [ pkgs."icu" ];

68 "idn" = [ pkgs."libidn" ];

72 "idn" = [ pkgs."libidn" ];

69 "IL" = [ pkgs."libdevil" ];

73 "IL" = [ pkgs."libdevil" ];

@@ -79,7 +83,10 @@ pkgs:

79 "lber" = [ pkgs."openldap" ];

83 "lber" = [ pkgs."openldap" ];

80 "ldap" = [ pkgs."openldap" ];

84 "ldap" = [ pkgs."openldap" ];

81 "libavutil" = [ pkgs."ffmpeg" ];

85 "libavutil" = [ pkgs."ffmpeg" ];

86+ "libcrypto" = [ pkgs."openssl".dev ];

87+ "libfreenect" = [ pkgs."freenect" ];

82 "libgsasl" = [ pkgs."gsasl" ];

88 "libgsasl" = [ pkgs."gsasl" ];

89+ "liboath" = [ pkgs."liboauth" ];

83 "libpcre" = [ pkgs."pcre" ];

90 "libpcre" = [ pkgs."pcre" ];

84 "libqrencode" = [ pkgs."qrencode" ];

91 "libqrencode" = [ pkgs."qrencode" ];

85 "libR" = [ pkgs."R" ];

92 "libR" = [ pkgs."R" ];

@@ -87,11 +94,14 @@ pkgs:

87 "libsecp256k1" = [ pkgs."secp256k1" ];

94 "libsecp256k1" = [ pkgs."secp256k1" ];

88 "libsoup-2.4" = [ pkgs."libsoup" ];

95 "libsoup-2.4" = [ pkgs."libsoup" ];

89 "libsoup-gnome-2.4" = [ pkgs."libsoup" ];

96 "libsoup-gnome-2.4" = [ pkgs."libsoup" ];

97+ "libssl" = [ pkgs."openssl".dev ];

90 "libsystemd" = [ pkgs."systemd" ];

98 "libsystemd" = [ pkgs."systemd" ];

91 "libudev" = [ pkgs."systemd" ];

99 "libudev" = [ pkgs."systemd" ];

100+ "libusb-1.0" = [ pkgs."libusb1" ];

92 "libxml-2.0" = [ pkgs."libxml2" ];

101 "libxml-2.0" = [ pkgs."libxml2" ];

93 "libzip" = [ pkgs."libzip" ];

102 "libzip" = [ pkgs."libzip" ];

94 "libzmq" = [ pkgs."zeromq" ];

103 "libzmq" = [ pkgs."zeromq" ];

104+ "libzstd" = [ pkgs."zstd" ];

95 "m" = []; # in stdenv

105 "m" = []; # in stdenv

96 "magic" = [ pkgs."file" ];

106 "magic" = [ pkgs."file" ];

97 "MagickWand" = [ pkgs."imagemagick" ];

107 "MagickWand" = [ pkgs."imagemagick" ];

@@ -105,13 +115,16 @@ pkgs:

105 "notify" = [ pkgs."libnotify" ];

115 "notify" = [ pkgs."libnotify" ];

106 "odbc" = [ pkgs."unixODBC" ];

116 "odbc" = [ pkgs."unixODBC" ];

107 "openblas" = [ pkgs."openblasCompat" ];

117 "openblas" = [ pkgs."openblasCompat" ];

118+ "opencv" = [ pkgs."opencv3" ];

108 "panelw" = [ pkgs."ncurses" ];

119 "panelw" = [ pkgs."ncurses" ];

109 "pangocairo" = [ pkgs."pango" ];

120 "pangocairo" = [ pkgs."pango" ];

110 "pcap" = [ pkgs."libpcap" ];

121 "pcap" = [ pkgs."libpcap" ];

111 "pfs-1.2" = [ pkgs."pfstools" ];

122 "pfs-1.2" = [ pkgs."pfstools" ];

112 "png" = [ pkgs."libpng" ];

123 "png" = [ pkgs."libpng" ];

113 "poppler-glib" = [ pkgs."poppler" ];

124 "poppler-glib" = [ pkgs."poppler" ];

125+ "poppler-cpp" = [ pkgs."poppler" ];

114 "pq" = [ pkgs."postgresql" ];

126 "pq" = [ pkgs."postgresql" ];

127+ "libpq" = [ pkgs."postgresql" ];

115 "pthread" = [];

128 "pthread" = [];

116 "pulse" = [ pkgs."libpulseaudio" ];

129 "pulse" = [ pkgs."libpulseaudio" ];

117 "pulse-simple" = [ pkgs."libpulseaudio" ];

130 "pulse-simple" = [ pkgs."libpulseaudio" ];

@@ -133,7 +146,6 @@ pkgs:

133 "sodium" = [ pkgs."libsodium" ];

146 "sodium" = [ pkgs."libsodium" ];

134 "sqlite3" = [ pkgs."sqlite" ];

147 "sqlite3" = [ pkgs."sqlite" ];

135 "ssh2" = [ pkgs."libssh2" ];

148 "ssh2" = [ pkgs."libssh2" ];

136− "ssl" = [ pkgs."openssl" ];

137 "statgrab" = [ pkgs."libstatgrab" ];

149 "statgrab" = [ pkgs."libstatgrab" ];

138 "stdc++" = []; # What is that?

150 "stdc++" = []; # What is that?

139 "stdc++.dll" = []; # What is that?

151 "stdc++.dll" = []; # What is that?

@@ -152,23 +164,24 @@ pkgs:

152 "webkit2gtk-4.0" = [ pkgs."webkitgtk" ];

164 "webkit2gtk-4.0" = [ pkgs."webkitgtk" ];

153 "webkit2gtk-web-extension-4.0" = [ pkgs."webkitgtk" ];

165 "webkit2gtk-web-extension-4.0" = [ pkgs."webkitgtk" ];

154 "webkitgtk-3.0" = [ pkgs."webkitgtk24x-gtk3" ]; # These are the old APIs, of which 2.4 is the last provider, so map directly to that

166 "webkitgtk-3.0" = [ pkgs."webkitgtk24x-gtk3" ]; # These are the old APIs, of which 2.4 is the last provider, so map directly to that

155− "X11" = [ pkgs."libX11" ];

167+ "vulkan" = [ pkgs."vulkan-loader" ]; # vulkan-loader provides vulkan.pc file for pkg-config.

156− "x11" = [ pkgs."xlibsWrapper" ];

168+ "X11" = [ pkgs.xorg."libX11" ];

157− "xau" = [ pkgs."libXau" ];

169+ "x11" = [ pkgs.xorg."xlibsWrapper" ];

158− "Xcursor" = [ pkgs."libXcursor" ];

170+ "xau" = [ pkgs.xorg."libXau" ];

171+ "Xcursor" = [ pkgs.xorg."libXcursor" ];

159 "xerces-c" = [ pkgs."xercesc" ];

172 "xerces-c" = [ pkgs."xercesc" ];

160− "Xext" = [ pkgs."libXext" ];

173+ "Xext" = [ pkgs.xorg."libXext" ];

161− "xft" = [ pkgs."libXft" ];

174+ "xft" = [ pkgs.xorg."libXft" ];

162− "Xi" = [ pkgs."libXi" ];

175+ "Xi" = [ pkgs.xorg."libXi" ];

163− "Xinerama" = [ pkgs."libXinerama" ];

176+ "Xinerama" = [ pkgs.xorg."libXinerama" ];

164 "xkbcommon" = [ pkgs."libxkbcommon" ];

177 "xkbcommon" = [ pkgs."libxkbcommon" ];

165 "xml2" = [ pkgs."libxml2" ];

178 "xml2" = [ pkgs."libxml2" ];

166− "Xpm" = [ pkgs."libXpm" ];

179+ "Xpm" = [ pkgs.xorg."libXpm" ];

167− "Xrandr" = [ pkgs."libXrandr" ];

180+ "Xrandr" = [ pkgs.xorg."libXrandr" ];

168− "Xrender" = [ pkgs."libXrender" ];

181+ "Xrender" = [ pkgs.xorg."libXrender" ];

169− "Xss" = [ pkgs."libXScrnSaver" ];

182+ "Xss" = [ pkgs.xorg."libXScrnSaver" ];

170− "Xtst" = [ pkgs."libXtst" ];

183+ "Xtst" = [ pkgs.xorg."libXtst" ];

171− "Xxf86vm" = [ pkgs."libXxf86vm" ];

184+ "Xxf86vm" = [ pkgs.xorg."libXxf86vm" ];

172 "yaml" = [ pkgs."libyaml" ];

185 "yaml" = [ pkgs."libyaml" ];

173 "yaml-0.1" = [ pkgs."libyaml" ];

186 "yaml-0.1" = [ pkgs."libyaml" ];

174 "z" = [ pkgs."zlib" ];

187 "z" = [ pkgs."zlib" ];

lib/project-overlays.nixnew file+37

@@ -0,0 +1,37 @@

1+{

2+ lib

3+, haskellLib

4+}: {

5+ # Provide a devshell profile (https://github.com/numtide/devshell),

6+ # adapted from the project normal shell.

7+ devshell = final: prev: {

8+ devshell = let

9+ in {

10+ packages = final.shell.nativeBuildInputs

11+ # devshell does not use pkgs.mkShell / pkgs.stdenv.mkDerivation,

12+ # so we need to explicit required dependencies which

13+ # are provided implicitely by stdenv when using the normal shell:

14+ ++ (lib.filter lib.isDerivation final.shell.stdenv.defaultNativeBuildInputs)

15+ ++ [ final.pkgs.buildPackages.binutils ];

16+ env = lib.mapAttrsToList lib.nameValuePair {

17+ inherit (final.shell) CABAL_CONFIG NIX_GHC_LIBDIR;

18+ };

19+ };

20+ };

21+

22+ # Provides easily accessible attrset for each type of

23+ # components belonging to the project packages.

24+ projectComponents = final: prev: {

25+ # local project packages:

26+ packages = haskellLib.selectProjectPackages final.hsPkgs;

27+ # set of all exes (as first level entries):

28+ exes = lib.foldl' lib.mergeAttrs { } (map (p: p.components.exes) (lib.attrValues final.packages));

29+ # `tests` are the test suites which have been built.

30+ tests = haskellLib.collectComponents' "tests" final.packages;

31+ # `benchmarks` (only built, not run).

32+ benchmarks = haskellLib.collectComponents' "benchmarks" final.packages;

33+ # `checks` collect results of executing the tests:

34+ checks = haskellLib.collectChecks' final.packages;

35+ };

36+

37+}

lib/spdx/cabal.nixnew file+19

@@ -0,0 +1,19 @@

1+let

2+ spdx = import ./parser.nix;

3+in pkgs:

4+with builtins;

5+let

6+ # For better performance these are not in the

7+ # let block below (probably helps by increasing

8+ # the sharing)

9+ license-map = import ../cabal-licenses.nix pkgs;

10+ otherLicenseWarning = lic:

11+ trace "WARNING: license \"${lic}\" not found"

12+ license-map.LicenseRef-OtherLicense;

13+in license:

14+let

15+ licenses = spdx.compound-expression license;

16+in if licenses == []

17+ then otherLicenseWarning license

18+ else map (lic: license-map.${lic} or (otherLicenseWarning lic))

19+ (pkgs.lib.unique (head licenses)._1)

lib/spdx/licenses.nixnew file+27

@@ -0,0 +1,27 @@

1+pkgs:

2+with builtins; let

3+ spdxJson = pkgs.buildPackages.spdx-license-list-data.json or pkgs.buildPackages.spdx-license-list-data;

4+ materialized' = ../../materialized + "/spdx-${spdxJson.version}";

5+ licensesJSON = fromJSON (replaceStrings

6+ [ "\\u0026" "\\u0027" "\\u003d" ]

7+ [ "&" "'" "=" ]

8+ (readFile "${pkgs.buildPackages.haskell-nix.materialize {

9+ materialized = if pathExists materialized' then materialized' else null;

10+ } (pkgs.buildPackages.runCommand "spdx-json" { inherit (spdxJson) version; } ''

11+ mkdir $out

12+ cp ${spdxJson}/json/licenses.json $out

13+ '')

14+ }/licenses.json")

15+ );

16+ dropFour = s: substring 0 (stringLength s - 4) s;

17+ toSpdx = lic: with lic;

18+ { spdxId = licenseId;

19+ shortName = licenseId;

20+ fullName = name;

21+ url = dropFour detailsUrl + "html";

22+ free = isOsiApproved || lic.isFsfLibre or false;

23+ };

24+ toNamedValue = lic: { name = lic.spdxId; value = lic; };

25+in

26+

27+listToAttrs (map (l: toNamedValue (toSpdx l)) licensesJSON.licenses)

lib/spdx/parser.nixnew file+115

@@ -0,0 +1,115 @@

1+let String = { mempty = ""; mappend = a: b: a + b; };

2+ List = { singleton = x: [x]; };

3+ pair = a: b: { _1 = a; _2 = b; };

4+ Pair = { pure = s: pair String.mempty s;

5+ mappend = a: b: pair (String.mappend a._1 b._1) b._2;

6+ map = f: p: pair (f p._1) p._2;

7+ };

8+ compose = f: g: x: f (g x);

9+in with builtins; rec {

10+ # Parser a = String -> [(a, String)]

11+ string = str: s:

12+ let strL = stringLength str;

13+ sL = stringLength s;

14+ in if str == substring 0 strL s

15+ then [ (pair str (substring strL sL s)) ]

16+ else [];

17+

18+ regex = capture_groups: re: s:

19+ let result = match "(${re})(.*)" s;

20+ in if result == null

21+ then []

22+ else [ (pair (elemAt result 0) (elemAt result (1 + capture_groups))) ];

23+

24+ # Left-biased choice

25+ choice = cs: s:

26+ if cs == []

27+ then []

28+ else let c = head cs;

29+ cs' = tail cs;

30+ result = c s;

31+ in if result == []

32+ then choice cs' s

33+ else result;

34+

35+ optional = p: s:

36+ let result = p s;

37+ in if result == []

38+ then [ (Pair.pure s) ]

39+ else result;

40+

41+ chain = ps: s:

42+ if ps == []

43+ then [ (Pair.pure s) ]

44+ else let p = head ps;

45+ ps' = tail ps;

46+ result = p s;

47+ in if result == []

48+ then []

49+ else let r = head result;

50+ rest = chain ps' r._2;

51+ in if rest == []

52+ then []

53+ else let r' = head rest;

54+ in [ (Pair.mappend r r') ];

55+

56+ idstring = regex 0 "[-\.0-9a-zA-Z]+";

57+

58+ license-ref = let documentref = chain [ (string "DocumentRef-")

59+ idstring

60+ (string ":")

61+ ];

62+ in chain [

63+ (optional documentref)

64+ (string "LicenseRef-")

65+ idstring

66+ ];

67+

68+ simple-expression = choice [ license-ref

69+ (chain [ idstring (string "+") ])

70+ idstring

71+ ];

72+

73+ compound-expression = let wrap = compose (map (Pair.map List.singleton));

74+ in choice [

75+ (s: let result = simple-expression s;

76+ in if result == []

77+ then []

78+ else let r = head result;

79+ rest = chain [(string " WITH ") idstring ] r._2;

80+ in if rest == []

81+ then []

82+ else [(pair r._1 (head rest)._2)]

83+ )

84+ (s: let result = simple-expression s;

85+ in if result == []

86+ then []

87+ else let r = head result;

88+ firstLicense = r._1;

89+ operator = choice [ (string " AND ")

90+ (string " OR ")

91+ ]

92+ r._2;

93+ in if operator == []

94+ then []

95+ else let s' = (head operator)._2;

96+ licenses = compound-expression s';

97+ in if licenses == []

98+ then []

99+ else let ls = head licenses;

100+ in [(pair ([firstLicense] ++ ls._1) ls._2)]

101+ )

102+ (wrap simple-expression)

103+ (s: let openParen = string "(" s;

104+ in if openParen == []

105+ then []

106+ else let result = compound-expression (head openParen)._2;

107+ in if result == []

108+ then []

109+ else let r = head result;

110+ closeParen = string ")" r._2;

111+ in if closeParen == []

112+ then []

113+ else [(pair r._1 (head closeParen)._2)])

114+ ];

115+}

lib/spdx/test.nixnew file+32

@@ -0,0 +1,32 @@

1+let spdx = import ./parser.nix;

2+in {

3+ idstringF = [ (spdx.idstring "$@#!$") ];

4+ idstringP = [ (spdx.idstring "blah") ];

5+

6+ license-refF = [ (spdx.license-ref "LicenseRef-$@#!$") ];

7+ license-refP = [ (spdx.license-ref "LicenseRef-blah")

8+ (spdx.license-ref "DocumentRef-beep:LicenseRef-boop")

9+ ];

10+

11+ simple-expressionF = [ (spdx.simple-expression "$@#!$") ];

12+ simple-expressionP = [

13+ (spdx.simple-expression "blah")

14+ (spdx.simple-expression "blah+")

15+ (spdx.simple-expression "LicenseRef-blah")

16+ (spdx.simple-expression "DocumentRef-beep:LicenseRef-boop")

17+ ];

18+

19+ compound-expressionF = [ (spdx.compound-expression "$@#!$") ];

20+ compound-expressionP = [

21+ (spdx.compound-expression "blah")

22+ (spdx.compound-expression "blah+")

23+ (spdx.compound-expression "LicenseRef-blah")

24+ (spdx.compound-expression "DocumentRef-beep:LicenseRef-boop")

25+ (spdx.compound-expression "(blah)")

26+ (spdx.compound-expression "beep OR boop")

27+ (spdx.compound-expression "beep AND boop")

28+ (spdx.compound-expression "beep WITH boop")

29+ (spdx.compound-expression "beep AND (boop OR blap)")

30+ (spdx.compound-expression "(beep AND ((boop OR ((blap)))))")

31+ ];

32+}

lib/stack-cache-generator.nix+53−45

@@ -1,6 +1,5 @@

1# Generate cache entries for dependencies of package defined in `src`

2

3−{ pkgs, haskellLib, nix-tools }:

4{ src

3{ src

5, stackYaml ? "stack.yaml"

4, stackYaml ? "stack.yaml"

6, sha256map ? null

5, sha256map ? null

@@ -9,48 +8,52 @@

9 # sha256map =

8 # sha256map =

10 # { "https://github.com/jgm/pandoc-citeproc"."0.17"

9 # { "https://github.com/jgm/pandoc-citeproc"."0.17"

11 # = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q"; };

10 # = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q"; };

12−, lookupSha256 ?

11+, branchMap ? null

13− if sha256map != null

12+ # A way to specify in which branch a git commit can

14− then { location, tag, ...}: sha256map."${location}"."${tag}"

13+ # be found

14+, lookupBranch ?

15+ if branchMap != null

16+ then { location, tag, ...}: branchMap."${location}"."${tag}" or null

15 else _: null

17 else _: null

18+, resolverSha256 ? null

19+, nix-tools

20+, evalPackages

16, ...

21, ...

17−}:

22+}@args:

18let

23let

24+ inherit (evalPackages) runCommand;

25+ inherit (evalPackages.haskell-nix) haskellLib;

26+

19 # We only care about the stackYaml file. If src is a local directory

27 # We only care about the stackYaml file. If src is a local directory

20 # we want to avoid recalculating the cache unless the stack.yaml file

28 # we want to avoid recalculating the cache unless the stack.yaml file

21 # changes.

29 # changes.

22

30

23− # Using origSrcSubDir bypasses any cleanSourceWith so that it will work when

31+ inherit (haskellLib.fetchResolver {

24− # access to the store is restricted. If origSrc was already in the store

32+ inherit src stackYaml resolverSha256;

25− # you can pass the project in as a string.

33+ }) resolver fetchedResolver;

26− rawStackYaml = builtins.readFile ((src.origSrcSubDir or src) + ("/" + stackYaml));

34+

35+ # Filter just the stack yaml file and any resolver yaml file it points to.

36+ maybeCleanedSource = haskellLib.cleanSourceWith {

37+ inherit src;

38+ filter = path: type:

39+ let

40+ origSrc = if src ? _isLibCleanSourceWith then src.origSrc else src;

41+ origSubDir = if src ? _isLibCleanSourceWithEx then src.origSubDir else "";

42+ relPath = evalPackages.lib.removePrefix (toString origSrc + origSubDir + "/") path;

27

43

28− # Determine the resolver as it may point to another file we need

44+ # checks if path1 is a parent directory for path2

29− # to look at.

45+ isParent = path1: path2: evalPackages.lib.hasPrefix "${path1}/" path2;

30− resolver =

31− let

32− rs = pkgs.lib.lists.concatLists (

33− pkgs.lib.lists.filter (l: l != null)

34− (builtins.map (l: builtins.match "^resolver: *(.*)" l)

35− (pkgs.lib.splitString "\n" rawStackYaml)));

36− in

37− pkgs.lib.lists.head (rs ++ [ null ]);

38

46

39− # Filter just the stack yaml file and any reolver yaml file it points to.

47+ in

40− maybeCleanedSource =

48+ (relPath == stackYaml)

41− if haskellLib.canCleanSource src

49+ || (resolver != null && (relPath == resolver || isParent relPath resolver))

42− then haskellLib.cleanSourceWith {

50+ ;

43− inherit src;

51+ };

44− filter = path: type:

45− pkgs.lib.hasSuffix ("/" + stackYaml) path

46− || (resolver != null && pkgs.lib.hasSuffix ("/" + resolver) path);

47− }

48− else src;

49

52

50 # All repos served via ssh or git protocols are usually private

53 # All repos served via ssh or git protocols are usually private

51− private = url: pkgs.lib.substring 0 4 url != "http";

54+ private = url: evalPackages.lib.substring 0 4 url != "http";

52−

55+

53− repos = builtins.fromJSON (builtins.readFile (pkgs.runCommand "stack-repos" {

56+ repos = builtins.fromJSON (builtins.readFile (evalPackages.runCommand "stack-repos" {

54 buildInputs = [ nix-tools ];

57 buildInputs = [ nix-tools ];

55 } ''

58 } ''

56 TMP=$(mktemp -d)

59 TMP=$(mktemp -d)

@@ -58,38 +61,43 @@ let

58 cp -r "${maybeCleanedSource}/." $TMP

61 cp -r "${maybeCleanedSource}/." $TMP

59 chmod -R +w $TMP

62 chmod -R +w $TMP

60 substituteInPlace ${stackYaml} --replace "# nix-sha256:" "nix-sha256:"

63 substituteInPlace ${stackYaml} --replace "# nix-sha256:" "nix-sha256:"

64+ ${evalPackages.lib.optionalString (fetchedResolver != null) ''

65+ substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

66+ ''}

61 stack-repos --stack-yaml ${stackYaml}

67 stack-repos --stack-yaml ${stackYaml}

62 cp repos.json $out

68 cp repos.json $out

63 ''));

69 ''));

64

70

65− cabalName = path: builtins.readFile (pkgs.runCommand "cabal-name" {

71+ cabalName = path: builtins.readFile (evalPackages.runCommand "cabal-name" {

66 buildInputs = [ nix-tools ];

72 buildInputs = [ nix-tools ];

67 } ''

73 } ''

68 cabal-name ${path} > $out

74 cabal-name ${path} > $out

69 '');

75 '');

70

76

71 hashPath = path:

77 hashPath = path:

72− builtins.readFile (pkgs.runCommand "hash-path" { preferLocalBuild = true; }

78+ builtins.readFile (evalPackages.runCommand "hash-path" { preferLocalBuild = true; }

73− "echo -n $(${pkgs.nix}/bin/nix-hash --type sha256 --base32 ${path}) > $out");

79+ "echo -n $(${evalPackages.nix}/bin/nix-hash --type sha256 --base32 ${path}) > $out");

74−in with pkgs.lib;

80+in with evalPackages.lib;

75concatMap (dep:

81concatMap (dep:

76 let

82 let

77 is-private = private dep.url;

83 is-private = private dep.url;

78− sha256 = if dep.sha256 != null

84+ sha256 =

79− then dep.sha256

85+ if dep.sha256 != null then dep.sha256

80− else lookupSha256 {

86+ else if sha256map != null then sha256map."${dep.url}"."${dep.rev}"

81− location = dep.url;

87+ else null;

82− tag = dep.rev;

88+ branch = lookupBranch {

83− };

89+ location = dep.url;

90+ tag = dep.rev;

91+ };

84 pkgsrc =

92 pkgsrc =

85 if !is-private && sha256 != null

93 if !is-private && sha256 != null

86− then pkgs.fetchgit {

94+ then evalPackages.fetchgit {

87 inherit (dep) url rev;

95 inherit (dep) url rev;

88 inherit sha256;

96 inherit sha256;

89 }

97 }

90− else builtins.fetchGit {

98+ else builtins.fetchGit ({

91 inherit (dep) url rev;

99 inherit (dep) url rev;

92− };

100+ } // evalPackages.lib.optionalAttrs (branch != null) { ref = branch; });

93 in map (subdir: {

101 in map (subdir: {

94 name = cabalName "${pkgsrc}/${subdir}";

102 name = cabalName "${pkgsrc}/${subdir}";

95 inherit (dep) url rev;

103 inherit (dep) url rev;

lib/system-nixpkgs-map.nix+121−83

@@ -1,98 +1,136 @@

1−# Maps of system pkg refenreces from

1+# Maps of system pkg references from cabal file to nixpkgs pkgs.

2−# cabal file to nixpkgs pkgs.

2+# library name (from `extra-libraries` field of `.cabal` file) -> nixpkgs package(s) mapping.

3−# See ../docs/dev/pkg-map.md

3+# This mapping is used to construct the `libs` component attribute.

4+# See ../docs/tutorials/pkg-map.md

4pkgs:

5pkgs:

5−# fetchgit should always come from the buildPackages

6+

6−# if it comes from the targetPackages we won't even

7+with pkgs;

7−# be able to execute it.

8+

8− { fetchgit = pkgs.buildPackages.fetchgit; }

9+let

9−# haskell lib -> nix lib mapping

10+ # On windows systems we need these to be propagatedBuildInputs so that the DLLs will be found.

11+ gcclibs = if pkgs.stdenv.hostPlatform.isWindows then [

12+ pkgs.windows.mcfgthreads

13+ # If we just use `pkgs.buildPackages.gcc.cc` here it breaks the `th-dlls` test. TODO figure out why exactly.

14+ (pkgs.buildPackages.runCommand "gcc-only" { nativeBuildInputs = [ pkgs.buildPackages.xorg.lndir ]; } ''

15+ mkdir $out

16+ lndir ${pkgs.buildPackages.gcc.cc} $out

17+ '')

18+ ] else [];

19+in

10# -- linux

20# -- linux

11−// { crypto = pkgs.openssl;

21+{ crypto = [ openssl ];

12− "c++" = null; # no libc++

22+ "c++" = []; # no libc++

13− "stdc++" = null; "stdc++-6" = null;

23+ "stdc++" = gcclibs;

14− ssl = pkgs.openssl;

24+ "stdc++-6" = gcclibs;

15− z = pkgs.zlib;

25+ gcc_s_seh-1 = gcclibs;

16− pthread = null; # available by default

26+ gcc_s = gcclibs;

17− GL = pkgs.libGL;

27+ gcc = gcclibs;

18− GLU = pkgs.libGLU;

28+ ssl = [ openssl ];

19− alut = pkgs.freealut;

29+ z = [ zlib ];

20− X11 = pkgs.xorg.libX11;

30+ m = []; # Included with ghc

21− Xrandr = pkgs.xorg.libXrandr;

31+ pcap = [ libpcap ];

22− Xext = pkgs.xorg.libXext;

32+ pthread = null; # available by default

23− Xi = pkgs.xorg.libXi;

33+ GL = [ libGL ];

24− Xxf86vm = pkgs.xorg.libXxf86vm;

34+ GLEW = [ glew ];

25− Xcursor = pkgs.xorg.libXcursor;

35+ GLU = [ libGLU ];

26− Xinerama = pkgs.xorg.libXinerama;

36+ alut = [ freealut ];

27− mysqlclient = pkgs.mysql;

37+ X11 = with xorg; [ libX11 ];

28− Imlib2 = pkgs.imlib2;

38+ Xrandr = [ xorg.libXrandr ];

29− asound = pkgs.alsaLib;

39+ Xrender = [ xorg.libXrender ];

30− ffi = null;

40+ Xss = [ xorg.libXScrnSaver ];

31− bz2 = pkgs.bzip2;

41+ Xext = [ xorg.libXext ];

32− util = pkgs.utillinux;

42+ Xi = [ xorg.libXi ];

33− magic = pkgs.file;

43+ Xxf86vm = [ xorg.libXxf86vm ];

34− pq = pkgs.postgresql;

44+ Xcursor = [ xorg.libXcursor ];

35− iconv = pkgs.libiconv;

45+ Xinerama = [ xorg.libXinerama ];

36− lapack = pkgs.liblapack;

46+ mysqlclient = [ mysql ];

37− boost_atomic = pkgs.boost;

47+ Imlib2 = [ imlib2 ];

38− boost_chrono = pkgs.boost;

48+ asound = [ alsaLib ];

39− boost_container = pkgs.boost;

49+ ffi = null;

40− boost_context = pkgs.boost;

50+ bz2 = [ bzip2 ];

41− boost_contract = pkgs.boost;

51+ util = [ utillinux ];

42− boost_coroutine = pkgs.boost;

52+ magic = [ file ];

43− boost_date_time = pkgs.boost;

53+ pq = [ postgresql ];

44− boost_fiber = pkgs.boost;

54+ libpq = [ postgresql ];

45− boost_filesystem = pkgs.boost;

55+ iconv = [ libiconv ];

46− boost_graph = pkgs.boost;

56+ lapack = [ liblapack ];

47− boost_iostreams = pkgs.boost;

57+ boost_atomic = [ boost ];

48− boost_locale = pkgs.boost;

58+ boost_chrono = [ boost ];

49− boost_log_setup = pkgs.boost;

59+ boost_container = [ boost ];

50− boost_log = pkgs.boost;

60+ boost_context = [ boost ];

51− boost_math_c99f = pkgs.boost;

61+ boost_contract = [ boost ];

52− boost_math_c99l = pkgs.boost;

62+ boost_coroutine = [ boost ];

53− boost_math_c99 = pkgs.boost;

63+ boost_date_time = [ boost ];

54− boost_math_tr1f = pkgs.boost;

64+ boost_fiber = [ boost ];

55− boost_math_tr1l = pkgs.boost;

65+ boost_filesystem = [ boost ];

56− boost_math_tr1 = pkgs.boost;

66+ boost_graph = [ boost ];

57− boost_prg_exec_monitor = pkgs.boost;

67+ boost_iostreams = [ boost ];

58− boost_program_options = pkgs.boost;

68+ boost_locale = [ boost ];

59− boost_random = pkgs.boost;

69+ boost_log_setup = [ boost ];

60− boost_regex = pkgs.boost;

70+ boost_log = [ boost ];

61− boost_serialization = pkgs.boost;

71+ boost_math_c99f = [ boost ];

62− boost_signals = pkgs.boost;

72+ boost_math_c99l = [ boost ];

63− boost_stacktrace_addr2line = pkgs.boost;

73+ boost_math_c99 = [ boost ];

64− boost_stacktrace_basic = pkgs.boost;

74+ boost_math_tr1f = [ boost ];

65− boost_stacktrace_noop = pkgs.boost;

75+ boost_math_tr1l = [ boost ];

66− boost_system = pkgs.boost;

76+ boost_math_tr1 = [ boost ];

67− boost_thread = pkgs.boost;

77+ boost_prg_exec_monitor = [ boost ];

68− boost_timer = pkgs.boost;

78+ boost_program_options = [ boost ];

69− boost_type_erasure = pkgs.boost;

79+ boost_random = [ boost ];

70− boost_unit_test_framework = pkgs.boost;

80+ boost_regex = [ boost ];

71− boost_wave = pkgs.boost;

81+ boost_serialization = [ boost ];

72− boost_wserialization = pkgs.boost;

82+ boost_signals = [ boost ];

73− tensorflow = pkgs.libtensorflow;

83+ boost_stacktrace_addr2line = [ boost ];

74− opencv = pkgs.opencv3;

84+ boost_stacktrace_basic = [ boost ];

75− icuuc = pkgs.icu;

85+ boost_stacktrace_noop = [ boost ];

76− icui18n = pkgs.icu;

86+ boost_system = [ boost ];

77− icudata = pkgs.icu;

87+ boost_thread = [ boost ];

78− vulkan = pkgs.vulkan-loader;

88+ boost_timer = [ boost ];

79− sodium = pkgs.libsodium;

89+ boost_type_erasure = [ boost ];

80− gfortran = pkgs.gfortran.cc.lib;

90+ boost_unit_test_framework = [ boost ];

81− }

91+ boost_wave = [ boost ];

92+ boost_wserialization = [ boost ];

93+ tensorflow = [ libtensorflow ];

94+ # odbc package requires unixODBC packages to be installed in order to successfully

95+ # compile C sources (https://github.com/fpco/odbc/blob/master/cbits/odbc.c)

96+ odbc = [ unixODBC ];

97+ opencv = [ opencv3 ];

98+ icuuc = [ icu ];

99+ icui18n = [ icu ];

100+ icu-i18n = [ icu ];

101+ icudata = [ icu ];

102+ vulkan = [ vulkan-loader ];

103+ sodium = [ libsodium ];

104+ gfortran = [ gfortran.cc.lib ];

105+ ssh2 = [ libssh2 ];

106+ gpiod = [ libgpiod ];

107+ png = [ libpng ];

108+ jpeg = [ libjpeg ];

109+ freenect_sync = [ freenect ];

110+ FLAC = [ flac ];

111+ mp3lame = [ lame ];

112+ tag_c = [ taglib ];

113+ jwt = [ libjwt ];

114+ GeoIP = [ geoip ];

115+ pulse-simple = [ libpulseaudio ];

116+ oath = [ liboauth ];

117+}

82# -- windows

118# -- windows

83// { advapi32 = null; gdi32 = null; imm32 = null; msimg32 = null;

119// { advapi32 = null; gdi32 = null; imm32 = null; msimg32 = null;

84 shell32 = null; shfolder = null; shlwapi = null; user32 = null;

120 shell32 = null; shfolder = null; shlwapi = null; user32 = null;

121+ ole32 = null; rpcrt4 = null;

85 winmm = null; userenv = null;

122 winmm = null; userenv = null;

86 kernel32 = null; ws2_32 = null;

123 kernel32 = null; ws2_32 = null;

87 # this should be bundled with gcc.

124 # this should be bundled with gcc.

88 # if it's not we have more severe

125 # if it's not we have more severe

89 # issues anyway.

126 # issues anyway.

90− gcc_s_seh-1 = null;

127+ ssl32 = null; eay32 = [ openssl ];

91− ssl32 = null; eay32 = pkgs.openssl;

92 iphlpapi = null; # IP Help API

128 iphlpapi = null; # IP Help API

93 msvcrt = null; # this is the libc

129 msvcrt = null; # this is the libc

94 Crypt32 = null;

130 Crypt32 = null;

131+ mswsock = null;

132+ bcrypt = null;

95 }

133 }

96# -- os x

134# -- os x

97−# NB: these map almost 1:1 to the famework names

135+# NB: these map almost 1:1 to the framework names

98−// pkgs.darwin.apple_sdk.frameworks

136+// darwin.apple_sdk.frameworks

lib/system-pkgs.nixnew file+16

@@ -0,0 +1,16 @@

1+# Cabal packages can depend on operating system packages. However

2+# package names vary between distributions - there is no standard.

3+#

4+# This file augments the nixpkgs package set with extra attributes

5+# from the system packages map file.

6+#

7+# This package set will be used when resolving system package

8+# dependencies of package descriptions.

9+

10+pkgs:

11+

12+ # Base packages.

13+ pkgs

14+

15+ # Apply the mapping.

16+ // import ./system-nixpkgs-map.nix pkgs

materialized/bootstrap/ghc8107/alex/.plan.nix/alex.nixnew file+160

@@ -0,0 +1,160 @@

1+{ system

2+ , compiler

3+ , flags

4+ , pkgs

5+ , hsPkgs

6+ , pkgconfPkgs

7+ , errorHandler

8+ , config

9+ , ... }:

10+ {

11+ flags = { small_base = true; };

12+ package = {

13+ specVersion = "1.8";

14+ identifier = { name = "alex"; version = "3.2.4"; };

15+ license = "BSD-3-Clause";

16+ copyright = "(c) Chis Dornan, Simon Marlow";

17+ maintainer = "Simon Marlow <marlowsd@gmail.com>";

18+ author = "Chris Dornan and Simon Marlow";

19+ homepage = "http://www.haskell.org/alex/";

20+ url = "";

21+ synopsis = "Alex is a tool for generating lexical analysers in Haskell";

22+ description = "Alex is a tool for generating lexical analysers in Haskell.\nIt takes a description of tokens based on regular\nexpressions and generates a Haskell module containing code\nfor scanning text efficiently. It is similar to the tool\nlex or flex for C/C++.";

23+ buildType = "Simple";

24+ isLocal = true;

25+ detailLevel = "FullDetails";

26+ licenseFiles = [ "LICENSE" ];

27+ dataDir = "data/";

28+ dataFiles = [

29+ "AlexTemplate"

30+ "AlexTemplate-ghc"

31+ "AlexTemplate-ghc-nopred"

32+ "AlexTemplate-ghc-debug"

33+ "AlexTemplate-debug"

34+ "AlexWrapper-basic"

35+ "AlexWrapper-basic-bytestring"

36+ "AlexWrapper-strict-bytestring"

37+ "AlexWrapper-posn"

38+ "AlexWrapper-posn-bytestring"

39+ "AlexWrapper-monad"

40+ "AlexWrapper-monad-bytestring"

41+ "AlexWrapper-monadUserState"

42+ "AlexWrapper-monadUserState-bytestring"

43+ "AlexWrapper-gscan"

44+ ];

45+ extraSrcFiles = [

46+ "CHANGELOG.md"

47+ "README.md"

48+ "TODO"

49+ "alex.spec"

50+ "doc/Makefile"

51+ "doc/aclocal.m4"

52+ "doc/alex.1.in"

53+ "doc/alex.xml"

54+ "doc/config.mk.in"

55+ "doc/configure.ac"

56+ "doc/docbook-xml.mk"

57+ "doc/fptools.css"

58+ "examples/Makefile"

59+ "examples/Tokens.x"

60+ "examples/Tokens_gscan.x"

61+ "examples/Tokens_posn.x"

62+ "examples/examples.x"

63+ "examples/haskell.x"

64+ "examples/lit.x"

65+ "examples/pp.x"

66+ "examples/state.x"

67+ "examples/tiny.y"

68+ "examples/words.x"

69+ "examples/words_monad.x"

70+ "examples/words_posn.x"

71+ "src/Parser.y.boot"

72+ "src/Scan.x.boot"

73+ "src/ghc_hooks.c"

74+ "templates/GenericTemplate.hs"

75+ "templates/wrappers.hs"

76+ "tests/Makefile"

77+ "tests/simple.x"

78+ "tests/null.x"

79+ "tests/tokens.x"

80+ "tests/tokens_gscan.x"

81+ "tests/tokens_posn.x"

82+ "tests/tokens_bytestring.x"

83+ "tests/tokens_posn_bytestring.x"

84+ "tests/tokens_scan_user.x"

85+ "tests/tokens_strict_bytestring.x"

86+ "tests/tokens_monad_bytestring.x"

87+ "tests/tokens_monadUserState_bytestring.x"

88+ "tests/tokens_bytestring_unicode.x"

89+ "tests/basic_typeclass.x"

90+ "tests/basic_typeclass_bytestring.x"

91+ "tests/default_typeclass.x"

92+ "tests/gscan_typeclass.x"

93+ "tests/posn_typeclass.x"

94+ "tests/monad_typeclass.x"

95+ "tests/monad_typeclass_bytestring.x"

96+ "tests/monadUserState_typeclass.x"

97+ "tests/monadUserState_typeclass_bytestring.x"

98+ "tests/posn_typeclass_bytestring.x"

99+ "tests/strict_typeclass.x"

100+ "tests/unicode.x"

101+ ];

102+ extraTmpFiles = [];

103+ extraDocFiles = [];

104+ };

105+ components = {

106+ exes = {

107+ "alex" = {

108+ depends = [

109+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

110+ ] ++ (if flags.small_base

111+ then [

112+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

113+ (hsPkgs."array" or (errorHandler.buildDepError "array"))

114+ (hsPkgs."containers" or (errorHandler.buildDepError "containers"))

115+ (hsPkgs."directory" or (errorHandler.buildDepError "directory"))

116+ ]

117+ else [ (hsPkgs."base" or (errorHandler.buildDepError "base")) ]);

118+ buildable = true;

119+ modules = [

120+ "AbsSyn"

121+ "CharSet"

122+ "DFA"

123+ "DFAMin"

124+ "DFS"

125+ "Info"

126+ "Map"

127+ "NFA"

128+ "Output"

129+ "Paths_alex"

130+ "Parser"

131+ "ParseMonad"

132+ "Scan"

133+ "Set"

134+ "Sort"

135+ "Util"

136+ "UTF8"

137+ "Data/Ranged"

138+ "Data/Ranged/Boundaries"

139+ "Data/Ranged/RangedSet"

140+ "Data/Ranged/Ranges"

141+ ];

142+ hsSourceDirs = [ "src" ];

143+ mainPath = [ "Main.hs" ] ++ [ "" ];

144+ };

145+ };

146+ tests = {

147+ "tests" = {

148+ depends = [

149+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

150+ (hsPkgs."process" or (errorHandler.buildDepError "process"))

151+ ];

152+ build-tools = [

153+ (hsPkgs.buildPackages.alex.components.exes.alex or (pkgs.buildPackages.alex or (errorHandler.buildToolDepError "alex:alex")))

154+ ];

155+ buildable = true;

156+ mainPath = [ "test.hs" ];

157+ };

158+ };

159+ };

160+ } // rec { src = (pkgs.lib).mkDefault ../.; }

materialized/bootstrap/ghc8107/alex/default.nixnew file+69

@@ -0,0 +1,69 @@

1+{

2+ pkgs = hackage:

3+ {

4+ packages = {

5+ "ghc-prim".revision = (((hackage."ghc-prim")."0.6.1").revisions).default;

6+ "array".revision = (((hackage."array")."0.5.4.0").revisions).default;

7+ "integer-gmp".revision = (((hackage."integer-gmp")."1.0.3.0").revisions).default;

8+ "process".revision = (((hackage."process")."1.6.13.2").revisions).default;

9+ "base".revision = (((hackage."base")."4.14.3.0").revisions).default;

10+ "rts".revision = (((hackage."rts")."1.0.1").revisions).default;

11+ "time".revision = (((hackage."time")."1.9.3").revisions).default;

12+ "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;

13+ "bytestring".revision = (((hackage."bytestring")."0.10.12.0").revisions).default;

14+ "containers".revision = (((hackage."containers")."0.6.5.1").revisions).default;

15+ "directory".revision = (((hackage."directory")."1.3.6.0").revisions).default;

16+ "filepath".revision = (((hackage."filepath")."1.4.2.1").revisions).default;

17+ "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;

18+ };

19+ compiler = {

20+ version = "8.10.7";

21+ nix-name = "ghc8107";

22+ packages = {

23+ "ghc-prim" = "0.6.1";

24+ "array" = "0.5.4.0";

25+ "integer-gmp" = "1.0.3.0";

26+ "process" = "1.6.13.2";

27+ "base" = "4.14.3.0";

28+ "rts" = "1.0.1";

29+ "time" = "1.9.3";

30+ "unix" = "2.7.2.2";

31+ "bytestring" = "0.10.12.0";

32+ "containers" = "0.6.5.1";

33+ "directory" = "1.3.6.0";

34+ "filepath" = "1.4.2.1";

35+ "deepseq" = "1.4.4.0";

36+ };

37+ };

38+ };

39+ extras = hackage:

40+ { packages = { alex = ./.plan.nix/alex.nix; }; };

41+ modules = [

42+ ({ lib, ... }:

43+ {

44+ packages = {

45+ "alex" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

46+ };

47+ })

48+ ({ lib, ... }:

49+ {

50+ packages = {

51+ "containers".components.library.planned = lib.mkOverride 900 true;

52+ "ghc-prim".components.library.planned = lib.mkOverride 900 true;

53+ "process".components.library.planned = lib.mkOverride 900 true;

54+ "integer-gmp".components.library.planned = lib.mkOverride 900 true;

55+ "array".components.library.planned = lib.mkOverride 900 true;

56+ "bytestring".components.library.planned = lib.mkOverride 900 true;

57+ "unix".components.library.planned = lib.mkOverride 900 true;

58+ "alex".components.exes."alex".planned = lib.mkOverride 900 true;

59+ "base".components.library.planned = lib.mkOverride 900 true;

60+ "rts".components.library.planned = lib.mkOverride 900 true;

61+ "time".components.library.planned = lib.mkOverride 900 true;

62+ "deepseq".components.library.planned = lib.mkOverride 900 true;

63+ "filepath".components.library.planned = lib.mkOverride 900 true;

64+ "directory".components.library.planned = lib.mkOverride 900 true;

65+ "alex".components.tests."tests".planned = lib.mkOverride 900 true;

66+ };

67+ })

68+ ];

69+ }

materialized/ghc883/happy/.plan.nix/happy.nix → materialized/bootstrap/ghc8107/happy-1.19.12/.plan.nix/happy.nixrenamed+1−1

@@ -190,7 +190,7 @@

190 (hsPkgs."process" or (errorHandler.buildDepError "process"))

191 ];

192 build-tools = [

193− (hsPkgs.buildPackages.happy or (pkgs.buildPackages.happy or (errorHandler.buildToolDepError "happy")))

193+ (hsPkgs.buildPackages.happy.components.exes.happy or (pkgs.buildPackages.happy or (errorHandler.buildToolDepError "happy:happy")))

194 ];

195 buildable = true;

196 mainPath = [ "test.hs" ];

materialized/bootstrap/ghc8107/happy-1.19.12/default.nixnew file+75

@@ -0,0 +1,75 @@

1+{

2+ pkgs = hackage:

3+ {

4+ packages = {

5+ "ghc-prim".revision = (((hackage."ghc-prim")."0.6.1").revisions).default;

6+ "array".revision = (((hackage."array")."0.5.4.0").revisions).default;

7+ "integer-gmp".revision = (((hackage."integer-gmp")."1.0.3.0").revisions).default;

8+ "process".revision = (((hackage."process")."1.6.13.2").revisions).default;

9+ "base".revision = (((hackage."base")."4.14.3.0").revisions).default;

10+ "rts".revision = (((hackage."rts")."1.0.1").revisions).default;

11+ "mtl".revision = (((hackage."mtl")."2.2.2").revisions).default;

12+ "time".revision = (((hackage."time")."1.9.3").revisions).default;

13+ "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;

14+ "bytestring".revision = (((hackage."bytestring")."0.10.12.0").revisions).default;

15+ "containers".revision = (((hackage."containers")."0.6.5.1").revisions).default;

16+ "directory".revision = (((hackage."directory")."1.3.6.0").revisions).default;

17+ "filepath".revision = (((hackage."filepath")."1.4.2.1").revisions).default;

18+ "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;

19+ "transformers".revision = (((hackage."transformers")."0.5.6.2").revisions).default;

20+ };

21+ compiler = {

22+ version = "8.10.7";

23+ nix-name = "ghc8107";

24+ packages = {

25+ "ghc-prim" = "0.6.1";

26+ "array" = "0.5.4.0";

27+ "integer-gmp" = "1.0.3.0";

28+ "process" = "1.6.13.2";

29+ "base" = "4.14.3.0";

30+ "rts" = "1.0.1";

31+ "mtl" = "2.2.2";

32+ "time" = "1.9.3";

33+ "unix" = "2.7.2.2";

34+ "bytestring" = "0.10.12.0";

35+ "containers" = "0.6.5.1";

36+ "directory" = "1.3.6.0";

37+ "filepath" = "1.4.2.1";

38+ "deepseq" = "1.4.4.0";

39+ "transformers" = "0.5.6.2";

40+ };

41+ };

42+ };

43+ extras = hackage:

44+ { packages = { happy = ./.plan.nix/happy.nix; }; };

45+ modules = [

46+ ({ lib, ... }:

47+ {

48+ packages = {

49+ "happy" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

50+ };

51+ })

52+ ({ lib, ... }:

53+ {

54+ packages = {

55+ "containers".components.library.planned = lib.mkOverride 900 true;

56+ "ghc-prim".components.library.planned = lib.mkOverride 900 true;

57+ "happy".components.exes."happy".planned = lib.mkOverride 900 true;

58+ "transformers".components.library.planned = lib.mkOverride 900 true;

59+ "process".components.library.planned = lib.mkOverride 900 true;

60+ "integer-gmp".components.library.planned = lib.mkOverride 900 true;

61+ "array".components.library.planned = lib.mkOverride 900 true;

62+ "bytestring".components.library.planned = lib.mkOverride 900 true;

63+ "unix".components.library.planned = lib.mkOverride 900 true;

64+ "base".components.library.planned = lib.mkOverride 900 true;

65+ "rts".components.library.planned = lib.mkOverride 900 true;

66+ "mtl".components.library.planned = lib.mkOverride 900 true;

67+ "time".components.library.planned = lib.mkOverride 900 true;

68+ "deepseq".components.library.planned = lib.mkOverride 900 true;

69+ "filepath".components.library.planned = lib.mkOverride 900 true;

70+ "happy".components.tests."tests".planned = lib.mkOverride 900 true;

71+ "directory".components.library.planned = lib.mkOverride 900 true;

72+ };

73+ })

74+ ];

75+ }

materialized/bootstrap/ghc8107/hscolour/.plan.nix/hscolour.nixnew file+70

@@ -0,0 +1,70 @@

1+{ system

2+ , compiler

3+ , flags

4+ , pkgs

5+ , hsPkgs

6+ , pkgconfPkgs

7+ , errorHandler

8+ , config

9+ , ... }:

10+ {

11+ flags = {};

12+ package = {

13+ specVersion = "1.6";

14+ identifier = { name = "hscolour"; version = "1.24.4"; };

15+ license = "LicenseRef-LGPL";

16+ copyright = "2003-2017 Malcolm Wallace; 2006 Bjorn Bringert";

17+ maintainer = "Malcolm Wallace";

18+ author = "Malcolm Wallace";

19+ homepage = "http://code.haskell.org/~malcolm/hscolour/";

20+ url = "";

21+ synopsis = "Colourise Haskell code.";

22+ description = "hscolour is a small Haskell script to colourise Haskell code. It currently\nhas six output formats:\nANSI terminal codes (optionally XTerm-256colour codes),\nHTML 3.2 with <font> tags,\nHTML 4.01 with CSS,\nHTML 4.01 with CSS and mouseover annotations,\nXHTML 1.0 with inline CSS styling,\nLaTeX,\nand mIRC chat codes.";

23+ buildType = "Simple";

24+ isLocal = true;

25+ detailLevel = "FullDetails";

26+ licenseFiles = [ "LICENCE-LGPL" ];

27+ dataDir = ".";

28+ dataFiles = [ "hscolour.css" "data/rgb24-example-.hscolour" ];

29+ extraSrcFiles = [];

30+ extraTmpFiles = [];

31+ extraDocFiles = [];

32+ };

33+ components = {

34+ "library" = {

35+ depends = [

36+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

37+ (hsPkgs."containers" or (errorHandler.buildDepError "containers"))

38+ ];

39+ buildable = true;

40+ modules = [

41+ "Language/Haskell/HsColour"

42+ "Language/Haskell/HsColour/ANSI"

43+ "Language/Haskell/HsColour/Anchors"

44+ "Language/Haskell/HsColour/ACSS"

45+ "Language/Haskell/HsColour/CSS"

46+ "Language/Haskell/HsColour/Classify"

47+ "Language/Haskell/HsColour/ColourHighlight"

48+ "Language/Haskell/HsColour/Colourise"

49+ "Language/Haskell/HsColour/General"

50+ "Language/Haskell/HsColour/HTML"

51+ "Language/Haskell/HsColour/InlineCSS"

52+ "Language/Haskell/HsColour/LaTeX"

53+ "Language/Haskell/HsColour/MIRC"

54+ "Language/Haskell/HsColour/Options"

55+ "Language/Haskell/HsColour/Output"

56+ "Language/Haskell/HsColour/TTY"

57+ ];

58+ };

59+ exes = {

60+ "HsColour" = {

61+ depends = [

62+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

63+ (hsPkgs."containers" or (errorHandler.buildDepError "containers"))

64+ ];

65+ buildable = true;

66+ mainPath = [ "HsColour.hs" ];

67+ };

68+ };

69+ };

70+ } // rec { src = (pkgs.lib).mkDefault ../.; }

materialized/bootstrap/ghc8107/hscolour/default.nixnew file+47

@@ -0,0 +1,47 @@

1+{

2+ pkgs = hackage:

3+ {

4+ packages = {

5+ "ghc-prim".revision = (((hackage."ghc-prim")."0.6.1").revisions).default;

6+ "array".revision = (((hackage."array")."0.5.4.0").revisions).default;

7+ "integer-gmp".revision = (((hackage."integer-gmp")."1.0.3.0").revisions).default;

8+ "base".revision = (((hackage."base")."4.14.3.0").revisions).default;

9+ "rts".revision = (((hackage."rts")."1.0.1").revisions).default;

10+ "containers".revision = (((hackage."containers")."0.6.5.1").revisions).default;

11+ "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;

12+ };

13+ compiler = {

14+ version = "8.10.7";

15+ nix-name = "ghc8107";

16+ packages = {

17+ "ghc-prim" = "0.6.1";

18+ "array" = "0.5.4.0";

19+ "integer-gmp" = "1.0.3.0";

20+ "base" = "4.14.3.0";

21+ "rts" = "1.0.1";

22+ "containers" = "0.6.5.1";

23+ "deepseq" = "1.4.4.0";

24+ };

25+ };

26+ };

27+ extras = hackage:

28+ { packages = { hscolour = ./.plan.nix/hscolour.nix; }; };

29+ modules = [

30+ ({ lib, ... }:

31+ { packages = { "hscolour" = { flags = {}; }; }; })

32+ ({ lib, ... }:

33+ {

34+ packages = {

35+ "containers".components.library.planned = lib.mkOverride 900 true;

36+ "ghc-prim".components.library.planned = lib.mkOverride 900 true;

37+ "hscolour".components.exes."HsColour".planned = lib.mkOverride 900 true;

38+ "hscolour".components.library.planned = lib.mkOverride 900 true;

39+ "integer-gmp".components.library.planned = lib.mkOverride 900 true;

40+ "array".components.library.planned = lib.mkOverride 900 true;

41+ "base".components.library.planned = lib.mkOverride 900 true;

42+ "rts".components.library.planned = lib.mkOverride 900 true;

43+ "deepseq".components.library.planned = lib.mkOverride 900 true;

44+ };

45+ })

46+ ];

47+ }

materialized/bootstrap/ghc844/alex/.plan.nix/alex.nix+1−1

@@ -150,7 +150,7 @@

150 (hsPkgs."process" or (errorHandler.buildDepError "process"))

151 ];

152 build-tools = [

153− (hsPkgs.buildPackages.alex or (pkgs.buildPackages.alex or (errorHandler.buildToolDepError "alex")))

153+ (hsPkgs.buildPackages.alex.components.exes.alex or (pkgs.buildPackages.alex or (errorHandler.buildToolDepError "alex:alex")))

154 ];

155 buildable = true;

156 mainPath = [ "test.hs" ];

materialized/bootstrap/ghc844/alex/default.nix+34−18

@@ -3,36 +3,34 @@

3 {

4 packages = {

5 "ghc-prim".revision = (((hackage."ghc-prim")."0.5.2.0").revisions).default;

6− "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;

6+ "array".revision = (((hackage."array")."0.5.2.0").revisions).default;

7− "rts".revision = (((hackage."rts")."1.0").revisions).default;

7+ "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

8− "deepseq".revision = (((hackage."deepseq")."1.4.3.0").revisions).default;

9− "directory".revision = (((hackage."directory")."1.3.1.5").revisions).default;

10− "containers".revision = (((hackage."containers")."0.5.11.0").revisions).default;

11− "bytestring".revision = (((hackage."bytestring")."0.10.8.2").revisions).default;

12 "base".revision = (((hackage."base")."4.11.1.0").revisions).default;

8 "base".revision = (((hackage."base")."4.11.1.0").revisions).default;

9+ "rts".revision = (((hackage."rts")."1.0").revisions).default;

13 "time".revision = (((hackage."time")."1.8.0.2").revisions).default;

10 "time".revision = (((hackage."time")."1.8.0.2").revisions).default;

11+ "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;

12+ "bytestring".revision = (((hackage."bytestring")."0.10.8.2").revisions).default;

13+ "containers".revision = (((hackage."containers")."0.5.11.0").revisions).default;

14+ "directory".revision = (((hackage."directory")."1.3.1.5").revisions).default;

14 "filepath".revision = (((hackage."filepath")."1.4.2").revisions).default;

15 "filepath".revision = (((hackage."filepath")."1.4.2").revisions).default;

15− "process".revision = (((hackage."process")."1.6.3.0").revisions).default;

16+ "deepseq".revision = (((hackage."deepseq")."1.4.3.0").revisions).default;

16− "array".revision = (((hackage."array")."0.5.2.0").revisions).default;

17− "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

18 };

17 };

19 compiler = {

18 compiler = {

20 version = "8.4.4";

19 version = "8.4.4";

21 nix-name = "ghc844";

20 nix-name = "ghc844";

22 packages = {

21 packages = {

23 "ghc-prim" = "0.5.2.0";

22 "ghc-prim" = "0.5.2.0";

24− "unix" = "2.7.2.2";

23+ "array" = "0.5.2.0";

25− "rts" = "1.0";

24+ "integer-gmp" = "1.0.2.0";

26− "deepseq" = "1.4.3.0";

27− "directory" = "1.3.1.5";

28− "containers" = "0.5.11.0";

29− "bytestring" = "0.10.8.2";

30 "base" = "4.11.1.0";

25 "base" = "4.11.1.0";

26+ "rts" = "1.0";

31 "time" = "1.8.0.2";

27 "time" = "1.8.0.2";

28+ "unix" = "2.7.2.2";

29+ "bytestring" = "0.10.8.2";

30+ "containers" = "0.5.11.0";

31+ "directory" = "1.3.1.5";

32 "filepath" = "1.4.2";

33− "process" = "1.6.3.0";

33+ "deepseq" = "1.4.3.0";

34− "array" = "0.5.2.0";

35− "integer-gmp" = "1.0.2.0";

36 };

34 };

37 };

35 };

38 };

36 };

@@ -45,5 +43,23 @@

45 "alex" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

43 "alex" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

46 };

44 };

47 })

45 })

46+ ({ lib, ... }:

47+ {

48+ packages = {

49+ "containers".components.library.planned = lib.mkOverride 900 true;

50+ "ghc-prim".components.library.planned = lib.mkOverride 900 true;

51+ "integer-gmp".components.library.planned = lib.mkOverride 900 true;

52+ "array".components.library.planned = lib.mkOverride 900 true;

53+ "bytestring".components.library.planned = lib.mkOverride 900 true;

54+ "unix".components.library.planned = lib.mkOverride 900 true;

55+ "alex".components.exes."alex".planned = lib.mkOverride 900 true;

56+ "base".components.library.planned = lib.mkOverride 900 true;

57+ "rts".components.library.planned = lib.mkOverride 900 true;

58+ "time".components.library.planned = lib.mkOverride 900 true;

59+ "deepseq".components.library.planned = lib.mkOverride 900 true;

60+ "filepath".components.library.planned = lib.mkOverride 900 true;

61+ "directory".components.library.planned = lib.mkOverride 900 true;

62+ };

63+ })

48 ];

64 ];

49 }

65 }

materialized/bootstrap/ghc844/happy-1.19.11/.plan.nix/happy.nix+5−5

@@ -23,14 +23,14 @@

23 buildType = "Custom";

24 isLocal = true;

25 setup-depends = [

26− (hsPkgs.buildPackages.Cabal or (pkgs.buildPackages.Cabal or (errorHandler.buildToolDepError "Cabal")))

26+ (hsPkgs.buildPackages.Cabal or (pkgs.buildPackages.Cabal or (errorHandler.setupDepError "Cabal")))

27− (hsPkgs.buildPackages.base or (pkgs.buildPackages.base or (errorHandler.buildToolDepError "base")))

27+ (hsPkgs.buildPackages.base or (pkgs.buildPackages.base or (errorHandler.setupDepError "base")))

28− (hsPkgs.buildPackages.directory or (pkgs.buildPackages.directory or (errorHandler.buildToolDepError "directory")))

28+ (hsPkgs.buildPackages.directory or (pkgs.buildPackages.directory or (errorHandler.setupDepError "directory")))

29− (hsPkgs.buildPackages.filepath or (pkgs.buildPackages.filepath or (errorHandler.buildToolDepError "filepath")))

29+ (hsPkgs.buildPackages.filepath or (pkgs.buildPackages.filepath or (errorHandler.setupDepError "filepath")))

30 ];

31 detailLevel = "FullDetails";

32 licenseFiles = [ "LICENSE" ];

33− dataDir = "";

33+ dataDir = ".";

34 dataFiles = [];

35 extraSrcFiles = [

36 "ANNOUNCE"

materialized/bootstrap/ghc844/happy-1.19.11/default.nix+55−28

@@ -4,24 +4,24 @@

4 packages = {

5 "binary".revision = (((hackage."binary")."0.8.5.1").revisions).default;

6 "ghc-prim".revision = (((hackage."ghc-prim")."0.5.2.0").revisions).default;

7− "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;

7+ "array".revision = (((hackage."array")."0.5.2.0").revisions).default;

8− "mtl".revision = (((hackage."mtl")."2.2.2").revisions).default;

8+ "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

9+ "pretty".revision = (((hackage."pretty")."1.1.3.6").revisions).default;

10+ "process".revision = (((hackage."process")."1.6.3.0").revisions).default;

11+ "base".revision = (((hackage."base")."4.11.1.0").revisions).default;

9 "rts".revision = (((hackage."rts")."1.0").revisions).default;

12 "rts".revision = (((hackage."rts")."1.0").revisions).default;

10− "deepseq".revision = (((hackage."deepseq")."1.4.3.0").revisions).default;

11− "parsec".revision = (((hackage."parsec")."3.1.13.0").revisions).default;

12− "directory".revision = (((hackage."directory")."1.3.1.5").revisions).default;

13− "containers".revision = (((hackage."containers")."0.5.11.0").revisions).default;

14− "bytestring".revision = (((hackage."bytestring")."0.10.8.2").revisions).default;

15 "text".revision = (((hackage."text")."1.2.3.1").revisions).default;

13 "text".revision = (((hackage."text")."1.2.3.1").revisions).default;

16− "Cabal".revision = (((hackage."Cabal")."2.2.0.1").revisions).default;

14+ "mtl".revision = (((hackage."mtl")."2.2.2").revisions).default;

17− "base".revision = (((hackage."base")."4.11.1.0").revisions).default;

18 "time".revision = (((hackage."time")."1.8.0.2").revisions).default;

15 "time".revision = (((hackage."time")."1.8.0.2").revisions).default;

19− "transformers".revision = (((hackage."transformers")."0.5.5.0").revisions).default;

16+ "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;

17+ "bytestring".revision = (((hackage."bytestring")."0.10.8.2").revisions).default;

18+ "containers".revision = (((hackage."containers")."0.5.11.0").revisions).default;

19+ "directory".revision = (((hackage."directory")."1.3.1.5").revisions).default;

20+ "parsec".revision = (((hackage."parsec")."3.1.13.0").revisions).default;

20 "filepath".revision = (((hackage."filepath")."1.4.2").revisions).default;

21 "filepath".revision = (((hackage."filepath")."1.4.2").revisions).default;

21− "process".revision = (((hackage."process")."1.6.3.0").revisions).default;

22+ "deepseq".revision = (((hackage."deepseq")."1.4.3.0").revisions).default;

22− "pretty".revision = (((hackage."pretty")."1.1.3.6").revisions).default;

23+ "transformers".revision = (((hackage."transformers")."0.5.5.0").revisions).default;

23− "array".revision = (((hackage."array")."0.5.2.0").revisions).default;

24+ "Cabal".revision = (((hackage."Cabal")."2.2.0.1").revisions).default;

24− "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

25 };

26 compiler = {

27 version = "8.4.4";

@@ -29,24 +29,24 @@

29 packages = {

30 "binary" = "0.8.5.1";

31 "ghc-prim" = "0.5.2.0";

32− "unix" = "2.7.2.2";

32+ "array" = "0.5.2.0";

33− "mtl" = "2.2.2";

33+ "integer-gmp" = "1.0.2.0";

34+ "pretty" = "1.1.3.6";

35+ "process" = "1.6.3.0";

36+ "base" = "4.11.1.0";

34 "rts" = "1.0";

37 "rts" = "1.0";

35− "deepseq" = "1.4.3.0";

36− "parsec" = "3.1.13.0";

37− "directory" = "1.3.1.5";

38− "containers" = "0.5.11.0";

39− "bytestring" = "0.10.8.2";

40 "text" = "1.2.3.1";

38 "text" = "1.2.3.1";

41− "Cabal" = "2.2.0.1";

39+ "mtl" = "2.2.2";

42− "base" = "4.11.1.0";

43 "time" = "1.8.0.2";

40 "time" = "1.8.0.2";

44− "transformers" = "0.5.5.0";

41+ "unix" = "2.7.2.2";

42+ "bytestring" = "0.10.8.2";

43+ "containers" = "0.5.11.0";

44+ "directory" = "1.3.1.5";

45+ "parsec" = "3.1.13.0";

45 "filepath" = "1.4.2";

46 "filepath" = "1.4.2";

46− "process" = "1.6.3.0";

47+ "deepseq" = "1.4.3.0";

47− "pretty" = "1.1.3.6";

48+ "transformers" = "0.5.5.0";

48− "array" = "0.5.2.0";

49+ "Cabal" = "2.2.0.1";

49− "integer-gmp" = "1.0.2.0";

50 };

51 };

52 };

@@ -59,5 +59,32 @@

59 "happy" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

60 };

61 })

62+ ({ lib, ... }:

63+ {

64+ packages = {

65+ "containers".components.library.planned = lib.mkOverride 900 true;

66+ "binary".components.library.planned = lib.mkOverride 900 true;

67+ "ghc-prim".components.library.planned = lib.mkOverride 900 true;

68+ "happy".components.exes."happy".planned = lib.mkOverride 900 true;

69+ "Cabal".components.library.planned = lib.mkOverride 900 true;

70+ "transformers".components.library.planned = lib.mkOverride 900 true;

71+ "process".components.library.planned = lib.mkOverride 900 true;

72+ "pretty".components.library.planned = lib.mkOverride 900 true;

73+ "integer-gmp".components.library.planned = lib.mkOverride 900 true;

74+ "array".components.library.planned = lib.mkOverride 900 true;

75+ "bytestring".components.library.planned = lib.mkOverride 900 true;

76+ "unix".components.library.planned = lib.mkOverride 900 true;

77+ "text".components.library.planned = lib.mkOverride 900 true;

78+ "base".components.library.planned = lib.mkOverride 900 true;

79+ "rts".components.library.planned = lib.mkOverride 900 true;

80+ "mtl".components.library.planned = lib.mkOverride 900 true;

81+ "time".components.library.planned = lib.mkOverride 900 true;

82+ "happy".components.setup.planned = lib.mkOverride 900 true;

83+ "deepseq".components.library.planned = lib.mkOverride 900 true;

84+ "filepath".components.library.planned = lib.mkOverride 900 true;

85+ "parsec".components.library.planned = lib.mkOverride 900 true;

86+ "directory".components.library.planned = lib.mkOverride 900 true;

87+ };

88+ })

62 ];

89 ];

63 }

90 }

materialized/ghc8101/happy/.plan.nix/happy.nix → materialized/bootstrap/ghc844/happy-1.19.12/.plan.nix/happy.nixrenamed+1−1

@@ -190,7 +190,7 @@

190 (hsPkgs."process" or (errorHandler.buildDepError "process"))

191 ];

192 build-tools = [

193− (hsPkgs.buildPackages.happy or (pkgs.buildPackages.happy or (errorHandler.buildToolDepError "happy")))

193+ (hsPkgs.buildPackages.happy.components.exes.happy or (pkgs.buildPackages.happy or (errorHandler.buildToolDepError "happy:happy")))

194 ];

195 buildable = true;

196 mainPath = [ "test.hs" ];

materialized/bootstrap/ghc844/happy-1.19.12/default.nixnew file+56

@@ -0,0 +1,56 @@

1+{

2+ pkgs = hackage:

3+ {

4+ packages = {

5+ "ghc-prim".revision = (((hackage."ghc-prim")."0.5.2.0").revisions).default;

6+ "array".revision = (((hackage."array")."0.5.2.0").revisions).default;

7+ "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

8+ "base".revision = (((hackage."base")."4.11.1.0").revisions).default;

9+ "rts".revision = (((hackage."rts")."1.0").revisions).default;

10+ "mtl".revision = (((hackage."mtl")."2.2.2").revisions).default;

11+ "containers".revision = (((hackage."containers")."0.5.11.0").revisions).default;

12+ "deepseq".revision = (((hackage."deepseq")."1.4.3.0").revisions).default;

13+ "transformers".revision = (((hackage."transformers")."0.5.5.0").revisions).default;

14+ };

15+ compiler = {

16+ version = "8.4.4";

17+ nix-name = "ghc844";

18+ packages = {

19+ "ghc-prim" = "0.5.2.0";

20+ "array" = "0.5.2.0";

21+ "integer-gmp" = "1.0.2.0";

22+ "base" = "4.11.1.0";

23+ "rts" = "1.0";

24+ "mtl" = "2.2.2";

25+ "containers" = "0.5.11.0";

26+ "deepseq" = "1.4.3.0";

27+ "transformers" = "0.5.5.0";

28+ };

29+ };

30+ };

31+ extras = hackage:

32+ { packages = { happy = ./.plan.nix/happy.nix; }; };

33+ modules = [

34+ ({ lib, ... }:

35+ {

36+ packages = {

37+ "happy" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

38+ };

39+ })

40+ ({ lib, ... }:

41+ {

42+ packages = {

43+ "containers".components.library.planned = lib.mkOverride 900 true;

44+ "ghc-prim".components.library.planned = lib.mkOverride 900 true;

45+ "happy".components.exes."happy".planned = lib.mkOverride 900 true;

46+ "transformers".components.library.planned = lib.mkOverride 900 true;

47+ "integer-gmp".components.library.planned = lib.mkOverride 900 true;

48+ "array".components.library.planned = lib.mkOverride 900 true;

49+ "base".components.library.planned = lib.mkOverride 900 true;

50+ "rts".components.library.planned = lib.mkOverride 900 true;

51+ "mtl".components.library.planned = lib.mkOverride 900 true;

52+ "deepseq".components.library.planned = lib.mkOverride 900 true;

53+ };

54+ })

55+ ];

56+ }

materialized/bootstrap/ghc844/hscolour/.plan.nix/hscolour.nix+1−1

@@ -24,7 +24,7 @@

24 isLocal = true;

25 detailLevel = "FullDetails";

26 licenseFiles = [ "LICENCE-LGPL" ];

27− dataDir = "";

27+ dataDir = ".";

28 dataFiles = [ "hscolour.css" "data/rgb24-example-.hscolour" ];

29 extraSrcFiles = [];

30 extraTmpFiles = [];

materialized/bootstrap/ghc844/hscolour/default.nix+22−8

@@ -3,24 +3,24 @@

3 {

4 packages = {

5 "ghc-prim".revision = (((hackage."ghc-prim")."0.5.2.0").revisions).default;

6− "rts".revision = (((hackage."rts")."1.0").revisions).default;

7− "deepseq".revision = (((hackage."deepseq")."1.4.3.0").revisions).default;

8− "containers".revision = (((hackage."containers")."0.5.11.0").revisions).default;

9− "base".revision = (((hackage."base")."4.11.1.0").revisions).default;

10 "array".revision = (((hackage."array")."0.5.2.0").revisions).default;

6 "array".revision = (((hackage."array")."0.5.2.0").revisions).default;

11 "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

7 "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

8+ "base".revision = (((hackage."base")."4.11.1.0").revisions).default;

9+ "rts".revision = (((hackage."rts")."1.0").revisions).default;

10+ "containers".revision = (((hackage."containers")."0.5.11.0").revisions).default;

11+ "deepseq".revision = (((hackage."deepseq")."1.4.3.0").revisions).default;

12 };

13 compiler = {

14 version = "8.4.4";

15 nix-name = "ghc844";

16 packages = {

17 "ghc-prim" = "0.5.2.0";

18− "rts" = "1.0";

19− "deepseq" = "1.4.3.0";

20− "containers" = "0.5.11.0";

21− "base" = "4.11.1.0";

22 "array" = "0.5.2.0";

18 "array" = "0.5.2.0";

23 "integer-gmp" = "1.0.2.0";

19 "integer-gmp" = "1.0.2.0";

20+ "base" = "4.11.1.0";

21+ "rts" = "1.0";

22+ "containers" = "0.5.11.0";

23+ "deepseq" = "1.4.3.0";

24 };

25 };

26 };

@@ -29,5 +29,19 @@

29 modules = [

30 ({ lib, ... }:

31 { packages = { "hscolour" = { flags = {}; }; }; })