dff62ec...iko/ghcjs-patch-master · haskell.nix

.buildkite/pipeline.yml+17−5

since splitsnapshots

unifiedsplit

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

1steps:

2− - label: 'Run tests with ghc884'

2+ - label: 'Run tests with ghc8107'

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

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 with ghc884'

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

18 command:

19− - nix-build build.nix -A maintainer-scripts.check-closure-size --argstr compiler-nix-name ghc884 -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:

@@ -36,5 +36,17 @@ steps:

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 ghc884 -o check-path-support.sh

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+22−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,9 +24,9 @@ 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)

13−- [Troubleshooting](https://input-output-hk.github.io/haskell.nix/troubleshooting/)

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

14- Explore the documentation from there to find further topics.

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

15

31

16## Help! Something isn't working

32## Help! Something isn't working

@@ -18,13 +34,13 @@ its dependencies into Nix code.

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

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

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

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

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

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

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

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

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

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

23

39

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

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

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

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

26

42

27−If you're still stuck, 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/), or open an issue.

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.

28

44

29## Related repos

45## Related repos

30

46

build.nix+28−12

@@ -5,9 +5,12 @@

5let

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

7in

8−{ nixpkgs ? haskellNix.sources.nixpkgs

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

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

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

13}:

16}:

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

17 buildHaskell = pkgs.buildPackages.haskell-nix;

20 buildHaskell = pkgs.buildPackages.haskell-nix;

18 tool = buildHaskell.tool;

21 tool = buildHaskell.tool;

19in rec {

22in rec {

20− tests = import ./test/default.nix { inherit pkgs ifdLevel compiler-nix-name; };

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

21

24

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

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

23− pkgs.recurseIntoAttrs {

26+ pkgs.recurseIntoAttrs ({

24− cabal-latest = tool compiler-nix-name "cabal" "latest";

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

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

29+ inherit evalPackages;

30+ version = {

31+ "ghc865" = "3.2.8";

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"]) {

25− hls-latest = tool compiler-nix-name "haskell-language-server" "latest";

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

26− hlint-latest = tool compiler-nix-name "hlint" (if compiler-nix-name == "ghc865" then "3.2.7" else "latest");

27− }

39+ })

28 );

40 );

29

41

30 # 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,7 +46,7 @@ in rec {

34 maintainer-scripts = pkgs.dontRecurseIntoAttrs {

46 maintainer-scripts = pkgs.dontRecurseIntoAttrs {

35 update-hackage = import ./scripts/update-hackage.nix {

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

36 inherit (pkgs) stdenv lib writeScript coreutils glibc git

48 inherit (pkgs) stdenv lib writeScript coreutils glibc git

37− openssh nix-prefetch-git gawk bash curl findutils;

49+ openssh nixFlakes gawk bash curl findutils;

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

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

39 nix-tools = haskell.internal-nix-tools;

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

40 cabal-install = haskell.internal-cabal-install;

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

@@ -42,7 +54,7 @@ in rec {

42 };

54 };

43 update-stackage = haskell.callPackage ./scripts/update-stackage.nix {

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

44 inherit (pkgs) stdenv lib writeScript coreutils glibc git

56 inherit (pkgs) stdenv lib writeScript coreutils glibc git

45− openssh nix-prefetch-git gawk bash curl findutils;

57+ openssh nixFlakes gawk bash curl findutils;

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

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

47 nix-tools = haskell.internal-nix-tools;

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

48 cabal-install = haskell.internal-cabal-install;

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

@@ -56,7 +68,7 @@ in rec {

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

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

57 # (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

58 # use)

70 # use)

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

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

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

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

61 # Includes cabal-install since this is commonly used.

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

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

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

@@ -65,13 +77,17 @@ in rec {

65 ];

77 ];

66 };

78 };

67 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 {};

68− check-path-support = pkgs.buildPackages.callPackage ./scripts/check-path-support.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+ };

69 };

85 };

70

86

71 # 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

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

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

73 maintainer-script-cache = pkgs.recurseIntoAttrs (

89 maintainer-script-cache = pkgs.recurseIntoAttrs (

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

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

75 inherit (maintainer-scripts) check-hydra;

91 inherit (maintainer-scripts) check-hydra;

76 })

92 })

77 // (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+157−40

@@ -1,4 +1,4 @@

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

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

2lib.makeOverridable (

3let self =

4{ componentId

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

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

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

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.

26

34

27, build-tools ? component.build-tools

35, build-tools ? component.build-tools

28, pkgconfig ? component.pkgconfig

36, pkgconfig ? component.pkgconfig

@@ -39,20 +47,22 @@ let self =

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

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

40 && !(stdenv.hostPlatform.isMusl && !stdenv.hostPlatform.isx86)

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

41, enableDeadCodeElimination ? component.enableDeadCodeElimination

49, enableDeadCodeElimination ? component.enableDeadCodeElimination

50+, writeHieFiles ? component.writeHieFiles

42

51

43, ghcOptions ? component.ghcOptions

52, ghcOptions ? component.ghcOptions

53+, contentAddressed ? component.contentAddressed

44

54

45# Options for Haddock generation

55# Options for Haddock generation

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

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

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

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

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

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

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

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

58# Coverage

68# Coverage

@@ -73,10 +83,16 @@ let self =

73

83

74# LLVM

84# LLVM

75, useLLVM ? ghc.useLLVM

85, useLLVM ? ghc.useLLVM

86+, smallAddressSpace ? false

76

87

77}@drvArgs:

88}@drvArgs:

78

89

79let

90let

91+ componentForSetup =

92+ if configureAllComponents

93+ then allComponent

94+ else component;

95+

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

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

81 enableDWARF = drvArgs.enableDWARF or false

97 enableDWARF = drvArgs.enableDWARF or false

82 && stdenv.hostPlatform.isLinux

98 && stdenv.hostPlatform.isLinux

@@ -84,8 +100,10 @@ let

84 && !stdenv.hostPlatform.isMusl

100 && !stdenv.hostPlatform.isMusl

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

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

86

102

87− ghc = if enableDWARF then defaults.ghc.dwarf else defaults.ghc;

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

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

88− setup = if enableDWARF then drvArgs.setup.dwarf else drvArgs.setup;

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

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

89

107

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

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

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

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

@@ -96,7 +114,7 @@ let

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

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

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

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

98 cleanSrc = haskellLib.rootAndSubDir (if canCleanSource

116 cleanSrc = haskellLib.rootAndSubDir (if canCleanSource

99− then haskellLib.cleanCabalComponent package component "${componentId.ctype}-${componentId.cname}" src

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

100 else

118 else

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

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

102 # from triggering a rebuild of this one.

120 # from triggering a rebuild of this one.

@@ -115,11 +133,12 @@ let

115

133

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

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

117

135

118− needsProfiling = enableExecutableProfiling || enableLibraryProfiling;

136+ needsProfiling = enableProfiling || enableLibraryProfiling;

119

137

120 configFiles = makeConfigFiles {

138 configFiles = makeConfigFiles {

139+ component = componentForSetup;

121 inherit (package) identifier;

140 inherit (package) identifier;

122− inherit component fullName flags needsProfiling enableDWARF;

141+ inherit fullName flags needsProfiling enableDWARF;

123 };

142 };

124

143

125 enableFeature = enable: feature:

144 enableFeature = enable: feature:

@@ -129,8 +148,21 @@ let

129

148

130 finalConfigureFlags = lib.concatStringsSep " " (

149 finalConfigureFlags = lib.concatStringsSep " " (

131 [ "--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"]

132− "${haskellLib.componentTarget componentId}"

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

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

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

134 ] ++ commonConfigureFlags);

166 ] ++ commonConfigureFlags);

135

167

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

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

@@ -148,7 +180,7 @@ let

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

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

149 ] ++

181 ] ++

150 # BINTOOLS

182 # BINTOOLS

151− (if stdenv.hostPlatform.isLinux

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

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

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

153 then [

185 then [

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

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

@@ -165,7 +197,7 @@ let

165 (disableFeature dontStrip "executable-stripping")

197 (disableFeature dontStrip "executable-stripping")

166 (disableFeature dontStrip "library-stripping")

198 (disableFeature dontStrip "library-stripping")

167 (enableFeature enableLibraryProfiling "library-profiling")

199 (enableFeature enableLibraryProfiling "library-profiling")

168− (enableFeature enableExecutableProfiling "executable-profiling")

200+ (enableFeature enableProfiling "profiling")

169 (enableFeature enableStatic "static")

201 (enableFeature enableStatic "static")

170 (enableFeature enableShared "shared")

202 (enableFeature enableShared "shared")

171 (enableFeature doCoverage "coverage")

203 (enableFeature doCoverage "coverage")

@@ -173,13 +205,13 @@ let

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

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

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

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

175 # 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

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

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

177 # component.

209 # component.

178 "--disable-executable-dynamic"

210 "--disable-executable-dynamic"

179 "--ghc-option=-optl=-pthread"

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

180 "--ghc-option=-optl=-static"

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

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

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

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

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

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

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

184 ++ lib.optionals haskellLib.isCrossHost (

216 ++ lib.optionals haskellLib.isCrossHost (

185 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"])

@@ -193,6 +225,14 @@ let

193 "--ghc-option=-fPIC" "--gcc-option=-fPIC"

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

194 ]

226 ]

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

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"

196 );

236 );

197

237

198 executableToolDepends =

238 executableToolDepends =

@@ -206,6 +246,7 @@ let

206 shellWrappers = ghcForComponent {

246 shellWrappers = ghcForComponent {

207 componentName = fullName;

247 componentName = fullName;

208 inherit configFiles enableDWARF;

248 inherit configFiles enableDWARF;

249+ inherit (component) plugins;

209 };

250 };

210

251

211 # 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

@@ -240,7 +281,7 @@ let

240 (lib.optionalString (cleanSrc.subDir != "") ''

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

241 cd ${lib.removePrefix "/" cleanSrc.subDir}

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

242 ''

283 ''

243− ) +

284+ ) +

244 (if cabalFile != null

285 (if cabalFile != null

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

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

246 else

287 else

@@ -276,7 +317,13 @@ let

276 componentDrv = drv;

317 componentDrv = drv;

277 };

318 };

278

319

320+ contentAddressedAttrs = lib.optionalAttrs contentAddressed {

321+ __contentAddressed = true;

322+ outputHashMode = "recursive";

323+ outputHashAlgo = "sha256";

324+ };

325+

279− drv = stdenv.mkDerivation (commonAttrs // {

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

280 pname = nameOnly;

327 pname = nameOnly;

281 inherit (package.identifier) version;

328 inherit (package.identifier) version;

282

329

@@ -309,16 +356,28 @@ let

309 description = package.synopsis or "";

356 description = package.synopsis or "";

310 license = haskellLib.cabalToNixpkgsLicense package.license;

357 license = haskellLib.cabalToNixpkgsLicense package.license;

311 platforms = if platforms == null then lib.platforms.all else platforms;

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;

312 };

367 };

313

368

314 propagatedBuildInputs =

369 propagatedBuildInputs =

315 frameworks # Frameworks will be needed at link time

370 frameworks # Frameworks will be needed at link time

316 # Not sure why pkgconfig needs to be propagatedBuildInputs but

371 # Not sure why pkgconfig needs to be propagatedBuildInputs but

317 # for gi-gtk-hs it seems to help.

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

318− ++ builtins.concatLists pkgconfig;

373+ ++ builtins.concatLists pkgconfig

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

375+ (lib.flatten component.libs

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

319

377

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

320− buildInputs = component.libs

379+ (lib.flatten component.libs

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

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

322

381

323 nativeBuildInputs =

382 nativeBuildInputs =

324 [shellWrappers buildPackages.removeReferencesTo]

383 [shellWrappers buildPackages.removeReferencesTo]

@@ -326,9 +385,10 @@ let

326

385

327 outputs = ["out" ]

386 outputs = ["out" ]

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

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

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

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

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

330

390

331− configurePhase =

391+ prePatch =

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

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

333 (lib.optionalString (stdenv.hostPlatform.isGhcjs) ''

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

334 export HOME=$(mktemp -d)

394 export HOME=$(mktemp -d)

@@ -340,7 +400,9 @@ let

340 cp -r . $source

400 cp -r . $source

341 cd $source

401 cd $source

342 chmod -R +w .

402 chmod -R +w .

343− '') + ''

403+ '') + commonAttrs.prePatch;

404+

405+ configurePhase = ''

344 runHook preConfigure

406 runHook preConfigure

345 echo Configure flags:

407 echo Configure flags:

346 printf "%q " ${finalConfigureFlags}

408 printf "%q " ${finalConfigureFlags}

@@ -349,12 +411,36 @@ let

349 runHook postConfigure

411 runHook postConfigure

350 '';

412 '';

351

413

352− 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 ''

353− runHook preBuild

430+ runHook preBuild

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

432+ runHook postBuild

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

434+ runHook preBuild

354− # 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

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

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

356− runHook postBuild

442+ runHook postBuild

357− '';

443+ '');

358

444

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

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

360 #

446 #

@@ -368,7 +454,11 @@ let

368 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";

369 in ''

455 in ''

370 runHook preInstall

456 runHook preInstall

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

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

458+ setupInstallFlags

459+ ++ lib.optional configureAllComponents

460+ (haskellLib.componentTarget componentId)

461+ )}

372 ${lib.optionalString (haskellLib.isLibrary componentId) ''

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

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

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

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

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

@@ -422,7 +512,7 @@ let

422 if [ -f ${testExecutable} ]; then

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

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

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

424 ${if stdenv.hostPlatform.isGhcjs then ''

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

425− 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}

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

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

427 '' else ''

517 '' else ''

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

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

@@ -430,7 +520,9 @@ let

430 fi

520 fi

431 '')

521 '')

432 # In case `setup copy` did not create this

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

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

523+ + (lib.optionalString enableSeparateDataOutput ''

524+ mkdir -p $data

525+ '')

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

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

435 echo "Symlink libffi and gmp .dlls ..."

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

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

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

@@ -438,14 +530,10 @@ let

438 done

530 done

439 ''

531 ''

440 # symlink all .dlls into the local directory.

532 # symlink all .dlls into the local directory.

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

442− # to symlink over dlls as needed.

443 + ''

533 + ''

444− echo "Symlink library dependencies..."

534+ for p in $pkgsHostTargetAsString; do

445− 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

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

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

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

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

448− fi

449 done

537 done

450 ''))

538 ''))

451 + (lib.optionalString doCoverage ''

539 + (lib.optionalString doCoverage ''

@@ -455,12 +543,41 @@ let

455 '')

543 '')

456 }

544 }

457 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.

458− '' + (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

459− 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

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

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

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

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

462 '');

569 '');

463

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+

464 shellHook = ''

581 shellHook = ''

465 export PATH="${shellWrappers}/bin:$PATH"

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

466 ${shellHookApplied}

583 ${shellHookApplied}

builder/default.nix+23−15

@@ -1,4 +1,4 @@

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

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.

@@ -17,8 +17,8 @@ let

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

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

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

20− inherit (buildPackages) stdenv;

20+ inherit (buildPackages) stdenv pkgconfig;

21− inherit buildPackages pkgconfig;

21+ inherit buildPackages;

22 inherit haskellLib nonReinstallablePkgs makeSetupConfigFiles;

23 };

24

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

26 # component builder and for nix-shells.

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

28 inherit lib ghc haskellLib;

29− inherit (buildPackages) stdenv runCommand makeWrapper;

29+ inherit (buildPackages) stdenv;

30+ inherit (buildPackages.buildPackages) runCommand makeWrapper;

30− inherit (buildPackages.xorg) lndir;

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

31 };

32 };

32

33

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

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

@@ -44,22 +45,29 @@ let

44

45

45 hoogleLocal = let

46 hoogleLocal = let

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

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

47− in { packages ? [], hoogle ? pkgs.buildPackages.haskell-nix.tool compiler.nix-name "hoogle" {

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

49+ inherit evalPackages;

48− version = "5.0.17.15";

50+ version = "5.0.18.3";

49 index-state = pkgs.haskell-nix.internalHackageIndexState;

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

50 }

52 }

51 }:

53 }:

52− haskellLib.weakCallPackage pkgs nixpkgsHoogle {

54+ let

55+ haskellPackages = {

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

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

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

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

55− then ghc.buildGHC

58+ then ghc.buildGHC

56− else ghc;

59+ else ghc;

57− inherit packages hoogle;

60+ inherit packages hoogle;

58− };

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;

59

67

60 # Same as haskellPackages.shellFor in nixpkgs.

68 # Same as haskellPackages.shellFor in nixpkgs.

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

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

62− inherit hsPkgs ghcForComponent makeConfigFiles hoogleLocal haskellLib buildPackages compiler;

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

63 inherit (buildPackages) glibcLocales;

71 inherit (buildPackages) glibcLocales;

64 };

72 };

65

73

builder/ghc-for-component-wrapper.nix+61−12

@@ -13,6 +13,7 @@

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

14, postInstall ? ""

15, enableDWARF

16+, plugins

16}:

17}:

17

18

18let

19let

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

37 ''

38 ''

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

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

39

40

41+ ''

40− # Start with a ghc...

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

43+ + ''

41 mkdir -p $out/bin

44 mkdir -p $out/bin

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

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

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

44 rm -rf ${libDir}/*/

46 rm -rf ${libDir}/*/

47+ ''

45− # ... 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+ + ''

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

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

51+ ''

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

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

53+ + ''

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

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

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

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

50 fi

56 fi

57+ ''

51− # ... and node modules ...

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

59+ + ''

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

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

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

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

54 fi

62 fi

63+ ''

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

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

65+ + ''

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

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

57

67

58− # Wrap compiler executables with correct env variables.

68+ ''

59− # 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"

60

100

101+ ''

102+ # Wrap compiler executables with correct env variables.

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

104+ + ''

61 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

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

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

63 rm -f $out/bin/$prg

107 rm -f $out/bin/$prg

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

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

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

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

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

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

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

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

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

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

70 fi

115 fi

71 done

116 done

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

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

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

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

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

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

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

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

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

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

82 fi

128 fi

83 done

129 done

84

130

131+ ''

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

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

133+ + ''

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

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

87 rm -f $out/bin/haddock

135 rm -f $out/bin/haddock

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

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

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

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

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

91 fi

139 fi

92

140

141+ ''

93− # 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

94− # --global-package-db flag.

143+ # --global-package-db flag.

95−

144+ + ''

96 for prg in ${ghcCommand}-pkg ${ghcCommand}-pkg-${ghc.version}; do

145 for prg in ${ghcCommand}-pkg ${ghcCommand}-pkg-${ghc.version}; do

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

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

98 rm -f $out/bin/$prg

147 rm -f $out/bin/$prg

builder/haddock-builder.nix+2

@@ -41,6 +41,7 @@ let

41 inherit (package) identifier;

42 inherit component fullName flags needsProfiling;

43 chooseDrv = p: p.haddock;

44+ inherit (componentDrv) enableDWARF;

44 };

45 };

45

46

46 finalConfigureFlags = lib.concatStringsSep " " (

47 finalConfigureFlags = lib.concatStringsSep " " (

@@ -55,6 +56,7 @@ let

55 componentName = fullName;

56 componentName = fullName;

56 configFiles = docsConfigFiles;

57 configFiles = docsConfigFiles;

57 inherit (componentDrv) enableDWARF;

58 inherit (componentDrv) enableDWARF;

59+ inherit (component) plugins;

58 };

60 };

59

61

60 drv = stdenv.mkDerivation (commonAttrs // {

62 drv = stdenv.mkDerivation (commonAttrs // {

builder/hspkg-builder.nix+38−25

@@ -23,38 +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

35− main = defaultMain

36− '';

37

41

38− # Get the Cabal lib used to build `cabal-install`.

42+ # This is the `Cabal` library that was built for `cabal-install` to use.

39− # To avoid infinite recursion we have to leave this out for packages

43+ # It makes sense to use this version (when possible) because it will match the behavior of

40− # needed to build `cabal-install`.

44+ # building with `cabal-install` (including fixes that may not be in the

41− # We always do this for ghcjs as the patched version of Cabal is needed.

45+ # version of Cabal bundled with GHC).

42− cabalLibDepends = lib.optional (

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

43− stdenv.hostPlatform.isGhcjs || (

52+ stdenv.buildPlatform != stdenv.hostPlatform

44− builtins.elem compiler-nix-name["ghc865" "ghc884"]

53+ ||

45− &&

54+ # These are the dependencies of `Cabal`

46 !builtins.elem package.identifier.name

55 !builtins.elem package.identifier.name

47 ["nix-tools" "alex" "happy" "hscolour" "Cabal" "bytestring" "aeson" "time"

56 ["nix-tools" "alex" "happy" "hscolour" "Cabal" "bytestring" "aeson" "time"

48 "filepath" "base-compat-batteries" "base-compat" "unix" "directory" "transformers"

57 "filepath" "base-compat-batteries" "base-compat" "unix" "directory" "transformers"

49− "containers" "binary" "mtl" "text" "process" "parsec"]

58+ "containers" "binary" "mtl" "text" "process" "parsec"];

50− )

51− )

52− buildPackages.haskell-nix.cabal-install-unchecked.${compiler-nix-name}.project.hsPkgs.Cabal.components.library;

53

59

54− defaultSetup = setup-builder {

60+ defaultSetup = setup-builder ({

55 name = "${ghc.targetPrefix}default-Setup";

61 name = "${ghc.targetPrefix}default-Setup";

56 component = {

62 component = {

57− depends = config.setup-depends ++ cabalLibDepends;

63+ depends = config.setup-depends ++ lib.optional useCabalFromCabalInstall cabalFromCabalInstall;

58 libs = [];

64 libs = [];

59 frameworks = [];

65 frameworks = [];

60 doExactConfig = false;

66 doExactConfig = false;

@@ -82,12 +88,19 @@ let

82 synopsis = null;

88 synopsis = null;

83 license = "MIT";

89 license = "MIT";

84 };

90 };

91+ src = null;

85− src = null; cleanSrc = buildPackages.runCommand "default-Setup-src" {} ''

92+ cleanSrc = buildPackages.runCommand "default-Setup-src" {} ''

86 mkdir $out

93 mkdir $out

87 cat ${defaultSetupSrc} > $out/Setup.hs

94 cat ${defaultSetupSrc} > $out/Setup.hs

88 '';

95 '';

89 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 = [];

90− };

103+ });

91

104

92 # buildPackages.runCommand "default-Setup" { nativeBuildInputs = [(ghc.passthru.buildGHC or ghc)]; } ''

105 # buildPackages.runCommand "default-Setup" { nativeBuildInputs = [(ghc.passthru.buildGHC or ghc)]; } ''

93 # cat ${defaultSetupSrc} > Setup.hs

106 # cat ${defaultSetupSrc} > Setup.hs

@@ -107,18 +120,18 @@ let

107 inherit (pkg) preUnpack postUnpack;

120 inherit (pkg) preUnpack postUnpack;

108 };

121 };

109

122

110− buildComp = componentId: component: comp-builder {

123+ buildComp = allComponent: componentId: component: comp-builder {

111− 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

112 shellHook

125 shellHook

113 ;

126 ;

114 };

127 };

115

128

116in rec {

129in rec {

117− components = haskellLib.applyComponents buildComp pkg;

130+ components = haskellLib.applyComponents (buildComp pkg.allComponent) pkg;

118 checks = pkgs.recurseIntoAttrs (builtins.mapAttrs

131 checks = pkgs.recurseIntoAttrs (builtins.mapAttrs

119 (_: d: haskellLib.check d)

132 (_: d: haskellLib.check d)

120 (lib.filterAttrs (_: d: d.config.doCheck) components.tests));

133 (lib.filterAttrs (_: d: d.config.doCheck) components.tests));

121− inherit (package) identifier detailLevel isLocal isProject;

134+ inherit (package) identifier detailLevel isLocal isProject buildType;

122 inherit setup cabalFile;

135 inherit setup cabalFile;

123 isHaskell = true;

136 isHaskell = true;

124 inherit src;

137 inherit src;

builder/make-config-files.nix+16−7

@@ -1,8 +1,12 @@

1{ stdenv, lib, haskellLib, ghc, nonReinstallablePkgs, runCommand, writeText, writeScript }@defaults:

2

3−{ identifier, component, fullName, flags ? {}, needsProfiling ? false, enableDWARF ? false, chooseDrv ? drv: drv }:

3+{ identifier, component, fullName, flags ? {}, needsProfiling ? false, enableDWARF ? false, chooseDrv ? drv: drv, nonReinstallablePkgs ? defaults.nonReinstallablePkgs }:

4

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+

6 ghc = if enableDWARF then defaults.ghc.dwarf else defaults.ghc;

10 ghc = if enableDWARF then defaults.ghc.dwarf else defaults.ghc;

7

11

8 flagsAndConfig = field: xs: lib.optionalString (xs != []) ''

12 flagsAndConfig = field: xs: lib.optionalString (xs != []) ''

@@ -81,15 +85,20 @@ let

81 ${target-pkg} init $out/${packageCfgDir}

85 ${target-pkg} init $out/${packageCfgDir}

82

86

83 ${lib.concatStringsSep "\n" (lib.mapAttrsToList flagsAndConfig {

87 ${lib.concatStringsSep "\n" (lib.mapAttrsToList flagsAndConfig {

84− "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));

85− "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)

86− "extra-framework-dirs" = map (p: "${p}/Library/Frameworks") component.frameworks;

95+ (map (p: "${p}/Library/Frameworks") component.frameworks);

87 })}

96 })}

88

97

89 ghc=${ghc}

98 ghc=${ghc}

90 ${ # Copy over the nonReinstallablePkgs from the global package db.

99 ${ # Copy over the nonReinstallablePkgs from the global package db.

91 ''

100 ''

92− for p in ${lib.concatStringsSep " " nonReinstallablePkgs}; do

101+ for p in ${lib.concatStringsSep " " nonReinstallablePkgs'}; do

93 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} \;

94 done

103 done

95 ''}

104 ''}

@@ -148,13 +157,13 @@ let

148 cat $p/exactDep/cabal.config >> $out/cabal.config

157 cat $p/exactDep/cabal.config >> $out/cabal.config

149 ''}

158 ''}

150 done

159 done

151− for p in ${lib.concatStringsSep " " (lib.remove "ghc" nonReinstallablePkgs)}; do

160+ for p in ${lib.concatStringsSep " " (lib.remove "ghc" nonReinstallablePkgs')}; do

152 if [ -e $ghc/envDeps/$p ]; then

161 if [ -e $ghc/envDeps/$p ]; then

153 cat $ghc/envDeps/$p >> $out/ghc-environment

162 cat $ghc/envDeps/$p >> $out/ghc-environment

154 fi

163 fi

155 done

164 done

156 '' + lib.optionalString component.doExactConfig ''

165 '' + lib.optionalString component.doExactConfig ''

157− for p in ${lib.concatStringsSep " " nonReinstallablePkgs}; do

166+ for p in ${lib.concatStringsSep " " nonReinstallablePkgs'}; do

158 if [ -e $ghc/exactDeps/$p ]; then

167 if [ -e $ghc/exactDeps/$p ]; then

159 cat $ghc/exactDeps/$p/configure-flags >> $out/configure-flags

168 cat $ghc/exactDeps/$p/configure-flags >> $out/configure-flags

160 cat $ghc/exactDeps/$p/cabal.config >> $out/cabal.config

169 cat $ghc/exactDeps/$p/cabal.config >> $out/cabal.config

builder/setup-builder.nix+11−6

@@ -1,4 +1,4 @@

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

1+{ pkgs, stdenv, lib, buildPackages, haskellLib, ghc, nonReinstallablePkgs, hsPkgs, makeSetupConfigFiles, pkgconfig }@defaults:

2

3let self =

4{ component, package, name, src, enableDWARF ? false, flags ? {}, revision ? null, patches ? [], defaultSetupSrc

@@ -7,9 +7,14 @@ let self =

7, preBuild ? component.preBuild , postBuild ? component.postBuild

8, preInstall ? component.preInstall , postInstall ? component.postInstall

9, cleanSrc ? haskellLib.cleanCabalComponent package component "setup" src

10+, nonReinstallablePkgs ? defaults.nonReinstallablePkgs

11+, smallAddressSpace ? false

10}@drvArgs:

12}@drvArgs:

11

13

12let

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+

13 cleanSrc' = haskellLib.rootAndSubDir cleanSrc;

18 cleanSrc' = haskellLib.rootAndSubDir cleanSrc;

14

19

15 fullName = "${name}-setup";

20 fullName = "${name}-setup";

@@ -18,7 +23,7 @@ let

18

23

19 configFiles = makeSetupConfigFiles {

24 configFiles = makeSetupConfigFiles {

20 inherit (package) identifier;

25 inherit (package) identifier;

21− inherit fullName flags component enableDWARF;

26+ inherit fullName flags component enableDWARF nonReinstallablePkgs;

22 };

27 };

23 hooks = haskellLib.optionalHooks {

28 hooks = haskellLib.optionalHooks {

24 inherit

29 inherit

@@ -52,6 +57,7 @@ let

52 cleanSrc = cleanSrc';

57 cleanSrc = cleanSrc';

53 inherit configFiles;

58 inherit configFiles;

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

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

60+ smallAddressSpace = self (drvArgs // { smallAddressSpace = true; });

55 };

61 };

56

62

57 meta = {

63 meta = {

@@ -70,13 +76,12 @@ let

70 for f in Setup.hs Setup.lhs; do

76 for f in Setup.hs Setup.lhs; do

71 if [ -f $f ]; then

77 if [ -f $f ]; then

72 echo Compiling package $f

78 echo Compiling package $f

73− ghc $f -threaded '' + (if includeGhcPackage then "-package ghc " else "")

79+ ghc $f -threaded ${if includeGhcPackage then "-package ghc " else ""

74− + ''-package-db ${configFiles}/${configFiles.packageCfgDir} --make -o ./Setup

80+ }-package-db ${configFiles}/${configFiles.packageCfgDir} --make -o ./Setup

75− setup=$(pwd)/Setup

76 fi

81 fi

77 done

82 done

78 [ -f ./Setup ] || (echo Failed to build Setup && exit 1)

83 [ -f ./Setup ] || (echo Failed to build Setup && exit 1)

79− runHook preBuild

84+ runHook postBuild

80 '';

85 '';

81

86

82 installPhase = ''

87 installPhase = ''

builder/shell-for.nix+63−36

@@ -1,4 +1,4 @@

1−{ lib, stdenv, mkShell, glibcLocales, pkgconfig, ghcForComponent, makeConfigFiles, hsPkgs, hoogleLocal, haskellLib, buildPackages, compiler }:

1+{ lib, stdenv, mkShell, glibcLocales, pkgconfig, ghcForComponent, makeConfigFiles, hsPkgs, hoogleLocal, haskellLib, buildPackages, evalPackages, compiler }:

2

3{ # `packages` function selects packages that will be worked on in the shell itself.

4 # These packages will not be built by `shellFor`, but their

@@ -9,10 +9,11 @@

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 hsPkgs)

12+, components ? ps: lib.concatMap haskellLib.getAllComponents (packages ps)

13 # Additional packages to be added unconditionally

14, additional ? _: []

15, withHoogle ? true

16+, withHaddock ? withHoogle

16, exactDeps ? false

17, exactDeps ? false

17, tools ? {}

18, tools ? {}

18, packageSetupDeps ? true

19, packageSetupDeps ? true

@@ -25,51 +26,69 @@ let

25

26

26 selectedPackages = packages hsPkgs;

27 selectedPackages = packages hsPkgs;

27 additionalPackages = additional hsPkgs;

28 additionalPackages = additional hsPkgs;

28− selectedComponents = components hsPkgs;

29+ directlySelectedComponents = components hsPkgs;

29

30

30− # The configs of all the selected components

31− selectedConfigs = map (c: c.config) selectedComponents

32− ++ lib.optionals packageSetupDeps (map (p: p.setup.config) selectedPackages);

33−

34− name = if lib.length selectedPackages == 1

35− then "ghc-shell-for-${(lib.head selectedPackages).identifier.name}"

36− else "ghc-shell-for-packages";

37−

38− # Given a `packages = [ a b ]` we construct a shell with the dependencies of `a` and `b`.

31+ # Given `directlySelectedComponents = [ a b ]`, we construct a shell that includes all of their dependencies

39 #

32 #

40− # But if `a` depends on `b`, we don't want to include `b`, because

33+ # But we want to exclude `a` if it is a transitive dependecy of `b`

34+ # because:

41 # - cabal will end up ignoring that built version;

35 # - cabal will end up ignoring that built version;

42 # - The user has indicated that's what they're working on, so they probably don't want to have to build

36 # - The user has indicated that's what they're working on, so they probably don't want to have to build

43 # it first (and it will change often).

37 # it first (and it will change often).

44− # Generally we never want to include any of (the components of) the selected packages as dependencies.

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− # We have to do this slightly differently because we will be looking at the actual components rather

51− # than the packages.

52

50

53− # Given a list of packages, removes those which were selected as part of the shell.

54− # We do this on the basis of their identifiers being the same, not direct equality (why?).

55− removeSelectedPackages =

56− # All the identifiers of the selected packages

57− let selectedPackageIds = map (p: p.identifier) selectedPackages;

58− in lib.filter (input: !(builtins.elem (input.identifier or null) selectedPackageIds));

59

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+

60− # Given a list of derivations, removes those which are components of packages which were selected as part of the shell.

70+ # Given a list of `depends`, removes those which are selected components

61 removeSelectedInputs =

71 removeSelectedInputs =

62− # All the components of the selected packages: we shouldn't add any of these as dependencies

72+ lib.filter (input: !(isSelectedComponent input));

63− let selectedPackageComponents = map (x: x.name) (lib.concatMap haskellLib.getAllComponents selectedPackages);

73+

64− in lib.filter (input: !(builtins.elem input.name selectedPackageComponents));

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+

81+ name = if lib.length selectedPackages == 1

82+ then "ghc-shell-for-${(lib.head selectedPackages).identifier.name}"

83+ else "ghc-shell-for-packages";

65

84

66− # We need to remove any dependencies which are selected packages (see above).

85+ # We need to remove any dependencies which would bring in selected components (see above).

67− # `depends` contains packages so we use 'removeSelectedPackages`.

68− packageInputs = removeSelectedPackages (lib.concatMap (cfg: cfg.depends) selectedConfigs) ++ additionalPackages;

86+ packageInputs = removeSelectedInputs (lib.concatMap (cfg: cfg.depends) selectedConfigs)

87+ ++ additionalPackages;

69

88

70 # Add the system libraries and build tools of the selected haskell packages to the shell.

89 # Add the system libraries and build tools of the selected haskell packages to the shell.

71 # We need to remove any inputs which are selected components (see above).

90 # We need to remove any inputs which are selected components (see above).

72− # `buildInputs`, `propagatedBuildInputs`, and `executableToolDepends` contain component

91+ # `buildInputs`, `propagatedBuildInputs`, and `executableToolDepends` contain component

73 # derivations, not packages, so we use `removeSelectedInputs`).

92 # derivations, not packages, so we use `removeSelectedInputs`).

74 systemInputs = removeSelectedInputs (lib.concatMap

93 systemInputs = removeSelectedInputs (lib.concatMap

75 (c: c.buildInputs ++ c.propagatedBuildInputs) selectedComponents);

94 (c: c.buildInputs ++ c.propagatedBuildInputs) selectedComponents);

@@ -80,13 +99,15 @@ let

80 component = {

99 component = {

81 depends = packageInputs;

100 depends = packageInputs;

82 libs = [];

101 libs = [];

102+ pkgconfig = [];

83 frameworks = [];

103 frameworks = [];

84 doExactConfig = false;

104 doExactConfig = false;

85 };

105 };

86 configFiles = makeConfigFiles {

106 configFiles = makeConfigFiles {

87 fullName = args.name or name;

107 fullName = args.name or name;

88 identifier.name = name;

108 identifier.name = name;

89− inherit component;

109+ inherit component enableDWARF;

110+ chooseDrv = p: if withHaddock && p ? haddock then p.haddock else p;

90 };

111 };

91 ghcEnv = ghcForComponent {

112 ghcEnv = ghcForComponent {

92 inherit configFiles;

113 inherit configFiles;

@@ -95,6 +116,7 @@ let

95 ln -s ${hoogleIndex}/bin/hoogle $out/bin

116 ln -s ${hoogleIndex}/bin/hoogle $out/bin

96 '';

117 '';

97 inherit enableDWARF;

118 inherit enableDWARF;

119+ plugins = [];

98 };

120 };

99

121

100 hoogleIndex = let

122 hoogleIndex = let

@@ -111,11 +133,16 @@ let

111 # inherit (hsPkgs) hoogle;

133 # inherit (hsPkgs) hoogle;

112 } // (

134 } // (

113 lib.optionalAttrs (args ? tools && args.tools ? hoogle) {

135 lib.optionalAttrs (args ? tools && args.tools ? hoogle) {

114− hoogle = buildPackages.haskell-nix.tool compiler.nix-name "hoogle" 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+ }]);

115 }

142 }

116 ));

143 ));

117

144

118− mkDrvArgs = builtins.removeAttrs args ["packages" "additional" "withHoogle" "tools"];

145+ mkDrvArgs = builtins.removeAttrs args ["packages" "components" "additional" "withHoogle" "tools"];

119in

146in

120 mkShell (mkDrvArgs // {

147 mkShell (mkDrvArgs // {

121 name = mkDrvArgs.name or name;

148 name = mkDrvArgs.name or name;

@@ -125,13 +152,15 @@ in

125 nativeBuildInputs = [ ghcEnv ]

152 nativeBuildInputs = [ ghcEnv ]

126 ++ nativeBuildInputs

153 ++ nativeBuildInputs

127 ++ mkDrvArgs.nativeBuildInputs or []

154 ++ mkDrvArgs.nativeBuildInputs or []

128− ++ lib.attrValues (buildPackages.haskell-nix.tools compiler.nix-name tools)

155+ ++ lib.attrValues (buildPackages.haskell-nix.tools' evalPackages compiler.nix-name tools)

129 # If this shell is a cross compilation shell include

156 # If this shell is a cross compilation shell include

130 # wrapper script for running cabal build with appropriate args.

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.

131 ++ lib.optional (ghcEnv.targetPrefix != "") (

159 ++ lib.optional (ghcEnv.targetPrefix != "") (

132 buildPackages.writeShellScriptBin "${ghcEnv.targetPrefix}cabal" ''

160 buildPackages.writeShellScriptBin "${ghcEnv.targetPrefix}cabal" ''

133 exec cabal \

161 exec cabal \

134 --with-ghc=${ghcEnv.targetPrefix}ghc \

162 --with-ghc=${ghcEnv.targetPrefix}ghc \

163+ --with-compiler=${ghcEnv.targetPrefix}ghc \

135 --with-ghc-pkg=${ghcEnv.targetPrefix}ghc-pkg \

164 --with-ghc-pkg=${ghcEnv.targetPrefix}ghc-pkg \

136 --with-hsc2hs=${ghcEnv.targetPrefix}hsc2hs \

165 --with-hsc2hs=${ghcEnv.targetPrefix}hsc2hs \

137 ${lib.optionalString (ghcEnv.targetPrefix == "js-unknown-ghcjs-") ''

166 ${lib.optionalString (ghcEnv.targetPrefix == "js-unknown-ghcjs-") ''

@@ -146,8 +175,6 @@ in

146 echo "${"Shell for " + toString (builtins.map (p : p.identifier.name) selectedPackages)}"

175 echo "${"Shell for " + toString (builtins.map (p : p.identifier.name) selectedPackages)}"

147 echo $nativeBuildInputs $buildInputs > $out

176 echo $nativeBuildInputs $buildInputs > $out

148 '';

177 '';

149− LANG = "en_US.UTF-8";

150− LOCALE_ARCHIVE = lib.optionalString (stdenv.hostPlatform.libc == "glibc") "${glibcLocales}/lib/locale/locale-archive";

151

178

152 # 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

153 # the correct global package DB.

180 # the correct global package DB.

changelog.md+57

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

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+

4## Feb 22, 2021

61## Feb 22, 2021

5* Add `.dwarf` to build any component with DWARF dubug info on linux

62* Add `.dwarf` to build any component with DWARF dubug info on linux

6 (ghc >=8.10.2).

63 (ghc >=8.10.2).

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 ./nix/sources.nix).nixpkgs {};

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+53−40

@@ -4,17 +4,24 @@

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 = {

12− "R2003" = "nixpkgs-2003";

13+ "R2111" = "nixpkgs-2111";

13− "R2009" = "nixpkgs-2009";

14+ "R2205" = "nixpkgs-2205";

14 "unstable" = "nixpkgs-unstable";

15 "unstable" = "nixpkgs-unstable";

15 };

16 };

17+ haskellNix = import ./default.nix { inherit checkMaterialization; };

18+ nixpkgsArgs = haskellNix.nixpkgsArgs // {

19+ # Needed for dwarf tests

20+ config = haskellNix.nixpkgsArgs.config // {

21+ permittedInsecurePackages = ["libdwarf-20210528" "libdwarf-20181024" "dwarfdump-20181024"];

22+ };

23+ };

16 compilerNixNames = nixpkgsName: nixpkgs: builtins.mapAttrs (compiler-nix-name: runTests: {

24 compilerNixNames = nixpkgsName: nixpkgs: builtins.mapAttrs (compiler-nix-name: runTests: {

17− inherit (import ./default.nix { inherit checkMaterialization; }) nixpkgsArgs;

18 inherit runTests;

25 inherit runTests;

19 }) (

26 }) (

20 # GHC version to cache and whether to run the tests against them.

27 # GHC version to cache and whether to run the tests against them.

@@ -23,53 +30,59 @@

23 # cabal-install and nix-tools plans. When removing a ghc version

30 # cabal-install and nix-tools plans. When removing a ghc version

24 # from here (so that is no longer cached) also remove ./materialized/ghcXXX.

31 # from here (so that is no longer cached) also remove ./materialized/ghcXXX.

25 # Update supported-ghc-versions.md to reflect any changes made here.

32 # Update supported-ghc-versions.md to reflect any changes made here.

26− {

33+ nixpkgs.lib.optionalAttrs (nixpkgsName == "R2111") {

27− ghc865 = true;

34+ ghc865 = false;

28− ghc884 = false; # Just included because the native version is needed at eval time

35+ ghc8107 = true;

29− } // nixpkgs.lib.optionalAttrs (nixpkgsName == "R2009") {

36+ } // nixpkgs.lib.optionalAttrs (nixpkgsName == "R2205") {

30− ghc884 = true;

37+ ghc865 = false;

31− ghc8104 = true;

38+ ghc8107 = true;

32 } // nixpkgs.lib.optionalAttrs (nixpkgsName == "unstable") {

39 } // nixpkgs.lib.optionalAttrs (nixpkgsName == "unstable") {

33− ghc884 = true;

40+ ghc865 = false;

34− ghc8104 = true;

41+ ghc884 = false; # Native version is used to boot 9.0.1

35− ghc810420210212 = false;

42+ ghc8107 = true;

43+ ghc902 = true;

44+ ghc924 = true;

36 });

45 });

37− systems = nixpkgs: nixpkgs.lib.filterAttrs (_: v: builtins.elem v supportedSystems) {

46+ systems = nixpkgsName: nixpkgs: compiler-nix-name: nixpkgs.lib.genAttrs (

38− # I wanted to take these from 'lib.systems.examples', but apparently there isn't one for linux!

47+ nixpkgs.lib.filter (v:

39− linux = "x86_64-linux";

48+ # We have less x86_64-darwin build capacity so build fewer GhC versions

40− darwin = "x86_64-darwin";

49+ (v != "x86_64-darwin" || (

41− };

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);

42 crossSystems = nixpkgsName: nixpkgs: compiler-nix-name: system:

60 crossSystems = nixpkgsName: nixpkgs: compiler-nix-name: system:

43 # 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

44 # of 'lib.systems.examples' are not understood between all versions

62 # of 'lib.systems.examples' are not understood between all versions

45 let lib = nixpkgs.lib;

63 let lib = nixpkgs.lib;

46− in lib.optionalAttrs (nixpkgsName == "unstable" && (__elem compiler-nix-name ["ghc865" "ghc884"])) {

64+ in lib.optionalAttrs (nixpkgsName == "unstable"

65+ && ((system == "x86_64-linux" && __elem compiler-nix-name ["ghc865" "ghc884" "ghc8107"])

66+ || (system == "x86_64-darwin" && __elem compiler-nix-name ["ghc8107"]))) {

47 inherit (lib.systems.examples) ghcjs;

67 inherit (lib.systems.examples) ghcjs;

48− } // lib.optionalAttrs (system == "x86_64-linux" && (

68+ } // lib.optionalAttrs (nixpkgsName == "unstable"

49− (nixpkgsName == "R2009" && __elem compiler-nix-name ["ghc8101" "ghc8102" "ghc8103" "ghc8104" "ghc810420210212"])

69+ && ((system == "x86_64-linux" && __elem compiler-nix-name ["ghc8107" "ghc902" "ghc924"])

50− || (nixpkgsName == "R2003" && __elem compiler-nix-name ["ghc865"]))) {

70+ || (system == "x86_64-darwin" && __elem compiler-nix-name []))) { # TODO add ghc versions when we have more darwin build capacity

51− # Windows cross compilation is currently broken on macOS

52 inherit (lib.systems.examples) mingwW64;

71 inherit (lib.systems.examples) mingwW64;

53− } // lib.optionalAttrs (system == "x86_64-linux"

72+ } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && __elem compiler-nix-name ["ghc8107" "ghc902" "ghc922" "ghc923" "ghc924"]) {

54− && !(nixpkgsName == "R2003" && compiler-nix-name == "ghc884")) {

55 # Musl cross only works on linux

73 # Musl cross only works on linux

56 # aarch64 cross only works on linux

74 # aarch64 cross only works on linux

57− # We also skip these for the R2003 was build of ghc884 (we only need the

58− # native so ifdLevel 1 includes compiler needed in ifdLevel2 eval)

59 inherit (lib.systems.examples) musl64 aarch64-multiplatform;

75 inherit (lib.systems.examples) musl64 aarch64-multiplatform;

60 };

76 };

61− isDisabled = d:

62− let meta = d.meta or {};

63− in meta.disabled or false;

77+ isDisabled = d: d.meta.disabled or false;

64in

78in

65dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:

79dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:

66 let pinnedNixpkgsSrc = sources.${nixpkgs-pin};

80 let pinnedNixpkgsSrc = sources.${nixpkgs-pin};

67− # We need this for generic nixpkgs stuff at the right version

68− genericPkgs = import pinnedNixpkgsSrc {};

81+ evalPackages = import pinnedNixpkgsSrc nixpkgsArgs;

69− in dimension "GHC version" (compilerNixNames nixpkgsName genericPkgs) (compiler-nix-name: {nixpkgsArgs, runTests}:

82+ in dimension "GHC version" (compilerNixNames nixpkgsName evalPackages) (compiler-nix-name: {runTests}:

70− dimension "System" (systems genericPkgs) (systemName: system:

83+ dimension "System" (systems nixpkgsName evalPackages compiler-nix-name) (systemName: system:

71 let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system; });

84 let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system; });

72− build = import ./build.nix { inherit pkgs ifdLevel compiler-nix-name; };

85+ build = import ./build.nix { inherit pkgs evalPackages ifdLevel compiler-nix-name; };

73 platformFilter = platformFilterGeneric pkgs system;

86 platformFilter = platformFilterGeneric pkgs system;

74 in filterAttrsOnlyRecursive (_: v: platformFilter v && !(isDisabled v)) ({

87 in filterAttrsOnlyRecursive (_: v: platformFilter v && !(isDisabled v)) ({

75 # Native builds

88 # Native builds

@@ -82,14 +95,14 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:

82 } // pkgs.lib.optionalAttrs (ifdLevel >= 1) {

95 } // pkgs.lib.optionalAttrs (ifdLevel >= 1) {

83 iserv-proxy = pkgs.ghc-extra-projects."${compiler-nix-name}".getComponent "iserv-proxy:exe:iserv-proxy";

96 iserv-proxy = pkgs.ghc-extra-projects."${compiler-nix-name}".getComponent "iserv-proxy:exe:iserv-proxy";

84 } // pkgs.lib.optionalAttrs (ifdLevel >= 3) {

97 } // pkgs.lib.optionalAttrs (ifdLevel >= 3) {

85− hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; inherit compiler-nix-name; }).getComponent "exe:hello";

98+ hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; inherit evalPackages compiler-nix-name; }).getComponent "exe:hello";

86 });

99 });

87 }

100 }

88 //

101 //

89− dimension "Cross system" (crossSystems nixpkgsName genericPkgs compiler-nix-name system) (crossSystemName: crossSystem:

102+ dimension "Cross system" (crossSystems nixpkgsName evalPackages compiler-nix-name system) (crossSystemName: crossSystem:

90 # Cross builds

103 # Cross builds

91 let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system crossSystem; });

104 let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system crossSystem; });

92− build = import ./build.nix { inherit pkgs ifdLevel compiler-nix-name; };

105+ build = import ./build.nix { inherit pkgs evalPackages ifdLevel compiler-nix-name; };

93 in pkgs.recurseIntoAttrs (pkgs.lib.optionalAttrs (ifdLevel >= 1) ({

106 in pkgs.recurseIntoAttrs (pkgs.lib.optionalAttrs (ifdLevel >= 1) ({

94 roots = pkgs.haskell-nix.roots' compiler-nix-name ifdLevel;

107 roots = pkgs.haskell-nix.roots' compiler-nix-name ifdLevel;

95 ghc = pkgs.buildPackages.haskell-nix.compiler."${compiler-nix-name}";

108 ghc = pkgs.buildPackages.haskell-nix.compiler."${compiler-nix-name}";

compiler/ghc/configured-src.nixdeleted−127

@@ -1,127 +0,0 @@

1−{ stdenv, lib, fetchurl

2−, ghc-version, ghc-version-date, ghc-patches, src-spec

3−, targetPrefix

4−, targetPlatform, hostPlatform

5−, targetPackages

6−, perl, autoconf, automake, m4, python3, sphinx, ghc, bootPkgs

7−, autoreconfHook, toolsForTarget, bash

8−, libDeps

9−, useLLVM, llvmPackages

10−, targetCC

11−, enableIntegerSimple, targetGmp

12−, enableDWARF, elfutils

13−, ncurses, targetLibffi, libiconv

14−, disableLargeAddressSpace

15−, buildMK

16−}:

17−stdenv.mkDerivation (rec {

18−

19− version = ghc-version;

20− patches = ghc-patches;

21− name = "${targetPrefix}ghc-${ghc-version}-configured-src";

22−

23− # Make sure we never relax`$PATH` and hooks support for compatability.

24− strictDeps = true;

25−

26− nativeBuildInputs = [

27− perl autoconf automake m4 python3 sphinx

28− ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour

29− ] ++ lib.optional (patches != []) autoreconfHook;

30−

31− # For building runtime libs

32− depsBuildTarget = toolsForTarget;

33−

34− buildInputs = [ perl bash ] ++ (libDeps hostPlatform);

35−

36− propagatedBuildInputs = [ targetPackages.stdenv.cc ]

37− ++ lib.optional useLLVM llvmPackages.llvm;

38−

39− depsTargetTarget = map lib.getDev (libDeps targetPlatform);

40− depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);

41−

42− postPatch = "patchShebangs .";

43−

44− src = if src-spec ? file

45− then src-spec.file

46− else fetchurl { inherit (src-spec) url sha256; };

47−

48− # GHC is a bit confused on its cross terminology.

49− preConfigure = ''

50− for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do

51− export "''${env#TARGET_}=''${!env}"

52− done

53− # GHC is a bit confused on its cross terminology, as these would normally be

54− # the *host* tools.

55− export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"

56− export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"

57− # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177

58− export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString targetPlatform.isAarch32 ".gold"}"

59− export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"

60− export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"

61− export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"

62− export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"

63− export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"

64− export STRIP="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}strip"

65−

66− echo -n "${buildMK}" > mk/build.mk

67− sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure

68− '' + lib.optionalString (!stdenv.isDarwin) ''

69− export NIX_LDFLAGS+=" -rpath $out/lib/${targetPrefix}ghc-${version}"

70− '' + lib.optionalString stdenv.isDarwin ''

71− export NIX_LDFLAGS+=" -no_dtrace_dof"

72− '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''

73− 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

74− '' + lib.optionalString targetPlatform.isMusl ''

75− echo "patching llvm-targets for musl targets..."

76− echo "Cloning these existing '*-linux-gnu*' targets:"

77− grep linux-gnu llvm-targets | sed 's/^/ /'

78− echo "(go go gadget sed)"

79− sed -i 's,$^.*linux-$gnu$.*$$,\0\n\1musl\2,' llvm-targets

80− echo "llvm-targets now contains these '*-linux-musl*' targets:"

81− grep linux-musl llvm-targets | sed 's/^/ /'

82−

83− echo "And now patching to preserve '-musleabi' as done with '-gnueabi'"

84− # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen)

85− for x in configure aclocal.m4; do

86− substituteInPlace $x \

87− --replace '*-android*|*-gnueabi*)' \

88− '*-android*|*-gnueabi*|*-musleabi*)'

89− done

90− '' + lib.optionalString (src-spec.version != ghc-version) ''

91− substituteInPlace configure --replace 'RELEASE=YES' 'RELEASE=NO'

92− echo '${ghc-version}' > VERSION

93− '' + lib.optionalString (ghc-version-date != null) ''

94− substituteInPlace configure --replace 'RELEASE=YES' 'RELEASE=NO'

95− echo '${ghc-version-date}' > VERSION_DATE

96− '';

97−

98− configurePlatforms = [ "build" "host" "target" ];

99− # `--with` flags for libraries needed for RTS linker

100− configureFlags = [

101− "--datadir=$doc/share/doc/ghc"

102− "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib"

103− ] ++ lib.optionals (targetLibffi != null) ["--with-system-libffi" "--with-ffi-includes=${targetLibffi.dev}/include" "--with-ffi-libraries=${targetLibffi.out}/lib"

104− ] ++ lib.optional (!enableIntegerSimple) [

105− "--with-gmp-includes=${targetGmp.dev}/include" "--with-gmp-libraries=${targetGmp.out}/lib"

106− ] ++ lib.optional (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [

107− "--with-iconv-includes=${libiconv}/include" "--with-iconv-libraries=${libiconv}/lib"

108− ] ++ lib.optionals (targetPlatform != hostPlatform) [

109− "--enable-bootstrap-with-devel-snapshot"

110− ] ++ lib.optionals (disableLargeAddressSpace) [

111− "--disable-large-address-space"

112− ] ++ lib.optionals (targetPlatform.isAarch32) [

113− "CFLAGS=-fuse-ld=gold"

114− "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"

115− "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"

116− ] ++ lib.optionals enableDWARF [

117− "--enable-dwarf-unwind"

118− "--with-libdw-includes=${lib.getDev elfutils}/include"

119− "--with-libdw-libraries=${lib.getLib elfutils}/lib"

120− ];

121−

122− outputs = [ "out" ];

123− phases = [ "unpackPhase" "patchPhase" ]

124− ++ lib.optional (ghc-patches != []) "autoreconfPhase"

125− ++ [ "configurePhase" "installPhase" ];

126− installPhase = "cp -r . $out";

127−})

compiler/ghc/default.nix+231−64

@@ -8,11 +8,14 @@ let self =

8

9# build-tools

10, bootPkgs

11+, buildPackages

11, autoconf, automake, coreutils, fetchurl, fetchpatch, perl, python3, m4, sphinx, numactl, elfutils

12, autoconf, automake, coreutils, fetchurl, fetchpatch, perl, python3, m4, sphinx, numactl, elfutils

12, autoreconfHook

13, autoreconfHook

13, bash

14, bash

14

15

15−, libiconv ? null, ncurses

16+, libiconv ? null

17+

18+, ncurses # TODO remove this once the cross compilers all work without

16

19

17, installDeps

20, installDeps

18

21

@@ -28,6 +31,9 @@ let self =

28, # 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

29 # library instead of the faster but GPLed integer-gmp library.

32 # library instead of the faster but GPLed integer-gmp library.

30 enableIntegerSimple ? !(lib.any (lib.meta.platformMatch stdenv.hostPlatform) gmp.meta.platforms), gmp

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

36+ enableNativeBignum ? !((lib.any (lib.meta.platformMatch stdenv.hostPlatform) gmp.meta.platforms) || enableIntegerSimple)

31

37

32, # If enabled, use -fPIC when compiling static libs.

38, # If enabled, use -fPIC when compiling static libs.

33 enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform && !stdenv.targetPlatform.isAarch32

39 enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform && !stdenv.targetPlatform.isAarch32

@@ -40,8 +46,12 @@ let self =

40

46

41, enableDWARF ? false

47, enableDWARF ? false

42

48

43−, # Whether to build terminfo. Musl fails to build terminfo as ncurses seems to be linked to glibc

49+, enableTerminfo ?

44− enableTerminfo ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.isMusl

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

45

55

46, # What flavour to build. An empty string indicates no

56, # What flavour to build. An empty string indicates no

47 # specific flavour and falls back to ghc default values.

57 # specific flavour and falls back to ghc default values.

@@ -64,7 +74,11 @@ let self =

64, extra-passthru ? {}

74, extra-passthru ? {}

65}@args:

75}@args:

66

76

67−assert !enableIntegerSimple -> gmp != null;

77+assert !(enableIntegerSimple || enableNativeBignum) -> gmp != null;

78+

79+# Early check to make sure only one of these is enabled

80+assert enableNativeBignum -> !enableIntegerSimple;

81+assert enableIntegerSimple -> !enableNativeBignum;

68

82

69let

83let

70 inherit (stdenv) buildPlatform hostPlatform targetPlatform;

84 inherit (stdenv) buildPlatform hostPlatform targetPlatform;

@@ -72,6 +86,17 @@ let

72

86

73 inherit (bootPkgs) ghc;

87 inherit (bootPkgs) ghc;

74

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+

75 # TODO check if this possible fix for segfaults works or not.

100 # TODO check if this possible fix for segfaults works or not.

76 targetLibffi =

101 targetLibffi =

77 # 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

@@ -84,6 +109,10 @@ let

84

109

85 targetGmp = targetPackages.gmp or gmp;

110 targetGmp = targetPackages.gmp or gmp;

86

111

112+ targetIconv = targetPackages.libiconv or libiconv;

113+

114+ targetNumactl = targetPackages.numactl or numactl;

115+

87 # TODO(@Ericson2314) Make unconditional

116 # TODO(@Ericson2314) Make unconditional

88 targetPrefix = lib.optionalString

117 targetPrefix = lib.optionalString

89 (targetPlatform != hostPlatform)

118 (targetPlatform != hostPlatform)

@@ -95,17 +124,25 @@ let

95 include mk/flavours/\$(BuildFlavour).mk

124 include mk/flavours/\$(BuildFlavour).mk

96 endif

125 endif

97 DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}

126 DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}

98− INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}

127+ '' + bignumSpec + ''

128+ EXTRA_HADDOCK_OPTS += --quickjump --hyperlinked-source

99 '' + lib.optionalString (targetPlatform != hostPlatform) ''

129 '' + lib.optionalString (targetPlatform != hostPlatform) ''

100 CrossCompilePrefix = ${targetPrefix}

130 CrossCompilePrefix = ${targetPrefix}

101 '' + lib.optionalString isCrossTarget ''

131 '' + lib.optionalString isCrossTarget ''

102 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)) ''

103 HADDOCK_DOCS = NO

136 HADDOCK_DOCS = NO

104 BUILD_SPHINX_HTML = NO

137 BUILD_SPHINX_HTML = NO

105 BUILD_SPHINX_PDF = NO

138 BUILD_SPHINX_PDF = NO

106 '' + lib.optionalString enableRelocatedStaticLibs ''

139 '' + lib.optionalString enableRelocatedStaticLibs ''

107 GhcLibHcOpts += -fPIC

140 GhcLibHcOpts += -fPIC

108 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

109 '' + lib.optionalString enableDWARF ''

146 '' + lib.optionalString enableDWARF ''

110 GhcLibHcOpts += -g3

147 GhcLibHcOpts += -g3

111 GhcRtsHcOpts += -g3

148 GhcRtsHcOpts += -g3

@@ -116,24 +153,29 @@ let

116 ''

153 ''

117 # musl doesn't have a system-linker. Only on x86, and on x86 we need it, as

154 # musl doesn't have a system-linker. Only on x86, and on x86 we need it, as

118 # our elf linker for x86_64 is broken.

155 # our elf linker for x86_64 is broken.

119− + lib.optionalString (targetPlatform.isMusl && !targetPlatform.isx86) ''

156+ + lib.optionalString (targetPlatform.isAndroid || (targetPlatform.isMusl && !targetPlatform.isx86)) ''

120 compiler_CONFIGURE_OPTS += --flags=-dynamic-system-linker

157 compiler_CONFIGURE_OPTS += --flags=-dynamic-system-linker

121 ''

158 ''

122 # 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,

123 # 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

124 # 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.

125− + lib.optionalString targetPlatform.isWindows ''

165+ + lib.optionalString (targetPlatform.isWindows || targetPlatform.isAndroid) ''

126 SplitSections = NO

166 SplitSections = NO

127 '' + lib.optionalString (!enableLibraryProfiling) ''

167 '' + lib.optionalString (!enableLibraryProfiling) ''

128 BUILD_PROF_LIBS = NO

168 BUILD_PROF_LIBS = NO

129 '';

169 '';

130

170

131 # Splicer will pull out correct variations

171 # Splicer will pull out correct variations

132− libDeps = platform: lib.optional enableTerminfo [ ncurses ]

172+ libDeps = platform: lib.optional enableTerminfo [ targetPackages.ncurses targetPackages.ncurses.dev ]

133 ++ [targetLibffi]

173 ++ [targetLibffi]

134 ++ lib.optional (!enableIntegerSimple) gmp

174 ++ lib.optional (!enableIntegerSimple) gmp

135 ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv

175 ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv

136− ++ lib.optional (platform.isLinux && !platform.isAarch32) 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;

137

179

138 toolsForTarget =

180 toolsForTarget =

139 if hostPlatform == buildPlatform then

181 if hostPlatform == buildPlatform then

@@ -143,24 +185,6 @@ let

143

185

144 targetCC = builtins.head toolsForTarget;

186 targetCC = builtins.head toolsForTarget;

145

187

146− configured-src = import ./configured-src.nix {

147− inherit stdenv lib fetchurl

148− ghc-version ghc-version-date ghc-patches src-spec

149− targetPrefix

150− targetPlatform hostPlatform

151− targetPackages

152− perl autoconf automake m4 python3 sphinx ghc bootPkgs

153− autoreconfHook toolsForTarget bash

154− libDeps

155− useLLVM llvmPackages

156− targetCC

157− enableIntegerSimple targetGmp

158− enableDWARF elfutils

159− ncurses targetLibffi libiconv

160− disableLargeAddressSpace

161− buildMK

162− ;

163− };

164in

188in

165stdenv.mkDerivation (rec {

189stdenv.mkDerivation (rec {

166 version = ghc-version;

190 version = ghc-version;

@@ -168,42 +192,102 @@ stdenv.mkDerivation (rec {

168

192

169 patches = ghc-patches;

193 patches = ghc-patches;

170

194

171− # for this to properly work (with inheritance of patches, postPatch, ...)

195+ src = if src-spec ? file

172− # this needs to be a function over the values we want to inherit and then called

196+ then src-spec.file

173− # accordingly. Most trivial might be to just have args, and mash them into the

197+ else fetchurl { inherit (src-spec) url sha256; };

174− # attrset.

175− src = configured-src;

176

198

177 # configure was run by configured-src already.

199 # configure was run by configured-src already.

178− phases = [ "unpackPhase" "buildPhase"

200+ phases = [ "unpackPhase" "patchPhase" ]

201+ ++ lib.optional (ghc-patches != []) "autoreconfPhase"

202+ ++ [ "configurePhase" "buildPhase"

179 "checkPhase" "installPhase"

203 "checkPhase" "installPhase"

180 "fixupPhase"

204 "fixupPhase"

181 "installCheckPhase"

205 "installCheckPhase"

182 "distPhase"

206 "distPhase"

183 ];

207 ];

184

208

185− # ghc hardcodes the TOP dir during config, this breaks when

209+ # GHC is a bit confused on its cross terminology.

186− # splitting the configured src from the build process.

210+ preConfigure =

187− postUnpack = ''

211+ # This code is only included when cross compiling as it breaks aarch64-darwin native compilation

188− (cd $sourceRoot

212+ lib.optionalString (targetPlatform != hostPlatform) ''

189− TOP=$(cat mk/config.mk|grep ^TOP|awk -F\ '{ print $3 }')

213+ for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do

190− PREFIX=$(cat mk/install.mk|grep ^prefix|awk -F\ '{ print $3 }')

214+ export "''${env#TARGET_}=''${!env}"

191−

215+ done

192− # these two are required

216+ # GHC is a bit confused on its cross terminology, as these would normally be

193− substituteInPlace mk/config.mk --replace "$TOP" "$PWD" \

217+ # the *host* tools.

194− --replace "$PREFIX" "$out"

218+ export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"

195−

219+ export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"

196− substituteInPlace mk/install.mk --replace "$TOP" "$PWD" \

220+ # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177

197− --replace "$PREFIX" "$out"

221+ export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString targetPlatform.isAarch32 ".gold"}"

198−

222+ export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"

199− # these two only for convencience.

223+ export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"

200− substituteInPlace config.log --replace "$TOP" "$PWD"\

224+ export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"

201− --replace "$PREFIX" "$out"

225+ export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"

202− substituteInPlace config.status --replace "$TOP" "$PWD"\

226+ export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"

203− --replace "$PREFIX" "$out")

227+ export STRIP="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}strip"

204−

228+ '' + ''

205−

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"

206− '';

290+ ];

207

291

208 enableParallelBuilding = true;

292 enableParallelBuilding = true;

209 postPatch = "patchShebangs .";

293 postPatch = "patchShebangs .";

@@ -226,9 +310,6 @@ stdenv.mkDerivation (rec {

226

310

227 buildInputs = [ perl bash ] ++ (libDeps hostPlatform);

311 buildInputs = [ perl bash ] ++ (libDeps hostPlatform);

228

312

229− propagatedBuildInputs = [ targetPackages.stdenv.cc ]

230− ++ lib.optional useLLVM llvmPackages.llvm;

231−

232 depsTargetTarget = map lib.getDev (libDeps targetPlatform);

313 depsTargetTarget = map lib.getDev (libDeps targetPlatform);

233 depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);

314 depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);

234

315

@@ -246,7 +327,18 @@ stdenv.mkDerivation (rec {

246 ++ lib.optional stdenv.targetPlatform.isAarch32 "pic"

327 ++ lib.optional stdenv.targetPlatform.isAarch32 "pic"

247 ++ lib.optional stdenv.targetPlatform.isMusl "pie";

328 ++ lib.optional stdenv.targetPlatform.isMusl "pie";

248

329

249− 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+ '' + ''

250 # Install the bash completion file.

342 # Install the bash completion file.

251 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

252

344

@@ -262,11 +354,9 @@ stdenv.mkDerivation (rec {

262 $i

354 $i

263 done

355 done

264

356

265− # Save generated files for needed when building ghcjs

357+ # Save generated files for needed when building ghc and ghcjs

266 mkdir -p $generated/includes/dist-derivedconstants/header

358 mkdir -p $generated/includes/dist-derivedconstants/header

267− cp includes/dist-derivedconstants/header/GHCConstantsHaskellExports.hs \

359+ cp includes/dist-derivedconstants/header/GHCConstantsHaskell*.hs \

268− includes/dist-derivedconstants/header/GHCConstantsHaskellType.hs \

269− includes/dist-derivedconstants/header/GHCConstantsHaskellWrappers.hs \

270 $generated/includes/dist-derivedconstants/header

360 $generated/includes/dist-derivedconstants/header

271 if [[ -f includes/ghcplatform.h ]]; then

361 if [[ -f includes/ghcplatform.h ]]; then

272 cp includes/ghcplatform.h $generated/includes

362 cp includes/ghcplatform.h $generated/includes

@@ -275,6 +365,15 @@ stdenv.mkDerivation (rec {

275 fi

365 fi

276 mkdir -p $generated/compiler/stage2/build

366 mkdir -p $generated/compiler/stage2/build

277 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

278 mkdir -p $generated/rts/build

377 mkdir -p $generated/rts/build

279 cp rts/build/config.hs-incl $generated/rts/build || true

378 cp rts/build/config.hs-incl $generated/rts/build || true

280

379

@@ -318,7 +417,40 @@ stdenv.mkDerivation (rec {

318 # Our Cabal compiler name

417 # Our Cabal compiler name

319 haskellCompilerName = "ghc-${version}";

418 haskellCompilerName = "ghc-${version}";

320

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 ({

321− 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+ });

322

454

323 # Used to detect non haskell-nix compilers (accidental 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)

324 isHaskellNixCompiler = true;

456 isHaskellNixCompiler = true;

@@ -328,6 +460,11 @@ stdenv.mkDerivation (rec {

328 enableDWARF = stdenv.targetPlatform.isLinux

460 enableDWARF = stdenv.targetPlatform.isLinux

329 && builtins.compareVersions ghc-version "8.10.2" >= 0;

461 && builtins.compareVersions ghc-version "8.10.2" >= 0;

330 });

462 });

463+

464+ # The same GHC, but without the large (1TB) address space reservation

465+ smallAddressSpace = lib.makeOverridable self (args // {

466+ disableLargeAddressSpace = true;

467+ });

331 } // extra-passthru;

468 } // extra-passthru;

332

469

333 meta = {

470 meta = {

@@ -337,9 +474,39 @@ stdenv.mkDerivation (rec {

337 inherit (ghc.meta) license platforms;

474 inherit (ghc.meta) license platforms;

338 };

475 };

339

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";

340} // lib.optionalAttrs targetPlatform.useAndroidPrebuilt {

482} // lib.optionalAttrs targetPlatform.useAndroidPrebuilt {

341 dontStrip = true;

483 dontStrip = true;

342 dontPatchELF = true;

484 dontPatchELF = true;

343 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+ '';

344});

511});

345in self

512in self

compiler/ghcjs/ghcjs-src.json+2−2

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

1{

2 "url": "https://github.com/ghcjs/ghcjs",

3− "rev": "30706cd687a301776ba4c1efd3db442fa9c78883",

3+ "rev": "58ed01e77028108c2b1da10d52cb331788b6a466",

4− "sha256": "sha256-7mJ/y6l89Rq/rIvZLZAOGpHsiBJ5BPCUuZIu2nxc6Dk=",

4+ "sha256": "1lr3grk5jjm8bvvkndilm06ry1dj7i66k4g27fr009bggdy9q6ws",

5 "fetchSubmodules": true

6}

compiler/ghcjs/ghcjs.nix+19−6

@@ -7,14 +7,22 @@

7 then "ghc884"

8 else "ghc865"

9, ghc ? pkgs.buildPackages.ghc

10+, overrideBootPackages ? [] # adds if not present, overrides if present.

10}:

11}:

11let

12let

12− isGhcjs88 = builtins.compareVersions ghcjsVersion "8.8.0.0" > 0;

13+ isGhcjs88 = builtins.compareVersions ghcjsVersion "8.8.0.0" >= 0;

14+ isGhcjs810 = builtins.compareVersions ghcjsVersion "8.10.0.0" >= 0;

13

15

14 project = pkgs.buildPackages.haskell-nix.ghcjsProject {

16 project = pkgs.buildPackages.haskell-nix.ghcjsProject {

15 src = ghcjsSrc;

17 src = ghcjsSrc;

16− inherit ghcjsVersion compiler-nix-name;

18+ inherit ghcjsVersion compiler-nix-name overrideBootPackages;

17 index-state = "2020-04-25T00: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 [];

18# plan-sha256 = "1wy2lr08maxyi7r8jiwf2gj6pdayk5vxxwh42bj4s2gg4035z0yc";

26# plan-sha256 = "1wy2lr08maxyi7r8jiwf2gj6pdayk5vxxwh42bj4s2gg4035z0yc";

19# materialized = ../../materialized/ghcjs;

27# materialized = ../../materialized/ghcjs;

20 };

28 };

@@ -54,10 +62,11 @@ let

54 ++ pkgs.lib.optional isGhcjs88 pkgs.buildPackages.procps;

62 ++ pkgs.lib.optional isGhcjs88 pkgs.buildPackages.procps;

55 passthru = {

63 passthru = {

56 inherit all-ghcjs bundled-ghcjs project;

64 inherit all-ghcjs bundled-ghcjs project;

57− inherit (project) configured-src;

65+ configured-src = project.configured-src + "/ghc";

58 # Used to detect non haskell-nix compilers (accidental 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)

59 isHaskellNixCompiler = true;

67 isHaskellNixCompiler = true;

60 } // ghcjs.components.exes;

68 } // ghcjs.components.exes;

69+ dontUpdateAutotoolsGnuConfigScripts = true;

61 dontConfigure = true;

70 dontConfigure = true;

62 dontInstall = true;

71 dontInstall = true;

63 buildPhase = ''

72 buildPhase = ''

@@ -104,10 +113,14 @@ let

104 fi

113 fi

105 done

114 done

106 } &

115 } &

107− ${ if isGhcjs88

116+ ${

108− then

109− # Unsets NIX_CFLAGS_COMPILE so the osx version of iconv.h is not used by mistake

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)

110 ''

122 ''

123+ else if isGhcjs88 then ''

111 env -u NIX_CFLAGS_COMPILE PATH=$out/bin:$PATH \

124 env -u NIX_CFLAGS_COMPILE PATH=$out/bin:$PATH \

112 $out/bin/ghcjs-boot -j1 --with-emsdk=${project.emsdk} --no-prof --no-haddock \

125 $out/bin/ghcjs-boot -j1 --with-emsdk=${project.emsdk} --no-prof --no-haddock \

113 || (echo failed > $TMP/done; false)

126 || (echo failed > $TMP/done; false)

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/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/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−4

@@ -2,11 +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}

7}

12

8

default.nix+29−29

@@ -1,29 +1,29 @@

1−{ checkMaterialization ? false # Allows us to easily switch on materialization checking

2−, system ? builtins.currentSystem

3−, sourcesOverride ? {}

4−, ... }@args: rec {

1+{...}@args:

5− sources = (import ./nix/sources.nix) // sourcesOverride;

2+

6− config = import ./config.nix;

3+let

7− overlays = [ allOverlays.combined ] ++ (

4+ nixpkgsSrc =

8− if checkMaterialization == true

5+ builtins.fetchTarball {

9− then [(

6+ url = "https://github.com/NixOS/nixpkgs/archive/110a2c9ebbf5d4a94486854f18a37a938cfacbbb.tar.gz";

10− final: prev: {

7+ sha256 = "sha256-leWXLchbAbqOlLT6tju631G40SzQWPqaAXQG3zH1Imw=";

11− haskell-nix = prev.haskell-nix // {

8+ };

12− checkMaterialization = true;

9+ pkgs = args.pkgs or (import nixpkgsSrc {});

13− };

10+ flake-compat =

14− }

11+ pkgs.fetchzip {

15− )]

12+ url = "https://github.com/edolstra/flake-compat/archive/5523c47f13259b981c49b26e28499724a5125fd8.tar.gz";

16− else []

13+ sha256 = "sha256-7IySNHriQjzOZ88DDk6VDPf1GoUaOrOeUdukY62o52o=";

17− ) ++ [(

14+ };

18− final: prev: {

15+ self = import flake-compat {

19− haskell-nix = prev.haskell-nix // {

16+ # We bypass flake-compat's rootSrc cleaning by evading its detection of this as a git

20− inherit overlays;

17+ # repo.

21− sources = prev.haskell-nix.sources // sourcesOverride;

18+ # This is done for 3 reasons:

22− };

19+ # * To workaround https://github.com/edolstra/flake-compat/issues/25

23− }

20+ # * Make `updateMaterilized` scripts work (if filtering is done by `flake-compat`

24− )];

21+ # the `updateMaterilized` scripts will try to update the copy in the store).

25− allOverlays = import ./overlays args;

22+ # * Allow more granular filtering done by the tests (the use of `cleanGit` and `cleanSourceWith`

26− nixpkgsArgs = { inherit config overlays system; };

23+ # in `test/default.nix`). If `flake-compat` copies the whole git repo, any change to the

27− pkgs = import sources.nixpkgs nixpkgsArgs;

24+ # repo causes a change of input for all tests.

28− pkgs-unstable = import sources.nixpkgs-unstable nixpkgsArgs;

25+ src = { outPath = ./.; };

29−}

26+ inherit pkgs;

27+ };

28+in self.defaultNix // (self.defaultNix.internal.compat

29+({ system = args.pkgs.system or builtins.currentSystem; } // args))

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/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+6−3

@@ -144,7 +144,7 @@ Then feeding its result into [mkStackPkgSet](#mkstackpkgset) passing also

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) |

147+| `ghcWithHoogle` | Function | [`ghcWithHoogle`](#ghcwithhoogle) |

148| `ghcWithPackages` | Function | [`ghcWithPackages`](#ghcwithpackages) |

149

150

@@ -163,9 +163,11 @@ Then feeding its result into [mkCabalProjectPkgSet](#mkcabalprojectpkgset) passi

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) |

166+| `ghcWithHoogle` | Function | [`ghcWithHoogle`](#ghcwithhoogle) |

167| `ghcWithPackages` | Function | [`ghcWithPackages`](#ghcwithpackages) |

168−| `projectCross` | Attrset | Like `pkgs.pkgsCross.X` from nixpkgs `p.projectCross.X` returns the project results for cross compilation to X. So `p.projectCross.ghcjs.hsPkgs` is the same as `hsPkgs` but compiled with ghcjs |

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. |

169

171

170## project, cabalProject and stackProject

172## project, cabalProject and stackProject

171

173

@@ -435,6 +437,7 @@ shellFor =

435| `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. |

436| `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. |

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. |

437| `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).

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). |

438| `{ ... }` | 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). |

439

442

440**Return value**: a derivation

443**Return value**: a derivation

docs/reference/supported-ghc-versions.md+39−18

@@ -1,28 +1,49 @@

1# Supported GHC Versions

2

3−

4−The following GHC versions are defined in `haskell.nix` (i.e. there is a derivation for them even if it isn't necessarily cached):

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}

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.

9

21

10−The following table shows the nixpkgs/GHC versions which are built by CI, and which of those are tested.

11−If you use a combination of nixpkgs version and GHC version which is in this table, you should get cache hits from our cache.

23+|------------------|--------------------|-------------|-----------------------|---------------|

12−The "nixpkgs versions" refer to the versions that `haskell.nix` provides; if you use your own version of nixpkgs you will likely not get cache hit.

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 |

13

31

14−| Nixpkgs version | GHC version | Tested? |

32+See [ci.nix](https://github.com/input-output-hk/haskell.nix/blob/master/ci.nix)

15−|------------------|-------------|---------|

33+for the source of truth about what is built and tested (in the off chance this

16−| 20.03 | 8.6.5 | Y |

34+document is out-of-sync with your checkout).

17−| 20.09 | 8.6.5 | Y |

18−| 20.09 | 8.8.4 | Y |

19−| 20.09 | 8.10.4 | Y |

20−| nixpkgs-unstable | 8.6.5 | Y |

21−| nixpkgs-unstable | 8.8.4 | Y |

22−| nixpkgs-unstable | 8.10.4 | Y |

23

35

24−See [ci.nix](https://github.com/input-output-hk/haskell.nix/blob/master/ci.nix) for the source of truth about what is built and tested.

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).

25

41

42+See

26−See [overlays/bootstrap.nix](https://github.com/input-output-hk/haskell.nix/blob/master/overlays/bootstrap.nix) for a list of all the valid `compiler-nix-names`.

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.

27

47

28−See also: [Instructions on adding new GHC versions](../dev/adding-new-ghc.md).

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/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/development.md+21−13

@@ -34,13 +34,14 @@ themselves. This is what the [`shellFor`][shellFor] function does.

34

35```nix

36# shell.nix

37−{ pkgs ? import <nixpkgs> {} }:

38−

39let

37let

40− hsPkgs = import ./default.nix { inherit pkgs; };

38+ project = import ./default.nix;

41in

39in

42− hsPkgs.shellFor {

40+ project.shellFor {

43− # 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).

44 packages = ps: with ps; [

45 packages = ps: with ps; [

45 pkga

46 pkga

46 pkgb

47 pkgb

@@ -50,15 +51,22 @@ in

50 # and provides a "hoogle" command to search the index.

51 # and provides a "hoogle" command to search the index.

51 withHoogle = true;

52 withHoogle = true;

52

53

53− # You might want some extra tools in the shell (optional).

54−

55 # Some common tools can be added with the `tools` argument

54 # Some common tools can be added with the `tools` argument

55+ tools = {

56− 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+ };

57 # See overlays/tools.nix for more details

60 # See overlays/tools.nix for more details

58

61

59 # Some you may need to get some other way.

62 # Some you may need to get some other way.

60− 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

61− [ ghcid ];

69+ ];

62

70

63 # Prevents cabal from choosing alternate plans, so that

71 # Prevents cabal from choosing alternate plans, so that

64 # *all* dependencies are provided by Nix.

72 # *all* dependencies are provided by Nix.

@@ -77,15 +85,15 @@ If you need a local Hoogle for all the dependencies of your project create this

77```nix

85```nix

78# shell-hoogle.nix

86# shell-hoogle.nix

79let

87let

80− hsPkgs = import ./default.nix {};

88+ project = import ./default.nix {};

81in

89in

82− hsPkgs.shellFor {

90+ project.shellFor {

83 packages = ps: [ps.my-package];

91 packages = ps: [ps.my-package];

84 withHoogle = true;

92 withHoogle = true;

85 }

93 }

86```

94```

87

95

88−and run `nix-shell shell-hoogle.nix --run "hoogle server --local"`.

96+and run `nix-shell shell-hoogle.nix --run "hoogle server --local"`.

89This 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`.

90

98

91

99

docs/tutorials/getting-started-flakes.md+44−14

@@ -22,10 +22,34 @@ You need to add the following sections to `/etc/nix/nix.conf` or, if you are a t

22

23```

24trusted-public-keys = [...] hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ= [...]

25−substituters = [...] https://hydra.iohk.io [...]

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+

28−This can be tricky to get setup properly. If you're still having trouble getting cache hits, consult the corresponding [troubleshooting section](../reference/troubleshooting#why-am-i-building-ghc).

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).

29

53

30## Scaffolding

54## Scaffolding

31

55

@@ -50,24 +74,30 @@ Add `flake.nix`:

50 final.haskell-nix.project' {

74 final.haskell-nix.project' {

51 src = ./.;

75 src = ./.;

52 compiler-nix-name = "ghc8104";

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];

53 };

90 };

54 })

91 })

55 ];

92 ];

56− pkgs = import nixpkgs { inherit system overlays; };

93+ pkgs = import nixpkgs { inherit system overlays; inherit (haskellNix) config; };

57− flake = pkgs.helloProject.flake {};

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+ };

58 in flake // {

98 in flake // {

59 # Built by `nix build .`

99 # Built by `nix build .`

60 defaultPackage = flake.packages."hello:exe:hello";

100 defaultPackage = flake.packages."hello:exe:hello";

61−

62− # This is used by `nix develop .` to open a shell for use with

63− # `cabal`, `hlint` and `haskell-language-server`

64− devShell = pkgs.helloProject.shellFor {

65− tools = {

66− cabal = "latest";

67− hlint = "latest";

68− haskell-language-server = "latest";

69− };

70− };

71 });

101 });

72}

102}

73```

103```

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+93−28

@@ -18,22 +18,61 @@ You need to add the following sections to `/etc/nix/nix.conf` or, if you are a t

18

19```

20trusted-public-keys = [...] hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ= [...]

21−substituters = [...] https://hydra.iohk.io [...]

21+substituters = [...] https://cache.iog.io [...]

22```

23

24If 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

28nix.binaryCachePublicKeys = [

40nix.binaryCachePublicKeys = [

29 "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

41 "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

30];

42];

31nix.binaryCaches = [

43nix.binaryCaches = [

32− "https://hydra.iohk.io"

44+ "https://cache.iog.io"

33−];

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+

34```

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:

35

72

36−This can be tricky to get setup properly. If you're still having trouble getting cache hits, consult the corresponding [troubleshooting section](../../troubleshooting#why-am-i-building-ghc).

73+```

74+niv update haskellNix

75+```

37

76

38## Scaffolding

77## Scaffolding

39

78

@@ -43,21 +82,28 @@ projects.

43Add `default.nix`:

82Add `default.nix`:

44

83

45```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+

46−{ # Fetch the latest haskell.nix and import its default.nix

92+ # Fetch the haskell.nix commit we have pinned with Niv

47− haskellNix ? import (builtins.fetchTarball "https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz") {}

93+ haskellNix = import sources.haskellNix {};

48−

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

49−# haskell.nix provides access to the nixpkgs pins which are used by our CI,

99+ # haskell.nix provides access to the nixpkgs pins which are used by our CI,

50−# hence 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.

51−# But you can also just use your own, e.g. '<nixpkgs>'.

101+ # But you can also just use your own, e.g. '<nixpkgs>'.

52−, nixpkgsSrc ? haskellNix.sources.nixpkgs-2009

102+ haskellNix.sources.nixpkgs-unstable

53−

54−# haskell.nix provides some arguments to be passed to nixpkgs, including some

103+ # These arguments passed to nixpkgs, include some patches and also

55−# patches and also the haskell.nix functionality itself as an overlay.

104+ # the haskell.nix functionality itself as an overlay.

56−, nixpkgsArgs ? haskellNix.nixpkgsArgs

105+ haskellNix.nixpkgsArgs;

57−

58−# import nixpkgs with overlays

59−, pkgs ? import nixpkgsSrc nixpkgsArgs

60−}: pkgs.haskell-nix.project {

106+in pkgs.haskell-nix.project {

61 # '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

62 src = pkgs.haskell-nix.haskellLib.cleanGit {

108 src = pkgs.haskell-nix.haskellLib.cleanGit {

63 name = "haskell-nix-project";

109 name = "haskell-nix-project";

@@ -96,20 +142,40 @@ nix-build -A projectCross.ghcjs.hsPkgs.your-package-name.components.exes.your-ex

96nix-build -A projectCross.mingwW64.hsPkgs.your-package-name.components.exes.your-exe-name

142nix-build -A projectCross.mingwW64.hsPkgs.your-package-name.components.exes.your-exe-name

97```

143```

98

144

99−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:

100

158

101```shell

159```shell

102−nix-shell -A shellFor

160+nix-shell

103cabal new-repl your-package-name:library:your-package-name

161cabal new-repl your-package-name:library:your-package-name

104cabal new-build your-package-name

162cabal new-build your-package-name

105```

163```

106

164

107To 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).

108

166

109−### Pinning the [haskell.nix][] version

167+## Using haskell.nix without Niv

168+

169+If you would prefer not to use niv you can replace

170+`sources = import ./nix/sources.nix {};` in the examples with:

110

171

111−For simplicity's sake we will use `fetchTarball` for the examples in

172+```nix

173+let sources = {

174+ haskellNix = builtins.fetchTarball "https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz";

175+ };

176+```

177+

112−this documentation. This will always get the latest version, and is

178+The `fetchTarball` call above will always get the latest version, and is

113similar to an auto-updating Nix channel.

179similar to an auto-updating Nix channel.

114

180

115However, in your own project, you may wish to pin [haskell.nix][] (as

181However, in your own project, you may wish to pin [haskell.nix][] (as

@@ -119,10 +185,9 @@ predictable, and faster (because the fixed version is cached).

119Straightforward way of doing this is to change the branch name to a revision.

185Straightforward way of doing this is to change the branch name to a revision.

120

186

121```nix

187```nix

122−{ # Fetch a specific haskell.nix and import its default.nix

188+let sources = {

123− 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";

124−

190+ };

125−...

126```

191```

127

192

128There are other possible schemes for pinning. See

193There are other possible schemes for pinning. See

docs/tutorials/materialization.md+99−115

@@ -2,7 +2,7 @@

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

7of an IFD (import from derivation).

8

@@ -16,143 +16,146 @@ 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

33

36−## How can we materialize the nix files?

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 nixpkgsArgs;

45 pkgs = import sources.nixpkgs nixpkgsArgs;

44 hlint = pkgs.haskell-nix.hackage-package {

46 hlint = pkgs.haskell-nix.hackage-package {

45− compiler-nix-name = "ghc884";

47+ compiler-nix-name = "ghc8102";

46 name = "hlint";

48 name = "hlint";

47 version = "2.2.11";

49 version = "2.2.11";

48 };

50 };

49−in hlint.components.exes.hlint

51+in hlint

50```

52```

51

53

52Building 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

53it again it should give just:

55it again it should give just:

54

56

55```

57```

56−$ nix-build hlint.nix

58+$ nix-build hlint.nix -A components.exes.hlint

57−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)!

58−trace: Using index-state: 2020-04-15T00:00:00Z for hlint

60+/nix/store/2ybrfmcp79gg75ad4pr1cbxjak70yg8b-hlint-exe-hlint-2.2.11

59−/nix/store/rnfz66v7k8i38c8rsmchzsyqjrmrbdpk-hlint-2.2.11-exe-hlint

60```

61```

61

62

62−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

63−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

64−`index-state` of hackage we want to use:

66+use:

65

67

66```nix

68```nix

67let inherit (import ./. {}) sources nixpkgsArgs;

69let inherit (import ./. {}) sources nixpkgsArgs;

68 pkgs = import sources.nixpkgs nixpkgsArgs;

70 pkgs = import sources.nixpkgs nixpkgsArgs;

69 hlint = pkgs.haskell-nix.hackage-package {

71 hlint = pkgs.haskell-nix.hackage-package {

70− compiler-nix-name = "ghc884";

72+ compiler-nix-name = "ghc8102";

71 name = "hlint";

73 name = "hlint";

72 version = "2.2.11";

74 version = "2.2.11";

73− index-state = "2020-04-15T00:00:00Z";

75+ index-state = "2021-01-04T00:00:00Z";

74 };

76 };

75−in hlint.components.exes.hlint

77+in hlint

76```

78```

77

79

78−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

79−calculate a suitable sha256 hash to turn the derivation

80−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:

81

83

82```

84```

83−$ nix-build hlint.nix

85+$ nix-build hlint.nix -A components.exes.hlint

84−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'.

85−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'.

86−/nix/store/rnfz66v7k8i38c8rsmchzsyqjrmrbdpk-hlint-2.2.11-exe-hlint

88+/nix/store/2ybrfmcp79gg75ad4pr1cbxjak70yg8b-hlint-exe-hlint-2.2.11

87−

89+

88−$ 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

89−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

90```

94```

91

95

92−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

93−stack projects)

97+by `stack-nix` and `stack-sha256`, respectively. We can add the hash as

98+`plan-sha256`:

94

99

95```nix

100```nix

96let inherit (import ./. {}) sources nixpkgsArgs;

101let inherit (import ./. {}) sources nixpkgsArgs;

97 pkgs = import sources.nixpkgs nixpkgsArgs;

102 pkgs = import sources.nixpkgs nixpkgsArgs;

98 hlint = pkgs.haskell-nix.hackage-package {

103 hlint = pkgs.haskell-nix.hackage-package {

99− compiler-nix-name = "ghc884";

104+ compiler-nix-name = "ghc8102";

100 name = "hlint";

105 name = "hlint";

101 version = "2.2.11";

106 version = "2.2.11";

102− index-state = "2020-04-15T00:00:00Z";

107+ index-state = "2021-01-04T00:00:00Z";

103− plan-sha256 = "02hasr27a994sml1fzf8swb716lm6lgixxr53y0gxkhw437xkck4";

108+ plan-sha256 = "04hdgqwpaswmyb0ili7fwi6czzihd6x0jlvivw52d1i7wv4gaqy7";

104 };

109 };

105−in hlint.components.exes.hlint

110+in hlint

106```

111```

107

112

108−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

109−still calculate all the dependencies (which can add seconds to

114+will still calculate all the dependencies (which can add seconds to `nix-build`

110−`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

111−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

112−to wait while they are built or downloaded.

117+downloaded.

113

118

114−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:

115

120

116```

121```

117−$ nix-build hlint.nix

122+$ nix-build hlint.nix -A components.exes.hlint

118−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'.

119−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

120−/nix/store/rnfz66v7k8i38c8rsmchzsyqjrmrbdpk-hlint-2.2.11-exe-hlint

121```

125```

122

126

123−To capture the nix we can do something like:

127+To capture the Nix expressions we can do something like:

124

128

125```nix

129```nix

126let inherit (import ./. {}) sources nixpkgsArgs;

130let inherit (import ./. {}) sources nixpkgsArgs;

127 pkgs = import sources.nixpkgs nixpkgsArgs;

131 pkgs = import sources.nixpkgs nixpkgsArgs;

128 hlint = pkgs.haskell-nix.hackage-package {

132 hlint = pkgs.haskell-nix.hackage-package {

129− compiler-nix-name = "ghc884";

133+ compiler-nix-name = "ghc8102";

130 name = "hlint";

134 name = "hlint";

131 version = "2.2.11";

135 version = "2.2.11";

132− index-state = "2020-04-15T00:00:00Z";

136+ index-state = "2021-01-04T00:00:00Z";

133− plan-sha256 = "02hasr27a994sml1fzf8swb716lm6lgixxr53y0gxkhw437xkck4";

137+ plan-sha256 = "04hdgqwpaswmyb0ili7fwi6czzihd6x0jlvivw52d1i7wv4gaqy7";

134 materialized = ./hlint.materialized;

138 materialized = ./hlint.materialized;

135 };

139 };

136−in hlint.components.exes.hlint

140+in hlint

137```

141```

138

142

139−Now we can copy the nix files needed and build with:

143+Now we can copy the Nix files needed and build with:

140

144

141```

145```

142−$ 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

143−$ nix-build hlint.nix

147+$ nix-build hlint.nix -A components.exes.hlint

144−/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

145```

150```

146

151

147−We may want to run `chmod -R +w hlint.materialized` as the files copied from the

148−store will be read only.

149−

150## How can we check `sha256` and `materialized` are up to date?

152## How can we check `sha256` and `materialized` are up to date?

151

153

152Let'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`.

153We can tell haskell.nix to check the materialization either by:

155We can tell haskell.nix to check the materialization either by:

154

156

155* Removing the materialization files with `rm -rf hlint.materialized`

157* Removing the materialization files with `rm -rf hlint.materialized`

158+

156* Temporarily adding `checkMaterialization = true;`

159* Temporarily adding `checkMaterialization = true;`

157

160

158If we choose to add the `checkMaterialization` flag you would have:

161If we choose to add the `checkMaterialization` flag you would have:

@@ -161,68 +164,50 @@ If we choose to add the `checkMaterialization` flag you would have:

161let inherit (import ./. {}) sources nixpkgsArgs;

164let inherit (import ./. {}) sources nixpkgsArgs;

162 pkgs = import sources.nixpkgs nixpkgsArgs;

165 pkgs = import sources.nixpkgs nixpkgsArgs;

163 hlint = pkgs.haskell-nix.hackage-package {

166 hlint = pkgs.haskell-nix.hackage-package {

164− compiler-nix-name = "ghc884";

167+ compiler-nix-name = "ghc8102";

165 name = "hlint";

168 name = "hlint";

166 version = "2.2.10";

169 version = "2.2.10";

167− index-state = "2020-04-15T00:00:00Z";

170+ index-state = "2021-01-04T00:00:00Z";

168− plan-sha256 = "02hasr27a994sml1fzf8swb716lm6lgixxr53y0gxkhw437xkck4";

171+ plan-sha256 = "04hdgqwpaswmyb0ili7fwi6czzihd6x0jlvivw52d1i7wv4gaqy7";

169 materialized = ./hlint.materialized;

172 materialized = ./hlint.materialized;

170 checkMaterialization = true;

173 checkMaterialization = true;

171 };

174 };

172−in hlint.components.exes.hlint

175+in hlint

173```

176```

174

177

175This 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:

176

179

177```

180```

178−$ nix-build hlint.nix

181+$ nix-build hlint.nix -A components.exes.hlint

179

182

180...

183...

181

184

182−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 :

183− plan-sha256 = "0zsi3wv92qax33ic4n5dfsqd1r9qam1k75za3c5jqgdxl3hy8vph";

186+ plan-sha256 = "0jsgdmii0a6b35sd42cpbc83s4sp4fbx8slphzvamq8n9x49i5b6";

184−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

185− rm -rf /Users/hamish/iohk/haskell.nix/hlint.materialized

186− cp -r /nix/store/ywdhbx9rzzkfc60c5vzk7cins2hnvkgx-hlint-plan-to-nix-pkgs /Users/hamish/iohk/haskell.nix/hlint.materialized

187− chmod -R +w /Users/hamish/iohk/haskell.nix/hlint.materialized

188−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

189−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

190(use '--show-trace' to show detailed location information)

191```

192

193−Checking the materialization requires nix to do all the work that materialization

193+Checking the materialization requires Nix to do all the work that

194−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

195−the time, we would be better off just removing `materialized` and `plan-sha256`.

196+removing `materialized` and `plan-sha256`.

196

197

197−## How can we update the nix files with a script?

198+## How can we update the Nix files with a script?

198

199

199−There are versions of the functions (`project'`, `cabalProject'`,

200+We can simply put the commands we used earlier in a script:

200−`stackProject'` and `hackage-project`) that also return the nix as

201−`plan-nix` or `stack-nix`. By calling one of these functions without

202−the hash and materialized nix we can find out what nix files should be.

203−For instance:

204

201

205```nix

202```nix

206−let inherit (import ./. {}) sources nixpkgsArgs;

203+#!/bin/sh

207− pkgs = import sources.nixpkgs nixpkgsArgs;

208− hlint = pkgs.haskell-nix.hackage-project {

209− compiler-nix-name = "ghc884";

210− name = "hlint";

211− version = "2.2.10";

212− index-state = "2020-04-15T00:00:00Z";

213− };

214−in hlint

215−```

216

204

217−```

205+# Output new plan-sha256

218−$ nix-build hlint.nix -A plan-nix

206+nix-build hlint.nix -A project.plan-nix.passthru.calculateMaterializedSha | bash

219−trace: Using index-state: 2020-04-15T00:00:00Z for hlint

220−trace: Get `plan-sha256` with `nix-hash --base32 --type sha256 /nix/store/ywdhbx9rzzkfc60c5vzk7cins2hnvkgx-hlint-plan-to-nix-pkgs/`

221−/nix/store/ywdhbx9rzzkfc60c5vzk7cins2hnvkgx-hlint-plan-to-nix-pkgs

222−```

223

207

224−We can have the script copy `$(nix-build hlint.nix -A plan-nix --no-out-link)`

208+# Update materialized Nix expressions

225−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+```

226

211

227## Can we skip making a copy and use `materialized = /nix/store/...`?

212## Can we skip making a copy and use `materialized = /nix/store/...`?

228

213

@@ -231,7 +216,7 @@ Yes and it gives us the same speed improvement, however:

231* It does not help at all in `restricted-eval` mode (Hydra).

216* It does not help at all in `restricted-eval` mode (Hydra).

232

217

233* Users will still wind up building or downloading the dependencies

218* Users will still wind up building or downloading the dependencies

234− needed to build the nix files (if they do not have them).

219+ needed to build the Nix files (if they do not have them).

235

220

236For those reasons it might be best to make a copy instead

221For those reasons it might be best to make a copy instead

237of using the `/nix/store/...` path directly.

222of using the `/nix/store/...` path directly.

@@ -243,30 +228,29 @@ a non-existing path is now an error:

243```nix

228```nix

244let inherit (import ./. {}) sources nixpkgsArgs;

229let inherit (import ./. {}) sources nixpkgsArgs;

245 pkgs = import sources.nixpkgs nixpkgsArgs;

230 pkgs = import sources.nixpkgs nixpkgsArgs;

246− hlintPlan = /nix/store/kk047cqsjvbj4w8psv4l05abdcnyrqdc-hlint-plan-to-nix-pkgs;

231+ hlintPlan = /nix/store/63k3f8bvsnag7v36vb3149208jyx61rk-hlint-plan-to-nix-pkgs;

247 hlint = pkgs.haskell-nix.hackage-package {

232 hlint = pkgs.haskell-nix.hackage-package {

248− compiler-nix-name = "ghc884";

233+ compiler-nix-name = "ghc8102";

249 name = "hlint";

234 name = "hlint";

250 version = "2.2.11";

235 version = "2.2.11";

251− index-state = "2020-04-15T00:00:00Z";

236+ index-state = "2021-01-04T00:00:00Z";

252− plan-sha256 = "02hasr27a994sml1fzf8swb716lm6lgixxr53y0gxkhw437xkck4";

237+ plan-sha256 = "04hdgqwpaswmyb0ili7fwi6czzihd6x0jlvivw52d1i7wv4gaqy7";

253 materialized = if __pathExists hlintPlan then hlintPlan else null;

238 materialized = if __pathExists hlintPlan then hlintPlan else null;

254 };

239 };

255−in hlint.components.exes.hlint

240+in hlint

256```

241```

257

242

258Running 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.

259

244

260```

245```

261−$ 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

262−trace: Using index-state: 2020-04-15T00:00:00Z for hlint

247+/nix/store/2ybrfmcp79gg75ad4pr1cbxjak70yg8b-hlint-exe-hlint-2.2.11

263−/nix/store/rnfz66v7k8i38c8rsmchzsyqjrmrbdpk-hlint-2.2.11-exe-hlint

264

248

265real 0m4.463s

249real 0m4.463s

266user 0m4.440s

250user 0m4.440s

267sys 0m0.461s

251sys 0m0.461s

268−$ time nix-build hlint.nix

252+$ time nix-build hlint.nix -A components.exes.hlint

269−/nix/store/rnfz66v7k8i38c8rsmchzsyqjrmrbdpk-hlint-2.2.11-exe-hlint

253+/nix/store/2ybrfmcp79gg75ad4pr1cbxjak70yg8b-hlint-exe-hlint-2.2.11

270

254

271real 0m2.206s

255real 0m2.206s

272user 0m1.665s

256user 0m1.665s

docs/tutorials/pkg-map.md+4−4

@@ -3,10 +3,10 @@

3Cabal files may contain dependencies to external non-Haskell

4dependencies via:

5

6−* [`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)

7−* [`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)

8−* [`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)

9−* [`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)

10

11If there is a `pkgs` attribute in Nixpkgs that matches the name given

12in the Cabal file, then it will be added as a dependency (see the

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+135−37

@@ -2,49 +2,147 @@

2 description = "Alternative Haskell Infrastructure for Nixpkgs";

3

4 inputs = {

5− # Note: keep this in sync with sources.json!

5+ nixpkgs.follows = "nixpkgs-unstable";

6− nixpkgs.url = github:NixOS/nixpkgs/f02bf8ffb9a5ec5e8f6f66f1e5544fd2aa1a0693;

6+ nixpkgs-2003 = { url = "github:NixOS/nixpkgs/nixpkgs-20.03-darwin"; };

7− nixpkgs-2003.url = github:NixOS/nixpkgs/7f73e46625f508a793700f5110b86f1a53341d6e;

7+ nixpkgs-2105 = { url = "github:NixOS/nixpkgs/nixpkgs-21.05-darwin"; };

8− nixpkgs-2009.url = github:NixOS/nixpkgs/f02bf8ffb9a5ec5e8f6f66f1e5544fd2aa1a0693;

8+ nixpkgs-2111 = { url = "github:NixOS/nixpkgs/nixpkgs-21.11-darwin"; };

9+ nixpkgs-2205 = { url = "github:NixOS/nixpkgs/nixpkgs-22.05-darwin"; };

9− nixpkgs-unstable.url = github:NixOS/nixpkgs/410bbd828cdc6156aecd5bc91772ad3a6b1099c7;

10+ nixpkgs-unstable = { url = "github:NixOS/nixpkgs/nixpkgs-unstable"; };

11+ flake-utils = { url = "github:numtide/flake-utils"; };

12+ hydra.url = "hydra";

13+ hackage = {

14+ url = "github:input-output-hk/hackage.nix";

15+ flake = false;

16+ };

17+ stackage = {

18+ url = "github:input-output-hk/stackage.nix";

19+ flake = false;

20+ };

21+ cabal-32 = {

22+ url = "github:haskell/cabal/3.2";

23+ flake = false;

24+ };

25+ cabal-34 = {

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+ };

10 };

60 };

11

61

12− outputs = { self, nixpkgs, ... }:

62+ outputs = { self, nixpkgs, nixpkgs-unstable, nixpkgs-2105, nixpkgs-2111, nixpkgs-2205, flake-utils, ... }@inputs:

13− {

63+ let compiler = "ghc924";

14−

15− internal = rec {

16 config = import ./config.nix;

64 config = import ./config.nix;

17− # We can't import ./nix/sources.nix directly, because that uses nixpkgs to fetch by default,

65+ in {

18− # and importing nixpkgs without specifying localSystem doesn't work on flakes.

66+ inherit config;

19− sources = let

67+ overlay = self.overlays.combined;

20− sourcesInfo =

68+ overlays = import ./overlays { sources = inputs; };

21− builtins.fromJSON (builtins.readFile ./nix/sources.json);

69+ internal = rec {

22− fetch = sourceInfo:

70+ nixpkgsArgs = {

23− builtins.fetchTarball { inherit (sourceInfo) url sha256; };

71+ inherit config;

24− in builtins.mapAttrs (_: fetch) sourcesInfo;

72+ overlays = [ self.overlay ];

73+ };

25

74

26− nixpkgsArgs = {

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; });

27− inherit config;

84+ inherit config;

28− overlays = [ self.overlay ];

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+ };

29 };

114 };

30

115

31− overlaysOverrideable = import ./overlays;

116+ # Note: `nix flake check` evaluates outputs for all platforms, and haskell.nix

32− };

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;

33

124

34− # Using the eval-on-build version here as the plan is that

125+ # FIXME: Currently `nix flake check` requires `--impure` because coverage-golden

35− # `builtins.currentSystem` will not be supported in flakes.

126+ # (and maybe other tests) import projects that use builtins.currentSystem

36− # https://github.com/NixOS/rfcs/pull/49/files#diff-a5a138ca225433534de8d260f225fe31R429

127+ checks = builtins.listToAttrs (map (pkg: {

37− overlay = self.overlays.combined-eval-on-build;

128+ name = pkg.name;

38− overlays = self.internal.overlaysOverrideable { sourcesOverride = self.internal.sources; };

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;

39

137

40− legacyPackages = let

138+ devShell = with self.legacyPackages.${system};

41− genAttrs = lst: f:

139+ mkShell {

42− builtins.listToAttrs (map (name: {

140+ buildInputs = [

43− inherit name;

141+ nixUnstable

44− value = f name;

142+ cabal-install

45− }) lst);

143+ haskell-nix.compiler.${compiler}

46− in genAttrs [ "x86_64-linux" "x86_64-darwin" ] (system:

144+ haskell-nix.nix-tools.${compiler}

47− import nixpkgs

145+ ];

48− (self.internal.nixpkgsArgs // { localSystem = { inherit system; }; }));

146+ };

49− };

147+ });

50}

148}

hackage-src.json+4−4

@@ -1,9 +1,9 @@

1{

2 "url": "https://github.com/input-output-hk/hackage.nix",

3− "rev": "48960ebaabc5f7f9433b2ed6d5dea66550f5e99e",

3+ "rev": "9bdefa51c864bbef48a2758b05b4b568f0ded62b",

4− "date": "2021-03-18T01:14:50+00:00",

4+ "date": "2021-08-06T01:11:48+00:00",

5− "path": "/nix/store/1d449n54vzgyw7sljy1f97yk1nign6ih-hackage.nix-48960eb",

5+ "path": "/nix/store/isypgnv4qa5398z6vjc3fi620l4y87c4-hackage.nix-9bdefa5",

6− "sha256": "024nxylwxikmlbwlniigzp3rcxyksjran1xpig2z7ynixpzwb0k7",

6+ "sha256": "0pm3m864wwgf76isjwb8244xh8xykc94b5az6zb1h38q30s9xjji",

7 "fetchSubmodules": false,

8 "deepClone": false,

9 "leaveDotGit": false

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-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.nix+120−14

@@ -74,20 +74,21 @@ let

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− extractRepoData = cabalProjectFileName: lookupSha256: repo:

77+ extractSourceRepoPackageData = cabalProjectFileName: sha256map: repo: {

78− builtins.map (subdir:

79− {

80− url = repo.location;

78+ url = repo.location;

81− ref = repo.tag;

79+ ref = repo.tag;

82− sha256 = repo."--sha256" or (lookupSha256 repo);

80+ sha256 = repo."--sha256" or (

83− inherit subdir;

81+ if sha256map != null

84− })

82+ then sha256map."${repo.location}"."${repo.tag}"

83+ else null);

85− (if repo ? subdir

84+ subdirs = if repo ? subdir

86− then pkgs.lib.filter (x: x != "") (pkgs.lib.splitString " " repo.subdir)

85+ then pkgs.lib.filter (x: x != "") (pkgs.lib.splitString " " repo.subdir)

87− else ["."]);

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.

90− parseBlock = cabalProjectFileName: lookupSha256: block:

91+ parseSourceRepositoryPackageBlock = cabalProjectFileName: sha256map: block:

91 let

92 let

92 x = span (pkgs.lib.strings.hasPrefix " ") (pkgs.lib.splitString "\n" block);

93 x = span (pkgs.lib.strings.hasPrefix " ") (pkgs.lib.splitString "\n" block);

93 attrs = parseBlockLines x.fst;

94 attrs = parseBlockLines x.fst;

@@ -98,10 +99,115 @@ let

98 otherText = "\nsource-repository-package\n" + block;

99 otherText = "\nsource-repository-package\n" + block;

99 }

100 }

100 else {

101 else {

101− sourceRepo = extractRepoData cabalProjectFileName lookupSha256 attrs;

102+ sourceRepo = extractSourceRepoPackageData cabalProjectFileName sha256map attrs;

102 otherText = pkgs.lib.strings.concatStringsSep "\n" x.snd;

103 otherText = pkgs.lib.strings.concatStringsSep "\n" x.snd;

103 };

104 };

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+

105in {

209in {

106− inherit parseIndexState parseBlockLines parseBlock;

210+ inherit parseIndexState parseSourceRepositoryPackages parseRepositories

211+ # These are only exposed for tests

212+ parseSourceRepositoryPackageBlock parseRepositoryBlock;

107}

213}

lib/call-cabal-project-to-nix.nix+159−81

@@ -1,4 +1,4 @@

1−{ dotCabal, pkgs, runCommand, evalPackages, 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

@@ -21,8 +21,6 @@ in

21, caller ? "callCabalProjectToNix" # Name of the calling function for better warning messages

22, ghc ? null # Deprecated in favour of `compiler-nix-name`

23, ghcOverride ? null # Used when we need to set ghc explicitly during bootstrapping

24−, nix-tools ? evalPackages.haskell-nix.nix-tools-unchecked.${compiler-nix-name} # When building cabal projects we use the nix-tools

25−, cabal-install ? evalPackages.haskell-nix.cabal-install-unchecked.${compiler-nix-name} # and cabal-install compiled with matching ghc version

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

@@ -32,17 +30,57 @@ in

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 =

33+ # { # For a `source-repository-package` use the `location` and `tag` as the key

35− # { "https://github.com/jgm/pandoc-citeproc"."0.17"

34+ # "https://github.com/jgm/pandoc-citeproc"."0.17"

36− # = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q"; };

35+ # = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q";

37−, lookupSha256 ?

36+ # # For a `repository` use the `url` as the key

38− if sha256map != null

37+ # "https://raw.githubusercontent.com/input-output-hk/hackage-overlay-ghcjs/bfc363b9f879c360e0a0460ec0c18ec87222ec32"

39− then { location, tag, ...}: sha256map."${location}"."${tag}"

38+ # = "sha256-g9xGgJqYmiczjxjQ5JOiK5KUUps+9+nlNGI/0SpSOpg=";

40− else _: null

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;

41−, extra-hackage-tarballs ? []

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);

47 nameAndSuffix = suffix: if name == null then suffix else name + "-" + suffix;

85 nameAndSuffix = suffix: if name == null then suffix else name + "-" + suffix;

48

86

@@ -76,15 +114,13 @@ let

76 ghc = ghc';

114 ghc = ghc';

77 subDir' = src.origSubDir or "";

115 subDir' = src.origSubDir or "";

78 subDir = pkgs.lib.strings.removePrefix "/" subDir';

116 subDir = pkgs.lib.strings.removePrefix "/" subDir';

79− maybeCleanedSource =

117+

80− if haskellLib.canCleanSource src

81− then (haskellLib.cleanSourceWith {

118+ cleanedSource = haskellLib.cleanSourceWith {

82− name = if name != null then "${name}-root-cabal-files" else "source-root-cabal-files";

119+ name = if name != null then "${name}-root-cabal-files" else "source-root-cabal-files";

83− src = src.origSrc or src;

120+ src = src.origSrc or src;

84− filter = path: type: (!(src ? filter) || src.filter path type) && (

121+ filter = path: type: (!(src ? filter) || src.filter path type) && (

85− type == "directory" ||

122+ type == "directory" ||

86− pkgs.lib.any (i: (pkgs.lib.hasSuffix i path)) [ ".cabal" "package.yaml" ]); })

123+ pkgs.lib.any (i: (pkgs.lib.hasSuffix i path)) [ ".cabal" "package.yaml" ]); };

87− else src.origSrc or src;

88

124

89 # Using origSrcSubDir bypasses any cleanSourceWith so that it will work when

125 # Using origSrcSubDir bypasses any cleanSourceWith so that it will work when

90 # 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

@@ -164,67 +200,104 @@ let

164 builtins.readFile (pkgs.runCommand "hash-path" { preferLocalBuild = true; }

200 builtins.readFile (pkgs.runCommand "hash-path" { preferLocalBuild = true; }

165 "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");

166

202

167− replaceSoureRepos = projectFile:

203+ replaceSourceRepos = projectFile:

168 let

204 let

169− fetchRepo = fetchgit: repoData:

205+ fetchPackageRepo = fetchgit: repoData:

170 let

206 let

171 fetched =

207 fetched =

208+ if inputMap ? "${repoData.url}/${repoData.ref}"

209+ then inputMap."${repoData.url}/${repoData.ref}"

210+ else if inputMap ? ${repoData.url}

211+ then

212+ (if inputMap.${repoData.url}.rev != repoData.ref

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}."

214+ else inputMap.${repoData.url})

172− if repoData.sha256 != null

215+ else if repoData.sha256 != null

173− then fetchgit { inherit (repoData) url sha256; rev = repoData.ref; }

216+ then fetchgit { inherit (repoData) url sha256; rev = repoData.ref; }

174 else

217 else

175 let drv = builtins.fetchGit { inherit (repoData) url ref; };

218 let drv = builtins.fetchGit { inherit (repoData) url ref; };

176 in __trace "WARNING: No sha256 found for source-repository-package ${repoData.url} ${repoData.ref} download may fail in restricted mode (hydra)"

219 in __trace "WARNING: No sha256 found for source-repository-package ${repoData.url} ${repoData.ref} download may fail in restricted mode (hydra)"

177− (__trace "Consider adding `--sha256: ${hashPath drv}` to the ${cabalProjectFileName} file or passing in a lookupSha256 argument"

220+ (__trace "Consider adding `--sha256: ${hashPath drv}` to the ${cabalProjectFileName} file or passing in a sha256map argument"

178 drv);

221 drv);

179− in fetched + (if repoData.subdir == "." then "" else "/" + repoData.subdir);

222+ in {

180−

223+ # Download the source-repository-package commit and add it to a minimal git

181− blocks = pkgs.lib.splitString "\nsource-repository-package\n" ("\n" + projectFile);

224+ # repository that `cabal` will be able to access from a non fixed output derivation.

182− initialText = pkgs.lib.lists.take 1 blocks;

225+ location = evalPackages.runCommand "source-repository-package" {

183− repoBlocks = builtins.map (pkgs.haskell-nix.haskellLib.parseBlock cabalProjectFileName lookupSha256) (pkgs.lib.lists.drop 1 blocks);

226+ nativeBuildInputs = [ evalPackages.rsync evalPackages.gitMinimal ];

184− sourceRepoData = pkgs.lib.lists.concatMap (x: x.sourceRepo) repoBlocks;

227+ } ''

185− otherText = pkgs.evalPackages.writeText "cabal.project" (pkgs.lib.strings.concatStringsSep "\n" (

228+ mkdir $out

186− initialText

229+ rsync -a --prune-empty-dirs "${fetched}/" "$out/"

187− ++ (builtins.map (x: x.otherText) repoBlocks)));

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";

239+ };

240+

241+ # Parse the `source-repository-package` blocks

242+ sourceRepoPackageResult = pkgs.haskell-nix.haskellLib.parseSourceRepositoryPackages

243+ cabalProjectFileName sha256map source-repo-override projectFile;

244+

245+ # Parse the `repository` blocks

246+ repoResult = pkgs.haskell-nix.haskellLib.parseRepositories

247+ evalPackages cabalProjectFileName sha256map inputMap cabal-install nix-tools sourceRepoPackageResult.otherText;

188

248

189 # we need the repository content twice:

249 # we need the repository content twice:

190 # * at eval time (below to build the fixed project file)

250 # * at eval time (below to build the fixed project file)

191− # Here we want to use pkgs.evalPackages.fetchgit, so one can calculate

251+ # Here we want to use evalPackages.fetchgit, so one can calculate

192 # the build plan for any target without a remote builder

252 # the build plan for any target without a remote builder

193 # * at built time (passed out)

253 # * at built time (passed out)

194 # Here we want to use plain pkgs.fetchgit, which is what a builder

254 # Here we want to use plain pkgs.fetchgit, which is what a builder

195 # on the target system would use, so that the derivation is unaffected

255 # on the target system would use, so that the derivation is unaffected

196 # and, say, a linux release build job can identify the derivation

256 # and, say, a linux release build job can identify the derivation

197 # as built by a darwin builder, and fetch it from a cache

257 # as built by a darwin builder, and fetch it from a cache

198− sourceReposBuild = builtins.map (fetchRepo pkgs.evalPackages.fetchgit) sourceRepoData ;

258+ sourceReposEval = builtins.map (fetchPackageRepo evalPackages.fetchgit) sourceRepoPackageResult.sourceRepos;

199− sourceReposEval = builtins.map (fetchRepo pkgs.fetchgit) sourceRepoData;

259+ sourceReposBuild = builtins.map (x: (fetchPackageRepo pkgs.fetchgit x).fetched) sourceRepoPackageResult.sourceRepos;

200 in {

260 in {

201 sourceRepos = sourceReposBuild;

261 sourceRepos = sourceReposBuild;

262+ inherit (repoResult) repos extra-hackages;

202 makeFixedProjectFile = ''

263 makeFixedProjectFile = ''

203− 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) (''

204 chmod +w -R ./cabal.project

267 chmod +w -R ./cabal.project

205 # The newline here is important in case cabal.project does not have one at the end

268 # The newline here is important in case cabal.project does not have one at the end

206− printf "\npackages:" >> ./cabal.project

269+ echo >> ./cabal.project

207− mkdir -p ./.source-repository-packages

208 '' +

270 '' +

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.

209− ( pkgs.lib.strings.concatStrings (

284+ replaceLocations = pkgs.lib.strings.concatStrings (

210 pkgs.lib.lists.zipListsWith (n: f: ''

285 pkgs.lib.lists.zipListsWith (n: f: ''

211− mkdir -p ./.source-repository-packages/${builtins.toString n}

286+ (cd $out${subDir'}

212− rsync -a --prune-empty-dirs \

287+ substituteInPlace $tmp${subDir'}/dist-newstyle/cache/plan.json --replace file://${f.location} ${builtins.toString n}

213− --include '*/' --include '*.cabal' --include 'package.yaml' \

288+ for a in $(grep -rl file://${f.location} .plan.nix/*.nix); do

214− --exclude '*' \

289+ substituteInPlace $a --replace file://${f.location} ${builtins.toString n}

215− "${f}/" "./.source-repository-packages/${builtins.toString n}/"

290+ done)

216− echo " ./.source-repository-packages/${builtins.toString n}" >> ./cabal.project

217 '')

291 '')

218 (pkgs.lib.lists.range 0 ((builtins.length sourceReposEval) - 1))

292 (pkgs.lib.lists.range 0 ((builtins.length sourceReposEval) - 1))

219 sourceReposEval

293 sourceReposEval

220− )

294+ );

221− );

222 };

295 };

223

296

224 fixedProject =

297 fixedProject =

225 if rawCabalProject == null

298 if rawCabalProject == null

226− then { sourceRepos = []; makeFixedProjectFile = ""; }

299+ then { sourceRepos = []; repos = {}; extra-hackages = []; makeFixedProjectFile = ""; replaceLocations = ""; }

227− else replaceSoureRepos rawCabalProject;

300+ else replaceSourceRepos rawCabalProject;

228

301

229 # The use of the actual GHC can cause significant problems:

302 # The use of the actual GHC can cause significant problems:

230 # * 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

@@ -295,12 +368,12 @@ let

295 '');

368 '');

296

369

297 # Dummy `ghc` that uses the captured output

370 # Dummy `ghc` that uses the captured output

298− dummy-ghc = pkgs.evalPackages.writeTextFile {

371+ dummy-ghc = evalPackages.writeTextFile {

299 name = "dummy-" + ghc.name;

372 name = "dummy-" + ghc.name;

300 executable = true;

373 executable = true;

301 destination = "/bin/${ghc.targetPrefix}ghc";

374 destination = "/bin/${ghc.targetPrefix}ghc";

302 text = ''

375 text = ''

303− #!${pkgs.evalPackages.runtimeShell}

376+ #!${evalPackages.runtimeShell}

304 case "$*" in

377 case "$*" in

305 --version*)

378 --version*)

306 cat ${dummy-ghc-data}/ghc/version

379 cat ${dummy-ghc-data}/ghc/version

@@ -338,12 +411,12 @@ let

338 };

411 };

339

412

340 # Dummy `ghc-pkg` that uses the captured output

413 # Dummy `ghc-pkg` that uses the captured output

341− dummy-ghc-pkg = pkgs.evalPackages.writeTextFile {

414+ dummy-ghc-pkg = evalPackages.writeTextFile {

342 name = "dummy-pkg-" + ghc.name;

415 name = "dummy-pkg-" + ghc.name;

343 executable = true;

416 executable = true;

344 destination = "/bin/${ghc.targetPrefix}ghc-pkg";

417 destination = "/bin/${ghc.targetPrefix}ghc-pkg";

345 text = ''

418 text = ''

346− #!${pkgs.evalPackages.runtimeShell}

419+ #!${evalPackages.runtimeShell}

347 case "$*" in

420 case "$*" in

348 --version)

421 --version)

349 cat ${dummy-ghc-data}/ghc-pkg/version

422 cat ${dummy-ghc-data}/ghc-pkg/version

@@ -379,10 +452,10 @@ let

379 else null;

452 else null;

380 } // pkgs.lib.optionalAttrs (checkMaterialization != null) {

453 } // pkgs.lib.optionalAttrs (checkMaterialization != null) {

381 inherit checkMaterialization;

454 inherit checkMaterialization;

382− }) (pkgs.evalPackages.runCommand (nameAndSuffix "plan-to-nix-pkgs") {

455+ }) (evalPackages.runCommand (nameAndSuffix "plan-to-nix-pkgs") {

383− nativeBuildInputs = [ nix-tools dummy-ghc dummy-ghc-pkg cabal-install pkgs.evalPackages.rsync ];

456+ nativeBuildInputs = [ nix-tools dummy-ghc dummy-ghc-pkg cabal-install evalPackages.rsync evalPackages.gitMinimal ];

384 # Needed or stack-to-nix will die on unicode inputs

457 # Needed or stack-to-nix will die on unicode inputs

385− LOCALE_ARCHIVE = pkgs.lib.optionalString (pkgs.evalPackages.stdenv.buildPlatform.libc == "glibc") "${pkgs.evalPackages.glibcLocales}/lib/locale/locale-archive";

458+ LOCALE_ARCHIVE = pkgs.lib.optionalString (evalPackages.stdenv.buildPlatform.libc == "glibc") "${evalPackages.glibcLocales}/lib/locale/locale-archive";

386 LANG = "en_US.UTF-8";

459 LANG = "en_US.UTF-8";

387 meta.platforms = pkgs.lib.platforms.all;

460 meta.platforms = pkgs.lib.platforms.all;

388 preferLocalBuild = false;

461 preferLocalBuild = false;

@@ -404,11 +477,11 @@ let

404 '';

477 '';

405 in {

478 in {

406 # These check for cabal configure failure

479 # These check for cabal configure failure

407− json = pkgs.evalPackages.runCommand (nameAndSuffix "plan-json") {} ''

480+ json = evalPackages.runCommand (nameAndSuffix "plan-json") {} ''

408 ${checkCabalConfigure}

481 ${checkCabalConfigure}

409 cp ${plan-nix.maybeJson} $out

482 cp ${plan-nix.maybeJson} $out

410 '';

483 '';

411− freeze = pkgs.evalPackages.runCommand (nameAndSuffix "plan-freeze") {} ''

484+ freeze = evalPackages.runCommand (nameAndSuffix "plan-freeze") {} ''

412 ${checkCabalConfigure}

485 ${checkCabalConfigure}

413 cp ${plan-nix.maybeFreeze} $out

486 cp ${plan-nix.maybeFreeze} $out

414 '';

487 '';

@@ -416,14 +489,18 @@ let

416 } ''

489 } ''

417 tmp=$(mktemp -d)

490 tmp=$(mktemp -d)

418 cd $tmp

491 cd $tmp

419− # if maybeCleanedSource is empty, this means it's a new

492+ # if cleanedSource is empty, this means it's a new

420 # project where the files haven't been added to the git

493 # project where the files haven't been added to the git

421 # repo yet. We fail early and provide a useful error

494 # repo yet. We fail early and provide a useful error

422 # message to prevent headaches (#290).

495 # message to prevent headaches (#290).

423− if [ -z "$(ls -A ${maybeCleanedSource})" ]; then

496+ if [ -z "$(ls -A ${cleanedSource})" ]; then

424− 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}/* .

425 fi

503 fi

426− cp -r ${maybeCleanedSource}/* .

427 chmod +w -R .

504 chmod +w -R .

428 # Decide what to do for each `package.yaml` file.

505 # Decide what to do for each `package.yaml` file.

429 for hpackFile in $(find . -name package.yaml); do (

506 for hpackFile in $(find . -name package.yaml); do (

@@ -446,15 +523,13 @@ let

446 ${pkgs.lib.optionalString (subDir != "") "cd ${subDir}"}

523 ${pkgs.lib.optionalString (subDir != "") "cd ${subDir}"}

447 ${fixedProject.makeFixedProjectFile}

524 ${fixedProject.makeFixedProjectFile}

448 ${pkgs.lib.optionalString (cabalProjectFreeze != null) ''

525 ${pkgs.lib.optionalString (cabalProjectFreeze != null) ''

449− cp ${pkgs.evalPackages.writeText "cabal.project.freeze" cabalProjectFreeze} \

526+ cp ${evalPackages.writeText "cabal.project.freeze" cabalProjectFreeze} \

450 cabal.project.freeze

527 cabal.project.freeze

451 chmod +w cabal.project.freeze

528 chmod +w cabal.project.freeze

452 ''}

529 ''}

453 export SSL_CERT_FILE=${cacert}/etc/ssl/certs/ca-bundle.crt

530 export SSL_CERT_FILE=${cacert}/etc/ssl/certs/ca-bundle.crt

454 export GIT_SSL_CAINFO=${cacert}/etc/ssl/certs/ca-bundle.crt

531 export GIT_SSL_CAINFO=${cacert}/etc/ssl/certs/ca-bundle.crt

455

532

456− mkdir -p $out

457−

458 # Using `cabal v2-freeze` will configure the project (since

533 # Using `cabal v2-freeze` will configure the project (since

459 # it is not configured yet), taking the existing `cabal.project.freeze`

534 # it is not configured yet), taking the existing `cabal.project.freeze`

460 # file into account. Then it "writes out a freeze file which

535 # file into account. Then it "writes out a freeze file which

@@ -467,15 +542,16 @@ let

467 # which is used by cabal (cached-index-state >= index-state-found).

542 # which is used by cabal (cached-index-state >= index-state-found).

468 dotCabal {

543 dotCabal {

469 inherit cabal-install nix-tools extra-hackage-tarballs;

544 inherit cabal-install nix-tools extra-hackage-tarballs;

545+ extra-hackage-repos = fixedProject.repos;

470 index-state = cached-index-state;

546 index-state = cached-index-state;

471 sha256 = index-sha256-found;

547 sha256 = index-sha256-found;

472 }

548 }

473− } cabal v2-freeze \

549+ } cabal v2-freeze ${

474− --index-state=${

475− # Setting the desired `index-state` here in case it was not

550+ # Setting the desired `index-state` here in case it is not

476− # from the cabal.project file. This will further restrict the

551+ # in the cabal.project file. This will further restrict the

477− # packages used by the solver (cached-index-state >= index-state-found).

552+ # packages used by the solver (cached-index-state >= index-state-found).

478− index-state-found} \

553+ pkgs.lib.optionalString (index-state != null) "--index-state=${index-state}"

554+ } \

479 -w ${

555 -w ${

480 # We are using `-w` rather than `--with-ghc` here to override

556 # We are using `-w` rather than `--with-ghc` here to override

481 # the `with-compiler:` in the `cabal.project` file.

557 # the `with-compiler:` in the `cabal.project` file.

@@ -487,6 +563,8 @@ let

487 "--ghcjs --with-ghcjs=js-unknown-ghcjs-ghc --with-ghcjs-pkg=js-unknown-ghcjs-ghc-pkg"} \

563 "--ghcjs --with-ghcjs=js-unknown-ghcjs-ghc --with-ghcjs-pkg=js-unknown-ghcjs-ghc-pkg"} \

488 ${configureArgs} 2>&1 | tee -a cabal-configure.out); then

564 ${configureArgs} 2>&1 | tee -a cabal-configure.out); then

489

565

566+ mkdir -p $out

567+

490 cp cabal.project.freeze $maybeFreeze

568 cp cabal.project.freeze $maybeFreeze

491 # Not needed any more (we don't want it to wind up in the $out hash)

569 # Not needed any more (we don't want it to wind up in the $out hash)

492 rm cabal.project.freeze

570 rm cabal.project.freeze

@@ -511,16 +589,15 @@ let

511 # proper relative paths.

589 # proper relative paths.

512 (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 .)

513

591

592+ # Replace the /nix/store paths to minimal git repos with indexes (that will work with materialization).

593+ ${fixedProject.replaceLocations}

594+

514 # Make the plan.json file available in case we need to debug plan-to-nix

595 # Make the plan.json file available in case we need to debug plan-to-nix

515 cp $tmp${subDir'}/dist-newstyle/cache/plan.json $maybeJson

596 cp $tmp${subDir'}/dist-newstyle/cache/plan.json $maybeJson

516

597

517 # Remove the non nix files ".project" ".cabal" "package.yaml" files

598 # Remove the non nix files ".project" ".cabal" "package.yaml" files

518 # 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

519 # without affecting the nix).

600 # without affecting the nix).

520− if [ -d $out${subDir'}/.source-repository-packages ]; then

521− chmod +w -R $out${subDir'}/.source-repository-packages

522− rm -rf $out${subDir'}/.source-repository-packages

523− fi

524 find $out $ -type f -or -type l $ ! -name '*.nix' -delete

601 find $out $ -type f -or -type l $ ! -name '*.nix' -delete

525 # Remove empty dirs

602 # Remove empty dirs

526 find $out -type d -empty -delete

603 find $out -type d -empty -delete

@@ -536,19 +613,20 @@ let

536

613

537 # When cabal configure fails copy the output that we captured above and

614 # When cabal configure fails copy the output that we captured above and

538 # use `failed-cabal-configure.nix` to make a suitable derviation with.

615 # use `failed-cabal-configure.nix` to make a suitable derviation with.

616+ mkdir -p $out${subDir'}

539− cp cabal-configure.out $out

617+ cp cabal-configure.out $out${subDir'}

540− cp ${./failed-cabal-configure.nix} $out/default.nix

618+ cp ${./failed-cabal-configure.nix} $out${subDir'}/default.nix

541

619

542 # These should only be used indirectly by `passthru.json` and `passthru.freeze`.

620 # These should only be used indirectly by `passthru.json` and `passthru.freeze`.

543 # Those derivations will check for `cabal-configure.out` out first to see if

621 # Those derivations will check for `cabal-configure.out` out first to see if

544 # it is ok to use these files.

622 # it is ok to use these files.

545− echo "Cabal configure failed see $out/cabal-configure.out for details" > $maybeJson

623+ echo "Cabal configure failed see $out${subDir'}/cabal-configure.out for details" > $maybeJson

546− echo "Cabal configure failed see $out/cabal-configure.out for details" > $maybeFreeze

624+ echo "Cabal configure failed see $out${subDir'}/cabal-configure.out for details" > $maybeFreeze

547 fi

625 fi

548 '');

626 '');

549in {

627in {

550 projectNix = plan-nix;

628 projectNix = plan-nix;

551 index-state = index-state-found;

629 index-state = index-state-found;

552 inherit src;

630 inherit src;

553− inherit (fixedProject) sourceRepos;

631+ inherit (fixedProject) sourceRepos extra-hackages;

554}

632}

lib/call-stack-to-nix.nix+32−18

@@ -5,7 +5,6 @@

5 *

6 * see also `call-cabal-project-to-nix`!

7 */

8−{ runCommand, pkgs, mkCacheFile, materialize, haskellLib }:

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 ? "stack.yaml"

10, stackYaml ? "stack.yaml"

@@ -15,17 +14,28 @@

15, resolverSha256 ? null

14, resolverSha256 ? null

16, materialized ? null # Location of a materialized copy of the nix files

15, materialized ? null # Location of a materialized copy of the nix files

17, checkMaterialization ? null # If true the nix files will be generated used to check plan-sha256 and material

16, checkMaterialization ? null # If true the nix files will be generated used to check plan-sha256 and material

18−, nix-tools ? pkgs.haskell-nix.internal-nix-tools # When building stack projects we use the internal nix-tools (compiled with a fixed GHC version)

17+, nix-tools

18+, evalPackages

19−, ... }:

19+, ... }@args:

20let

21+ inherit (evalPackages) runCommand;

22+ inherit (evalPackages.haskell-nix) mkCacheFile materialize haskellLib;

21 inherit (haskellLib.fetchResolver {

23 inherit (haskellLib.fetchResolver {

22 inherit src stackYaml resolverSha256;

24 inherit src stackYaml resolverSha256;

23 }) resolver fetchedResolver;

25 }) resolver fetchedResolver;

24

26

25 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+

26 stackToNixArgs = builtins.concatStringsSep " " [

36 stackToNixArgs = builtins.concatStringsSep " " [

27 "--full"

37 "--full"

28− "--stack-yaml=$SRC/${stackYaml}"

38+ "--stack-yaml=$SRC${subDir'}/${stackYaml}"

29 (if ignorePackageYaml then "--ignore-package-yaml" else "")

39 (if ignorePackageYaml then "--ignore-package-yaml" else "")

30 "-o ."

40 "-o ."

31 ];

41 ];

@@ -35,35 +45,39 @@ let

35 sha256Arg = "stack-sha256";

45 sha256Arg = "stack-sha256";

36 reasonNotSafe = null;

46 reasonNotSafe = null;

37 this = "project.stack-nix" + (if name != null then " for ${name}" else "");

47 this = "project.stack-nix" + (if name != null then " for ${name}" else "");

38− } // pkgs.lib.optionalAttrs (checkMaterialization != null) {

48+ } // evalPackages.lib.optionalAttrs (checkMaterialization != null) {

39 inherit checkMaterialization;

49 inherit checkMaterialization;

40 }) (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") {

41− nativeBuildInputs = [ nix-tools pkgs.nix-prefetch-git pkgs.cacert pkgs.xorg.lndir ];

51+ nativeBuildInputs = [ nix-tools evalPackages.nix-prefetch-git evalPackages.cacert evalPackages.xorg.lndir ];

42 # Needed or stack-to-nix will die on unicode inputs

52 # Needed or stack-to-nix will die on unicode inputs

43− 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";

44 LANG = "en_US.UTF-8";

54 LANG = "en_US.UTF-8";

45 LC_ALL = "en_US.UTF-8";

55 LC_ALL = "en_US.UTF-8";

46 preferLocalBuild = false;

56 preferLocalBuild = false;

47 } (''

57 } (''

48 mkdir -p $out${subDir'}

58 mkdir -p $out${subDir'}

59+ SRC=$(mktemp -d)

60+ cd $SRC

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}"}

49 ${

70 ${

50− # If no resolver was fetched use the original stack.yaml

71+ # If a resolver was fetched use the it instead of the original stack.yaml

51− if fetchedResolver == null

72+ evalPackages.lib.optionalString (fetchedResolver != null)

52− then ''

53− SRC=${src}

54− ''

55− else

56 # Replace the resolver path in the stack.yaml with the fetched version

73 # Replace the resolver path in the stack.yaml with the fetched version

57 ''

74 ''

58− SRC=$(mktemp -d)

59− cd $SRC

60− lndir -silent "${src}/." $SRC

61 rm ${stackYaml}

75 rm ${stackYaml}

62 cp ${src}/${stackYaml} .

76 cp ${src}/${stackYaml} .

63 chmod +w ${stackYaml}

77 chmod +w ${stackYaml}

64 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

78 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

65 ''}

79 ''}

66− ${pkgs.lib.optionalString (cache != null) ''

80+ ${evalPackages.lib.optionalString (cache != null) ''

67 cp ${mkCacheFile cache}/.stack-to-nix.cache* $out${subDir'}

81 cp ${mkCacheFile cache}/.stack-to-nix.cache* $out${subDir'}

68 ''}

82 ''}

69 (cd $out${subDir'} && stack-to-nix ${stackToNixArgs})

83 (cd $out${subDir'} && stack-to-nix ${stackToNixArgs})

@@ -71,7 +85,7 @@ let

71 # 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

72 # be accessable in restricted mode.

86 # be accessable in restricted mode.

73 for nixf in $(find $out -name "*.nix" -type f); do

87 for nixf in $(find $out -name "*.nix" -type f); do

74− substituteInPlace $nixf --replace "$SRC" "."

88+ substituteInPlace $nixf --replace "$SRC${subDir'}" "."

75 done

89 done

76

90

77 # 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+19−14

@@ -1,4 +1,4 @@

1−{ stdenv, lib, haskellLib, srcOnly }:

1+{ stdenv, lib, haskellLib }:

2drv:

3

4let

@@ -7,13 +7,25 @@ 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 exeName;

30 inherit (drv) identifier config configFiles executableToolDepends cleanSrc env exeName;

19 };

31 };

@@ -22,19 +34,12 @@ in stdenv.mkDerivation ({

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 mkdir $out

42 mkdir $out

31− ${

32− # Change to the source sub directory if there is one.

33− lib.optionalString (drv.srcSubDir or "" != "") ''

34− cd ${lib.removePrefix "/" drv.srcSubDir}

35− ''

36− }

37−

38 runHook preCheck

43 runHook preCheck

39

44

40 ${toString component.testWrapper} ${drv}/bin/${drv.exeName} ${lib.concatStringsSep " " component.testFlags} | tee $out/test-stdout

45 ${toString component.testWrapper} ${drv}/bin/${drv.exeName} ${lib.concatStringsSep " " component.testFlags} | tee $out/test-stdout

lib/clean-cabal-component.nix+2−2

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

1# Use cleanSourceWith to filter just the files needed for a particular

2# component of the package

3−{ lib, cleanSourceWith, canCleanSource }: package: component: componentName: src:

3+{ lib, cleanSourceWith }: package: component: componentName: src:

4let

5 srcStr' = src.origSrc or null;

6 subDir = if src.origSubDir or "" == ""

@@ -56,7 +56,7 @@ let

56 then p

57 else p + "/";

58in

59− if srcStr' == null || package.detailLevel != "FullDetails" || !canCleanSource src

59+ if srcStr' == null || package.detailLevel != "FullDetails"

60 then src

61 else

62 let

lib/clean-git.nix+63−24

@@ -65,9 +65,13 @@ then

65 first_line = head git_content;

66 prefix = "gitdir: ";

67 ok = length git_content == 1 && lib.hasPrefix prefix first_line;

68+ raw_path = remove_prefix prefix first_line;

68 in

69 in

69 if ok

70 if ok

70− then /. + remove_prefix prefix first_line

71+ then

72+ if lib.hasPrefix "/" raw_path

73+ then /. + raw_path

74+ else /. + builtins.toPath (origSrcSubDir + "/" + raw_path)

71 else abort "gitSource.nix: Cannot parse ${origSrcSubDir + "/.git"}";

75 else abort "gitSource.nix: Cannot parse ${origSrcSubDir + "/.git"}";

72 }));

76 }));

73

77

@@ -87,32 +91,37 @@ then

87 gitModulesStr = origSrcSubDir + "/.gitmodules";

91 gitModulesStr = origSrcSubDir + "/.gitmodules";

88 gitModules = builtins.path { name = "gitmodules"; path = gitModulesStr; };

92 gitModules = builtins.path { name = "gitmodules"; path = gitModulesStr; };

89

93

94+ # Files from the git repository related knownSubmoduleDirs.

95+ gitSubmoduleFiles = knownSubmoduleDirs:

96+ let pathsNeeded = map (p: toString (src.origSrcSubDir or src) + "/${p}") (

97+ lib.concatMap (x: all_paren_dirs (x + "/.git")) knownSubmoduleDirs);

90− gitSubmoduleFiles = cleanSourceWith {

98+ in cleanSourceWith {

91− caller = "cleanGit";

99+ caller = "cleanGit";

92− name = (if name == null then "" else name + "-") + "gitSubmoduleFiles";

100+ name = (if name == null then "" else name + "-") + "gitSubmoduleFiles";

93− inherit src;

101+ inherit src;

94− filter = path: type:

102+ filter = path: type:

95− type == "directory" # TODO get sudmodule directories from `.gitmodules`

103+ elem path pathsNeeded

96− # and use that to filter directory tree here

104+ ||

97− ||

98− lib.any (i: (lib.hasSuffix i path)) [

99− "/.git" ".gitmodules" ".git/config" ".git/index" ".git/HEAD" ".git/objects" ".git/refs" ] ||

100− (lib.strings.hasInfix ".git/modules/" path &&

101 lib.any (i: (lib.hasSuffix i path)) [

105 lib.any (i: (lib.hasSuffix i path)) [

106+ ".gitmodules" ".git/config" ".git/index" ".git/HEAD" ".git/objects" ".git/refs" ]

107+ ||

108+ (lib.strings.hasInfix ".git/modules/" path &&

109+ lib.any (i: (lib.hasSuffix i path)) [

102− "config" "index" "HEAD" "objects" "refs" ]);

110+ "config" "index" "HEAD" "objects" "refs" ]);

103− };

111+ };

112+

113+ hasSubmodules = !isWorktree && builtins.pathExists gitModulesStr;

104

114

105 # 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

106 # `git ls-files --recurse-submodules` to give us an accurate list

116 # `git ls-files --recurse-submodules` to give us an accurate list

107 # of all the files in the index.

117 # of all the files in the index.

108− whitelist_file =

118+ whitelist_files = knownSubmoduleDirs:

109− runCommand "git-ls-files" {envVariable = true;} ''

119+ runCommand "git-ls-files" { preferLocalBuild = true; } ''

110 tmp=$(mktemp -d)

120 tmp=$(mktemp -d)

111 cd $tmp

121 cd $tmp

112− ${ lib.optionalString (!isWorktree && builtins.pathExists gitModulesStr) ''

122+ ${ lib.optionalString hasSubmodules ''

113− cp -ra ${gitSubmoduleFiles}/. $tmp

123+ cp -ra ${gitSubmoduleFiles knownSubmoduleDirs}/. $tmp

114 chmod +w -R $tmp

124 chmod +w -R $tmp

115− rm -rf .git

116 ''}

125 ''}

117 cp -r ${gitDir} .git

126 cp -r ${gitDir} .git

118 chmod +w -R .git

127 chmod +w -R .git

@@ -123,10 +132,37 @@ then

123 ${ lib.optionalString (isWorktree && builtins.pathExists gitModulesStr) ''

132 ${ lib.optionalString (isWorktree && builtins.pathExists gitModulesStr) ''

124 cp ${gitModules} ./.gitmodules

133 cp ${gitModules} ./.gitmodules

125 ''}

134 ''}

135+ mkdir $out

136+ ${ lib.optionalString hasSubmodules ''

137+ ${git}/bin/git submodule status --recursive | awk '{ print $2 }' > $out/submoduleDirs

138+ ''}

126− ${git}/bin/git ls-files --recurse-submodules > $out

139+ ${git}/bin/git ls-files --recurse-submodules > $out/files

127 '';

140 '';

128

141

129− 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 [];

130

166

131 all_paren_dirs = p:

167 all_paren_dirs = p:

132 if p == "." || p == "/"

168 if p == "." || p == "/"

@@ -138,13 +174,13 @@ then

138 concatMap (p:

174 concatMap (p:

139 # Using `origSrcSubDir` (if present) makes it possible to cleanGit src that

175 # Using `origSrcSubDir` (if present) makes it possible to cleanGit src that

140 # has already been cleaned with cleanSrcWith.

176 # has already been cleaned with cleanSrcWith.

141− let full_path = src.origSrcSubDir or (toString src) + "/${p}"; in

177+ let full_path = toString (src.origSrcSubDir or src) + "/${p}"; in

142 map (p': { name = p'; value = true; }) (all_paren_dirs full_path)

178 map (p': { name = p'; value = true; }) (all_paren_dirs full_path)

143− ) whitelist

179+ ) whitelist.files

144 );

180 );

145

181

146 # Identify files in the `.git` dir

182 # Identify files in the `.git` dir

147− isGitDirPath = path:

183+ isGitDirPath = path:

148 path == origSrcSubDir + "/.git"

184 path == origSrcSubDir + "/.git"

149 || lib.hasPrefix (origSrcSubDir + "/.git/") path;

185 || lib.hasPrefix (origSrcSubDir + "/.git/") path;

150

186

@@ -155,6 +191,9 @@ then

155 cleanSourceWith {

191 cleanSourceWith {

156 caller = "cleanGit";

192 caller = "cleanGit";

157 inherit name src subDir includeSiblings filter;

193 inherit name src subDir includeSiblings filter;

194+ } // {

195+ # For testing

196+ # inherit whitelist whitelist_set;

158 }

197 }

159

198

160else

199else

lib/clean-source-with.nix+35−8

@@ -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

@@ -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−

117− pathHasContext = builtins.hasContext or (lib.hasPrefix builtins.storeDir);

118−

119− canCleanSource = src:

120− src ? _isLibCleanSourceWithEx

121− || src ? _isLibCleanSourceWith

122− || !(pathHasContext (toString src));

123}

150}

lib/cover-project.nix+44−47

@@ -10,19 +10,12 @@ coverageReports:

10let

11 toBashArray = arr: "(" + (lib.concatStringsSep " " arr) + ")";

12

13− # Create table rows for a project coverage index page that look something like:

13+ # Create a list element for a project coverage index page.

14− #

15− # | Package |

16− # |------------------|

17− # | cardano-shell |

18− # | cardano-launcher |

19− coverageTableRows = coverageReport:

14+ coverageListElement = coverageReport:

20 ''

15 ''

21− <tr>

16+ <li>

22− <td>

23− <a href="${coverageReport.passthru.name}/hpc_index.html">${coverageReport.passthru.name}</href>

17+ <a href="${coverageReport.passthru.name}/hpc_index.html">${coverageReport.passthru.name}</a>

24− </td>

18+ </li>

25− </tr>

26 '';

19 '';

27

20

28 projectIndexHtml = pkgs.writeText "index.html" ''

21 projectIndexHtml = pkgs.writeText "index.html" ''

@@ -31,23 +24,32 @@ let

31 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

24 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

32 </head>

25 </head>

33 <body>

26 <body>

34− <table border="1" width="100%">

27+ <div>

35− <tbody>

28+ WARNING: Modules with no coverage are not included in any of these reports, this is just how HPC works under the hood.

36− <tr>

29+ </div>

30+ <div>

37− <th>Report</th>

31+ <h2>Union Report</h2>

38− </tr>

32+ <p>The following report shows how each module is covered by any test in the project:</p>

39−

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>

40− ${with lib; concatStringsSep "\n" (map coverageTableRows coverageReports)}

43+ ${with lib; concatStringsSep "\n" (map coverageListElement coverageReports)}

41−

44+ </ul>

42− </tbody>

45+ </div>

43− </table>

44 </body>

46 </body>

45 </html>

47 </html>

46 '';

48 '';

47

49

48 ghc = project.pkg-set.config.ghc.package;

50 ghc = project.pkg-set.config.ghc.package;

49

51

50− libs = lib.remove null (map (r: r.library) coverageReports);

52+ libs = lib.unique (lib.concatMap (r: r.mixLibraries) coverageReports);

51

53

52 mixDirs =

54 mixDirs =

53 map

55 map

@@ -56,6 +58,17 @@ let

56

58

57 srcDirs = map (l: l.srcSubDirPath) libs;

59 srcDirs = map (l: l.srcSubDirPath) libs;

58

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+

59in pkgs.runCommand "project-coverage-report"

72in pkgs.runCommand "project-coverage-report"

60 ({ nativeBuildInputs = [ (ghc.buildGHC or ghc) pkgs.buildPackages.zip ];

73 ({ nativeBuildInputs = [ (ghc.buildGHC or ghc) pkgs.buildPackages.zip ];

61 LANG = "en_US.UTF-8";

74 LANG = "en_US.UTF-8";

@@ -124,30 +137,14 @@ in pkgs.runCommand "project-coverage-report"

124 cp -R $report/share/hpc/vanilla/html/* $out/share/hpc/vanilla/html/

137 cp -R $report/share/hpc/vanilla/html/* $out/share/hpc/vanilla/html/

125 '') coverageReports)}

138 '') coverageReports)}

126

139

127− if [ ''${#tixFiles[@]} -ne 0 ]; then

128− # Create tix file with test run information for all packages

129− tixFile="$out/share/hpc/vanilla/tix/all/all.tix"

130− hpcSumCmd=("hpc" "sum" "--union" "--output=$tixFile")

131− hpcSumCmd+=("''${tixFiles[@]}")

132− echo "''${hpcSumCmd[@]}"

133− eval "''${hpcSumCmd[@]}"

134−

135− # Markup a HTML coverage report for the entire project

140+ # Copy out "all" coverage report

136− cp ${projectIndexHtml} $out/share/hpc/vanilla/html/index.html

141+ cp -R ${allCoverageReport}/share/hpc/vanilla/tix/all $out/share/hpc/vanilla/tix

137− echo "report coverage-per-package $out/share/hpc/vanilla/html/index.html" >> $out/nix-support/hydra-build-products

138−

139− local markupOutDir="$out/share/hpc/vanilla/html/all"

142+ cp -R ${allCoverageReport}/share/hpc/vanilla/html/all $out/share/hpc/vanilla/html

140− local srcDirs=${toBashArray srcDirs}

141− local mixDirs=${toBashArray mixDirs}

142− local allMixModules=()

143−

144− mkdir $markupOutDir

145− findModules allMixModules "$out/share/hpc/vanilla/mix/" "*.mix"

146

143

147− markup srcDirs mixDirs allMixModules "$markupOutDir" "$tixFile"

144+ # Markup a HTML coverage summary report for the entire project

145+ cp ${projectIndexHtml} $out/share/hpc/vanilla/html/index.html

148

146

149− echo "report coverage $markupOutDir/hpc_index.html" >> $out/nix-support/hydra-build-products

147+ echo "report coverage $out/share/hpc/vanilla/html/index.html" >> $out/nix-support/hydra-build-products

150− ( cd $out/share/hpc/vanilla/html ; zip -r $out/share/hpc/vanilla/html.zip . )

148+ ( cd $out/share/hpc/vanilla/html ; zip -r $out/share/hpc/vanilla/html.zip . )

151− echo "file zip $out/share/hpc/vanilla/html.zip" >> $out/nix-support/hydra-build-products

149+ echo "file zip $out/share/hpc/vanilla/html.zip" >> $out/nix-support/hydra-build-products

152− fi

153 ''

150 ''

lib/cover.nix+102−69

@@ -1,18 +1,18 @@

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".

1{ stdenv, lib, haskellLib, pkgs }:

4{ stdenv, lib, haskellLib, pkgs }:

2

5

3−# Name of the coverage report, which should be unique

6+# Name of the coverage report, which should be unique.

4{ name

7{ name

5−# Library to check coverage of

6−, library

7−# List of check derivations that generate coverage

8+# List of check derivations that generate coverage.

8−, checks

9+, checks ? []

9−# List of other libraries to include in the coverage report. The

10+# List of libraries to include in the coverage report. If one of the above

10−# default value if just the derivation provided as the `library`

11+# checks generates coverage for a particular library, coverage will only

11−# argument. Use a larger list of libraries if you would like the tests

12+# be included if that library is in this list.

12−# of one local package to generate coverage for another.

13−, mixLibraries ? [library]

13+, mixLibraries ? []

14−# hack for project-less projects

14+# Hack for project-less projects.

15−, ghc ? library.project.pkg-set.config.ghc.package

15+, ghc ? if mixLibraries == [] then null else (lib.head mixLibraries).project.pkg-set.config.ghc.package

16}:

17

18let

@@ -26,7 +26,7 @@ let

26in pkgs.runCommand (name + "-coverage-report")

27 ({nativeBuildInputs = [ (ghc.buildGHC or ghc) pkgs.buildPackages.zip ];

28 passthru = {

29− inherit name library checks;

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

@@ -70,71 +70,105 @@ in pkgs.runCommand (name + "-coverage-report")

70 local -n tixFs=$2

71 local outFile="$3"

72

73+ if (( "''${#tixFs[@]}" > 0 )); then

73− local hpcSumCmd=("hpc" "sum" "--union" "--output=$outFile")

74+ local hpcSumCmd=("hpc" "sum" "--union" "--output=$outFile")

74

75

75− for module in "''${includedModules[@]}"; do

76+ for module in "''${includedModules[@]}"; do

76− hpcSumCmd+=("--include=$module")

77+ hpcSumCmd+=("--include=$module")

77− done

78+ done

78

79

79− for tixFile in "''${tixFs[@]}"; do

80+ for tixFile in "''${tixFs[@]}"; do

80− hpcSumCmd+=("$tixFile")

81+ hpcSumCmd+=("$tixFile")

81− done

82+ done

82

83

83− echo "''${hpcSumCmd[@]}"

84+ echo "''${hpcSumCmd[@]}"

84− eval "''${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

85 }

92 }

86

93

87 function findModules() {

94 function findModules() {

88− local searchDir=$2

95+ local -n result=$1

96+ local -n searchDirs=$2

89 local pattern=$3

97 local pattern=$3

90

98

99+ for dir in "''${searchDirs[@]}"; do

91− pushd $searchDir

100+ pushd $dir

101+ local temp=()

92− mapfile -d $'\0' $1 < <(find ./ -type f \

102+ mapfile -d $'\0' temp < <(find ./ -type f \

93− -wholename "$pattern" -not -name "Paths*" \

103+ -wholename "$pattern" -not -name "Paths*" \

94− -exec basename {} \; \

104+ -exec basename {} \; \

95− | sed "s/\.mix$//" \

105+ | sed "s/\.mix$//" \

96− | tr "\n" "\0")

106+ | tr "\n" "\0")

107+ result+=("''${temp[@]}")

97− popd

108+ popd

109+ done

98 }

110 }

99

111

100− local mixDirs=${toBashArray mixDirs}

101−

102 mkdir -p $out/nix-support

112 mkdir -p $out/nix-support

103− mkdir -p $out/share/hpc/vanilla/mix/${name}

113+ mkdir -p $out/share/hpc/vanilla/mix/

104 mkdir -p $out/share/hpc/vanilla/tix/${name}

114 mkdir -p $out/share/hpc/vanilla/tix/${name}

105 mkdir -p $out/share/hpc/vanilla/html/${name}

115 mkdir -p $out/share/hpc/vanilla/html/${name}

106

116

117+ local srcDirs=${toBashArray srcDirs}

118+ local mixDirs=${toBashArray mixDirs}

119+

107− # Copy over mix files verbatim

120+ # Copy out mix files used for this report

108 for dir in "''${mixDirs[@]}"; do

121 for dir in "''${mixDirs[@]}"; do

109 if [ -d "$dir" ]; then

122 if [ -d "$dir" ]; then

110− cp -R "$dir"/* $out/share/hpc/vanilla/mix/${name}

123+ cp -R "$dir" $out/share/hpc/vanilla/mix/

111 fi

124 fi

112 done

125 done

113

126

114− local srcDirs=${toBashArray srcDirs}

127+ local mixModules=()

115− local allMixModules=()

128+ # Mix modules for all packages in "mixLibraries"

116− local pkgMixModules=()

129+ findModules mixModules mixDirs "*.mix"

117−

130+

118− # The behaviour of stack coverage reports is to provide tix files

131+ # We need to make a distinction between library "exposed-modules" and

119− # that include coverage information for every local package, but

132+ # "other-modules" used in test suites:

120− # to provide HTML reports that only include coverage info for the

133+ # - "exposed-modules" are addressed as "$library-$version-$hash/module"

121− # current package. We emulate the same behaviour here. If the user

134+ # - "other-modules" are addressed as "module"

122− # includes all local packages in the mix libraries argument, they

135+ #

123− # will get a coverage report very similar to stack.

136+ # This complicates the code required to find the mix modules. For a given mix directory:

124−

137+ #

125− # All mix modules

138+ # mix

126− findModules allMixModules "$out/share/hpc/vanilla/mix/${name}" "*.mix"

139+ # └── ntp-client-0.0.1

127− # Only mix modules corresponding to this package

140+ # └── ntp-client-0.0.1-gYjRsBHUCaHX7ENcjHnw5

128− findModules pkgMixModules "$out/share/hpc/vanilla/mix/${name}" "*${name}*/*.mix"

141+ # ├── Network.NTP.Client.mix

129−

142+ # ├── Network.NTP.Client.Packet.mix

130− # For each test

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+

131 local tixFiles=()

165 local tixFiles=()

132 ${lib.concatStringsSep "\n" (builtins.map (check: ''

166 ${lib.concatStringsSep "\n" (builtins.map (check: ''

133 if [ -d "${check}/share/hpc/vanilla/tix" ]; then

167 if [ -d "${check}/share/hpc/vanilla/tix" ]; then

134 pushd ${check}/share/hpc/vanilla/tix

168 pushd ${check}/share/hpc/vanilla/tix

135

169

136 tixFile="$(find . -iwholename "*.tix" -type f -print -quit)"

170 tixFile="$(find . -iwholename "*.tix" -type f -print -quit)"

137− local newTixFile=$out/share/hpc/vanilla/tix/${name}/"$tixFile"

171+ local newTixFile=$out/share/hpc/vanilla/tix/${check.name}/"$(basename $tixFile)"

138

172

139 mkdir -p "$(dirname $newTixFile)"

173 mkdir -p "$(dirname $newTixFile)"

140 # Copy over the tix file verbatim

174 # Copy over the tix file verbatim

@@ -143,29 +177,28 @@ in pkgs.runCommand (name + "-coverage-report")

143 # Add the tix file to our list

177 # Add the tix file to our list

144 tixFiles+=("$newTixFile")

178 tixFiles+=("$newTixFile")

145

179

146− # Create a coverage report for *just that test*

180+ # Create a coverage report for *just that check* affecting any of the

181+ # "mixLibraries"

147− markup srcDirs mixDirs pkgMixModules "$out/share/hpc/vanilla/html/${name}/${check.exeName}/" "$newTixFile"

182+ markup srcDirs mixDirs mixModules "$out/share/hpc/vanilla/html/${check.name}/" "$newTixFile"

148

183

149 popd

184 popd

150 fi

185 fi

151 '') checks)

186 '') checks)

152 }

187 }

153

188

154− # Sum tix files to create a tix file with all relevant tix

189+ # Sum tix files to create a tix file with tix information from all tests in

155− # information and markup a HTML report from this info.

190+ # the package and markup a HTML report from this info.

156− if (( "''${#tixFiles[@]}" > 0 )); then

157− local sumTixFile="$out/share/hpc/vanilla/tix/${name}/${name}.tix"

191+ local sumTixFile="$out/share/hpc/vanilla/tix/${name}/${name}.tix"

158− local markupOutDir="$out/share/hpc/vanilla/html/${name}"

192+ local markupOutDir="$out/share/hpc/vanilla/html/${name}"

159

193

160− # Sum all of our tix file, including modules from any local package

194+ # Sum all of our tix files

161− sumTix allMixModules tixFiles "$sumTixFile"

195+ sumTix mixModules tixFiles "$sumTixFile"

162

196

163− # Markup a HTML report, included modules from only this package

197+ # Markup a HTML report

164− markup srcDirs mixDirs pkgMixModules "$markupOutDir" "$sumTixFile"

198+ markup srcDirs mixDirs mixModules "$markupOutDir" "$sumTixFile"

165

199

166− # Provide a HTML zipfile and Hydra links

200+ # Provide a HTML zipfile and Hydra links

167− ( cd "$markupOutDir" ; zip -r $out/share/hpc/vanilla/${name}-html.zip . )

201+ ( cd "$markupOutDir" ; zip -r $out/share/hpc/vanilla/${name}-html.zip . )

168− echo "report coverage $markupOutDir/hpc_index.html" >> $out/nix-support/hydra-build-products

202+ echo "report coverage $markupOutDir/hpc_index.html" >> $out/nix-support/hydra-build-products

169− echo "file zip $out/share/hpc/vanilla/${name}-html.zip" >> $out/nix-support/hydra-build-products

203+ echo "file zip $out/share/hpc/vanilla/${name}-html.zip" >> $out/nix-support/hydra-build-products

170− fi

171 ''

204 ''

lib/default.nix+60−50

@@ -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

@@ -73,8 +70,12 @@ in {

73 comps = config.components;

70 comps = config.components;

74 applyLibrary = cname: f { cname = config.package.identifier.name; ctype = "lib"; };

71 applyLibrary = cname: f { cname = config.package.identifier.name; ctype = "lib"; };

75 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}."); };

73+ isBuildable = comp:

74+ config.package.buildable # Set manually in a module (allows whole packages to be disabled)

75+ && comp.buildable # Set based on `buildable` in `.cabal` files

76+ && comp.planned; # Set if the component was in the `plan.json`

76− buildableAttrs = lib.filterAttrs (n: comp: comp.buildable or true);

77+ buildableAttrs = lib.filterAttrs (n: isBuildable);

77− libComp = if comps.library == null || !(comps.library.buildable or true)

78+ libComp = if comps.library == null || !(isBuildable comps.library)

78 then {}

79 then {}

79 else lib.mapAttrs applyLibrary (removeAttrs comps (subComponentTypes ++ [ "setup" ]));

80 else lib.mapAttrs applyLibrary (removeAttrs comps (subComponentTypes ++ [ "setup" ]));

80 subComps = lib.mapAttrs

81 subComps = lib.mapAttrs

@@ -132,14 +133,7 @@ in {

132 ## flatLibDepends :: Component -> [Package]

133 ## flatLibDepends :: Component -> [Package]

133 flatLibDepends = component:

134 flatLibDepends = component:

134 let

135 let

135− # this is a minor improvement over the "cannot coerce set to string"

136− # error. It will now say:

137− #

138− # > The option `packages.Win32.package.identifier.name' is used but not defined.

139− #

140− # which indicates that the package.Win32 is missing and not defined.

141− getKey = x: if x ? "outPath" then "${x}" else (throw x.identifier.name);

142− makePairs = map (p: rec { key=getKey val; val=(p.components.library or p); });

136+ makePairs = map (p: rec { key=val.name; val=(p.components.library or p); });

143 closure = builtins.genericClosure {

137 closure = builtins.genericClosure {

144 startSet = makePairs component.depends;

138 startSet = makePairs component.depends;

145 operator = {val,...}: makePairs val.config.depends;

139 operator = {val,...}: makePairs val.config.depends;

@@ -195,17 +189,17 @@ in {

195 collectChecks' = collectChecks (_: true);

189 collectChecks' = collectChecks (_: true);

196

190

197 # Replacement for lib.cleanSourceWith that has a subDir argument.

191 # Replacement for lib.cleanSourceWith that has a subDir argument.

198− inherit (import ./clean-source-with.nix { inherit lib; }) cleanSourceWith canCleanSource;

192+ inherit (import ./clean-source-with.nix { inherit lib; }) cleanSourceWith;

199

193

200 # Use cleanSourceWith to filter just the files needed for a particular

194 # Use cleanSourceWith to filter just the files needed for a particular

201 # component of a package

195 # component of a package

202− cleanCabalComponent = import ./clean-cabal-component.nix { inherit lib cleanSourceWith canCleanSource; };

196+ cleanCabalComponent = import ./clean-cabal-component.nix { inherit lib cleanSourceWith; };

203

197

204 # Clean git directory based on `git ls-files --recurse-submodules`

198 # Clean git directory based on `git ls-files --recurse-submodules`

205 cleanGit = import ./clean-git.nix {

199 cleanGit = import ./clean-git.nix {

206 inherit lib cleanSourceWith;

200 inherit lib cleanSourceWith;

207 git = gitMinimal;

201 git = gitMinimal;

208− inherit (pkgs.evalPackages) runCommand;

202+ inherit (pkgs.buildPackages.buildPackages) runCommand;

209 };

203 };

210

204

211 # 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

@@ -235,7 +229,7 @@ in {

235

229

236 # Check a test component

230 # Check a test component

237 check = import ./check.nix {

231 check = import ./check.nix {

238− inherit stdenv lib haskellLib srcOnly;

232+ inherit stdenv lib haskellLib;

239 };

233 };

240

234

241 # Do coverage of a package

235 # Do coverage of a package

@@ -254,31 +248,33 @@ in {

254 # 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.

255 # For instance when building ghc we want to include ghci.

249 # For instance when building ghc we want to include ghci.

256 isCrossHost = stdenv.hostPlatform != stdenv.buildPlatform

250 isCrossHost = stdenv.hostPlatform != stdenv.buildPlatform

257− && !(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);

258 # 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

259 isCrossTarget = stdenv.targetPlatform != stdenv.hostPlatform

253 isCrossTarget = stdenv.targetPlatform != stdenv.hostPlatform

260− && !(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);

261 # Native musl build-host-target combo

255 # Native musl build-host-target combo

262 isNativeMusl = stdenv.hostPlatform.isMusl

256 isNativeMusl = stdenv.hostPlatform.isMusl

263 && stdenv.buildPlatform == stdenv.hostPlatform

257 && stdenv.buildPlatform == stdenv.hostPlatform

264 && stdenv.hostPlatform == stdenv.targetPlatform;

258 && stdenv.hostPlatform == stdenv.targetPlatform;

265

259

266− # Takes a version number or attr set of arguments (for cabalProject)

260+ # Takes a version number, module or list of modules (for cabalProject)

267− # and converts it to an attr set of arguments. This allows

261+ # and converts it to an list of project modules. This allows

268 # 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"; ... }

269− versionOrArgsToArgs = versionOrArgs:

263+ versionOrModToMods = versionOrMod:

270− if lib.isAttrs versionOrArgs

264+ if lib.isString versionOrMod

271− then versionOrArgs

265+ then [{ version = versionOrMod; }]

272− else { version = versionOrArgs; };

266+ else if lib.isList versionOrMod

267+ then versionOrMod

268+ else [versionOrMod];

273

269

274 # Find the resolver in the stack.yaml file and fetch it if a sha256 value is provided

270 # Find the resolver in the stack.yaml file and fetch it if a sha256 value is provided

275 fetchResolver = import ./fetch-resolver.nix {

271 fetchResolver = import ./fetch-resolver.nix {

276− inherit (pkgs.evalPackages) pkgs;

272+ inherit (pkgs.buildPackages) pkgs;

277 };

273 };

278

274

279 inherit (import ./cabal-project-parser.nix {

275 inherit (import ./cabal-project-parser.nix {

280 inherit pkgs;

276 inherit pkgs;

281− }) parseIndexState parseBlock;

277+ }) parseIndexState parseSourceRepositoryPackages parseRepositories parseSourceRepositoryPackageBlock parseRepositoryBlock;

282

278

283

279

284 cabalToNixpkgsLicense = import ./spdx/cabal.nix pkgs;

280 cabalToNixpkgsLicense = import ./spdx/cabal.nix pkgs;

@@ -293,26 +289,9 @@ in {

293 if subDir == ""

289 if subDir == ""

294 then src

290 then src

295 else

291 else

296− if haskellLib.canCleanSource src

297− then haskellLib.cleanSourceWith {

292+ haskellLib.cleanSourceWith {

298− inherit src subDir includeSiblings;

293+ inherit src subDir includeSiblings;

299− }

300− else let name = src.name or "source" + "-" + __replaceStrings ["/"] ["-"] subDir;

301− in if includeSiblings

302− then rec {

303− # Keep `src.origSrc` so it can be used to allow references

304− # to other parts of that root.

305− inherit name;

306− origSrc = src.origSrc or src;

307− origSubDir = src.origSubDir or "" + "/" + subDir;

308− outPath = origSrc + origSubDir;

309− }

310− else {

311− # We are not going to need other parts of `origSrc` if there

312− # was one and we can ignore it

313− inherit name;

314− outPath = src + "/" + subDir;

315− };

294+ };

316

295

317 # Givin a `src` split it into a `root` path (based on `src.origSrc` if

296 # Givin a `src` split it into a `root` path (based on `src.origSrc` if

318 # present) and `subDir` (based on `src.origSubDir). The

297 # present) and `subDir` (based on `src.origSubDir). The

@@ -333,4 +312,35 @@ in {

333 }

312 }

334 else src.origSrc or src; # If there is a subDir and origSrc (but no filter) use origSrc

313 else src.origSrc or src; # If there is a subDir and origSrc (but no filter) use origSrc

335 };

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+ };

336}

346}

lib/fetch-resolver.nix+6−2

@@ -5,10 +5,12 @@

5, resolverSha256 ? null

6}:

7let

8+ srcDir = src.origSrcSubDir or src;

9+

8 # Using origSrcSubDir bypasses any cleanSourceWith so that it will work when

10 # Using origSrcSubDir bypasses any cleanSourceWith so that it will work when

9 # access to the store is restricted. If origSrc was already in the store

11 # access to the store is restricted. If origSrc was already in the store

10 # you can pass the project in as a string.

12 # you can pass the project in as a string.

11− rawStackYaml = builtins.readFile ((src.origSrcSubDir or src) + ("/" + stackYaml));

13+ rawStackYaml = builtins.readFile (srcDir + "/${stackYaml}");

12

14

13 # Determine the resolver as it may point to another file we need

15 # Determine the resolver as it may point to another file we need

14 # to look at.

16 # to look at.

@@ -28,6 +30,8 @@ let

28 url = resolver;

30 url = resolver;

29 sha256 = resolverSha256;

31 sha256 = resolverSha256;

30 }

32 }

33+ else if resolver != null && __pathExists (srcDir + "/${resolver}")

34+ then pkgs.copyPathToStore (srcDir + "/${resolver}")

31− else null;

35+ else null;

32

36

33in { inherit resolver fetchedResolver; }

37in { inherit resolver fetchedResolver; }

lib/ghcjs-project.nix+68−17

@@ -23,7 +23,7 @@

23{ src

24, compiler-nix-name

25, ghc ? pkgs.buildPackages.haskell-nix.compiler.${compiler-nix-name}

26−, ghcjsVersion

26+, ghcjsVersion # Version in the ghcjs.cabal file (that we will replace)

27, ghcVersion ? ghc.version

28, happy ? pkgs.haskell-nix.tool compiler-nix-name "happy" {

29 index-state = pkgs.haskell-nix.internalHackageIndexState;

@@ -35,7 +35,14 @@

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+ }

38−, cabal-install ? pkgs.haskell-nix.tool compiler-nix-name "cabal" {

45+ else pkgs.haskell-nix.tool compiler-nix-name "cabal" {

39 index-state = pkgs.haskell-nix.internalHackageIndexState;

46 index-state = pkgs.haskell-nix.internalHackageIndexState;

40 version = "3.2.0.0";

47 version = "3.2.0.0";

41 # Cabal 3.2.1.0 no longer supports he mix of `cabal-version`,

48 # Cabal 3.2.1.0 no longer supports he mix of `cabal-version`,

@@ -45,10 +52,13 @@

45 '';

52 '';

46 materialized = ../materialized/ghcjs/cabal + "/${compiler-nix-name}";

53 materialized = ../materialized/ghcjs/cabal + "/${compiler-nix-name}";

47 }

54 }

55+, overrideBootPackages ? []

56+, patches ? []

48, ...

57, ...

49}@args:

58}@args:

50let

59let

51− isGhcjs88 = builtins.compareVersions ghcjsVersion "8.8.0.0" > 0;

60+ isGhcjs88 = builtins.compareVersions ghcjsVersion "8.8.0.0" >= 0;

61+ isGhcjs810 = builtins.compareVersions ghcjsVersion "8.10.0.0" >= 0;

52

62

53 # Inputs needed to configure the GHCJS source tree

63 # Inputs needed to configure the GHCJS source tree

54 configureInputs = with pkgs; [

64 configureInputs = with pkgs; [

@@ -67,7 +77,11 @@ let

67

77

68 # Inputs needed to boot the GHCJS compiler

78 # Inputs needed to boot the GHCJS compiler

69 bootInputs = with pkgs.buildPackages; [

79 bootInputs = with pkgs.buildPackages; [

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.

70− nodejs

84+ nodejs-18_x

71 makeWrapper

85 makeWrapper

72 xorg.lndir

86 xorg.lndir

73 gmp

87 gmp

@@ -75,9 +89,9 @@ let

75 ]

89 ]

76 ++ [ ghc cabal-install emsdk ];

90 ++ [ ghc cabal-install emsdk ];

77 # Configured the GHCJS source

91 # Configured the GHCJS source

78− configured-src = pkgs.runCommand "configured-ghcjs-src" {

92+ configured-src = (pkgs.runCommandCC "configured-ghcjs-src" {

79 buildInputs = configureInputs;

93 buildInputs = configureInputs;

80− inherit src;

94+ inherit src patches;

81 } ''

95 } ''

82 export HOME=$(pwd)

96 export HOME=$(pwd)

83 mkdir $HOME/.cabal

97 mkdir $HOME/.cabal

@@ -86,6 +100,11 @@ let

86 chmod -R +w "$out"

100 chmod -R +w "$out"

87 cd "$out"

101 cd "$out"

88

102

103+ for p in $patches

104+ do

105+ patch -p1 <$p

106+ done

107+

89 # TODO: Find a better way to avoid impure version numbers

108 # TODO: Find a better way to avoid impure version numbers

90 sed -i 's/RELEASE=NO/RELEASE=YES/' ghc/configure.ac

109 sed -i 's/RELEASE=NO/RELEASE=YES/' ghc/configure.ac

91 sed -i 's/${ghcjsVersion}/${ghcVersion}/' ghcjs.cabal

110 sed -i 's/${ghcjsVersion}/${ghcVersion}/' ghcjs.cabal

@@ -103,26 +122,58 @@ let

103 rm -rf utils/pkg-cache/ghc

122 rm -rf utils/pkg-cache/ghc

104 cp -r ${ghc.generated} utils/pkg-cache/ghc

123 cp -r ${ghc.generated} utils/pkg-cache/ghc

105

124

106− cp ${../overlays/patches/config.sub} ghc/libraries/integer-gmp/config.sub

125+ for a in integer-gmp base unix; do

107− cp ${../overlays/patches/config.sub} ghc/libraries/base/config.sub

126+ cp ${../overlays/patches/config.sub} ghc/libraries/$a/config.sub

108− cp ${../overlays/patches/config.sub} ghc/libraries/unix/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

109

132

110 patchShebangs .

133 patchShebangs .

111 sed -i 's/gcc /cc /g' utils/makePackages.sh

134 sed -i 's/gcc /cc /g' utils/makePackages.sh

112 ./utils/makePackages.sh copy

135 ./utils/makePackages.sh copy

113

136

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+ }

153+

154+ chmod -R +w $out/lib/boot/pkg

155+ '') // {

156+ # The configured source includes /nix/store paths and so filtering can fail.

157+ filterPath = { path, ... }: path;

114− '';

158+ };

115 # 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.

116

160

117 ghcjsProject = pkgs.haskell-nix.cabalProject' (

161 ghcjsProject = pkgs.haskell-nix.cabalProject' (

118− (pkgs.lib.filterAttrs

162+ (pkgs.lib.filterAttrs

119 (n: _: !(builtins.any (x: x == n)

163 (n: _: !(builtins.any (x: x == n)

120− ["src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"])) args) // {

164+ [ "src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"

165+ "overrideBootPackages" "patches"])) args) // {

121 src = configured-src;

166 src = configured-src;

122− index-state = "2020-11-16T00:00:00Z";

167+ index-state = "2021-03-20T00:00:00Z";

123− compiler-nix-name = if isGhcjs88 then "ghc884" else "ghc865";

168+ inherit compiler-nix-name;

124− configureArgs = pkgs.lib.optionalString isGhcjs88 "--constraint='Cabal >=3.0.2.0 && <3.1'";

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+ });

125− materialized = ../materialized + (if isGhcjs88 then "/ghcjs884" else "/ghcjs865");

176+ materialized = ../materialized + "/ghcjs/${compiler-nix-name}";

126 modules = [

177 modules = [

127 {

178 {

128 # we need ghc-boot in here for ghcjs.

179 # we need ghc-boot in here for ghcjs.

@@ -135,6 +186,7 @@ let

135 packages.Cabal.patches = [ ./../overlays/patches/Cabal/fix-data-dir.patch ];

186 packages.Cabal.patches = [ ./../overlays/patches/Cabal/fix-data-dir.patch ];

136 })

187 })

137 {

188 {

189+ ghcOptions = ["-O2"];

138 packages.ghcjs.doHaddock = false;

190 packages.ghcjs.doHaddock = false;

139 packages.haddock-ghcjs.doHaddock = false;

191 packages.haddock-ghcjs.doHaddock = false;

140 packages.haddock-api-ghcjs.doHaddock = false;

192 packages.haddock-api-ghcjs.doHaddock = false;

@@ -164,4 +216,3 @@ in ghcjsProject // {

164 };

216 };

165 inherit configureInputs bootInputs configured-src emscriptenupstream emscripten emsdk;

217 inherit configureInputs bootInputs configured-src emscriptenupstream emscripten emsdk;

166}

218}

167−

lib/import-and-filter-project.nix+15−21

@@ -6,14 +6,11 @@

6let

7 # Full source including possible relative paths form the

8 # project directory.

9− srcRoot =

10− if haskellLib.canCleanSource src

11− then haskellLib.cleanSourceWith {

9+ srcRoot = haskellLib.cleanSourceWith {

12− name = if src ? name then "${src.name}-root" else "source-root";

10+ name = if src ? name then "${src.name}-root" else "source-root";

13− src = src.origSrc or src;

11+ src = src.origSrc or src;

14− filter = src.filter or (_: _: true);

12+ filter = src.filter or (_: _: true);

15− }

13+ };

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 /

@@ -27,31 +24,28 @@ in project // {

27 else {...}@args: with pkgs.lib.strings;

24 else {...}@args: with pkgs.lib.strings;

28 let

25 let

29 oldPkg = import value args;

26 oldPkg = import value args;

30− # When the package src is in the project dir, this is the subDir it is in.

31− subDir = removePrefix "/" (removePrefix (toString projectNix)

32− (toString oldPkg.src.content));

33− srcRepoPrefix = projectSubDir'' + ".source-repository-packages/";

34−

35 packageInfo =

27 packageInfo =

36− if !hasPrefix (toString projectNix) (toString oldPkg.src.content)

28+ if oldPkg.src ? url

37 then {

29 then {

38− # Source location does not match project prefix

30+ # The source is from a source-repository-package in a cabal.project file

31+ # and lib/call-cabal-project-to-nix.nix should have replaced the url with

32+ # an index into the sourceRepos list.

39 isProject = false;

33 isProject = false;

40− packageSrc = toString oldPkg.src.content;

34+ packageSrc = pkgs.lib.lists.elemAt sourceRepos (toInt oldPkg.src.url);

41 }

35 }

42− else if hasPrefix srcRepoPrefix subDir

36+ else if !hasPrefix "${projectNix}" (toString oldPkg.src.content)

43 then {

37 then {

44− # The source is from a source repository

38+ # Source location does not match project prefix

45 isProject = false;

39 isProject = false;

46− packageSrc = pkgs.lib.lists.elemAt sourceRepos (

40+ packageSrc = toString oldPkg.src.content;

47− toInt (removePrefix srcRepoPrefix subDir));

48 }

41 }

49 else {

42 else {

50 # Source does match project prefix and it is not from a source repository

43 # Source does match project prefix and it is not from a source repository

51 isProject = true;

44 isProject = true;

52 packageSrc = haskellLib.appendSubDir {

45 packageSrc = haskellLib.appendSubDir {

53 src = srcRoot;

46 src = srcRoot;

54− inherit subDir;

47+ subDir = removePrefix "/" (removePrefix "${projectNix}"

48+ (toString oldPkg.src.content));

55 includeSiblings = true; # Filtering sibling dirs of the package dir is done in the

49 includeSiblings = true; # Filtering sibling dirs of the package dir is done in the

56 # component builder so that relative paths can be used to

50 # component builder so that relative paths can be used to

57 # reference project directories not in the package subDir.

51 # reference project directories not in the package subDir.

lib/materialize.nix+12−10

@@ -24,7 +24,7 @@

24}: derivation:

25

26let

27− inherit (derivation) name;

27+ name = derivation.name + pkgs.lib.optionalString (derivation ? version) "-${derivation.version}";

28

29 traceIgnoringSha256 = reason: x:

30 if sha256 != null

@@ -36,10 +36,15 @@ let

36 then builtins.trace ("Warning: ignoring materialized for " + name + " " + reason) x

37 else x;

38

39+ traceWhenChecking = message: x:

40+ if checkMaterialization

41+ then builtins.trace message x

42+ else x;

43+

39 unchecked =

44 unchecked =

40 let

45 let

41− sha256message = "To make ${this} a fixed-output derivation but not materialized, set `${sha256Arg}` to the output of the 'calculateMaterializedSha' script in 'passthru'.";

46+ sha256message = "${name}: To make ${this} a fixed-output derivation but not materialized, set `${sha256Arg}` to the output of the 'calculateMaterializedSha' script in 'passthru'.";

42− materializeMessage = "To materialize ${this} entirely, pass a writable path as the `materialized` argument and run the 'updateMaterialized' script in 'passthru'.";

47+ materializeMessage = "${name}: To materialize ${this} entirely, pass a writable path as the `materialized` argument and run the 'updateMaterialized' script in 'passthru'.";

43 in if reasonNotSafe != null

48 in if reasonNotSafe != null

44 then

49 then

45 # 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

@@ -50,10 +55,10 @@ let

50 else if sha256 != null

55 else if sha256 != null

51 then

56 then

52 # Let the user know how to materialize if they want to.

57 # Let the user know how to materialize if they want to.

53− builtins.trace materializeMessage calculateUseHash

58+ traceWhenChecking materializeMessage calculateUseHash

54 else # materialized == null && sha256 == null

59 else # materialized == null && sha256 == null

55 # 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.

56− builtins.trace sha256message (builtins.trace materializeMessage calculateNoHash);

61+ traceWhenChecking sha256message (traceWhenChecking materializeMessage calculateNoHash);

57

62

58 # Build fully and check the hash and materialized versions

63 # Build fully and check the hash and materialized versions

59 checked =

64 checked =

@@ -123,11 +128,7 @@ let

123 calculateUseMaterialized =

128 calculateUseMaterialized =

124 assert materialized != null;

129 assert materialized != null;

125 assert __pathExists materialized;

130 assert __pathExists materialized;

126− runCommand name (pkgs.lib.optionalAttrs (sha256 == null) hashArgs) ''

127− cp -Lr ${materialized} $out

131+ { outPath = materialized; inherit name; };

128− # Make sure output files can be removed from the sandbox

129− chmod -R +w $out

130− '';

131 calculateMaterializedSha =

132 calculateMaterializedSha =

132 writeShellScript "calculateSha" ''${nix}/bin/nix-hash --base32 --type sha256 ${calculateNoHash}'';

133 writeShellScript "calculateSha" ''${nix}/bin/nix-hash --base32 --type sha256 ${calculateNoHash}'';

133

134

@@ -143,6 +144,7 @@ let

143 fi

144 fi

144

145

145 # Generate the files

146 # Generate the files

147+ mkdir -p $TARGET

146 rm -rf $TARGET

148 rm -rf $TARGET

147 cp -r ${calculateNoHash} "$TARGET"

149 cp -r ${calculateNoHash} "$TARGET"

148 chmod -R +w "$TARGET"

150 chmod -R +w "$TARGET"

lib/pkgconf-nixpkgs-map.nix+9−1

@@ -27,11 +27,12 @@ pkgs:

27 "dl" = []; # provided by glibc

28 "fftw3" = [ pkgs."fftw" ];

29 "fftw3f" = [ pkgs."fftwFloat" ];

30+ "freetype2" = [ pkgs."freetype" ];

30 "gconf" = [ pkgs."GConf" ];

31 "gconf" = [ pkgs."GConf" ];

31 "gconf-2.0" = [ pkgs."GConf" ];

32 "gconf-2.0" = [ pkgs."GConf" ];

32 "gdk-2.0" = [ pkgs."gtk2" ];

33 "gdk-2.0" = [ pkgs."gtk2" ];

33 "gdk-3.0" = [ pkgs."gtk3" ];

34 "gdk-3.0" = [ pkgs."gtk3" ];

34− "gdk-pixbuf-2.0" = [ pkgs."gdk_pixbuf" ];

35+ "gdk-pixbuf-2.0" = [ (pkgs."gdk-pixbuf" or pkgs."gdk_pixbuf") ];

35 "gdk-x11-2.0" = [ pkgs."gdk_x11" ];

36 "gdk-x11-2.0" = [ pkgs."gdk_x11" ];

36 "gdk-x11-3.0" = [ pkgs."gtk3" ];

37 "gdk-x11-3.0" = [ pkgs."gtk3" ];

37 "gio-2.0" = [ pkgs."glib" ];

38 "gio-2.0" = [ pkgs."glib" ];

@@ -44,7 +45,9 @@ pkgs:

44 "gnome-vfs-2.0" = [ pkgs."gnome-vfs" ];

45 "gnome-vfs-2.0" = [ pkgs."gnome-vfs" ];

45 "gnome-vfs-module-2.0" = [ pkgs."gnome-vfs_module" ];

46 "gnome-vfs-module-2.0" = [ pkgs."gnome-vfs_module" ];

46 "gobject-2.0" = [ pkgs."glib" ];

47 "gobject-2.0" = [ pkgs."glib" ];

48+ "gmodule-2.0" = [ pkgs."glib" ];

47 "gobject-introspection-1.0" = [ pkgs."gobject-introspection" ];

49 "gobject-introspection-1.0" = [ pkgs."gobject-introspection" ];

50+ "graphene-gobject-1.0" = [ pkgs."graphene" ];

48 "gstreamer-audio-0.10" = [ pkgs."gst-plugins-base" ];

51 "gstreamer-audio-0.10" = [ pkgs."gst-plugins-base" ];

49 "gstreamer-audio-1.0" = [ pkgs."gst-plugins-base" ];

52 "gstreamer-audio-1.0" = [ pkgs."gst-plugins-base" ];

50 "gstreamer-base-0.10" = [ pkgs."gst-plugins-base" ];

53 "gstreamer-base-0.10" = [ pkgs."gst-plugins-base" ];

@@ -64,6 +67,7 @@ pkgs:

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" ];

@@ -80,7 +84,9 @@ pkgs:

80 "ldap" = [ pkgs."openldap" ];

84 "ldap" = [ pkgs."openldap" ];

81 "libavutil" = [ pkgs."ffmpeg" ];

85 "libavutil" = [ pkgs."ffmpeg" ];

82 "libcrypto" = [ pkgs."openssl".dev ];

86 "libcrypto" = [ pkgs."openssl".dev ];

87+ "libfreenect" = [ pkgs."freenect" ];

83 "libgsasl" = [ pkgs."gsasl" ];

88 "libgsasl" = [ pkgs."gsasl" ];

89+ "liboath" = [ pkgs."liboauth" ];

84 "libpcre" = [ pkgs."pcre" ];

90 "libpcre" = [ pkgs."pcre" ];

85 "libqrencode" = [ pkgs."qrencode" ];

91 "libqrencode" = [ pkgs."qrencode" ];

86 "libR" = [ pkgs."R" ];

92 "libR" = [ pkgs."R" ];

@@ -95,6 +101,7 @@ pkgs:

95 "libxml-2.0" = [ pkgs."libxml2" ];

101 "libxml-2.0" = [ pkgs."libxml2" ];

96 "libzip" = [ pkgs."libzip" ];

102 "libzip" = [ pkgs."libzip" ];

97 "libzmq" = [ pkgs."zeromq" ];

103 "libzmq" = [ pkgs."zeromq" ];

104+ "libzstd" = [ pkgs."zstd" ];

98 "m" = []; # in stdenv

105 "m" = []; # in stdenv

99 "magic" = [ pkgs."file" ];

106 "magic" = [ pkgs."file" ];

100 "MagickWand" = [ pkgs."imagemagick" ];

107 "MagickWand" = [ pkgs."imagemagick" ];

@@ -115,6 +122,7 @@ pkgs:

115 "pfs-1.2" = [ pkgs."pfstools" ];

122 "pfs-1.2" = [ pkgs."pfstools" ];

116 "png" = [ pkgs."libpng" ];

123 "png" = [ pkgs."libpng" ];

117 "poppler-glib" = [ pkgs."poppler" ];

124 "poppler-glib" = [ pkgs."poppler" ];

125+ "poppler-cpp" = [ pkgs."poppler" ];

118 "pq" = [ pkgs."postgresql" ];

126 "pq" = [ pkgs."postgresql" ];

119 "libpq" = [ pkgs."postgresql" ];

127 "libpq" = [ pkgs."postgresql" ];

120 "pthread" = [];

128 "pthread" = [];

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/licenses.nix+14−7

@@ -1,18 +1,25 @@

1pkgs:

2with builtins; let

3+ spdxJson = pkgs.buildPackages.spdx-license-list-data.json or pkgs.buildPackages.spdx-license-list-data;

4+ materialized' = ../../materialized + "/spdx-${spdxJson.version}";

3 licensesJSON = fromJSON (replaceStrings

5 licensesJSON = fromJSON (replaceStrings

4 [ "\\u0026" "\\u0027" "\\u003d" ]

6 [ "\\u0026" "\\u0027" "\\u003d" ]

5 [ "&" "'" "=" ]

7 [ "&" "'" "=" ]

6− (readFile "${pkgs.evalPackages.spdx-license-list-data}/json/licenses.json")

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")

7 );

15 );

8 dropFour = s: substring 0 (stringLength s - 4) s;

16 dropFour = s: substring 0 (stringLength s - 4) s;

9 toSpdx = lic: with lic;

17 toSpdx = lic: with lic;

10− { spdxId = licenseId

18+ { spdxId = licenseId;

11− ; shortName = licenseId

19+ shortName = licenseId;

12− ; fullName = name

20+ fullName = name;

13− ; url = dropFour detailsUrl + "html"

21+ url = dropFour detailsUrl + "html";

14− ; free = isOsiApproved

22+ free = isOsiApproved || lic.isFsfLibre or false;

15− ;

16 };

23 };

17 toNamedValue = lic: { name = lic.spdxId; value = lic; };

24 toNamedValue = lic: { name = lic.spdxId; value = lic; };

18in

25in

lib/stack-cache-generator.nix+33−39

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

1# Generate cache entries for dependencies of package defined in `src`

2

3−{ pkgs, haskellLib }:

4{ src

3{ src

5, stackYaml ? "stack.yaml"

4, stackYaml ? "stack.yaml"

6, sha256map ? null

5, sha256map ? null

@@ -9,10 +8,6 @@

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 ?

13− if sha256map != null

14− then { location, tag, ...}: sha256map."${location}"."${tag}"

15− else _: null

16, branchMap ? null

11, branchMap ? null

17 # A way to specify in which branch a git commit can

12 # A way to specify in which branch a git commit can

18 # be found

13 # be found

@@ -21,10 +16,14 @@

21 then { location, tag, ...}: branchMap."${location}"."${tag}" or null

16 then { location, tag, ...}: branchMap."${location}"."${tag}" or null

22 else _: null

17 else _: null

23, resolverSha256 ? null

18, resolverSha256 ? null

24−, nix-tools ? pkgs.haskell-nix.internal-nix-tools # When building stack projects we use the internal nix-tools (compiled with a fixed GHC version)

19+, nix-tools

20+, evalPackages

25, ...

21, ...

26−}:

22+}@args:

27let

23let

24+ inherit (evalPackages) runCommand;

25+ inherit (evalPackages.haskell-nix) haskellLib;

26+

28 # 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

29 # 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

30 # changes.

29 # changes.

@@ -34,30 +33,27 @@ let

34 }) resolver fetchedResolver;

33 }) resolver fetchedResolver;

35

34

36 # Filter just the stack yaml file and any resolver yaml file it points to.

35 # Filter just the stack yaml file and any resolver yaml file it points to.

37− maybeCleanedSource =

38− if haskellLib.canCleanSource src

39− then haskellLib.cleanSourceWith {

36+ maybeCleanedSource = haskellLib.cleanSourceWith {

40− inherit src;

37+ inherit src;

41− filter = path: type:

38+ filter = path: type:

42− let

39+ let

43− origSrc = if src ? _isLibCleanSourceWith then src.origSrc else src;

40+ origSrc = if src ? _isLibCleanSourceWith then src.origSrc else src;

44− origSubDir = if src ? _isLibCleanSourceWithEx then src.origSubDir else "";

41+ origSubDir = if src ? _isLibCleanSourceWithEx then src.origSubDir else "";

45− relPath = pkgs.lib.removePrefix (toString origSrc + origSubDir + "/") path;

42+ relPath = evalPackages.lib.removePrefix (toString origSrc + origSubDir + "/") path;

46

43

47− # checks if path1 is a parent directory for path2

44+ # checks if path1 is a parent directory for path2

48− isParent = path1: path2: pkgs.lib.hasPrefix "${path1}/" path2;

45+ isParent = path1: path2: evalPackages.lib.hasPrefix "${path1}/" path2;

49

46

50− in

47+ in

51− (relPath == stackYaml)

48+ (relPath == stackYaml)

52− || (resolver != null && (relPath == resolver || isParent relPath resolver))

49+ || (resolver != null && (relPath == resolver || isParent relPath resolver))

53− ;

50+ ;

54− }

51+ };

55− else src;

56

52

57 # All repos served via ssh or git protocols are usually private

53 # All repos served via ssh or git protocols are usually private

58− private = url: pkgs.lib.substring 0 4 url != "http";

54+ private = url: evalPackages.lib.substring 0 4 url != "http";

59

55

60− repos = builtins.fromJSON (builtins.readFile (pkgs.runCommand "stack-repos" {

56+ repos = builtins.fromJSON (builtins.readFile (evalPackages.runCommand "stack-repos" {

61 buildInputs = [ nix-tools ];

57 buildInputs = [ nix-tools ];

62 } ''

58 } ''

63 TMP=$(mktemp -d)

59 TMP=$(mktemp -d)

@@ -65,45 +61,43 @@ let

65 cp -r "${maybeCleanedSource}/." $TMP

61 cp -r "${maybeCleanedSource}/." $TMP

66 chmod -R +w $TMP

62 chmod -R +w $TMP

67 substituteInPlace ${stackYaml} --replace "# nix-sha256:" "nix-sha256:"

63 substituteInPlace ${stackYaml} --replace "# nix-sha256:" "nix-sha256:"

68− ${pkgs.lib.optionalString (fetchedResolver != null) ''

64+ ${evalPackages.lib.optionalString (fetchedResolver != null) ''

69 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

65 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

70 ''}

66 ''}

71 stack-repos --stack-yaml ${stackYaml}

67 stack-repos --stack-yaml ${stackYaml}

72 cp repos.json $out

68 cp repos.json $out

73 ''));

69 ''));

74

70

75− cabalName = path: builtins.readFile (pkgs.runCommand "cabal-name" {

71+ cabalName = path: builtins.readFile (evalPackages.runCommand "cabal-name" {

76 buildInputs = [ nix-tools ];

72 buildInputs = [ nix-tools ];

77 } ''

73 } ''

78 cabal-name ${path} > $out

74 cabal-name ${path} > $out

79 '');

75 '');

80

76

81 hashPath = path:

77 hashPath = path:

82− builtins.readFile (pkgs.runCommand "hash-path" { preferLocalBuild = true; }

78+ builtins.readFile (evalPackages.runCommand "hash-path" { preferLocalBuild = true; }

83− "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");

84−in with pkgs.lib;

80+in with evalPackages.lib;

85concatMap (dep:

81concatMap (dep:

86 let

82 let

87 is-private = private dep.url;

83 is-private = private dep.url;

88− sha256 = if dep.sha256 != null

84+ sha256 =

89− then dep.sha256

85+ if dep.sha256 != null then dep.sha256

90− else lookupSha256 {

86+ else if sha256map != null then sha256map."${dep.url}"."${dep.rev}"

91− location = dep.url;

87+ else null;

92− tag = dep.rev;

93− };

94 branch = lookupBranch {

88 branch = lookupBranch {

95 location = dep.url;

89 location = dep.url;

96 tag = dep.rev;

90 tag = dep.rev;

97 };

91 };

98 pkgsrc =

92 pkgsrc =

99 if !is-private && sha256 != null

93 if !is-private && sha256 != null

100− then pkgs.fetchgit {

94+ then evalPackages.fetchgit {

101 inherit (dep) url rev;

95 inherit (dep) url rev;

102 inherit sha256;

96 inherit sha256;

103 }

97 }

104 else builtins.fetchGit ({

98 else builtins.fetchGit ({

105 inherit (dep) url rev;

99 inherit (dep) url rev;

106− } // pkgs.lib.optionalAttrs (branch != null) { ref = branch; });

100+ } // evalPackages.lib.optionalAttrs (branch != null) { ref = branch; });

107 in map (subdir: {

101 in map (subdir: {

108 name = cabalName "${pkgsrc}/${subdir}";

102 name = cabalName "${pkgsrc}/${subdir}";

109 inherit (dep) url rev;

103 inherit (dep) url rev;

lib/system-nixpkgs-map.nix+35−4

@@ -6,16 +6,32 @@ pkgs:

6

7with pkgs;

8

9+let

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

9# -- linux

20# -- linux

10{ crypto = [ openssl ];

21{ crypto = [ openssl ];

11− "c++" = null; # no libc++

22+ "c++" = []; # no libc++

12− "stdc++" = null;

23+ "stdc++" = gcclibs;

13− "stdc++-6" = null;

24+ "stdc++-6" = gcclibs;

25+ gcc_s_seh-1 = gcclibs;

26+ gcc_s = gcclibs;

27+ gcc = gcclibs;

14 ssl = [ openssl ];

28 ssl = [ openssl ];

15 z = [ zlib ];

29 z = [ zlib ];

30+ m = []; # Included with ghc

16 pcap = [ libpcap ];

31 pcap = [ libpcap ];

17 pthread = null; # available by default

32 pthread = null; # available by default

18 GL = [ libGL ];

33 GL = [ libGL ];

34+ GLEW = [ glew ];

19 GLU = [ libGLU ];

35 GLU = [ libGLU ];

20 alut = [ freealut ];

36 alut = [ freealut ];

21 X11 = with xorg; [ libX11 ];

37 X11 = with xorg; [ libX11 ];

@@ -35,6 +51,7 @@ with pkgs;

35 util = [ utillinux ];

51 util = [ utillinux ];

36 magic = [ file ];

52 magic = [ file ];

37 pq = [ postgresql ];

53 pq = [ postgresql ];

54+ libpq = [ postgresql ];

38 iconv = [ libiconv ];

55 iconv = [ libiconv ];

39 lapack = [ liblapack ];

56 lapack = [ liblapack ];

40 boost_atomic = [ boost ];

57 boost_atomic = [ boost ];

@@ -80,25 +97,39 @@ with pkgs;

80 opencv = [ opencv3 ];

97 opencv = [ opencv3 ];

81 icuuc = [ icu ];

98 icuuc = [ icu ];

82 icui18n = [ icu ];

99 icui18n = [ icu ];

100+ icu-i18n = [ icu ];

83 icudata = [ icu ];

101 icudata = [ icu ];

84 vulkan = [ vulkan-loader ];

102 vulkan = [ vulkan-loader ];

85 sodium = [ libsodium ];

103 sodium = [ libsodium ];

86 gfortran = [ gfortran.cc.lib ];

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 ];

87}

117}

88# -- windows

118# -- windows

89// { advapi32 = null; gdi32 = null; imm32 = null; msimg32 = null;

119// { advapi32 = null; gdi32 = null; imm32 = null; msimg32 = null;

90 shell32 = null; shfolder = null; shlwapi = null; user32 = null;

120 shell32 = null; shfolder = null; shlwapi = null; user32 = null;

121+ ole32 = null; rpcrt4 = null;

91 winmm = null; userenv = null;

122 winmm = null; userenv = null;

92 kernel32 = null; ws2_32 = null;

123 kernel32 = null; ws2_32 = null;

93 # this should be bundled with gcc.

124 # this should be bundled with gcc.

94 # if it's not we have more severe

125 # if it's not we have more severe

95 # issues anyway.

126 # issues anyway.

96− gcc_s_seh-1 = null;

97 ssl32 = null; eay32 = [ openssl ];

127 ssl32 = null; eay32 = [ openssl ];

98 iphlpapi = null; # IP Help API

128 iphlpapi = null; # IP Help API

99 msvcrt = null; # this is the libc

129 msvcrt = null; # this is the libc

100 Crypt32 = null;

130 Crypt32 = null;

101 mswsock = null;

131 mswsock = null;

132+ bcrypt = null;

102 }

133 }

103# -- os x

134# -- os x

104# NB: these map almost 1:1 to the framework names

135# NB: these map almost 1:1 to the framework names

lib/system-pkgs.nix+1−18

@@ -9,25 +9,8 @@

9

10pkgs:

11

12−let

13− buildEnvMaybe = name: paths:

14− if builtins.length paths == 1

15− then builtins.head paths

16− else pkgs.buildEnv { name = "${name}-env"; inherit paths; };

17−

18− mapPackages = name: ps:

19− if builtins.typeOf ps == "list"

20− then buildEnvMaybe name ps

21− else ps;

22−

23−in

24 # Base packages.

12 # Base packages.

25 pkgs

13 pkgs

26

14

27− # fetchgit should always come from the evalPackages

28− # if it comes from the targetPackages we won't even

29− # be able to execute it.

30− // { fetchgit = pkgs.evalPackages.fetchgit; }

31−

32 # Apply the mapping.

15 # Apply the mapping.

33− // builtins.mapAttrs mapPackages (import ./system-nixpkgs-map.nix pkgs)

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/bootstrap/ghc8107/happy-1.19.12/.plan.nix/happy.nixnew file+200

@@ -0,0 +1,200 @@

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 = "happy"; version = "1.19.12"; };

15+ license = "BSD-2-Clause";

16+ copyright = "(c) Andy Gill, Simon Marlow";

17+ maintainer = "Simon Marlow <marlowsd@gmail.com>";

18+ author = "Andy Gill and Simon Marlow";

19+ homepage = "https://www.haskell.org/happy/";

20+ url = "";

21+ synopsis = "Happy is a parser generator for Haskell";

22+ description = "Happy is a parser generator for Haskell. Given a grammar\nspecification in BNF, Happy generates Haskell code to parse the\ngrammar. Happy works in a similar way to the @yacc@ tool for C.";

23+ buildType = "Simple";

24+ isLocal = true;

25+ detailLevel = "FullDetails";

26+ licenseFiles = [ "LICENSE" ];

27+ dataDir = "data/";

28+ dataFiles = [

29+ "HappyTemplate"

30+ "HappyTemplate-arrays"

31+ "HappyTemplate-arrays-coerce"

32+ "HappyTemplate-arrays-coerce-debug"

33+ "HappyTemplate-arrays-debug"

34+ "HappyTemplate-arrays-ghc"

35+ "HappyTemplate-arrays-ghc-debug"

36+ "HappyTemplate-coerce"

37+ "HappyTemplate-ghc"

38+ "GLR_Base"

39+ "GLR_Lib"

40+ "GLR_Lib-ghc"

41+ "GLR_Lib-ghc-debug"

42+ ];

43+ extraSrcFiles = [

44+ "ANNOUNCE"

45+ "CHANGES"

46+ "Makefile"

47+ "README.md"

48+ "TODO"

49+ "doc/Makefile"

50+ "doc/aclocal.m4"

51+ "doc/config.mk.in"

52+ "doc/configure.ac"

53+ "doc/docbook-xml.mk"

54+ "doc/fptools.css"

55+ "doc/happy.1.in"

56+ "doc/happy.xml"

57+ "examples/glr/nlp/Main.lhs"

58+ "examples/glr/nlp/Makefile"

59+ "examples/glr/nlp/README"

60+ "examples/glr/nlp/English.y"

61+ "examples/glr/nlp/Hugs.lhs"

62+ "examples/glr/Makefile"

63+ "examples/glr/Makefile.defs"

64+ "examples/glr/expr-eval/Main.lhs"

65+ "examples/glr/expr-eval/Makefile"

66+ "examples/glr/expr-eval/Expr.y"

67+ "examples/glr/expr-eval/README"

68+ "examples/glr/expr-eval/Hugs.lhs"

69+ "examples/glr/expr-tree/Main.lhs"

70+ "examples/glr/expr-tree/Makefile"

71+ "examples/glr/expr-tree/Expr.y"

72+ "examples/glr/expr-tree/README"

73+ "examples/glr/expr-tree/Tree.lhs"

74+ "examples/glr/expr-tree/Hugs.lhs"

75+ "examples/glr/highly-ambiguous/Main.lhs"

76+ "examples/glr/highly-ambiguous/Makefile"

77+ "examples/glr/highly-ambiguous/Expr.y"

78+ "examples/glr/highly-ambiguous/README"

79+ "examples/glr/highly-ambiguous/Hugs.lhs"

80+ "examples/glr/hidden-leftrec/Main.lhs"

81+ "examples/glr/hidden-leftrec/Makefile"

82+ "examples/glr/hidden-leftrec/Expr.y"

83+ "examples/glr/hidden-leftrec/README"

84+ "examples/glr/hidden-leftrec/Hugs.lhs"

85+ "examples/glr/expr-monad/Main.lhs"

86+ "examples/glr/expr-monad/Makefile"

87+ "examples/glr/expr-monad/Expr.y"

88+ "examples/glr/expr-monad/README"

89+ "examples/glr/expr-monad/Hugs.lhs"

90+ "examples/glr/bio-eg/Main.lhs"

91+ "examples/glr/bio-eg/Makefile"

92+ "examples/glr/bio-eg/Bio.y"

93+ "examples/glr/bio-eg/README"

94+ "examples/glr/bio-eg/1-1200.dna"

95+ "examples/glr/bio-eg/1-600.dna"

96+ "examples/glr/common/DV_lhs"

97+ "examples/glr/common/DaVinciTypes.hs"

98+ "examples/glr/packing/Main.lhs"

99+ "examples/glr/packing/Makefile"

100+ "examples/glr/packing/Expr.y"

101+ "examples/glr/packing/README"

102+ "examples/glr/packing/Hugs.lhs"

103+ "examples/PgnParser.ly"

104+ "examples/MonadTest.ly"

105+ "examples/igloo/ParserM.hs"

106+ "examples/igloo/Makefile"

107+ "examples/igloo/Parser.y"

108+ "examples/igloo/Foo.hs"

109+ "examples/igloo/README"

110+ "examples/igloo/Lexer.x"

111+ "examples/README"

112+ "examples/Calc.ly"

113+ "examples/DavesExample.ly"

114+ "examples/ErrorTest.ly"

115+ "examples/ErlParser.ly"

116+ "examples/SimonsExample.ly"

117+ "examples/LexerTest.ly"

118+ "happy.spec"

119+ "src/ARRAY-NOTES"

120+ "tests/AttrGrammar001.y"

121+ "tests/AttrGrammar002.y"

122+ "tests/Makefile"

123+ "tests/Partial.ly"

124+ "tests/Test.ly"

125+ "tests/TestMulti.ly"

126+ "tests/TestPrecedence.ly"

127+ "tests/bogus-token.y"

128+ "tests/bug001.ly"

129+ "tests/bug002.y"

130+ "tests/error001.stderr"

131+ "tests/error001.stdout"

132+ "tests/error001.y"

133+ "tests/monad001.y"

134+ "tests/monad002.ly"

135+ "tests/monaderror.y"

136+ "tests/precedence001.ly"

137+ "tests/precedence002.y"

138+ "tests/test_rules.y"

139+ "tests/issue91.y"

140+ "tests/issue93.y"

141+ "tests/issue94.y"

142+ "tests/issue95.y"

143+ "tests/monaderror-explist.y"

144+ "tests/typeclass_monad001.y"

145+ "tests/typeclass_monad002.ly"

146+ "tests/typeclass_monad_lexer.y"

147+ "tests/rank2.y"

148+ ];

149+ extraTmpFiles = [];

150+ extraDocFiles = [];

151+ };

152+ components = {

153+ exes = {

154+ "happy" = {

155+ depends = [

156+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

157+ (hsPkgs."array" or (errorHandler.buildDepError "array"))

158+ (hsPkgs."containers" or (errorHandler.buildDepError "containers"))

159+ (hsPkgs."mtl" or (errorHandler.buildDepError "mtl"))

160+ ];

161+ buildable = true;

162+ modules = [

163+ "Paths_happy"

164+ "AbsSyn"

165+ "First"

166+ "GenUtils"

167+ "Grammar"

168+ "Info"

169+ "LALR"

170+ "Lexer"

171+ "ParseMonad"

172+ "Parser"

173+ "ProduceCode"

174+ "ProduceGLRCode"

175+ "NameSet"

176+ "Target"

177+ "AttrGrammar"

178+ "AttrGrammarParser"

179+ "ParamRules"

180+ "PrettyGrammar"

181+ ];

182+ hsSourceDirs = [ "src" ];

183+ mainPath = [ "Main.lhs" ];

184+ };

185+ };

186+ tests = {

187+ "tests" = {

188+ depends = [

189+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

190+ (hsPkgs."process" or (errorHandler.buildDepError "process"))

191+ ];

192+ build-tools = [

193+ (hsPkgs.buildPackages.happy.components.exes.happy or (pkgs.buildPackages.happy or (errorHandler.buildToolDepError "happy:happy")))

194+ ];

195+ buildable = true;

196+ mainPath = [ "test.hs" ];

197+ };

198+ };

199+ };

200+ } // rec { src = (pkgs.lib).mkDefault ../.; }

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/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;

7− "rts".revision = (((hackage."rts")."1.0").revisions).default;

6+ "array".revision = (((hackage."array")."0.5.2.0").revisions).default;

8− "deepseq".revision = (((hackage."deepseq")."1.4.3.0").revisions).default;

7+ "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.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+1−1

@@ -30,7 +30,7 @@

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+ "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;

8− "mtl".revision = (((hackage."mtl")."2.2.2").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− "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

24+ "Cabal".revision = (((hackage."Cabal")."2.2.0.1").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/bootstrap/ghc844/happy-1.19.12/default.nix+25−22

@@ -3,40 +3,28 @@

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+ "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

7− "mtl".revision = (((hackage."mtl")."2.2.2").revisions).default;

8+ "base".revision = (((hackage."base")."4.11.1.0").revisions).default;

8 "rts".revision = (((hackage."rts")."1.0").revisions).default;

9 "rts".revision = (((hackage."rts")."1.0").revisions).default;

9− "deepseq".revision = (((hackage."deepseq")."1.4.3.0").revisions).default;

10+ "mtl".revision = (((hackage."mtl")."2.2.2").revisions).default;

10− "directory".revision = (((hackage."directory")."1.3.1.5").revisions).default;

11 "containers".revision = (((hackage."containers")."0.5.11.0").revisions).default;

12− "bytestring".revision = (((hackage."bytestring")."0.10.8.2").revisions).default;

12+ "deepseq".revision = (((hackage."deepseq")."1.4.3.0").revisions).default;

13− "base".revision = (((hackage."base")."4.11.1.0").revisions).default;

14− "time".revision = (((hackage."time")."1.8.0.2").revisions).default;

15 "transformers".revision = (((hackage."transformers")."0.5.5.0").revisions).default;

13 "transformers".revision = (((hackage."transformers")."0.5.5.0").revisions).default;

16− "filepath".revision = (((hackage."filepath")."1.4.2").revisions).default;

17− "process".revision = (((hackage."process")."1.6.3.0").revisions).default;

18− "array".revision = (((hackage."array")."0.5.2.0").revisions).default;

19− "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

20 };

14 };

21 compiler = {

15 compiler = {

22 version = "8.4.4";

16 version = "8.4.4";

23 nix-name = "ghc844";

17 nix-name = "ghc844";

24 packages = {

18 packages = {

25 "ghc-prim" = "0.5.2.0";

19 "ghc-prim" = "0.5.2.0";

26− "unix" = "2.7.2.2";

20+ "array" = "0.5.2.0";

27− "mtl" = "2.2.2";

21+ "integer-gmp" = "1.0.2.0";

22+ "base" = "4.11.1.0";

28 "rts" = "1.0";

23 "rts" = "1.0";

29− "deepseq" = "1.4.3.0";

24+ "mtl" = "2.2.2";

30− "directory" = "1.3.1.5";

31 "containers" = "0.5.11.0";

25 "containers" = "0.5.11.0";

32− "bytestring" = "0.10.8.2";

26+ "deepseq" = "1.4.3.0";

33− "base" = "4.11.1.0";

34− "time" = "1.8.0.2";

35 "transformers" = "0.5.5.0";

27 "transformers" = "0.5.5.0";

36− "filepath" = "1.4.2";

37− "process" = "1.6.3.0";

38− "array" = "0.5.2.0";

39− "integer-gmp" = "1.0.2.0";

40 };

28 };

41 };

29 };

42 };

30 };

@@ -49,5 +37,20 @@

49 "happy" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

37 "happy" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

50 };

38 };

51 })

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+ })

52 ];

55 ];

53 }

56 }

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 = {}; }; }; })