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

.buildkite/pipeline.yml+17−5

since splitsnapshots

unifiedsplit

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

1steps:

2− - label: 'Run tests with ghc8105'

2+ - label: 'Run tests with ghc8107'

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

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 ghc8105'

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

18 command:

19− - nix-build build.nix -A maintainer-scripts.check-closure-size --argstr compiler-nix-name ghc8105 -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 ghc8105 -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+21−5

@@ -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,8 +34,8 @@ 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.

build.nix+26−11

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

5let

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

7in

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

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,22 @@ 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+ };

25− } // pkgs.lib.optionalAttrs (compiler-nix-name != "ghc901") {

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

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

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

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

28 })

39 })

29 );

40 );

30

41

@@ -35,7 +46,7 @@ in rec {

35 maintainer-scripts = pkgs.dontRecurseIntoAttrs {

46 maintainer-scripts = pkgs.dontRecurseIntoAttrs {

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

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

37 inherit (pkgs) stdenv lib writeScript coreutils glibc git

48 inherit (pkgs) stdenv lib writeScript coreutils glibc git

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

49+ openssh nixFlakes gawk bash curl findutils;

39 # 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)

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

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

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

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

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

43 };

54 };

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

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

45 inherit (pkgs) stdenv lib writeScript coreutils glibc git

56 inherit (pkgs) stdenv lib writeScript coreutils glibc git

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

57+ openssh nixFlakes gawk bash curl findutils;

47 # 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)

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

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

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

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

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

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

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

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

59 # use)

70 # use)

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

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

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

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

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

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

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

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

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

66 ];

77 ];

67 };

78 };

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

69− 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+ };

70 };

85 };

71

86

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

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

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

74 maintainer-script-cache = pkgs.recurseIntoAttrs (

89 maintainer-script-cache = pkgs.recurseIntoAttrs (

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

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

76 inherit (maintainer-scripts) check-hydra;

91 inherit (maintainer-scripts) check-hydra;

77 })

92 })

78 // (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+91−28

@@ -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

@@ -50,6 +50,7 @@ let self =

50, writeHieFiles ? component.writeHieFiles

51

52, ghcOptions ? component.ghcOptions

53+, contentAddressed ? component.contentAddressed

53

54

54# Options for Haddock generation

55# Options for Haddock generation

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

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

@@ -61,7 +62,7 @@ let self =

61

62

62# Profiling

63# Profiling

63, enableLibraryProfiling ? component.enableLibraryProfiling

64, enableLibraryProfiling ? component.enableLibraryProfiling

64−, enableExecutableProfiling ? component.enableExecutableProfiling

65+, enableProfiling ? component.enableProfiling

65, profilingDetail ? component.profilingDetail

66, profilingDetail ? component.profilingDetail

66

67

67# Coverage

68# Coverage

@@ -82,6 +83,7 @@ let self =

82

83

83# LLVM

84# LLVM

84, useLLVM ? ghc.useLLVM

85, useLLVM ? ghc.useLLVM

86+, smallAddressSpace ? false

85

87

86}@drvArgs:

88}@drvArgs:

87

89

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

98 && !stdenv.hostPlatform.isMusl

100 && !stdenv.hostPlatform.isMusl

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

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

100

102

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

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

103

107

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

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

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

@@ -129,7 +133,7 @@ let

129

133

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

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

131

135

132− needsProfiling = enableExecutableProfiling || enableLibraryProfiling;

136+ needsProfiling = enableProfiling || enableLibraryProfiling;

133

137

134 configFiles = makeConfigFiles {

138 configFiles = makeConfigFiles {

135 component = componentForSetup;

139 component = componentForSetup;

@@ -176,7 +180,7 @@ let

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

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

177 ] ++

181 ] ++

178 # BINTOOLS

182 # BINTOOLS

179− (if stdenv.hostPlatform.isLinux

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

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

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

181 then [

185 then [

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

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

@@ -193,7 +197,7 @@ let

193 (disableFeature dontStrip "executable-stripping")

197 (disableFeature dontStrip "executable-stripping")

194 (disableFeature dontStrip "library-stripping")

198 (disableFeature dontStrip "library-stripping")

195 (enableFeature enableLibraryProfiling "library-profiling")

199 (enableFeature enableLibraryProfiling "library-profiling")

196− (enableFeature enableExecutableProfiling "executable-profiling")

200+ (enableFeature enableProfiling "profiling")

197 (enableFeature enableStatic "static")

201 (enableFeature enableStatic "static")

198 (enableFeature enableShared "shared")

202 (enableFeature enableShared "shared")

199 (enableFeature doCoverage "coverage")

203 (enableFeature doCoverage "coverage")

@@ -201,13 +205,13 @@ let

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

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

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

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

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

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

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

205 # component.

209 # component.

206 "--disable-executable-dynamic"

210 "--disable-executable-dynamic"

207 "--ghc-option=-optl=-pthread"

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

208 "--ghc-option=-optl=-static"

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

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

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

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

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

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

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

212 ++ lib.optionals haskellLib.isCrossHost (

216 ++ lib.optionals haskellLib.isCrossHost (

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

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

221 "--ghc-option=-fPIC" "--gcc-option=-fPIC"

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

222 ]

226 ]

223 ++ 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"

224 );

236 );

225

237

226 executableToolDepends =

238 executableToolDepends =

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

234 shellWrappers = ghcForComponent {

246 shellWrappers = ghcForComponent {

235 componentName = fullName;

247 componentName = fullName;

236 inherit configFiles enableDWARF;

248 inherit configFiles enableDWARF;

249+ inherit (component) plugins;

237 };

250 };

238

251

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

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

304 componentDrv = drv;

317 componentDrv = drv;

305 };

318 };

306

319

320+ contentAddressedAttrs = lib.optionalAttrs contentAddressed {

321+ __contentAddressed = true;

322+ outputHashMode = "recursive";

323+ outputHashAlgo = "sha256";

324+ };

325+

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

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

308 pname = nameOnly;

327 pname = nameOnly;

309 inherit (package.identifier) version;

328 inherit (package.identifier) version;

310

329

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

337 description = package.synopsis or "";

356 description = package.synopsis or "";

338 license = haskellLib.cabalToNixpkgsLicense package.license;

357 license = haskellLib.cabalToNixpkgsLicense package.license;

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

340 };

367 };

341

368

342 propagatedBuildInputs =

369 propagatedBuildInputs =

343 frameworks # Frameworks will be needed at link time

370 frameworks # Frameworks will be needed at link time

344 # Not sure why pkgconfig needs to be propagatedBuildInputs but

371 # Not sure why pkgconfig needs to be propagatedBuildInputs but

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

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

346− ++ builtins.concatLists pkgconfig;

373+ ++ builtins.concatLists pkgconfig

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

375+ (lib.flatten component.libs

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

347

377

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

348− buildInputs = component.libs

379+ (lib.flatten component.libs

349− ++ map haskellLib.dependToLib component.depends;

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

350

381

351 nativeBuildInputs =

382 nativeBuildInputs =

352 [shellWrappers buildPackages.removeReferencesTo]

383 [shellWrappers buildPackages.removeReferencesTo]

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

380 runHook postConfigure

411 runHook postConfigure

381 '';

412 '';

382

413

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

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

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

386− $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}

387− runHook postBuild

442+ runHook postBuild

388− '';

443+ '');

389

444

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

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

391 #

446 #

@@ -457,7 +512,7 @@ let

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

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

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

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

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

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

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

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

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

462 '' else ''

517 '' else ''

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

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

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

465 fi

520 fi

466 '')

521 '')

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

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

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

523+ + (lib.optionalString enableSeparateDataOutput ''

524+ mkdir -p $data

525+ '')

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

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

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

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

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

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

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

473 done

530 done

474 ''

531 ''

475 # symlink all .dlls into the local directory.

532 # symlink all .dlls into the local directory.

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

477− # to symlink over dlls as needed.

478 + ''

533 + ''

479− echo "Symlink library dependencies..."

534+ for p in $pkgsHostTargetAsString; do

480− for libdir in $(${stdenv.hostPlatform.config}-ghc-pkg field "*" dynamic-library-dirs --simple-output|xargs|sed 's/ /\n/g'|sort -u); do

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

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

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

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

483− fi

484 done

537 done

485 ''))

538 ''))

486 + (lib.optionalString doCoverage ''

539 + (lib.optionalString doCoverage ''

@@ -515,6 +568,16 @@ let

515 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}.

516 '');

569 '');

517

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+

518 shellHook = ''

581 shellHook = ''

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

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

520 ${shellHookApplied}

583 ${shellHookApplied}

builder/default.nix+20−13

@@ -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

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

45

46 hoogleLocal = let

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

48− 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;

49− version = "5.0.17.15";

50+ version = "5.0.18.3";

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

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

51 }

52 }

52 }:

53 }:

53− haskellLib.weakCallPackage pkgs nixpkgsHoogle {

54+ let

55+ haskellPackages = {

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

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

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

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

56− then ghc.buildGHC

58+ then ghc.buildGHC

57− else ghc;

59+ else ghc;

58− inherit packages hoogle;

60+ inherit packages hoogle;

59− };

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;

60

67

61 # Same as haskellPackages.shellFor in nixpkgs.

68 # Same as haskellPackages.shellFor in nixpkgs.

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

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

63− inherit hsPkgs ghcForComponent makeConfigFiles hoogleLocal haskellLib buildPackages compiler;

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

64 inherit (buildPackages) glibcLocales;

71 inherit (buildPackages) glibcLocales;

65 };

72 };

66

73

builder/ghc-for-component-wrapper.nix+60−15

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

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

14, postInstall ? ""

15, enableDWARF

16+, plugins

16}:

17}:

17

18

18let

19let

@@ -37,31 +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− # now the tricky bit. For GHCJS (to make plugins work), we need a special

68+ ''

59− # file called ghc_libdir. That points to the build ghc's lib.

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

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

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}]"

61

94

62− # Wrap compiler executables with correct env variables.

95+ ''

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

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"

64

100

101+ ''

102+ # Wrap compiler executables with correct env variables.

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

104+ + ''

65 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

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

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

67 rm -f $out/bin/$prg

107 rm -f $out/bin/$prg

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

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

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

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

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

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

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

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

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

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

74 fi

115 fi

75 done

116 done

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

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

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

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

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

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

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

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

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

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

86 fi

128 fi

87 done

129 done

88

130

131+ ''

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

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

133+ + ''

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

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

91 rm -f $out/bin/haddock

135 rm -f $out/bin/haddock

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

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

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

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

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

95 fi

139 fi

96

140

141+ ''

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

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

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

99−

144+ + ''

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

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

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

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

102 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+35−22

@@ -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

@@ -118,7 +131,7 @@ in rec {

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

@@ -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,16 +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

85− ++ lib.optionals (stdenv.hostPlatform.isWindows) (map (p: "${lib.getBin p}/bin") component.libs);

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

91+ (map (p: "${lib.getBin p}/bin")

92+ (lib.flatten component.libs ++ lib.concatLists component.pkgconfig));

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

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

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

88 })}

96 })}

89

97

90 ghc=${ghc}

98 ghc=${ghc}

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

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

92 ''

100 ''

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

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

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

95 done

103 done

96 ''}

104 ''}

@@ -149,13 +157,13 @@ let

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

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

150 ''}

158 ''}

151 done

159 done

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

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

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

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

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

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

155 fi

163 fi

156 done

164 done

157 '' + lib.optionalString component.doExactConfig ''

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

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

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

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

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

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

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

161 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+23−12

@@ -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

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

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

@@ -55,23 +56,27 @@ let

55 (builtins.map (x: lib.nameValuePair (x.name) x)

56 (builtins.map (x: lib.nameValuePair (x.name) x)

56 (haskellLib.flatLibDepends {depends = directlySelectedComponents;}));

57 (haskellLib.flatLibDepends {depends = directlySelectedComponents;}));

57

58

59+ isSelectedComponent =

60+ comp: selectedComponentsBitmap."${((haskellLib.dependToLib comp).name or null)}" or false;

58 selectedComponentsBitmap =

61 selectedComponentsBitmap =

59 lib.mapAttrs

62 lib.mapAttrs

60− (_: x: (builtins.any

63+ (_: x: (builtins.any isSelectedComponent x.config.depends))

61− (dep: selectedComponentsBitmap."${(haskellLib.dependToLib dep).name}") x.config.depends))

62 transitiveDependenciesComponents

64 transitiveDependenciesComponents

63 // builtins.listToAttrs (map (x: lib.nameValuePair x.name true) directlySelectedComponents); # base case

65 // builtins.listToAttrs (map (x: lib.nameValuePair x.name true) directlySelectedComponents); # base case

64

66

65 selectedComponents =

67 selectedComponents =

66− lib.filter (x: selectedComponentsBitmap."${x.name}") (lib.attrValues transitiveDependenciesComponents);

68+ lib.filter isSelectedComponent (lib.attrValues transitiveDependenciesComponents);

67

69

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

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

69 removeSelectedInputs =

71 removeSelectedInputs =

70− lib.filter (input: !(selectedComponentsBitmap."${((haskellLib.dependToLib input).name or null)}" or false));

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

71

73

72− # The configs of all the selected components

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.

73 selectedConfigs = map (c: c.config) selectedComponents

77 selectedConfigs = map (c: c.config) selectedComponents

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

78+ ++ lib.optionals packageSetupDeps (map (p: p.setup.config)

79+ (lib.filter (p: p.buildType != "Simple") selectedPackages));

75

80

76 name = if lib.length selectedPackages == 1

81 name = if lib.length selectedPackages == 1

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

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

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

94 component = {

99 component = {

95 depends = packageInputs;

100 depends = packageInputs;

96 libs = [];

101 libs = [];

102+ pkgconfig = [];

97 frameworks = [];

103 frameworks = [];

98 doExactConfig = false;

104 doExactConfig = false;

99 };

105 };

100 configFiles = makeConfigFiles {

106 configFiles = makeConfigFiles {

101 fullName = args.name or name;

107 fullName = args.name or name;

102 identifier.name = name;

108 identifier.name = name;

103− inherit component;

109+ inherit component enableDWARF;

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

104 };

111 };

105 ghcEnv = ghcForComponent {

112 ghcEnv = ghcForComponent {

106 inherit configFiles;

113 inherit configFiles;

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

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

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

110 '';

117 '';

111 inherit enableDWARF;

118 inherit enableDWARF;

119+ plugins = [];

112 };

120 };

113

121

114 hoogleIndex = let

122 hoogleIndex = let

@@ -125,7 +133,12 @@ let

125 # inherit (hsPkgs) hoogle;

133 # inherit (hsPkgs) hoogle;

126 } // (

134 } // (

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

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

128− 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+ }]);

129 }

142 }

130 ));

143 ));

131

144

@@ -139,7 +152,7 @@ in

139 nativeBuildInputs = [ ghcEnv ]

152 nativeBuildInputs = [ ghcEnv ]

140 ++ nativeBuildInputs

153 ++ nativeBuildInputs

141 ++ mkDrvArgs.nativeBuildInputs or []

154 ++ mkDrvArgs.nativeBuildInputs or []

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

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

143 # If this shell is a cross compilation shell include

156 # If this shell is a cross compilation shell include

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

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

145 # Includes `--with-compiler` in case the `cabal.project` file has `with-compiler:` in it.

158 # Includes `--with-compiler` in case the `cabal.project` file has `with-compiler:` in it.

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

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

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

163 echo $nativeBuildInputs $buildInputs > $out

176 echo $nativeBuildInputs $buildInputs > $out

164 '';

177 '';

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

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

167

178

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

169 # the correct global package DB.

180 # the correct global package DB.

changelog.md+52

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

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+

4## Apr 8, 2021

56## Apr 8, 2021

5* Project arguments are now validated with the Nix module system.

57* Project arguments are now validated with the Nix module system.

6 If unexpected argments are passed to a project function this may now

58 If unexpected argments are passed to a project function this may now

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+48−31

@@ -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− "R2009" = "nixpkgs-2009";

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

13− "R2105" = "nixpkgs-2105";

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,35 +30,46 @@

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− nixpkgs.lib.optionalAttrs (nixpkgsName == "R2009") {

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

27 ghc865 = false;

34 ghc865 = false;

28− ghc8105 = false;

35+ ghc8107 = true;

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

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

30 ghc865 = false;

37 ghc865 = false;

31− ghc8105 = true;

38+ ghc8107 = true;

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

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

33 ghc865 = false;

40 ghc865 = false;

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

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

35− ghc8105 = true;

42+ ghc8107 = true;

36− ghc901 = true;

43+ ghc902 = true;

37− ghc810420210212 = false;

44+ ghc924 = true;

38 });

45 });

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

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

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

47+ nixpkgs.lib.filter (v:

41− linux = "x86_64-linux";

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

42− darwin = "x86_64-darwin";

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

43− };

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

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

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

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

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

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

47 let lib = nixpkgs.lib;

63 let lib = nixpkgs.lib;

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

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

49 inherit (lib.systems.examples) ghcjs;

67 inherit (lib.systems.examples) ghcjs;

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

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

51− nixpkgsName == "unstable" && (__elem compiler-nix-name ["ghc8105"])) {

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

52− # Windows cross compilation is currently broken on macOS

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

53 inherit (lib.systems.examples) mingwW64;

71 inherit (lib.systems.examples) mingwW64;

54− } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && compiler-nix-name == "ghc8105") {

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

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 inherit (lib.systems.examples) musl64 aarch64-multiplatform;

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

@@ -60,12 +78,11 @@

60in

78in

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

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

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

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

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

64− genericPkgs = import pinnedNixpkgsSrc {};

81+ evalPackages = import pinnedNixpkgsSrc nixpkgsArgs;

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

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

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

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

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

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

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

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

69 platformFilter = platformFilterGeneric pkgs system;

86 platformFilter = platformFilterGeneric pkgs system;

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

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

71 # Native builds

88 # Native builds

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

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

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

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

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

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

81− 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";

82 });

99 });

83 }

100 }

84 //

101 //

85− 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:

86 # Cross builds

103 # Cross builds

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

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

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

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

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

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

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

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

91 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+216−66

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

13, autoreconfHook

14, bash

15

16−, libiconv ? null, ncurses

16+, libiconv ? null

17+

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

17

19

18, installDeps

20, installDeps

19

21

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

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

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

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

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

32

37

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

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

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

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

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

41

46

42, enableDWARF ? false

47, enableDWARF ? false

43

48

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

49+, enableTerminfo ?

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

46

55

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

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

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

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

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

65, extra-passthru ? {}

74, extra-passthru ? {}

66}@args:

75}@args:

67

76

68−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;

69

82

70let

83let

71 inherit (stdenv) buildPlatform hostPlatform targetPlatform;

84 inherit (stdenv) buildPlatform hostPlatform targetPlatform;

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

73

86

74 inherit (bootPkgs) ghc;

87 inherit (bootPkgs) ghc;

75

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+

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

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

77 targetLibffi =

101 targetLibffi =

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

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

85

109

86 targetGmp = targetPackages.gmp or gmp;

110 targetGmp = targetPackages.gmp or gmp;

87

111

112+ targetIconv = targetPackages.libiconv or libiconv;

113+

114+ targetNumactl = targetPackages.numactl or numactl;

115+

88 # TODO(@Ericson2314) Make unconditional

116 # TODO(@Ericson2314) Make unconditional

89 targetPrefix = lib.optionalString

117 targetPrefix = lib.optionalString

90 (targetPlatform != hostPlatform)

118 (targetPlatform != hostPlatform)

@@ -96,7 +124,8 @@ let

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

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

97 endif

125 endif

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

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

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

127+ '' + bignumSpec + ''

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

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

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

101 CrossCompilePrefix = ${targetPrefix}

130 CrossCompilePrefix = ${targetPrefix}

102 '' + lib.optionalString isCrossTarget ''

131 '' + lib.optionalString isCrossTarget ''

@@ -110,6 +139,10 @@ let

110 '' + lib.optionalString enableRelocatedStaticLibs ''

139 '' + lib.optionalString enableRelocatedStaticLibs ''

111 GhcLibHcOpts += -fPIC

140 GhcLibHcOpts += -fPIC

112 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

113 '' + lib.optionalString enableDWARF ''

146 '' + lib.optionalString enableDWARF ''

114 GhcLibHcOpts += -g3

147 GhcLibHcOpts += -g3

115 GhcRtsHcOpts += -g3

148 GhcRtsHcOpts += -g3

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

120 ''

153 ''

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

122 # our elf linker for x86_64 is broken.

155 # our elf linker for x86_64 is broken.

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

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

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

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

125 ''

158 ''

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

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

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

129− + lib.optionalString targetPlatform.isWindows ''

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

130 SplitSections = NO

166 SplitSections = NO

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

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

132 BUILD_PROF_LIBS = NO

168 BUILD_PROF_LIBS = NO

133 '';

169 '';

134

170

135 # Splicer will pull out correct variations

171 # Splicer will pull out correct variations

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

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

137 ++ [targetLibffi]

173 ++ [targetLibffi]

138 ++ lib.optional (!enableIntegerSimple) gmp

174 ++ lib.optional (!enableIntegerSimple) gmp

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

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

140− ++ 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;

141

179

142 toolsForTarget =

180 toolsForTarget =

143 if hostPlatform == buildPlatform then

181 if hostPlatform == buildPlatform then

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

147

185

148 targetCC = builtins.head toolsForTarget;

186 targetCC = builtins.head toolsForTarget;

149

187

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

151− inherit stdenv lib fetchurl

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

153− targetPrefix

154− targetPlatform hostPlatform

155− targetPackages

156− perl autoconf automake m4 python3 sphinx ghc bootPkgs

157− autoreconfHook toolsForTarget bash

158− libDeps

159− useLLVM llvmPackages

160− targetCC

161− enableIntegerSimple targetGmp

162− enableDWARF elfutils

163− ncurses targetLibffi libiconv

164− disableLargeAddressSpace

165− buildMK

166− ;

167− };

168in

188in

169stdenv.mkDerivation (rec {

189stdenv.mkDerivation (rec {

170 version = ghc-version;

190 version = ghc-version;

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

172

192

173 patches = ghc-patches;

193 patches = ghc-patches;

174

194

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

195+ src = if src-spec ? file

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

196+ then src-spec.file

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

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

178− # attrset.

179− src = configured-src;

180

198

181 # configure was run by configured-src already.

199 # configure was run by configured-src already.

182− phases = [ "unpackPhase" "buildPhase"

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

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

202+ ++ [ "configurePhase" "buildPhase"

183 "checkPhase" "installPhase"

203 "checkPhase" "installPhase"

184 "fixupPhase"

204 "fixupPhase"

185 "installCheckPhase"

205 "installCheckPhase"

186 "distPhase"

206 "distPhase"

187 ];

207 ];

188

208

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

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

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

210+ preConfigure =

191− postUnpack = ''

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

192− (cd $sourceRoot

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

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

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

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

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

195−

215+ done

196− # these two are required

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

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

217+ # the *host* tools.

198− --replace "$PREFIX" "$out"

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

199−

219+ export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"

200− substituteInPlace mk/install.mk --replace "$TOP" "$PWD" \

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

201− --replace "$PREFIX" "$out"

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

202−

222+ export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"

203− # these two only for convencience.

223+ export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"

204− substituteInPlace config.log --replace "$TOP" "$PWD"\

224+ export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"

205− --replace "$PREFIX" "$out"

225+ export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"

206− substituteInPlace config.status --replace "$TOP" "$PWD"\

226+ export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"

207− --replace "$PREFIX" "$out")

227+ export STRIP="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}strip"

208−

228+ '' + ''

209−

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"

210− '';

290+ ];

211

291

212 enableParallelBuilding = true;

292 enableParallelBuilding = true;

213 postPatch = "patchShebangs .";

293 postPatch = "patchShebangs .";

@@ -230,9 +310,6 @@ stdenv.mkDerivation (rec {

230

310

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

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

232

312

233− propagatedBuildInputs = [ targetPackages.stdenv.cc ]

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

235−

236 depsTargetTarget = map lib.getDev (libDeps targetPlatform);

313 depsTargetTarget = map lib.getDev (libDeps targetPlatform);

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

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

238

315

@@ -250,7 +327,18 @@ stdenv.mkDerivation (rec {

250 ++ lib.optional stdenv.targetPlatform.isAarch32 "pic"

327 ++ lib.optional stdenv.targetPlatform.isAarch32 "pic"

251 ++ lib.optional stdenv.targetPlatform.isMusl "pie";

328 ++ lib.optional stdenv.targetPlatform.isMusl "pie";

252

329

253− 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+ '' + ''

254 # Install the bash completion file.

342 # Install the bash completion file.

255 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

256

344

@@ -266,11 +354,9 @@ stdenv.mkDerivation (rec {

266 $i

354 $i

267 done

355 done

268

356

269− # Save generated files for needed when building ghcjs

357+ # Save generated files for needed when building ghc and ghcjs

270 mkdir -p $generated/includes/dist-derivedconstants/header

358 mkdir -p $generated/includes/dist-derivedconstants/header

271− cp includes/dist-derivedconstants/header/GHCConstantsHaskellExports.hs \

359+ cp includes/dist-derivedconstants/header/GHCConstantsHaskell*.hs \

272− includes/dist-derivedconstants/header/GHCConstantsHaskellType.hs \

273− includes/dist-derivedconstants/header/GHCConstantsHaskellWrappers.hs \

274 $generated/includes/dist-derivedconstants/header

360 $generated/includes/dist-derivedconstants/header

275 if [[ -f includes/ghcplatform.h ]]; then

361 if [[ -f includes/ghcplatform.h ]]; then

276 cp includes/ghcplatform.h $generated/includes

362 cp includes/ghcplatform.h $generated/includes

@@ -279,6 +365,15 @@ stdenv.mkDerivation (rec {

279 fi

365 fi

280 mkdir -p $generated/compiler/stage2/build

366 mkdir -p $generated/compiler/stage2/build

281 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

282 mkdir -p $generated/rts/build

377 mkdir -p $generated/rts/build

283 cp rts/build/config.hs-incl $generated/rts/build || true

378 cp rts/build/config.hs-incl $generated/rts/build || true

284

379

@@ -322,7 +417,40 @@ stdenv.mkDerivation (rec {

322 # Our Cabal compiler name

417 # Our Cabal compiler name

323 haskellCompilerName = "ghc-${version}";

418 haskellCompilerName = "ghc-${version}";

324

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

325− 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+ });

326

454

327 # 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)

328 isHaskellNixCompiler = true;

456 isHaskellNixCompiler = true;

@@ -332,6 +460,11 @@ stdenv.mkDerivation (rec {

332 enableDWARF = stdenv.targetPlatform.isLinux

460 enableDWARF = stdenv.targetPlatform.isLinux

333 && builtins.compareVersions ghc-version "8.10.2" >= 0;

461 && builtins.compareVersions ghc-version "8.10.2" >= 0;

334 });

462 });

463+

464+ # The same GHC, but without the large (1TB) address space reservation

465+ smallAddressSpace = lib.makeOverridable self (args // {

466+ disableLargeAddressSpace = true;

467+ });

335 } // extra-passthru;

468 } // extra-passthru;

336

469

337 meta = {

470 meta = {

@@ -350,13 +483,30 @@ stdenv.mkDerivation (rec {

350 dontStrip = true;

483 dontStrip = true;

351 dontPatchELF = true;

484 dontPatchELF = true;

352 noAuditTmpdir = true;

485 noAuditTmpdir = true;

353−} // lib.optionalAttrs (ghc-version == "8.10.5" && stdenv.buildPlatform.isDarwin) {

486+} // lib.optionalAttrs (stdenv.buildPlatform.isDarwin || stdenv.targetPlatform.isWindows) {

354 # ghc install on macOS wants to run `xattr -r -c`

487 # ghc install on macOS wants to run `xattr -r -c`

355 # The macOS version fails because it wants python 2.

488 # The macOS version fails because it wants python 2.

356 # The nix version of xattr does not support those args.

489 # The nix version of xattr does not support those args.

357 # Luckily setting the path to something that does not exist will skip the step.

490 # Luckily setting the path to something that does not exist will skip the step.

358− preBuild = ''

491+ preBuild = lib.optionalString stdenv.buildPlatform.isDarwin ''

359 export XATTR=$(mktemp -d)/nothing

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

360 '';

510 '';

361});

511});

362in self

512in self

compiler/ghcjs/ghcjs.nix+9−1

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

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,8 +15,14 @@ let

14

15

15 project = pkgs.buildPackages.haskell-nix.ghcjsProject {

16 project = pkgs.buildPackages.haskell-nix.ghcjsProject {

16 src = ghcjsSrc;

17 src = ghcjsSrc;

17− inherit ghcjsVersion compiler-nix-name;

18+ inherit ghcjsVersion compiler-nix-name overrideBootPackages;

18 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 [];

19# plan-sha256 = "1wy2lr08maxyi7r8jiwf2gj6pdayk5vxxwh42bj4s2gg4035z0yc";

26# plan-sha256 = "1wy2lr08maxyi7r8jiwf2gj6pdayk5vxxwh42bj4s2gg4035z0yc";

20# materialized = ../../materialized/ghcjs;

27# materialized = ../../materialized/ghcjs;

21 };

28 };

@@ -59,6 +66,7 @@ let

59 # 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)

60 isHaskellNixCompiler = true;

67 isHaskellNixCompiler = true;

61 } // ghcjs.components.exes;

68 } // ghcjs.components.exes;

69+ dontUpdateAutotoolsGnuConfigScripts = true;

62 dontConfigure = true;

70 dontConfigure = true;

63 dontInstall = true;

71 dontInstall = true;

64 buildPhase = ''

72 buildPhase = ''

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.json+2−2

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

1{

2 "url": "https://github.com/ghcjs/ghcjs",

3− "rev": "2453b111a20ac99a1b1d4de2c8aaa824be4114f5",

3+ "rev": "bb403ec3a1506831aae2d608b7b21c1937e4fb20",

4− "sha256": "sha256-luapKcU4UUQLgSVh+Locfa/PMe9nZOZI1n9L37nuJdI=",

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/library.md+4−2

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

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/getting-started-flakes.md+33−5

@@ -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

@@ -57,15 +81,19 @@ Add `flake.nix`:

57 hlint = {};

81 hlint = {};

58 haskell-language-server = {};

82 haskell-language-server = {};

59 };

83 };

84+ # Non-Haskell shell tools go here

85+ shell.buildInputs = with pkgs; [

86+ nixpkgs-fmt

87+ ];

60 # This adds `js-unknown-ghcjs-cabal` to the shell.

88 # This adds `js-unknown-ghcjs-cabal` to the shell.

61− shell.crossPlatform = p: [p.ghcjs];

89+ # shell.crossPlatforms = p: [p.ghcjs];

62 };

90 };

63 })

91 })

64 ];

92 ];

65− pkgs = import nixpkgs { inherit system overlays; };

93+ pkgs = import nixpkgs { inherit system overlays; inherit (haskellNix) config; };

66 flake = pkgs.helloProject.flake {

94 flake = pkgs.helloProject.flake {

67 # This adds support for `nix build .#js-unknown-ghcjs-cabal:hello:exe:hello`

95 # This adds support for `nix build .#js-unknown-ghcjs-cabal:hello:exe:hello`

68− crossPlatforms = p: [p.ghcjs];

96+ # crossPlatforms = p: [p.ghcjs];

69 };

97 };

70 in flake // {

98 in flake // {

71 # Built by `nix build .`

99 # Built by `nix build .`

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+19−7

@@ -18,26 +18,38 @@ 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+];

34```

46```

35

47

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

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

37

49

38## Niv

50## Niv

39

51

40−[Niv](https://github.com/nmattia/niv) is a command line tool for keeping tack of Nix project dependencies.

52+[Niv](https://github.com/nmattia/niv) is a command line tool for keeping track of Nix project dependencies.

41

53

42This guide assumes that the `sources.haskellNix` will be set to point

54This guide assumes that the `sources.haskellNix` will be set to point

43a pinned copy of the haskell.nix github repo. One easy way to do this

55a pinned copy of the haskell.nix github repo. One easy way to do this

@@ -87,7 +99,7 @@ let

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

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

89 # But you can also just use your own, e.g. '<nixpkgs>'.

101 # But you can also just use your own, e.g. '<nixpkgs>'.

90− haskellNix.sources.nixpkgs-2009

102+ haskellNix.sources.nixpkgs-unstable

91 # These arguments passed to nixpkgs, include some patches and also

103 # These arguments passed to nixpkgs, include some patches and also

92 # the haskell.nix functionality itself as an overlay.

104 # the haskell.nix functionality itself as an overlay.

93 haskellNix.nixpkgsArgs;

105 haskellNix.nixpkgsArgs;

@@ -174,7 +186,7 @@ Straightforward way of doing this is to change the branch name to a revision.

174

186

175```nix

187```nix

176let sources = {

188let sources = {

177− 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";

178 };

190 };

179```

191```

180

192

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

@@ -2,45 +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/3c6f3f84af60a8ed5b8a79cf3026b7630fcdefb8;

7− nixpkgs-2009.url = github:NixOS/nixpkgs/46d1c3f28ca991601a53e9a14fdd53fcd3dd8416;

6+ nixpkgs-2003 = { url = "github:NixOS/nixpkgs/nixpkgs-20.03-darwin"; };

8− nixpkgs-2105.url = github:NixOS/nixpkgs/3c6f3f84af60a8ed5b8a79cf3026b7630fcdefb8;

7+ nixpkgs-2105 = { url = "github:NixOS/nixpkgs/nixpkgs-21.05-darwin"; };

9− nixpkgs-unstable.url = github:NixOS/nixpkgs/0747387223edf1aa5beaedf48983471315d95e16;

8+ nixpkgs-2111 = { url = "github:NixOS/nixpkgs/nixpkgs-21.11-darwin"; };

9+ nixpkgs-2205 = { url = "github:NixOS/nixpkgs/nixpkgs-22.05-darwin"; };

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− # Use a shim for pkgs that does not depend on `builtins.currentSystem`.

65+ in {

66+ inherit config;

67+ overlay = self.overlays.combined;

18− sources = import ./nix/sources.nix {

68+ overlays = import ./overlays { sources = inputs; };

19− pkgs = { fetchzip = builtins.fetchTarball; };

69+ internal = rec {

70+ nixpkgsArgs = {

71+ inherit config;

72+ overlays = [ self.overlay ];

20− };

73+ };

74+

75+ sources = inputs;

21

76

22− nixpkgsArgs = {

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

23− inherit config;

84+ inherit config;

24− 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+ };

25 };

114 };

26

115

27− overlaysOverrideable = import ./overlays;

116+ # Note: `nix flake check` evaluates outputs for all platforms, and haskell.nix

28− };

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;

29

124

30− # Using the eval-on-build version here as the plan is that

125+ # FIXME: Currently `nix flake check` requires `--impure` because coverage-golden

31− # `builtins.currentSystem` will not be supported in flakes.

126+ # (and maybe other tests) import projects that use builtins.currentSystem

32− # https://github.com/NixOS/rfcs/pull/49/files#diff-a5a138ca225433534de8d260f225fe31R429

127+ checks = builtins.listToAttrs (map (pkg: {

33− overlay = self.overlays.combined-eval-on-build;

128+ name = pkg.name;

34− 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;

35

137

36− legacyPackages = let

138+ devShell = with self.legacyPackages.${system};

37− genAttrs = lst: f:

139+ mkShell {

38− builtins.listToAttrs (map (name: {

140+ buildInputs = [

39− inherit name;

141+ nixUnstable

40− value = f name;

142+ cabal-install

41− }) lst);

143+ haskell-nix.compiler.${compiler}

42− in genAttrs [ "x86_64-linux" "x86_64-darwin" ] (system:

144+ haskell-nix.nix-tools.${compiler}

43− import nixpkgs

145+ ];

44− (self.internal.nixpkgsArgs // { localSystem = { inherit system; }; }));

146+ };

45− };

147+ });

46}

148}

hackage-src.json+4−4

@@ -1,9 +1,9 @@

1{

2 "url": "https://github.com/input-output-hk/hackage.nix",

3− "rev": "eba2b9968363959952d97b2352adab960d294249",

3+ "rev": "9bdefa51c864bbef48a2758b05b4b568f0ded62b",

4− "date": "2021-06-24T01:12:44+00:00",

4+ "date": "2021-08-06T01:11:48+00:00",

5− "path": "/nix/store/34a7r7x93kyrlfr9i0zygnxszs98n0s6-hackage.nix-eba2b99",

5+ "path": "/nix/store/isypgnv4qa5398z6vjc3fi620l4y87c4-hackage.nix-9bdefa5",

6− "sha256": "19gy5nxzsp5rxldbnvblhcq5inmz45wwjsp4ww9mq6f864jz7aqz",

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

@@ -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

@@ -30,17 +30,47 @@ in

30 # An alternative to adding `--sha256` comments into the

31 # cabal.project file:

32 # sha256map =

33+ # { # For a `source-repository-package` use the `location` and `tag` as the key

33− # { "https://github.com/jgm/pandoc-citeproc"."0.17"

34+ # "https://github.com/jgm/pandoc-citeproc"."0.17"

34− # = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q"; };

35+ # = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q";

35−, lookupSha256 ?

36+ # # For a `repository` use the `url` as the key

36− if sha256map != null

37+ # "https://raw.githubusercontent.com/input-output-hk/hackage-overlay-ghcjs/bfc363b9f879c360e0a0460ec0c18ec87222ec32"

37− then { location, tag, ...}: sha256map."${location}"."${tag}"

38+ # = "sha256-g9xGgJqYmiczjxjQ5JOiK5KUUps+9+nlNGI/0SpSOpg=";

38− 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;

39−, 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

40, ...

68, ...

41}@args:

69}@args:

42

70

43let

71let

72+ inherit (evalPackages.haskell-nix) materialize dotCabal;

73+

44 # These defaults are hear rather than in modules/cabal-project.nix to make them

74 # These defaults are hear rather than in modules/cabal-project.nix to make them

45 # lazy enough to avoid infinite recursion issues.

75 # lazy enough to avoid infinite recursion issues.

46 # Using null as the default also improves performance as they are not forced by the

76 # Using null as the default also improves performance as they are not forced by the

@@ -84,15 +114,13 @@ let

84 ghc = ghc';

114 ghc = ghc';

85 subDir' = src.origSubDir or "";

115 subDir' = src.origSubDir or "";

86 subDir = pkgs.lib.strings.removePrefix "/" subDir';

116 subDir = pkgs.lib.strings.removePrefix "/" subDir';

87− maybeCleanedSource =

117+

88− if haskellLib.canCleanSource src

89− then (haskellLib.cleanSourceWith {

118+ cleanedSource = haskellLib.cleanSourceWith {

90− 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";

91− src = src.origSrc or src;

120+ src = src.origSrc or src;

92− filter = path: type: (!(src ? filter) || src.filter path type) && (

121+ filter = path: type: (!(src ? filter) || src.filter path type) && (

93− type == "directory" ||

122+ type == "directory" ||

94− 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" ]); };

95− else src.origSrc or src;

96

124

97 # Using origSrcSubDir bypasses any cleanSourceWith so that it will work when

125 # Using origSrcSubDir bypasses any cleanSourceWith so that it will work when

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

@@ -172,67 +200,104 @@ let

172 builtins.readFile (pkgs.runCommand "hash-path" { preferLocalBuild = true; }

200 builtins.readFile (pkgs.runCommand "hash-path" { preferLocalBuild = true; }

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

174

202

175− replaceSoureRepos = projectFile:

203+ replaceSourceRepos = projectFile:

176 let

204 let

177− fetchRepo = fetchgit: repoData:

205+ fetchPackageRepo = fetchgit: repoData:

178 let

206 let

179 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})

180− if repoData.sha256 != null

215+ else if repoData.sha256 != null

181− then fetchgit { inherit (repoData) url sha256; rev = repoData.ref; }

216+ then fetchgit { inherit (repoData) url sha256; rev = repoData.ref; }

182 else

217 else

183 let drv = builtins.fetchGit { inherit (repoData) url ref; };

218 let drv = builtins.fetchGit { inherit (repoData) url ref; };

184 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)"

185− (__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"

186 drv);

221 drv);

187− in fetched + (if repoData.subdir == "." then "" else "/" + repoData.subdir);

222+ in {

188−

223+ # Download the source-repository-package commit and add it to a minimal git

189− 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.

190− initialText = pkgs.lib.lists.take 1 blocks;

225+ location = evalPackages.runCommand "source-repository-package" {

191− repoBlocks = builtins.map (pkgs.haskell-nix.haskellLib.parseBlock cabalProjectFileName lookupSha256) (pkgs.lib.lists.drop 1 blocks);

226+ nativeBuildInputs = [ evalPackages.rsync evalPackages.gitMinimal ];

192− sourceRepoData = pkgs.lib.lists.concatMap (x: x.sourceRepo) repoBlocks;

227+ } ''

193− otherText = pkgs.evalPackages.writeText "cabal.project" (pkgs.lib.strings.concatStringsSep "\n" (

228+ mkdir $out

194− initialText

229+ rsync -a --prune-empty-dirs "${fetched}/" "$out/"

195− ++ (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;

196

248

197 # we need the repository content twice:

249 # we need the repository content twice:

198 # * at eval time (below to build the fixed project file)

250 # * at eval time (below to build the fixed project file)

199− # Here we want to use pkgs.evalPackages.fetchgit, so one can calculate

251+ # Here we want to use evalPackages.fetchgit, so one can calculate

200 # the build plan for any target without a remote builder

252 # the build plan for any target without a remote builder

201 # * at built time (passed out)

253 # * at built time (passed out)

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

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

204 # and, say, a linux release build job can identify the derivation

256 # and, say, a linux release build job can identify the derivation

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

206− sourceReposEval = builtins.map (fetchRepo pkgs.evalPackages.fetchgit) sourceRepoData ;

258+ sourceReposEval = builtins.map (fetchPackageRepo evalPackages.fetchgit) sourceRepoPackageResult.sourceRepos;

207− sourceReposBuild = builtins.map (fetchRepo pkgs.fetchgit) sourceRepoData;

259+ sourceReposBuild = builtins.map (x: (fetchPackageRepo pkgs.fetchgit x).fetched) sourceRepoPackageResult.sourceRepos;

208 in {

260 in {

209 sourceRepos = sourceReposBuild;

261 sourceRepos = sourceReposBuild;

262+ inherit (repoResult) repos extra-hackages;

210 makeFixedProjectFile = ''

263 makeFixedProjectFile = ''

211− 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) (''

212 chmod +w -R ./cabal.project

267 chmod +w -R ./cabal.project

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

214− printf "\npackages:" >> ./cabal.project

269+ echo >> ./cabal.project

215− mkdir -p ./.source-repository-packages

216 '' +

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.

217− ( pkgs.lib.strings.concatStrings (

284+ replaceLocations = pkgs.lib.strings.concatStrings (

218 pkgs.lib.lists.zipListsWith (n: f: ''

285 pkgs.lib.lists.zipListsWith (n: f: ''

219− mkdir -p ./.source-repository-packages/${builtins.toString n}

286+ (cd $out${subDir'}

220− rsync -a --prune-empty-dirs \

287+ substituteInPlace $tmp${subDir'}/dist-newstyle/cache/plan.json --replace file://${f.location} ${builtins.toString n}

221− --include '*/' --include '*.cabal' --include 'package.yaml' \

288+ for a in $(grep -rl file://${f.location} .plan.nix/*.nix); do

222− --exclude '*' \

289+ substituteInPlace $a --replace file://${f.location} ${builtins.toString n}

223− "${f}/" "./.source-repository-packages/${builtins.toString n}/"

290+ done)

224− echo " ./.source-repository-packages/${builtins.toString n}" >> ./cabal.project

225 '')

291 '')

226 (pkgs.lib.lists.range 0 ((builtins.length sourceReposEval) - 1))

292 (pkgs.lib.lists.range 0 ((builtins.length sourceReposEval) - 1))

227 sourceReposEval

293 sourceReposEval

228− )

294+ );

229− );

230 };

295 };

231

296

232 fixedProject =

297 fixedProject =

233 if rawCabalProject == null

298 if rawCabalProject == null

234− then { sourceRepos = []; makeFixedProjectFile = ""; }

299+ then { sourceRepos = []; repos = {}; extra-hackages = []; makeFixedProjectFile = ""; replaceLocations = ""; }

235− else replaceSoureRepos rawCabalProject;

300+ else replaceSourceRepos rawCabalProject;

236

301

237 # The use of the actual GHC can cause significant problems:

302 # The use of the actual GHC can cause significant problems:

238 # * 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

@@ -303,12 +368,12 @@ let

303 '');

368 '');

304

369

305 # Dummy `ghc` that uses the captured output

370 # Dummy `ghc` that uses the captured output

306− dummy-ghc = pkgs.evalPackages.writeTextFile {

371+ dummy-ghc = evalPackages.writeTextFile {

307 name = "dummy-" + ghc.name;

372 name = "dummy-" + ghc.name;

308 executable = true;

373 executable = true;

309 destination = "/bin/${ghc.targetPrefix}ghc";

374 destination = "/bin/${ghc.targetPrefix}ghc";

310 text = ''

375 text = ''

311− #!${pkgs.evalPackages.runtimeShell}

376+ #!${evalPackages.runtimeShell}

312 case "$*" in

377 case "$*" in

313 --version*)

378 --version*)

314 cat ${dummy-ghc-data}/ghc/version

379 cat ${dummy-ghc-data}/ghc/version

@@ -346,12 +411,12 @@ let

346 };

411 };

347

412

348 # Dummy `ghc-pkg` that uses the captured output

413 # Dummy `ghc-pkg` that uses the captured output

349− dummy-ghc-pkg = pkgs.evalPackages.writeTextFile {

414+ dummy-ghc-pkg = evalPackages.writeTextFile {

350 name = "dummy-pkg-" + ghc.name;

415 name = "dummy-pkg-" + ghc.name;

351 executable = true;

416 executable = true;

352 destination = "/bin/${ghc.targetPrefix}ghc-pkg";

417 destination = "/bin/${ghc.targetPrefix}ghc-pkg";

353 text = ''

418 text = ''

354− #!${pkgs.evalPackages.runtimeShell}

419+ #!${evalPackages.runtimeShell}

355 case "$*" in

420 case "$*" in

356 --version)

421 --version)

357 cat ${dummy-ghc-data}/ghc-pkg/version

422 cat ${dummy-ghc-data}/ghc-pkg/version

@@ -387,10 +452,10 @@ let

387 else null;

452 else null;

388 } // pkgs.lib.optionalAttrs (checkMaterialization != null) {

453 } // pkgs.lib.optionalAttrs (checkMaterialization != null) {

389 inherit checkMaterialization;

454 inherit checkMaterialization;

390− }) (pkgs.evalPackages.runCommand (nameAndSuffix "plan-to-nix-pkgs") {

455+ }) (evalPackages.runCommand (nameAndSuffix "plan-to-nix-pkgs") {

391− 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 ];

392 # Needed or stack-to-nix will die on unicode inputs

457 # Needed or stack-to-nix will die on unicode inputs

393− 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";

394 LANG = "en_US.UTF-8";

459 LANG = "en_US.UTF-8";

395 meta.platforms = pkgs.lib.platforms.all;

460 meta.platforms = pkgs.lib.platforms.all;

396 preferLocalBuild = false;

461 preferLocalBuild = false;

@@ -412,11 +477,11 @@ let

412 '';

477 '';

413 in {

478 in {

414 # These check for cabal configure failure

479 # These check for cabal configure failure

415− json = pkgs.evalPackages.runCommand (nameAndSuffix "plan-json") {} ''

480+ json = evalPackages.runCommand (nameAndSuffix "plan-json") {} ''

416 ${checkCabalConfigure}

481 ${checkCabalConfigure}

417 cp ${plan-nix.maybeJson} $out

482 cp ${plan-nix.maybeJson} $out

418 '';

483 '';

419− freeze = pkgs.evalPackages.runCommand (nameAndSuffix "plan-freeze") {} ''

484+ freeze = evalPackages.runCommand (nameAndSuffix "plan-freeze") {} ''

420 ${checkCabalConfigure}

485 ${checkCabalConfigure}

421 cp ${plan-nix.maybeFreeze} $out

486 cp ${plan-nix.maybeFreeze} $out

422 '';

487 '';

@@ -424,14 +489,18 @@ let

424 } ''

489 } ''

425 tmp=$(mktemp -d)

490 tmp=$(mktemp -d)

426 cd $tmp

491 cd $tmp

427− # if maybeCleanedSource is empty, this means it's a new

492+ # if cleanedSource is empty, this means it's a new

428 # project where the files haven't been added to the git

493 # project where the files haven't been added to the git

429 # repo yet. We fail early and provide a useful error

494 # repo yet. We fail early and provide a useful error

430 # message to prevent headaches (#290).

495 # message to prevent headaches (#290).

431− if [ -z "$(ls -A ${maybeCleanedSource})" ]; then

496+ if [ -z "$(ls -A ${cleanedSource})" ]; then

432− 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}/* .

433 fi

503 fi

434− cp -r ${maybeCleanedSource}/* .

435 chmod +w -R .

504 chmod +w -R .

436 # Decide what to do for each `package.yaml` file.

505 # Decide what to do for each `package.yaml` file.

437 for hpackFile in $(find . -name package.yaml); do (

506 for hpackFile in $(find . -name package.yaml); do (

@@ -454,7 +523,7 @@ let

454 ${pkgs.lib.optionalString (subDir != "") "cd ${subDir}"}

523 ${pkgs.lib.optionalString (subDir != "") "cd ${subDir}"}

455 ${fixedProject.makeFixedProjectFile}

524 ${fixedProject.makeFixedProjectFile}

456 ${pkgs.lib.optionalString (cabalProjectFreeze != null) ''

525 ${pkgs.lib.optionalString (cabalProjectFreeze != null) ''

457− cp ${pkgs.evalPackages.writeText "cabal.project.freeze" cabalProjectFreeze} \

526+ cp ${evalPackages.writeText "cabal.project.freeze" cabalProjectFreeze} \

458 cabal.project.freeze

527 cabal.project.freeze

459 chmod +w cabal.project.freeze

528 chmod +w cabal.project.freeze

460 ''}

529 ''}

@@ -473,15 +542,16 @@ let

473 # which is used by cabal (cached-index-state >= index-state-found).

542 # which is used by cabal (cached-index-state >= index-state-found).

474 dotCabal {

543 dotCabal {

475 inherit cabal-install nix-tools extra-hackage-tarballs;

544 inherit cabal-install nix-tools extra-hackage-tarballs;

545+ extra-hackage-repos = fixedProject.repos;

476 index-state = cached-index-state;

546 index-state = cached-index-state;

477 sha256 = index-sha256-found;

547 sha256 = index-sha256-found;

478 }

548 }

479− } cabal v2-freeze \

549+ } cabal v2-freeze ${

480− --index-state=${

481− # Setting the desired `index-state` here in case it was not

550+ # Setting the desired `index-state` here in case it is not

482− # from the cabal.project file. This will further restrict the

551+ # in the cabal.project file. This will further restrict the

483− # packages used by the solver (cached-index-state >= index-state-found).

552+ # packages used by the solver (cached-index-state >= index-state-found).

484− index-state-found} \

553+ pkgs.lib.optionalString (index-state != null) "--index-state=${index-state}"

554+ } \

485 -w ${

555 -w ${

486 # We are using `-w` rather than `--with-ghc` here to override

556 # We are using `-w` rather than `--with-ghc` here to override

487 # the `with-compiler:` in the `cabal.project` file.

557 # the `with-compiler:` in the `cabal.project` file.

@@ -519,16 +589,15 @@ let

519 # proper relative paths.

589 # proper relative paths.

520 (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 .)

521

591

592+ # Replace the /nix/store paths to minimal git repos with indexes (that will work with materialization).

593+ ${fixedProject.replaceLocations}

594+

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

523 cp $tmp${subDir'}/dist-newstyle/cache/plan.json $maybeJson

596 cp $tmp${subDir'}/dist-newstyle/cache/plan.json $maybeJson

524

597

525 # Remove the non nix files ".project" ".cabal" "package.yaml" files

598 # Remove the non nix files ".project" ".cabal" "package.yaml" files

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

527 # without affecting the nix).

600 # without affecting the nix).

528− if [ -d $out${subDir'}/.source-repository-packages ]; then

529− chmod +w -R $out${subDir'}/.source-repository-packages

530− rm -rf $out${subDir'}/.source-repository-packages

531− fi

532 find $out $ -type f -or -type l $ ! -name '*.nix' -delete

601 find $out $ -type f -or -type l $ ! -name '*.nix' -delete

533 # Remove empty dirs

602 # Remove empty dirs

534 find $out -type d -empty -delete

603 find $out -type d -empty -delete

@@ -559,5 +628,5 @@ in {

559 projectNix = plan-nix;

628 projectNix = plan-nix;

560 index-state = index-state-found;

629 index-state = index-state-found;

561 inherit src;

630 inherit src;

562− inherit (fixedProject) sourceRepos;

631+ inherit (fixedProject) sourceRepos extra-hackages;

563}

632}

lib/call-stack-to-nix.nix+21−22

@@ -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,24 +14,24 @@

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

26− subDir = pkgs.lib.strings.removePrefix "/" subDir';

28+ subDir = evalPackages.lib.strings.removePrefix "/" subDir';

27− maybeCleanedSource =

28− if haskellLib.canCleanSource src

29− then (haskellLib.cleanSourceWith {

29+ cleanedSource = (haskellLib.cleanSourceWith {

30− name = if name != null then "${name}-root-cabal-files" else "source-root-cabal-files";

30+ name = if name != null then "${name}-root-cabal-files" else "source-root-cabal-files";

31− src = src.origSrc or src;

31+ src = src.origSrc or src;

32− filter = path: type: (!(src ? filter) || src.filter path type) && (

32+ filter = path: type: (!(src ? filter) || src.filter path type) && (

33− type == "directory" ||

33+ type == "directory" ||

34− pkgs.lib.any (i: (pkgs.lib.hasSuffix i path)) [ stackYaml ".cabal" "package.yaml" ]); })

34+ evalPackages.lib.any (i: (evalPackages.lib.hasSuffix i path)) [ stackYaml ".cabal" "package.yaml" ]); });

35− else src.origSrc or src;

36

35

37 stackToNixArgs = builtins.concatStringsSep " " [

36 stackToNixArgs = builtins.concatStringsSep " " [

38 "--full"

37 "--full"

@@ -46,12 +45,12 @@ let

46 sha256Arg = "stack-sha256";

45 sha256Arg = "stack-sha256";

47 reasonNotSafe = null;

46 reasonNotSafe = null;

48 this = "project.stack-nix" + (if name != null then " for ${name}" else "");

47 this = "project.stack-nix" + (if name != null then " for ${name}" else "");

49− } // pkgs.lib.optionalAttrs (checkMaterialization != null) {

48+ } // evalPackages.lib.optionalAttrs (checkMaterialization != null) {

50 inherit checkMaterialization;

49 inherit checkMaterialization;

51 }) (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") {

52− 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 ];

53 # Needed or stack-to-nix will die on unicode inputs

52 # Needed or stack-to-nix will die on unicode inputs

54− 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";

55 LANG = "en_US.UTF-8";

54 LANG = "en_US.UTF-8";

56 LC_ALL = "en_US.UTF-8";

55 LC_ALL = "en_US.UTF-8";

57 preferLocalBuild = false;

56 preferLocalBuild = false;

@@ -59,18 +58,18 @@ let

59 mkdir -p $out${subDir'}

58 mkdir -p $out${subDir'}

60 SRC=$(mktemp -d)

59 SRC=$(mktemp -d)

61 cd $SRC

60 cd $SRC

62− # if maybeCleanedSource is empty, this means it's a new

61+ # if cleanedSource is empty, this means it's a new

63 # project where the files haven't been added to the git

62 # project where the files haven't been added to the git

64 # repo yet. We fail early and provide a useful error

63 # repo yet. We fail early and provide a useful error

65 # message to prevent headaches (#290).

64 # message to prevent headaches (#290).

66− if [ -z "$(ls -A ${maybeCleanedSource})" ]; then

65+ if [ -z "$(ls -A ${cleanedSource})" ]; then

67 echo "cleaned source is empty. Did you forget to 'git add -A'?"; exit 1;

66 echo "cleaned source is empty. Did you forget to 'git add -A'?"; exit 1;

68 fi

67 fi

69− lndir -silent "${maybeCleanedSource}/." $SRC

68+ lndir -silent "${cleanedSource}/." $SRC

70− ${pkgs.lib.optionalString (subDir != "") "cd ${subDir}"}

69+ ${evalPackages.lib.optionalString (subDir != "") "cd ${subDir}"}

71 ${

70 ${

72 # If a resolver was fetched use the it instead of the original stack.yaml

71 # If a resolver was fetched use the it instead of the original stack.yaml

73− pkgs.lib.optionalString (fetchedResolver != null)

72+ evalPackages.lib.optionalString (fetchedResolver != null)

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

75 ''

74 ''

76 rm ${stackYaml}

75 rm ${stackYaml}

@@ -78,7 +77,7 @@ let

78 chmod +w ${stackYaml}

77 chmod +w ${stackYaml}

79 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

78 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

80 ''}

79 ''}

81− ${pkgs.lib.optionalString (cache != null) ''

80+ ${evalPackages.lib.optionalString (cache != null) ''

82 cp ${mkCacheFile cache}/.stack-to-nix.cache* $out${subDir'}

81 cp ${mkCacheFile cache}/.stack-to-nix.cache* $out${subDir'}

83 ''}

82 ''}

84 (cd $out${subDir'} && stack-to-nix ${stackToNixArgs})

83 (cd $out${subDir'} && stack-to-nix ${stackToNixArgs})

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− # Using `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+8−4

@@ -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

@@ -112,7 +116,7 @@ then

112 # `git ls-files --recurse-submodules` to give us an accurate list

116 # `git ls-files --recurse-submodules` to give us an accurate list

113 # of all the files in the index.

117 # of all the files in the index.

114 whitelist_files = knownSubmoduleDirs:

118 whitelist_files = knownSubmoduleDirs:

115− runCommand "git-ls-files" {} ''

119+ runCommand "git-ls-files" { preferLocalBuild = true; } ''

116 tmp=$(mktemp -d)

120 tmp=$(mktemp -d)

117 cd $tmp

121 cd $tmp

118 ${ lib.optionalString hasSubmodules ''

122 ${ lib.optionalString hasSubmodules ''

@@ -135,7 +139,7 @@ then

135 ${git}/bin/git ls-files --recurse-submodules > $out/files

139 ${git}/bin/git ls-files --recurse-submodules > $out/files

136 '';

140 '';

137

141

138− # Find the submodules

142+ # Find the submodules

139 whitelist_recursive = knownSubmoduleDirs:

143 whitelist_recursive = knownSubmoduleDirs:

140 let

144 let

141 # Get the new list of submoduleDirs and files

145 # Get the new list of submoduleDirs and files

@@ -176,7 +180,7 @@ then

176 );

180 );

177

181

178 # Identify files in the `.git` dir

182 # Identify files in the `.git` dir

179− isGitDirPath = path:

183+ isGitDirPath = path:

180 path == origSrcSubDir + "/.git"

184 path == origSrcSubDir + "/.git"

181 || lib.hasPrefix (origSrcSubDir + "/.git/") path;

185 || lib.hasPrefix (origSrcSubDir + "/.git/") path;

182

186

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

@@ -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

@@ -337,22 +316,31 @@ in {

337 # Run evalModules passing the project function argument (m) as a module along with

316 # Run evalModules passing the project function argument (m) as a module along with

338 # the the a projectType module (../modules/cabal-project.nix or ../modules/stack-project.nix).

317 # the the a projectType module (../modules/cabal-project.nix or ../modules/stack-project.nix).

339 # The resulting config is then passed to the project function's implementation.

318 # The resulting config is then passed to the project function's implementation.

340− evalProjectModule = projectType: m: f: f

319+ evalProjectModule = projectType: m: f:

320+ let project = f

341 (lib.evalModules {

321 (lib.evalModules {

342 modules = (if builtins.isList m then m else [m]) ++ [

322 modules = (if builtins.isList m then m else [m]) ++ [

343 # Include ../modules/cabal-project.nix or ../modules/stack-project.nix

323 # Include ../modules/cabal-project.nix or ../modules/stack-project.nix

344 (import ../modules/project-common.nix)

324 (import ../modules/project-common.nix)

345 (import projectType)

325 (import projectType)

346− # Pass the pkgs to the modules

326+ # Pass the pkgs and the buildProject to the modules

347 ({ config, lib, ... }: {

327 ({ config, lib, ... }: {

348 _module.args = {

328 _module.args = {

349 inherit pkgs;

329 inherit pkgs;

330+ # to make it easy to depends on build packages in, eg., shell definition:

331+ inherit (project) buildProject;

350 };

332 };

333+ inherit (project) hsPkgs;

351 })

334 })

352 ];

335 ];

353 }).config;

336 }).config;

337+ in project;

354

338

355 # Converts from a `compoent.depends` value to a library derivation.

339 # Converts from a `compoent.depends` value to a library derivation.

356 # In the case of sublibs the `depends` value should already be the derivation.

340 # In the case of sublibs the `depends` value should already be the derivation.

357 dependToLib = d: d.components.library or d;

341 dependToLib = d: d.components.library or d;

342+

343+ projectOverlays = import ./project-overlays.nix {

344+ inherit lib haskellLib;

345+ };

358}

346}

lib/ghcjs-project.nix+47−11

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

@@ -39,7 +39,7 @@

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.4.0.0";

42+ version = "3.6.2.0";

43 materialized = ../materialized/ghcjs/cabal + "/${compiler-nix-name}";

44 }

45 else pkgs.haskell-nix.tool compiler-nix-name "cabal" {

@@ -52,6 +52,8 @@

52 '';

53 materialized = ../materialized/ghcjs/cabal + "/${compiler-nix-name}";

54 }

55+, overrideBootPackages ? []

56+, patches ? []

55, ...

57, ...

56}@args:

58}@args:

57let

59let

@@ -75,7 +77,11 @@ let

75

77

76 # Inputs needed to boot the GHCJS compiler

78 # Inputs needed to boot the GHCJS compiler

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

78− nodejs

84+ nodejs-18_x

79 makeWrapper

85 makeWrapper

80 xorg.lndir

86 xorg.lndir

81 gmp

87 gmp

@@ -83,9 +89,9 @@ let

83 ]

89 ]

84 ++ [ ghc cabal-install emsdk ];

90 ++ [ ghc cabal-install emsdk ];

85 # Configured the GHCJS source

91 # Configured the GHCJS source

86− configured-src = pkgs.runCommand "configured-ghcjs-src" {

92+ configured-src = (pkgs.runCommandCC "configured-ghcjs-src" {

87 buildInputs = configureInputs;

93 buildInputs = configureInputs;

88− inherit src;

94+ inherit src patches;

89 } ''

95 } ''

90 export HOME=$(pwd)

96 export HOME=$(pwd)

91 mkdir $HOME/.cabal

97 mkdir $HOME/.cabal

@@ -94,6 +100,11 @@ let

94 chmod -R +w "$out"

100 chmod -R +w "$out"

95 cd "$out"

101 cd "$out"

96

102

103+ for p in $patches

104+ do

105+ patch -p1 <$p

106+ done

107+

97 # TODO: Find a better way to avoid impure version numbers

108 # TODO: Find a better way to avoid impure version numbers

98 sed -i 's/RELEASE=NO/RELEASE=YES/' ghc/configure.ac

109 sed -i 's/RELEASE=NO/RELEASE=YES/' ghc/configure.ac

99 sed -i 's/${ghcjsVersion}/${ghcVersion}/' ghcjs.cabal

110 sed -i 's/${ghcjsVersion}/${ghcVersion}/' ghcjs.cabal

@@ -126,18 +137,43 @@ let

126 for a in integer-gmp base unix; do

137 for a in integer-gmp base unix; do

127 cp ${../overlays/patches/config.sub} lib/boot/pkg/$a/config.sub

138 cp ${../overlays/patches/config.sub} lib/boot/pkg/$a/config.sub

128 done

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;

129− '';

158+ };

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

131

160

132 ghcjsProject = pkgs.haskell-nix.cabalProject' (

161 ghcjsProject = pkgs.haskell-nix.cabalProject' (

133− (pkgs.lib.filterAttrs

162+ (pkgs.lib.filterAttrs

134 (n: _: !(builtins.any (x: x == n)

163 (n: _: !(builtins.any (x: x == n)

135− ["src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"])) args) // {

164+ [ "src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"

165+ "overrideBootPackages" "patches"])) args) // {

136 src = configured-src;

166 src = configured-src;

137 index-state = "2021-03-20T00:00:00Z";

167 index-state = "2021-03-20T00:00:00Z";

138− compiler-nix-name = if isGhcjs810 then "ghc8105" else if isGhcjs88 then "ghc884" else "ghc865";

168+ inherit compiler-nix-name;

139 configureArgs = pkgs.lib.optionalString (isGhcjs88 && !isGhcjs810) "--constraint='Cabal >=3.0.2.0 && <3.1'";

169 configureArgs = pkgs.lib.optionalString (isGhcjs88 && !isGhcjs810) "--constraint='Cabal >=3.0.2.0 && <3.1'";

140− materialized = ../materialized + (if isGhcjs810 then "/ghcjs8105" else if isGhcjs88 then "/ghcjs884" else "/ghcjs865");

170+ # If a package is in both build-depends and build-tool-depends multiple versions may

171+ # be in the `plan.json` file. Haskell.nix will pick the newer one, but when nbuilding

172+ # ghcjs 8.6 we need to use the older happy version.

173+ pkg-def-extras = pkgs.lib.optional (!isGhcjs88) (hackage: {

174+ packages.happy.revision = hackage.happy."1.19.9".revisions.default;

175+ });

176+ materialized = ../materialized + "/ghcjs/${compiler-nix-name}";

141 modules = [

177 modules = [

142 {

178 {

143 # we need ghc-boot in here for ghcjs.

179 # we need ghc-boot in here for ghcjs.

@@ -150,6 +186,7 @@ let

150 packages.Cabal.patches = [ ./../overlays/patches/Cabal/fix-data-dir.patch ];

186 packages.Cabal.patches = [ ./../overlays/patches/Cabal/fix-data-dir.patch ];

151 })

187 })

152 {

188 {

189+ ghcOptions = ["-O2"];

153 packages.ghcjs.doHaddock = false;

190 packages.ghcjs.doHaddock = false;

154 packages.haddock-ghcjs.doHaddock = false;

191 packages.haddock-ghcjs.doHaddock = false;

155 packages.haddock-api-ghcjs.doHaddock = false;

192 packages.haddock-api-ghcjs.doHaddock = false;

@@ -179,4 +216,3 @@ in ghcjsProject // {

179 };

216 };

180 inherit configureInputs bootInputs configured-src emscriptenupstream emscripten emsdk;

217 inherit configureInputs bootInputs configured-src emscriptenupstream emscripten emsdk;

181}

218}

182−

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+8−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" ];

@@ -46,6 +47,7 @@ pkgs:

46 "gobject-2.0" = [ pkgs."glib" ];

47 "gobject-2.0" = [ pkgs."glib" ];

47 "gmodule-2.0" = [ pkgs."glib" ];

48 "gmodule-2.0" = [ pkgs."glib" ];

48 "gobject-introspection-1.0" = [ pkgs."gobject-introspection" ];

49 "gobject-introspection-1.0" = [ pkgs."gobject-introspection" ];

50+ "graphene-gobject-1.0" = [ pkgs."graphene" ];

49 "gstreamer-audio-0.10" = [ pkgs."gst-plugins-base" ];

51 "gstreamer-audio-0.10" = [ pkgs."gst-plugins-base" ];

50 "gstreamer-audio-1.0" = [ pkgs."gst-plugins-base" ];

52 "gstreamer-audio-1.0" = [ pkgs."gst-plugins-base" ];

51 "gstreamer-base-0.10" = [ pkgs."gst-plugins-base" ];

53 "gstreamer-base-0.10" = [ pkgs."gst-plugins-base" ];

@@ -65,6 +67,7 @@ pkgs:

65 "hidapi-libusb" = [ pkgs."hidapi" ];

67 "hidapi-libusb" = [ pkgs."hidapi" ];

66 "icudata" = [ pkgs."icu" ];

68 "icudata" = [ pkgs."icu" ];

67 "icui18n" = [ pkgs."icu" ];

69 "icui18n" = [ pkgs."icu" ];

70+ "icu-i18n" = [ pkgs."icu" ];

68 "icuuc" = [ pkgs."icu" ];

71 "icuuc" = [ pkgs."icu" ];

69 "idn" = [ pkgs."libidn" ];

72 "idn" = [ pkgs."libidn" ];

70 "IL" = [ pkgs."libdevil" ];

73 "IL" = [ pkgs."libdevil" ];

@@ -81,7 +84,9 @@ pkgs:

81 "ldap" = [ pkgs."openldap" ];

84 "ldap" = [ pkgs."openldap" ];

82 "libavutil" = [ pkgs."ffmpeg" ];

85 "libavutil" = [ pkgs."ffmpeg" ];

83 "libcrypto" = [ pkgs."openssl".dev ];

86 "libcrypto" = [ pkgs."openssl".dev ];

87+ "libfreenect" = [ pkgs."freenect" ];

84 "libgsasl" = [ pkgs."gsasl" ];

88 "libgsasl" = [ pkgs."gsasl" ];

89+ "liboath" = [ pkgs."liboauth" ];

85 "libpcre" = [ pkgs."pcre" ];

90 "libpcre" = [ pkgs."pcre" ];

86 "libqrencode" = [ pkgs."qrencode" ];

91 "libqrencode" = [ pkgs."qrencode" ];

87 "libR" = [ pkgs."R" ];

92 "libR" = [ pkgs."R" ];

@@ -96,6 +101,7 @@ pkgs:

96 "libxml-2.0" = [ pkgs."libxml2" ];

101 "libxml-2.0" = [ pkgs."libxml2" ];

97 "libzip" = [ pkgs."libzip" ];

102 "libzip" = [ pkgs."libzip" ];

98 "libzmq" = [ pkgs."zeromq" ];

103 "libzmq" = [ pkgs."zeromq" ];

104+ "libzstd" = [ pkgs."zstd" ];

99 "m" = []; # in stdenv

105 "m" = []; # in stdenv

100 "magic" = [ pkgs."file" ];

106 "magic" = [ pkgs."file" ];

101 "MagickWand" = [ pkgs."imagemagick" ];

107 "MagickWand" = [ pkgs."imagemagick" ];

@@ -116,6 +122,7 @@ pkgs:

116 "pfs-1.2" = [ pkgs."pfstools" ];

122 "pfs-1.2" = [ pkgs."pfstools" ];

117 "png" = [ pkgs."libpng" ];

123 "png" = [ pkgs."libpng" ];

118 "poppler-glib" = [ pkgs."poppler" ];

124 "poppler-glib" = [ pkgs."poppler" ];

125+ "poppler-cpp" = [ pkgs."poppler" ];

119 "pq" = [ pkgs."postgresql" ];

126 "pq" = [ pkgs."postgresql" ];

120 "libpq" = [ pkgs."postgresql" ];

127 "libpq" = [ pkgs."postgresql" ];

121 "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 = {}; }; }; })