iko/ghcjs-patch-master..962ecfe · haskell.nix

.buildkite/pipeline.yml+5−17

since splitsnapshots

unifiedsplit

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

1steps:

2− - label: 'Run tests with ghc8107'

2+ - label: 'Run tests with ghc884'

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

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

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

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

18 command:

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

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

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

21 - ./check-closure-size.sh

22 agents:

@@ -36,17 +36,5 @@ 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 ghc8107 -o check-path-support.sh

39+ - nix-build build.nix -A maintainer-scripts.check-path-support --argstr compiler-nix-name ghc884 -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+10−3

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

1steps:

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

2+ - label: 'Update hackage.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:

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

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

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

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

9 - ./update-stackage.sh

16 - ./update-stackage.sh

10 artifact_paths:

17 artifact_paths:

11− - "flake.lock"

18+ - "stackage-src.json"

12 agents:

19 agents:

13 system: x86_64-linux

20 system: x86_64-linux

14

21

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

17

24

18 - label: 'Update pins'

25 - label: 'Update pins'

19 command:

26 command:

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

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

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

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

22 - ./update-pins.sh

29 - ./update-pins.sh

23 agents:

30 agents:

.github/workflows/rebase.yamldeleted−28

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

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.ymldeleted−51

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

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+6−22

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

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−

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

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

18

2

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

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

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

24

8

25## Documentation

9## Documentation

26

10

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

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

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

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

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

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

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

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

31

15

32## Help! Something isn't working

16## Help! Something isn't working

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

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

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

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

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

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

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

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

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

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

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

39

23

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

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

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

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

42

26

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

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

44

28

45## Related repos

29## Related repos

46

30

build.nix+12−28

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

5let

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

7in

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

8+{ nixpkgs ? haskellNix.sources.nixpkgs

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

14, ifdLevel ? 1000

11, ifdLevel ? 1000

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

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

16}:

13}:

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

20 buildHaskell = pkgs.buildPackages.haskell-nix;

17 buildHaskell = pkgs.buildPackages.haskell-nix;

21 tool = buildHaskell.tool;

18 tool = buildHaskell.tool;

22in rec {

19in rec {

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

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

24

21

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

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

26− pkgs.recurseIntoAttrs ({

23+ pkgs.recurseIntoAttrs {

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

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

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

29− inherit evalPackages;

30− version = {

31− "ghc865" = "3.2.8";

32− "ghc882" = "3.3.6";

33− "ghc883" = "3.3.6";

34− "ghc884" = "3.3.6";

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

36− };

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

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

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

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

39− })

27+ }

40 );

28 );

41

29

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

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

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

46 maintainer-scripts = pkgs.dontRecurseIntoAttrs {

34 maintainer-scripts = pkgs.dontRecurseIntoAttrs {

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

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

48 inherit (pkgs) stdenv lib writeScript coreutils glibc git

36 inherit (pkgs) stdenv lib writeScript coreutils glibc git

49− openssh nixFlakes gawk bash curl findutils;

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

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

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

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

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

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

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

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

54 };

42 };

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

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

56 inherit (pkgs) stdenv lib writeScript coreutils glibc git

44 inherit (pkgs) stdenv lib writeScript coreutils glibc git

57− openssh nixFlakes gawk bash curl findutils;

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

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

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

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

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

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

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

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

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

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

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

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

70 # use)

58 # use)

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

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

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

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

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

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

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

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

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

77 ];

65 ];

78 };

66 };

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

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

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

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

85 };

69 };

86

70

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

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

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

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

89 maintainer-script-cache = pkgs.recurseIntoAttrs (

73 maintainer-script-cache = pkgs.recurseIntoAttrs (

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

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

91 inherit (maintainer-scripts) check-hydra;

75 inherit (maintainer-scripts) check-hydra;

92 })

76 })

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

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

builder/Setup.ghcjs.hsdeleted−272

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

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.hsdeleted−2

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

1−import Distribution.Simple

2−main = defaultMain

builder/comp-builder.nix+40−157

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

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

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

2lib.makeOverridable (

3let self =

4{ componentId

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

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

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

25, shellHook ? ""

26−, configureAllComponents ? component.configureAllComponents ||

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

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

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

30− ( haskellLib.isTest componentId &&

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

32− )

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

34

26

35, build-tools ? component.build-tools

27, build-tools ? component.build-tools

36, pkgconfig ? component.pkgconfig

28, pkgconfig ? component.pkgconfig

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

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

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

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

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

49, enableDeadCodeElimination ? component.enableDeadCodeElimination

41, enableDeadCodeElimination ? component.enableDeadCodeElimination

50−, writeHieFiles ? component.writeHieFiles

51

42

52, ghcOptions ? component.ghcOptions

43, ghcOptions ? component.ghcOptions

53−, contentAddressed ? component.contentAddressed

54

44

55# Options for Haddock generation

45# Options for Haddock generation

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

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

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

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

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

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

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

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

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

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

61, setupHaddockFlags ? component.setupHaddockFlags

51, setupHaddockFlags ? component.setupHaddockFlags

62

52

63# Profiling

53# Profiling

64, enableLibraryProfiling ? component.enableLibraryProfiling

54, enableLibraryProfiling ? component.enableLibraryProfiling

65−, enableProfiling ? component.enableProfiling

55+, enableExecutableProfiling ? component.enableExecutableProfiling

66, profilingDetail ? component.profilingDetail

56, profilingDetail ? component.profilingDetail

67

57

68# Coverage

58# Coverage

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

83

73

84# LLVM

74# LLVM

85, useLLVM ? ghc.useLLVM

75, useLLVM ? ghc.useLLVM

86−, smallAddressSpace ? false

87

76

88}@drvArgs:

77}@drvArgs:

89

78

90let

79let

91− componentForSetup =

92− if configureAllComponents

93− then allComponent

94− else component;

95−

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

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

97 enableDWARF = drvArgs.enableDWARF or false

81 enableDWARF = drvArgs.enableDWARF or false

98 && stdenv.hostPlatform.isLinux

82 && stdenv.hostPlatform.isLinux

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

100 && !stdenv.hostPlatform.isMusl

84 && !stdenv.hostPlatform.isMusl

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

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

102

86

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

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

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

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

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

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

107

89

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

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

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

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

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

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

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

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

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

116 cleanSrc = haskellLib.rootAndSubDir (if canCleanSource

98 cleanSrc = haskellLib.rootAndSubDir (if canCleanSource

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

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

118 else

100 else

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

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

120 # from triggering a rebuild of this one.

102 # from triggering a rebuild of this one.

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

133

115

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

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

135

117

136− needsProfiling = enableProfiling || enableLibraryProfiling;

118+ needsProfiling = enableExecutableProfiling || enableLibraryProfiling;

137

119

138 configFiles = makeConfigFiles {

120 configFiles = makeConfigFiles {

139− component = componentForSetup;

140 inherit (package) identifier;

121 inherit (package) identifier;

141− inherit fullName flags needsProfiling enableDWARF;

122+ inherit component fullName flags needsProfiling enableDWARF;

142 };

123 };

143

124

144 enableFeature = enable: feature:

125 enableFeature = enable: feature:

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

148

129

149 finalConfigureFlags = lib.concatStringsSep " " (

130 finalConfigureFlags = lib.concatStringsSep " " (

150 [ "--prefix=$out"

131 [ "--prefix=$out"

151− ] ++

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

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

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

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

156− lib.optionals writeHieFiles [

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

158− ] ++

159− (

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

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

162− if configureAllComponents

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

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

132+ "${haskellLib.componentTarget componentId}"

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

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

166 ] ++ commonConfigureFlags);

134 ] ++ commonConfigureFlags);

167

135

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

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

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

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

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

181 ] ++

149 ] ++

182 # BINTOOLS

150 # BINTOOLS

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

151+ (if stdenv.hostPlatform.isLinux

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

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

185 then [

153 then [

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

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

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

197 (disableFeature dontStrip "executable-stripping")

165 (disableFeature dontStrip "executable-stripping")

198 (disableFeature dontStrip "library-stripping")

166 (disableFeature dontStrip "library-stripping")

199 (enableFeature enableLibraryProfiling "library-profiling")

167 (enableFeature enableLibraryProfiling "library-profiling")

200− (enableFeature enableProfiling "profiling")

168+ (enableFeature enableExecutableProfiling "executable-profiling")

201 (enableFeature enableStatic "static")

169 (enableFeature enableStatic "static")

202 (enableFeature enableShared "shared")

170 (enableFeature enableShared "shared")

203 (enableFeature doCoverage "coverage")

171 (enableFeature doCoverage "coverage")

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

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

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

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

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

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

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

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

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

209 # component.

177 # component.

210 "--disable-executable-dynamic"

178 "--disable-executable-dynamic"

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

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

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

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

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

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

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

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

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

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

216 ++ lib.optionals haskellLib.isCrossHost (

184 ++ lib.optionals haskellLib.isCrossHost (

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

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

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

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

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

226 ]

194 ]

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

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

236 );

196 );

237

197

238 executableToolDepends =

198 executableToolDepends =

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

246 shellWrappers = ghcForComponent {

206 shellWrappers = ghcForComponent {

247 componentName = fullName;

207 componentName = fullName;

248 inherit configFiles enableDWARF;

208 inherit configFiles enableDWARF;

249− inherit (component) plugins;

250 };

209 };

251

210

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

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

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

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

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

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

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

283 ''

242 ''

284− ) +

243+ ) +

285 (if cabalFile != null

244 (if cabalFile != null

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

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

287 else

246 else

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

317 componentDrv = drv;

276 componentDrv = drv;

318 };

277 };

319

278

320− contentAddressedAttrs = lib.optionalAttrs contentAddressed {

321− __contentAddressed = true;

322− outputHashMode = "recursive";

323− outputHashAlgo = "sha256";

324− };

325−

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

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

327 pname = nameOnly;

280 pname = nameOnly;

328 inherit (package.identifier) version;

281 inherit (package.identifier) version;

329

282

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

356 description = package.synopsis or "";

309 description = package.synopsis or "";

357 license = haskellLib.cabalToNixpkgsLicense package.license;

310 license = haskellLib.cabalToNixpkgsLicense package.license;

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

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

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

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

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

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

363− # attempt to run, for example,

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

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

366− mainProgram = exeName;

367 };

312 };

368

313

369 propagatedBuildInputs =

314 propagatedBuildInputs =

370 frameworks # Frameworks will be needed at link time

315 frameworks # Frameworks will be needed at link time

371 # Not sure why pkgconfig needs to be propagatedBuildInputs but

316 # Not sure why pkgconfig needs to be propagatedBuildInputs but

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

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

373− ++ builtins.concatLists pkgconfig

318+ ++ builtins.concatLists pkgconfig;

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

375− (lib.flatten component.libs

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

377

319

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

379− (lib.flatten component.libs

320+ buildInputs = component.libs

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

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

381

322

382 nativeBuildInputs =

323 nativeBuildInputs =

383 [shellWrappers buildPackages.removeReferencesTo]

324 [shellWrappers buildPackages.removeReferencesTo]

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

385

326

386 outputs = ["out" ]

327 outputs = ["out" ]

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

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

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

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

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

390

330

391− prePatch =

331+ configurePhase =

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

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

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

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

394 export HOME=$(mktemp -d)

334 export HOME=$(mktemp -d)

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

400 cp -r . $source

340 cp -r . $source

401 cd $source

341 cd $source

402 chmod -R +w .

342 chmod -R +w .

403− '') + commonAttrs.prePatch;

343+ '') + ''

404−

405− configurePhase = ''

406 runHook preConfigure

344 runHook preConfigure

407 echo Configure flags:

345 echo Configure flags:

408 printf "%q " ${finalConfigureFlags}

346 printf "%q " ${finalConfigureFlags}

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

411 runHook postConfigure

349 runHook postConfigure

412 '';

350 '';

413

351

414− buildPhase =

352+ buildPhase = ''

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

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

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

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

419− # list when we need it.

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

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

422− '') +

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

424−

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

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

427− # where the binary cache becomes useless

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

429− (if contentAddressed then ''

430− runHook preBuild

353+ 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

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

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

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

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

442− runHook postBuild

356+ runHook postBuild

443− '');

357+ '';

444

358

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

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

446 #

360 #

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

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

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

455 in ''

369 in ''

456 runHook preInstall

370 runHook preInstall

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

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

458− setupInstallFlags

459− ++ lib.optional configureAllComponents

460− (haskellLib.componentTarget componentId)

461− )}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

517 '' else ''

427 '' else ''

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

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

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

520 fi

430 fi

521 '')

431 '')

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

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

523− + (lib.optionalString enableSeparateDataOutput ''

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

524− mkdir -p $data

525− '')

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

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

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

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

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

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

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

530 done

438 done

531 ''

439 ''

532 # symlink all .dlls into the local directory.

440 # symlink all .dlls into the local directory.

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

442+ # to symlink over dlls as needed.

533 + ''

443 + ''

534− for p in $pkgsHostTargetAsString; do

444+ echo "Symlink library dependencies..."

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

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

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

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

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

448+ fi

537 done

449 done

538 ''))

450 ''))

539 + (lib.optionalString doCoverage ''

451 + (lib.optionalString doCoverage ''

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

543 '')

455 '')

544 }

456 }

545 runHook postInstall

457 runHook postInstall

546− '' + (

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

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

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

550− # circular references.

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

458+ '' + (lib.optionalString keepSource ''

552− mv dist dist-tmp-dir

553− mkdir -p dist/build

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

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

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

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

558− fi

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

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

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

562− fi

563− rm -rf dist-tmp-dir

459+ rm -rf dist

564− ''

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

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

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

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

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

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

569 '');

462 '');

570

463

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−

581 shellHook = ''

464 shellHook = ''

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

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

583 ${shellHookApplied}

466 ${shellHookApplied}

builder/default.nix+15−23

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

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

1+{ pkgs, buildPackages, 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 pkgconfig;

20+ inherit (buildPackages) stdenv;

21− inherit buildPackages;

21+ inherit buildPackages pkgconfig;

22 inherit haskellLib nonReinstallablePkgs makeSetupConfigFiles;

23 };

24

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

26 # component builder and for nix-shells.

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

28 inherit lib ghc haskellLib;

29− inherit (buildPackages) stdenv;

29+ inherit (buildPackages) stdenv runCommand makeWrapper;

30− inherit (buildPackages.buildPackages) runCommand makeWrapper;

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

30+ inherit (buildPackages.xorg) lndir;

32 };

31 };

33

32

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

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

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

45

44

46 hoogleLocal = let

45 hoogleLocal = let

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

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

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

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

49− inherit evalPackages;

50− version = "5.0.18.3";

48+ version = "5.0.17.15";

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

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

52 }

50 }

53 }:

51 }:

54− let

52+ haskellLib.weakCallPackage pkgs nixpkgsHoogle {

55− haskellPackages = {

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

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

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

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

58− then ghc.buildGHC

55+ then ghc.buildGHC

59− else ghc;

56+ else ghc;

60− inherit packages hoogle;

57+ inherit packages hoogle;

61− };

58+ };

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;

67

59

68 # Same as haskellPackages.shellFor in nixpkgs.

60 # Same as haskellPackages.shellFor in nixpkgs.

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

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

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

62+ inherit hsPkgs ghcForComponent makeConfigFiles hoogleLocal haskellLib buildPackages compiler;

71 inherit (buildPackages) glibcLocales;

63 inherit (buildPackages) glibcLocales;

72 };

64 };

73

65

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

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

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

14, postInstall ? ""

15, enableDWARF

16−, plugins

17}:

16}:

18

17

19let

18let

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

38 ''

37 ''

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

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

40

39

41− ''

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

40+ # Start with a ghc...

43− + ''

44 mkdir -p $out/bin

41 mkdir -p $out/bin

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

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

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

46 rm -rf ${libDir}/*/

44 rm -rf ${libDir}/*/

47− ''

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

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

49− + ''

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

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

51− ''

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

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

53− + ''

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

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

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

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

56 fi

50 fi

57− ''

58− # ... and node modules ...

51+ # ... and node modules ...

59− + ''

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

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

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

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

62 fi

54 fi

63− ''

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

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

65− + ''

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

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

67

57

68− ''

58+ # Wrap compiler executables with correct env variables.

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

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

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

71− # initialize them with the given arguments.

72− #

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

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

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

76− + ''

77− GHC_PLUGINS="["

78− LIST_PREFIX=""

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

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

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

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

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

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

85− LIST_PREFIX=""

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

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

88− LIST_PREFIX=","

89− '') plugin.args)}

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

91− LIST_PREFIX=","

92− '') plugins)}

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

94−

95− ''

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

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

98− + ''

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

100

60

101− ''

102− # Wrap compiler executables with correct env variables.

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

104− + ''

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

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

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

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

107 rm -f $out/bin/$prg

63 rm -f $out/bin/$prg

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

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

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

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

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

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

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

113− --set "GHC_PLUGINS" "$GHC_PLUGINS" \

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

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

115 fi

70 fi

116 done

71 done

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

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

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

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

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

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

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

126− --set "GHC_PLUGINS" "$GHC_PLUGINS" \

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

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

128 fi

82 fi

129 done

83 done

130

84

131− ''

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

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

133− + ''

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

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

135 rm -f $out/bin/haddock

87 rm -f $out/bin/haddock

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

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

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

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

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

139 fi

91 fi

140

92

141− ''

142− # Point ghc-pkg to the package database of the component using the

93+ # Point ghc-pkg to the package database of the component using the

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

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

144− + ''

95+

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

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

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

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

147 rm -f $out/bin/$prg

98 rm -f $out/bin/$prg

builder/haddock-builder.nix−2

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

41 inherit (package) identifier;

42 inherit component fullName flags needsProfiling;

43 chooseDrv = p: p.haddock;

44− inherit (componentDrv) enableDWARF;

45 };

44 };

46

45

47 finalConfigureFlags = lib.concatStringsSep " " (

46 finalConfigureFlags = lib.concatStringsSep " " (

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

56 componentName = fullName;

55 componentName = fullName;

57 configFiles = docsConfigFiles;

56 configFiles = docsConfigFiles;

58 inherit (componentDrv) enableDWARF;

57 inherit (componentDrv) enableDWARF;

59− inherit (component) plugins;

60 };

58 };

61

59

62 drv = stdenv.mkDerivation (commonAttrs // {

60 drv = stdenv.mkDerivation (commonAttrs // {

builder/hspkg-builder.nix+25−38

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

33− cabalFile = if revision == null || revision == 0 || bundledSrc != null then null else

26+ cabalFile = if revision == null || revision == 0 then null else

34 fetchurl {

27 fetchurl {

35 name = "${name}-${toString revision}.cabal";

28 name = "${name}-${toString revision}.cabal";

36 url = "https://hackage.haskell.org/package/${name}/revision/${toString revision}.cabal";

29 url = "https://hackage.haskell.org/package/${name}/revision/${toString revision}.cabal";

37 sha256 = revisionSha256;

30 sha256 = revisionSha256;

38 };

31 };

39

32

40− defaultSetupSrc = if stdenv.hostPlatform.isGhcjs then ./Setup.ghcjs.hs else ./Setup.hs;

33+ defaultSetupSrc = builtins.toFile "Setup.hs" ''

34+ import Distribution.Simple

35+ main = defaultMain

36+ '';

41

37

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

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

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

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

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

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

45− # version of Cabal bundled with GHC).

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

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

42+ cabalLibDepends = lib.optional (

47−

48− # Check there is no chance we are building `cabalFromCabalInstall`. Using `cabalFromCabalInstall`

49− # to build itseld would cause infinite recursion.

50− useCabalFromCabalInstall =

51− # `cabalFromCabalInstall` is not cross compiled

52− stdenv.buildPlatform != stdenv.hostPlatform

43+ stdenv.hostPlatform.isGhcjs || (

53− ||

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

54− # These are the dependencies of `Cabal`

45+ &&

55 !builtins.elem package.identifier.name

46 !builtins.elem package.identifier.name

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

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

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

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

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

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

50+ )

51+ )

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

59

53

60− defaultSetup = setup-builder ({

54+ defaultSetup = setup-builder {

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

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

62 component = {

56 component = {

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

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

64 libs = [];

58 libs = [];

65 frameworks = [];

59 frameworks = [];

66 doExactConfig = false;

60 doExactConfig = false;

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

88 synopsis = null;

82 synopsis = null;

89 license = "MIT";

83 license = "MIT";

90 };

84 };

91− src = null;

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

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

93 mkdir $out

86 mkdir $out

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

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

95 '';

88 '';

96 inherit defaultSetupSrc;

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

103− });

90+ };

104

91

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

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

106 # cat ${defaultSetupSrc} > Setup.hs

93 # cat ${defaultSetupSrc} > Setup.hs

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

120 inherit (pkg) preUnpack postUnpack;

107 inherit (pkg) preUnpack postUnpack;

121 };

108 };

122

109

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

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

124− inherit allComponent componentId component package name src flags setup cabalFile cabal-generator patches revision

111+ inherit componentId component package name src flags setup cabalFile cabal-generator patches revision

125 shellHook

112 shellHook

126 ;

113 ;

127 };

114 };

128

115

129in rec {

116in rec {

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

117+ components = haskellLib.applyComponents buildComp pkg;

131 checks = pkgs.recurseIntoAttrs (builtins.mapAttrs

118 checks = pkgs.recurseIntoAttrs (builtins.mapAttrs

132 (_: d: haskellLib.check d)

119 (_: d: haskellLib.check d)

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

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

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

121+ inherit (package) identifier detailLevel isLocal isProject;

135 inherit setup cabalFile;

122 inherit setup cabalFile;

136 isHaskell = true;

123 isHaskell = true;

137 inherit src;

124 inherit src;

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

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

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

2

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

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

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−

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

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

11

7

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

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

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

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

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

86

82

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

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

88− "extra-lib-dirs" = map (p: "${lib.getLib p}/lib") (lib.flatten component.libs)

84+ "extra-lib-dirs" = map (p: "${lib.getLib p}/lib") component.libs;

89− # On windows also include `bin` directories that may contain DLLs

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

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

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

93− "extra-include-dirs" = map (p: "${lib.getDev p}/include") (lib.flatten component.libs);

85+ "extra-include-dirs" = map (p: "${lib.getDev p}/include") component.libs;

94− "extra-framework-dirs" = lib.optionals (stdenv.hostPlatform.isDarwin)

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

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

96 })}

87 })}

97

88

98 ghc=${ghc}

89 ghc=${ghc}

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

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

100 ''

91 ''

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

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

102 find $ghc/lib/${ghc.name}/package.conf.d -name $p'*.conf' -exec cp -f {} $out/${packageCfgDir} \;

93 find $ghc/lib/${ghc.name}/package.conf.d -name $p'*.conf' -exec cp -f {} $out/${packageCfgDir} \;

103 done

94 done

104 ''}

95 ''}

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

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

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

158 ''}

149 ''}

159 done

150 done

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

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

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

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

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

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

163 fi

154 fi

164 done

155 done

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

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

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

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

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

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

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

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

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

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

builder/setup-builder.nix+6−11

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

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

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

2

3let self =

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

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

12}@drvArgs:

10}@drvArgs:

13

11

14let

12let

15− ghc = (if enableDWARF then (x: x.dwarf) else (x: x)) (

16− (if smallAddressSpace then (x: x.smallAddressSpace) else (x: x)) defaults.ghc);

17−

18 cleanSrc' = haskellLib.rootAndSubDir cleanSrc;

13 cleanSrc' = haskellLib.rootAndSubDir cleanSrc;

19

14

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

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

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

23

18

24 configFiles = makeSetupConfigFiles {

19 configFiles = makeSetupConfigFiles {

25 inherit (package) identifier;

20 inherit (package) identifier;

26− inherit fullName flags component enableDWARF nonReinstallablePkgs;

21+ inherit fullName flags component enableDWARF;

27 };

22 };

28 hooks = haskellLib.optionalHooks {

23 hooks = haskellLib.optionalHooks {

29 inherit

24 inherit

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

57 cleanSrc = cleanSrc';

52 cleanSrc = cleanSrc';

58 inherit configFiles;

53 inherit configFiles;

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

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

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

61 };

55 };

62

56

63 meta = {

57 meta = {

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

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

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

77 if [ -f $f ]; then

71 if [ -f $f ]; then

78 echo Compiling package $f

72 echo Compiling package $f

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

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

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

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

75+ setup=$(pwd)/Setup

81 fi

76 fi

82 done

77 done

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

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

84− runHook postBuild

79+ runHook preBuild

85 '';

80 '';

86

81

87 installPhase = ''

82 installPhase = ''

builder/shell-for.nix+36−63

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

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

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

2

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

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

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

9 # in the selected packages. If only as subset of the components will be

10 # worked on in the shell then we can pass a different `components` function

11 # to select those.

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

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

13 # Additional packages to be added unconditionally

14, additional ? _: []

15, withHoogle ? true

16−, withHaddock ? withHoogle

17, exactDeps ? false

16, exactDeps ? false

18, tools ? {}

17, tools ? {}

19, packageSetupDeps ? true

18, packageSetupDeps ? true

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

26

25

27 selectedPackages = packages hsPkgs;

26 selectedPackages = packages hsPkgs;

28 additionalPackages = additional hsPkgs;

27 additionalPackages = additional hsPkgs;

29− directlySelectedComponents = components hsPkgs;

28+ selectedComponents = components hsPkgs;

30

29

30+ # The configs of all the selected components

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

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

33+

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

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

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

37+

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

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

32 #

39 #

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

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

34− # because:

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

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

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

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

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

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

38− # Generally we never want to include any of `directlySelectedComponents` as dependencies.

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

39− #

40− # We do this by defining a set of `selectedComponents`, where `x` is in `selectedComponents` if and only if:

41− # - `x` is in `directlySelectedComponents`

42− # - `x` is a transitive dependency of something in `directlySelectedComponents`

43− # and `x` transitively depends on something in `directlySelectedComponents`

44− # We use the dependencies of `selectedComponents` filtering out members of `selectedComponents`

45 #

46 # Furthermore, if `a` depends on `b`, `a` will include the library component of `b` in its `buildInputs`

47 # (to make `propagatedBuildInputs` of `pkgconfig-depends` work). So we also need to filter those

48 # (the pkgconfig depends of `b` will still be included in the

49 # system shell's `buildInputs` via `b`'s own `buildInputs`).

50+ # We have to do this slightly differently because we will be looking at the actual components rather

51+ # than the packages.

50

52

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

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

55+ removeSelectedPackages =

56+ # All the identifiers of the selected packages

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

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

51

59

52− # all packages that are indirectly depended on by `directlySelectedComponents`

53− # including `directlySelectedComponents`

54− transitiveDependenciesComponents =

55− builtins.listToAttrs

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

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

58−

59− isSelectedComponent =

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

61− selectedComponentsBitmap =

62− lib.mapAttrs

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

64− transitiveDependenciesComponents

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

66−

67− selectedComponents =

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

69−

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

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

71 removeSelectedInputs =

61 removeSelectedInputs =

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

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

73−

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

74− # The configs of all the selected components.

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

75− # This excludes the `setup` dependencies of `Simple` packages, because

76− # `cabal-install` does not build a `Setup` executable for `Simple` packages.

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

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

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

80−

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

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

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

84

65

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

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

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

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

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

87− ++ additionalPackages;

88

69

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

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

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

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

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

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

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

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

93 systemInputs = removeSelectedInputs (lib.concatMap

74 systemInputs = removeSelectedInputs (lib.concatMap

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

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

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

99 component = {

80 component = {

100 depends = packageInputs;

81 depends = packageInputs;

101 libs = [];

82 libs = [];

102− pkgconfig = [];

103 frameworks = [];

83 frameworks = [];

104 doExactConfig = false;

84 doExactConfig = false;

105 };

85 };

106 configFiles = makeConfigFiles {

86 configFiles = makeConfigFiles {

107 fullName = args.name or name;

87 fullName = args.name or name;

108 identifier.name = name;

88 identifier.name = name;

109− inherit component enableDWARF;

89+ inherit component;

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

111 };

90 };

112 ghcEnv = ghcForComponent {

91 ghcEnv = ghcForComponent {

113 inherit configFiles;

92 inherit configFiles;

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

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

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

117 '';

96 '';

118 inherit enableDWARF;

97 inherit enableDWARF;

119− plugins = [];

120 };

98 };

121

99

122 hoogleIndex = let

100 hoogleIndex = let

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

133 # inherit (hsPkgs) hoogle;

111 # inherit (hsPkgs) hoogle;

134 } // (

112 } // (

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

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

136− hoogle = buildPackages.haskell-nix.hackage-tool (

114+ hoogle = buildPackages.haskell-nix.tool compiler.nix-name "hoogle" args.tools.hoogle;

137− haskellLib.versionOrModToMods args.tools.hoogle ++ [{

138− name = "hoogle";

139− compiler-nix-name = compiler.nix-name;

140− inherit evalPackages;

141− }]);

142 }

115 }

143 ));

116 ));

144

117

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

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

146in

119in

147 mkShell (mkDrvArgs // {

120 mkShell (mkDrvArgs // {

148 name = mkDrvArgs.name or name;

121 name = mkDrvArgs.name or name;

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

152 nativeBuildInputs = [ ghcEnv ]

125 nativeBuildInputs = [ ghcEnv ]

153 ++ nativeBuildInputs

126 ++ nativeBuildInputs

154 ++ mkDrvArgs.nativeBuildInputs or []

127 ++ mkDrvArgs.nativeBuildInputs or []

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

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

156 # If this shell is a cross compilation shell include

129 # If this shell is a cross compilation shell include

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

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

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

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

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

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

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

161 exec cabal \

133 exec cabal \

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

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

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

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

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

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

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

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

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

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

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

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

176 echo $nativeBuildInputs $buildInputs > $out

147 echo $nativeBuildInputs $buildInputs > $out

177 '';

148 '';

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

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

178

151

179 # This helps tools like `ghcide` (that use the ghc api) to find

152 # This helps tools like `ghcide` (that use the ghc api) to find

180 # the correct global package DB.

153 # the correct global package DB.

changelog.md−57

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

1This file contains a summary of changes to Haskell.nix and `nix-tools`

2that will impact users.

3

4−## Jul 27, 2022

5−* Removed reliance on `builtins.currentSystem`. It was used it to provide

6− `pkgs.evalPackages` via an overlay that it used to run derivations

7− used in imports from derivation (IFDs).

8−

9− These derivations are now run on `buildPackages` by default.

10−

11− Passsing `evalPackages` to a project function will change where all the

12− derivations used in IFDs are run for that project (including shell tools):

13− evalPackages = import nixpkgs haskellNix.nixpkgsArgs;

14−

15− Passing `evalSystem` instead will use create a suitable `nixpkgs` using `pkgs.path`

16− and `pkgs.overlay`:

17− evalSystem = "x86_64-linux";

18− or

19− evalSystem = builtins.currentSystem;

20−

21− The `haskellLib.cleanGit` function is also affected by this change. If you are cross

22− compiling and using `cleanGit` you should probably do something like:

23− pkgs = import nixpkgs haskellNix.nixpkgsArgs;

24− evalPackages = import nixpkgs (haskellNix.nixpkgsArgs // { system = evalSystem; });

25− p = pkgs.pkgsCross.mingwW64.haskell-nix.cabalProject {

26− inherit evalPackages;

27− src = evalPackages.haskell-nix.haskellLib.cleanGit { src = ./.; };

28− };

29−

30−## Feb 16, 2022

31−* Removed lookupSha256 argument from project functions.

32− Pass a `sha256map` instead.

33−* Added better support for `repository` in `cabal.project`. These

34− blocks should now work without the need for passing `extra-hackages` and

35− `extra-hackage-tarballs`.

36−

37−## Aug 6, 2021

38−* Included dependencies of haskell.nix that were tracked in `nix/sources.json`

39− as flake inputs (`flake.lock` replaces `nix/sources.json`).

40−* Uses `flake-compat` to continue to provide a compatible interface for non

41− flake projects.

42−

43−## Jul 23, 2021

44−* `source-repository-package` references in `cabal.project` files are now

45− left as a `source-repository-package` when calculating the the `plan-nix` for

46− `cabalProject` based functions.

47− This makes haskell.nix match the behaviour of `cabal` better.

48− Materialized files for projects that use `source-repository-package`

49− references will need to be updated.

50−* Only planned components are included in a haskell.nix cabal project.

51− If cabal solver does not include the component in the `plan.json` file it

52− will not be present in `hsPkgs.pkg.components`.

53−* When the same package occurs more than once in a plan.json file

54− the latest version is picked by haskell.nix.

55−

56−## Apr 8, 2021

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

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

59− result in an error.

60−

61## Feb 22, 2021

4## Feb 22, 2021

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

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

63 (ghc >=8.10.2).

6 (ghc >=8.10.2).

ci-lib.nix+4−4

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

1−{

1+let

2 # Generic nixpkgs, use *only* for lib functions that are stable across versions

3− pkgs ? (import ./. {}).pkgs,

3+ pkgs = import (import ./nix/sources.nix).nixpkgs {};

4− lib ? pkgs.lib

4+ lib = pkgs.lib;

5−}: rec {

5+in rec {

6 inherit (import ./dimension.nix) dimension;

7

8 # A filter for removing packages that aren't supported on the current platform

ci.nix+40−53

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

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 }:

9 let

8 let

10− inherit (import ./ci-lib.nix { inherit pkgs; }) dimension platformFilterGeneric filterAttrsOnlyRecursive;

9+ inherit (import ./ci-lib.nix) dimension platformFilterGeneric filterAttrsOnlyRecursive;

11− inherit (pkgs.haskell-nix) sources;

10+ sources = import ./nix/sources.nix {};

12 nixpkgsVersions = {

11 nixpkgsVersions = {

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

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

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

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

15 "unstable" = "nixpkgs-unstable";

14 "unstable" = "nixpkgs-unstable";

16 };

15 };

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

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

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

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

25 inherit runTests;

18 inherit runTests;

26 }) (

19 }) (

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

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

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

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

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

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

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

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

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

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

26+ {

34− ghc865 = false;

27+ ghc865 = true;

35− ghc8107 = true;

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

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

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

37− ghc865 = false;

30+ ghc884 = true;

38− ghc8107 = true;

31+ ghc8104 = true;

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

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

40− ghc865 = false;

33+ ghc884 = true;

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

34+ ghc8104 = true;

42− ghc8107 = true;

35+ ghc810420210212 = false;

43− ghc902 = true;

44− ghc924 = true;

45 });

36 });

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

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

47− nixpkgs.lib.filter (v:

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

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

39+ linux = "x86_64-linux";

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

40+ darwin = "x86_64-darwin";

50− !__elem compiler-nix-name ["ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901" "ghc921" "ghc922"]))

41+ };

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

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

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

61 # We need to use the actual nixpkgs version we're working with here, since the values

43 # We need to use the actual nixpkgs version we're working with here, since the values

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

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

63 let lib = nixpkgs.lib;

45 let lib = nixpkgs.lib;

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

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

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

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

67 inherit (lib.systems.examples) ghcjs;

47 inherit (lib.systems.examples) ghcjs;

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

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

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

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

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

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

51+ # Windows cross compilation is currently broken on macOS

71 inherit (lib.systems.examples) mingwW64;

52 inherit (lib.systems.examples) mingwW64;

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

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

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

73 # Musl cross only works on linux

55 # Musl cross only works on linux

74 # aarch64 cross only works on linux

56 # aarch64 cross only works on linux

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

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

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

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

76 };

60 };

61+ isDisabled = d:

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

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

63+ in meta.disabled or false;

78in

64in

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

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

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

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

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

81− evalPackages = import pinnedNixpkgsSrc nixpkgsArgs;

68+ genericPkgs = import pinnedNixpkgsSrc {};

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

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

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

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

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

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

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

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

86 platformFilter = platformFilterGeneric pkgs system;

73 platformFilter = platformFilterGeneric pkgs system;

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

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

88 # Native builds

75 # Native builds

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

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

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

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

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

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

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

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

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

99 });

86 });

100 }

87 }

101 //

88 //

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

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

103 # Cross builds

90 # Cross builds

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

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

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

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

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

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

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

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

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

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

compiler/ghc/configured-src.nixnew file+127

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

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+64−231

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

8

9# build-tools

10, bootPkgs

11−, buildPackages

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

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

13, autoreconfHook

12, autoreconfHook

14, bash

13, bash

15

14

16−, libiconv ? null

15+, libiconv ? null, ncurses

17−

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

19

16

20, installDeps

17, installDeps

21

18

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

31, # If enabled, GHC will be built with the GPL-free but slower integer-simple

28, # If enabled, GHC will be built with the GPL-free but slower integer-simple

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

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

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

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

37

31

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

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

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

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

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

46

40

47, enableDWARF ? false

41, enableDWARF ? false

48

42

49−, enableTerminfo ?

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

50− # Terminfo does not work on older ghc cross arm and windows compilers

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

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

55

45

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

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

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

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

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

74, extra-passthru ? {}

64, extra-passthru ? {}

75}@args:

65}@args:

76

66

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

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

78−

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

80−assert enableNativeBignum -> !enableIntegerSimple;

81−assert enableIntegerSimple -> !enableNativeBignum;

82

68

83let

69let

84 inherit (stdenv) buildPlatform hostPlatform targetPlatform;

70 inherit (stdenv) buildPlatform hostPlatform targetPlatform;

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

86

72

87 inherit (bootPkgs) ghc;

73 inherit (bootPkgs) ghc;

88

74

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−

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

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

101 targetLibffi =

76 targetLibffi =

102 # on native platforms targetPlatform.{libffi, gmp} do not exist; thus fall back

77 # on native platforms targetPlatform.{libffi, gmp} do not exist; thus fall back

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

109

84

110 targetGmp = targetPackages.gmp or gmp;

85 targetGmp = targetPackages.gmp or gmp;

111

86

112− targetIconv = targetPackages.libiconv or libiconv;

113−

114− targetNumactl = targetPackages.numactl or numactl;

115−

116 # TODO(@Ericson2314) Make unconditional

87 # TODO(@Ericson2314) Make unconditional

117 targetPrefix = lib.optionalString

88 targetPrefix = lib.optionalString

118 (targetPlatform != hostPlatform)

89 (targetPlatform != hostPlatform)

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

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

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

125 endif

96 endif

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

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

127− '' + bignumSpec + ''

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

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

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

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

130 CrossCompilePrefix = ${targetPrefix}

100 CrossCompilePrefix = ${targetPrefix}

131 '' + lib.optionalString isCrossTarget ''

101 '' + lib.optionalString isCrossTarget ''

132 Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"}

102 Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"}

133− ''

134− # GHC 9.0.1 fails to compile for musl unless HADDOC_DOCS = NO

135− + lib.optionalString (isCrossTarget || (targetPlatform.isMusl && builtins.compareVersions ghc-version "9.0.1" >= 0)) ''

136 HADDOCK_DOCS = NO

103 HADDOCK_DOCS = NO

137 BUILD_SPHINX_HTML = NO

104 BUILD_SPHINX_HTML = NO

138 BUILD_SPHINX_PDF = NO

105 BUILD_SPHINX_PDF = NO

139 '' + lib.optionalString enableRelocatedStaticLibs ''

106 '' + lib.optionalString enableRelocatedStaticLibs ''

140 GhcLibHcOpts += -fPIC

107 GhcLibHcOpts += -fPIC

141 GhcRtsHcOpts += -fPIC

108 GhcRtsHcOpts += -fPIC

142− GhcRtsCcOpts += -fPIC

143− '' + lib.optionalString (enableRelocatedStaticLibs && targetPlatform.isx86_64 && !targetPlatform.isWindows) ''

144− GhcLibHcOpts += -fexternal-dynamic-refs

145− GhcRtsHcOpts += -fexternal-dynamic-refs

146 '' + lib.optionalString enableDWARF ''

109 '' + lib.optionalString enableDWARF ''

147 GhcLibHcOpts += -g3

110 GhcLibHcOpts += -g3

148 GhcRtsHcOpts += -g3

111 GhcRtsHcOpts += -g3

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

153 ''

116 ''

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

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

155 # our elf linker for x86_64 is broken.

118 # our elf linker for x86_64 is broken.

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

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

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

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

158 ''

121 ''

159 # While split sections are now enabled by default in ghc 8.8 for windows,

122 # While split sections are now enabled by default in ghc 8.8 for windows,

160 # the seem to lead to `too many sections` errors when building base for

123 # the seem to lead to `too many sections` errors when building base for

161 # profiling.

124 # profiling.

162− #

163− # It appears that loading split sections through iserv on qemu-aarch64, is

164− # particularly slow. Let's disable them for now.

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

125+ + lib.optionalString targetPlatform.isWindows ''

166 SplitSections = NO

126 SplitSections = NO

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

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

168 BUILD_PROF_LIBS = NO

128 BUILD_PROF_LIBS = NO

169 '';

129 '';

170

130

171 # Splicer will pull out correct variations

131 # Splicer will pull out correct variations

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

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

173 ++ [targetLibffi]

133 ++ [targetLibffi]

174 ++ lib.optional (!enableIntegerSimple) gmp

134 ++ lib.optional (!enableIntegerSimple) gmp

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

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

176− ++ lib.optional (enableNUMA && platform.isLinux && !platform.isAarch32 && !platform.isAndroid) numactl

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

179

137

180 toolsForTarget =

138 toolsForTarget =

181 if hostPlatform == buildPlatform then

139 if hostPlatform == buildPlatform then

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

185

143

186 targetCC = builtins.head toolsForTarget;

144 targetCC = builtins.head toolsForTarget;

187

145

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

147+ inherit stdenv lib fetchurl

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

149+ targetPrefix

150+ targetPlatform hostPlatform

151+ targetPackages

152+ perl autoconf automake m4 python3 sphinx ghc bootPkgs

153+ autoreconfHook toolsForTarget bash

154+ libDeps

155+ useLLVM llvmPackages

156+ targetCC

157+ enableIntegerSimple targetGmp

158+ enableDWARF elfutils

159+ ncurses targetLibffi libiconv

160+ disableLargeAddressSpace

161+ buildMK

162+ ;

163+ };

188in

164in

189stdenv.mkDerivation (rec {

165stdenv.mkDerivation (rec {

190 version = ghc-version;

166 version = ghc-version;

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

192

168

193 patches = ghc-patches;

169 patches = ghc-patches;

194

170

195− src = if src-spec ? file

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

196− then src-spec.file

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

197− else fetchurl { inherit (src-spec) url sha256; };

173+ # accordingly. Most trivial might be to just have args, and mash them into the

174+ # attrset.

175+ src = configured-src;

198

176

199 # configure was run by configured-src already.

177 # configure was run by configured-src already.

200− phases = [ "unpackPhase" "patchPhase" ]

178+ phases = [ "unpackPhase" "buildPhase"

201− ++ lib.optional (ghc-patches != []) "autoreconfPhase"

202− ++ [ "configurePhase" "buildPhase"

203 "checkPhase" "installPhase"

179 "checkPhase" "installPhase"

204 "fixupPhase"

180 "fixupPhase"

205 "installCheckPhase"

181 "installCheckPhase"

206 "distPhase"

182 "distPhase"

207 ];

183 ];

208

184

209− # GHC is a bit confused on its cross terminology.

185+ # ghc hardcodes the TOP dir during config, this breaks when

210− preConfigure =

186+ # splitting the configured src from the build process.

211− # This code is only included when cross compiling as it breaks aarch64-darwin native compilation

187+ postUnpack = ''

212− lib.optionalString (targetPlatform != hostPlatform) ''

188+ (cd $sourceRoot

213− for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do

189+ TOP=$(cat mk/config.mk|grep ^TOP|awk -F\ '{ print $3 }')

214− export "''${env#TARGET_}=''${!env}"

190+ PREFIX=$(cat mk/install.mk|grep ^prefix|awk -F\ '{ print $3 }')

215− done

191+

216− # GHC is a bit confused on its cross terminology, as these would normally be

192+ # these two are required

217− # the *host* tools.

193+ substituteInPlace mk/config.mk --replace "$TOP" "$PWD" \

218− export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"

194+ --replace "$PREFIX" "$out"

219− export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"

195+

220− # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177

196+ substituteInPlace mk/install.mk --replace "$TOP" "$PWD" \

221− export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString targetPlatform.isAarch32 ".gold"}"

197+ --replace "$PREFIX" "$out"

222− export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"

198+

223− export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"

199+ # these two only for convencience.

224− export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"

200+ substituteInPlace config.log --replace "$TOP" "$PWD"\

225− export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"

201+ --replace "$PREFIX" "$out"

226− export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"

202+ substituteInPlace config.status --replace "$TOP" "$PWD"\

227− export STRIP="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}strip"

203+ --replace "$PREFIX" "$out")

228− '' + ''

204+

229− echo -n "${buildMK}" > mk/build.mk

205+

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"

290− ];

206+ '';

291

207

292 enableParallelBuilding = true;

208 enableParallelBuilding = true;

293 postPatch = "patchShebangs .";

209 postPatch = "patchShebangs .";

@@ -310,6 +226,9 @@ stdenv.mkDerivation (rec {

310

226

311 buildInputs = [ perl bash ] ++ (libDeps hostPlatform);

227 buildInputs = [ perl bash ] ++ (libDeps hostPlatform);

312

228

229+ propagatedBuildInputs = [ targetPackages.stdenv.cc ]

230+ ++ lib.optional useLLVM llvmPackages.llvm;

231+

313 depsTargetTarget = map lib.getDev (libDeps targetPlatform);

232 depsTargetTarget = map lib.getDev (libDeps targetPlatform);

314 depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);

233 depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);

315

234

@@ -327,18 +246,7 @@ stdenv.mkDerivation (rec {

327 ++ lib.optional stdenv.targetPlatform.isAarch32 "pic"

246 ++ lib.optional stdenv.targetPlatform.isAarch32 "pic"

328 ++ lib.optional stdenv.targetPlatform.isMusl "pie";

247 ++ lib.optional stdenv.targetPlatform.isMusl "pie";

329

248

330− postInstall = lib.optionalString (enableNUMA && targetPlatform.isLinux) ''

249+ postInstall = ''

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− '' + ''

342 # Install the bash completion file.

250 # Install the bash completion file.

343 install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc

251 install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc

344

252

@@ -354,9 +262,11 @@ stdenv.mkDerivation (rec {

354 $i

262 $i

355 done

263 done

356

264

357− # Save generated files for needed when building ghc and ghcjs

265+ # Save generated files for needed when building ghcjs

358 mkdir -p $generated/includes/dist-derivedconstants/header

266 mkdir -p $generated/includes/dist-derivedconstants/header

359− cp includes/dist-derivedconstants/header/GHCConstantsHaskell*.hs \

267+ cp includes/dist-derivedconstants/header/GHCConstantsHaskellExports.hs \

268+ includes/dist-derivedconstants/header/GHCConstantsHaskellType.hs \

269+ includes/dist-derivedconstants/header/GHCConstantsHaskellWrappers.hs \

360 $generated/includes/dist-derivedconstants/header

270 $generated/includes/dist-derivedconstants/header

361 if [[ -f includes/ghcplatform.h ]]; then

271 if [[ -f includes/ghcplatform.h ]]; then

362 cp includes/ghcplatform.h $generated/includes

272 cp includes/ghcplatform.h $generated/includes

@@ -365,15 +275,6 @@ stdenv.mkDerivation (rec {

365 fi

275 fi

366 mkdir -p $generated/compiler/stage2/build

276 mkdir -p $generated/compiler/stage2/build

367 cp compiler/stage2/build/Config.hs $generated/compiler/stage2/build || true

277 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

377 mkdir -p $generated/rts/build

278 mkdir -p $generated/rts/build

378 cp rts/build/config.hs-incl $generated/rts/build || true

279 cp rts/build/config.hs-incl $generated/rts/build || true

379

280

@@ -417,40 +318,7 @@ stdenv.mkDerivation (rec {

417 # Our Cabal compiler name

318 # Our Cabal compiler name

418 haskellCompilerName = "ghc-${version}";

319 haskellCompilerName = "ghc-${version}";

419

320

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 ({

425− name = name + "-configured-src";

321+ configured-src = 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− });

454

322

455 # Used to detect non haskell-nix compilers (accidental use of nixpkgs compilers can lead to unexpected errors)

323 # Used to detect non haskell-nix compilers (accidental use of nixpkgs compilers can lead to unexpected errors)

456 isHaskellNixCompiler = true;

324 isHaskellNixCompiler = true;

@@ -460,11 +328,6 @@ stdenv.mkDerivation (rec {

460 enableDWARF = stdenv.targetPlatform.isLinux

328 enableDWARF = stdenv.targetPlatform.isLinux

461 && builtins.compareVersions ghc-version "8.10.2" >= 0;

329 && builtins.compareVersions ghc-version "8.10.2" >= 0;

462 });

330 });

463−

464− # The same GHC, but without the large (1TB) address space reservation

465− smallAddressSpace = lib.makeOverridable self (args // {

466− disableLargeAddressSpace = true;

467− });

468 } // extra-passthru;

331 } // extra-passthru;

469

332

470 meta = {

333 meta = {

@@ -474,39 +337,9 @@ stdenv.mkDerivation (rec {

474 inherit (ghc.meta) license platforms;

337 inherit (ghc.meta) license platforms;

475 };

338 };

476

339

477− # Needed for `haddock` to work on source that includes non ASCII chars

478− LANG = "en_US.UTF-8";

479− LC_ALL = "en_US.UTF-8";

480−} // lib.optionalAttrs (stdenv.buildPlatform.libc == "glibc") {

481− LOCALE_ARCHIVE = "${buildPackages.glibcLocales}/lib/locale/locale-archive";

482} // lib.optionalAttrs targetPlatform.useAndroidPrebuilt {

340} // lib.optionalAttrs targetPlatform.useAndroidPrebuilt {

483 dontStrip = true;

341 dontStrip = true;

484 dontPatchELF = true;

342 dontPatchELF = true;

485 noAuditTmpdir = true;

343 noAuditTmpdir = true;

486−} // lib.optionalAttrs (stdenv.buildPlatform.isDarwin || stdenv.targetPlatform.isWindows) {

487− # ghc install on macOS wants to run `xattr -r -c`

488− # The macOS version fails because it wants python 2.

489− # The nix version of xattr does not support those args.

490− # Luckily setting the path to something that does not exist will skip the step.

491− preBuild = lib.optionalString stdenv.buildPlatform.isDarwin ''

492− export XATTR=$(mktemp -d)/nothing

493− ''

494− # We need to point at a stand in `windows.h` header file so that the RTS headers can

495− # work on the hostPlatform. We also need to work around case sensitve file system issues.

496− + lib.optionalString stdenv.targetPlatform.isWindows ''

497− export NIX_CFLAGS_COMPILE_${

498− # We want this only to apply to the non windows hostPlatform (the

499− # windows gcc cross compiler has a full `windows.h`).

500− # This matches the way `suffixSalt` is calculated in nixpkgs.

501− # See https://github.com/NixOS/nixpkgs/blob/8411006d6bcd7f6e6a8a1a80ce8fcdccdd16c6ab/pkgs/build-support/cc-wrapper/default.nix#L58

502− lib.replaceStrings ["-" "."] ["_" "_"] stdenv.hostPlatform.config

503− }+=" -I${../windows/include}"

504− if [[ -f libraries/base/include/winio_structs.h ]]; then

505− substituteInPlace libraries/base/include/winio_structs.h --replace Windows.h windows.h

506− fi

507− if [[ -f rts/win32/ThrIOManager.c ]]; then

508− substituteInPlace rts/win32/ThrIOManager.c --replace rts\\OSThreads.h rts/OSThreads.h

509− fi

510− '';

511});

344});

512in self

345in self

compiler/ghcjs/ghcjs-src.json+2−2

@@ -1,6 +1,6 @@

1{

2 "url": "https://github.com/ghcjs/ghcjs",

3− "rev": "58ed01e77028108c2b1da10d52cb331788b6a466",

3+ "rev": "30706cd687a301776ba4c1efd3db442fa9c78883",

4− "sha256": "1lr3grk5jjm8bvvkndilm06ry1dj7i66k4g27fr009bggdy9q6ws",

4+ "sha256": "sha256-7mJ/y6l89Rq/rIvZLZAOGpHsiBJ5BPCUuZIu2nxc6Dk=",

5 "fetchSubmodules": true

6}

compiler/ghcjs/ghcjs.nix+6−19

@@ -7,22 +7,14 @@

7 then "ghc884"

8 else "ghc865"

9, ghc ? pkgs.buildPackages.ghc

10−, overrideBootPackages ? [] # adds if not present, overrides if present.

11}:

10}:

12let

11let

13− isGhcjs88 = builtins.compareVersions ghcjsVersion "8.8.0.0" >= 0;

12+ isGhcjs88 = builtins.compareVersions ghcjsVersion "8.8.0.0" > 0;

14− isGhcjs810 = builtins.compareVersions ghcjsVersion "8.10.0.0" >= 0;

15

13

16 project = pkgs.buildPackages.haskell-nix.ghcjsProject {

14 project = pkgs.buildPackages.haskell-nix.ghcjsProject {

17 src = ghcjsSrc;

15 src = ghcjsSrc;

18− inherit ghcjsVersion compiler-nix-name overrideBootPackages;

16+ inherit ghcjsVersion compiler-nix-name;

19 index-state = "2020-04-25T00:00:00Z";

17 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 [];

26# plan-sha256 = "1wy2lr08maxyi7r8jiwf2gj6pdayk5vxxwh42bj4s2gg4035z0yc";

18# plan-sha256 = "1wy2lr08maxyi7r8jiwf2gj6pdayk5vxxwh42bj4s2gg4035z0yc";

27# materialized = ../../materialized/ghcjs;

19# materialized = ../../materialized/ghcjs;

28 };

20 };

@@ -62,11 +54,10 @@ let

62 ++ pkgs.lib.optional isGhcjs88 pkgs.buildPackages.procps;

54 ++ pkgs.lib.optional isGhcjs88 pkgs.buildPackages.procps;

63 passthru = {

55 passthru = {

64 inherit all-ghcjs bundled-ghcjs project;

56 inherit all-ghcjs bundled-ghcjs project;

65− configured-src = project.configured-src + "/ghc";

57+ inherit (project) configured-src;

66 # Used to detect non haskell-nix compilers (accidental use of nixpkgs compilers can lead to unexpected errors)

58 # Used to detect non haskell-nix compilers (accidental use of nixpkgs compilers can lead to unexpected errors)

67 isHaskellNixCompiler = true;

59 isHaskellNixCompiler = true;

68 } // ghcjs.components.exes;

60 } // ghcjs.components.exes;

69− dontUpdateAutotoolsGnuConfigScripts = true;

70 dontConfigure = true;

61 dontConfigure = true;

71 dontInstall = true;

62 dontInstall = true;

72 buildPhase = ''

63 buildPhase = ''

@@ -113,14 +104,10 @@ let

113 fi

104 fi

114 done

105 done

115 } &

106 } &

116− ${

107+ ${ if isGhcjs88

108+ then

117− # Unsets NIX_CFLAGS_COMPILE so the osx version of iconv.h is not used by mistake

109+ # Unsets NIX_CFLAGS_COMPILE so the osx version of iconv.h is not used by mistake

118− if isGhcjs810 then ''

119− env -u NIX_CFLAGS_COMPILE PATH=$out/bin:$PATH \

120− $out/bin/ghcjs-boot --with-emsdk=${project.emsdk} --no-haddock \

121− || (echo failed > $TMP/done; false)

122 ''

110 ''

123− else if isGhcjs88 then ''

124 env -u NIX_CFLAGS_COMPILE PATH=$out/bin:$PATH \

111 env -u NIX_CFLAGS_COMPILE PATH=$out/bin:$PATH \

125 $out/bin/ghcjs-boot -j1 --with-emsdk=${project.emsdk} --no-prof --no-haddock \

112 $out/bin/ghcjs-boot -j1 --with-emsdk=${project.emsdk} --no-prof --no-haddock \

126 || (echo failed > $TMP/done; false)

113 || (echo failed > $TMP/done; false)

compiler/ghcjs/ghcjs810-patched-boot-packages/aeson.patchdeleted−13

@@ -1,13 +0,0 @@

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.nixdeleted−176

@@ -1,176 +0,0 @@

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.patchdeleted−471

@@ -1,471 +0,0 @@

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.patchdeleted−99

@@ -1,99 +0,0 @@

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.jsondeleted−6

@@ -1,6 +0,0 @@

1−{

2− "url": "https://github.com/ghcjs/ghcjs",

3− "rev": "bb403ec3a1506831aae2d608b7b21c1937e4fb20",

4− "sha256": "0bs3hijwn0p4wvphwg78mwbz8qyi10wqgfh8yfaszaj1766892ba",

5− "fetchSubmodules": true

6−}

compiler/ghcjs/patches/810/boot-optimization-flags.patchdeleted−14

@@ -1,14 +0,0 @@

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.patchdeleted−87

@@ -1,87 +0,0 @@

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.hdeleted−1

@@ -1 +0,0 @@

1−#include <windows.h>

compiler/windows/include/windows.hdeleted−18

@@ -1,18 +0,0 @@

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,7 +2,11 @@

2 # allow building for windows

3 allowUnsupportedSystem = true;

4 # we want the 64bit wine version

5+ # See overlays/wine.nix as well!

5 wine.build = "wine64";

6 wine.build = "wine64";

6 wine.release = "stable";

7 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" ];

7}

11}

8

12

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 ? {}

1−{...}@args:

4+, ... }@args: rec {

2−

5+ sources = (import ./nix/sources.nix) // sourcesOverride;

3−let

6+ config = import ./config.nix;

4− nixpkgsSrc =

7+ overlays = [ allOverlays.combined ] ++ (

5− builtins.fetchTarball {

8+ if checkMaterialization == true

6− url = "https://github.com/NixOS/nixpkgs/archive/110a2c9ebbf5d4a94486854f18a37a938cfacbbb.tar.gz";

9+ then [(

7− sha256 = "sha256-leWXLchbAbqOlLT6tju631G40SzQWPqaAXQG3zH1Imw=";

10+ final: prev: {

8− };

11+ haskell-nix = prev.haskell-nix // {

9− pkgs = args.pkgs or (import nixpkgsSrc {});

12+ checkMaterialization = true;

10− flake-compat =

13+ };

11− pkgs.fetchzip {

14+ }

12− url = "https://github.com/edolstra/flake-compat/archive/5523c47f13259b981c49b26e28499724a5125fd8.tar.gz";

15+ )]

13− sha256 = "sha256-7IySNHriQjzOZ88DDk6VDPf1GoUaOrOeUdukY62o52o=";

16+ else []

14− };

17+ ) ++ [(

15− self = import flake-compat {

18+ final: prev: {

16− # We bypass flake-compat's rootSrc cleaning by evading its detection of this as a git

19+ haskell-nix = prev.haskell-nix // {

17− # repo.

20+ inherit overlays;

18− # This is done for 3 reasons:

21+ sources = prev.haskell-nix.sources // sourcesOverride;

19− # * To workaround https://github.com/edolstra/flake-compat/issues/25

22+ };

20− # * Make `updateMaterilized` scripts work (if filtering is done by `flake-compat`

23+ }

21− # the `updateMaterilized` scripts will try to update the copy in the store).

24+ )];

22− # * Allow more granular filtering done by the tests (the use of `cleanGit` and `cleanSourceWith`

25+ allOverlays = import ./overlays args;

23− # in `test/default.nix`). If `flake-compat` copies the whole git repo, any change to the

26+ nixpkgsArgs = { inherit config overlays system; };

24− # repo causes a change of input for all tests.

27+ pkgs = import sources.nixpkgs nixpkgsArgs;

25− src = { outPath = ./.; };

28+ pkgs-unstable = import sources.nixpkgs-unstable nixpkgsArgs;

26− inherit pkgs;

29+}

27− };

28−in self.defaultNix // (self.defaultNix.internal.compat

29−({ system = args.pkgs.system or builtins.currentSystem; } // args))

docs/dev/hix.mddeleted−27

@@ -1,27 +0,0 @@

1−# Making changes to Hix

2−

3−When making changes to the way Hix works it is often useful to be able to

4−test the changes locally before uploading them to github.

5−

6−## Hix Command Wrappers

7−

8−Install the hix command wrappers after making changes to a local clone of haskell.nix:

9−

10−```

11−nix-env -iA hix -f /path/to/local/haskell.nix

12−hix-shell

13−```

14−

15−Or override the version of haskell.nix used by the commands with the `HIX_ROOT` environment variable:

16−

17−```

18−HIX_ROOT=/path/to/local/haskell.nix hix-shell

19−```

20−

21−## Flakes

22−

23−For flakes use `--override-input` to point to the modified haskell.nix:

24−

25−```

26−nix develop --override-input haskellNix /path/to/local/haskell.nix

27−```

docs/reference/commands.md+3−7

@@ -1,8 +1,4 @@

1−# Command line tools

2−

3−To install the command line tools refer to the [Installing nix-tools](https://input-output-hk.github.io/haskell.nix/dev/manually-generating-nix-expressions/) section.

4−

5−## stack-to-nix

1+# stack-to-nix

6

2

7```

3```

8stack-to-nix - a stack to nix converter

4stack-to-nix - a stack to nix converter

@@ -32,7 +28,7 @@ output directory, it will create a basic one with a

32

28

33[cache-issue]: https://github.com/input-output-hk/haskell.nix/issues/57

29[cache-issue]: https://github.com/input-output-hk/haskell.nix/issues/57

34

30

35−## plan-to-nix

31+# plan-to-nix

36

32

37```

33```

38plan-to-nix - a stack to nix converter

34plan-to-nix - a stack to nix converter

@@ -69,7 +65,7 @@ these files.

69 generated, remove `.nix-tools.cache`

65 generated, remove `.nix-tools.cache`

70 (The open issue is [#57][cache-issue]).

66 (The open issue is [#57][cache-issue]).

71

67

72−## cabal-to-nix

68+# cabal-to-nix

73

69

74```

70```

75Usage: cabal-to-nix FILE.cabal

71Usage: cabal-to-nix FILE.cabal

docs/reference/library.md+3−6

@@ -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,11 +163,9 @@ 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 |

168+| `projectCross` | Attrset | Like `pkgs.pkgsCross.X` from nixpkgs `p.projectCross.X` returns the project results for cross compilation to X. So `p.projectCross.ghcjs.hsPkgs` is the same as `hsPkgs` but compiled with ghcjs |

169−| `appendModule` | Function | Re-eval the project with an extra module (or module list). |

170−| `extend` and `appendOverlays` | Function | Modify a project, or add attributes, through overlays: `p.extend(final: prev: { })`. The overlays are carried-over `projectCross` and `appendModule` invocations. |

171

169

172## project, cabalProject and stackProject

170## project, cabalProject and stackProject

173

171

@@ -437,7 +435,6 @@ shellFor =

437| `exactDeps` | Boolean | Prevents the Cabal solver from choosing any package dependency other than what are in the package set. |

435| `exactDeps` | Boolean | Prevents the Cabal solver from choosing any package dependency other than what are in the package set. |

438| `tools` | Function | AttrSet of tools to make available e.g. `{ cabal = "3.2.0.0"; }` or `{ cabal = { version = "3.2.0.0"; }; }`. If an AttrSet is provided for a tool, the additional arguments will be passed to the function creating the derivation for that tool. So you can provide an `index-state` or a `materialized` argument like that `{ cabal = { version = "3.2.0.0"; index-state = "2020-10-30T00:00:00Z"; materialized = ./cabal.materialized; }; }` for example. You can specify and materialize the version of hoogle used to construct the hoogle index by including something like `{ hoogle = { version = "5.0.17.15"; index-state = "2020-05-31T00:00:00Z"; materialized = ./hoogle.materialized; }`. Uses a default version of hoogle if omitted. |

436| `tools` | Function | AttrSet of tools to make available e.g. `{ cabal = "3.2.0.0"; }` or `{ cabal = { version = "3.2.0.0"; }; }`. If an AttrSet is provided for a tool, the additional arguments will be passed to the function creating the derivation for that tool. So you can provide an `index-state` or a `materialized` argument like that `{ cabal = { version = "3.2.0.0"; index-state = "2020-10-30T00:00:00Z"; materialized = ./cabal.materialized; }; }` for example. You can specify and materialize the version of hoogle used to construct the hoogle index by including something like `{ hoogle = { version = "5.0.17.15"; index-state = "2020-05-31T00:00:00Z"; materialized = ./hoogle.materialized; }`. Uses a default version of hoogle if omitted. |

439| `inputsFrom` | List | List of other shells to include in this one. The `buildInputs` and `nativeBuildInputs` of each will be included using [mkShell](https://nixos.org/manual/nixpkgs/stable/#sec-pkgs-mkShell).

437| `inputsFrom` | List | List of other shells to include in this one. The `buildInputs` and `nativeBuildInputs` of each will be included using [mkShell](https://nixos.org/manual/nixpkgs/stable/#sec-pkgs-mkShell).

440−| `crossPlatforms` | Function | Platform selection function for cross compilation targets to support eg. `ps: with ps; [ghcjs mingwW64]` (see nixpkgs lib.systems.examples for list of platform names). |

441| `{ ... }` | Attrset | All the other arguments are passed to [`mkDerivation`](https://nixos.org/nixpkgs/manual/#sec-using-stdenv). |

438| `{ ... }` | Attrset | All the other arguments are passed to [`mkDerivation`](https://nixos.org/nixpkgs/manual/#sec-using-stdenv). |

442

439

443**Return value**: a derivation

440**Return value**: a derivation

docs/reference/supported-ghc-versions.md+18−39

@@ -1,49 +1,28 @@

1# Supported GHC Versions

2

3+

3−The following GHC versions are defined in `haskell.nix` (there is a derivation

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):

4−for each, though not all are cached or tested by CI):

5- 8.4.4

6- 8.6.{1,2,3,4,5}

7- 8.8.{1,2,3,4}

8−- 8.10.{1,2,3,4,5}

8+- 8.10.{1,2,3,4}

9−- 9.0.1

10−- 9.2.1

11−- 9.2.2

12−

13−The following table shows the Nixpkgs/GHC versions which are built/cached, and

14−which of those are further tested. If you use a combination of Nixpkgs version

15−and GHC version which is in this table, you should hit our cache, saving

16−considering time by not building GHC and a few additional tools.

17−

18−Note that if you try to use `haskell.nix` as an overlay over Nixpkgs from a

19−standard Nixpkgs channel you will likely get a cache miss. To hit our cache you

20−really should use an instance of Nixpkgs provided by `haskell.nix` itself.

21

9

10+The following table shows the nixpkgs/GHC versions which are built by CI, and which of those are tested.

23−|------------------|--------------------|-------------|-----------------------|---------------|

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.

24−| 21.11 | `nixpkgs-2111` | 8.6.5 | `ghc865` | No |

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.

25−| 21.11 | `nixpkgs-2111` | 8.10.7 | `ghc8107` | Yes |

26−| unstable | `nixpkgs-unstable` | 8.6.5 | `ghc865` | No |

27−| unstable | `nixpkgs-unstable` | 8.8.4 | `ghc884` | No |

28−| unstable | `nixpkgs-unstable` | 8.10.7 | `ghc8107` | Yes |

29−| unstable | `nixpkgs-unstable` | 9.0.2 | `ghc902` | Yes |

30−| unstable | `nixpkgs-unstable` | 9.2.4 | `ghc924` | Yes |

31

13

32−See [ci.nix](https://github.com/input-output-hk/haskell.nix/blob/master/ci.nix)

14+| Nixpkgs version | GHC version | Tested? |

33−for the source of truth about what is built and tested (in the off chance this

15+|------------------|-------------|---------|

34−document is out-of-sync with your checkout).

16+| 20.03 | 8.6.5 | Y |

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 |

35

23

36−See the [getting started guide](../tutorials/getting-started.md) for

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.

37−instructions on how to set up Nix to take advantage of our cache when building.

38−This guide also covers where to use the Nixpkgs pinning and `compiler-nix-name`

39−settings from the table above. For further information, see the [instructions

40−for how to pin Nixpkgs](../dev/nixpkgs-pin.md).

41

25

42−See

43−[overlays/bootstrap.nix](https://github.com/input-output-hk/haskell.nix/blob/master/overlays/bootstrap.nix)

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`.

44−for a full list of all the valid `compiler-nix-name`s beyond what's

45−cached/tested in CI. You're free to use these, but be ready for longer build

46−times.

47

27

48−Lastly, see [instructions on adding new GHC versions](../dev/adding-new-ghc.md)

28+See also: [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.mddeleted−65

@@ -1,65 +0,0 @@

1−# Content addressed derivations

2−## Introduction

3−

4−Floating content addressed derivations (from now *CA derivations*) is an experimental feature which substantially change how the hashes in the store paths are calculated.

5−Indeed, normally derivations are input addressed i.e. the outputs store paths depends only on the derivation inputs, instead with CA derivations they depend on the content of the outputs.

6−

7−This has two main advantages:

8−

9−- The so-called "early cutoff", namely the ability of Nix to stop a build if the build outputs would be something already built.

10−For example suppose you add a comment in an Haskell source, at this point Nix will rebuild the component depending on this source but since the output will be the same (adding a comment is an "output-invariant" change for `ghc`) every other component that depends on that will not be rebuilt.

11−- Users of the same Nix store does not need to trust each other when using substituters.

12−

13−You can find more information in the [ca-derivations page on the wiki](https://nixos.wiki/wiki/Ca-derivations) (and in the other resources linked there).

14−

15−## Usage

16−### Enable CA derivations in your system

17−First of all your Nix installation must support the `ca-derivations` experimental feature, this can done by adding the following in your `nix.conf`:

18−

19−```

20−experimental-features = ca-derivations

21−```

22−

23−Or if you use NixOS:

24−```

25−nix.extraOptions = ''

26− experimental-features = ca-derivations

27−'';

28−```

29−

30−## Enable CA derivations in your project

31−At this point you can pass a new module to `project'` that tells `haskell.nix` to build every component in the project as CA derivation.

32−

33−```

34−haskell-nix.project' {

35− # ...

36−

37− modules = [{

38− contentAddressed = true;

39− # packages.project-name.components.exes.executable.contentAddressed = true;

40− }];

41−};

42−```

43−

44−Optionally you can also specify which components you don't want to be content addressed.

45−

46−## Known problems

47−### Limitation of the current CA derivations implementation

48−

49−As explained in the [RFC 62](https://github.com/tweag/rfcs/blob/cas-rfc/rfcs/0062-content-addressed-paths.md)

50−

51−> The current implementation has a naive approach that just forbids fetching a path if the local system has a different realisation for the same drv output. This approach is simple and correct, but it's possible that it might not be good-enough in practice as it can result in a totally useless binary cache in some pathological cases.

52−

53−For example, suppose that your machine builds a derivation `A` producing an output `A.out` in your store and that after that a CI machine builds the same derivation `A` but producing a different output `A.out'` and populating a cache with this output.

54−At this point, if you need to build a derivation `B` that depends on `A`, since you already have the realisation `A.out` in your local store and you can't get `B.out` from the cache and you will end up building `B` even if one of its realisation is in the cache.

55−

56−This means that, in some cases, enabling CA derivations would lead to more rebuilds than not having it.

57−

58−### Hydra

59−Hydra currently doesn't support CA derivations, efforts are being made in this direction.

60−

61−

62−### GHC is not deterministic

63−Currently `ghc` is determinstic only disabling the parallel building i.e. passing `-j1`. [Here](https://gitlab.haskell.org/ghc/ghc/-/issues/12935) the upstream issue.

64−

65−Having a deterministic `ghc` would be a dream since it will automatically fix all the pathological cases about substituters discussed above and would allow `haskell.nix` to parallel build even when using CA derivations.

docs/tutorials/development.md+13−21

@@ -34,14 +34,13 @@ themselves. This is what the [`shellFor`][shellFor] function does.

34

35```nix

36# shell.nix

37+{ pkgs ? import <nixpkgs> {} }:

38+

37let

39let

38− project = import ./default.nix;

40+ hsPkgs = import ./default.nix { inherit pkgs; };

39in

41in

40− project.shellFor {

42+ hsPkgs.shellFor {

41− # ALL of these arguments are optional.

43+ # Include only the *local* packages of your project.

42−

43− # List of packages from the project you want to work on in

44− # the shell (default is all the projects local packages).

45 packages = ps: with ps; [

44 packages = ps: with ps; [

46 pkga

45 pkga

47 pkgb

46 pkgb

@@ -51,22 +50,15 @@ in

51 # and provides a "hoogle" command to search the index.

50 # and provides a "hoogle" command to search the index.

52 withHoogle = true;

51 withHoogle = true;

53

52

53+ # You might want some extra tools in the shell (optional).

54+

54 # Some common tools can be added with the `tools` argument

55 # Some common tools can be added with the `tools` argument

55− tools = {

56− cabal = "3.2.0.0";

56+ tools = { cabal = "3.2.0.0"; hlint = "2.2.11"; };

57− hlint = "latest"; # Selects the latest version in the hackage.nix snapshot

58− haskell-language-server = "latest";

59− };

60 # See overlays/tools.nix for more details

57 # See overlays/tools.nix for more details

61

58

62 # Some you may need to get some other way.

59 # Some you may need to get some other way.

63− buildInputs = [ (import <nixpkgs> {}).git ];

60+ buildInputs = with pkgs.haskellPackages;

64−

65− # Sellect cross compilers to include.

66− crossPlatforms = ps: with ps; [

67− ghcjs # Adds support for `js-unknown-ghcjs-cabal build` in the shell

68− # mingwW64 # Adds support for `x86_64-W64-mingw32-cabal build` in the shell

69− ];

61+ [ ghcid ];

70

62

71 # Prevents cabal from choosing alternate plans, so that

63 # Prevents cabal from choosing alternate plans, so that

72 # *all* dependencies are provided by Nix.

64 # *all* dependencies are provided by Nix.

@@ -85,15 +77,15 @@ If you need a local Hoogle for all the dependencies of your project create this

85```nix

77```nix

86# shell-hoogle.nix

78# shell-hoogle.nix

87let

79let

88− project = import ./default.nix {};

80+ hsPkgs = import ./default.nix {};

89in

81in

90− project.shellFor {

82+ hsPkgs.shellFor {

91 packages = ps: [ps.my-package];

83 packages = ps: [ps.my-package];

92 withHoogle = true;

84 withHoogle = true;

93 }

85 }

94```

86```

95

87

96−and run `nix-shell shell-hoogle.nix --run "hoogle server --local"`.

88+and run `nix-shell shell-hoogle.nix --run "hoogle server --local"`.

97This will open a local Hoogle server at `http://127.0.0.1:8080`.

89This will open a local Hoogle server at `http://127.0.0.1:8080`.

98

90

99

91

docs/tutorials/getting-started-flakes.md+14−44

@@ -22,34 +22,10 @@ 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://cache.iog.io [...]

25+substituters = [...] https://hydra.iohk.io [...]

26```

27

28−If you're running NixOS, you need to add/update the following in your `/etc/nixos/configuration.nix` files instead.

29−

30−```

31−# Binary Cache for Haskell.nix

32−nix.settings.trusted-public-keys = [

33− "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

34−];

35−nix.settings.substituters = [

36− "https://cache.iog.io"

37−];

38−```

39−

40−NixOS-21.11 and older use slightly different settings.

41−

42−```

43−# Binary Cache for Haskell.nix

44−nix.binaryCachePublicKeys = [

45− "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

46−];

47−nix.binaryCaches = [

48− "https://cache.iog.io"

49−];

50−```

51−

52−This can be tricky to get setup properly. If you're still having trouble getting cache hits, consult the corresponding [troubleshooting section](../troubleshooting.md#why-am-i-building-ghc).

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).

53

29

54## Scaffolding

30## Scaffolding

55

31

@@ -74,30 +50,24 @@ Add `flake.nix`:

74 final.haskell-nix.project' {

50 final.haskell-nix.project' {

75 src = ./.;

51 src = ./.;

76 compiler-nix-name = "ghc8104";

52 compiler-nix-name = "ghc8104";

77− # This is used by `nix develop .` to open a shell for use with

78− # `cabal`, `hlint` and `haskell-language-server`

79− shell.tools = {

80− cabal = {};

81− hlint = {};

82− haskell-language-server = {};

83− };

84− # Non-Haskell shell tools go here

85− shell.buildInputs = with pkgs; [

86− nixpkgs-fmt

87− ];

88− # This adds `js-unknown-ghcjs-cabal` to the shell.

89− # shell.crossPlatforms = p: [p.ghcjs];

90 };

53 };

91 })

54 })

92 ];

55 ];

93− pkgs = import nixpkgs { inherit system overlays; inherit (haskellNix) config; };

56+ pkgs = import nixpkgs { inherit system overlays; };

94− flake = pkgs.helloProject.flake {

57+ flake = pkgs.helloProject.flake {};

95− # This adds support for `nix build .#js-unknown-ghcjs-cabal:hello:exe:hello`

96− # crossPlatforms = p: [p.ghcjs];

97− };

98 in flake // {

58 in flake // {

99 # Built by `nix build .`

59 # Built by `nix build .`

100 defaultPackage = flake.packages."hello:exe:hello";

60 defaultPackage = flake.packages."hello:exe:hello";

61+

62+ # This is used by `nix develop .` to open a shell for use with

63+ # `cabal`, `hlint` and `haskell-language-server`

64+ devShell = pkgs.helloProject.shellFor {

65+ tools = {

66+ cabal = "latest";

67+ hlint = "latest";

68+ haskell-language-server = "latest";

69+ };

70+ };

101 });

71 });

102}

72}

103```

73```

docs/tutorials/getting-started-hix.mddeleted−227

@@ -1,227 +0,0 @@

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+28−93

@@ -18,61 +18,22 @@ 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://cache.iog.io [...]

21+substituters = [...] https://hydra.iohk.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

40nix.binaryCachePublicKeys = [

28nix.binaryCachePublicKeys = [

41 "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

29 "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

42];

30];

43nix.binaryCaches = [

31nix.binaryCaches = [

44− "https://cache.iog.io"

32+ "https://hydra.iohk.io"

45−];

33+];

46−```

47−

48−This can be tricky to get setup properly. If you're still having trouble getting cache hits, consult the corresponding [troubleshooting section](../troubleshooting.md#why-am-i-building-ghc).

49−

50−## Niv

51−

52−[Niv](https://github.com/nmattia/niv) is a command line tool for keeping track of Nix project dependencies.

53−

54−This guide assumes that the `sources.haskellNix` will be set to point

55−a pinned copy of the haskell.nix github repo. One easy way to do this

56−is to use Niv. If you prefer not to use Niv another option is described

57−in the in the "Using haskell.nix without niv" section of this document.

58−

59−If you want to use Nix Flakes to pin your dependencies then you should

60−consider following the [Getting started with flakes](./getting-started-flakes.md)

61−document instead of this one.

62−

63−After installing niv you can initialize niv and pin the latest haskell.nix

64−commit by running the following in the root directory of the project:

65−

66−```

67−niv init

68−niv add input-output-hk/haskell.nix -n haskellNix

69```

34```

70

35

71−Then when you want to update to the latest version of haskellNix use:

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).

72−

73−```

74−niv update haskellNix

75−```

76

37

77## Scaffolding

38## Scaffolding

78

39

@@ -82,28 +43,21 @@ projects.

82Add `default.nix`:

43Add `default.nix`:

83

44

84```nix

45```nix

85−let

86− # Read in the Niv sources

87− sources = import ./nix/sources.nix {};

88− # If ./nix/sources.nix file is not found run:

89− # niv init

90− # niv add input-output-hk/haskell.nix -n haskellNix

91−

92− # Fetch the haskell.nix commit we have pinned with Niv

46+{ # Fetch the latest haskell.nix and import its default.nix

93− haskellNix = import sources.haskellNix {};

47+ haskellNix ? import (builtins.fetchTarball "https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz") {}

94− # If haskellNix is not found run:

48+

95− # niv add input-output-hk/haskell.nix -n haskellNix

96−

97− # Import nixpkgs and pass the haskell.nix provided nixpkgsArgs

98− pkgs = import

99− # haskell.nix provides access to the nixpkgs pins which are used by our CI,

49+# haskell.nix provides access to the nixpkgs pins which are used by our CI,

100− # hence you will be more likely to get cache hits when using these.

50+# hence you will be more likely to get cache hits when using these.

101− # But you can also just use your own, e.g. '<nixpkgs>'.

51+# But you can also just use your own, e.g. '<nixpkgs>'.

102− haskellNix.sources.nixpkgs-unstable

52+, nixpkgsSrc ? haskellNix.sources.nixpkgs-2009

53+

103− # These arguments passed to nixpkgs, include some patches and also

54+# haskell.nix provides some arguments to be passed to nixpkgs, including some

104− # the haskell.nix functionality itself as an overlay.

55+# patches and also the haskell.nix functionality itself as an overlay.

105− haskellNix.nixpkgsArgs;

56+, nixpkgsArgs ? haskellNix.nixpkgsArgs

57+

58+# import nixpkgs with overlays

59+, pkgs ? import nixpkgsSrc nixpkgsArgs

106−in pkgs.haskell-nix.project {

60+}: pkgs.haskell-nix.project {

107 # 'cleanGit' cleans a source directory based on the files known by git

61 # 'cleanGit' cleans a source directory based on the files known by git

108 src = pkgs.haskell-nix.haskellLib.cleanGit {

62 src = pkgs.haskell-nix.haskellLib.cleanGit {

109 name = "haskell-nix-project";

63 name = "haskell-nix-project";

@@ -142,40 +96,20 @@ nix-build -A projectCross.ghcjs.hsPkgs.your-package-name.components.exes.your-ex

142nix-build -A projectCross.mingwW64.hsPkgs.your-package-name.components.exes.your-exe-name

96nix-build -A projectCross.mingwW64.hsPkgs.your-package-name.components.exes.your-exe-name

143```

97```

144

98

145−To open a shell for use with `cabal`, `hlint` and `haskell-language-server` add `shell.nix`:

99+To open a shell for use with `cabal` run:

146−

147−```nix

148−(import ./default.nix).shellFor {

149− tools = {

150− cabal = "3.2.0.0";

151− hlint = "latest";

152− haskell-language-server = "latest";

153− };

154−}

155−```

156−

157−Then run:

158

100

159```shell

101```shell

160−nix-shell

102+nix-shell -A shellFor

161cabal new-repl your-package-name:library:your-package-name

103cabal new-repl your-package-name:library:your-package-name

162cabal new-build your-package-name

104cabal new-build your-package-name

163```

105```

164

106

165To open a shell for use with `stack` see [the following issue](https://github.com/input-output-hk/haskell.nix/issues/689#issuecomment-643832619).

107To open a shell for use with `stack` see [the following issue](https://github.com/input-output-hk/haskell.nix/issues/689#issuecomment-643832619).

166

108

167−## Using haskell.nix without Niv

109+### Pinning the [haskell.nix][] version

168−

169−If you would prefer not to use niv you can replace

170−`sources = import ./nix/sources.nix {};` in the examples with:

171

110

172−```nix

111+For simplicity's sake we will use `fetchTarball` for the examples in

173−let sources = {

174− haskellNix = builtins.fetchTarball "https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz";

175− };

176−```

177−

178−The `fetchTarball` call above will always get the latest version, and is

112+this documentation. This will always get the latest version, and is

179similar to an auto-updating Nix channel.

113similar to an auto-updating Nix channel.

180

114

181However, in your own project, you may wish to pin [haskell.nix][] (as

115However, in your own project, you may wish to pin [haskell.nix][] (as

@@ -185,9 +119,10 @@ predictable, and faster (because the fixed version is cached).

185Straightforward way of doing this is to change the branch name to a revision.

119Straightforward way of doing this is to change the branch name to a revision.

186

120

187```nix

121```nix

188−let sources = {

122+{ # Fetch a specific haskell.nix and import its default.nix

189− haskellNix = builtins.fetchTarball "https://github.com/input-output-hk/haskell.nix/archive/f1a94a4c82a2ab999a67c3b84269da78d89f0075.tar.gz";

123+ haskellNix ? import (builtins.fetchTarball "https://github.com/input-output-hk/haskell.nix/archive/f1a94a4c82a2ab999a67c3b84269da78d89f0075.tar.gz") {}

190− };

124+

125+...

191```

126```

192

127

193There are other possible schemes for pinning. See

128There are other possible schemes for pinning. See

docs/tutorials/materialization.md+115−99

@@ -2,7 +2,7 @@

2

3## What is materialization?

4

5−Capturing and storing the Nix files for a project so that they do

5+Capturing and storing the nix files for a project so that they do

6not need to be built (or checked). This allows us to cache the input

7of an IFD (import from derivation).

8

@@ -16,146 +16,143 @@ dependencies of nix-tools for instance).

16 is not unusual for it to take 5 seconds per project).

17

18* They can be slow to build (or download) on machines that do not

19− yet have them in the Nix store.

19+ yet have them in the nix store.

20

21−* Hydra does not show progress because it does not provide feedback until it

21+* Hydra does not show progress because it does not provide feedback

22− has a list of jobs and the list of jobs cannot depend on the Nix expressions

22+ until it has a list of jobs and the list of jobs cannot depends

23− being present (although this is often blamed on IFD it would be the same if

23+ on the nix being present (although this is often blamed on IFD

24− it wrote out JSON files and read them in)

24+ it would be the same if it wrote out JSON files and read them in)

25

26−## When is it OK to materialize?

26+## When is it ok to materialize?

27

28−* The Nix expressions are unlikely to change frequently (and when it does you

28+* The nix is unlikely to change frequently (and when it does you

29 are happy to manually update it).

30

31−* You are happy to script something to update the materialized Nix files

31+* You are happy to script something to update the materialized

32− automatically.

32+ nix files automatically.

33+* You are certain that the IFD you materialize is not `system`-dependent. If it was you'd

34+ obtain different nix expressions depending on which `system` the IFD was evaluated.

33

35

34−* You are certain that the IFD you materialize is not `system`-dependent. If it

36+## How can we materialize the nix files?

35− was you'd obtain different Nix expressions depending on which `system` the

36− IFD was evaluated.

37

38−## How can we materialize the Nix files?

39−

40−Lets say we want to build `hlint`. We might start with an `hlint.nix`

38+Lets say we want to build `hlint`. We might start with an `hlint`

41file that looks like this:

39file that looks like this:

42

40

43```nix

41```nix

44let inherit (import ./. {}) sources nixpkgsArgs;

42let inherit (import ./. {}) sources nixpkgsArgs;

45 pkgs = import sources.nixpkgs nixpkgsArgs;

43 pkgs = import sources.nixpkgs nixpkgsArgs;

46 hlint = pkgs.haskell-nix.hackage-package {

44 hlint = pkgs.haskell-nix.hackage-package {

47− compiler-nix-name = "ghc8102";

45+ compiler-nix-name = "ghc884";

48 name = "hlint";

46 name = "hlint";

49 version = "2.2.11";

47 version = "2.2.11";

50 };

48 };

51−in hlint

49+in hlint.components.exes.hlint

52```

50```

53

51

54Building this may result in a lot of output, but if you build

52Building this may result in a lot of output, but if you build

55it again it should give just:

53it again it should give just:

56

54

57```

55```

58−$ nix-build hlint.nix -A components.exes.hlint

56+$ nix-build hlint.nix

59−trace: No index state specified for hlint, using the latest index state that we know about (2021-01-04T00:00:00Z)!

57+trace: Using latest index state for hlint!

60−/nix/store/2ybrfmcp79gg75ad4pr1cbxjak70yg8b-hlint-exe-hlint-2.2.11

58+trace: Using index-state: 2020-04-15T00:00:00Z for hlint

59+/nix/store/rnfz66v7k8i38c8rsmchzsyqjrmrbdpk-hlint-2.2.11-exe-hlint

61```

60```

62

61

63−To materialize the Nix files we need to take care to pin down the inputs. Stack

62+To materialize the nix files we need to take care to pin down the

64−projects have their inputs pinned through specifying the snapshot. For cabal

65−projects this means we must specify the `index-state` of hackage we want to

63+inputs. For cabal projects this means we must specify the

66−use:

64+`index-state` of hackage we want to use:

67

65

68```nix

66```nix

69let inherit (import ./. {}) sources nixpkgsArgs;

67let inherit (import ./. {}) sources nixpkgsArgs;

70 pkgs = import sources.nixpkgs nixpkgsArgs;

68 pkgs = import sources.nixpkgs nixpkgsArgs;

71 hlint = pkgs.haskell-nix.hackage-package {

69 hlint = pkgs.haskell-nix.hackage-package {

72− compiler-nix-name = "ghc8102";

70+ compiler-nix-name = "ghc884";

73 name = "hlint";

71 name = "hlint";

74 version = "2.2.11";

72 version = "2.2.11";

75− index-state = "2021-01-04T00:00:00Z";

73+ index-state = "2020-04-15T00:00:00Z";

76 };

74 };

77−in hlint

75+in hlint.components.exes.hlint

78```

76```

79

77

80−Now if we build again we get a hint telling use how to calculate a suitable

78+Now if we build again we get a hint telling use how to

79+calculate a suitable sha256 hash to turn the derivation

81−sha256 hash to turn the derivation containing the Nix files into a fixed-output

80+containing the nix files into a fixed output derivation:

82−derivation:

83

81

84```

82```

85−$ nix-build hlint.nix -A components.exes.hlint

83+$ nix-build hlint.nix

86−trace: To make project.plan-nix for hlint a fixed-output derivation but not materialized, set `plan-sha256` to the output of the 'calculateMaterializedSha' script in 'passthru'.

84+trace: Using index-state: 2020-04-15T00:00:00Z for hlint

87−trace: To materialize project.plan-nix for hlint entirely, pass a writable path as the `materialized` argument and run the 'updateMaterialized' script in 'passthru'.

85+trace: Get `plan-sha256` with `nix-hash --base32 --type sha256 /nix/store/8z6p4237rin3c6c1lmjwshmj8rdqrhw2-hlint-plan-to-nix-pkgs/`

88−/nix/store/2ybrfmcp79gg75ad4pr1cbxjak70yg8b-hlint-exe-hlint-2.2.11

86+/nix/store/rnfz66v7k8i38c8rsmchzsyqjrmrbdpk-hlint-2.2.11-exe-hlint

89−

87+

90−$ nix-build hlint.nix -A project.plan-nix.passthru.calculateMaterializedSha | bash

88+$ nix-hash --base32 --type sha256 /nix/store/8z6p4237rin3c6c1lmjwshmj8rdqrhw2-hlint-plan-to-nix-pkgs/

91−trace: To make project.plan-nix for hlint a fixed-output derivation but not materialized, set `plan-sha256` to the output of the 'calculateMaterializedSha' script in 'passthru'.

89+02hasr27a994sml1fzf8swb716lm6lgixxr53y0gxkhw437xkck4

92−trace: To materialize project.plan-nix for hlint entirely, pass a writable path as the `materialized` argument and run the 'updateMaterialized' script in 'passthru'.

93−04hdgqwpaswmyb0ili7fwi6czzihd6x0jlvivw52d1i7wv4gaqy7

94```

90```

95

91

96−For a Stack project all occurences of `plan-nix` and `plan-sha256` are replaced

92+We can add the hash as `plan-sha256` or (`stack-sha256` for

97−by `stack-nix` and `stack-sha256`, respectively. We can add the hash as

93+stack projects)

98−`plan-sha256`:

99

94

100```nix

95```nix

101let inherit (import ./. {}) sources nixpkgsArgs;

96let inherit (import ./. {}) sources nixpkgsArgs;

102 pkgs = import sources.nixpkgs nixpkgsArgs;

97 pkgs = import sources.nixpkgs nixpkgsArgs;

103 hlint = pkgs.haskell-nix.hackage-package {

98 hlint = pkgs.haskell-nix.hackage-package {

104− compiler-nix-name = "ghc8102";

99+ compiler-nix-name = "ghc884";

105 name = "hlint";

100 name = "hlint";

106 version = "2.2.11";

101 version = "2.2.11";

107− index-state = "2021-01-04T00:00:00Z";

102+ index-state = "2020-04-15T00:00:00Z";

108− plan-sha256 = "04hdgqwpaswmyb0ili7fwi6czzihd6x0jlvivw52d1i7wv4gaqy7";

103+ plan-sha256 = "02hasr27a994sml1fzf8swb716lm6lgixxr53y0gxkhw437xkck4";

109 };

104 };

110−in hlint

105+in hlint.components.exes.hlint

111```

106```

112

107

113−Just adding the hash might help reuse of the cached Nix expressions, but Nix

108+Just adding the hash might help reuse of the cached nix, but nix will

114−will still calculate all the dependencies (which can add seconds to `nix-build`

109+still calculate all the dependencies (which can add seconds to

115−and `nix-shell` commands when no other work is needed) and users who do not yet

110+`nix-build` and `nix-shell` commands when no other work is needed)

116−have the dependencies in their store will have to wait while they are built or

111+and users who do not yet have the dependencies in their store will have

117−downloaded.

112+to wait while they are built or downloaded.

118

113

119−Running `nix-build` again gives us a hint on what we can do next:

114+Running nix build again gives us a hint on what we can do next:

120

115

121```

116```

122−$ nix-build hlint.nix -A components.exes.hlint

117+$ nix-build hlint.nix

123−trace: To materialize project.plan-nix for hlint entirely, pass a writable path as the `materialized` argument and run the 'updateMaterialized' script in 'passthru'.

118+trace: Using index-state: 2020-04-15T00:00:00Z for hlint

124−/nix/store/2ybrfmcp79gg75ad4pr1cbxjak70yg8b-hlint-exe-hlint-2.2.11

119+trace: To materialize, point `materialized` to a copy of /nix/store/kk047cqsjvbj4w8psv4l05abdcnyrqdc-hlint-plan-to-nix-pkgs

120+/nix/store/rnfz66v7k8i38c8rsmchzsyqjrmrbdpk-hlint-2.2.11-exe-hlint

125```

121```

126

122

127−To capture the Nix expressions we can do something like:

123+To capture the nix we can do something like:

128

124

129```nix

125```nix

130let inherit (import ./. {}) sources nixpkgsArgs;

126let inherit (import ./. {}) sources nixpkgsArgs;

131 pkgs = import sources.nixpkgs nixpkgsArgs;

127 pkgs = import sources.nixpkgs nixpkgsArgs;

132 hlint = pkgs.haskell-nix.hackage-package {

128 hlint = pkgs.haskell-nix.hackage-package {

133− compiler-nix-name = "ghc8102";

129+ compiler-nix-name = "ghc884";

134 name = "hlint";

130 name = "hlint";

135 version = "2.2.11";

131 version = "2.2.11";

136− index-state = "2021-01-04T00:00:00Z";

132+ index-state = "2020-04-15T00:00:00Z";

137− plan-sha256 = "04hdgqwpaswmyb0ili7fwi6czzihd6x0jlvivw52d1i7wv4gaqy7";

133+ plan-sha256 = "02hasr27a994sml1fzf8swb716lm6lgixxr53y0gxkhw437xkck4";

138 materialized = ./hlint.materialized;

134 materialized = ./hlint.materialized;

139 };

135 };

140−in hlint

136+in hlint.components.exes.hlint

141```

137```

142

138

143−Now we can copy the Nix files needed and build with:

139+Now we can copy the nix files needed and build with:

144

140

145```

141```

146−$ nix-build hlint.nix 2>&1 | grep -om1 '/nix/store/.*-updateMaterialized' | bash

142+$ cp -r /nix/store/8z6p4237rin3c6c1lmjwshmj8rdqrhw2-hlint-plan-to-nix-pkgs hlint.materialized

147−$ nix-build hlint.nix -A components.exes.hlint

143+$ nix-build hlint.nix

148−building '/nix/store/wpxsgzl1z4jnhfqzmzg3xxv3ljpmzr5h-hlint-plan-to-nix-pkgs.drv'...

144+/nix/store/rnfz66v7k8i38c8rsmchzsyqjrmrbdpk-hlint-2.2.11-exe-hlint

149−/nix/store/2ybrfmcp79gg75ad4pr1cbxjak70yg8b-hlint-exe-hlint-2.2.11

150```

145```

151

146

147+We may want to run `chmod -R +w hlint.materialized` as the files copied from the

148+store will be read only.

149+

152## How can we check `sha256` and `materialized` are up to date?

150## How can we check `sha256` and `materialized` are up to date?

153

151

154Let's pretend we had to go back to `hlint` version `2.2.10`.

152Let's pretend we had to go back to `hlint` version `2.2.10`.

155We can tell haskell.nix to check the materialization either by:

153We can tell haskell.nix to check the materialization either by:

156

154

157* Removing the materialization files with `rm -rf hlint.materialized`

155* Removing the materialization files with `rm -rf hlint.materialized`

158−

159* Temporarily adding `checkMaterialization = true;`

156* Temporarily adding `checkMaterialization = true;`

160

157

161If we choose to add the `checkMaterialization` flag you would have:

158If we choose to add the `checkMaterialization` flag you would have:

@@ -164,51 +161,69 @@ If we choose to add the `checkMaterialization` flag you would have:

164let inherit (import ./. {}) sources nixpkgsArgs;

161let inherit (import ./. {}) sources nixpkgsArgs;

165 pkgs = import sources.nixpkgs nixpkgsArgs;

162 pkgs = import sources.nixpkgs nixpkgsArgs;

166 hlint = pkgs.haskell-nix.hackage-package {

163 hlint = pkgs.haskell-nix.hackage-package {

167− compiler-nix-name = "ghc8102";

164+ compiler-nix-name = "ghc884";

168 name = "hlint";

165 name = "hlint";

169 version = "2.2.10";

166 version = "2.2.10";

170− index-state = "2021-01-04T00:00:00Z";

167+ index-state = "2020-04-15T00:00:00Z";

171− plan-sha256 = "04hdgqwpaswmyb0ili7fwi6czzihd6x0jlvivw52d1i7wv4gaqy7";

168+ plan-sha256 = "02hasr27a994sml1fzf8swb716lm6lgixxr53y0gxkhw437xkck4";

172 materialized = ./hlint.materialized;

169 materialized = ./hlint.materialized;

173 checkMaterialization = true;

170 checkMaterialization = true;

174 };

171 };

175−in hlint

172+in hlint.components.exes.hlint

176```

173```

177

174

178This will fail and report the details of what is wrong and how to fix it:

175This will fail and report the details of what is wrong and how to fix it:

179

176

180```

177```

181−$ nix-build hlint.nix -A components.exes.hlint

178+$ nix-build hlint.nix

182

179

183...

180...

184

181

185−Calculated hash for hlint-plan-to-nix-pkgs was not 04hdgqwpaswmyb0ili7fwi6czzihd6x0jlvivw52d1i7wv4gaqy7. New hash is :

182+Calculated hash for hlint-plan-to-nix-pkgs was not 02hasr27a994sml1fzf8swb716lm6lgixxr53y0gxkhw437xkck4. New hash is :

186− plan-sha256 = "0jsgdmii0a6b35sd42cpbc83s4sp4fbx8slphzvamq8n9x49i5b6";

183+ plan-sha256 = "0zsi3wv92qax33ic4n5dfsqd1r9qam1k75za3c5jqgdxl3hy8vph";

187−Materialized nix used for hlint-plan-to-nix-pkgs incorrect. To fix run: /nix/store/6wp0zzal40ls874f5ddpaac7qmii9y4z-updateMaterialized

184+Materialized nix used for hlint-plan-to-nix-pkgs incorrect. To fix run :

185+ rm -rf /Users/hamish/iohk/haskell.nix/hlint.materialized

186+ cp -r /nix/store/ywdhbx9rzzkfc60c5vzk7cins2hnvkgx-hlint-plan-to-nix-pkgs /Users/hamish/iohk/haskell.nix/hlint.materialized

187+ chmod -R +w /Users/hamish/iohk/haskell.nix/hlint.materialized

188−builder for '/nix/store/61a0vginv76w4p9ycyd628pjanav06pl-hlint-plan-to-nix-pkgs.drv' failed with exit code 1

188+builder for '/nix/store/a5zmgfjfxahapw0q8hd2da5bg7knqvbx-hlint-plan-to-nix-pkgs.drv' failed with exit code 1

189−error: build of '/nix/store/61a0vginv76w4p9ycyd628pjanav06pl-hlint-plan-to-nix-pkgs.drv' failed

189+error: build of '/nix/store/a5zmgfjfxahapw0q8hd2da5bg7knqvbx-hlint-plan-to-nix-pkgs.drv' failed

190(use '--show-trace' to show detailed location information)

191```

192

193−Checking the materialization requires Nix to do all the work that

193+Checking the materialization requires nix to do all the work that materialization

194−materialization avoids. So while it might be tempting to leave

194+avoids. So while it might be tempting to leave `checkMaterialization = true` all

195−`checkMaterialization = true` all the time, we would be better off just

196−removing `materialized` and `plan-sha256`.

195+the time, we would be better off just removing `materialized` and `plan-sha256`.

197

196

198−## How can we update the Nix files with a script?

197+## How can we update the nix files with a script?

199

198

200−We can simply put the commands we used earlier in a script:

199+There are versions of the functions (`project'`, `cabalProject'`,

200+`stackProject'` and `hackage-project`) that also return the nix as

201+`plan-nix` or `stack-nix`. By calling one of these functions without

202+the hash and materialized nix we can find out what nix files should be.

203+For instance:

201

204

202```nix

205```nix

203−#!/bin/sh

206+let inherit (import ./. {}) sources nixpkgsArgs;

204−

207+ pkgs = import sources.nixpkgs nixpkgsArgs;

205−# Output new plan-sha256

208+ hlint = pkgs.haskell-nix.hackage-project {

206−nix-build hlint.nix -A project.plan-nix.passthru.calculateMaterializedSha | bash

209+ compiler-nix-name = "ghc884";

210+ name = "hlint";

211+ version = "2.2.10";

212+ index-state = "2020-04-15T00:00:00Z";

213+ };

214+in hlint

215+```

207

216

208−# Update materialized Nix expressions

217+```

209−nix-build hlint.nix 2>&1 | grep -om1 '/nix/store/.*-updateMaterialized' | bash

218+$ nix-build hlint.nix -A plan-nix

219+trace: Using index-state: 2020-04-15T00:00:00Z for hlint

220+trace: Get `plan-sha256` with `nix-hash --base32 --type sha256 /nix/store/ywdhbx9rzzkfc60c5vzk7cins2hnvkgx-hlint-plan-to-nix-pkgs/`

221+/nix/store/ywdhbx9rzzkfc60c5vzk7cins2hnvkgx-hlint-plan-to-nix-pkgs

210```

222```

211

223

224+We can have the script copy `$(nix-build hlint.nix -A plan-nix --no-out-link)`

225+and use `nix-hash` to calculate the new value for `plan-sha256`.

226+

212## Can we skip making a copy and use `materialized = /nix/store/...`?

227## Can we skip making a copy and use `materialized = /nix/store/...`?

213

228

214Yes and it gives us the same speed improvement, however:

229Yes and it gives us the same speed improvement, however:

@@ -216,7 +231,7 @@ Yes and it gives us the same speed improvement, however:

216* It does not help at all in `restricted-eval` mode (Hydra).

231* It does not help at all in `restricted-eval` mode (Hydra).

217

232

218* Users will still wind up building or downloading the dependencies

233* Users will still wind up building or downloading the dependencies

219− needed to build the Nix files (if they do not have them).

234+ needed to build the nix files (if they do not have them).

220

235

221For those reasons it might be best to make a copy instead

236For those reasons it might be best to make a copy instead

222of using the `/nix/store/...` path directly.

237of using the `/nix/store/...` path directly.

@@ -228,29 +243,30 @@ a non-existing path is now an error:

228```nix

243```nix

229let inherit (import ./. {}) sources nixpkgsArgs;

244let inherit (import ./. {}) sources nixpkgsArgs;

230 pkgs = import sources.nixpkgs nixpkgsArgs;

245 pkgs = import sources.nixpkgs nixpkgsArgs;

231− hlintPlan = /nix/store/63k3f8bvsnag7v36vb3149208jyx61rk-hlint-plan-to-nix-pkgs;

246+ hlintPlan = /nix/store/kk047cqsjvbj4w8psv4l05abdcnyrqdc-hlint-plan-to-nix-pkgs;

232 hlint = pkgs.haskell-nix.hackage-package {

247 hlint = pkgs.haskell-nix.hackage-package {

233− compiler-nix-name = "ghc8102";

248+ compiler-nix-name = "ghc884";

234 name = "hlint";

249 name = "hlint";

235 version = "2.2.11";

250 version = "2.2.11";

236− index-state = "2021-01-04T00:00:00Z";

251+ index-state = "2020-04-15T00:00:00Z";

237− plan-sha256 = "04hdgqwpaswmyb0ili7fwi6czzihd6x0jlvivw52d1i7wv4gaqy7";

252+ plan-sha256 = "02hasr27a994sml1fzf8swb716lm6lgixxr53y0gxkhw437xkck4";

238 materialized = if __pathExists hlintPlan then hlintPlan else null;

253 materialized = if __pathExists hlintPlan then hlintPlan else null;

239 };

254 };

240−in hlint

255+in hlint.components.exes.hlint

241```

256```

242

257

243Running when no building is needed is still slow in restricted evaluation mode.

258Running when no building is needed is still slow in restricted evaluation mode.

244

259

245```

260```

246−$ time nix-build --option restrict-eval true -I . --option allowed-uris "https://github.com/NixOS https://github.com/input-output-hk" hlint.nix -A components.exes.hlint --show-trace

261+$ time nix-build --option restrict-eval true -I . --option allowed-uris "https://github.com/NixOS https://github.com/input-output-hk" hlint.nix --show-trace

247−/nix/store/2ybrfmcp79gg75ad4pr1cbxjak70yg8b-hlint-exe-hlint-2.2.11

262+trace: Using index-state: 2020-04-15T00:00:00Z for hlint

263+/nix/store/rnfz66v7k8i38c8rsmchzsyqjrmrbdpk-hlint-2.2.11-exe-hlint

248

264

249real 0m4.463s

265real 0m4.463s

250user 0m4.440s

266user 0m4.440s

251sys 0m0.461s

267sys 0m0.461s

252−$ time nix-build hlint.nix -A components.exes.hlint

268+$ time nix-build hlint.nix

253−/nix/store/2ybrfmcp79gg75ad4pr1cbxjak70yg8b-hlint-exe-hlint-2.2.11

269+/nix/store/rnfz66v7k8i38c8rsmchzsyqjrmrbdpk-hlint-2.2.11-exe-hlint

254

270

255real 0m2.206s

271real 0m2.206s

256user 0m1.665s

272user 0m1.665s

docs/tutorials/pkg-map.md+4−4

@@ -3,10 +3,10 @@

3Cabal files may contain dependencies to external non-Haskell

4dependencies via:

5

6−* [`build-tool-depends`](https://cabal.readthedocs.io/en/latest/cabal-package.html#pkg-field-build-tool-depends)

6+* [`build-tool-depends`](https://cabal.readthedocs.io/en/latest/developing-packages.html#pkg-field-build-tool-depends)

7−* [`pkgconfig-depends`](https://cabal.readthedocs.io/en/latest/cabal-package.html#pkg-field-pkgconfig-depends)

7+* [`pkgconfig-depends`](https://cabal.readthedocs.io/en/latest/developing-packages.html#pkg-field-pkgconfig-depends)

8−* [`frameworks`](https://cabal.readthedocs.io/en/latest/cabal-package.html#pkg-field-frameworks)

8+* [`frameworks`](https://cabal.readthedocs.io/en/latest/developing-packages.html#pkg-field-frameworks)

9−* [`extra-libraries`](https://cabal.readthedocs.io/en/latest/cabal-package.html#pkg-field-extra-libraries)

9+* [`extra-libraries`](https://cabal.readthedocs.io/en/latest/developing-packages.html#pkg-field-extra-libraries)

10

11If there is a `pkgs` attribute in Nixpkgs that matches the name given

12in the Cabal file, then it will be added as a dependency (see the

flake.lockdeleted−396

@@ -1,396 +0,0 @@

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+37−135

@@ -2,147 +2,49 @@

2 description = "Alternative Haskell Infrastructure for Nixpkgs";

3

4 inputs = {

5− nixpkgs.follows = "nixpkgs-unstable";

5+ # Note: keep this in sync with sources.json!

6− nixpkgs-2003 = { url = "github:NixOS/nixpkgs/nixpkgs-20.03-darwin"; };

6+ nixpkgs.url = github:NixOS/nixpkgs/f02bf8ffb9a5ec5e8f6f66f1e5544fd2aa1a0693;

7− nixpkgs-2105 = { url = "github:NixOS/nixpkgs/nixpkgs-21.05-darwin"; };

7+ nixpkgs-2003.url = github:NixOS/nixpkgs/7f73e46625f508a793700f5110b86f1a53341d6e;

8− nixpkgs-2111 = { url = "github:NixOS/nixpkgs/nixpkgs-21.11-darwin"; };

8+ nixpkgs-2009.url = github:NixOS/nixpkgs/f02bf8ffb9a5ec5e8f6f66f1e5544fd2aa1a0693;

9− nixpkgs-2205 = { url = "github:NixOS/nixpkgs/nixpkgs-22.05-darwin"; };

10− nixpkgs-unstable = { url = "github:NixOS/nixpkgs/nixpkgs-unstable"; };

9+ nixpkgs-unstable.url = github:NixOS/nixpkgs/410bbd828cdc6156aecd5bc91772ad3a6b1099c7;

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− };

60 };

10 };

61

11

62− outputs = { self, nixpkgs, nixpkgs-unstable, nixpkgs-2105, nixpkgs-2111, nixpkgs-2205, flake-utils, ... }@inputs:

12+ outputs = { self, nixpkgs, ... }:

63− let compiler = "ghc924";

13+ {

64− config = import ./config.nix;

65− in {

66− inherit config;

67− overlay = self.overlays.combined;

68− overlays = import ./overlays { sources = inputs; };

69− internal = rec {

70− nixpkgsArgs = {

71− inherit config;

72− overlays = [ self.overlay ];

73− };

74

14

75− sources = inputs;

15+ internal = rec {

16+ config = import ./config.nix;

17+ # We can't import ./nix/sources.nix directly, because that uses nixpkgs to fetch by default,

18+ # and importing nixpkgs without specifying localSystem doesn't work on flakes.

19+ sources = let

20+ sourcesInfo =

21+ builtins.fromJSON (builtins.readFile ./nix/sources.json);

22+ fetch = sourceInfo:

23+ builtins.fetchTarball { inherit (sourceInfo) url sha256; };

24+ in builtins.mapAttrs (_: fetch) sourcesInfo;

76

25

77− overlaysOverrideable = import ./overlays;

26+ nixpkgsArgs = {

78− # Compatibility with old default.nix

79− compat = { checkMaterialization ?

80− false # Allows us to easily switch on materialization checking

81− , system, sourcesOverride ? { }, ... }@args: rec {

82− sources = inputs // sourcesOverride;

83− allOverlays = import ./overlays (args // { inherit sources; });

84− inherit config;

27+ inherit config;

85− # We are overriding 'overlays' and 'nixpkgsArgs' from the

28+ overlays = [ self.overlay ];

86− # flake outputs so that we can incorporate the args passed

87− # to the compat layer (e.g. sourcesOverride).

88− overlays = [ allOverlays.combined ]

89− ++ (if checkMaterialization == true then

90− [

91− (final: prev: {

92− haskell-nix = prev.haskell-nix // {

93− checkMaterialization = true;

94− };

95− })

96− ]

97− else

98− [ ]);

99− nixpkgsArgs = {

100− inherit config overlays;

101− };

102− pkgs = import nixpkgs

103− (nixpkgsArgs // { localSystem = { inherit system; }; });

104− pkgs-2105 = import nixpkgs-2105

105− (nixpkgsArgs // { localSystem = { inherit system; }; });

106− pkgs-2111 = import nixpkgs-2111

107− (nixpkgsArgs // { localSystem = { inherit system; }; });

108− pkgs-2205 = import nixpkgs-2205

109− (nixpkgsArgs // { localSystem = { inherit system; }; });

110− pkgs-unstable = import nixpkgs-unstable

111− (nixpkgsArgs // { localSystem = { inherit system; }; });

112− hix = import ./hix/default.nix { inherit pkgs; };

113− };

114 };

29 };

115

30

116− # Note: `nix flake check` evaluates outputs for all platforms, and haskell.nix

31+ overlaysOverrideable = import ./overlays;

117− # uses IFD heavily, you have to have the ability to build for all platforms

32+ };

118− # supported by haskell.nix, e.g. with remote builders, in order to check this flake.

119− # If you want to run the tests for just your platform, run `./test/tests.sh` or

120− # `nix-build -A checks.$PLATFORM`

121− } // flake-utils.lib.eachSystem [ "x86_64-linux" "x86_64-darwin" "aarch64-linux" "aarch64-darwin" ] (system: rec {

122− legacyPackages = (self.internal.compat { inherit system; }).pkgs;

123− legacyPackagesUnstable = (self.internal.compat { inherit system; }).pkgs-unstable;

124

33

125− # FIXME: Currently `nix flake check` requires `--impure` because coverage-golden

34+ # Using the eval-on-build version here as the plan is that

126− # (and maybe other tests) import projects that use builtins.currentSystem

35+ # `builtins.currentSystem` will not be supported in flakes.

127− checks = builtins.listToAttrs (map (pkg: {

36+ # https://github.com/NixOS/rfcs/pull/49/files#diff-a5a138ca225433534de8d260f225fe31R429

128− name = pkg.name;

37+ overlay = self.overlays.combined-eval-on-build;

129− value = pkg;

38+ overlays = self.internal.overlaysOverrideable { sourcesOverride = self.internal.sources; };

130− }) (nixpkgs.lib.collect nixpkgs.lib.isDerivation (import ./test rec {

131− haskellNix = self.internal.compat { inherit system; };

132− compiler-nix-name = compiler;

133− pkgs = haskellNix.pkgs;

134− })));

135− # Exposed so that buildkite can check that `allow-import-from-derivation=false` works for core of haskell.nix

136− roots = legacyPackagesUnstable.haskell-nix.roots compiler;

137

39

138− devShell = with self.legacyPackages.${system};

40+ legacyPackages = let

139− mkShell {

41+ genAttrs = lst: f:

140− buildInputs = [

42+ builtins.listToAttrs (map (name: {

141− nixUnstable

43+ inherit name;

142− cabal-install

44+ value = f name;

143− haskell-nix.compiler.${compiler}

45+ }) lst);

144− haskell-nix.nix-tools.${compiler}

46+ in genAttrs [ "x86_64-linux" "x86_64-darwin" ] (system:

145− ];

47+ import nixpkgs

146− };

48+ (self.internal.nixpkgsArgs // { localSystem = { inherit system; }; }));

147− });

49+ };

148}

50}

hackage-src.json+4−4

@@ -1,9 +1,9 @@

1{

2 "url": "https://github.com/input-output-hk/hackage.nix",

3− "rev": "9bdefa51c864bbef48a2758b05b4b568f0ded62b",

3+ "rev": "48960ebaabc5f7f9433b2ed6d5dea66550f5e99e",

4− "date": "2021-08-06T01:11:48+00:00",

4+ "date": "2021-03-18T01:14:50+00:00",

5− "path": "/nix/store/isypgnv4qa5398z6vjc3fi620l4y87c4-hackage.nix-9bdefa5",

5+ "path": "/nix/store/1d449n54vzgyw7sljy1f97yk1nign6ih-hackage.nix-48960eb",

6− "sha256": "0pm3m864wwgf76isjwb8244xh8xykc94b5az6zb1h38q30s9xjji",

6+ "sha256": "024nxylwxikmlbwlniigzp3rcxyksjran1xpig2z7ynixpzwb0k7",

7 "fetchSubmodules": false,

8 "deepClone": false,

9 "leaveDotGit": false

hix/default.nixdeleted−43

@@ -1,43 +0,0 @@

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.nixdeleted−77

@@ -1,77 +0,0 @@

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+14−120

@@ -74,21 +74,20 @@ 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− extractSourceRepoPackageData = cabalProjectFileName: sha256map: repo: {

77+ extractRepoData = cabalProjectFileName: lookupSha256: repo:

78+ builtins.map (subdir:

79+ {

78− url = repo.location;

80+ url = repo.location;

79− ref = repo.tag;

81+ ref = repo.tag;

80− sha256 = repo."--sha256" or (

82+ sha256 = repo."--sha256" or (lookupSha256 repo);

81− if sha256map != null

83+ inherit subdir;

82− then sha256map."${repo.location}"."${repo.tag}"

84+ })

83− else null);

84− subdirs = if repo ? subdir

85+ (if repo ? subdir

85− then pkgs.lib.filter (x: x != "") (pkgs.lib.splitString " " repo.subdir)

86+ then pkgs.lib.filter (x: x != "") (pkgs.lib.splitString " " repo.subdir)

86− else ["."];

87+ else ["."]);

87− };

88

89 # Parse a source-repository-package and return data of `type: git` repositories

90− # See tests/unit.nix for examples of input and output.

91− parseSourceRepositoryPackageBlock = cabalProjectFileName: sha256map: block:

90+ parseBlock = cabalProjectFileName: lookupSha256: block:

92 let

91 let

93 x = span (pkgs.lib.strings.hasPrefix " ") (pkgs.lib.splitString "\n" block);

92 x = span (pkgs.lib.strings.hasPrefix " ") (pkgs.lib.splitString "\n" block);

94 attrs = parseBlockLines x.fst;

93 attrs = parseBlockLines x.fst;

@@ -99,115 +98,10 @@ let

99 otherText = "\nsource-repository-package\n" + block;

98 otherText = "\nsource-repository-package\n" + block;

100 }

99 }

101 else {

100 else {

102− sourceRepo = extractSourceRepoPackageData cabalProjectFileName sha256map attrs;

101+ sourceRepo = extractRepoData cabalProjectFileName lookupSha256 attrs;

103 otherText = pkgs.lib.strings.concatStringsSep "\n" x.snd;

102 otherText = pkgs.lib.strings.concatStringsSep "\n" x.snd;

104 };

103 };

105

104

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−

209in {

105in {

210− inherit parseIndexState parseSourceRepositoryPackages parseRepositories

106+ inherit parseIndexState parseBlockLines parseBlock;

211− # These are only exposed for tests

212− parseSourceRepositoryPackageBlock parseRepositoryBlock;

213}

107}

lib/call-cabal-project-to-nix.nix+81−165

@@ -1,4 +1,4 @@

1−{ pkgs, runCommand, cacert, index-state-hashes, haskellLib }@defaults:

1+{ dotCabal, pkgs, runCommand, evalPackages, symlinkJoin, cacert, index-state-hashes, haskellLib, materialize }@defaults:

2let readIfExists = src: fileName:

3 let origSrcDir = src.origSrcSubDir or src;

4 in

@@ -21,6 +21,8 @@ in

21, caller ? "callCabalProjectToNix" # Name of the calling function for better warning messages

22, ghc ? null # Deprecated in favour of `compiler-nix-name`

23, ghcOverride ? null # Used when we need to set ghc explicitly during bootstrapping

24+, nix-tools ? evalPackages.haskell-nix.nix-tools-unchecked.${compiler-nix-name} # When building cabal projects we use the nix-tools

25+, cabal-install ? evalPackages.haskell-nix.cabal-install-unchecked.${compiler-nix-name} # and cabal-install compiled with matching ghc version

24, configureArgs ? "" # Extra arguments to pass to `cabal v2-configure`.

26, configureArgs ? "" # Extra arguments to pass to `cabal v2-configure`.

25 # `--enable-tests --enable-benchmarks` are included by default.

27 # `--enable-tests --enable-benchmarks` are included by default.

26 # If the tests and benchmarks are not needed and they

28 # If the tests and benchmarks are not needed and they

@@ -30,57 +32,17 @@ in

30 # An alternative to adding `--sha256` comments into the

32 # An alternative to adding `--sha256` comments into the

31 # cabal.project file:

33 # cabal.project file:

32 # sha256map =

34 # sha256map =

33− # { # For a `source-repository-package` use the `location` and `tag` as the key

34− # "https://github.com/jgm/pandoc-citeproc"."0.17"

35+ # { "https://github.com/jgm/pandoc-citeproc"."0.17"

35− # = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q";

36+ # = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q"; };

36− # # For a `repository` use the `url` as the key

37+, lookupSha256 ?

37− # "https://raw.githubusercontent.com/input-output-hk/hackage-overlay-ghcjs/bfc363b9f879c360e0a0460ec0c18ec87222ec32"

38+ if sha256map != null

38− # = "sha256-g9xGgJqYmiczjxjQ5JOiK5KUUps+9+nlNGI/0SpSOpg=";

39+ then { location, tag, ...}: sha256map."${location}"."${tag}"

39− # };

40+ else _: null

40−, inputMap ? {}

41− # An alternative to providing a `sha256` handy for flakes

42− # cabal.project file:

43− # inputs.pandoc-citeproc.url = "github:jgm/pandoc-citeproc/0.17";

44− # inputs.pandoc-citeproc.flake = false;

45− # outputs = inputs:

46− # ...

47− # inputMap."https://github.com/jgm/pandoc-citeproc" = inputs.inputs.pandoc-citeproc;

48−, extra-hackage-tarballs ? {}

41+, 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

68, ...

42, ...

69}@args:

43}@args:

70

44

71let

45let

72− inherit (evalPackages.haskell-nix) materialize dotCabal;

73−

74− # These defaults are hear rather than in modules/cabal-project.nix to make them

75− # lazy enough to avoid infinite recursion issues.

76− # Using null as the default also improves performance as they are not forced by the

77− # nix module system for `nix-tools-unchecked` and `cabal-install-unchecked`.

78− nix-tools = if args.nix-tools or null != null

79− then args.nix-tools

80− else evalPackages.haskell-nix.nix-tools-unchecked.${compiler-nix-name};

81− cabal-install = if args.cabal-install or null != null

82− then args.cabal-install

83− else evalPackages.haskell-nix.cabal-install-unchecked.${compiler-nix-name};

84 forName = pkgs.lib.optionalString (name != null) (" for " + name);

46 forName = pkgs.lib.optionalString (name != null) (" for " + name);

85 nameAndSuffix = suffix: if name == null then suffix else name + "-" + suffix;

47 nameAndSuffix = suffix: if name == null then suffix else name + "-" + suffix;

86

48

@@ -114,13 +76,15 @@ let

114 ghc = ghc';

76 ghc = ghc';

115 subDir' = src.origSubDir or "";

77 subDir' = src.origSubDir or "";

116 subDir = pkgs.lib.strings.removePrefix "/" subDir';

78 subDir = pkgs.lib.strings.removePrefix "/" subDir';

117−

79+ maybeCleanedSource =

80+ if haskellLib.canCleanSource src

118− cleanedSource = haskellLib.cleanSourceWith {

81+ then (haskellLib.cleanSourceWith {

119− name = if name != null then "${name}-root-cabal-files" else "source-root-cabal-files";

82+ name = if name != null then "${name}-root-cabal-files" else "source-root-cabal-files";

120− src = src.origSrc or src;

83+ src = src.origSrc or src;

121− filter = path: type: (!(src ? filter) || src.filter path type) && (

84+ filter = path: type: (!(src ? filter) || src.filter path type) && (

122− type == "directory" ||

85+ type == "directory" ||

123− pkgs.lib.any (i: (pkgs.lib.hasSuffix i path)) [ ".cabal" "package.yaml" ]); };

86+ pkgs.lib.any (i: (pkgs.lib.hasSuffix i path)) [ ".cabal" "package.yaml" ]); })

87+ else src.origSrc or src;

124

88

125 # Using origSrcSubDir bypasses any cleanSourceWith so that it will work when

89 # Using origSrcSubDir bypasses any cleanSourceWith so that it will work when

126 # access to the store is restricted. If origSrc was already in the store

90 # access to the store is restricted. If origSrc was already in the store

@@ -200,104 +164,67 @@ let

200 builtins.readFile (pkgs.runCommand "hash-path" { preferLocalBuild = true; }

164 builtins.readFile (pkgs.runCommand "hash-path" { preferLocalBuild = true; }

201 "echo -n $(${pkgs.nix}/bin/nix-hash --type sha256 --base32 ${path}) > $out");

165 "echo -n $(${pkgs.nix}/bin/nix-hash --type sha256 --base32 ${path}) > $out");

202

166

203− replaceSourceRepos = projectFile:

167+ replaceSoureRepos = projectFile:

204 let

168 let

205− fetchPackageRepo = fetchgit: repoData:

169+ fetchRepo = fetchgit: repoData:

206 let

170 let

207 fetched =

171 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})

215− else if repoData.sha256 != null

172+ if repoData.sha256 != null

216− then fetchgit { inherit (repoData) url sha256; rev = repoData.ref; }

173+ then fetchgit { inherit (repoData) url sha256; rev = repoData.ref; }

217 else

174 else

218 let drv = builtins.fetchGit { inherit (repoData) url ref; };

175 let drv = builtins.fetchGit { inherit (repoData) url ref; };

219 in __trace "WARNING: No sha256 found for source-repository-package ${repoData.url} ${repoData.ref} download may fail in restricted mode (hydra)"

176 in __trace "WARNING: No sha256 found for source-repository-package ${repoData.url} ${repoData.ref} download may fail in restricted mode (hydra)"

220− (__trace "Consider adding `--sha256: ${hashPath drv}` to the ${cabalProjectFileName} file or passing in a sha256map argument"

177+ (__trace "Consider adding `--sha256: ${hashPath drv}` to the ${cabalProjectFileName} file or passing in a lookupSha256 argument"

221 drv);

178 drv);

222− in {

179+ in fetched + (if repoData.subdir == "." then "" else "/" + repoData.subdir);

223− # Download the source-repository-package commit and add it to a minimal git

180+

224− # repository that `cabal` will be able to access from a non fixed output derivation.

181+ blocks = pkgs.lib.splitString "\nsource-repository-package\n" ("\n" + projectFile);

225− location = evalPackages.runCommand "source-repository-package" {

182+ initialText = pkgs.lib.lists.take 1 blocks;

226− nativeBuildInputs = [ evalPackages.rsync evalPackages.gitMinimal ];

183+ repoBlocks = builtins.map (pkgs.haskell-nix.haskellLib.parseBlock cabalProjectFileName lookupSha256) (pkgs.lib.lists.drop 1 blocks);

227− } ''

184+ sourceRepoData = pkgs.lib.lists.concatMap (x: x.sourceRepo) repoBlocks;

228− mkdir $out

185+ otherText = pkgs.evalPackages.writeText "cabal.project" (pkgs.lib.strings.concatStringsSep "\n" (

229− rsync -a --prune-empty-dirs "${fetched}/" "$out/"

186+ initialText

230− cd $out

187+ ++ (builtins.map (x: x.otherText) repoBlocks)));

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;

248

188

249 # we need the repository content twice:

189 # we need the repository content twice:

250 # * at eval time (below to build the fixed project file)

190 # * at eval time (below to build the fixed project file)

251− # Here we want to use evalPackages.fetchgit, so one can calculate

191+ # Here we want to use pkgs.evalPackages.fetchgit, so one can calculate

252 # the build plan for any target without a remote builder

192 # the build plan for any target without a remote builder

253 # * at built time (passed out)

193 # * at built time (passed out)

254 # Here we want to use plain pkgs.fetchgit, which is what a builder

194 # Here we want to use plain pkgs.fetchgit, which is what a builder

255 # on the target system would use, so that the derivation is unaffected

195 # on the target system would use, so that the derivation is unaffected

256 # and, say, a linux release build job can identify the derivation

196 # and, say, a linux release build job can identify the derivation

257 # as built by a darwin builder, and fetch it from a cache

197 # as built by a darwin builder, and fetch it from a cache

258− sourceReposEval = builtins.map (fetchPackageRepo evalPackages.fetchgit) sourceRepoPackageResult.sourceRepos;

198+ sourceReposBuild = builtins.map (fetchRepo pkgs.evalPackages.fetchgit) sourceRepoData ;

259− sourceReposBuild = builtins.map (x: (fetchPackageRepo pkgs.fetchgit x).fetched) sourceRepoPackageResult.sourceRepos;

199+ sourceReposEval = builtins.map (fetchRepo pkgs.fetchgit) sourceRepoData;

260 in {

200 in {

261 sourceRepos = sourceReposBuild;

201 sourceRepos = sourceReposBuild;

262− inherit (repoResult) repos extra-hackages;

263 makeFixedProjectFile = ''

202 makeFixedProjectFile = ''

264− cp -f ${evalPackages.writeText "cabal.project" sourceRepoPackageResult.otherText} ./cabal.project

203+ cp -f ${otherText} ./cabal.project

265− '' +

266− pkgs.lib.optionalString (builtins.length sourceReposEval != 0) (''

267 chmod +w -R ./cabal.project

204 chmod +w -R ./cabal.project

268 # The newline here is important in case cabal.project does not have one at the end

205 # The newline here is important in case cabal.project does not have one at the end

269− echo >> ./cabal.project

206+ printf "\npackages:" >> ./cabal.project

207+ mkdir -p ./.source-repository-packages

270 '' +

208 '' +

271− # Add replacement `source-repository-package` blocks pointing to the minimal git repos

272− ( pkgs.lib.strings.concatMapStrings (f: ''

273− echo "source-repository-package" >> ./cabal.project

274− echo " type: git" >> ./cabal.project

275− echo " location: file://${f.location}" >> ./cabal.project

276− echo " subdir: ${builtins.concatStringsSep " " f.subdirs}" >> ./cabal.project

277− echo " tag: ${f.tag}" >> ./cabal.project

278− '') sourceReposEval

279− ));

280− # This will be used to replace refernces to the minimal git repos with just the index

281− # of the repo. The index will be used in lib/import-and-filter-project.nix to

282− # lookup the correct repository in `sourceReposBuild`. This avoids having

283− # `/nix/store` paths in the `plan-nix` output so that it can be materialized safely.

284− replaceLocations = pkgs.lib.strings.concatStrings (

209+ ( pkgs.lib.strings.concatStrings (

285 pkgs.lib.lists.zipListsWith (n: f: ''

210 pkgs.lib.lists.zipListsWith (n: f: ''

286− (cd $out${subDir'}

211+ mkdir -p ./.source-repository-packages/${builtins.toString n}

287− substituteInPlace $tmp${subDir'}/dist-newstyle/cache/plan.json --replace file://${f.location} ${builtins.toString n}

212+ rsync -a --prune-empty-dirs \

288− for a in $(grep -rl file://${f.location} .plan.nix/*.nix); do

213+ --include '*/' --include '*.cabal' --include 'package.yaml' \

289− substituteInPlace $a --replace file://${f.location} ${builtins.toString n}

214+ --exclude '*' \

290− done)

215+ "${f}/" "./.source-repository-packages/${builtins.toString n}/"

216+ echo " ./.source-repository-packages/${builtins.toString n}" >> ./cabal.project

291 '')

217 '')

292 (pkgs.lib.lists.range 0 ((builtins.length sourceReposEval) - 1))

218 (pkgs.lib.lists.range 0 ((builtins.length sourceReposEval) - 1))

293 sourceReposEval

219 sourceReposEval

294− );

220+ )

221+ );

295 };

222 };

296

223

297 fixedProject =

224 fixedProject =

298 if rawCabalProject == null

225 if rawCabalProject == null

299− then { sourceRepos = []; repos = {}; extra-hackages = []; makeFixedProjectFile = ""; replaceLocations = ""; }

226+ then { sourceRepos = []; makeFixedProjectFile = ""; }

300− else replaceSourceRepos rawCabalProject;

227+ else replaceSoureRepos rawCabalProject;

301

228

302 # The use of the actual GHC can cause significant problems:

229 # The use of the actual GHC can cause significant problems:

303 # * For hydra to assemble a list of jobs from `components.tests` it must

230 # * For hydra to assemble a list of jobs from `components.tests` it must

@@ -368,12 +295,12 @@ let

368 '');

295 '');

369

296

370 # Dummy `ghc` that uses the captured output

297 # Dummy `ghc` that uses the captured output

371− dummy-ghc = evalPackages.writeTextFile {

298+ dummy-ghc = pkgs.evalPackages.writeTextFile {

372 name = "dummy-" + ghc.name;

299 name = "dummy-" + ghc.name;

373 executable = true;

300 executable = true;

374 destination = "/bin/${ghc.targetPrefix}ghc";

301 destination = "/bin/${ghc.targetPrefix}ghc";

375 text = ''

302 text = ''

376− #!${evalPackages.runtimeShell}

303+ #!${pkgs.evalPackages.runtimeShell}

377 case "$*" in

304 case "$*" in

378 --version*)

305 --version*)

379 cat ${dummy-ghc-data}/ghc/version

306 cat ${dummy-ghc-data}/ghc/version

@@ -411,12 +338,12 @@ let

411 };

338 };

412

339

413 # Dummy `ghc-pkg` that uses the captured output

340 # Dummy `ghc-pkg` that uses the captured output

414− dummy-ghc-pkg = evalPackages.writeTextFile {

341+ dummy-ghc-pkg = pkgs.evalPackages.writeTextFile {

415 name = "dummy-pkg-" + ghc.name;

342 name = "dummy-pkg-" + ghc.name;

416 executable = true;

343 executable = true;

417 destination = "/bin/${ghc.targetPrefix}ghc-pkg";

344 destination = "/bin/${ghc.targetPrefix}ghc-pkg";

418 text = ''

345 text = ''

419− #!${evalPackages.runtimeShell}

346+ #!${pkgs.evalPackages.runtimeShell}

420 case "$*" in

347 case "$*" in

421 --version)

348 --version)

422 cat ${dummy-ghc-data}/ghc-pkg/version

349 cat ${dummy-ghc-data}/ghc-pkg/version

@@ -452,10 +379,10 @@ let

452 else null;

379 else null;

453 } // pkgs.lib.optionalAttrs (checkMaterialization != null) {

380 } // pkgs.lib.optionalAttrs (checkMaterialization != null) {

454 inherit checkMaterialization;

381 inherit checkMaterialization;

455− }) (evalPackages.runCommand (nameAndSuffix "plan-to-nix-pkgs") {

382+ }) (pkgs.evalPackages.runCommand (nameAndSuffix "plan-to-nix-pkgs") {

456− nativeBuildInputs = [ nix-tools dummy-ghc dummy-ghc-pkg cabal-install evalPackages.rsync evalPackages.gitMinimal ];

383+ nativeBuildInputs = [ nix-tools dummy-ghc dummy-ghc-pkg cabal-install pkgs.evalPackages.rsync ];

457 # Needed or stack-to-nix will die on unicode inputs

384 # Needed or stack-to-nix will die on unicode inputs

458− LOCALE_ARCHIVE = pkgs.lib.optionalString (evalPackages.stdenv.buildPlatform.libc == "glibc") "${evalPackages.glibcLocales}/lib/locale/locale-archive";

385+ LOCALE_ARCHIVE = pkgs.lib.optionalString (pkgs.evalPackages.stdenv.buildPlatform.libc == "glibc") "${pkgs.evalPackages.glibcLocales}/lib/locale/locale-archive";

459 LANG = "en_US.UTF-8";

386 LANG = "en_US.UTF-8";

460 meta.platforms = pkgs.lib.platforms.all;

387 meta.platforms = pkgs.lib.platforms.all;

461 preferLocalBuild = false;

388 preferLocalBuild = false;

@@ -477,11 +404,11 @@ let

477 '';

404 '';

478 in {

405 in {

479 # These check for cabal configure failure

406 # These check for cabal configure failure

480− json = evalPackages.runCommand (nameAndSuffix "plan-json") {} ''

407+ json = pkgs.evalPackages.runCommand (nameAndSuffix "plan-json") {} ''

481 ${checkCabalConfigure}

408 ${checkCabalConfigure}

482 cp ${plan-nix.maybeJson} $out

409 cp ${plan-nix.maybeJson} $out

483 '';

410 '';

484− freeze = evalPackages.runCommand (nameAndSuffix "plan-freeze") {} ''

411+ freeze = pkgs.evalPackages.runCommand (nameAndSuffix "plan-freeze") {} ''

485 ${checkCabalConfigure}

412 ${checkCabalConfigure}

486 cp ${plan-nix.maybeFreeze} $out

413 cp ${plan-nix.maybeFreeze} $out

487 '';

414 '';

@@ -489,18 +416,14 @@ let

489 } ''

416 } ''

490 tmp=$(mktemp -d)

417 tmp=$(mktemp -d)

491 cd $tmp

418 cd $tmp

492− # if cleanedSource is empty, this means it's a new

419+ # if maybeCleanedSource is empty, this means it's a new

493 # project where the files haven't been added to the git

420 # project where the files haven't been added to the git

494 # repo yet. We fail early and provide a useful error

421 # repo yet. We fail early and provide a useful error

495 # message to prevent headaches (#290).

422 # message to prevent headaches (#290).

496− if [ -z "$(ls -A ${cleanedSource})" ]; then

423+ if [ -z "$(ls -A ${maybeCleanedSource})" ]; then

497− echo "cleaned source is empty. Did you forget to 'git add -A'?"

424+ echo "cleaned source is empty. Did you forget to 'git add -A'?"; exit 1;

498− ${pkgs.lib.optionalString (__length fixedProject.sourceRepos == 0) ''

499− exit 1

500− ''}

501− else

502− cp -r ${cleanedSource}/* .

503 fi

425 fi

426+ cp -r ${maybeCleanedSource}/* .

504 chmod +w -R .

427 chmod +w -R .

505 # Decide what to do for each `package.yaml` file.

428 # Decide what to do for each `package.yaml` file.

506 for hpackFile in $(find . -name package.yaml); do (

429 for hpackFile in $(find . -name package.yaml); do (

@@ -523,13 +446,15 @@ let

523 ${pkgs.lib.optionalString (subDir != "") "cd ${subDir}"}

446 ${pkgs.lib.optionalString (subDir != "") "cd ${subDir}"}

524 ${fixedProject.makeFixedProjectFile}

447 ${fixedProject.makeFixedProjectFile}

525 ${pkgs.lib.optionalString (cabalProjectFreeze != null) ''

448 ${pkgs.lib.optionalString (cabalProjectFreeze != null) ''

526− cp ${evalPackages.writeText "cabal.project.freeze" cabalProjectFreeze} \

449+ cp ${pkgs.evalPackages.writeText "cabal.project.freeze" cabalProjectFreeze} \

527 cabal.project.freeze

450 cabal.project.freeze

528 chmod +w cabal.project.freeze

451 chmod +w cabal.project.freeze

529 ''}

452 ''}

530 export SSL_CERT_FILE=${cacert}/etc/ssl/certs/ca-bundle.crt

453 export SSL_CERT_FILE=${cacert}/etc/ssl/certs/ca-bundle.crt

531 export GIT_SSL_CAINFO=${cacert}/etc/ssl/certs/ca-bundle.crt

454 export GIT_SSL_CAINFO=${cacert}/etc/ssl/certs/ca-bundle.crt

532

455

456+ mkdir -p $out

457+

533 # Using `cabal v2-freeze` will configure the project (since

458 # Using `cabal v2-freeze` will configure the project (since

534 # it is not configured yet), taking the existing `cabal.project.freeze`

459 # it is not configured yet), taking the existing `cabal.project.freeze`

535 # file into account. Then it "writes out a freeze file which

460 # file into account. Then it "writes out a freeze file which

@@ -542,16 +467,15 @@ let

542 # which is used by cabal (cached-index-state >= index-state-found).

467 # which is used by cabal (cached-index-state >= index-state-found).

543 dotCabal {

468 dotCabal {

544 inherit cabal-install nix-tools extra-hackage-tarballs;

469 inherit cabal-install nix-tools extra-hackage-tarballs;

545− extra-hackage-repos = fixedProject.repos;

546 index-state = cached-index-state;

470 index-state = cached-index-state;

547 sha256 = index-sha256-found;

471 sha256 = index-sha256-found;

548 }

472 }

549− } cabal v2-freeze ${

473+ } cabal v2-freeze \

474+ --index-state=${

550− # Setting the desired `index-state` here in case it is not

475+ # Setting the desired `index-state` here in case it was not

551− # in the cabal.project file. This will further restrict the

476+ # from the cabal.project file. This will further restrict the

552− # packages used by the solver (cached-index-state >= index-state-found).

477+ # packages used by the solver (cached-index-state >= index-state-found).

553− pkgs.lib.optionalString (index-state != null) "--index-state=${index-state}"

478+ index-state-found} \

554− } \

555 -w ${

479 -w ${

556 # We are using `-w` rather than `--with-ghc` here to override

480 # We are using `-w` rather than `--with-ghc` here to override

557 # the `with-compiler:` in the `cabal.project` file.

481 # the `with-compiler:` in the `cabal.project` file.

@@ -563,8 +487,6 @@ let

563 "--ghcjs --with-ghcjs=js-unknown-ghcjs-ghc --with-ghcjs-pkg=js-unknown-ghcjs-ghc-pkg"} \

487 "--ghcjs --with-ghcjs=js-unknown-ghcjs-ghc --with-ghcjs-pkg=js-unknown-ghcjs-ghc-pkg"} \

564 ${configureArgs} 2>&1 | tee -a cabal-configure.out); then

488 ${configureArgs} 2>&1 | tee -a cabal-configure.out); then

565

489

566− mkdir -p $out

567−

568 cp cabal.project.freeze $maybeFreeze

490 cp cabal.project.freeze $maybeFreeze

569 # Not needed any more (we don't want it to wind up in the $out hash)

491 # Not needed any more (we don't want it to wind up in the $out hash)

570 rm cabal.project.freeze

492 rm cabal.project.freeze

@@ -589,15 +511,16 @@ let

589 # proper relative paths.

511 # proper relative paths.

590 (cd $out${subDir'} && plan-to-nix --full --plan-json $tmp${subDir'}/dist-newstyle/cache/plan.json -o .)

512 (cd $out${subDir'} && plan-to-nix --full --plan-json $tmp${subDir'}/dist-newstyle/cache/plan.json -o .)

591

513

592− # Replace the /nix/store paths to minimal git repos with indexes (that will work with materialization).

593− ${fixedProject.replaceLocations}

594−

595 # Make the plan.json file available in case we need to debug plan-to-nix

514 # Make the plan.json file available in case we need to debug plan-to-nix

596 cp $tmp${subDir'}/dist-newstyle/cache/plan.json $maybeJson

515 cp $tmp${subDir'}/dist-newstyle/cache/plan.json $maybeJson

597

516

598 # Remove the non nix files ".project" ".cabal" "package.yaml" files

517 # Remove the non nix files ".project" ".cabal" "package.yaml" files

599 # as they should not be in the output hash (they may change slightly

518 # as they should not be in the output hash (they may change slightly

600 # without affecting the nix).

519 # without affecting the nix).

520+ if [ -d $out${subDir'}/.source-repository-packages ]; then

521+ chmod +w -R $out${subDir'}/.source-repository-packages

522+ rm -rf $out${subDir'}/.source-repository-packages

523+ fi

601 find $out $ -type f -or -type l $ ! -name '*.nix' -delete

524 find $out $ -type f -or -type l $ ! -name '*.nix' -delete

602 # Remove empty dirs

525 # Remove empty dirs

603 find $out -type d -empty -delete

526 find $out -type d -empty -delete

@@ -605,28 +528,21 @@ let

605 # move pkgs.nix to default.nix ensure we can just nix `import` the result.

528 # move pkgs.nix to default.nix ensure we can just nix `import` the result.

606 mv $out${subDir'}/pkgs.nix $out${subDir'}/default.nix

529 mv $out${subDir'}/pkgs.nix $out${subDir'}/default.nix

607 else

530 else

608− # Check that this was a solver failure that (not some other

609− # possibly non deterministic failure).

610− # TODO replace grep once https://github.com/haskell/cabal/issues/5191

611− # is fixed.

612− grep "cabal: Could not resolve dependencies" cabal-configure.out

613−

614 # When cabal configure fails copy the output that we captured above and

531 # When cabal configure fails copy the output that we captured above and

615 # use `failed-cabal-configure.nix` to make a suitable derviation with.

532 # use `failed-cabal-configure.nix` to make a suitable derviation with.

616− mkdir -p $out${subDir'}

617− cp cabal-configure.out $out${subDir'}

533+ cp cabal-configure.out $out

618− cp ${./failed-cabal-configure.nix} $out${subDir'}/default.nix

534+ cp ${./failed-cabal-configure.nix} $out/default.nix

619

535

620 # These should only be used indirectly by `passthru.json` and `passthru.freeze`.

536 # These should only be used indirectly by `passthru.json` and `passthru.freeze`.

621 # Those derivations will check for `cabal-configure.out` out first to see if

537 # Those derivations will check for `cabal-configure.out` out first to see if

622 # it is ok to use these files.

538 # it is ok to use these files.

623− echo "Cabal configure failed see $out${subDir'}/cabal-configure.out for details" > $maybeJson

539+ echo "Cabal configure failed see $out/cabal-configure.out for details" > $maybeJson

624− echo "Cabal configure failed see $out${subDir'}/cabal-configure.out for details" > $maybeFreeze

540+ echo "Cabal configure failed see $out/cabal-configure.out for details" > $maybeFreeze

625 fi

541 fi

626 '');

542 '');

627in {

543in {

628 projectNix = plan-nix;

544 projectNix = plan-nix;

629 index-state = index-state-found;

545 index-state = index-state-found;

630 inherit src;

546 inherit src;

631− inherit (fixedProject) sourceRepos extra-hackages;

547+ inherit (fixedProject) sourceRepos;

632}

548}

lib/call-stack-to-nix.nix+18−32

@@ -5,6 +5,7 @@

5 *

6 * see also `call-cabal-project-to-nix`!

7 */

8+{ runCommand, pkgs, mkCacheFile, materialize, haskellLib }:

8{ name ? src.name or null # optional name for better error messages

9{ name ? src.name or null # optional name for better error messages

9, src

10, src

10, stackYaml ? "stack.yaml"

11, stackYaml ? "stack.yaml"

@@ -14,28 +15,17 @@

14, resolverSha256 ? null

15, resolverSha256 ? null

15, materialized ? null # Location of a materialized copy of the nix files

16, materialized ? null # Location of a materialized copy of the nix files

16, checkMaterialization ? null # If true the nix files will be generated used to check plan-sha256 and material

17, checkMaterialization ? null # If true the nix files will be generated used to check plan-sha256 and material

17−, nix-tools

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)

18−, evalPackages

19−, ... }@args:

19+, ... }:

20let

21− inherit (evalPackages) runCommand;

22− inherit (evalPackages.haskell-nix) mkCacheFile materialize haskellLib;

23 inherit (haskellLib.fetchResolver {

21 inherit (haskellLib.fetchResolver {

24 inherit src stackYaml resolverSha256;

22 inherit src stackYaml resolverSha256;

25 }) resolver fetchedResolver;

23 }) resolver fetchedResolver;

26

24

27 subDir' = src.origSubDir or "";

25 subDir' = src.origSubDir or "";

28− subDir = evalPackages.lib.strings.removePrefix "/" subDir';

29− cleanedSource = (haskellLib.cleanSourceWith {

30− name = if name != null then "${name}-root-cabal-files" else "source-root-cabal-files";

31− src = src.origSrc or src;

32− filter = path: type: (!(src ? filter) || src.filter path type) && (

33− type == "directory" ||

34− evalPackages.lib.any (i: (evalPackages.lib.hasSuffix i path)) [ stackYaml ".cabal" "package.yaml" ]); });

35−

36 stackToNixArgs = builtins.concatStringsSep " " [

26 stackToNixArgs = builtins.concatStringsSep " " [

37 "--full"

27 "--full"

38− "--stack-yaml=$SRC${subDir'}/${stackYaml}"

28+ "--stack-yaml=$SRC/${stackYaml}"

39 (if ignorePackageYaml then "--ignore-package-yaml" else "")

29 (if ignorePackageYaml then "--ignore-package-yaml" else "")

40 "-o ."

30 "-o ."

41 ];

31 ];

@@ -45,39 +35,35 @@ let

45 sha256Arg = "stack-sha256";

35 sha256Arg = "stack-sha256";

46 reasonNotSafe = null;

36 reasonNotSafe = null;

47 this = "project.stack-nix" + (if name != null then " for ${name}" else "");

37 this = "project.stack-nix" + (if name != null then " for ${name}" else "");

48− } // evalPackages.lib.optionalAttrs (checkMaterialization != null) {

38+ } // pkgs.lib.optionalAttrs (checkMaterialization != null) {

49 inherit checkMaterialization;

39 inherit checkMaterialization;

50 }) (runCommand (if name == null then "stack-to-nix-pkgs" else name + "-stack-to-nix-pkgs") {

40 }) (runCommand (if name == null then "stack-to-nix-pkgs" else name + "-stack-to-nix-pkgs") {

51− nativeBuildInputs = [ nix-tools evalPackages.nix-prefetch-git evalPackages.cacert evalPackages.xorg.lndir ];

41+ nativeBuildInputs = [ nix-tools pkgs.nix-prefetch-git pkgs.cacert pkgs.xorg.lndir ];

52 # Needed or stack-to-nix will die on unicode inputs

42 # Needed or stack-to-nix will die on unicode inputs

53− LOCALE_ARCHIVE = evalPackages.lib.optionalString (evalPackages.stdenv.hostPlatform.libc == "glibc") "${evalPackages.glibcLocales}/lib/locale/locale-archive";

43+ LOCALE_ARCHIVE = pkgs.lib.optionalString (pkgs.stdenv.hostPlatform.libc == "glibc") "${pkgs.glibcLocales}/lib/locale/locale-archive";

54 LANG = "en_US.UTF-8";

44 LANG = "en_US.UTF-8";

55 LC_ALL = "en_US.UTF-8";

45 LC_ALL = "en_US.UTF-8";

56 preferLocalBuild = false;

46 preferLocalBuild = false;

57 } (''

47 } (''

58 mkdir -p $out${subDir'}

48 mkdir -p $out${subDir'}

59− SRC=$(mktemp -d)

60− cd $SRC

61− # if cleanedSource is empty, this means it's a new

62− # project where the files haven't been added to the git

63− # repo yet. We fail early and provide a useful error

64− # message to prevent headaches (#290).

65− if [ -z "$(ls -A ${cleanedSource})" ]; then

66− echo "cleaned source is empty. Did you forget to 'git add -A'?"; exit 1;

67− fi

68− lndir -silent "${cleanedSource}/." $SRC

69− ${evalPackages.lib.optionalString (subDir != "") "cd ${subDir}"}

70 ${

49 ${

71− # If a resolver was fetched use the it instead of the original stack.yaml

50+ # If no resolver was fetched use the original stack.yaml

72− evalPackages.lib.optionalString (fetchedResolver != null)

51+ if fetchedResolver == null

52+ then ''

53+ SRC=${src}

54+ ''

55+ else

73 # Replace the resolver path in the stack.yaml with the fetched version

56 # Replace the resolver path in the stack.yaml with the fetched version

74 ''

57 ''

58+ SRC=$(mktemp -d)

59+ cd $SRC

60+ lndir -silent "${src}/." $SRC

75 rm ${stackYaml}

61 rm ${stackYaml}

76 cp ${src}/${stackYaml} .

62 cp ${src}/${stackYaml} .

77 chmod +w ${stackYaml}

63 chmod +w ${stackYaml}

78 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

64 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

79 ''}

65 ''}

80− ${evalPackages.lib.optionalString (cache != null) ''

66+ ${pkgs.lib.optionalString (cache != null) ''

81 cp ${mkCacheFile cache}/.stack-to-nix.cache* $out${subDir'}

67 cp ${mkCacheFile cache}/.stack-to-nix.cache* $out${subDir'}

82 ''}

68 ''}

83 (cd $out${subDir'} && stack-to-nix ${stackToNixArgs})

69 (cd $out${subDir'} && stack-to-nix ${stackToNixArgs})

@@ -85,7 +71,7 @@ let

85 # We need to strip out any references to $src, as those won't

71 # We need to strip out any references to $src, as those won't

86 # be accessable in restricted mode.

72 # be accessable in restricted mode.

87 for nixf in $(find $out -name "*.nix" -type f); do

73 for nixf in $(find $out -name "*.nix" -type f); do

88− substituteInPlace $nixf --replace "$SRC${subDir'}" "."

74+ substituteInPlace $nixf --replace "$SRC" "."

89 done

75 done

90

76

91 # move pkgs.nix to default.nix ensure we can just nix `import` the result.

77 # move pkgs.nix to default.nix ensure we can just nix `import` the result.

lib/check.nix+14−19

@@ -1,4 +1,4 @@

1−{ stdenv, lib, haskellLib }:

1+{ stdenv, lib, haskellLib, srcOnly }:

2drv:

3

4let

@@ -7,25 +7,13 @@ 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− }) // {

27 name = (drv.name + "-check");

11 name = (drv.name + "-check");

28

12

13+ # Useing `srcOnly` (rather than getting the `src` via a `drv.passthru`)

14+ # should correctly apply the patches from `drv` (if any).

15+ src = drv.source or (srcOnly drv);

16+

29 passthru = {

17 passthru = {

30 inherit (drv) identifier config configFiles executableToolDepends cleanSrc env exeName;

18 inherit (drv) identifier config configFiles executableToolDepends cleanSrc env exeName;

31 };

19 };

@@ -34,12 +22,19 @@ in stdenv.mkDerivation ((

34

22

35 inherit (component) doCheck doCrossCheck;

23 inherit (component) doCheck doCrossCheck;

36

24

37− phases = ["unpackPhase" "patchPhase" "buildPhase"];

25+ phases = ["unpackPhase" "buildPhase"];

38

26

39 # If doCheck or doCrossCheck are false we may still build this

27 # If doCheck or doCrossCheck are false we may still build this

40 # component and we want it to quietly succeed.

28 # component and we want it to quietly succeed.

41 buildPhase = ''

29 buildPhase = ''

42 mkdir $out

30 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+

43 runHook preCheck

38 runHook preCheck

44

39

45 ${toString component.testWrapper} ${drv}/bin/${drv.exeName} ${lib.concatStringsSep " " component.testFlags} | tee $out/test-stdout

40 ${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 }: package: component: componentName: src:

3+{ lib, cleanSourceWith, canCleanSource }: 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"

59+ if srcStr' == null || package.detailLevel != "FullDetails" || !canCleanSource src

60 then src

61 else

62 let

lib/clean-git.nix+24−63

@@ -65,13 +65,9 @@ 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;

69 in

68 in

70 if ok

69 if ok

71− then

70+ then /. + remove_prefix prefix first_line

72− if lib.hasPrefix "/" raw_path

73− then /. + raw_path

74− else /. + builtins.toPath (origSrcSubDir + "/" + raw_path)

75 else abort "gitSource.nix: Cannot parse ${origSrcSubDir + "/.git"}";

71 else abort "gitSource.nix: Cannot parse ${origSrcSubDir + "/.git"}";

76 }));

72 }));

77

73

@@ -91,37 +87,32 @@ then

91 gitModulesStr = origSrcSubDir + "/.gitmodules";

87 gitModulesStr = origSrcSubDir + "/.gitmodules";

92 gitModules = builtins.path { name = "gitmodules"; path = gitModulesStr; };

88 gitModules = builtins.path { name = "gitmodules"; path = gitModulesStr; };

93

89

94− # Files from the git repository related knownSubmoduleDirs.

95− gitSubmoduleFiles = knownSubmoduleDirs:

96− let pathsNeeded = map (p: toString (src.origSrcSubDir or src) + "/${p}") (

97− lib.concatMap (x: all_paren_dirs (x + "/.git")) knownSubmoduleDirs);

98− in cleanSourceWith {

90+ gitSubmoduleFiles = cleanSourceWith {

99− caller = "cleanGit";

91+ caller = "cleanGit";

100− name = (if name == null then "" else name + "-") + "gitSubmoduleFiles";

92+ name = (if name == null then "" else name + "-") + "gitSubmoduleFiles";

101− inherit src;

93+ inherit src;

102− filter = path: type:

94+ filter = path: type:

103− elem path pathsNeeded

95+ type == "directory" # TODO get sudmodule directories from `.gitmodules`

104− ||

96+ # and use that to filter directory tree here

97+ ||

98+ lib.any (i: (lib.hasSuffix i path)) [

99+ "/.git" ".gitmodules" ".git/config" ".git/index" ".git/HEAD" ".git/objects" ".git/refs" ] ||

100+ (lib.strings.hasInfix ".git/modules/" path &&

105 lib.any (i: (lib.hasSuffix i path)) [

101 lib.any (i: (lib.hasSuffix i path)) [

106− ".gitmodules" ".git/config" ".git/index" ".git/HEAD" ".git/objects" ".git/refs" ]

102+ "config" "index" "HEAD" "objects" "refs" ]);

107− ||

103+ };

108− (lib.strings.hasInfix ".git/modules/" path &&

109− lib.any (i: (lib.hasSuffix i path)) [

110− "config" "index" "HEAD" "objects" "refs" ]);

111− };

112−

113− hasSubmodules = !isWorktree && builtins.pathExists gitModulesStr;

114

104

115 # Make a temporary dir that looks enough like the real thing for

105 # Make a temporary dir that looks enough like the real thing for

116 # `git ls-files --recurse-submodules` to give us an accurate list

106 # `git ls-files --recurse-submodules` to give us an accurate list

117 # of all the files in the index.

107 # of all the files in the index.

118− whitelist_files = knownSubmoduleDirs:

108+ whitelist_file =

119− runCommand "git-ls-files" { preferLocalBuild = true; } ''

109+ runCommand "git-ls-files" {envVariable = true;} ''

120 tmp=$(mktemp -d)

110 tmp=$(mktemp -d)

121 cd $tmp

111 cd $tmp

122− ${ lib.optionalString hasSubmodules ''

112+ ${ lib.optionalString (!isWorktree && builtins.pathExists gitModulesStr) ''

123− cp -ra ${gitSubmoduleFiles knownSubmoduleDirs}/. $tmp

113+ cp -ra ${gitSubmoduleFiles}/. $tmp

124 chmod +w -R $tmp

114 chmod +w -R $tmp

115+ rm -rf .git

125 ''}

116 ''}

126 cp -r ${gitDir} .git

117 cp -r ${gitDir} .git

127 chmod +w -R .git

118 chmod +w -R .git

@@ -132,37 +123,10 @@ then

132 ${ lib.optionalString (isWorktree && builtins.pathExists gitModulesStr) ''

123 ${ lib.optionalString (isWorktree && builtins.pathExists gitModulesStr) ''

133 cp ${gitModules} ./.gitmodules

124 cp ${gitModules} ./.gitmodules

134 ''}

125 ''}

135− mkdir $out

136− ${ lib.optionalString hasSubmodules ''

137− ${git}/bin/git submodule status --recursive | awk '{ print $2 }' > $out/submoduleDirs

138− ''}

139− ${git}/bin/git ls-files --recurse-submodules > $out/files

126+ ${git}/bin/git ls-files --recurse-submodules > $out

140 '';

127 '';

141

128

142− # Find the submodules

129+ whitelist = lines (readFile (whitelist_file.out));

143− whitelist_recursive = knownSubmoduleDirs:

144− let

145− # Get the new list of submoduleDirs and files

146− # (useing the submoduleDirs we already know about)

147− files = whitelist_files knownSubmoduleDirs;

148− new = {

149− submoduleDirs = lines (readFile (files + "/submoduleDirs"));

150− files = lines (readFile (files + "/files"));

151− };

152− in

153− # If we are not expecting submodules or if the new list does not

154− # contain any additional submodules we are done.

155− if !hasSubmodules || lib.all (x: elem x knownSubmoduleDirs) new.submoduleDirs

156− then new

157− else

158− # Look again using what we know now about the submodules

159− whitelist_recursive new.submoduleDirs;

160−

161− # Use empty as a starting point for looking for submodules.

162− # We could allow a list to be passed into cleanGit, but when testing

163− # on the `ghcjs` repo (one with a lot of submodules) it did not

164− # make much of a difference to the speed of `cleanGit`.

165− whitelist = whitelist_recursive [];

166

130

167 all_paren_dirs = p:

131 all_paren_dirs = p:

168 if p == "." || p == "/"

132 if p == "." || p == "/"

@@ -174,13 +138,13 @@ then

174 concatMap (p:

138 concatMap (p:

175 # Using `origSrcSubDir` (if present) makes it possible to cleanGit src that

139 # Using `origSrcSubDir` (if present) makes it possible to cleanGit src that

176 # has already been cleaned with cleanSrcWith.

140 # has already been cleaned with cleanSrcWith.

177− let full_path = toString (src.origSrcSubDir or src) + "/${p}"; in

141+ let full_path = src.origSrcSubDir or (toString src) + "/${p}"; in

178 map (p': { name = p'; value = true; }) (all_paren_dirs full_path)

142 map (p': { name = p'; value = true; }) (all_paren_dirs full_path)

179− ) whitelist.files

143+ ) whitelist

180 );

144 );

181

145

182 # Identify files in the `.git` dir

146 # Identify files in the `.git` dir

183− isGitDirPath = path:

147+ isGitDirPath = path:

184 path == origSrcSubDir + "/.git"

148 path == origSrcSubDir + "/.git"

185 || lib.hasPrefix (origSrcSubDir + "/.git/") path;

149 || lib.hasPrefix (origSrcSubDir + "/.git/") path;

186

150

@@ -191,9 +155,6 @@ then

191 cleanSourceWith {

155 cleanSourceWith {

192 caller = "cleanGit";

156 caller = "cleanGit";

193 inherit name src subDir includeSiblings filter;

157 inherit name src subDir includeSiblings filter;

194− } // {

195− # For testing

196− # inherit whitelist whitelist_set;

197 }

158 }

198

159

199else

160else

lib/clean-source-with.nix+8−35

@@ -50,33 +50,6 @@

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

80 cleanSourceWith = { filter ? _path: _type: true, src, subDir ? "", name ? null

53 cleanSourceWith = { filter ? _path: _type: true, src, subDir ? "", name ? null

81 , caller ? "cleanSourceWith", includeSiblings ? false }:

54 , caller ? "cleanSourceWith", includeSiblings ? false }:

82 let

55 let

@@ -130,21 +103,21 @@

130 __trace (

103 __trace (

131 "WARNING: `${caller}` called on ${toString src} without a `name`. "

104 "WARNING: `${caller}` called on ${toString src} without a `name`. "

132 + "Consider adding `name = \"${baseNameOf src}\";`") "source";

105 + "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));

140 in {

106 in {

141 inherit origSrc origSubDir origSrcSubDir;

107 inherit origSrc origSubDir origSrcSubDir;

142 filter = filter';

108 filter = filter';

143− outPath = (filterPath { filter = filter'; path = origSrc; name = name'; }) + origSubDir;

109+ outPath = (builtins.path { filter = filter'; path = origSrc; name = name'; }) + origSubDir;

144 _isLibCleanSourceWithEx = true;

110 _isLibCleanSourceWithEx = true;

145 # It is only safe for older cleanSourceWith to filter this one

111 # It is only safe for older cleanSourceWith to filter this one

146 # if the we are still looking at the root of origSrc

112 # if the we are still looking at the root of origSrc

147 _isLibCleanSourceWith = origSubDir == "";

113 _isLibCleanSourceWith = origSubDir == "";

148 name = name';

114 name = name';

149 };

115 };

116+

117+ pathHasContext = builtins.hasContext or (lib.hasPrefix builtins.storeDir);

118+

119+ canCleanSource = src:

120+ src ? _isLibCleanSourceWithEx

121+ || src ? _isLibCleanSourceWith

122+ || !(pathHasContext (toString src));

150}

123}

lib/cover-project.nix+47−44

@@ -10,12 +10,19 @@ coverageReports:

10let

11 toBashArray = arr: "(" + (lib.concatStringsSep " " arr) + ")";

12

13− # Create a list element for a project coverage index page.

13+ # Create table rows for a project coverage index page that look something like:

14+ #

15+ # | Package |

16+ # |------------------|

17+ # | cardano-shell |

18+ # | cardano-launcher |

14− coverageListElement = coverageReport:

19+ coverageTableRows = coverageReport:

15 ''

20 ''

16− <li>

21+ <tr>

22+ <td>

17− <a href="${coverageReport.passthru.name}/hpc_index.html">${coverageReport.passthru.name}</a>

23+ <a href="${coverageReport.passthru.name}/hpc_index.html">${coverageReport.passthru.name}</href>

18− </li>

24+ </td>

25+ </tr>

19 '';

26 '';

20

27

21 projectIndexHtml = pkgs.writeText "index.html" ''

28 projectIndexHtml = pkgs.writeText "index.html" ''

@@ -24,32 +31,23 @@ let

24 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

31 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

25 </head>

32 </head>

26 <body>

33 <body>

27− <div>

34+ <table border="1" width="100%">

28− WARNING: Modules with no coverage are not included in any of these reports, this is just how HPC works under the hood.

35+ <tbody>

29− </div>

36+ <tr>

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>

43− ${with lib; concatStringsSep "\n" (map coverageListElement coverageReports)}

40+ ${with lib; concatStringsSep "\n" (map coverageTableRows coverageReports)}

44− </ul>

41+

45− </div>

42+ </tbody>

43+ </table>

46 </body>

44 </body>

47 </html>

45 </html>

48 '';

46 '';

49

47

50 ghc = project.pkg-set.config.ghc.package;

48 ghc = project.pkg-set.config.ghc.package;

51

49

52− libs = lib.unique (lib.concatMap (r: r.mixLibraries) coverageReports);

50+ libs = lib.remove null (map (r: r.library) coverageReports);

53

51

54 mixDirs =

52 mixDirs =

55 map

53 map

@@ -58,17 +56,6 @@ let

58

56

59 srcDirs = map (l: l.srcSubDirPath) libs;

57 srcDirs = map (l: l.srcSubDirPath) libs;

60

58

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−

72in pkgs.runCommand "project-coverage-report"

59in pkgs.runCommand "project-coverage-report"

73 ({ nativeBuildInputs = [ (ghc.buildGHC or ghc) pkgs.buildPackages.zip ];

60 ({ nativeBuildInputs = [ (ghc.buildGHC or ghc) pkgs.buildPackages.zip ];

74 LANG = "en_US.UTF-8";

61 LANG = "en_US.UTF-8";

@@ -137,14 +124,30 @@ in pkgs.runCommand "project-coverage-report"

137 cp -R $report/share/hpc/vanilla/html/* $out/share/hpc/vanilla/html/

124 cp -R $report/share/hpc/vanilla/html/* $out/share/hpc/vanilla/html/

138 '') coverageReports)}

125 '') coverageReports)}

139

126

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+

140− # Copy out "all" coverage report

135+ # Markup a HTML coverage report for the entire project

141− cp -R ${allCoverageReport}/share/hpc/vanilla/tix/all $out/share/hpc/vanilla/tix

136+ cp ${projectIndexHtml} $out/share/hpc/vanilla/html/index.html

137+ echo "report coverage-per-package $out/share/hpc/vanilla/html/index.html" >> $out/nix-support/hydra-build-products

138+

142− cp -R ${allCoverageReport}/share/hpc/vanilla/html/all $out/share/hpc/vanilla/html

139+ local markupOutDir="$out/share/hpc/vanilla/html/all"

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"

143

146

144− # Markup a HTML coverage summary report for the entire project

147+ markup srcDirs mixDirs allMixModules "$markupOutDir" "$tixFile"

145− cp ${projectIndexHtml} $out/share/hpc/vanilla/html/index.html

146

148

147− echo "report coverage $out/share/hpc/vanilla/html/index.html" >> $out/nix-support/hydra-build-products

149+ echo "report coverage $markupOutDir/hpc_index.html" >> $out/nix-support/hydra-build-products

148− ( cd $out/share/hpc/vanilla/html ; zip -r $out/share/hpc/vanilla/html.zip . )

150+ ( cd $out/share/hpc/vanilla/html ; zip -r $out/share/hpc/vanilla/html.zip . )

149− echo "file zip $out/share/hpc/vanilla/html.zip" >> $out/nix-support/hydra-build-products

151+ echo "file zip $out/share/hpc/vanilla/html.zip" >> $out/nix-support/hydra-build-products

152+ fi

150 ''

153 ''

lib/cover.nix+69−102

@@ -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".

4{ stdenv, lib, haskellLib, pkgs }:

1{ stdenv, lib, haskellLib, pkgs }:

5

2

6−# Name of the coverage report, which should be unique.

3+# Name of the coverage report, which should be unique

7{ name

4{ name

5+# Library to check coverage of

6+, library

8−# List of check derivations that generate coverage.

7+# List of check derivations that generate coverage

9−, checks ? []

8+, checks

10−# List of libraries to include in the coverage report. If one of the above

9+# List of other libraries to include in the coverage report. The

11−# checks generates coverage for a particular library, coverage will only

10+# default value if just the derivation provided as the `library`

12−# be included if that library is in this list.

11+# argument. Use a larger list of libraries if you would like the tests

12+# of one local package to generate coverage for another.

13−, mixLibraries ? []

13+, mixLibraries ? [library]

14−# Hack for project-less projects.

14+# hack for project-less projects

15−, ghc ? if mixLibraries == [] then null else (lib.head mixLibraries).project.pkg-set.config.ghc.package

15+, ghc ? library.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 checks mixLibraries;

29+ inherit name library checks;

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,105 +70,71 @@ in pkgs.runCommand (name + "-coverage-report")

70 local -n tixFs=$2

71 local outFile="$3"

72

73− if (( "''${#tixFs[@]}" > 0 )); then

74− local hpcSumCmd=("hpc" "sum" "--union" "--output=$outFile")

73+ local hpcSumCmd=("hpc" "sum" "--union" "--output=$outFile")

75

74

76− for module in "''${includedModules[@]}"; do

75+ for module in "''${includedModules[@]}"; do

77− hpcSumCmd+=("--include=$module")

76+ hpcSumCmd+=("--include=$module")

78− done

77+ done

79

78

80− for tixFile in "''${tixFs[@]}"; do

79+ for tixFile in "''${tixFs[@]}"; do

81− hpcSumCmd+=("$tixFile")

80+ hpcSumCmd+=("$tixFile")

82− done

81+ done

83

82

84− echo "''${hpcSumCmd[@]}"

83+ echo "''${hpcSumCmd[@]}"

85− eval "''${hpcSumCmd[@]}"

84+ eval "''${hpcSumCmd[@]}"

86− else

87− # If there are no tix files we output an empty tix file so that we can

88− # markup an empty HTML coverage report. This is preferable to failing to

89− # output a HTML report.

90− echo 'Tix []' > $outFile

91− fi

92 }

85 }

93

86

94 function findModules() {

87 function findModules() {

95− local -n result=$1

88+ local searchDir=$2

96− local -n searchDirs=$2

97 local pattern=$3

89 local pattern=$3

98

90

99− for dir in "''${searchDirs[@]}"; do

100− pushd $dir

91+ pushd $searchDir

101− local temp=()

102− mapfile -d $'\0' temp < <(find ./ -type f \

92+ mapfile -d $'\0' $1 < <(find ./ -type f \

103− -wholename "$pattern" -not -name "Paths*" \

93+ -wholename "$pattern" -not -name "Paths*" \

104− -exec basename {} \; \

94+ -exec basename {} \; \

105− | sed "s/\.mix$//" \

95+ | sed "s/\.mix$//" \

106− | tr "\n" "\0")

96+ | tr "\n" "\0")

107− result+=("''${temp[@]}")

108− popd

97+ popd

109− done

110 }

98 }

111

99

100+ local mixDirs=${toBashArray mixDirs}

101+

112 mkdir -p $out/nix-support

102 mkdir -p $out/nix-support

113− mkdir -p $out/share/hpc/vanilla/mix/

103+ mkdir -p $out/share/hpc/vanilla/mix/${name}

114 mkdir -p $out/share/hpc/vanilla/tix/${name}

104 mkdir -p $out/share/hpc/vanilla/tix/${name}

115 mkdir -p $out/share/hpc/vanilla/html/${name}

105 mkdir -p $out/share/hpc/vanilla/html/${name}

116

106

117− local srcDirs=${toBashArray srcDirs}

118− local mixDirs=${toBashArray mixDirs}

119−

120− # Copy out mix files used for this report

107+ # Copy over mix files verbatim

121 for dir in "''${mixDirs[@]}"; do

108 for dir in "''${mixDirs[@]}"; do

122 if [ -d "$dir" ]; then

109 if [ -d "$dir" ]; then

123− cp -R "$dir" $out/share/hpc/vanilla/mix/

110+ cp -R "$dir"/* $out/share/hpc/vanilla/mix/${name}

124 fi

111 fi

125 done

112 done

126

113

127− local mixModules=()

114+ local srcDirs=${toBashArray srcDirs}

128− # Mix modules for all packages in "mixLibraries"

115+ local allMixModules=()

129− findModules mixModules mixDirs "*.mix"

116+ local pkgMixModules=()

130−

117+

131− # We need to make a distinction between library "exposed-modules" and

118+ # The behaviour of stack coverage reports is to provide tix files

132− # "other-modules" used in test suites:

119+ # that include coverage information for every local package, but

133− # - "exposed-modules" are addressed as "$library-$version-$hash/module"

120+ # to provide HTML reports that only include coverage info for the

134− # - "other-modules" are addressed as "module"

121+ # current package. We emulate the same behaviour here. If the user

135− #

122+ # includes all local packages in the mix libraries argument, they

136− # This complicates the code required to find the mix modules. For a given mix directory:

123+ # will get a coverage report very similar to stack.

137− #

124+

138− # mix

125+ # All mix modules

139− # └── ntp-client-0.0.1

126+ findModules allMixModules "$out/share/hpc/vanilla/mix/${name}" "*.mix"

140− # └── ntp-client-0.0.1-gYjRsBHUCaHX7ENcjHnw5

127+ # Only mix modules corresponding to this package

141− # ├── Network.NTP.Client.mix

128+ findModules pkgMixModules "$out/share/hpc/vanilla/mix/${name}" "*${name}*/*.mix"

142− # ├── Network.NTP.Client.Packet.mix

129+

143− # └── Network.NTP.Client.Query.mix

130+ # For each test

144− #

145− # Iff ntp-client uses "other-modules" in a test suite, both:

146− # - "mix/ntp-client-0.0.1", and

147− # - "mix/ntp-client-0.0.1/ntp-client-0.0.1-gYjRsBHUCaHX7ENcjHnw5"

148− # need to be provided to hpc as search directories.

149− #

150− # I'd prefer to just exclude "other-modules", but I can't think of an easy

151− # way to do that in bash.

152− #

153− # Here we expand the search dirs and modify the mix dirs accordingly:

154− for dir in "''${mixDirs[@]}"; do

155− local otherModulesSearchDirs=()

156− # Simply consider any directory with a mix file as a search directory.

157− mapfile -d $'\0' otherModulesSearchDirs < <(find $dir -type f \

158− -wholename "*.mix" \

159− -exec dirname {} \; \

160− | uniq \

161− | tr "\n" "\0")

162− mixDirs+=("''${otherModulesSearchDirs[@]}")

163− done

164−

165 local tixFiles=()

131 local tixFiles=()

166 ${lib.concatStringsSep "\n" (builtins.map (check: ''

132 ${lib.concatStringsSep "\n" (builtins.map (check: ''

167 if [ -d "${check}/share/hpc/vanilla/tix" ]; then

133 if [ -d "${check}/share/hpc/vanilla/tix" ]; then

168 pushd ${check}/share/hpc/vanilla/tix

134 pushd ${check}/share/hpc/vanilla/tix

169

135

170 tixFile="$(find . -iwholename "*.tix" -type f -print -quit)"

136 tixFile="$(find . -iwholename "*.tix" -type f -print -quit)"

171− local newTixFile=$out/share/hpc/vanilla/tix/${check.name}/"$(basename $tixFile)"

137+ local newTixFile=$out/share/hpc/vanilla/tix/${name}/"$tixFile"

172

138

173 mkdir -p "$(dirname $newTixFile)"

139 mkdir -p "$(dirname $newTixFile)"

174 # Copy over the tix file verbatim

140 # Copy over the tix file verbatim

@@ -177,28 +143,29 @@ in pkgs.runCommand (name + "-coverage-report")

177 # Add the tix file to our list

143 # Add the tix file to our list

178 tixFiles+=("$newTixFile")

144 tixFiles+=("$newTixFile")

179

145

180− # Create a coverage report for *just that check* affecting any of the

146+ # Create a coverage report for *just that test*

181− # "mixLibraries"

182− markup srcDirs mixDirs mixModules "$out/share/hpc/vanilla/html/${check.name}/" "$newTixFile"

147+ markup srcDirs mixDirs pkgMixModules "$out/share/hpc/vanilla/html/${name}/${check.exeName}/" "$newTixFile"

183

148

184 popd

149 popd

185 fi

150 fi

186 '') checks)

151 '') checks)

187 }

152 }

188

153

189− # Sum tix files to create a tix file with tix information from all tests in

154+ # Sum tix files to create a tix file with all relevant tix

190− # the package and markup a HTML report from this info.

155+ # information and markup a HTML report from this info.

156+ if (( "''${#tixFiles[@]}" > 0 )); then

191− local sumTixFile="$out/share/hpc/vanilla/tix/${name}/${name}.tix"

157+ local sumTixFile="$out/share/hpc/vanilla/tix/${name}/${name}.tix"

192− local markupOutDir="$out/share/hpc/vanilla/html/${name}"

158+ local markupOutDir="$out/share/hpc/vanilla/html/${name}"

193

159

194− # Sum all of our tix files

160+ # Sum all of our tix file, including modules from any local package

195− sumTix mixModules tixFiles "$sumTixFile"

161+ sumTix allMixModules tixFiles "$sumTixFile"

196

162

197− # Markup a HTML report

163+ # Markup a HTML report, included modules from only this package

198− markup srcDirs mixDirs mixModules "$markupOutDir" "$sumTixFile"

164+ markup srcDirs mixDirs pkgMixModules "$markupOutDir" "$sumTixFile"

199

165

200− # Provide a HTML zipfile and Hydra links

166+ # Provide a HTML zipfile and Hydra links

201− ( cd "$markupOutDir" ; zip -r $out/share/hpc/vanilla/${name}-html.zip . )

167+ ( cd "$markupOutDir" ; zip -r $out/share/hpc/vanilla/${name}-html.zip . )

202− echo "report coverage $markupOutDir/hpc_index.html" >> $out/nix-support/hydra-build-products

168+ echo "report coverage $markupOutDir/hpc_index.html" >> $out/nix-support/hydra-build-products

203− echo "file zip $out/share/hpc/vanilla/${name}-html.zip" >> $out/nix-support/hydra-build-products

169+ echo "file zip $out/share/hpc/vanilla/${name}-html.zip" >> $out/nix-support/hydra-build-products

170+ fi

204 ''

171 ''

lib/default.nix+50−60

@@ -4,8 +4,11 @@

4with haskellLib;

5

6let

7− # Why `final.buildPackages.buildPackages.gitMinimal`?

7+ # Why `final.evalPackages.buildPackages.gitMinimal`?

8− # Why not just final.buildPackages.gitMinimal?

8+ # Why not just final.evalPackages.gitMinimal?

9+ #

10+ # A problem arises when `evalPackages` is `buildPackages`.i

11+ # As may be the case in a flake.

9 #

12 #

10 # It turns out `git` depends on `gdb` in a round about way:

13 # It turns out `git` depends on `gdb` in a round about way:

11 # git -> openssh -> libfido2 -> systemd -> python libxml -> Cython -> gdb

14 # git -> openssh -> libfido2 -> systemd -> python libxml -> Cython -> gdb

@@ -21,7 +24,7 @@ let

21 # * When `gdb` does not exist for `js`, so when cross

24 # * When `gdb` does not exist for `js`, so when cross

22 # compiling with ghcjs `final.buildPackages.git` fails

25 # compiling with ghcjs `final.buildPackages.git` fails

23 # to build at all.

26 # to build at all.

24− inherit (pkgs.buildPackages.buildPackages) gitMinimal;

27+ inherit (pkgs.evalPackages.buildPackages) gitMinimal;

25

28

26in {

29in {

27 # Within the package components, these are the attribute names of

30 # Within the package components, these are the attribute names of

@@ -70,12 +73,8 @@ in {

70 comps = config.components;

73 comps = config.components;

71 applyLibrary = cname: f { cname = config.package.identifier.name; ctype = "lib"; };

74 applyLibrary = cname: f { cname = config.package.identifier.name; ctype = "lib"; };

72 applySubComp = ctype: cname: f { inherit cname; ctype = componentPrefix.${ctype} or (throw "Missing component mapping for ${ctype}."); };

75 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`

77− buildableAttrs = lib.filterAttrs (n: isBuildable);

76+ buildableAttrs = lib.filterAttrs (n: comp: comp.buildable or true);

78− libComp = if comps.library == null || !(isBuildable comps.library)

77+ libComp = if comps.library == null || !(comps.library.buildable or true)

79 then {}

78 then {}

80 else lib.mapAttrs applyLibrary (removeAttrs comps (subComponentTypes ++ [ "setup" ]));

79 else lib.mapAttrs applyLibrary (removeAttrs comps (subComponentTypes ++ [ "setup" ]));

81 subComps = lib.mapAttrs

80 subComps = lib.mapAttrs

@@ -133,7 +132,14 @@ in {

133 ## flatLibDepends :: Component -> [Package]

132 ## flatLibDepends :: Component -> [Package]

134 flatLibDepends = component:

133 flatLibDepends = component:

135 let

134 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);

136− makePairs = map (p: rec { key=val.name; val=(p.components.library or p); });

142+ makePairs = map (p: rec { key=getKey val; val=(p.components.library or p); });

137 closure = builtins.genericClosure {

143 closure = builtins.genericClosure {

138 startSet = makePairs component.depends;

144 startSet = makePairs component.depends;

139 operator = {val,...}: makePairs val.config.depends;

145 operator = {val,...}: makePairs val.config.depends;

@@ -189,17 +195,17 @@ in {

189 collectChecks' = collectChecks (_: true);

195 collectChecks' = collectChecks (_: true);

190

196

191 # Replacement for lib.cleanSourceWith that has a subDir argument.

197 # Replacement for lib.cleanSourceWith that has a subDir argument.

192− inherit (import ./clean-source-with.nix { inherit lib; }) cleanSourceWith;

198+ inherit (import ./clean-source-with.nix { inherit lib; }) cleanSourceWith canCleanSource;

193

199

194 # Use cleanSourceWith to filter just the files needed for a particular

200 # Use cleanSourceWith to filter just the files needed for a particular

195 # component of a package

201 # component of a package

196− cleanCabalComponent = import ./clean-cabal-component.nix { inherit lib cleanSourceWith; };

202+ cleanCabalComponent = import ./clean-cabal-component.nix { inherit lib cleanSourceWith canCleanSource; };

197

203

198 # Clean git directory based on `git ls-files --recurse-submodules`

204 # Clean git directory based on `git ls-files --recurse-submodules`

199 cleanGit = import ./clean-git.nix {

205 cleanGit = import ./clean-git.nix {

200 inherit lib cleanSourceWith;

206 inherit lib cleanSourceWith;

201 git = gitMinimal;

207 git = gitMinimal;

202− inherit (pkgs.buildPackages.buildPackages) runCommand;

208+ inherit (pkgs.evalPackages) runCommand;

203 };

209 };

204

210

205 # Some times it is handy to temporarily use a relative path between git

211 # Some times it is handy to temporarily use a relative path between git

@@ -229,7 +235,7 @@ in {

229

235

230 # Check a test component

236 # Check a test component

231 check = import ./check.nix {

237 check = import ./check.nix {

232− inherit stdenv lib haskellLib;

238+ inherit stdenv lib haskellLib srcOnly;

233 };

239 };

234

240

235 # Do coverage of a package

241 # Do coverage of a package

@@ -248,33 +254,31 @@ in {

248 # In most cases we do not want to treat musl as a cross compiler.

254 # In most cases we do not want to treat musl as a cross compiler.

249 # For instance when building ghc we want to include ghci.

255 # For instance when building ghc we want to include ghci.

250 isCrossHost = stdenv.hostPlatform != stdenv.buildPlatform

256 isCrossHost = stdenv.hostPlatform != stdenv.buildPlatform

251− && !(stdenv.buildPlatform.isLinux && stdenv.hostPlatform.isMusl && stdenv.buildPlatform.linuxArch == stdenv.hostPlatform.linuxArch);

257+ && !(stdenv.buildPlatform.isLinux && stdenv.hostPlatform.isMusl && stdenv.buildPlatform.isx86 && stdenv.hostPlatform.isx86);

252 # This is the same as isCrossHost but for use when building ghc itself

258 # This is the same as isCrossHost but for use when building ghc itself

253 isCrossTarget = stdenv.targetPlatform != stdenv.hostPlatform

259 isCrossTarget = stdenv.targetPlatform != stdenv.hostPlatform

254− && !(stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl && stdenv.hostPlatform.linuxArch == stdenv.targetPlatform.linuxArch);

260+ && !(stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl && stdenv.hostPlatform.isx86 && stdenv.targetPlatform.isx86);

255 # Native musl build-host-target combo

261 # Native musl build-host-target combo

256 isNativeMusl = stdenv.hostPlatform.isMusl

262 isNativeMusl = stdenv.hostPlatform.isMusl

257 && stdenv.buildPlatform == stdenv.hostPlatform

263 && stdenv.buildPlatform == stdenv.hostPlatform

258 && stdenv.hostPlatform == stdenv.targetPlatform;

264 && stdenv.hostPlatform == stdenv.targetPlatform;

259

265

260− # Takes a version number, module or list of modules (for cabalProject)

266+ # Takes a version number or attr set of arguments (for cabalProject)

261− # and converts it to an list of project modules. This allows

267+ # and converts it to an attr set of arguments. This allows

262 # the use of "1.0.0.0" or { version = "1.0.0.0"; ... }

268 # the use of "1.0.0.0" or { version = "1.0.0.0"; ... }

263− versionOrModToMods = versionOrMod:

269+ versionOrArgsToArgs = versionOrArgs:

264− if lib.isString versionOrMod

270+ if lib.isAttrs versionOrArgs

265− then [{ version = versionOrMod; }]

271+ then versionOrArgs

266− else if lib.isList versionOrMod

272+ else { version = versionOrArgs; };

267− then versionOrMod

268− else [versionOrMod];

269

273

270 # Find the resolver in the stack.yaml file and fetch it if a sha256 value is provided

274 # Find the resolver in the stack.yaml file and fetch it if a sha256 value is provided

271 fetchResolver = import ./fetch-resolver.nix {

275 fetchResolver = import ./fetch-resolver.nix {

272− inherit (pkgs.buildPackages) pkgs;

276+ inherit (pkgs.evalPackages) pkgs;

273 };

277 };

274

278

275 inherit (import ./cabal-project-parser.nix {

279 inherit (import ./cabal-project-parser.nix {

276 inherit pkgs;

280 inherit pkgs;

277− }) parseIndexState parseSourceRepositoryPackages parseRepositories parseSourceRepositoryPackageBlock parseRepositoryBlock;

281+ }) parseIndexState parseBlock;

278

282

279

283

280 cabalToNixpkgsLicense = import ./spdx/cabal.nix pkgs;

284 cabalToNixpkgsLicense = import ./spdx/cabal.nix pkgs;

@@ -289,9 +293,26 @@ in {

289 if subDir == ""

293 if subDir == ""

290 then src

294 then src

291 else

295 else

296+ if haskellLib.canCleanSource src

292− haskellLib.cleanSourceWith {

297+ then haskellLib.cleanSourceWith {

293− inherit src subDir includeSiblings;

298+ 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;

294− };

315+ };

295

316

296 # Givin a `src` split it into a `root` path (based on `src.origSrc` if

317 # Givin a `src` split it into a `root` path (based on `src.origSrc` if

297 # present) and `subDir` (based on `src.origSubDir). The

318 # present) and `subDir` (based on `src.origSubDir). The

@@ -312,35 +333,4 @@ in {

312 }

333 }

313 else src.origSrc or src; # If there is a subDir and origSrc (but no filter) use origSrc

334 else src.origSrc or src; # If there is a subDir and origSrc (but no filter) use origSrc

314 };

335 };

315−

316− # Run evalModules passing the project function argument (m) as a module along with

317− # the the a projectType module (../modules/cabal-project.nix or ../modules/stack-project.nix).

318− # The resulting config is then passed to the project function's implementation.

319− evalProjectModule = projectType: m: f:

320− let project = f

321− (lib.evalModules {

322− modules = (if builtins.isList m then m else [m]) ++ [

323− # Include ../modules/cabal-project.nix or ../modules/stack-project.nix

324− (import ../modules/project-common.nix)

325− (import projectType)

326− # Pass the pkgs and the buildProject to the modules

327− ({ config, lib, ... }: {

328− _module.args = {

329− inherit pkgs;

330− # to make it easy to depends on build packages in, eg., shell definition:

331− inherit (project) buildProject;

332− };

333− inherit (project) hsPkgs;

334− })

335− ];

336− }).config;

337− in project;

338−

339− # Converts from a `compoent.depends` value to a library derivation.

340− # In the case of sublibs the `depends` value should already be the derivation.

341− dependToLib = d: d.components.library or d;

342−

343− projectOverlays = import ./project-overlays.nix {

344− inherit lib haskellLib;

345− };

346}

336}

lib/fetch-resolver.nix+2−6

@@ -5,12 +5,10 @@

5, resolverSha256 ? null

6}:

7let

8− srcDir = src.origSrcSubDir or src;

9−

10 # Using origSrcSubDir bypasses any cleanSourceWith so that it will work when

8 # Using origSrcSubDir bypasses any cleanSourceWith so that it will work when

11 # access to the store is restricted. If origSrc was already in the store

9 # access to the store is restricted. If origSrc was already in the store

12 # you can pass the project in as a string.

10 # you can pass the project in as a string.

13− rawStackYaml = builtins.readFile (srcDir + "/${stackYaml}");

11+ rawStackYaml = builtins.readFile ((src.origSrcSubDir or src) + ("/" + stackYaml));

14

12

15 # Determine the resolver as it may point to another file we need

13 # Determine the resolver as it may point to another file we need

16 # to look at.

14 # to look at.

@@ -30,8 +28,6 @@ let

30 url = resolver;

28 url = resolver;

31 sha256 = resolverSha256;

29 sha256 = resolverSha256;

32 }

30 }

33− else if resolver != null && __pathExists (srcDir + "/${resolver}")

34− then pkgs.copyPathToStore (srcDir + "/${resolver}")

35− else null;

31+ else null;

36

32

37in { inherit resolver fetchedResolver; }

33in { inherit resolver fetchedResolver; }

lib/ghcjs-project.nix+17−68

@@ -23,7 +23,7 @@

23{ src

24, compiler-nix-name

25, ghc ? pkgs.buildPackages.haskell-nix.compiler.${compiler-nix-name}

26−, ghcjsVersion # Version in the ghcjs.cabal file (that we will replace)

26+, ghcjsVersion

27, ghcVersion ? ghc.version

28, happy ? pkgs.haskell-nix.tool compiler-nix-name "happy" {

29 index-state = pkgs.haskell-nix.internalHackageIndexState;

@@ -35,14 +35,7 @@

35 version = "3.2.5";

36 materialized = ../materialized/ghcjs/alex + "/${compiler-nix-name}";

37 }

38−, cabal-install ?

39− if (builtins.compareVersions ghcjsVersion "8.10.0.0" >= 0)

40− then pkgs.haskell-nix.tool compiler-nix-name "cabal" {

41− index-state = pkgs.haskell-nix.internalHackageIndexState;

42− version = "3.6.2.0";

43− materialized = ../materialized/ghcjs/cabal + "/${compiler-nix-name}";

44− }

45− else pkgs.haskell-nix.tool compiler-nix-name "cabal" {

38+, cabal-install ? pkgs.haskell-nix.tool compiler-nix-name "cabal" {

46 index-state = pkgs.haskell-nix.internalHackageIndexState;

39 index-state = pkgs.haskell-nix.internalHackageIndexState;

47 version = "3.2.0.0";

40 version = "3.2.0.0";

48 # Cabal 3.2.1.0 no longer supports he mix of `cabal-version`,

41 # Cabal 3.2.1.0 no longer supports he mix of `cabal-version`,

@@ -52,13 +45,10 @@

52 '';

45 '';

53 materialized = ../materialized/ghcjs/cabal + "/${compiler-nix-name}";

46 materialized = ../materialized/ghcjs/cabal + "/${compiler-nix-name}";

54 }

47 }

55−, overrideBootPackages ? []

56−, patches ? []

57, ...

48, ...

58}@args:

49}@args:

59let

50let

60− isGhcjs88 = builtins.compareVersions ghcjsVersion "8.8.0.0" >= 0;

51+ isGhcjs88 = builtins.compareVersions ghcjsVersion "8.8.0.0" > 0;

61− isGhcjs810 = builtins.compareVersions ghcjsVersion "8.10.0.0" >= 0;

62

52

63 # Inputs needed to configure the GHCJS source tree

53 # Inputs needed to configure the GHCJS source tree

64 configureInputs = with pkgs; [

54 configureInputs = with pkgs; [

@@ -77,11 +67,7 @@ let

77

67

78 # Inputs needed to boot the GHCJS compiler

68 # Inputs needed to boot the GHCJS compiler

79 bootInputs = with pkgs.buildPackages; [

69 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.

84− nodejs-18_x

70+ nodejs

85 makeWrapper

71 makeWrapper

86 xorg.lndir

72 xorg.lndir

87 gmp

73 gmp

@@ -89,9 +75,9 @@ let

89 ]

75 ]

90 ++ [ ghc cabal-install emsdk ];

76 ++ [ ghc cabal-install emsdk ];

91 # Configured the GHCJS source

77 # Configured the GHCJS source

92− configured-src = (pkgs.runCommandCC "configured-ghcjs-src" {

78+ configured-src = pkgs.runCommand "configured-ghcjs-src" {

93 buildInputs = configureInputs;

79 buildInputs = configureInputs;

94− inherit src patches;

80+ inherit src;

95 } ''

81 } ''

96 export HOME=$(pwd)

82 export HOME=$(pwd)

97 mkdir $HOME/.cabal

83 mkdir $HOME/.cabal

@@ -100,11 +86,6 @@ let

100 chmod -R +w "$out"

86 chmod -R +w "$out"

101 cd "$out"

87 cd "$out"

102

88

103− for p in $patches

104− do

105− patch -p1 <$p

106− done

107−

108 # TODO: Find a better way to avoid impure version numbers

89 # TODO: Find a better way to avoid impure version numbers

109 sed -i 's/RELEASE=NO/RELEASE=YES/' ghc/configure.ac

90 sed -i 's/RELEASE=NO/RELEASE=YES/' ghc/configure.ac

110 sed -i 's/${ghcjsVersion}/${ghcVersion}/' ghcjs.cabal

91 sed -i 's/${ghcjsVersion}/${ghcVersion}/' ghcjs.cabal

@@ -122,58 +103,26 @@ let

122 rm -rf utils/pkg-cache/ghc

103 rm -rf utils/pkg-cache/ghc

123 cp -r ${ghc.generated} utils/pkg-cache/ghc

104 cp -r ${ghc.generated} utils/pkg-cache/ghc

124

105

125− for a in integer-gmp base unix; do

106+ cp ${../overlays/patches/config.sub} ghc/libraries/integer-gmp/config.sub

126− cp ${../overlays/patches/config.sub} ghc/libraries/$a/config.sub

107+ cp ${../overlays/patches/config.sub} ghc/libraries/base/config.sub

127− cp ${../overlays/patches/config.guess} ghc/libraries/$a/config.guess

108+ cp ${../overlays/patches/config.sub} ghc/libraries/unix/config.sub

128− chmod +w ghc/libraries/$a/config.*

129− done

130−

131− sed -i 's/_AC_PROG_CC_C99/AC_PROG_CC_C99/' ghc/aclocal.m4

132

109

133 patchShebangs .

110 patchShebangs .

134 sed -i 's/gcc /cc /g' utils/makePackages.sh

111 sed -i 's/gcc /cc /g' utils/makePackages.sh

135 ./utils/makePackages.sh copy

112 ./utils/makePackages.sh copy

136

113

137− for a in integer-gmp base unix; do

138− cp ${../overlays/patches/config.sub} lib/boot/pkg/$a/config.sub

139− done

140− ${ # it just so happens that all existing uses of overriding boot packages

141− # need to be installed right after template-haskell

142− # if at some point we would need to insert them at different points

143− # then we will have gto come up with something more clever

144− builtins.concatStringsSep "\n" (map ({name, src}: ''

145− rm -rf $out/lib/boot/pkg/${name}

146− cp -r ${src} $out/lib/boot/pkg/${name}

147− sed -i 's/^ - ${name}$//g' $out/lib/boot/boot.yaml

148− sed -i 's/^ - template-haskell$/ - template-haskell\n - ${name}/g' $out/lib/boot/boot.yaml

149− echo "Added ${name} to boot.yaml"

150− ''

151− ) (pkgs.lib.reverseList overrideBootPackages))

152− }

153−

154− chmod -R +w $out/lib/boot/pkg

155− '') // {

156− # The configured source includes /nix/store paths and so filtering can fail.

157− filterPath = { path, ... }: path;

158− };

114+ '';

159 # see https://github.com/ghcjs/ghcjs/issues/751 for the happy upper bound.

115 # see https://github.com/ghcjs/ghcjs/issues/751 for the happy upper bound.

160

116

161 ghcjsProject = pkgs.haskell-nix.cabalProject' (

117 ghcjsProject = pkgs.haskell-nix.cabalProject' (

162− (pkgs.lib.filterAttrs

118+ (pkgs.lib.filterAttrs

163 (n: _: !(builtins.any (x: x == n)

119 (n: _: !(builtins.any (x: x == n)

164− [ "src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"

120+ ["src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"])) args) // {

165− "overrideBootPackages" "patches"])) args) // {

166 src = configured-src;

121 src = configured-src;

167− index-state = "2021-03-20T00:00:00Z";

122+ index-state = "2020-11-16T00:00:00Z";

168− inherit compiler-nix-name;

123+ compiler-nix-name = if isGhcjs88 then "ghc884" else "ghc865";

169− configureArgs = pkgs.lib.optionalString (isGhcjs88 && !isGhcjs810) "--constraint='Cabal >=3.0.2.0 && <3.1'";

124+ configureArgs = pkgs.lib.optionalString isGhcjs88 "--constraint='Cabal >=3.0.2.0 && <3.1'";

170− # If a package is in both build-depends and build-tool-depends multiple versions may

171− # be in the `plan.json` file. Haskell.nix will pick the newer one, but when nbuilding

172− # ghcjs 8.6 we need to use the older happy version.

173− pkg-def-extras = pkgs.lib.optional (!isGhcjs88) (hackage: {

174− packages.happy.revision = hackage.happy."1.19.9".revisions.default;

175− });

176− materialized = ../materialized + "/ghcjs/${compiler-nix-name}";

125+ materialized = ../materialized + (if isGhcjs88 then "/ghcjs884" else "/ghcjs865");

177 modules = [

126 modules = [

178 {

127 {

179 # we need ghc-boot in here for ghcjs.

128 # we need ghc-boot in here for ghcjs.

@@ -186,7 +135,6 @@ let

186 packages.Cabal.patches = [ ./../overlays/patches/Cabal/fix-data-dir.patch ];

135 packages.Cabal.patches = [ ./../overlays/patches/Cabal/fix-data-dir.patch ];

187 })

136 })

188 {

137 {

189− ghcOptions = ["-O2"];

190 packages.ghcjs.doHaddock = false;

138 packages.ghcjs.doHaddock = false;

191 packages.haddock-ghcjs.doHaddock = false;

139 packages.haddock-ghcjs.doHaddock = false;

192 packages.haddock-api-ghcjs.doHaddock = false;

140 packages.haddock-api-ghcjs.doHaddock = false;

@@ -216,3 +164,4 @@ in ghcjsProject // {

216 };

164 };

217 inherit configureInputs bootInputs configured-src emscriptenupstream emscripten emsdk;

165 inherit configureInputs bootInputs configured-src emscriptenupstream emscripten emsdk;

218}

166}

167+

lib/import-and-filter-project.nix+21−15

@@ -6,11 +6,14 @@

6let

7 # Full source including possible relative paths form the

8 # project directory.

9+ srcRoot =

10+ if haskellLib.canCleanSource src

9− srcRoot = haskellLib.cleanSourceWith {

11+ then haskellLib.cleanSourceWith {

10− name = if src ? name then "${src.name}-root" else "source-root";

12+ name = if src ? name then "${src.name}-root" else "source-root";

11− src = src.origSrc or src;

13+ src = src.origSrc or src;

12− filter = src.filter or (_: _: true);

14+ filter = src.filter or (_: _: true);

13− };

15+ }

16+ else src.origSrc or src;

14 # The sub directory containing the cabal.project or stack.yaml file

17 # The sub directory containing the cabal.project or stack.yaml file

15 projectSubDir' = src.origSubDir or ""; # With leading /

18 projectSubDir' = src.origSubDir or ""; # With leading /

16 projectSubDir = pkgs.lib.strings.removePrefix "/" projectSubDir'; # Without /

19 projectSubDir = pkgs.lib.strings.removePrefix "/" projectSubDir'; # Without /

@@ -24,28 +27,31 @@ in project // {

24 else {...}@args: with pkgs.lib.strings;

27 else {...}@args: with pkgs.lib.strings;

25 let

28 let

26 oldPkg = import value args;

29 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+

27 packageInfo =

35 packageInfo =

28− if oldPkg.src ? url

36+ if !hasPrefix (toString projectNix) (toString oldPkg.src.content)

29 then {

37 then {

30− # The source is from a source-repository-package in a cabal.project file

38+ # Source location does not match project prefix

31− # and lib/call-cabal-project-to-nix.nix should have replaced the url with

32− # an index into the sourceRepos list.

33 isProject = false;

39 isProject = false;

34− packageSrc = pkgs.lib.lists.elemAt sourceRepos (toInt oldPkg.src.url);

40+ packageSrc = toString oldPkg.src.content;

35 }

41 }

36− else if !hasPrefix "${projectNix}" (toString oldPkg.src.content)

42+ else if hasPrefix srcRepoPrefix subDir

37 then {

43 then {

38− # Source location does not match project prefix

44+ # The source is from a source repository

39 isProject = false;

45 isProject = false;

40− packageSrc = toString oldPkg.src.content;

46+ packageSrc = pkgs.lib.lists.elemAt sourceRepos (

47+ toInt (removePrefix srcRepoPrefix subDir));

41 }

48 }

42 else {

49 else {

43 # Source does match project prefix and it is not from a source repository

50 # Source does match project prefix and it is not from a source repository

44 isProject = true;

51 isProject = true;

45 packageSrc = haskellLib.appendSubDir {

52 packageSrc = haskellLib.appendSubDir {

46 src = srcRoot;

53 src = srcRoot;

47− subDir = removePrefix "/" (removePrefix "${projectNix}"

54+ inherit subDir;

48− (toString oldPkg.src.content));

49 includeSiblings = true; # Filtering sibling dirs of the package dir is done in the

55 includeSiblings = true; # Filtering sibling dirs of the package dir is done in the

50 # component builder so that relative paths can be used to

56 # component builder so that relative paths can be used to

51 # reference project directories not in the package subDir.

57 # reference project directories not in the package subDir.

lib/materialize.nix+10−12

@@ -24,7 +24,7 @@

24}: derivation:

25

26let

27− name = derivation.name + pkgs.lib.optionalString (derivation ? version) "-${derivation.version}";

27+ inherit (derivation) name;

28

29 traceIgnoringSha256 = reason: x:

30 if sha256 != null

@@ -36,15 +36,10 @@ 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−

44 unchecked =

39 unchecked =

45 let

40 let

46− sha256message = "${name}: To make ${this} a fixed-output derivation but not materialized, set `${sha256Arg}` to the output of the 'calculateMaterializedSha' script in 'passthru'.";

41+ sha256message = "To make ${this} a fixed-output derivation but not materialized, set `${sha256Arg}` to the output of the 'calculateMaterializedSha' 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'.";

42+ materializeMessage = "To materialize ${this} entirely, pass a writable path as the `materialized` argument and run the 'updateMaterialized' script in 'passthru'.";

48 in if reasonNotSafe != null

43 in if reasonNotSafe != null

49 then

44 then

50 # Warn the user if they tried to pin stuff down when it is not safe

45 # Warn the user if they tried to pin stuff down when it is not safe

@@ -55,10 +50,10 @@ let

55 else if sha256 != null

50 else if sha256 != null

56 then

51 then

57 # Let the user know how to materialize if they want to.

52 # Let the user know how to materialize if they want to.

58− traceWhenChecking materializeMessage calculateUseHash

53+ builtins.trace materializeMessage calculateUseHash

59 else # materialized == null && sha256 == null

54 else # materialized == null && sha256 == null

60 # Let the user know how to calculate a sha256 or materialize if they want to.

55 # Let the user know how to calculate a sha256 or materialize if they want to.

61− traceWhenChecking sha256message (traceWhenChecking materializeMessage calculateNoHash);

56+ builtins.trace sha256message (builtins.trace materializeMessage calculateNoHash);

62

57

63 # Build fully and check the hash and materialized versions

58 # Build fully and check the hash and materialized versions

64 checked =

59 checked =

@@ -128,7 +123,11 @@ let

128 calculateUseMaterialized =

123 calculateUseMaterialized =

129 assert materialized != null;

124 assert materialized != null;

130 assert __pathExists materialized;

125 assert __pathExists materialized;

126+ runCommand name (pkgs.lib.optionalAttrs (sha256 == null) hashArgs) ''

131− { outPath = materialized; inherit name; };

127+ cp -Lr ${materialized} $out

128+ # Make sure output files can be removed from the sandbox

129+ chmod -R +w $out

130+ '';

132 calculateMaterializedSha =

131 calculateMaterializedSha =

133 writeShellScript "calculateSha" ''${nix}/bin/nix-hash --base32 --type sha256 ${calculateNoHash}'';

132 writeShellScript "calculateSha" ''${nix}/bin/nix-hash --base32 --type sha256 ${calculateNoHash}'';

134

133

@@ -144,7 +143,6 @@ let

144 fi

143 fi

145

144

146 # Generate the files

145 # Generate the files

147− mkdir -p $TARGET

148 rm -rf $TARGET

146 rm -rf $TARGET

149 cp -r ${calculateNoHash} "$TARGET"

147 cp -r ${calculateNoHash} "$TARGET"

150 chmod -R +w "$TARGET"

148 chmod -R +w "$TARGET"

lib/pkgconf-nixpkgs-map.nix+1−9

@@ -27,12 +27,11 @@ pkgs:

27 "dl" = []; # provided by glibc

28 "fftw3" = [ pkgs."fftw" ];

29 "fftw3f" = [ pkgs."fftwFloat" ];

30− "freetype2" = [ pkgs."freetype" ];

31 "gconf" = [ pkgs."GConf" ];

30 "gconf" = [ pkgs."GConf" ];

32 "gconf-2.0" = [ pkgs."GConf" ];

31 "gconf-2.0" = [ pkgs."GConf" ];

33 "gdk-2.0" = [ pkgs."gtk2" ];

32 "gdk-2.0" = [ pkgs."gtk2" ];

34 "gdk-3.0" = [ pkgs."gtk3" ];

33 "gdk-3.0" = [ pkgs."gtk3" ];

35− "gdk-pixbuf-2.0" = [ (pkgs."gdk-pixbuf" or pkgs."gdk_pixbuf") ];

34+ "gdk-pixbuf-2.0" = [ pkgs."gdk_pixbuf" ];

36 "gdk-x11-2.0" = [ pkgs."gdk_x11" ];

35 "gdk-x11-2.0" = [ pkgs."gdk_x11" ];

37 "gdk-x11-3.0" = [ pkgs."gtk3" ];

36 "gdk-x11-3.0" = [ pkgs."gtk3" ];

38 "gio-2.0" = [ pkgs."glib" ];

37 "gio-2.0" = [ pkgs."glib" ];

@@ -45,9 +44,7 @@ pkgs:

45 "gnome-vfs-2.0" = [ pkgs."gnome-vfs" ];

44 "gnome-vfs-2.0" = [ pkgs."gnome-vfs" ];

46 "gnome-vfs-module-2.0" = [ pkgs."gnome-vfs_module" ];

45 "gnome-vfs-module-2.0" = [ pkgs."gnome-vfs_module" ];

47 "gobject-2.0" = [ pkgs."glib" ];

46 "gobject-2.0" = [ pkgs."glib" ];

48− "gmodule-2.0" = [ pkgs."glib" ];

49 "gobject-introspection-1.0" = [ pkgs."gobject-introspection" ];

47 "gobject-introspection-1.0" = [ pkgs."gobject-introspection" ];

50− "graphene-gobject-1.0" = [ pkgs."graphene" ];

51 "gstreamer-audio-0.10" = [ pkgs."gst-plugins-base" ];

48 "gstreamer-audio-0.10" = [ pkgs."gst-plugins-base" ];

52 "gstreamer-audio-1.0" = [ pkgs."gst-plugins-base" ];

49 "gstreamer-audio-1.0" = [ pkgs."gst-plugins-base" ];

53 "gstreamer-base-0.10" = [ pkgs."gst-plugins-base" ];

50 "gstreamer-base-0.10" = [ pkgs."gst-plugins-base" ];

@@ -67,7 +64,6 @@ pkgs:

67 "hidapi-libusb" = [ pkgs."hidapi" ];

64 "hidapi-libusb" = [ pkgs."hidapi" ];

68 "icudata" = [ pkgs."icu" ];

65 "icudata" = [ pkgs."icu" ];

69 "icui18n" = [ pkgs."icu" ];

66 "icui18n" = [ pkgs."icu" ];

70− "icu-i18n" = [ pkgs."icu" ];

71 "icuuc" = [ pkgs."icu" ];

67 "icuuc" = [ pkgs."icu" ];

72 "idn" = [ pkgs."libidn" ];

68 "idn" = [ pkgs."libidn" ];

73 "IL" = [ pkgs."libdevil" ];

69 "IL" = [ pkgs."libdevil" ];

@@ -84,9 +80,7 @@ pkgs:

84 "ldap" = [ pkgs."openldap" ];

80 "ldap" = [ pkgs."openldap" ];

85 "libavutil" = [ pkgs."ffmpeg" ];

81 "libavutil" = [ pkgs."ffmpeg" ];

86 "libcrypto" = [ pkgs."openssl".dev ];

82 "libcrypto" = [ pkgs."openssl".dev ];

87− "libfreenect" = [ pkgs."freenect" ];

88 "libgsasl" = [ pkgs."gsasl" ];

83 "libgsasl" = [ pkgs."gsasl" ];

89− "liboath" = [ pkgs."liboauth" ];

90 "libpcre" = [ pkgs."pcre" ];

84 "libpcre" = [ pkgs."pcre" ];

91 "libqrencode" = [ pkgs."qrencode" ];

85 "libqrencode" = [ pkgs."qrencode" ];

92 "libR" = [ pkgs."R" ];

86 "libR" = [ pkgs."R" ];

@@ -101,7 +95,6 @@ pkgs:

101 "libxml-2.0" = [ pkgs."libxml2" ];

95 "libxml-2.0" = [ pkgs."libxml2" ];

102 "libzip" = [ pkgs."libzip" ];

96 "libzip" = [ pkgs."libzip" ];

103 "libzmq" = [ pkgs."zeromq" ];

97 "libzmq" = [ pkgs."zeromq" ];

104− "libzstd" = [ pkgs."zstd" ];

105 "m" = []; # in stdenv

98 "m" = []; # in stdenv

106 "magic" = [ pkgs."file" ];

99 "magic" = [ pkgs."file" ];

107 "MagickWand" = [ pkgs."imagemagick" ];

100 "MagickWand" = [ pkgs."imagemagick" ];

@@ -122,7 +115,6 @@ pkgs:

122 "pfs-1.2" = [ pkgs."pfstools" ];

115 "pfs-1.2" = [ pkgs."pfstools" ];

123 "png" = [ pkgs."libpng" ];

116 "png" = [ pkgs."libpng" ];

124 "poppler-glib" = [ pkgs."poppler" ];

117 "poppler-glib" = [ pkgs."poppler" ];

125− "poppler-cpp" = [ pkgs."poppler" ];

126 "pq" = [ pkgs."postgresql" ];

118 "pq" = [ pkgs."postgresql" ];

127 "libpq" = [ pkgs."postgresql" ];

119 "libpq" = [ pkgs."postgresql" ];

128 "pthread" = [];

120 "pthread" = [];

lib/project-overlays.nixdeleted−37

@@ -1,37 +0,0 @@

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+7−14

@@ -1,25 +1,18 @@

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}";

5 licensesJSON = fromJSON (replaceStrings

3 licensesJSON = fromJSON (replaceStrings

6 [ "\\u0026" "\\u0027" "\\u003d" ]

4 [ "\\u0026" "\\u0027" "\\u003d" ]

7 [ "&" "'" "=" ]

5 [ "&" "'" "=" ]

8− (readFile "${pkgs.buildPackages.haskell-nix.materialize {

6+ (readFile "${pkgs.evalPackages.spdx-license-list-data}/json/licenses.json")

9− materialized = if pathExists materialized' then materialized' else null;

10− } (pkgs.buildPackages.runCommand "spdx-json" { inherit (spdxJson) version; } ''

11− mkdir $out

12− cp ${spdxJson}/json/licenses.json $out

13− '')

14− }/licenses.json")

15 );

7 );

16 dropFour = s: substring 0 (stringLength s - 4) s;

8 dropFour = s: substring 0 (stringLength s - 4) s;

17 toSpdx = lic: with lic;

9 toSpdx = lic: with lic;

18− { spdxId = licenseId;

10+ { spdxId = licenseId

19− shortName = licenseId;

11+ ; shortName = licenseId

20− fullName = name;

12+ ; fullName = name

21− url = dropFour detailsUrl + "html";

13+ ; url = dropFour detailsUrl + "html"

22− free = isOsiApproved || lic.isFsfLibre or false;

14+ ; free = isOsiApproved

15+ ;

23 };

16 };

24 toNamedValue = lic: { name = lic.spdxId; value = lic; };

17 toNamedValue = lic: { name = lic.spdxId; value = lic; };

25in

18in

lib/stack-cache-generator.nix+39−33

@@ -1,5 +1,6 @@

1# Generate cache entries for dependencies of package defined in `src`

2

3+{ pkgs, haskellLib }:

3{ src

4{ src

4, stackYaml ? "stack.yaml"

5, stackYaml ? "stack.yaml"

5, sha256map ? null

6, sha256map ? null

@@ -8,6 +9,10 @@

8 # sha256map =

9 # sha256map =

9 # { "https://github.com/jgm/pandoc-citeproc"."0.17"

10 # { "https://github.com/jgm/pandoc-citeproc"."0.17"

10 # = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q"; };

11 # = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q"; };

12+, lookupSha256 ?

13+ if sha256map != null

14+ then { location, tag, ...}: sha256map."${location}"."${tag}"

15+ else _: null

11, branchMap ? null

16, branchMap ? null

12 # A way to specify in which branch a git commit can

17 # A way to specify in which branch a git commit can

13 # be found

18 # be found

@@ -16,14 +21,10 @@

16 then { location, tag, ...}: branchMap."${location}"."${tag}" or null

21 then { location, tag, ...}: branchMap."${location}"."${tag}" or null

17 else _: null

22 else _: null

18, resolverSha256 ? null

23, resolverSha256 ? null

19−, nix-tools

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)

20−, evalPackages

21, ...

25, ...

22−}@args:

26+}:

23let

27let

24− inherit (evalPackages) runCommand;

25− inherit (evalPackages.haskell-nix) haskellLib;

26−

27 # We only care about the stackYaml file. If src is a local directory

28 # We only care about the stackYaml file. If src is a local directory

28 # we want to avoid recalculating the cache unless the stack.yaml file

29 # we want to avoid recalculating the cache unless the stack.yaml file

29 # changes.

30 # changes.

@@ -33,27 +34,30 @@ let

33 }) resolver fetchedResolver;

34 }) resolver fetchedResolver;

34

35

35 # Filter just the stack yaml file and any resolver yaml file it points to.

36 # Filter just the stack yaml file and any resolver yaml file it points to.

37+ maybeCleanedSource =

38+ if haskellLib.canCleanSource src

36− maybeCleanedSource = haskellLib.cleanSourceWith {

39+ then haskellLib.cleanSourceWith {

37− inherit src;

40+ inherit src;

38− filter = path: type:

41+ filter = path: type:

39− let

42+ let

40− origSrc = if src ? _isLibCleanSourceWith then src.origSrc else src;

43+ origSrc = if src ? _isLibCleanSourceWith then src.origSrc else src;

41− origSubDir = if src ? _isLibCleanSourceWithEx then src.origSubDir else "";

44+ origSubDir = if src ? _isLibCleanSourceWithEx then src.origSubDir else "";

42− relPath = evalPackages.lib.removePrefix (toString origSrc + origSubDir + "/") path;

45+ relPath = pkgs.lib.removePrefix (toString origSrc + origSubDir + "/") path;

43

46

44− # checks if path1 is a parent directory for path2

47+ # checks if path1 is a parent directory for path2

45− isParent = path1: path2: evalPackages.lib.hasPrefix "${path1}/" path2;

48+ isParent = path1: path2: pkgs.lib.hasPrefix "${path1}/" path2;

46

49

47− in

50+ in

48− (relPath == stackYaml)

51+ (relPath == stackYaml)

49− || (resolver != null && (relPath == resolver || isParent relPath resolver))

52+ || (resolver != null && (relPath == resolver || isParent relPath resolver))

50− ;

53+ ;

51− };

54+ }

55+ else src;

52

56

53 # All repos served via ssh or git protocols are usually private

57 # All repos served via ssh or git protocols are usually private

54− private = url: evalPackages.lib.substring 0 4 url != "http";

58+ private = url: pkgs.lib.substring 0 4 url != "http";

55

59

56− repos = builtins.fromJSON (builtins.readFile (evalPackages.runCommand "stack-repos" {

60+ repos = builtins.fromJSON (builtins.readFile (pkgs.runCommand "stack-repos" {

57 buildInputs = [ nix-tools ];

61 buildInputs = [ nix-tools ];

58 } ''

62 } ''

59 TMP=$(mktemp -d)

63 TMP=$(mktemp -d)

@@ -61,43 +65,45 @@ let

61 cp -r "${maybeCleanedSource}/." $TMP

65 cp -r "${maybeCleanedSource}/." $TMP

62 chmod -R +w $TMP

66 chmod -R +w $TMP

63 substituteInPlace ${stackYaml} --replace "# nix-sha256:" "nix-sha256:"

67 substituteInPlace ${stackYaml} --replace "# nix-sha256:" "nix-sha256:"

64− ${evalPackages.lib.optionalString (fetchedResolver != null) ''

68+ ${pkgs.lib.optionalString (fetchedResolver != null) ''

65 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

69 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

66 ''}

70 ''}

67 stack-repos --stack-yaml ${stackYaml}

71 stack-repos --stack-yaml ${stackYaml}

68 cp repos.json $out

72 cp repos.json $out

69 ''));

73 ''));

70

74

71− cabalName = path: builtins.readFile (evalPackages.runCommand "cabal-name" {

75+ cabalName = path: builtins.readFile (pkgs.runCommand "cabal-name" {

72 buildInputs = [ nix-tools ];

76 buildInputs = [ nix-tools ];

73 } ''

77 } ''

74 cabal-name ${path} > $out

78 cabal-name ${path} > $out

75 '');

79 '');

76

80

77 hashPath = path:

81 hashPath = path:

78− builtins.readFile (evalPackages.runCommand "hash-path" { preferLocalBuild = true; }

82+ builtins.readFile (pkgs.runCommand "hash-path" { preferLocalBuild = true; }

79− "echo -n $(${evalPackages.nix}/bin/nix-hash --type sha256 --base32 ${path}) > $out");

83+ "echo -n $(${pkgs.nix}/bin/nix-hash --type sha256 --base32 ${path}) > $out");

80−in with evalPackages.lib;

84+in with pkgs.lib;

81concatMap (dep:

85concatMap (dep:

82 let

86 let

83 is-private = private dep.url;

87 is-private = private dep.url;

84− sha256 =

88+ sha256 = if dep.sha256 != null

85− if dep.sha256 != null then dep.sha256

89+ then dep.sha256

86− else if sha256map != null then sha256map."${dep.url}"."${dep.rev}"

90+ else lookupSha256 {

87− else null;

91+ location = dep.url;

92+ tag = dep.rev;

93+ };

88 branch = lookupBranch {

94 branch = lookupBranch {

89 location = dep.url;

95 location = dep.url;

90 tag = dep.rev;

96 tag = dep.rev;

91 };

97 };

92 pkgsrc =

98 pkgsrc =

93 if !is-private && sha256 != null

99 if !is-private && sha256 != null

94− then evalPackages.fetchgit {

100+ then pkgs.fetchgit {

95 inherit (dep) url rev;

101 inherit (dep) url rev;

96 inherit sha256;

102 inherit sha256;

97 }

103 }

98 else builtins.fetchGit ({

104 else builtins.fetchGit ({

99 inherit (dep) url rev;

105 inherit (dep) url rev;

100− } // evalPackages.lib.optionalAttrs (branch != null) { ref = branch; });

106+ } // pkgs.lib.optionalAttrs (branch != null) { ref = branch; });

101 in map (subdir: {

107 in map (subdir: {

102 name = cabalName "${pkgsrc}/${subdir}";

108 name = cabalName "${pkgsrc}/${subdir}";

103 inherit (dep) url rev;

109 inherit (dep) url rev;

lib/system-nixpkgs-map.nix+4−35

@@ -6,32 +6,16 @@ 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

20# -- linux

9# -- linux

21{ crypto = [ openssl ];

10{ crypto = [ openssl ];

22− "c++" = []; # no libc++

11+ "c++" = null; # no libc++

23− "stdc++" = gcclibs;

12+ "stdc++" = null;

24− "stdc++-6" = gcclibs;

13+ "stdc++-6" = null;

25− gcc_s_seh-1 = gcclibs;

26− gcc_s = gcclibs;

27− gcc = gcclibs;

28 ssl = [ openssl ];

14 ssl = [ openssl ];

29 z = [ zlib ];

15 z = [ zlib ];

30− m = []; # Included with ghc

31 pcap = [ libpcap ];

16 pcap = [ libpcap ];

32 pthread = null; # available by default

17 pthread = null; # available by default

33 GL = [ libGL ];

18 GL = [ libGL ];

34− GLEW = [ glew ];

35 GLU = [ libGLU ];

19 GLU = [ libGLU ];

36 alut = [ freealut ];

20 alut = [ freealut ];

37 X11 = with xorg; [ libX11 ];

21 X11 = with xorg; [ libX11 ];

@@ -51,7 +35,6 @@ in

51 util = [ utillinux ];

35 util = [ utillinux ];

52 magic = [ file ];

36 magic = [ file ];

53 pq = [ postgresql ];

37 pq = [ postgresql ];

54− libpq = [ postgresql ];

55 iconv = [ libiconv ];

38 iconv = [ libiconv ];

56 lapack = [ liblapack ];

39 lapack = [ liblapack ];

57 boost_atomic = [ boost ];

40 boost_atomic = [ boost ];

@@ -97,39 +80,25 @@ in

97 opencv = [ opencv3 ];

80 opencv = [ opencv3 ];

98 icuuc = [ icu ];

81 icuuc = [ icu ];

99 icui18n = [ icu ];

82 icui18n = [ icu ];

100− icu-i18n = [ icu ];

101 icudata = [ icu ];

83 icudata = [ icu ];

102 vulkan = [ vulkan-loader ];

84 vulkan = [ vulkan-loader ];

103 sodium = [ libsodium ];

85 sodium = [ libsodium ];

104 gfortran = [ gfortran.cc.lib ];

86 gfortran = [ gfortran.cc.lib ];

105− ssh2 = [ libssh2 ];

106− gpiod = [ libgpiod ];

107− png = [ libpng ];

108− jpeg = [ libjpeg ];

109− freenect_sync = [ freenect ];

110− FLAC = [ flac ];

111− mp3lame = [ lame ];

112− tag_c = [ taglib ];

113− jwt = [ libjwt ];

114− GeoIP = [ geoip ];

115− pulse-simple = [ libpulseaudio ];

116− oath = [ liboauth ];

117}

87}

118# -- windows

88# -- windows

119// { advapi32 = null; gdi32 = null; imm32 = null; msimg32 = null;

89// { advapi32 = null; gdi32 = null; imm32 = null; msimg32 = null;

120 shell32 = null; shfolder = null; shlwapi = null; user32 = null;

90 shell32 = null; shfolder = null; shlwapi = null; user32 = null;

121− ole32 = null; rpcrt4 = null;

122 winmm = null; userenv = null;

91 winmm = null; userenv = null;

123 kernel32 = null; ws2_32 = null;

92 kernel32 = null; ws2_32 = null;

124 # this should be bundled with gcc.

93 # this should be bundled with gcc.

125 # if it's not we have more severe

94 # if it's not we have more severe

126 # issues anyway.

95 # issues anyway.

96+ gcc_s_seh-1 = null;

127 ssl32 = null; eay32 = [ openssl ];

97 ssl32 = null; eay32 = [ openssl ];

128 iphlpapi = null; # IP Help API

98 iphlpapi = null; # IP Help API

129 msvcrt = null; # this is the libc

99 msvcrt = null; # this is the libc

130 Crypt32 = null;

100 Crypt32 = null;

131 mswsock = null;

101 mswsock = null;

132− bcrypt = null;

133 }

102 }

134# -- os x

103# -- os x

135# NB: these map almost 1:1 to the framework names

104# NB: these map almost 1:1 to the framework names

lib/system-pkgs.nix+18−1

@@ -9,8 +9,25 @@

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

12 # Base packages.

24 # Base packages.

13 pkgs

25 pkgs

14

26

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+

15 # Apply the mapping.

32 # Apply the mapping.

16− // import ./system-nixpkgs-map.nix pkgs

33+ // builtins.mapAttrs mapPackages (import ./system-nixpkgs-map.nix pkgs)

materialized/bootstrap/ghc8107/alex/.plan.nix/alex.nixdeleted−160

@@ -1,160 +0,0 @@

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.nixdeleted−69

@@ -1,69 +0,0 @@

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.nixdeleted−200

@@ -1,200 +0,0 @@

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.nixdeleted−75

@@ -1,75 +0,0 @@

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.nixdeleted−70

@@ -1,70 +0,0 @@

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.nixdeleted−47

@@ -1,47 +0,0 @@

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+18−34

@@ -3,34 +3,36 @@

3 {

4 packages = {

5 "ghc-prim".revision = (((hackage."ghc-prim")."0.5.2.0").revisions).default;

6− "array".revision = (((hackage."array")."0.5.2.0").revisions).default;

7− "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

8− "base".revision = (((hackage."base")."4.11.1.0").revisions).default;

9− "rts".revision = (((hackage."rts")."1.0").revisions).default;

10− "time".revision = (((hackage."time")."1.8.0.2").revisions).default;

11 "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;

6 "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;

12− "bytestring".revision = (((hackage."bytestring")."0.10.8.2").revisions).default;

7+ "rts".revision = (((hackage."rts")."1.0").revisions).default;

13− "containers".revision = (((hackage."containers")."0.5.11.0").revisions).default;

8+ "deepseq".revision = (((hackage."deepseq")."1.4.3.0").revisions).default;

14 "directory".revision = (((hackage."directory")."1.3.1.5").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;

13+ "time".revision = (((hackage."time")."1.8.0.2").revisions).default;

15 "filepath".revision = (((hackage."filepath")."1.4.2").revisions).default;

14 "filepath".revision = (((hackage."filepath")."1.4.2").revisions).default;

16− "deepseq".revision = (((hackage."deepseq")."1.4.3.0").revisions).default;

15+ "process".revision = (((hackage."process")."1.6.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;

17 };

18 };

18 compiler = {

19 compiler = {

19 version = "8.4.4";

20 version = "8.4.4";

20 nix-name = "ghc844";

21 nix-name = "ghc844";

21 packages = {

22 packages = {

22 "ghc-prim" = "0.5.2.0";

23 "ghc-prim" = "0.5.2.0";

23− "array" = "0.5.2.0";

24− "integer-gmp" = "1.0.2.0";

25− "base" = "4.11.1.0";

26− "rts" = "1.0";

27− "time" = "1.8.0.2";

28 "unix" = "2.7.2.2";

24 "unix" = "2.7.2.2";

29− "bytestring" = "0.10.8.2";

25+ "rts" = "1.0";

30− "containers" = "0.5.11.0";

26+ "deepseq" = "1.4.3.0";

31 "directory" = "1.3.1.5";

27 "directory" = "1.3.1.5";

28+ "containers" = "0.5.11.0";

29+ "bytestring" = "0.10.8.2";

30+ "base" = "4.11.1.0";

31+ "time" = "1.8.0.2";

32 "filepath" = "1.4.2";

33− "deepseq" = "1.4.3.0";

33+ "process" = "1.6.3.0";

34+ "array" = "0.5.2.0";

35+ "integer-gmp" = "1.0.2.0";

34 };

36 };

35 };

37 };

36 };

38 };

@@ -43,23 +45,5 @@

43 "alex" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

45 "alex" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

44 };

46 };

45 })

47 })

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− })

64 ];

48 ];

65 }

49 }

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+28−55

@@ -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− "array".revision = (((hackage."array")."0.5.2.0").revisions).default;

7+ "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;

8− "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

8+ "mtl".revision = (((hackage."mtl")."2.2.2").revisions).default;

9− "pretty".revision = (((hackage."pretty")."1.1.3.6").revisions).default;

10− "process".revision = (((hackage."process")."1.6.3.0").revisions).default;

11− "base".revision = (((hackage."base")."4.11.1.0").revisions).default;

12 "rts".revision = (((hackage."rts")."1.0").revisions).default;

9 "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;

13 "text".revision = (((hackage."text")."1.2.3.1").revisions).default;

15 "text".revision = (((hackage."text")."1.2.3.1").revisions).default;

14− "mtl".revision = (((hackage."mtl")."2.2.2").revisions).default;

16+ "Cabal".revision = (((hackage."Cabal")."2.2.0.1").revisions).default;

17+ "base".revision = (((hackage."base")."4.11.1.0").revisions).default;

15 "time".revision = (((hackage."time")."1.8.0.2").revisions).default;

18 "time".revision = (((hackage."time")."1.8.0.2").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;

21− "filepath".revision = (((hackage."filepath")."1.4.2").revisions).default;

22− "deepseq".revision = (((hackage."deepseq")."1.4.3.0").revisions).default;

23 "transformers".revision = (((hackage."transformers")."0.5.5.0").revisions).default;

19 "transformers".revision = (((hackage."transformers")."0.5.5.0").revisions).default;

24− "Cabal".revision = (((hackage."Cabal")."2.2.0.1").revisions).default;

20+ "filepath".revision = (((hackage."filepath")."1.4.2").revisions).default;

21+ "process".revision = (((hackage."process")."1.6.3.0").revisions).default;

22+ "pretty".revision = (((hackage."pretty")."1.1.3.6").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;

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− "array" = "0.5.2.0";

32+ "unix" = "2.7.2.2";

33− "integer-gmp" = "1.0.2.0";

33+ "mtl" = "2.2.2";

34− "pretty" = "1.1.3.6";

35− "process" = "1.6.3.0";

36− "base" = "4.11.1.0";

37 "rts" = "1.0";

34 "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";

38 "text" = "1.2.3.1";

40 "text" = "1.2.3.1";

39− "mtl" = "2.2.2";

41+ "Cabal" = "2.2.0.1";

42+ "base" = "4.11.1.0";

40 "time" = "1.8.0.2";

43 "time" = "1.8.0.2";

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";

46− "filepath" = "1.4.2";

47− "deepseq" = "1.4.3.0";

48 "transformers" = "0.5.5.0";

44 "transformers" = "0.5.5.0";

49− "Cabal" = "2.2.0.1";

45+ "filepath" = "1.4.2";

46+ "process" = "1.6.3.0";

47+ "pretty" = "1.1.3.6";

48+ "array" = "0.5.2.0";

49+ "integer-gmp" = "1.0.2.0";

50 };

51 };

52 };

@@ -59,32 +59,5 @@

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− })

89 ];

62 ];

90 }

63 }

materialized/bootstrap/ghc844/happy-1.19.12/default.nix+22−25

@@ -3,28 +3,40 @@

3 {

4 packages = {

5 "ghc-prim".revision = (((hackage."ghc-prim")."0.5.2.0").revisions).default;

6− "array".revision = (((hackage."array")."0.5.2.0").revisions).default;

6+ "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;

7− "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

8− "base".revision = (((hackage."base")."4.11.1.0").revisions).default;

9− "rts".revision = (((hackage."rts")."1.0").revisions).default;

10 "mtl".revision = (((hackage."mtl")."2.2.2").revisions).default;

7 "mtl".revision = (((hackage."mtl")."2.2.2").revisions).default;

11− "containers".revision = (((hackage."containers")."0.5.11.0").revisions).default;

8+ "rts".revision = (((hackage."rts")."1.0").revisions).default;

12 "deepseq".revision = (((hackage."deepseq")."1.4.3.0").revisions).default;

9 "deepseq".revision = (((hackage."deepseq")."1.4.3.0").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;

13+ "base".revision = (((hackage."base")."4.11.1.0").revisions).default;

14+ "time".revision = (((hackage."time")."1.8.0.2").revisions).default;

13 "transformers".revision = (((hackage."transformers")."0.5.5.0").revisions).default;

15 "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;

14 };

20 };

15 compiler = {

21 compiler = {

16 version = "8.4.4";

22 version = "8.4.4";

17 nix-name = "ghc844";

23 nix-name = "ghc844";

18 packages = {

24 packages = {

19 "ghc-prim" = "0.5.2.0";

25 "ghc-prim" = "0.5.2.0";

20− "array" = "0.5.2.0";

26+ "unix" = "2.7.2.2";

21− "integer-gmp" = "1.0.2.0";

22− "base" = "4.11.1.0";

23− "rts" = "1.0";

24 "mtl" = "2.2.2";

27 "mtl" = "2.2.2";

25− "containers" = "0.5.11.0";

28+ "rts" = "1.0";

26 "deepseq" = "1.4.3.0";

29 "deepseq" = "1.4.3.0";

30+ "directory" = "1.3.1.5";

31+ "containers" = "0.5.11.0";

32+ "bytestring" = "0.10.8.2";

33+ "base" = "4.11.1.0";

34+ "time" = "1.8.0.2";

27 "transformers" = "0.5.5.0";

35 "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";

28 };

40 };

29 };

41 };

30 };

42 };

@@ -37,20 +49,5 @@

37 "happy" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

49 "happy" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

38 };

50 };

39 })

51 })

40− ({ lib, ... }:

41− {

42− packages = {

43− "containers".components.library.planned = lib.mkOverride 900 true;

44− "ghc-prim".components.library.planned = lib.mkOverride 900 true;

45− "happy".components.exes."happy".planned = lib.mkOverride 900 true;

46− "transformers".components.library.planned = lib.mkOverride 900 true;

47− "integer-gmp".components.library.planned = lib.mkOverride 900 true;

48− "array".components.library.planned = lib.mkOverride 900 true;

49− "base".components.library.planned = lib.mkOverride 900 true;

50− "rts".components.library.planned = lib.mkOverride 900 true;

51− "mtl".components.library.planned = lib.mkOverride 900 true;

52− "deepseq".components.library.planned = lib.mkOverride 900 true;

53− };

54− })

55 ];

52 ];

56 }

53 }

materialized/bootstrap/ghc844/hscolour/default.nix+8−22

@@ -3,24 +3,24 @@

3 {

4 packages = {

5 "ghc-prim".revision = (((hackage."ghc-prim")."0.5.2.0").revisions).default;

6− "array".revision = (((hackage."array")."0.5.2.0").revisions).default;

7− "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

8− "base".revision = (((hackage."base")."4.11.1.0").revisions).default;

9 "rts".revision = (((hackage."rts")."1.0").revisions).default;

6 "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;

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;

11+ "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.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− "array" = "0.5.2.0";

19− "integer-gmp" = "1.0.2.0";

20− "base" = "4.11.1.0";

21 "rts" = "1.0";

18 "rts" = "1.0";

22− "containers" = "0.5.11.0";

23 "deepseq" = "1.4.3.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";

23+ "integer-gmp" = "1.0.2.0";

24 };

25 };

26 };

@@ -29,19 +29,5 @@

29 modules = [

30 ({ lib, ... }:

31 { packages = { "hscolour" = { flags = {}; }; }; })