iko/ghcjs-patch-master..c52845f · 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+14−30

@@ -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+ ghcide-020 = tool compiler-nix-name "ghcide" "0.2.0";

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

25+ cabal-32 = tool compiler-nix-name "cabal" "3.2.0.0";

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

26+ hls-051 = tool compiler-nix-name "haskell-language-server" "0.5.1";

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.

@@ -45,16 +33,16 @@ in rec {

45 # are not pure).

33 # are not pure).

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

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

41 inherit (haskell) update-index-state-hashes;

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 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+91−271

@@ -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+{ stdenv, buildPackages, ghc, lib, gobject-introspection ? null, haskellLib, makeConfigFiles, haddockBuilder, ghcForComponent, hsPkgs, compiler, runCommand, libffi, gmp, zlib, ncurses, numactl, nodejs }:

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,18 @@ 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−

52−, ghcOptions ? component.ghcOptions

53−, contentAddressed ? component.contentAddressed

54

42

55# Options for Haddock generation

43# Options for Haddock generation

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

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

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

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

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

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

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

47, 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`

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

61, setupHaddockFlags ? component.setupHaddockFlags

49, setupHaddockFlags ? component.setupHaddockFlags

62

50

63# Profiling

51# Profiling

64, enableLibraryProfiling ? component.enableLibraryProfiling

52, enableLibraryProfiling ? component.enableLibraryProfiling

65−, enableProfiling ? component.enableProfiling

53+, enableExecutableProfiling ? component.enableExecutableProfiling

66, profilingDetail ? component.profilingDetail

54, profilingDetail ? component.profilingDetail

67

55

68# Coverage

56# Coverage

@@ -83,62 +71,24 @@ let self =

83

71

84# LLVM

72# LLVM

85, useLLVM ? ghc.useLLVM

73, useLLVM ? ghc.useLLVM

86−, smallAddressSpace ? false

87

74

88}@drvArgs:

75}@drvArgs:

89

76

90let

77let

91− componentForSetup =

92− if configureAllComponents

93− then allComponent

94− else component;

95−

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

97− enableDWARF = drvArgs.enableDWARF or false

98− && stdenv.hostPlatform.isLinux

99− && !haskellLib.isCrossHost

100− && !stdenv.hostPlatform.isMusl

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

102−

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

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

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

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

107−

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

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

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

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

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

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

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

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

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

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

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

116− cleanSrc = haskellLib.rootAndSubDir (if canCleanSource

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

81+ else haskellLib.cleanCabalComponent package component src;

118− else

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

120− # from triggering a rebuild of this one.

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

122− # in the `subDir`.

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

124− then haskellLib.cleanSourceWith {

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

126− src = src.origSrc;

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

128− inherit (src) filter;

129− }

130− else src);

131

82

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

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

133

84

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

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

135

86

136− needsProfiling = enableProfiling || enableLibraryProfiling;

87+ needsProfiling = enableExecutableProfiling || enableLibraryProfiling;

137

88

138 configFiles = makeConfigFiles {

89 configFiles = makeConfigFiles {

139− component = componentForSetup;

140 inherit (package) identifier;

90 inherit (package) identifier;

141− inherit fullName flags needsProfiling enableDWARF;

91+ inherit component fullName flags needsProfiling;

142 };

92 };

143

93

144 enableFeature = enable: feature:

94 enableFeature = enable: feature:

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

148

98

149 finalConfigureFlags = lib.concatStringsSep " " (

99 finalConfigureFlags = lib.concatStringsSep " " (

150 [ "--prefix=$out"

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

101+ "${haskellLib.componentTarget componentId}"

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

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

166 ] ++ commonConfigureFlags);

103 ] ++ commonConfigureFlags);

167

104

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

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

@@ -180,7 +117,7 @@ let

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

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

181 ] ++

118 ] ++

182 # BINTOOLS

119 # BINTOOLS

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

120+ (if stdenv.hostPlatform.isLinux

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

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

185 then [

122 then [

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

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

@@ -197,7 +134,7 @@ let

197 (disableFeature dontStrip "executable-stripping")

134 (disableFeature dontStrip "executable-stripping")

198 (disableFeature dontStrip "library-stripping")

135 (disableFeature dontStrip "library-stripping")

199 (enableFeature enableLibraryProfiling "library-profiling")

136 (enableFeature enableLibraryProfiling "library-profiling")

200− (enableFeature enableProfiling "profiling")

137+ (enableFeature enableExecutableProfiling "executable-profiling")

201 (enableFeature enableStatic "static")

138 (enableFeature enableStatic "static")

202 (enableFeature enableShared "shared")

139 (enableFeature enableShared "shared")

203 (enableFeature doCoverage "coverage")

140 (enableFeature doCoverage "coverage")

@@ -205,13 +142,13 @@ let

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

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

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

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

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

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

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

209 # component.

146 # component.

210 "--disable-executable-dynamic"

147 "--disable-executable-dynamic"

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

148 "--ghc-option=-optl=-pthread"

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

149 "--ghc-option=-optl=-static"

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

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

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

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

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

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

216 ++ lib.optionals haskellLib.isCrossHost (

153 ++ lib.optionals haskellLib.isCrossHost (

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

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

@@ -220,21 +157,14 @@ let

220 ++ (ghc.extraConfigureFlags or [])

157 ++ (ghc.extraConfigureFlags or [])

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

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

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

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

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

160+ ++ lib.optional enableDWARF "--ghc-option=-g"

224 ++ lib.optionals useLLVM [

161 ++ lib.optionals useLLVM [

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

162 "--ghc-option=-fPIC" "--gcc-option=-fPIC"

226 ]

163 ]

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

228− ++ lib.optional (

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

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

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

232− haskellLib.isCrossHost

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

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

235− "--ghc-options=-j1"

236 );

164 );

237

165

166+ setupGhcOptions = lib.optional (package.ghcOptions != null) '' --ghc${lib.optionalString (stdenv.hostPlatform.isGhcjs) "js"}-options="${package.ghcOptions}"'';

167+

238 executableToolDepends =

168 executableToolDepends =

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

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

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

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

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

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

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

246 shellWrappers = ghcForComponent {

176 shellWrappers = ghcForComponent {

247 componentName = fullName;

177 componentName = fullName;

248− inherit configFiles enableDWARF;

178+ inherit configFiles;

249− inherit (component) plugins;

250 };

179 };

251

180

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

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

@@ -261,7 +190,7 @@ let

261

190

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

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

263 commonAttrs = {

192 commonAttrs = {

264− src = cleanSrc.root;

193+ src = cleanSrc;

265

194

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

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

267 LC_ALL = "en_US.UTF-8";

196 LC_ALL = "en_US.UTF-8";

@@ -270,27 +199,14 @@ let

270

199

271 SETUP_HS = setup + /bin/Setup;

200 SETUP_HS = setup + /bin/Setup;

272

201

273− prePatch =

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

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

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

277− # will happen when:

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

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

280− # include an `origSubDir`

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

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

283− ''

284− ) +

285− (if cabalFile != null

202+ prePatch = if (cabalFile != null)

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

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

287− else

204+ else

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

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

289− # (compiled with a fixed GHC version)

206+ # (compiled with a fixed GHC version)

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

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

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

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

292− ''

209+ '';

293− );

294 }

210 }

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

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

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

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

@@ -310,20 +226,14 @@ let

310

226

311 haddock = haddockBuilder {

227 haddock = haddockBuilder {

312 inherit componentId component package flags commonConfigureFlags

228 inherit componentId component package flags commonConfigureFlags

313− commonAttrs revision doHaddock

229+ commonAttrs revision setupGhcOptions doHaddock

314 doHoogle hyperlinkSource quickjump setupHaddockFlags

230 doHoogle hyperlinkSource quickjump setupHaddockFlags

315 needsProfiling configFiles preHaddock postHaddock pkgconfig;

231 needsProfiling configFiles preHaddock postHaddock pkgconfig;

316

232

317 componentDrv = drv;

233 componentDrv = drv;

318 };

234 };

319

235

320− contentAddressedAttrs = lib.optionalAttrs contentAddressed {

321− __contentAddressed = true;

322− outputHashMode = "recursive";

323− outputHashAlgo = "sha256";

324− };

325−

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

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

327 pname = nameOnly;

237 pname = nameOnly;

328 inherit (package.identifier) version;

238 inherit (package.identifier) version;

329

239

@@ -335,13 +245,10 @@ let

335 passthru = {

245 passthru = {

336 inherit (package) identifier;

246 inherit (package) identifier;

337 config = component;

247 config = component;

338− srcSubDir = cleanSrc.subDir;

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

340− inherit configFiles executableToolDepends exeName enableDWARF;

248+ inherit configFiles executableToolDepends cleanSrc exeName;

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

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

342 env = shellWrappers;

250 env = shellWrappers;

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

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

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

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

252 } // lib.optionalAttrs (haskellLib.isLibrary componentId) ({

346 inherit haddock;

253 inherit haddock;

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

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

@@ -354,30 +261,22 @@ let

354 meta = {

261 meta = {

355 homepage = package.homepage or "";

262 homepage = package.homepage or "";

356 description = package.synopsis or "";

263 description = package.synopsis or "";

357− license = haskellLib.cabalToNixpkgsLicense package.license;

264+ license =

265+ let

266+ license-map = import ../lib/cabal-licenses.nix lib;

267+ in license-map.${package.license} or

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

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

269+ platforms = if platforms == null then stdenv.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 };

270 };

368

271

369 propagatedBuildInputs =

272 propagatedBuildInputs =

370 frameworks # Frameworks will be needed at link time

273 frameworks # Frameworks will be needed at link time

371 # Not sure why pkgconfig needs to be propagatedBuildInputs but

274 # Not sure why pkgconfig needs to be propagatedBuildInputs but

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

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

373− ++ builtins.concatLists pkgconfig

276+ ++ builtins.concatLists pkgconfig;

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

375− (lib.flatten component.libs

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

377

277

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

379− (lib.flatten component.libs

278+ buildInputs = component.libs

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

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

381

280

382 nativeBuildInputs =

281 nativeBuildInputs =

383 [shellWrappers buildPackages.removeReferencesTo]

282 [shellWrappers buildPackages.removeReferencesTo]

@@ -385,24 +284,14 @@ let

385

284

386 outputs = ["out" ]

285 outputs = ["out" ]

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

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

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

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

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

288+

390−

289+ configurePhase =

391− prePatch =

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

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

394− export HOME=$(mktemp -d)

395− '') +

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

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

398− '') +

399 (lib.optionalString keepSource ''

290 (lib.optionalString keepSource ''

400 cp -r . $source

291 cp -r . $source

401 cd $source

292 cd $source

402 chmod -R +w .

293 chmod -R +w .

403− '') + commonAttrs.prePatch;

294+ '') + ''

404−

405− configurePhase = ''

406 runHook preConfigure

295 runHook preConfigure

407 echo Configure flags:

296 echo Configure flags:

408 printf "%q " ${finalConfigureFlags}

297 printf "%q " ${finalConfigureFlags}

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

411 runHook postConfigure

300 runHook postConfigure

412 '';

301 '';

413

302

414− buildPhase =

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

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

305+ # 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}

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

442− runHook postBuild

307+ runHook postBuild

443− '');

308+ '';

444

309

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

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

446 #

311 #

@@ -454,65 +319,49 @@ let

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

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

455 in ''

320 in ''

456 runHook preInstall

321 runHook preInstall

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

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

458− setupInstallFlags

459− ++ lib.optional configureAllComponents

460− (haskellLib.componentTarget componentId)

461− )}

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

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

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

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

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

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

326+ if [ -d "${name}.conf" ]; then

327+ for pkg in ${name}.conf/*; do

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

329+ done

330+ elif [ -e "${name}.conf" ]; then

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

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

332+ fi

466

333

467 mkdir -p $out/exactDep

334 mkdir -p $out/exactDep

468 touch $out/exactDep/configure-flags

335 touch $out/exactDep/configure-flags

469 touch $out/exactDep/cabal.config

336 touch $out/exactDep/cabal.config

470 touch $out/envDep

337 touch $out/envDep

471

338

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

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

474− then ''

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

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

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

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

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

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

478− else

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

480− exit 1

481− fi

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

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

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

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

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

485− else

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

487− exit 1

488− fi

489− ''

490− else

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

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

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

493− (''

345+ # query should be safe.

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

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

347+ else

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

349+ exit 0

350+ fi

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

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

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

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

497− ''

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

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

500− # name added.

501− + ''

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

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

503− else

354+ else

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

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

505− exit 1

356+ exit 0

506− fi

357+ fi

507− '')

508− }

509 ''}

358 ''}

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

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

511 mkdir -p $out/bin

360 mkdir -p $out/bin

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

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

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

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

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

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

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

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

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

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

517 '' else ''

366 '' else ''

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

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

@@ -520,22 +369,22 @@ let

520 fi

369 fi

521 '')

370 '')

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

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

523− + (lib.optionalString enableSeparateDataOutput ''

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

524− mkdir -p $data

525− '')

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

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

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

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

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

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

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

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

530 done

377 done

531− ''

532 # symlink all .dlls into the local directory.

378 # symlink all .dlls into the local directory.

533− + ''

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

534− for p in $pkgsHostTargetAsString; do

380+ # to symlink over dlls as needed.

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

381+ echo "Symlink library dependencies..."

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

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

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

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

385+ fi

537 done

386 done

538− ''))

387+ '')

539 + (lib.optionalString doCoverage ''

388 + (lib.optionalString doCoverage ''

540 mkdir -p $out/share

389 mkdir -p $out/share

541 cp -r dist/hpc $out/share

390 cp -r dist/hpc $out/share

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

543 '')

392 '')

544 }

393 }

545 runHook postInstall

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

395+ '' + (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

396+ 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) ''

397 '') + (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}.

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

569 '');

399 '');

570

400

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

401 shellHook = ''

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

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

583 ${shellHookApplied}

403 ${shellHookApplied}

@@ -590,7 +410,7 @@ let

590 preBuild postBuild

410 preBuild postBuild

591 preInstall postInstall;

411 preInstall postInstall;

592 }

412 }

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

413+ // lib.optionalAttrs (hardeningDisable != []) {

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

414+ inherit hardeningDisable;

595 });

415 });

596in drv; in self)

416in drv; in self)

builder/default.nix+16−24

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

@@ -83,7 +75,7 @@ in {

83 # Build a Haskell package from its config.

75 # Build a Haskell package from its config.

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

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

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

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

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

78+ inherit haskellLib ghc comp-builder setup-builder;

87 };

79 };

88

80

89 inherit shellFor makeConfigFiles;

81 inherit shellFor makeConfigFiles;

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

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

7# database.

8

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

10−}@defaults:

10+}:

11

12{ componentName # Full derivation name of the component

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

14, postInstall ? ""

15−, enableDWARF

16−, plugins

17}:

15}:

18

16

19let

17let

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

21−

22 inherit (configFiles) targetPrefix ghcCommand ghcCommandCaps packageCfgDir;

18 inherit (configFiles) targetPrefix ghcCommand ghcCommandCaps packageCfgDir;

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

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

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

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

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

38 ''

34 ''

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

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

40

36

41− ''

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

37+ # Start with a ghc...

43− + ''

44 mkdir -p $out/bin

38 mkdir -p $out/bin

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

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

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

46 rm -rf ${libDir}/*/

41 rm -rf ${libDir}/*/

47− ''

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

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

49− + ''

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

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

51− ''

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

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

53− + ''

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

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

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

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

56 fi

47 fi

57− ''

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

48+ # ... and node modules ...

59− + ''

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

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

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

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

62 fi

51 fi

63− ''

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

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

65− + ''

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

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

67

54

68− ''

55+ # Wrap compiler executables with correct env variables.

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

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

57

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

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

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

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

107 rm -f $out/bin/$prg

60 rm -f $out/bin/$prg

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

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

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

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

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

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

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

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

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

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

115 fi

67 fi

116 done

68 done

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

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

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

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

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

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

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

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

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

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

128 fi

79 fi

129 done

80 done

130

81

131− ''

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

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

133− + ''

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

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

135 rm -f $out/bin/haddock

84 rm -f $out/bin/haddock

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

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

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

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

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

139 fi

88 fi

140

89

141− ''

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

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

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

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

144− + ''

92+

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

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

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

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

147 rm -f $out/bin/$prg

95 rm -f $out/bin/$prg

builder/haddock-builder.nix+2−4

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

16, hyperlinkSource

17, quickjump

18, setupHaddockFlags

19+, setupGhcOptions

19

20

20, needsProfiling

21, needsProfiling

21, componentDrv

22, componentDrv

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

41 inherit (package) identifier;

42 inherit (package) identifier;

42 inherit component fullName flags needsProfiling;

43 inherit component fullName flags needsProfiling;

43 chooseDrv = p: p.haddock;

44 chooseDrv = p: p.haddock;

44− inherit (componentDrv) enableDWARF;

45 };

46

47 finalConfigureFlags = lib.concatStringsSep " " (

@@ -55,8 +55,6 @@ let

55 shellWrappers = ghcForComponent {

56 componentName = fullName;

57 configFiles = docsConfigFiles;

58− inherit (componentDrv) enableDWARF;

59− inherit (component) plugins;

60 };

58 };

61

59

62 drv = stdenv.mkDerivation (commonAttrs // {

60 drv = stdenv.mkDerivation (commonAttrs // {

@@ -110,7 +108,7 @@ let

110 ${lib.optionalString doHoogle "--hoogle"} \

108 ${lib.optionalString doHoogle "--hoogle"} \

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

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

112 ${lib.optionalString quickjump "--quickjump"} \

110 ${lib.optionalString quickjump "--quickjump"} \

113− ${lib.concatStringsSep " " setupHaddockFlags}

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

114 }

112 }

115 runHook postHaddock

113 runHook postHaddock

116 '';

114 '';

builder/hspkg-builder.nix+14−44

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

1−{ pkgs, buildPackages, stdenv, lib, haskellLib, ghc, compiler-nix-name, fetchurl, runCommand, comp-builder, setup-builder }:

1+{ pkgs, buildPackages, stdenv, lib, haskellLib, ghc, fetchurl, runCommand, comp-builder, setup-builder }:

2

3config:

4{ flags

@@ -23,44 +23,21 @@ 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" ''

41−

34+ import Distribution.Simple

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

35+ main = defaultMain

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

36+ '';

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

45− # version of Cabal bundled with GHC).

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

47−

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

49− # to build itseld would cause infinite recursion.

50− useCabalFromCabalInstall =

51− # `cabalFromCabalInstall` is not cross compiled

52− stdenv.buildPlatform != stdenv.hostPlatform

53− ||

54− # These are the dependencies of `Cabal`

55− !builtins.elem package.identifier.name

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

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

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

59−

60− defaultSetup = setup-builder ({

37+ defaultSetup = setup-builder {

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

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

62 component = {

39 component = {

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

40+ depends = config.setup-depends;

64 libs = [];

41 libs = [];

65 frameworks = [];

42 frameworks = [];

66 doExactConfig = false;

43 doExactConfig = false;

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

88 synopsis = null;

65 synopsis = null;

89 license = "MIT";

66 license = "MIT";

90 };

67 };

91− src = null;

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

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

93 mkdir $out

69 mkdir $out

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

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

95 '';

71 '';

96 inherit defaultSetupSrc;

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

73+ };

104

74

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

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

106 # cat ${defaultSetupSrc} > Setup.hs

76 # cat ${defaultSetupSrc} > Setup.hs

@@ -120,18 +90,18 @@ let

120 inherit (pkg) preUnpack postUnpack;

90 inherit (pkg) preUnpack postUnpack;

121 };

91 };

122

92

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

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

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

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

125 shellHook

95 shellHook

126 ;

96 ;

127 };

97 };

128

98

129in rec {

99in rec {

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

100+ components = haskellLib.applyComponents buildComp pkg;

131 checks = pkgs.recurseIntoAttrs (builtins.mapAttrs

101 checks = pkgs.recurseIntoAttrs (builtins.mapAttrs

132 (_: d: haskellLib.check d)

102 (_: d: haskellLib.check d)

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

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

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

104+ inherit (package) identifier detailLevel isLocal;

135 inherit setup cabalFile;

105 inherit setup cabalFile;

136 isHaskell = true;

106 isHaskell = true;

137 inherit src;

107 inherit src;

builder/make-config-files.nix+12−36

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

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

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

2

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

3+{ identifier, component, fullName, flags ? {}, needsProfiling ? 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;

11−

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

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

13 echo ${lib.concatStringsSep " " (map (x: "--${field}=${x}") xs)} >> $out/configure-flags

7 echo ${lib.concatStringsSep " " (map (x: "--${field}=${x}") xs)} >> $out/configure-flags

14 echo "${field}: ${lib.concatStringsSep " " xs}" >> $out/cabal.config

8 echo "${field}: ${lib.concatStringsSep " " xs}" >> $out/cabal.config

@@ -53,10 +47,9 @@ let

53 # TODO investigate why this is needed

47 # TODO investigate why this is needed

54 # TODO find out why p ? configFiles helps (for instance for `R1909.aarch64-unknown-linux-gnu.tests.cabal-22.run.x86_64-linux`)

48 # TODO find out why p ? configFiles helps (for instance for `R1909.aarch64-unknown-linux-gnu.tests.cabal-22.run.x86_64-linux`)

55 libDeps = map chooseDrv (

49 libDeps = map chooseDrv (

56− (if enableDWARF then (x: map (p: p.dwarf or p) x) else x: x)

57− ((if needsProfiling then (x: map (p: p.profiled or p) x) else x: x)

50+ (if needsProfiling then (x: map (p: p.profiled or p) x) else x: x)

58 (lib.filter (p: (p ? configFiles) && p.configFiles.targetPrefix == ghc.targetPrefix)

51 (lib.filter (p: (p ? configFiles) && p.configFiles.targetPrefix == ghc.targetPrefix)

59− (map getLibComponent component.depends)))

52+ (map getLibComponent component.depends))

60 );

53 );

61 cfgFiles =

54 cfgFiles =

62 let xs = map

55 let xs = map

@@ -85,44 +78,27 @@ let

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

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

86

79

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

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

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

81+ "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);

82+ "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);

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

96 })}

84 })}

97

85

98 ghc=${ghc}

86 ghc=${ghc}

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

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

100 ''

88 ''

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

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

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

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

103 done

91 done

104 ''}

92 ''}

105

93

106 for l in "${cfgFiles}"; do

94 for l in "${cfgFiles}"; do

107 if [ -n "$l" ]; then

95 if [ -n "$l" ]; then

108− files=("$l/${packageCfgDir}/"*.conf)

109− if (( ''${#files[@]} )); then

110− cp -f "''${files[@]}" $out/${packageCfgDir}

96+ cp -f "$l/${packageCfgDir}/"*.conf $out/${packageCfgDir}

111− else

112− echo "$l/${packageCfgDir} didn't contain any *.conf files!"

113− exit 1

114− fi

115 fi

97 fi

116 done

98 done

117 for l in "${libs}"; do

99 for l in "${libs}"; do

118 if [ -n "$l" ]; then

100 if [ -n "$l" ]; then

119− files=("$l/package.conf.d/"*.conf)

120− if (( ''${#files[@]} )); then

121− cp -f "''${files[@]}" $out/${packageCfgDir}

101+ cp -f "$l/package.conf.d/"*.conf $out/${packageCfgDir}

122− else

123− echo "$l/package.conf.d didn't contain any *.conf files!"

124− exit 1

125− fi

126 fi

102 fi

127 done

103 done

128

104

@@ -157,13 +133,13 @@ let

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

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

158 ''}

134 ''}

159 done

135 done

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

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

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

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

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

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

163 fi

139 fi

164 done

140 done

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

141 '' + lib.optionalString component.doExactConfig ''

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

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

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

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

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

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

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

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

builder/setup-builder.nix+18−33

@@ -1,29 +1,21 @@

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

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

2

3−let self =

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

3+{ component, package, name, src, flags ? {}, revision ? null, patches ? [], defaultSetupSrc

5, preUnpack ? component.preUnpack, postUnpack ? component.postUnpack

4, preUnpack ? component.preUnpack, postUnpack ? component.postUnpack

6, prePatch ? null, postPatch ? null

5, prePatch ? null, postPatch ? null

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

6, preBuild ? component.preBuild , postBuild ? component.postBuild

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

7, preInstall ? component.preInstall , postInstall ? component.postInstall

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

8+, cleanSrc ? haskellLib.cleanCabalComponent package component src

10−, nonReinstallablePkgs ? defaults.nonReinstallablePkgs

9+}:

11−, smallAddressSpace ? false

12−}@drvArgs:

13

10

14let

11let

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

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

17−

18− cleanSrc' = haskellLib.rootAndSubDir cleanSrc;

19−

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

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

21

13

22 includeGhcPackage = lib.any (p: p.identifier.name == "ghc") component.depends;

14 includeGhcPackage = lib.any (p: p.identifier.name == "ghc") component.depends;

23

15

24 configFiles = makeSetupConfigFiles {

16 configFiles = makeSetupConfigFiles {

25 inherit (package) identifier;

17 inherit (package) identifier;

26− inherit fullName flags component enableDWARF nonReinstallablePkgs;

18+ inherit fullName flags component;

27 };

19 };

28 hooks = haskellLib.optionalHooks {

20 hooks = haskellLib.optionalHooks {

29 inherit

21 inherit

@@ -43,7 +35,7 @@ let

43 drv =

35 drv =

44 stdenv.mkDerivation ({

36 stdenv.mkDerivation ({

45 name = "${ghc.targetPrefix}${fullName}";

37 name = "${ghc.targetPrefix}${fullName}";

46− src = cleanSrc'.root;

38+ src = cleanSrc;

47 buildInputs = component.libs

39 buildInputs = component.libs

48 ++ component.frameworks

40 ++ component.frameworks

49 ++ builtins.concatLists component.pkgconfig;

41 ++ builtins.concatLists component.pkgconfig;

@@ -52,19 +44,18 @@ let

52 passthru = {

44 passthru = {

53 inherit (package) identifier;

45 inherit (package) identifier;

54 config = component;

46 config = component;

55− srcSubDir = cleanSrc'.subDir;

56− srcSubDirPath = cleanSrc'.root + cleanSrc'.subDir;

57− cleanSrc = cleanSrc';

58− inherit configFiles;

47+ inherit configFiles cleanSrc;

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

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

61 };

48 };

62

49

63 meta = {

50 meta = {

64 homepage = package.homepage or "";

51 homepage = package.homepage or "";

65 description = package.synopsis or "";

52 description = package.synopsis or "";

66− license = haskellLib.cabalToNixpkgsLicense package.license;

53+ license =

54+ let

55+ license-map = import ../lib/cabal-licenses.nix lib;

56+ in license-map.${package.license} or

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

67− platforms = if component.platforms == null then lib.platforms.all else component.platforms;

58+ platforms = if component.platforms == null then stdenv.lib.platforms.all else component.platforms;

68 };

59 };

69

60

70 phases = ["unpackPhase" "patchPhase" "buildPhase" "installPhase"];

61 phases = ["unpackPhase" "patchPhase" "buildPhase" "installPhase"];

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

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

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

77 if [ -f $f ]; then

68 if [ -f $f ]; then

78 echo Compiling package $f

69 echo Compiling package $f

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

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

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

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

72+ setup=$(pwd)/Setup

81 fi

73 fi

82 done

74 done

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

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

84− runHook postBuild

76+ runHook preBuild

85 '';

77 '';

86

78

87 installPhase = ''

79 installPhase = ''

@@ -91,14 +83,7 @@ let

91 runHook postInstall

83 runHook postInstall

92 '';

84 '';

93 }

85 }

94− // (lib.optionalAttrs (cleanSrc'.subDir != "") {

95− prePatch =

96− # If the package is in a sub directory `cd` there first

97− ''

98− cd ${lib.removePrefix "/" cleanSrc'.subDir}

99− '';

100− })

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

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

102 // hooks

87 // hooks

103 );

88 );

104−in drv; in self

89+in drv

builder/shell-for.nix+45−88

@@ -1,23 +1,25 @@

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

1+{ lib, stdenv, 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

5 # dependencies will be included in the shell's `ghc-pkg list`.

6+ packages ? ps:

7+ let

6− packages ? ps: builtins.attrValues (haskellLib.selectLocalPackages ps)

8+ selected = haskellLib.selectLocalPackages ps;

9+ in

10+ builtins.trace ("Shell for " + toString (builtins.attrNames selected))

11+ (builtins.attrValues selected)

7 # `components` function selects components that will be worked on in the shell itself.

12 # `components` function selects components that will be worked on in the shell itself.

8 # By default `shellFor` will include the dependencies of all of the components

13 # By default `shellFor` will include the dependencies of all of the components

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

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

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

11 # to select those.

16 # to select those.

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

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

13 # Additional packages to be added unconditionally

18 # Additional packages to be added unconditionally

14, additional ? _: []

19, additional ? _: []

15, withHoogle ? true

20, withHoogle ? true

16−, withHaddock ? withHoogle

17, exactDeps ? false

21, exactDeps ? false

18, tools ? {}

22, tools ? {}

19−, packageSetupDeps ? true

20−, enableDWARF ? false

21, ... } @ args:

23, ... } @ args:

22

24

23let

25let

@@ -26,69 +28,50 @@ let

26

28

27 selectedPackages = packages hsPkgs;

29 selectedPackages = packages hsPkgs;

28 additionalPackages = additional hsPkgs;

30 additionalPackages = additional hsPkgs;

29− directlySelectedComponents = components hsPkgs;

31+ selectedComponents = components hsPkgs;

30

32

33+ # The configs of all the selected components

34+ selectedConfigs = map (c: c.config) selectedComponents ++ map (p: p.setup.config) selectedPackages;

35+

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

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

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

39+

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

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

32 #

41 #

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

42+ # 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;

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

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

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

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

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

47 #

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

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

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

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

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

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

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

53+ # than the packages.

50

54

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

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

57+ removeSelectedPackages =

58+ # All the identifiers of the selected packages

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

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

51

61

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

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

71 removeSelectedInputs =

63 removeSelectedInputs =

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

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

65+ let selectedPackageComponents = lib.concatMap haskellLib.getAllComponents selectedPackages;

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

73

67

74− # The configs of all the selected components.

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

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

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

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

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

80−

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

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

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

84−

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

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

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

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

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

87− ++ additionalPackages;

88

71

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

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

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

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

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

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

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

93 systemInputs = removeSelectedInputs (lib.concatMap

76 systemInputs = removeSelectedInputs (lib.concatMap

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

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

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

99 component = {

82 component = {

100 depends = packageInputs;

83 depends = packageInputs;

101 libs = [];

84 libs = [];

102− pkgconfig = [];

103 frameworks = [];

85 frameworks = [];

104 doExactConfig = false;

86 doExactConfig = false;

105 };

87 };

106 configFiles = makeConfigFiles {

88 configFiles = makeConfigFiles {

107 fullName = args.name or name;

89 fullName = args.name or name;

108 identifier.name = name;

90 identifier.name = name;

109− inherit component enableDWARF;

91+ inherit component;

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

111 };

92 };

112 ghcEnv = ghcForComponent {

93 ghcEnv = ghcForComponent {

113 inherit configFiles;

94 inherit configFiles;

@@ -115,8 +96,6 @@ let

115 postInstall = lib.optionalString withHoogle' ''

96 postInstall = lib.optionalString withHoogle' ''

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

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

117 '';

98 '';

118− inherit enableDWARF;

119− plugins = [];

120 };

99 };

121

100

122 hoogleIndex = let

101 hoogleIndex = let

@@ -133,48 +112,26 @@ let

133 # inherit (hsPkgs) hoogle;

112 # inherit (hsPkgs) hoogle;

134 } // (

113 } // (

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

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

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

115+ 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 }

116 }

143 ));

117 ));

144

118

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

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

146in

120in

147− mkShell (mkDrvArgs // {

121+ stdenv.mkDerivation (mkDrvArgs // {

148 name = mkDrvArgs.name or name;

122 name = mkDrvArgs.name or name;

149

123

150 buildInputs = systemInputs

124 buildInputs = systemInputs

151− ++ mkDrvArgs.buildInputs or [];

125+ ++ mkDrvArgs.buildInputs or []

126+ ++ lib.optional withHoogle' hoogleIndex;

152 nativeBuildInputs = [ ghcEnv ]

127 nativeBuildInputs = [ ghcEnv ]

153 ++ nativeBuildInputs

128 ++ nativeBuildInputs

154 ++ mkDrvArgs.nativeBuildInputs or []

129 ++ mkDrvArgs.nativeBuildInputs or []

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

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

156− # If this shell is a cross compilation shell include

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

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

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

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

161− exec cabal \

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

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

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

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

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

167− --with-ghcjs=${ghcEnv.targetPrefix}ghc \

168− --with-ghcjs-pkg=${ghcEnv.targetPrefix}ghc-pkg \

169− --ghcjs \

170− ''} $(builtin type -P "${ghcEnv.targetPrefix}pkg-config" &> /dev/null && echo "--with-pkg-config=${ghcEnv.targetPrefix}pkg-config") \

171− "$@"

172− '');

173 phases = ["installPhase"];

131 phases = ["installPhase"];

174− installPhase = ''

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

176− echo $nativeBuildInputs $buildInputs > $out

132+ installPhase = "echo $nativeBuildInputs $buildInputs > $out";

177− '';

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

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

178

135

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

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

180 # the correct global package DB.

137 # the correct global package DB.

changelog.md−101

@@ -1,107 +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

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

63− (ghc >=8.10.2).

64−* Pass `enableDWARF` to `shellFor` for to get a shell where all the

65− components are the `.dwarf` ones.

66−

67−## Feb 18, 2021

68−* `ghcOptions` has been moved from package and is now a list of strings.

69− old: packages.x.package.ghcOptions = "someGHCoption";

70− new: packages.x.ghcOptions = ["someGHCoption"];

71− To specify ghcOptions for all packages:

72− ghcOptions = ["someGHCoption"];

73− For a single component:

74− packages.x.compoents.library.ghcOptions = ["someGHCoption"];

75−

76−## Feb 8, 2021

77−* Removed older versions of haskell-language-server from custom-tools

78− (0.8.0 is in hackage so we can still get that version).

79−

80−## Jan 14, 2021

81−* Added support for cross package refs (with a project). Relative

82− directory references between packages within a project should now

83− work.

84−* Added `includeSiblings` to `cleanSourceWith`. When `true` it

85− prevents the `subDir` arg from causing filtering of other directories.

86−* Added `keepGitDir` to `cleanGit` to allow `.git` directory to be kept

87− (useful for components that use the `githash` package).

88−

89−## Nov 26, 2020

90−* Renamed `otherShells` arg for `shellFor` to `inputsFrom

91−

92−## Nov 25, 2020

93−* The `shellFor` `makeConfigFiles` `ghcWithHoogle` and `ghcWithPackages`

94− functions have been removed from `project.hsPkgs`. Instead access

95− them from `project` itself (e.g. change `p.hsPkgs.shellFor` to `p.shellFor`).

96−* The reflex-platform like `project.shells.ghc` has been removed.

97− If needed, add something like `p // { shells.ghc = p.shellFor {} }`

98− to `shell.nix`.

99−

100−## Nov 24, 2020

101−* Added `${targetPrefix}cabal` wrapper script for running cross

102− compilers in `shellFor`.

103−* `otherShells` arg added to `shellFor`.

104−

105## Oct 31, 2020

4## Oct 31, 2020

106* Passing `tools.hoogle` to `shellFor` with a value suitable for `haskel-nix.tool` will

5* Passing `tools.hoogle` to `shellFor` with a value suitable for `haskel-nix.tool` will

107 use the specified `hoogle` inside `shellFor`. This allows for materialization

6 use the specified `hoogle` inside `shellFor`. This allows for materialization

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

@@ -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+ "R1909" = "nixpkgs-1909";

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

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

15− "unstable" = "nixpkgs-unstable";

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

16− };

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

18− nixpkgsArgs = haskellNix.nixpkgsArgs // {

19− # Needed for dwarf tests

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

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

22− };

23 };

15 };

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

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;

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

28+ } // nixpkgs.lib.optionalAttrs (nixpkgsName == "R2003") {

37− ghc865 = false;

38− ghc8107 = true;

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

40− ghc865 = false;

29+ ghc883 = false;

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

30+ ghc884 = true;

42− ghc8107 = true;

31+ ghc8101 = false;

43− ghc902 = true;

32+ ghc8102 = true;

44− ghc924 = true;

33+ ghc8102-experimental = true;

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

35+ ghc8102 = 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 == "R2003" && (__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" && (nixpkgsName == "R2009" || (!(__elem compiler-nix-name ["ghc8101" "ghc8102" "ghc8102-experimental"])))) {

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

49+ # Windows cross compilation is currently broken on macOS

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

71 inherit (lib.systems.examples) mingwW64;

50 inherit (lib.systems.examples) mingwW64;

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

51+ } // lib.optionalAttrs (system == "x86_64-linux") {

73 # Musl cross only works on linux

52 # Musl cross only works on linux

74 # aarch64 cross only works on linux

53 # aarch64 cross only works on linux

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

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

76 };

55 };

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

78in

56in

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

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

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

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

59+ # We need this for generic nixpkgs stuff at the right version

81− evalPackages = import pinnedNixpkgsSrc nixpkgsArgs;

60+ genericPkgs = import pinnedNixpkgsSrc {};

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

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

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

62+ dimension "System" (systems genericPkgs) (systemName: system:

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

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

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

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

86 platformFilter = platformFilterGeneric pkgs system;

65 platformFilter = platformFilterGeneric pkgs system;

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

66+ in filterAttrsOnlyRecursive (_: v: platformFilter v) {

88 # Native builds

67 # Native builds

89 # TODO: can we merge this into the general case by picking an appropriate "cross system" to mean native?

68 # TODO: can we merge this into the general case by picking an appropriate "cross system" to mean native?

90 native = pkgs.recurseIntoAttrs ({

69 native = pkgs.recurseIntoAttrs ({

@@ -93,16 +72,16 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:

93 } // pkgs.lib.optionalAttrs runTests {

72 } // pkgs.lib.optionalAttrs runTests {

94 inherit (build) tests tools maintainer-scripts maintainer-script-cache;

73 inherit (build) tests tools maintainer-scripts maintainer-script-cache;

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

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

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

75+ iserv-proxy = pkgs.ghc-extra-packages."${compiler-nix-name}".iserv-proxy.components.exes.iserv-proxy;

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

76 } // 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";

77+ hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; inherit compiler-nix-name; }).components.exes.hello;

99 });

78 });

100 }

79 }

101 //

80 //

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

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

103 # Cross builds

82 # Cross builds

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

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

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

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

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

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

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

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

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

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

@@ -115,12 +94,12 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:

115 inherit (build) tests;

94 inherit (build) tests;

116 }) // pkgs.lib.optionalAttrs (ifdLevel >= 2 && crossSystemName != "ghcjs") {

95 }) // pkgs.lib.optionalAttrs (ifdLevel >= 2 && crossSystemName != "ghcjs") {

117 # GHCJS builds its own template haskell runner.

96 # GHCJS builds its own template haskell runner.

118− remote-iserv = pkgs.ghc-extra-projects."${compiler-nix-name}".getComponent "remote-iserv:exe:remote-iserv";

97+ remote-iserv = pkgs.ghc-extra-packages."${compiler-nix-name}".remote-iserv.components.exes.remote-iserv;

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

98+ iserv-proxy = pkgs.ghc-extra-packages."${compiler-nix-name}".iserv-proxy.components.exes.iserv-proxy;

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

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

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

100+ hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; inherit compiler-nix-name; }).components.exes.hello;

122 })

101 })

123− ))

102+ )

124 )

103 )

125 )

104 )

126)

105)

compiler/bootstrap/cabal-install.nix+2−2

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

1−{ fetchurl, hackage, stdenv, lib, ghc, zlib, src, version }:

1+{ fetchurl, hackage, stdenv, ghc, zlib, src, version }:

2let dependencies =

3 [ { name = "deepseq"; version = "1.4.3.0"; }

4 { name = "binary"; version = "0.8.5.1"; }

@@ -42,7 +42,7 @@ in stdenv.mkDerivation ({

42 };

43

44 meta = {

45− platforms = lib.platforms.all;

45+ platforms = stdenv.lib.platforms.all;

46 };

47

48 nativeBuildInputs = [ ghc zlib ];

compiler/ghc/configured-src.nixnew file+116

@@ -0,0 +1,116 @@

1+{ stdenv, fetchurl

2+, ghc-version, 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+, ncurses, targetLibffi, libiconv

13+, disableLargeAddressSpace

14+, buildMK

15+}:

16+stdenv.mkDerivation (rec {

17+

18+ version = ghc-version;

19+ patches = ghc-patches;

20+ name = "${targetPrefix}ghc-${ghc-version}-configured-src";

21+

22+ # Make sure we never relax`$PATH` and hooks support for compatability.

23+ strictDeps = true;

24+

25+ nativeBuildInputs = [

26+ perl autoconf automake m4 python3 sphinx

27+ ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour

28+ ] ++ stdenv.lib.optional (patches != []) autoreconfHook;

29+

30+ # For building runtime libs

31+ depsBuildTarget = toolsForTarget;

32+

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

34+

35+ propagatedBuildInputs = [ targetPackages.stdenv.cc ]

36+ ++ stdenv.lib.optional useLLVM llvmPackages.llvm;

37+

38+ depsTargetTarget = map stdenv.lib.getDev (libDeps targetPlatform);

39+ depsTargetTargetPropagated = map (stdenv.lib.getOutput "out") (libDeps targetPlatform);

40+

41+ postPatch = "patchShebangs .";

42+

43+ src = if src-spec ? file

44+ then src-spec.file

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

46+

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

48+ preConfigure = ''

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

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

51+ done

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

53+ # the *host* tools.

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

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

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

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

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

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

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

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

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

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

64+

65+ echo -n "${buildMK}" > mk/build.mk

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

67+ '' + stdenv.lib.optionalString (!stdenv.isDarwin) ''

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

69+ '' + stdenv.lib.optionalString stdenv.isDarwin ''

70+ export NIX_LDFLAGS+=" -no_dtrace_dof"

71+ '' + stdenv.lib.optionalString targetPlatform.useAndroidPrebuilt ''

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

73+ '' + stdenv.lib.optionalString targetPlatform.isMusl ''

74+ echo "patching llvm-targets for musl targets..."

75+ echo "Cloning these existing '*-linux-gnu*' targets:"

76+ grep linux-gnu llvm-targets | sed 's/^/ /'

77+ echo "(go go gadget sed)"

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

79+ echo "llvm-targets now contains these '*-linux-musl*' targets:"

80+ grep linux-musl llvm-targets | sed 's/^/ /'

81+

82+ echo "And now patching to preserve '-musleabi' as done with '-gnueabi'"

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

84+ for x in configure aclocal.m4; do

85+ substituteInPlace $x \

86+ --replace '*-android*|*-gnueabi*)' \

87+ '*-android*|*-gnueabi*|*-musleabi*)'

88+ done

89+ '';

90+

91+ configurePlatforms = [ "build" "host" "target" ];

92+ # `--with` flags for libraries needed for RTS linker

93+ configureFlags = [

94+ "--datadir=$doc/share/doc/ghc"

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

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

97+ ] ++ stdenv.lib.optional (!enableIntegerSimple) [

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

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

100+ "--with-iconv-includes=${libiconv}/include" "--with-iconv-libraries=${libiconv}/lib"

101+ ] ++ stdenv.lib.optionals (targetPlatform != hostPlatform) [

102+ "--enable-bootstrap-with-devel-snapshot"

103+ ] ++ stdenv.lib.optionals (disableLargeAddressSpace) [

104+ "--disable-large-address-space"

105+ ] ++ stdenv.lib.optionals (targetPlatform.isAarch32) [

106+ "CFLAGS=-fuse-ld=gold"

107+ "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"

108+ "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"

109+ ] ;

110+

111+ outputs = [ "out" ];

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

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

114+ ++ [ "configurePhase" "installPhase" ];

115+ installPhase = "cp -r . $out";

116+})

compiler/ghc/default.nix+93−275

@@ -3,19 +3,15 @@

3# haskell.nix ships its own version of the ghc expression as it needs more

4# control over the expression to isolate it against varying <nixpkgs> and

5# allow us to customize it to the way haskell.nix works.

6−let self =

7−{ stdenv, lib, haskell-nix, targetPackages

6+{ stdenv, haskell-nix, targetPackages

8

7

9# build-tools

8# build-tools

10, bootPkgs

9, bootPkgs

11−, buildPackages

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

10+, autoconf, automake, coreutils, fetchurl, fetchpatch, perl, python3, m4, sphinx, numactl

13, autoreconfHook

11, autoreconfHook

14, bash

12, bash

15

13

16−, libiconv ? null

14+, libiconv ? null, ncurses

17−

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

19

15

20, installDeps

16, installDeps

21

17

@@ -30,10 +26,7 @@ let self =

30

26

31, # If enabled, GHC will be built with the GPL-free but slower integer-simple

27, # 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.

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

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

29+ enableIntegerSimple ? !(stdenv.lib.any (stdenv.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

30

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

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

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

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

@@ -44,18 +37,12 @@ let self =

44

37

45, enableLibraryProfiling ? true

38, enableLibraryProfiling ? true

46

39

47−, enableDWARF ? false

40+, # Whether to build terminfo. Musl fails to build terminfo as ncurses seems to be linked to glibc

48−

41+ enableTerminfo ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.isMusl

49−, enableTerminfo ?

50− # Terminfo does not work on older ghc cross arm and windows compilers

51− (!haskell-nix.haskellLib.isCrossTarget || !(stdenv.targetPlatform.isAarch64 || stdenv.targetPlatform.isWindows) || builtins.compareVersions ghc-version "8.10" >= 0)

52−

53−, # Wheter to build in NUMA support

54− enableNUMA ? true

55

42

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

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

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

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

58− ghcFlavour ? lib.optionalString haskell-nix.haskellLib.isCrossTarget (

45+ ghcFlavour ? stdenv.lib.optionalString haskell-nix.haskellLib.isCrossTarget (

59 if useLLVM

46 if useLLVM

60 then "perf-cross"

47 then "perf-cross"

61 else "perf-cross-ncg"

48 else "perf-cross-ncg"

@@ -66,19 +53,14 @@ let self =

66 disableLargeAddressSpace ? stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64

53 disableLargeAddressSpace ? stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64

67

54

68, ghc-version ? src-spec.version

55, ghc-version ? src-spec.version

69−, ghc-version-date ? null

70, src-spec

56, src-spec

71, ghc-patches ? []

57, ghc-patches ? []

72

58

73# extra values we want to have available as passthru values.

59# extra values we want to have available as passthru values.

74, extra-passthru ? {}

60, extra-passthru ? {}

75−}@args:

61+}:

76−

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

78

62

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

63+assert !enableIntegerSimple -> gmp != null;

80−assert enableNativeBignum -> !enableIntegerSimple;

81−assert enableIntegerSimple -> !enableNativeBignum;

82

64

83let

65let

84 inherit (stdenv) buildPlatform hostPlatform targetPlatform;

66 inherit (stdenv) buildPlatform hostPlatform targetPlatform;

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

86

68

87 inherit (bootPkgs) ghc;

69 inherit (bootPkgs) ghc;

88

70

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.

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

101 targetLibffi =

72 targetLibffi =

102 # on native platforms targetPlatform.{libffi, gmp} do not exist; thus fall back

73 # on native platforms targetPlatform.{libffi, gmp} do not exist; thus fall back

@@ -109,12 +80,8 @@ let

109

80

110 targetGmp = targetPackages.gmp or gmp;

81 targetGmp = targetPackages.gmp or gmp;

111

82

112− targetIconv = targetPackages.libiconv or libiconv;

113−

114− targetNumactl = targetPackages.numactl or numactl;

115−

116 # TODO(@Ericson2314) Make unconditional

83 # TODO(@Ericson2314) Make unconditional

117− targetPrefix = lib.optionalString

84+ targetPrefix = stdenv.lib.optionalString

118 (targetPlatform != hostPlatform)

85 (targetPlatform != hostPlatform)

119 "${targetPlatform.config}-";

86 "${targetPlatform.config}-";

120

87

@@ -124,67 +91,68 @@ let

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

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

125 endif

92 endif

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

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

127− '' + bignumSpec + ''

94+ INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}

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

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

95+ '' + stdenv.lib.optionalString (targetPlatform != hostPlatform) ''

130 CrossCompilePrefix = ${targetPrefix}

96 CrossCompilePrefix = ${targetPrefix}

131− '' + lib.optionalString isCrossTarget ''

97+ '' + stdenv.lib.optionalString isCrossTarget ''

132 Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"}

98 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

99 HADDOCK_DOCS = NO

137 BUILD_SPHINX_HTML = NO

100 BUILD_SPHINX_HTML = NO

138 BUILD_SPHINX_PDF = NO

101 BUILD_SPHINX_PDF = NO

139− '' + lib.optionalString enableRelocatedStaticLibs ''

102+ '' + stdenv.lib.optionalString enableRelocatedStaticLibs ''

140 GhcLibHcOpts += -fPIC

103 GhcLibHcOpts += -fPIC

141 GhcRtsHcOpts += -fPIC

104 GhcRtsHcOpts += -fPIC

142− GhcRtsCcOpts += -fPIC

143− '' + lib.optionalString (enableRelocatedStaticLibs && targetPlatform.isx86_64 && !targetPlatform.isWindows) ''

144− GhcLibHcOpts += -fexternal-dynamic-refs

145− GhcRtsHcOpts += -fexternal-dynamic-refs

146− '' + lib.optionalString enableDWARF ''

147− GhcLibHcOpts += -g3

148− GhcRtsHcOpts += -g3

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

105+ '' + stdenv.lib.optionalString targetPlatform.useAndroidPrebuilt ''

150 EXTRA_CC_OPTS += -std=gnu99

106 EXTRA_CC_OPTS += -std=gnu99

151− '' + lib.optionalString (!enableTerminfo) ''

107+ '' + stdenv.lib.optionalString (!enableTerminfo) ''

152 WITH_TERMINFO=NO

108 WITH_TERMINFO=NO

153 ''

109 ''

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

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

111 # our elf linker for x86_64 is broken.

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

112+ + stdenv.lib.optionalString (targetPlatform.isMusl && !targetPlatform.isx86) ''

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

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

158 ''

114 ''

159 # While split sections are now enabled by default in ghc 8.8 for windows,

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

116 # the seem to lead to `too many sections` errors when building base for

161 # profiling.

117 # 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) ''

118+ + stdenv.lib.optionalString targetPlatform.isWindows ''

166 SplitSections = NO

119 SplitSections = NO

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

120+ '' + stdenv.lib.optionalString (!enableLibraryProfiling) ''

168 BUILD_PROF_LIBS = NO

121 BUILD_PROF_LIBS = NO

169 '';

122 '';

170

123

171 # Splicer will pull out correct variations

124 # Splicer will pull out correct variations

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

125+ libDeps = platform: stdenv.lib.optional enableTerminfo [ ncurses ]

173 ++ [targetLibffi]

126 ++ [targetLibffi]

174− ++ lib.optional (!enableIntegerSimple) gmp

127+ ++ stdenv.lib.optional (!enableIntegerSimple) gmp

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

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

176− ++ lib.optional (enableNUMA && platform.isLinux && !platform.isAarch32 && !platform.isAndroid) numactl

129+ ++ stdenv.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

130

180 toolsForTarget =

131 toolsForTarget =

181 if hostPlatform == buildPlatform then

132 if hostPlatform == buildPlatform then

182− [ targetPackages.stdenv.cc ] ++ lib.optional useLLVM llvmPackages.llvm

133+ [ targetPackages.stdenv.cc ] ++ stdenv.lib.optional useLLVM llvmPackages.llvm

183 else assert targetPlatform == hostPlatform; # build != host == target

134 else assert targetPlatform == hostPlatform; # build != host == target

184− [ stdenv.cc ] ++ lib.optional useLLVM buildLlvmPackages.llvm;

135+ [ stdenv.cc ] ++ stdenv.lib.optional useLLVM buildLlvmPackages.llvm;

185

136

186 targetCC = builtins.head toolsForTarget;

137 targetCC = builtins.head toolsForTarget;

187

138

139+ configured-src = import ./configured-src.nix {

140+ inherit stdenv fetchurl

141+ ghc-version ghc-patches src-spec

142+ targetPrefix

143+ targetPlatform hostPlatform

144+ targetPackages

145+ perl autoconf automake m4 python3 sphinx ghc bootPkgs

146+ autoreconfHook toolsForTarget bash

147+ libDeps

148+ useLLVM llvmPackages

149+ targetCC

150+ enableIntegerSimple targetGmp

151+ ncurses targetLibffi libiconv

152+ disableLargeAddressSpace

153+ buildMK

154+ ;

155+ };

188in

156in

189stdenv.mkDerivation (rec {

157stdenv.mkDerivation (rec {

190 version = ghc-version;

158 version = ghc-version;

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

192

160

193 patches = ghc-patches;

161 patches = ghc-patches;

194

162

195− src = if src-spec ? file

163+ # for this to properly work (with inheritance of patches, postPatch, ...)

196− then src-spec.file

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

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

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

166+ # attrset.

167+ src = configured-src;

198

168

199 # configure was run by configured-src already.

169 # configure was run by configured-src already.

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

170+ phases = [ "unpackPhase" "buildPhase"

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

202− ++ [ "configurePhase" "buildPhase"

203 "checkPhase" "installPhase"

171 "checkPhase" "installPhase"

204 "fixupPhase"

172 "fixupPhase"

205 "installCheckPhase"

173 "installCheckPhase"

206 "distPhase"

174 "distPhase"

207 ];

175 ];

208

176

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

177+ # ghc hardcodes the TOP dir during config, this breaks when

210− preConfigure =

178+ # splitting the configured src from the build process.

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

179+ postUnpack = ''

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

180+ (cd $sourceRoot

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

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

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

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

215− done

183+

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

184+ # these two are required

217− # the *host* tools.

185+ substituteInPlace mk/config.mk --replace "$TOP" "$PWD" \

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

186+ --replace "$PREFIX" "$out"

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

187+

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

188+ substituteInPlace mk/install.mk --replace "$TOP" "$PWD" \

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

189+ --replace "$PREFIX" "$out"

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

190+

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

191+ # these two only for convencience.

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

192+ substituteInPlace config.log --replace "$TOP" "$PWD"\

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

193+ --replace "$PREFIX" "$out"

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

194+ substituteInPlace config.status --replace "$TOP" "$PWD"\

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

195+ --replace "$PREFIX" "$out")

228− '' + ''

196+

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

197+

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

198+ '';

291

199

292 enableParallelBuilding = true;

200 enableParallelBuilding = true;

293 postPatch = "patchShebangs .";

201 postPatch = "patchShebangs .";

@@ -303,19 +211,22 @@ stdenv.mkDerivation (rec {

303 nativeBuildInputs = [

211 nativeBuildInputs = [

304 perl autoconf automake m4 python3 sphinx

212 perl autoconf automake m4 python3 sphinx

305 ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour

213 ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour

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

214+ ] ++ stdenv.lib.optional (patches != []) autoreconfHook;

307

215

308 # For building runtime libs

216 # For building runtime libs

309 depsBuildTarget = toolsForTarget;

217 depsBuildTarget = toolsForTarget;

310

218

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

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

312

220

221+ propagatedBuildInputs = [ targetPackages.stdenv.cc ]

222+ ++ stdenv.lib.optional useLLVM llvmPackages.llvm;

223+

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

224+ depsTargetTarget = map stdenv.lib.getDev (libDeps targetPlatform);

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

225+ depsTargetTargetPropagated = map (stdenv.lib.getOutput "out") (libDeps targetPlatform);

315

226

316 # required, because otherwise all symbols from HSffi.o are stripped, and

227 # required, because otherwise all symbols from HSffi.o are stripped, and

317 # that in turn causes GHCi to abort

228 # that in turn causes GHCi to abort

318− stripDebugFlags = [ "-S" ] ++ lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols";

229+ stripDebugFlags = [ "-S" ] ++ stdenv.lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols";

319

230

320 # See #63511 - the only unstripped file is the debug rts which isn't meant to

231 # See #63511 - the only unstripped file is the debug rts which isn't meant to

321 # be stripped.

232 # be stripped.

@@ -324,21 +235,10 @@ stdenv.mkDerivation (rec {

324 checkTarget = "test";

235 checkTarget = "test";

325

236

326 hardeningDisable = [ "format" ]

237 hardeningDisable = [ "format" ]

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

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

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

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

329−

240+

330− postInstall = lib.optionalString (enableNUMA && targetPlatform.isLinux) ''

241+ 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.

242 # Install the bash completion file.

343 install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc

243 install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc

344

244

@@ -349,14 +249,16 @@ stdenv.mkDerivation (rec {

349 # The ghcprog fixup is for musl (where runhaskell script just needs to point to the correct

249 # The ghcprog fixup is for musl (where runhaskell script just needs to point to the correct

350 # ghc program to work).

250 # ghc program to work).

351 sed -i \

251 sed -i \

352− -e '2i export PATH="$PATH:${lib.makeBinPath [ targetPackages.stdenv.cc.bintools coreutils ]}"' \

252+ -e '2i export PATH="$PATH:${stdenv.lib.makeBinPath [ targetPackages.stdenv.cc.bintools coreutils ]}"' \

353 -e 's/ghcprog="ghc-/ghcprog="${targetPrefix}ghc-/' \

253 -e 's/ghcprog="ghc-/ghcprog="${targetPrefix}ghc-/' \

354 $i

254 $i

355 done

255 done

356

256

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

257+ # Save generated files for needed when building ghcjs

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

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

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

259+ cp includes/dist-derivedconstants/header/GHCConstantsHaskellExports.hs \

260+ includes/dist-derivedconstants/header/GHCConstantsHaskellType.hs \

261+ includes/dist-derivedconstants/header/GHCConstantsHaskellWrappers.hs \

360 $generated/includes/dist-derivedconstants/header

262 $generated/includes/dist-derivedconstants/header

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

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

362 cp includes/ghcplatform.h $generated/includes

264 cp includes/ghcplatform.h $generated/includes

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

365 fi

267 fi

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

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

367 cp compiler/stage2/build/Config.hs $generated/compiler/stage2/build || true

269 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

270 mkdir -p $generated/rts/build

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

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

379

272

@@ -391,19 +284,19 @@ stdenv.mkDerivation (rec {

391 # Sanity checks for https://github.com/input-output-hk/haskell.nix/issues/660

284 # Sanity checks for https://github.com/input-output-hk/haskell.nix/issues/660

392 if ! "$out/bin/${targetPrefix}ghc" --version; then

285 if ! "$out/bin/${targetPrefix}ghc" --version; then

393 echo "ERROR: Missing file $out/bin/${targetPrefix}ghc"

286 echo "ERROR: Missing file $out/bin/${targetPrefix}ghc"

394− exit 1

287+ exit 0

395 fi

288 fi

396 if ! "$out/bin/${targetPrefix}ghc-pkg" --version; then

289 if ! "$out/bin/${targetPrefix}ghc-pkg" --version; then

397 echo "ERROR: Missing file $out/bin/${targetPrefix}ghc-pkg"

290 echo "ERROR: Missing file $out/bin/${targetPrefix}ghc-pkg"

398− exit 1

291+ exit 0

399 fi

292 fi

400 if [[ ! -d "$out/lib/${targetPrefix}ghc-${version}" ]]; then

293 if [[ ! -d "$out/lib/${targetPrefix}ghc-${version}" ]]; then

401 echo "ERROR: Missing directory $out/lib/${targetPrefix}ghc-${version}"

294 echo "ERROR: Missing directory $out/lib/${targetPrefix}ghc-${version}"

402− exit 1

295+ exit 0

403 fi

296 fi

404 if (( $(ls -1 "$out/lib/${targetPrefix}ghc-${version}" | wc -l) < 30 )); then

297 if (( $(ls -1 "$out/lib/${targetPrefix}ghc-${version}" | wc -l) < 30 )); then

405 echo "ERROR: Expected more files in $out/lib/${targetPrefix}ghc-${version}"

298 echo "ERROR: Expected more files in $out/lib/${targetPrefix}ghc-${version}"

406− exit 1

299+ exit 0

407 fi

300 fi

408 '';

301 '';

409

302

@@ -417,54 +310,10 @@ stdenv.mkDerivation (rec {

417 # Our Cabal compiler name

310 # Our Cabal compiler name

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

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

419

312

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

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

314

455 # Used to detect non haskell-nix compilers (accidental use of nixpkgs compilers can lead to unexpected errors)

315 # Used to detect non haskell-nix compilers (accidental use of nixpkgs compilers can lead to unexpected errors)

456 isHaskellNixCompiler = true;

316 isHaskellNixCompiler = true;

457−

458− # The same GHC, but with debug enabled (if it can be)

459− dwarf = lib.makeOverridable self (args // {

460− enableDWARF = stdenv.targetPlatform.isLinux

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

462− });

463−

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

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

466− disableLargeAddressSpace = true;

467− });

468 } // extra-passthru;

317 } // extra-passthru;

469

318

470 meta = {

319 meta = {

@@ -474,39 +323,8 @@ stdenv.mkDerivation (rec {

474 inherit (ghc.meta) license platforms;

323 inherit (ghc.meta) license platforms;

475 };

324 };

476

325

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 {

326+} // stdenv.lib.optionalAttrs targetPlatform.useAndroidPrebuilt {

483 dontStrip = true;

327 dontStrip = true;

484 dontPatchELF = true;

328 dontPatchELF = true;

485 noAuditTmpdir = true;

329 noAuditTmpdir = true;

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

330+})

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

512−in 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": "31a54f7320b1f9700eb6389c2eb2d50c712e8371",

4− "sha256": "1lr3grk5jjm8bvvkndilm06ry1dj7i66k4g27fr009bggdy9q6ws",

4+ "sha256": "1cj1gfqcj0ygc23xj5gbm0ym9wmh8ini57zlgd6s25avgjbrwga6",

5 "fetchSubmodules": true

6}

compiler/ghcjs/ghcjs.nix+27−48

@@ -1,28 +1,20 @@

1{ pkgs

2, ghcjsSrcJson ? ./ghcjs-src.json

3, ghcjsSrc ? pkgs.buildPackages.fetchgit (builtins.fromJSON (builtins.readFile ghcjsSrcJson))

4−, ghcjsVersion ? "8.6.0.0.10"

4+, ghcjsVersion ? "8.6.0.1"

5, ghcVersion ? "8.6.5"

6, compiler-nix-name ? if builtins.compareVersions ghcjsVersion "8.8.0.0" > 0

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

@@ -32,25 +24,21 @@ let

32 all-ghcjs = pkgs.buildPackages.symlinkJoin {

24 all-ghcjs = pkgs.buildPackages.symlinkJoin {

33 name = "ghcjs-${ghcjsVersion}-symlinked";

25 name = "ghcjs-${ghcjsVersion}-symlinked";

34 paths = [

26 paths = [

35− (ghcjs.getComponent "exe:ghcjs-boot")

27+ ghcjs.components.exes.ghcjs

28+ ghcjs.components.exes.ghcjs-pkg

29+ ghcjs.components.exes.ghcjs-boot

30+ ghcjs.components.exes.ghcjs-dumparchive

36 ] ++ (if isGhcjs88

31 ] ++ (if isGhcjs88

37 then [

32 then [

38− (ghcjs.getComponent "exe:ghcjs")

33+ ghcjs.components.exes.haddock

39− (ghcjs.getComponent "exe:ghcjs-pkg")

40− (ghcjs.getComponent "exe:private-ghcjs-hsc2hs")

41− (ghcjs.getComponent "exe:haddock")

42− (ghcjs.getComponent "exe:ghcjs-dumparchive")

43− (ghcjs.getComponent "exe:private-ghcjs-run")

34+ ghcjs.components.exes.private-ghcjs-run

44− (ghcjs.getComponent "exe:private-ghcjs-unlit")

35+ ghcjs.components.exes.private-ghcjs-unlit

36+ ghcjs.components.exes.private-ghcjs-hsc2hs

45 ]

37 ]

46 else [

38 else [

47− (ghcjs.getComponent "exe:private-ghcjs-ghcjs")

39+ ghcjs.components.exes.haddock-ghcjs

48− (ghcjs.getComponent "exe:private-ghcjs-ghcjs-pkg")

40+ ghcjs.components.exes.hsc2hs-ghcjs

49− (ghcjs.getComponent "exe:private-ghcjs-run")

41+ ghcjs.components.exes.ghcjs-run

50− (ghcjs.getComponent "exe:private-ghcjs-unlit")

51− (ghcjs.getComponent "exe:private-ghcjs-hsc2hs")

52− (ghcjs.getComponent "exe:private-ghcjs-haddock")

53− (ghcjs.getComponent "exe:private-ghcjs-ghcjs-dumparchive")

54 ]);

42 ]);

55 };

43 };

56 libexec = "libexec/${builtins.replaceStrings ["darwin" "i686"] ["osx" "i386"] pkgs.stdenv.buildPlatform.system}-${ghc.name}/ghcjs-${ghcVersion}";

44 libexec = "libexec/${builtins.replaceStrings ["darwin" "i686"] ["osx" "i386"] pkgs.stdenv.buildPlatform.system}-${ghc.name}/ghcjs-${ghcVersion}";

@@ -62,11 +50,10 @@ let

62 ++ pkgs.lib.optional isGhcjs88 pkgs.buildPackages.procps;

50 ++ pkgs.lib.optional isGhcjs88 pkgs.buildPackages.procps;

63 passthru = {

51 passthru = {

64 inherit all-ghcjs bundled-ghcjs project;

52 inherit all-ghcjs bundled-ghcjs project;

65− configured-src = project.configured-src + "/ghc";

53+ inherit (project) configured-src;

66 # Used to detect non haskell-nix compilers (accidental use of nixpkgs compilers can lead to unexpected errors)

54 # Used to detect non haskell-nix compilers (accidental use of nixpkgs compilers can lead to unexpected errors)

67 isHaskellNixCompiler = true;

55 isHaskellNixCompiler = true;

68 } // ghcjs.components.exes;

56 } // ghcjs.components.exes;

69− dontUpdateAutotoolsGnuConfigScripts = true;

70 dontConfigure = true;

57 dontConfigure = true;

71 dontInstall = true;

58 dontInstall = true;

72 buildPhase = ''

59 buildPhase = ''

@@ -81,26 +68,22 @@ let

81 lndir ${all-ghcjs}/bin $out/bin

68 lndir ${all-ghcjs}/bin $out/bin

82 chmod -R +w $out/bin

69 chmod -R +w $out/bin

83 rm $out/bin/ghcjs-boot

70 rm $out/bin/ghcjs-boot

84− cp ${ghcjs.getComponent "exe:ghcjs-boot"}/bin/ghcjs-boot $out/bin

71+ cp ${ghcjs.components.exes.ghcjs-boot}/bin/ghcjs-boot $out/bin

85 rm $out/bin/haddock

72 rm $out/bin/haddock

86− cp ${ghcjs.getComponent "exe:haddock"}/bin/haddock $out/bin

73+ cp ${ghcjs.components.exes.haddock}/bin/haddock $out/bin

87

74

88 wrapProgram $out/bin/ghcjs --add-flags "-B$out/lib"

75 wrapProgram $out/bin/ghcjs --add-flags "-B$out/lib"

89 wrapProgram $out/bin/haddock --add-flags "-B$out/lib"

76 wrapProgram $out/bin/haddock --add-flags "-B$out/lib"

90 wrapProgram $out/bin/ghcjs-pkg --add-flags "--global-package-db=$out/lib/package.conf.d"

77 wrapProgram $out/bin/ghcjs-pkg --add-flags "--global-package-db=$out/lib/package.conf.d"

91 ''

78 ''

92 else ''

79 else ''

93− mkdir -p $out

80+ mkdir -p $out/bin

94− lndir ${all-ghcjs} $out

95 mkdir -p $out/lib/ghcjs-${ghcVersion}

81 mkdir -p $out/lib/ghcjs-${ghcVersion}

96− rm $out/bin/ghcjs-boot

97− cp ${ghcjs.getComponent "exe:ghcjs-boot"}/bin/ghcjs-boot $out/bin

98− wrapProgram $out/bin/ghcjs-boot --set ghcjs_libexecdir $out/bin

99− mv $out/${libexec}/* $out/bin

82+ lndir ${all-ghcjs}/${libexec} $out/bin

100

83

101− wrapProgram $out/bin/private-ghcjs-ghcjs --add-flags "-B$out/lib"

84+ wrapProgram $out/bin/ghcjs --add-flags "-B$out/lib/ghcjs-${ghcVersion}"

102− wrapProgram $out/bin/private-ghcjs-haddock --add-flags "-B$out/lib"

85+ wrapProgram $out/bin/haddock-ghcjs --add-flags "-B$out/lib/ghcjs-${ghcVersion}"

103− wrapProgram $out/bin/private-ghcjs-ghcjs-pkg --add-flags "--global-package-db=$out/lib/package.conf.d"

86+ wrapProgram $out/bin/ghcjs-pkg --add-flags "--global-package-db=$out/lib/ghcjs-${ghcVersion}/package.conf.d"

104 ''

87 ''

105 }

88 }

106 # Avoid timeouts while unix package runs hsc2hs (it does not print anything

89 # Avoid timeouts while unix package runs hsc2hs (it does not print anything

@@ -113,21 +96,17 @@ let

113 fi

96 fi

114 done

97 done

115 } &

98 } &

116− ${

99+ ${ if isGhcjs88

100+ then

117− # Unsets NIX_CFLAGS_COMPILE so the osx version of iconv.h is not used by mistake

101+ # 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 ''

102 ''

123− else if isGhcjs88 then ''

124 env -u NIX_CFLAGS_COMPILE PATH=$out/bin:$PATH \

103 env -u NIX_CFLAGS_COMPILE PATH=$out/bin:$PATH \

104+ PYTHON=${pkgs.buildPackages.python3}/bin/python3 \

125 $out/bin/ghcjs-boot -j1 --with-emsdk=${project.emsdk} --no-prof --no-haddock \

105 $out/bin/ghcjs-boot -j1 --with-emsdk=${project.emsdk} --no-prof --no-haddock \

126 || (echo failed > $TMP/done; false)

106 || (echo failed > $TMP/done; false)

127 ''

107 ''

128 else ''

108 else ''

129− env -u NIX_CFLAGS_COMPILE PATH=$out/bin:$PATH \

130− $out/bin/ghcjs-boot -j1 --with-ghcjs-libdir=$out --with-emsdk=${project.emsdk} \

109+ env PATH=$out/bin:$PATH $out/bin/ghcjs-boot -j1 --with-ghcjs-bin $out/bin \

131 || (echo failed > $TMP/done; false)

110 || (echo failed > $TMP/done; false)

132 ''

111 ''

133 }

112 }

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

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

1{

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

3− "rev": "1af48a877fdf1f647a3b81e828a1e61adb0baceb",

3+ "rev": "1193ead2c760bab1e2ab461458ec771237ccf9b5",

4− "sha256": "sha256-B4LFpd1nl96SO6/gsTjkizMGSglMkrujmwgXVjahC68=",

4+ "sha256": "1h7gaq1lhf61b5x693phgpm2z0w393b1sbkxrd9mxzz9xxlyrhkl",

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/old-ghc-nix/default.nixnew file+10

@@ -0,0 +1,10 @@

1+{ pkgs ? import <nixpkgs> {} }:

2+let

3+ fetch = jsonFile:

4+ with builtins;

5+ let spec = fromJSON (readFile jsonFile);

6+ in pkgs.fetchgit {

7+ name = "old-ghc-nix";

8+ inherit (spec) sha256 url rev;

9+ };

10+in import (fetch ./old-ghc-nix.json) { inherit pkgs; }

compiler/old-ghc-nix/old-ghc-nix.jsonnew file+7

@@ -0,0 +1,7 @@

1+{

2+ "url": "https://github.com/angerman/old-ghc-nix",

3+ "rev": "2a41a09127f6dc7a6384823d1acd51ba257f95bd",

4+ "date": "2020-06-03T12:50:09+08:00",

5+ "sha256": "1cp6aksb6ldgjb5zyqikyjrjij79n9z7wd86migph0wp19vmszkf",

6+ "fetchSubmodules": false

7+}

compiler/windows/include/synchapi.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+28−29

@@ -1,29 +1,28 @@

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

26− inherit pkgs;

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/dev/nix-tools-pin.mddeleted−16

@@ -1,16 +0,0 @@

1−## How to update [`nix-tools`](https://github.com/input-output-hk/nix-tools)

2−

3−1. Use niv to update the sources.json:

4−

5− ```

6− niv update nix-tools

7− ```

8−

9−

10−2. If `nix-tools.cabal` or `plan-to-nix` have changed, check the

11− materialized files for each of the compiler nix name in

12− `ls -d materialized/ghc*/nix-tools` with:

13−

14− ```

15− nix-build scripts/check-compiler-materialization --argstr compiler-nix-name ghc884

16− ```

docs/dev/nixpkgs-pin.md+15−7

@@ -1,17 +1,25 @@

1# Haskell.nix Nixpkgs Pin

2

3−Haskell.nix contains several Nixpkgs pins imanaged by `niv` in

3+Haskell.nix contains a Nixpkgs pin in

4−`nix/sources.json`.

4+[`nixpkgs/github.json`](https://github.com/input-output-hk/haskell.nix/blob/master/nixpkgs/github.json).

5−

5+This is the version of Nixpkgs used for builds of `nix-tools` and

6−These are used in testing various versions of nixpkgs.

6+running the tests.

7

8To use haskell.nix the `config` and `overlays` need to be applied to

9Nixpkgs. Users should probably pin a suitable version of nixpkgs, although things might not work for them if their Nixpkgs version is

10too different.

11

12We aim to keep this pin somewhere on a channel of the **Nixpkgs latest

13−stable release**. That is currently 20.09.

13+stable release**. That is currently 19.09.

14

15We also execute tests on MacOS (darwin). The darwin channel is usually

16−behind the NixOS channel. So we follow the `nixpkgs-20.09-darwin`

16+behind the NixOS channel. So we choose the `nixpkgs-19.09-darwin`

17−channel.

17+channel:

18+

19+```

20+nix-prefetch-git https://github.com/NixOS/nixpkgs-channels refs/heads/nixpkgs-19.09-darwin

21+```

22+

23+Keep the URL in `github.json` pointing at

24+<https://github.com/NixOS/nixpkgs>. Case matters because the Hydra

25+trusted URL whitelist is case-sensitive.

docs/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+11−21

@@ -112,16 +112,16 @@ will be passed to it:

112

113# Top-level attributes

114

115−## project'

115+## project

116

117Function that accepts attribute set with a `src` attribute and looks for `stack.yaml` file relative to it.

118

119−If file exists, it calls [stackProject](#stackproject') function. Otherwise it will call [cabalProject](#cabalproject') function.

119+If file exists, it calls [stackProject](#stackproject) function. Otherwise it will call [cabalProject](#cabalproject) function.

120

121**Example**:

122

123```nix

124−pkgs.haskell-nix.project' {

124+pkgs.haskell-nix.project {

125 # 'cleanGit' cleans a source directory based on the files known by git

126 src = pkgs.haskell-nix.haskellLib.cleanGit {

127 name = "haskell-nix-project";

@@ -130,7 +130,7 @@ pkgs.haskell-nix.project' {

130}

131```

132

133−## stackProject'

133+## stackProject

134

135A function calling [callStackToNix](#callstacktonix) with all arguments.

136

@@ -142,13 +142,14 @@ Then feeding its result into [mkStackPkgSet](#mkstackpkgset) passing also

142| Attribute | Type | Description |

143|-------------------|--------------------------------------------------|----------------------------------------------------------------------------|

144| `hsPkgs` | Attrset of [Haskell Packages](#haskell-package) | Buildable packages, created from `packages` |

145+| `pkg-set` | Attrset | [`pkgSet`](#package-set) |

145| `stack-nix` | | `projectNix` attribute of [`callStackToNix`](#callstacktonix) return value |

146| `stack-nix` | | `projectNix` attribute of [`callStackToNix`](#callstacktonix) return value |

146| `shellFor` | Function | [`shellFor`](#shellfor) |

147| `shellFor` | Function | [`shellFor`](#shellfor) |

147−| `ghcWithHoogle` | Function | [`ghcWithHoogle`](#ghcwithhoogle) |

148+| `ghcWithHoogle` | Function | [`ghcWithHoogle`](#ghcwithhoogle) |

148| `ghcWithPackages` | Function | [`ghcWithPackages`](#ghcwithpackages) |

149| `ghcWithPackages` | Function | [`ghcWithPackages`](#ghcwithpackages) |

149

150

151

151−## cabalProject'

152+## cabalProject

152

153

153A function calling [callCabalProjectToNix](#callcabalprojecttonix) with all arguments.

154A function calling [callCabalProjectToNix](#callcabalprojecttonix) with all arguments.

154

155

@@ -160,21 +161,14 @@ Then feeding its result into [mkCabalProjectPkgSet](#mkcabalprojectpkgset) passi

160| Attribute | Type | Description |

161| Attribute | Type | Description |

161|-------------------|--------------------------------------------------|-----------------------------------------------------------------------------|

162|-------------------|--------------------------------------------------|-----------------------------------------------------------------------------|

162| `hsPkgs` | Attrset of [Haskell Packages](#haskell-package) | Buildable packages, created from `packages` |

163| `hsPkgs` | Attrset of [Haskell Packages](#haskell-package) | Buildable packages, created from `packages` |

164+| `pkg-set` | Attrset | [`pkgSet`](#package-set) |

163| `plan-nix` | | `projectNix` attribute of [`callCabalProjectToNix`](#callcabalprojecttonix) return value |

165| `plan-nix` | | `projectNix` attribute of [`callCabalProjectToNix`](#callcabalprojecttonix) return value |

164| `index-state` | | `index-state` attribute of [`callCabalProjectToNix`](#callcabalprojecttonix) return value |

166| `index-state` | | `index-state` attribute of [`callCabalProjectToNix`](#callcabalprojecttonix) return value |

165| `shellFor` | Function | [`shellFor`](#shellfor) |

167| `shellFor` | Function | [`shellFor`](#shellfor) |

166−| `ghcWithHoogle` | Function | [`ghcWithHoogle`](#ghcwithhoogle) |

168+| `ghcWithHoogle` | Function | [`ghcWithHoogle`](#ghcwithhoogle) |

167| `ghcWithPackages` | Function | [`ghcWithPackages`](#ghcwithpackages) |

169| `ghcWithPackages` | Function | [`ghcWithPackages`](#ghcwithpackages) |

168−| `projectCross` | Attrset | Like `pkgs.pkgsCross.<system>` from nixpkgs `p.projectCross.<system>` returns the project results for cross compilation (where system is a member of nixpkgs lib.systems.examples). So `p.projectCross.ghcjs.hsPkgs` is the same as `hsPkgs` but compiled with ghcjs |

169−| `appendModule` | Function | Re-eval the project with an extra module (or module list). |

170−| `extend` and `appendOverlays` | Function | Modify a project, or add attributes, through overlays: `p.extend(final: prev: { })`. The overlays are carried-over `projectCross` and `appendModule` invocations. |

171

170

172−## project, cabalProject and stackProject

173

171

174−These versions of the function are the same as project', cabalProject'

175−and stackProject', but `hsPkgs` attributes are also included in the

176−return value directly. That way a package can be referenced as

177−`(project {...}).foo` instead of `(project' {...}).hsPkgs.foo`.

178

172

179## mkStackPkgSet

173## mkStackPkgSet

180

174

@@ -410,11 +404,9 @@ Sub-component types identify [components](#component) and are one of:

410 - `tests`

404 - `tests`

411 - `benchmarks`

405 - `benchmarks`

412

406

413−# Project functions

407+# Package-set functions

414

408

415−These functions are included in the `project` return values.

409+These functions exist within the `hsPkgs` package set.

416−In the past they also existed within `project.hsPkgs`,

417−but have now been removed from there.

418

410

419## shellFor

411## shellFor

420

412

@@ -436,8 +428,6 @@ shellFor =

436| `withHoogle` | Boolean | Whether to build a Hoogle documentation index and provide the `hoogle` command. |

428| `withHoogle` | Boolean | Whether to build a Hoogle documentation index and provide the `hoogle` command. |

437| `exactDeps` | Boolean | Prevents the Cabal solver from choosing any package dependency other than what are in the package set. |

429| `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. |

430| `tools` | Function | AttrSet of tools to make available e.g. `{ cabal = "3.2.0.0"; }` or `{ cabal = { version = "3.2.0.0"; }; }`. If an AttrSet is provided for a tool, the additional arguments will be passed to the function creating the derivation for that tool. So you can provide an `index-state` or a `materialized` argument like that `{ cabal = { version = "3.2.0.0"; index-state = "2020-10-30T00:00:00Z"; materialized = ./cabal.materialized; }; }` for example. You can specify and materialize the version of hoogle used to construct the hoogle index by including something like `{ hoogle = { version = "5.0.17.15"; index-state = "2020-05-31T00:00:00Z"; materialized = ./hoogle.materialized; }`. Uses a default version of hoogle if omitted. |

439−| `inputsFrom` | List | List of other shells to include in this one. The `buildInputs` and `nativeBuildInputs` of each will be included using [mkShell](https://nixos.org/manual/nixpkgs/stable/#sec-pkgs-mkShell).

440−| `crossPlatforms` | Function | Platform selection function for cross compilation targets to support eg. `ps: with ps; [ghcjs mingwW64]` (see nixpkgs lib.systems.examples for list of platform names). |

441| `{ ... }` | Attrset | All the other arguments are passed to [`mkDerivation`](https://nixos.org/nixpkgs/manual/#sec-using-stdenv). |

431| `{ ... }` | Attrset | All the other arguments are passed to [`mkDerivation`](https://nixos.org/nixpkgs/manual/#sec-using-stdenv). |

442

432

443**Return value**: a derivation

433**Return value**: a derivation

docs/reference/supported-ghc-versions.md+26−45

@@ -1,49 +1,30 @@

1# Supported GHC Versions

2

3−The following GHC versions are defined in `haskell.nix` (there is a derivation

3+The following versions of GHC built on the CI servers and should be included

4−for each, though not all are cached or tested by CI):

4+in the binary cache (for the default haskell.nix `nixpkgs`).

5−- 8.4.4

5+

6−- 8.6.{1,2,3,4,5}

6+* 8.6.5 `compiler-nix-name = "ghc865";`

7−- 8.8.{1,2,3,4}

7+* 8.8.3 `compiler-nix-name = "ghc883";`

8−- 8.10.{1,2,3,4,5}

8+* 8.8.4 `compiler-nix-name = "ghc884";`

9−- 9.0.1

9+* 8.10.1 `compiler-nix-name = "ghc8101";`

10−- 9.2.1

10+* 8.10.2 `compiler-nix-name = "ghc8102";`

11−- 9.2.2

11+

12−

12+Full test suite is run against 8.6.5, 8.8.4 and 8.10.2.

13−The following table shows the Nixpkgs/GHC versions which are built/cached, and

14−which of those are further tested. If you use a combination of Nixpkgs version

15−and GHC version which is in this table, you should hit our cache, saving

16−considering time by not building GHC and a few additional tools.

17−

18−Note that if you try to use `haskell.nix` as an overlay over Nixpkgs from a

19−standard Nixpkgs channel you will likely get a cache miss. To hit our cache you

20−really should use an instance of Nixpkgs provided by `haskell.nix` itself.

21−

23−|------------------|--------------------|-------------|-----------------------|---------------|

24−| 21.11 | `nixpkgs-2111` | 8.6.5 | `ghc865` | No |

25−| 21.11 | `nixpkgs-2111` | 8.10.7 | `ghc8107` | Yes |

26−| unstable | `nixpkgs-unstable` | 8.6.5 | `ghc865` | No |

27−| unstable | `nixpkgs-unstable` | 8.8.4 | `ghc884` | No |

28−| unstable | `nixpkgs-unstable` | 8.10.7 | `ghc8107` | Yes |

29−| unstable | `nixpkgs-unstable` | 9.0.2 | `ghc902` | Yes |

30−| unstable | `nixpkgs-unstable` | 9.2.4 | `ghc924` | Yes |

31

13

32See [ci.nix](https://github.com/input-output-hk/haskell.nix/blob/master/ci.nix)

14See [ci.nix](https://github.com/input-output-hk/haskell.nix/blob/master/ci.nix)

33−for the source of truth about what is built and tested (in the off chance this

15+for the list of tested GHC versions.

34−document is out-of-sync with your checkout).

16+

35−

17+The following GHC versions are not included in CI and will not be cached:

36−See the [getting started guide](../tutorials/getting-started.md) for

18+

37−instructions on how to set up Nix to take advantage of our cache when building.

19+* 8.4.4 `compiler-nix-name = "ghc844";`

38−This guide also covers where to use the Nixpkgs pinning and `compiler-nix-name`

20+* 8.6.1 `compiler-nix-name = "ghc861";`

39−settings from the table above. For further information, see the [instructions

21+* 8.6.2 `compiler-nix-name = "ghc862";`

40−for how to pin Nixpkgs](../dev/nixpkgs-pin.md).

22+* 8.6.3 `compiler-nix-name = "ghc863";`

41−

23+* 8.6.4 `compiler-nix-name = "ghc864";`

42−See

24+* 8.8.1 `compiler-nix-name = "ghc881";`

25+* 8.8.2 `compiler-nix-name = "ghc882";`

26+

43−[overlays/bootstrap.nix](https://github.com/input-output-hk/haskell.nix/blob/master/overlays/bootstrap.nix)

27+See [overlays/bootstrap.nix](https://github.com/input-output-hk/haskell.nix/blob/master/overlays/bootstrap.nix)

44−for a full list of all the valid `compiler-nix-name`s beyond what's

28+for a list of all the valid `compiler-nix-names`.

45−cached/tested in CI. You're free to use these, but be ready for longer build

29+

46−times.

47−

48−Lastly, see [instructions on adding new GHC versions](../dev/adding-new-ghc.md)

30+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/cross-compilation.md+1−1

@@ -90,7 +90,7 @@ executables you must add package overrides to:

90```nix

91{

92 packages.bench.components.exes.bench.configureFlags =

93− lib.optionals stdenv.hostPlatform.isMusl [

93+ stdenv.lib.optionals stdenv.hostPlatform.isMusl [

94 "--disable-executable-dynamic"

95 "--disable-shared"

96 "--ghc-option=-optl=-pthread"

docs/tutorials/development.md+15−23

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

@@ -108,7 +100,7 @@ selects packages from the larger package set.

108# shell.nix

100# shell.nix

109let

101let

110 haskellNix = import (builtins.fetchTarball https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz) {};

102 haskellNix = import (builtins.fetchTarball https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz) {};

111− nixpkgs = import haskellNix.sources.nixpkgs haskellNix.nixpkgsArgs;

103+ nixpkgs = import haskellNix.sources.nixpkgs-1909 haskellNix.nixpkgsArgs;

112 haskell = nixpkgs.haskell-nix;

104 haskell = nixpkgs.haskell-nix;

113in

105in

114 haskell.haskellPackages.ghcWithPackages (ps: with ps;

106 haskell.haskellPackages.ghcWithPackages (ps: with ps;

@@ -127,7 +119,7 @@ project.

127```nix

119```nix

128let

120let

129 haskellNix = import (builtins.fetchTarball https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz) {};

121 haskellNix = import (builtins.fetchTarball https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz) {};

130− nixpkgs = import haskellNix.sources.nixpkgs haskellNix.nixpkgsArgs;

122+ nixpkgs = import haskellNix.sources.nixpkgs-1909 haskellNix.nixpkgsArgs;

131 haskell = nixpkgs.haskell-nix;

123 haskell = nixpkgs.haskell-nix;

132in

124in

133 haskell.snapshots."lts-13.18".alex.components.exes.alex

125 haskell.snapshots."lts-13.18".alex.components.exes.alex

docs/tutorials/getting-started-flakes.mddeleted−142

@@ -1,142 +0,0 @@

1−# Getting started with flakes

2−

3−This version of the getting started guide is for users who

4−are using [Nix Flakes](https://nixos.wiki/wiki/Flakes).

5−The non flakes version of the guide is [here](getting-started.md).

6−

7−`haskell.nix` can automatically translate your

8−[Cabal](https://cabal.readthedocs.io/en/latest/cabal-project.html)

9−or [Stack](https://docs.haskellstack.org/en/stable/README/#quick-start-guide)

10−project and its dependencies into Nix code.

11−

12−Assuming you have [Nix](https://nixos.org/download.html) installed, you can

13−start setting up your project.

14−

15−## Setting up the binary cache

16−

17−IMPORTANT: you *must* do this or you *will* build several copies of GHC!

18−

19−You can configure Nix to use our binary cache, which is pushed to by CI, so should contain the artifacts that you need.

20−

21−You need to add the following sections to `/etc/nix/nix.conf` or, if you are a trusted user, `~/.config/nix/nix.conf` (if you don't know what a "trusted user" is, you probably want to do the former).

22−

23−```

24−trusted-public-keys = [...] hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ= [...]

25−substituters = [...] https://cache.iog.io [...]

26−```

27−

28−If you're running NixOS, you need to add/update the following in your `/etc/nixos/configuration.nix` files instead.

29−

30−```

31−# Binary Cache for Haskell.nix

32−nix.settings.trusted-public-keys = [

33− "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

34−];

35−nix.settings.substituters = [

36− "https://cache.iog.io"

37−];

38−```

39−

40−NixOS-21.11 and older use slightly different settings.

41−

42−```

43−# Binary Cache for Haskell.nix

44−nix.binaryCachePublicKeys = [

45− "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

46−];

47−nix.binaryCaches = [

48− "https://cache.iog.io"

49−];

50−```

51−

52−This can be tricky to get setup properly. If you're still having trouble getting cache hits, consult the corresponding [troubleshooting section](../troubleshooting.md#why-am-i-building-ghc).

53−

54−## Scaffolding

55−

56−The following work with `stack.yaml` and `cabal.project` based

57−projects.

58−

59−Add `flake.nix`:

60−

61−```nix

62−{

63− description = "A very basic flake";

64− inputs.haskellNix.url = "github:input-output-hk/haskell.nix";

65− inputs.nixpkgs.follows = "haskellNix/nixpkgs-unstable";

66− inputs.flake-utils.url = "github:numtide/flake-utils";

67− outputs = { self, nixpkgs, flake-utils, haskellNix }:

68− flake-utils.lib.eachSystem [ "x86_64-linux" "x86_64-darwin" ] (system:

69− let

70− overlays = [ haskellNix.overlay

71− (final: prev: {

72− # This overlay adds our project to pkgs

73− helloProject =

74− final.haskell-nix.project' {

75− src = ./.;

76− compiler-nix-name = "ghc8104";

77− # This is used by `nix develop .` to open a shell for use with

78− # `cabal`, `hlint` and `haskell-language-server`

79− shell.tools = {

80− cabal = {};

81− hlint = {};

82− haskell-language-server = {};

83− };

84− # Non-Haskell shell tools go here

85− shell.buildInputs = with pkgs; [

86− nixpkgs-fmt

87− ];

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

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

90− };

91− })

92− ];

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

94− flake = pkgs.helloProject.flake {

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

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

97− };

98− in flake // {

99− # Built by `nix build .`

100− defaultPackage = flake.packages."hello:exe:hello";

101− });

102−}

103−```

104−

105−!!! note "git dependencies"

106− If you have git dependencies in your project, you'll need

107− to [calculate sha256 hashes for them](./source-repository-hashes.md).

108−

109−### Working with a project

110−

111−Top-level attributes are Haskell packages (incl. dependencies) part of your project.

112−

113−To build the library component of a package in the project run:

114−

115−```shell

116−nix build .#your-package-name:lib:your-package-name

117−```

118−

119−There are also other components such as `exe`, `test` and `benchmark`.

120−To build an executable:

121−

122−```shell

123−nix build .#your-package-name:exe:your-exe-name

124−```

125−

126−To use the `devShell` provided by the flake run:

127−

128−```shell

129−nix develop .

130−cabal repl your-package-name:lib:your-package-name

131−cabal build your-package-name

132−```

133−

134−To open a shell for use with `stack` see [the following issue](https://github.com/input-output-hk/haskell.nix/issues/689#issuecomment-643832619).

135−

136−## Going forward

137−

138−Read through [project](../reference/library.md#project) function reference to see how the API works.

139−

140−There are a number of things to explore further in the tutorials section.

141−

142−[haskell.nix]: https://github.com/input-output-hk/haskell.nix

docs/tutorials/getting-started-hix.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+26−110

@@ -18,61 +18,10 @@ 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

24−If you're running NixOS, you need to add/update the following in your `/etc/nixos/configuration.nix` files instead.

25−

26−```

27−# Binary Cache for Haskell.nix

28−nix.settings.trusted-public-keys = [

29− "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

30−];

31−nix.settings.substituters = [

32− "https://cache.iog.io"

33−];

34−```

35−

36−NixOS-21.11 and older use slightly different settings.

37−

38−```

39−# Binary Cache for Haskell.nix

40−nix.binaryCachePublicKeys = [

41− "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

42−];

43−nix.binaryCaches = [

44− "https://cache.iog.io"

45−];

46−```

47−

48−This can be tricky to get setup properly. If you're still having trouble getting cache hits, consult the corresponding [troubleshooting section](../troubleshooting.md#why-am-i-building-ghc).

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

49−

50−## Niv

51−

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

53−

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

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

56−is to use Niv. If you prefer not to use Niv another option is described

57−in the in the "Using haskell.nix without niv" section of this document.

58−

59−If you want to use Nix Flakes to pin your dependencies then you should

60−consider following the [Getting started with flakes](./getting-started-flakes.md)

61−document instead of this one.

62−

63−After installing niv you can initialize niv and pin the latest haskell.nix

64−commit by running the following in the root directory of the project:

65−

66−```

67−niv init

68−niv add input-output-hk/haskell.nix -n haskellNix

69−```

70−

71−Then when you want to update to the latest version of haskellNix use:

72−

73−```

74−niv update haskellNix

75−```

76

25

77## Scaffolding

26## Scaffolding

78

27

@@ -82,28 +31,21 @@ projects.

82Add `default.nix`:

31Add `default.nix`:

83

32

84```nix

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

34+{ # Fetch the latest haskell.nix and import its default.nix

93− haskellNix = import sources.haskellNix {};

35+ haskellNix ? import (builtins.fetchTarball "https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz") {}

94− # If haskellNix is not found run:

36+

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,

37+# 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.

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

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

102− haskellNix.sources.nixpkgs-unstable

40+, nixpkgsSrc ? haskellNix.sources.nixpkgs-2003

41+

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

42+# haskell.nix provides some arguments to be passed to nixpkgs, including some

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

43+# patches and also the haskell.nix functionality itself as an overlay.

105− haskellNix.nixpkgsArgs;

44+, nixpkgsArgs ? haskellNix.nixpkgsArgs

45+

46+# import nixpkgs with overlays

47+, pkgs ? import nixpkgsSrc nixpkgsArgs

106−in pkgs.haskell-nix.project {

48+}: pkgs.haskell-nix.project {

107 # 'cleanGit' cleans a source directory based on the files known by git

49 # 'cleanGit' cleans a source directory based on the files known by git

108 src = pkgs.haskell-nix.haskellLib.cleanGit {

50 src = pkgs.haskell-nix.haskellLib.cleanGit {

109 name = "haskell-nix-project";

51 name = "haskell-nix-project";

@@ -135,47 +77,20 @@ To build an executable:

135nix-build -A your-package-name.components.exes.your-exe-name

77nix-build -A your-package-name.components.exes.your-exe-name

136```

78```

137

79

138−To cross compile use the `projectCross` attribute:

139−

140−```

141−nix-build -A projectCross.ghcjs.hsPkgs.your-package-name.components.exes.your-exe-name

142−nix-build -A projectCross.mingwW64.hsPkgs.your-package-name.components.exes.your-exe-name

143−```

144−

145−To open a shell for use with `cabal`, `hlint` and `haskell-language-server` add `shell.nix`:

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

81

159```shell

82```shell

160−nix-shell

83+nix-shell -A shellFor

161cabal new-repl your-package-name:library:your-package-name

84cabal new-repl your-package-name:library:your-package-name

162cabal new-build your-package-name

85cabal new-build your-package-name

163```

86```

164

87

165To open a shell for use with `stack` see [the following issue](https://github.com/input-output-hk/haskell.nix/issues/689#issuecomment-643832619).

88To open a shell for use with `stack` see [the following issue](https://github.com/input-output-hk/haskell.nix/issues/689#issuecomment-643832619).

166

89

167−## Using haskell.nix without Niv

90+### 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−

172−```nix

173−let sources = {

174− haskellNix = builtins.fetchTarball "https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz";

175− };

176−```

177

91

92+For simplicity's sake we will use `fetchTarball` for the examples in

178−The `fetchTarball` call above will always get the latest version, and is

93+this documentation. This will always get the latest version, and is

179similar to an auto-updating Nix channel.

94similar to an auto-updating Nix channel.

180

95

181However, in your own project, you may wish to pin [haskell.nix][] (as

96However, in your own project, you may wish to pin [haskell.nix][] (as

@@ -185,9 +100,10 @@ predictable, and faster (because the fixed version is cached).

185Straightforward way of doing this is to change the branch name to a revision.

100Straightforward way of doing this is to change the branch name to a revision.

186

101

187```nix

102```nix

188−let sources = {

103+{ # 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";

104+ haskellNix ? import (builtins.fetchTarball "https://github.com/input-output-hk/haskell.nix/archive/f1a94a4c82a2ab999a67c3b84269da78d89f0075.tar.gz") {}

190− };

105+

106+...

191```

107```

192

108

193There are other possible schemes for pinning. See

109There 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+6−32

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

@@ -29,39 +29,13 @@ nixpkgs.overlays = [

29];

30```

31

32−### Replace libraries of components

33−

34−If a component is missing a dependency it can be added via modules. For example:

35−

36−``` nix

37−project = pkgs.haskell-nix.project' {

38− src = self;

39− compiler-nix-name = "ghc8102";

40− modules = [{

41− # Replace `extra-libraries` dependencies

42− packages.X11.components.library.libs = pkgs.lib.mkForce (with pkgs.xorg;

43− [ libX11 libXrandr libXext libXScrnSaver libXinerama ]);

44− }];

45−};

46−```

47−

48### Mapping in Haskell.nix

32### Mapping in Haskell.nix

49

33

50Alternatively, if the name is commonly used, an alias can be added to

34Alternatively, if the name is commonly used, an alias can be added to

51the Haskell.nix sources, so that it's solved for all users.

35the Haskell.nix sources, so that it's solved for all users.

52

36

53−* [`lib/pkgconf-nixpkgs-map.nix`](https://github.com/input-output-hk/haskell.nix/blob/master/lib/pkgconf-nixpkgs-map.nix)

37+* [`lib/pkgconf-nixpkgs-map.nix`](https://github.com/input-output-hk/haskell.nix/blob/master/lib/pkgconf-nixpkgs-map.nix) - for `pkgconfig-depends`

54− — for `pkgconfig-depends`.

55−

56− Each mapping entry is a list of packages.

57−

58−* [`lib/system-nixpkgs-map.nix`](https://github.com/input-output-hk/haskell.nix/blob/master/lib/system-nixpkgs-map.nix)

38+* [`lib/system-nixpkgs-map.nix`](https://github.com/input-output-hk/haskell.nix/blob/master/lib/system-nixpkgs-map.nix) - for `build-tool-depends`, `frameworks`, `extra-libraries`, etc.

59− — for `build-tool-depends`, `frameworks`, `extra-libraries`, etc.

60−

61− Each name can be mapped to:

62− 1. A single package from nixkpgs.

63− 2. `null` — eliminates the dependency

64− 3. A list of packages — sometimes needed for dependencies such as `X11`.

65

39

66!!! tip "Open a PR"

40!!! tip "Open a PR"

67 Please go ahead and open a [pull request](https://github.com/input-output-hk/haskell.nix/pulls)

41 Please go ahead and open a [pull request](https://github.com/input-output-hk/haskell.nix/pulls)

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+29−143

@@ -1,148 +1,34 @@

1{

2 description = "Alternative Haskell Infrastructure for Nixpkgs";

3

4− inputs = {

4+ outputs = { self }: {

5− nixpkgs.follows = "nixpkgs-unstable";

5+ # Using the eval-on-build version here as the plan is that

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

6+ # `builtins.currentSystem` will not be supported in flakes.

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

7+ # https://github.com/NixOS/rfcs/pull/49/files#diff-a5a138ca225433534de8d260f225fe31R429

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

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

10− nixpkgs-unstable = { url = "github:NixOS/nixpkgs/nixpkgs-unstable"; };

11− flake-utils = { url = "github:numtide/flake-utils"; };

12− hydra.url = "hydra";

13− hackage = {

14− url = "github:input-output-hk/hackage.nix";

15− flake = false;

16− };

17− stackage = {

18− url = "github:input-output-hk/stackage.nix";

19− flake = false;

20− };

21− cabal-32 = {

22− url = "github:haskell/cabal/3.2";

23− flake = false;

24− };

25− cabal-34 = {

26− url = "github:haskell/cabal/3.4";

27− flake = false;

28− };

29− cabal-36 = {

30− url = "github:haskell/cabal/3.6";

31− flake = false;

32− };

33− cardano-shell = {

34− url = "github:input-output-hk/cardano-shell";

35− flake = false;

36− };

37− "ghc-8.6.5-iohk" = {

38− type = "github";

39− owner = "input-output-hk";

40− repo = "ghc";

41− ref = "release/8.6.5-iohk";

42− flake = false;

43− };

44− hpc-coveralls = {

45− url = "github:sevanspowell/hpc-coveralls";

46− flake = false;

47− };

48− nix-tools = {

49− url = "github:input-output-hk/nix-tools";

50− flake = false;

51− };

52− old-ghc-nix = {

53− url = "github:angerman/old-ghc-nix/master";

54− flake = false;

55− };

56− HTTP = {

57− url = "github:phadej/HTTP";

58− flake = false;

59− };

60− };

61−

62− outputs = { self, nixpkgs, nixpkgs-unstable, nixpkgs-2105, nixpkgs-2111, nixpkgs-2205, flake-utils, ... }@inputs:

63− let compiler = "ghc924";

64− config = import ./config.nix;

65− in {

66− inherit config;

67− overlay = self.overlays.combined;

8+ overlay = (self.overlays {sourcesOverride = self.sources;}).combined-eval-on-build;

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

9+ overlays = import ./overlays;

69− internal = rec {

10+ config = import ./config.nix;

70− nixpkgsArgs = {

11+ # We can't import ./nix/sources.nix directly, because that uses nixpkgs to fetch by default,

71− inherit config;

12+ # and importing nixpkgs without specifying localSystem doesn't work on flakes.

72− overlays = [ self.overlay ];

13+ sources = let

73− };

14+ sourcesInfo =

74−

15+ builtins.fromJSON (builtins.readFile ./nix/sources.json);

75− sources = inputs;

16+ fetch = sourceInfo:

17+ builtins.fetchTarball { inherit (sourceInfo) url sha256; };

18+ in builtins.mapAttrs (_: fetch) sourcesInfo;

76

19

77− overlaysOverrideable = import ./overlays;

20+ 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;

21+ inherit (self) config;

85− # We are overriding 'overlays' and 'nixpkgsArgs' from the

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

23+ };

95− })

96− ]

97− else

98− [ ]);

99− nixpkgsArgs = {

100− inherit config overlays;

101− };

102− pkgs = import nixpkgs

103− (nixpkgsArgs // { localSystem = { inherit system; }; });

104− pkgs-2105 = import nixpkgs-2105

105− (nixpkgsArgs // { localSystem = { inherit system; }; });

106− pkgs-2111 = import nixpkgs-2111

107− (nixpkgsArgs // { localSystem = { inherit system; }; });

108− pkgs-2205 = import nixpkgs-2205

109− (nixpkgsArgs // { localSystem = { inherit system; }; });

110− pkgs-unstable = import nixpkgs-unstable

111− (nixpkgsArgs // { localSystem = { inherit system; }; });

112− hix = import ./hix/default.nix { inherit pkgs; };

113− };

114− };

115−

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

117− # uses IFD heavily, you have to have the ability to build for all platforms

118− # supported by haskell.nix, e.g. with remote builders, in order to check this flake.

119− # If you want to run the tests for just your platform, run `./test/tests.sh` or

120− # `nix-build -A checks.$PLATFORM`

121− } // flake-utils.lib.eachSystem [ "x86_64-linux" "x86_64-darwin" "aarch64-linux" "aarch64-darwin" ] (system: rec {

122− legacyPackages = (self.internal.compat { inherit system; }).pkgs;

24+ legacyPackages = let

123− legacyPackagesUnstable = (self.internal.compat { inherit system; }).pkgs-unstable;

25+ genAttrs = lst: f:

124−

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

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

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

26+ builtins.listToAttrs (map (name: {

128− name = pkg.name;

27+ inherit name;

129− value = pkg;

28+ value = f name;

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

29+ }) lst);

135− # Exposed so that buildkite can check that `allow-import-from-derivation=false` works for core of haskell.nix

30+ in genAttrs [ "x86_64-linux" "x86_64-darwin" ] (system:

136− roots = legacyPackagesUnstable.haskell-nix.roots compiler;

31+ import self.sources.nixpkgs

137−

32+ (self.nixpkgsArgs // { localSystem = { inherit system; }; }));

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

139− mkShell {

140− buildInputs = [

141− nixUnstable

142− cabal-install

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

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

145− ];

146− };

147− });

33+ };

148}

34}

hackage-src.json+4−7

@@ -1,10 +1,7 @@

1{

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

3− "rev": "9bdefa51c864bbef48a2758b05b4b568f0ded62b",

3+ "rev": "fa7813199b44bd6a53ce84db798732f72a29c057",

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

4+ "date": "2020-11-21T01:12:24+00:00",

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

5+ "sha256": "095zpw0909rk2z0w8r9sh6yfv6aykksfvf7v792xjfsrc3kggz98",

6− "sha256": "0pm3m864wwgf76isjwb8244xh8xykc94b5az6zb1h38q30s9xjji",

7− "fetchSubmodules": false,

6+ "fetchSubmodules": false

8− "deepClone": false,

9− "leaveDotGit": false

10}

7}

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-licenses.nix+21−18

@@ -1,21 +1,24 @@

1−pkgs:

1+lib: with lib.licenses;

2−let licenses = import spdx/licenses.nix pkgs;

2+{ BSD-3-Clause = bsd3;

3−in licenses // {

3+ BSD-2-Clause = bsd2;

4+ MIT = mit;

5+ "MPL-2.0" = mpl20;

6+ ISC = isc;

7+ "LGPL-2.1-only" = lgpl21;

8+ "LGPL-3.0-only" = lgpl3;

9+ "GPL-2.0-only" = gpl2;

10+ "GPL-2.0-or-later" = gpl2Plus;

11+ "GPL-3.0-only" = gpl3;

12+ "AGPL-3.0-only" = agpl3;

13+ "AGPL-3.0-or-later" = agpl3Plus;

14+ "Apache-2.0" = asl20;

15+ "GPL-2.0-or-later AND BSD-3-Clause" = [gpl2Plus bsd3];

16+ "NCSA" = ncsa;

4 # Generic

17 # Generic

5− LicenseRef-PublicDomain = {

18+ LicenseRef-Apache = "Apache";

6− spdxId = "LicenseRef-PublicDomain";

19+ LicenseRef-GPL = "GPL";

7− shortName = "Public Domain";

20+ LicenseRef-LGPL = "LGPL";

8− fullName = "This work is dedicated to the Public Domain";

21+ LicenseRef-PublicDomain = publicDomain;

9− url = "https://wikipedia.org/wiki/Public_domain";

10− free = true;

11− };

12− LicenseRef-OtherLicense = {

13− spdxId = "LicenseRef-OtherLicense";

22+ LicenseRef-OtherLicense = null;

14− shortName = "Other License";

15− fullName = "Unidentified Other License";

16− url = "https://spdx.github.io/spdx-spec/appendix-IV-SPDX-license-expressions/";

17− # Not setting `free` here. The license may or may not be `free`.

18− # See https://github.com/input-output-hk/haskell.nix/pull/1006

19− };

20 NONE = null;

23 NONE = null;

21}

24}

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+77−216

@@ -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,59 +32,18 @@ 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;

86

47

87 ghc' =

48 ghc' =

88 if ghcOverride != null

49 if ghcOverride != null

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

114 ghc = ghc';

75 ghc = ghc';

115 subDir' = src.origSubDir or "";

76 subDir' = src.origSubDir or "";

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

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

117−

78+ maybeCleanedSource =

79+ if haskellLib.canCleanSource src

118− cleanedSource = haskellLib.cleanSourceWith {

80+ then (haskellLib.cleanSourceWith {

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

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

120− src = src.origSrc or src;

82+ src = src.origSrc or src;

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

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

122− type == "directory" ||

84+ type == "directory" ||

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

85+ pkgs.lib.any (i: (pkgs.lib.hasSuffix i path)) [ ".cabal" "package.yaml" ]); })

86+ else src.origSrc or src;

124

87

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

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

89 # access to the store is restricted. If origSrc was already in the store

@@ -148,9 +111,8 @@ let

148 then index-state

111 then index-state

149 else if cabalProjectIndexState != null

112 else if cabalProjectIndexState != null

150 then cabalProjectIndexState

113 then cabalProjectIndexState

151− else

152− let latest-index-state = pkgs.lib.last (builtins.attrNames index-state-hashes);

153− in builtins.trace ("No index state specified" + (if name == null then "" else " for " + name) + ", using the latest index state that we know about (${latest-index-state})!") latest-index-state;

114+ else builtins.trace ("Using latest index state" + (if name == null then "" else " for " + name) + "!")

115+ (pkgs.lib.last (builtins.attrNames index-state-hashes));

154

116

155 index-state-pinned = index-state != null || cabalProjectIndexState != null;

117 index-state-pinned = index-state != null || cabalProjectIndexState != null;

156

118

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

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

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

201 "echo -n $(${pkgs.nix}/bin/nix-hash --type sha256 --base32 ${path}) > $out");

163 "echo -n $(${pkgs.nix}/bin/nix-hash --type sha256 --base32 ${path}) > $out");

202

164

203− replaceSourceRepos = projectFile:

165+ replaceSoureRepos = projectFile:

204 let

166 let

205− fetchPackageRepo = fetchgit: repoData:

167+ fetchRepo = fetchgit: repoData:

206 let

168 let

207 fetched =

169 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

170+ if repoData.sha256 != null

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

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

217 else

172 else

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

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

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

175+ (__trace "Consider adding `--sha256: ${hashPath drv}` to the ${cabalProjectFileName} file or passing in a lookupSha256 argument"

221 drv);

176 drv);

222− in {

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

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

224− # repository that `cabal` will be able to access from a non fixed output derivation.

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

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

227− } ''

228− mkdir $out

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

230− cd $out

231− chmod -R +w .

232− git init -b minimal

233− git add --force .

234− GIT_COMMITTER_NAME='No One' GIT_COMMITTER_EMAIL= git commit -m "Minimal Repo For Haskell.Nix" --author 'No One <>'

235− '';

236− inherit (repoData) subdirs;

237− inherit fetched;

238− tag = "minimal";

239− };

240−

241− # Parse the `source-repository-package` blocks

242− sourceRepoPackageResult = pkgs.haskell-nix.haskellLib.parseSourceRepositoryPackages

243− cabalProjectFileName sha256map source-repo-override projectFile;

244

178

245− # Parse the `repository` blocks

179+ blocks = pkgs.lib.splitString "\nsource-repository-package\n" ("\n" + projectFile);

246− repoResult = pkgs.haskell-nix.haskellLib.parseRepositories

180+ initialText = pkgs.lib.lists.take 1 blocks;

247− evalPackages cabalProjectFileName sha256map inputMap cabal-install nix-tools sourceRepoPackageResult.otherText;

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

182+ sourceRepoData = pkgs.lib.lists.concatMap (x: x.sourceRepo) repoBlocks;

183+ otherText = pkgs.evalPackages.writeText "cabal.project" (pkgs.lib.strings.concatStringsSep "\n" (

184+ initialText

185+ ++ (builtins.map (x: x.otherText) repoBlocks)));

248

186

249 # we need the repository content twice:

187 # we need the repository content twice:

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

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

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

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

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

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

253 # * at built time (passed out)

191 # * at built time (passed out)

254 # Here we want to use plain pkgs.fetchgit, which is what a builder

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

193 # on the target system would use, so that the derivation is unaffected

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

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

257 # as built by a darwin builder, and fetch it from a cache

195 # as built by a darwin builder, and fetch it from a cache

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

196+ sourceReposBuild = builtins.map (fetchRepo pkgs.evalPackages.fetchgit) sourceRepoData ;

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

197+ sourceReposEval = builtins.map (fetchRepo pkgs.fetchgit) sourceRepoData;

260 in {

198 in {

261 sourceRepos = sourceReposBuild;

199 sourceRepos = sourceReposBuild;

262− inherit (repoResult) repos extra-hackages;

263 makeFixedProjectFile = ''

200 makeFixedProjectFile = ''

264− cp -f ${evalPackages.writeText "cabal.project" sourceRepoPackageResult.otherText} ./cabal.project

201+ cp -f ${otherText} ./cabal.project

265− '' +

266− pkgs.lib.optionalString (builtins.length sourceReposEval != 0) (''

267 chmod +w -R ./cabal.project

202 chmod +w -R ./cabal.project

268 # The newline here is important in case cabal.project does not have one at the end

203 # The newline here is important in case cabal.project does not have one at the end

269− echo >> ./cabal.project

204+ printf "\npackages:" >> ./cabal.project

205+ mkdir -p ./.source-repository-packages

270 '' +

206 '' +

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 (

207+ ( pkgs.lib.strings.concatStrings (

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

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

286− (cd $out${subDir'}

209+ mkdir -p ./.source-repository-packages/${builtins.toString n}

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

210+ rsync -a --prune-empty-dirs \

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

211+ --include '*/' --include '*.cabal' --include 'package.yaml' \

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

212+ --exclude '*' \

290− done)

213+ "${f}/" "./.source-repository-packages/${builtins.toString n}/"

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

291 '')

215 '')

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

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

293 sourceReposEval

217 sourceReposEval

294− );

218+ )

219+ );

295 };

220 };

296

221

297 fixedProject =

222 fixedProject =

298 if rawCabalProject == null

223 if rawCabalProject == null

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

224+ then { sourceRepos = []; makeFixedProjectFile = ""; }

300− else replaceSourceRepos rawCabalProject;

225+ else replaceSoureRepos rawCabalProject;

301

226

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

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

303 # * For hydra to assemble a list of jobs from `components.tests` it must

228 # * For hydra to assemble a list of jobs from `components.tests` it must

@@ -368,12 +293,12 @@ let

368 '');

293 '');

369

294

370 # Dummy `ghc` that uses the captured output

295 # Dummy `ghc` that uses the captured output

371− dummy-ghc = evalPackages.writeTextFile {

296+ dummy-ghc = pkgs.evalPackages.writeTextFile {

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

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

373 executable = true;

298 executable = true;

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

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

375 text = ''

300 text = ''

376− #!${evalPackages.runtimeShell}

301+ #!${pkgs.evalPackages.runtimeShell}

377 case "$*" in

302 case "$*" in

378 --version*)

303 --version*)

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

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

@@ -411,12 +336,12 @@ let

411 };

336 };

412

337

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

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

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

339+ dummy-ghc-pkg = pkgs.evalPackages.writeTextFile {

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

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

416 executable = true;

341 executable = true;

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

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

418 text = ''

343 text = ''

419− #!${evalPackages.runtimeShell}

344+ #!${pkgs.evalPackages.runtimeShell}

420 case "$*" in

345 case "$*" in

421 --version)

346 --version)

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

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

@@ -444,7 +369,6 @@ let

444 inherit materialized;

369 inherit materialized;

445 sha256 = plan-sha256;

370 sha256 = plan-sha256;

446 sha256Arg = "plan-sha256";

371 sha256Arg = "plan-sha256";

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

448 # Before pinning stuff down we need an index state to use

372 # Before pinning stuff down we need an index state to use

449 reasonNotSafe =

373 reasonNotSafe =

450 if !index-state-pinned

374 if !index-state-pinned

@@ -452,55 +376,24 @@ let

452 else null;

376 else null;

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

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

454 inherit checkMaterialization;

378 inherit checkMaterialization;

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

379+ }) (pkgs.evalPackages.runCommand (if name == null then "plan-to-nix-pkgs" else name + "-plan-to-nix-pkgs") {

456− nativeBuildInputs = [ nix-tools dummy-ghc dummy-ghc-pkg cabal-install evalPackages.rsync evalPackages.gitMinimal ];

380+ nativeBuildInputs = [ nix-tools dummy-ghc dummy-ghc-pkg cabal-install pkgs.evalPackages.rsync ];

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

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

382+ LOCALE_ARCHIVE = pkgs.lib.optionalString (pkgs.evalPackages.stdenv.buildPlatform.libc == "glibc") "${pkgs.evalPackages.glibcLocales}/lib/locale/locale-archive";

459 LANG = "en_US.UTF-8";

383 LANG = "en_US.UTF-8";

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

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

461 preferLocalBuild = false;

385 preferLocalBuild = false;

462− outputs = [

463− "out" # The results of plan-to-nix

464− # These two output will be present if in cabal configure failed.

465− # They are used to provide passthru.json and passthru.freeze that

466− # check first for cabal configure failure.

467− "maybeJson" # The `plan.json` file generated by cabal and used for `plan-to-nix` input

468− "maybeFreeze" # The `cabal.project.freeze` file created by `cabal v2-freeze`

469− ];

470− passthru =

471− let

472− checkCabalConfigure = ''

473− if [[ -f ${plan-nix}/cabal-configure.out ]]; then

474− cat ${plan-nix}/cabal-configure.out

475− exit 1

476− fi

477− '';

478− in {

479− # These check for cabal configure failure

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

481− ${checkCabalConfigure}

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

483− '';

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

485− ${checkCabalConfigure}

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

487− '';

488− };

489 } ''

386 } ''

490 tmp=$(mktemp -d)

387 tmp=$(mktemp -d)

491 cd $tmp

388 cd $tmp

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

389+ # if maybeCleanedSource is empty, this means it's a new

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

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

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

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

495 # message to prevent headaches (#290).

392 # message to prevent headaches (#290).

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

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

497− echo "cleaned source is empty. Did you forget to 'git add -A'?"

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

395 fi

396+ cp -r ${maybeCleanedSource}/* .

504 chmod +w -R .

397 chmod +w -R .

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

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

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

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

@@ -523,35 +416,28 @@ let

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

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

524 ${fixedProject.makeFixedProjectFile}

417 ${fixedProject.makeFixedProjectFile}

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

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

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

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

527 cabal.project.freeze

420 cabal.project.freeze

528− chmod +w cabal.project.freeze

529 ''}

421 ''}

530 export SSL_CERT_FILE=${cacert}/etc/ssl/certs/ca-bundle.crt

422 export SSL_CERT_FILE=${cacert}/etc/ssl/certs/ca-bundle.crt

531 export GIT_SSL_CAINFO=${cacert}/etc/ssl/certs/ca-bundle.crt

423 export GIT_SSL_CAINFO=${cacert}/etc/ssl/certs/ca-bundle.crt

532−

533− # Using `cabal v2-freeze` will configure the project (since

534− # it is not configured yet), taking the existing `cabal.project.freeze`

535− # file into account. Then it "writes out a freeze file which

536− # records all of the versions and flags that are picked" (from cabal docs).

537− echo "Using index-state ${index-state-found}"

538− if(HOME=${

424+ HOME=${

539 # This creates `.cabal` directory that is as it would have

425 # This creates `.cabal` directory that is as it would have

540 # been at the time `cached-index-state`. We may include

426 # been at the time `cached-index-state`. We may include

541 # some packages that will be excluded by `index-state-found`

427 # some packages that will be excluded by `index-state-found`

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

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

543 dotCabal {

429 dotCabal {

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

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

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

546 index-state = cached-index-state;

431 index-state = cached-index-state;

547 sha256 = index-sha256-found;

432 sha256 = index-sha256-found;

548 }

433 }

549− } cabal v2-freeze ${

434+ } cabal v2-configure \

435+ --index-state=${

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

436+ # Setting the desired `index-state` here in case it was not

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

437+ # from the cabal.project file. This will further restrict the

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

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

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

439+ builtins.trace ("Using index-state: ${index-state-found}" + (if name == null then "" else " for " + name))

554− } \

440+ index-state-found} \

555 -w ${

441 -w ${

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

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

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

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

@@ -561,14 +447,10 @@ let

561 --enable-benchmarks \

447 --enable-benchmarks \

562 ${pkgs.lib.optionalString (ghc.targetPrefix == "js-unknown-ghcjs-")

448 ${pkgs.lib.optionalString (ghc.targetPrefix == "js-unknown-ghcjs-")

563 "--ghcjs --with-ghcjs=js-unknown-ghcjs-ghc --with-ghcjs-pkg=js-unknown-ghcjs-ghc-pkg"} \

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

450+ ${configureArgs}

565

451

566 mkdir -p $out

452 mkdir -p $out

567

453

568− cp cabal.project.freeze $maybeFreeze

569− # Not needed any more (we don't want it to wind up in the $out hash)

570− rm cabal.project.freeze

571−

572 # ensure we have all our .cabal files (also those generated from package.yaml) files.

454 # ensure we have all our .cabal files (also those generated from package.yaml) files.

573 # otherwise we'd need to be careful about putting the `cabal-generator = hpack` into

455 # otherwise we'd need to be careful about putting the `cabal-generator = hpack` into

574 # the nix expression. As we already called `hpack` on all `package.yaml` files we can

456 # the nix expression. As we already called `hpack` on all `package.yaml` files we can

@@ -589,44 +471,23 @@ let

589 # proper relative paths.

471 # proper relative paths.

590 (cd $out${subDir'} && plan-to-nix --full --plan-json $tmp${subDir'}/dist-newstyle/cache/plan.json -o .)

472 (cd $out${subDir'} && plan-to-nix --full --plan-json $tmp${subDir'}/dist-newstyle/cache/plan.json -o .)

591

473

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

593− ${fixedProject.replaceLocations}

594−

595− # Make the plan.json file available in case we need to debug plan-to-nix

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

597−

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

474 # Remove the non nix files ".project" ".cabal" "package.yaml" files

599 # as they should not be in the output hash (they may change slightly

475 # as they should not be in the output hash (they may change slightly

600 # without affecting the nix).

476 # without affecting the nix).

477+ if [ -d $out${subDir'}/.source-repository-packages ]; then

478+ chmod +w -R $out${subDir'}/.source-repository-packages

479+ rm -rf $out${subDir'}/.source-repository-packages

480+ fi

601 find $out $ -type f -or -type l $ ! -name '*.nix' -delete

481 find $out $ -type f -or -type l $ ! -name '*.nix' -delete

602 # Remove empty dirs

482 # Remove empty dirs

603 find $out -type d -empty -delete

483 find $out -type d -empty -delete

604

484

605 # move pkgs.nix to default.nix ensure we can just nix `import` the result.

485 # move pkgs.nix to default.nix ensure we can just nix `import` the result.

606 mv $out${subDir'}/pkgs.nix $out${subDir'}/default.nix

486 mv $out${subDir'}/pkgs.nix $out${subDir'}/default.nix

607− else

608− # Check that this was a solver failure that (not some other

609− # possibly non deterministic failure).

610− # TODO replace grep once https://github.com/haskell/cabal/issues/5191

611− # is fixed.

612− grep "cabal: Could not resolve dependencies" cabal-configure.out

613−

614− # When cabal configure fails copy the output that we captured above and

615− # use `failed-cabal-configure.nix` to make a suitable derviation with.

616− mkdir -p $out${subDir'}

617− cp cabal-configure.out $out${subDir'}

618− cp ${./failed-cabal-configure.nix} $out${subDir'}/default.nix

619−

620− # These should only be used indirectly by `passthru.json` and `passthru.freeze`.

621− # Those derivations will check for `cabal-configure.out` out first to see if

622− # it is ok to use these files.

623− echo "Cabal configure failed see $out${subDir'}/cabal-configure.out for details" > $maybeJson

624− echo "Cabal configure failed see $out${subDir'}/cabal-configure.out for details" > $maybeFreeze

625− fi

626 '');

487 '');

627in {

488in {

628 projectNix = plan-nix;

489 projectNix = plan-nix;

629 index-state = index-state-found;

490 index-state = index-state-found;

630 inherit src;

491 inherit src;

631− inherit (fixedProject) sourceRepos extra-hackages;

492+ inherit (fixedProject) sourceRepos;

632}

493}

lib/call-stack-to-nix.nix+18−33

@@ -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 ];

@@ -44,40 +34,35 @@ let

44 sha256 = stack-sha256;

34 sha256 = stack-sha256;

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 "");

48− } // evalPackages.lib.optionalAttrs (checkMaterialization != null) {

37+ } // pkgs.lib.optionalAttrs (checkMaterialization != null) {

49 inherit checkMaterialization;

38 inherit checkMaterialization;

50 }) (runCommand (if name == null then "stack-to-nix-pkgs" else name + "-stack-to-nix-pkgs") {

39 }) (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 ];

40+ nativeBuildInputs = [ nix-tools pkgs.nix-prefetch-git pkgs.cacert pkgs.xorg.lndir ];

52 # Needed or stack-to-nix will die on unicode inputs

41 # 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";

42+ LOCALE_ARCHIVE = pkgs.lib.optionalString (pkgs.stdenv.hostPlatform.libc == "glibc") "${pkgs.glibcLocales}/lib/locale/locale-archive";

54 LANG = "en_US.UTF-8";

43 LANG = "en_US.UTF-8";

55 LC_ALL = "en_US.UTF-8";

44 LC_ALL = "en_US.UTF-8";

56 preferLocalBuild = false;

45 preferLocalBuild = false;

57 } (''

46 } (''

58 mkdir -p $out${subDir'}

47 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 ${

48 ${

71− # If a resolver was fetched use the it instead of the original stack.yaml

49+ # If no resolver was fetched use the original stack.yaml

72− evalPackages.lib.optionalString (fetchedResolver != null)

50+ if fetchedResolver == null

51+ then ''

52+ SRC=${src}

53+ ''

54+ else

73 # Replace the resolver path in the stack.yaml with the fetched version

55 # Replace the resolver path in the stack.yaml with the fetched version

74 ''

56 ''

57+ SRC=$(mktemp -d)

58+ cd $SRC

59+ lndir -silent "${src}/." $SRC

75 rm ${stackYaml}

60 rm ${stackYaml}

76 cp ${src}/${stackYaml} .

61 cp ${src}/${stackYaml} .

77 chmod +w ${stackYaml}

62 chmod +w ${stackYaml}

78 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

63 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

79 ''}

64 ''}

80− ${evalPackages.lib.optionalString (cache != null) ''

65+ ${pkgs.lib.optionalString (cache != null) ''

81 cp ${mkCacheFile cache}/.stack-to-nix.cache* $out${subDir'}

66 cp ${mkCacheFile cache}/.stack-to-nix.cache* $out${subDir'}

82 ''}

67 ''}

83 (cd $out${subDir'} && stack-to-nix ${stackToNixArgs})

68 (cd $out${subDir'} && stack-to-nix ${stackToNixArgs})

@@ -85,7 +70,7 @@ let

85 # We need to strip out any references to $src, as those won't

70 # We need to strip out any references to $src, as those won't

86 # be accessable in restricted mode.

71 # be accessable in restricted mode.

87 for nixf in $(find $out -name "*.nix" -type f); do

72 for nixf in $(find $out -name "*.nix" -type f); do

88− substituteInPlace $nixf --replace "$SRC${subDir'}" "."

73+ substituteInPlace $nixf --replace "$SRC" "."

89 done

74 done

90

75

91 # move pkgs.nix to default.nix ensure we can just nix `import` the result.

76 # move pkgs.nix to default.nix ensure we can just nix `import` the result.

lib/check.nix+8−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,13 @@ 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+

43 runHook preCheck

32 runHook preCheck

44

33

45 ${toString component.testWrapper} ${drv}/bin/${drv.exeName} ${lib.concatStringsSep " " component.testFlags} | tee $out/test-stdout

34 ${toString component.testWrapper} ${drv}/bin/${drv.exeName} ${lib.concatStringsSep " " component.testFlags} | tee $out/test-stdout

lib/clean-cabal-component.nix+56−105

@@ -1,55 +1,19 @@

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 }: package: component: src:

4let

5− srcStr' = src.origSrc or null;

5+ srcStr' = src.origSrcSubDir or src.origSrc or null;

6− subDir = if src.origSubDir or "" == ""

7− then ""

8− else lib.removePrefix "/" src.origSubDir + "/";

9− # Remove a directory for each .. part of a path.

10− removeDotDots = parts: lib.reverseList (

11− builtins.foldl' (a: b:

12− if b == ".."

13− then builtins.tail a

14− else builtins.concatLists [ [b] a ]) [] parts);

15 # Transform

6 # Transform

16− # "." -> ""

7+ # "." -> ""

17− # "./." -> ""

18− # "./xyz" -> "xyz"

19− # "../abc" -> ERROR

20− # "abc/.." -> ""

21− # "abc/../xyz" -> "xyz"

22− # "abc/./xyz" -> "abc/xyz"

23− # "abc/./../xyz" -> "xyz"

8+ # "./." -> ""

24− # "abc/.././xyz" -> "xyz"

9+ # "./xyz" -> "xyz"

25− # "abc/" -> "abc/"

26− normalizeRelativePath = path:

10+ normalizeRelativePath = rel:

27− let

11+ if rel == "." || rel == "./."

28− # Split the path into component parts and remove the empty ones and single dots.

29− nonEmptyParts = lib.filter (x: x != "" && x != ".") (lib.splitString "/" path);

30− in lib.concatStringsSep "/" (removeDotDots nonEmptyParts)

31− # Keep the trailing slash if there was one.

32− + (if lib.hasSuffix "/" path then "/" else "");

33− isAbsolutePath = path: lib.hasPrefix "/" path;

34− isRelativePath = path: !(isAbsolutePath path);

35− normalizePath = path:

36− (if isAbsolutePath path

37− then "/"

12+ then ""

38− else ""

13+ else lib.strings.removePrefix "./" rel;

39− ) + normalizeRelativePath path;

40− combinePaths = a: b:

41− if isAbsolutePath b

42− then b

43− else normalizePath (

44− if a == ""

45− then b

46− else if b == ""

47− then a

48− else a + "/" + b

49− );

50− # Like normalizePath but with a trailing / when needed

14+ # Like normalizeRelativePath but with a trailing / when needed

51− normalizeDir = dir:

15+ normalizeRelativeDir = dir:

52− let p = normalizePath dir;

16+ let p = normalizeRelativePath dir;

53 in if p == "" || p == "/"

17 in if p == "" || p == "/"

54 then ""

18 then ""

55 else if lib.hasSuffix "/" p

19 else if lib.hasSuffix "/" p

@@ -61,78 +25,65 @@ in

61 else

25 else

62 let

26 let

63 srcStr = toString srcStr';

27 srcStr = toString srcStr';

64− dataDir = combinePaths subDir package.dataDir;

28+ dataDir = normalizeRelativeDir package.dataDir;

65− hsSourceDirs = builtins.map (d: combinePaths subDir d) component.hsSourceDirs

29+ hsSourceDirs = builtins.map normalizeRelativeDir component.hsSourceDirs

66− ++ (if component.hsSourceDirs == [] then [subDir] else []);

30+ ++ (if component.hsSourceDirs == [] then [""] else []);

67− includeDirs = builtins.map (d: combinePaths subDir d) component.includeDirs;

31+ includeDirs = builtins.map normalizeRelativeDir component.includeDirs;

68− # paths that will be needed (used to check if a parent dir should be included)

69− dirsNeeded =

32+ dirsNeeded = [dataDir]

70− # These already include subDir

71− [dataDir]

72 ++ hsSourceDirs

33 ++ hsSourceDirs

73− ++ includeDirs

34+ ++ includeDirs;

74− ++ builtins.map (f: combinePaths dataDir f) package.dataFiles

75− ++ otherSourceFiles

76− ++ builtins.map (d: combinePaths subDir d) (

77− # These need the subDir added

78− package.licenseFiles

79− ++ package.extraSrcFiles

80− ++ component.extraSrcFiles

81− ++ package.extraDocFiles);

82 fileMatch = dir: list:

35 fileMatch = dir: list:

83 let

36 let

84− prefixes = builtins.map (f: combinePaths dir f) (

37+ prefixes = builtins.map (f: dir + f) (

85 lib.lists.remove null (lib.lists.flatten (

38 lib.lists.remove null (lib.lists.flatten (

86 builtins.map (f: builtins.match "([^*]*)[*].*" f) list)));

39 builtins.map (f: builtins.match "([^*]*)[*].*" f) list)));

87− exactMatches = builtins.map (f: combinePaths dir f) (

40+ exactMatches = builtins.map (f: dataDir + f) (

88 lib.lists.remove null (lib.lists.flatten (

41 lib.lists.remove null (lib.lists.flatten (

89 builtins.map (f: builtins.match "([^*]*)" f) list)));

42 builtins.map (f: builtins.match "([^*]*)" f) list)));

90 in rPath: lib.any (d: lib.strings.hasPrefix d rPath) prefixes

43 in rPath: lib.any (d: lib.strings.hasPrefix d rPath) prefixes

91 || lib.any (d: d == rPath) exactMatches;

44 || lib.any (d: d == rPath) exactMatches;

92 dataFileMatch = fileMatch dataDir package.dataFiles;

45 dataFileMatch = fileMatch dataDir package.dataFiles;

93− licenseMatch = fileMatch subDir package.licenseFiles;

46+ licenseMatch = fileMatch "" package.licenseFiles;

94− extraSrcMatch = fileMatch subDir (

47+ extraSrcMatch = fileMatch "" (

95 package.extraSrcFiles

48 package.extraSrcFiles

96 ++ component.extraSrcFiles);

49 ++ component.extraSrcFiles);

97− extraDocMatch = fileMatch subDir package.extraDocFiles;

50+ extraDocMatch = fileMatch "" package.extraDocFiles;

98− otherSourceFiles = builtins.map (f: combinePaths subDir f) (

51+ otherSourceFiles =

99 component.asmSources

52 component.asmSources

100 ++ component.cmmSources

53 ++ component.cmmSources

101 ++ component.cSources

54 ++ component.cSources

102 ++ component.cxxSources

55 ++ component.cxxSources

103− ++ component.jsSources);

56+ ++ component.jsSources;

104 in cleanSourceWith {

57 in cleanSourceWith {

105− name = src.name or "source" + "-${componentName}";

58+ inherit src;

106− subDir = lib.removePrefix "/" (src.origSubDir or "");

107− includeSiblings = true;

108− src = cleanSourceWith {

109− src = src.origSrc or src;

110− filter = path: type:

59+ filter = path: type:

111− (!(src ? filter) || src.filter path type) && (

112− assert (if !lib.strings.hasPrefix (srcStr + "/") (path + "/")

60+ assert (if !lib.strings.hasPrefix (srcStr + "/") (path + "/")

113− then throw ("Unexpected path " + path + " (expected something in " + srcStr + "/)")

61+ then throw ("Unexpected path " + path + " (expected something in " + srcStr + "/)")

114− else true);

62+ else true);

115− let

63+ let

116− srcStrLen = lib.strings.stringLength srcStr;

64+ srcStrLen = lib.strings.stringLength srcStr;

117− rPath = lib.strings.substring (srcStrLen + 1) (lib.strings.stringLength path - srcStrLen - 1) path;

65+ rPath = lib.strings.substring (srcStrLen + 1) (lib.strings.stringLength path - srcStrLen - 1) path;

118− # This is a handy way to find out why different files are included

66+ # This is a handy way to find out why different files are included

119− # traceReason = reason: v: if v then builtins.trace (rPath + " : " + reason) true else false;

67+ # traceReason = reason: v: if v then builtins.trace (rPath + " : " + reason) true else false;

120− traceReason = reason: v: v;

68+ traceReason = reason: v: v;

121− in

69+ in

122− traceReason "directory is needed" (

70+ traceReason "directory is needed" (

123− lib.any (d: lib.strings.hasPrefix (rPath + "/") d) dirsNeeded)

71+ lib.any (d: lib.strings.hasPrefix (rPath + "/") d) (

72+ dirsNeeded

73+ ++ package.licenseFiles

74+ ++ package.extraSrcFiles

75+ ++ component.extraSrcFiles

76+ ++ package.extraDocFiles

77+ ++ builtins.map (f: dataDir + f) package.dataFiles

78+ ++ otherSourceFiles))

124− || traceReason "cabal package definition" (lib.strings.hasPrefix subDir rPath

79+ || traceReason "cabal package definition" (lib.strings.hasSuffix ".cabal" rPath)

125− && lib.strings.hasSuffix ".cabal" rPath)

126− || traceReason "hpack package defintion" (lib.strings.hasPrefix subDir rPath

80+ || traceReason "hpack package defintion" (rPath == "package.yaml")

127− && rPath == "package.yaml")

128− || traceReason "data file" (lib.strings.hasPrefix dataDir rPath

81+ || traceReason "data file" (lib.strings.hasPrefix dataDir rPath

129− && dataFileMatch rPath)

82+ && dataFileMatch rPath)

130− || traceReason "haskell source dir" (lib.any (d: lib.strings.hasPrefix d rPath) hsSourceDirs)

83+ || traceReason "haskell source dir" (lib.any (d: lib.strings.hasPrefix d rPath) hsSourceDirs)

131− || traceReason "include dir" (lib.any (d: lib.strings.hasPrefix d rPath) includeDirs)

84+ || traceReason "include dir" (lib.any (d: lib.strings.hasPrefix d rPath) includeDirs)

132− || traceReason "license file" (licenseMatch rPath)

85+ || traceReason "license file" (licenseMatch rPath)

133− || traceReason "extra source file" (extraSrcMatch rPath)

86+ || traceReason "extra source file" (extraSrcMatch rPath)

134− || traceReason "extra doc file" (extraDocMatch rPath)

87+ || traceReason "extra doc file" (extraDocMatch rPath)

135− || traceReason "other source file" (lib.any (f: f == rPath) otherSourceFiles)

88+ || traceReason "other source file" (lib.any (f: f == rPath) otherSourceFiles);

136− );

137− };

138 }

89 }

lib/clean-git.nix+47−88

@@ -1,6 +1,6 @@

1# From https://github.com/NixOS/nix/issues/2944

2{ lib, runCommand, git, cleanSourceWith }:

3−{ name ? null, src, subDir ? "", includeSiblings ? false, keepGitDir ? false }:

3+{ name ? null, src, subDir ? "" }:

4

5# The function call

6#

@@ -24,6 +24,26 @@ with builtins;

24# is shared among multiple invocations of gitSource:

25

26let

27+ filter_from_list = root: files:

28+ let

29+ all_paren_dirs = p:

30+ if p == "." || p == "/"

31+ then []

32+ else [ p ] ++ all_paren_dirs (dirOf p);

33+

34+ whitelist_set = listToAttrs (

35+ concatMap (p:

36+ # Using `origSrcSubDir` (if present) makes it possible to cleanGit src that

37+ # has already been cleaned with cleanSrcWith.

38+ let full_path = root.origSrcSubDir or (toString root) + "/${p}"; in

39+ map (p': { name = p'; value = true; }) (all_paren_dirs full_path)

40+ ) files

41+ );

42+ in

43+ p: t: hasAttr (toString p) whitelist_set;

44+

45+ has_prefix = prefix: s:

46+ prefix == builtins.substring 0 (builtins.stringLength prefix) s;

27 remove_prefix = prefix: s:

47 remove_prefix = prefix: s:

28 builtins.substring

48 builtins.substring

29 (builtins.stringLength prefix)

49 (builtins.stringLength prefix)

@@ -64,14 +84,10 @@ then

64 git_content = lines (readFile (origSrcSubDir + "/.git"));

84 git_content = lines (readFile (origSrcSubDir + "/.git"));

65 first_line = head git_content;

85 first_line = head git_content;

66 prefix = "gitdir: ";

86 prefix = "gitdir: ";

67− ok = length git_content == 1 && lib.hasPrefix prefix first_line;

87+ ok = length git_content == 1 && has_prefix prefix first_line;

68− raw_path = remove_prefix prefix first_line;

69 in

88 in

70 if ok

89 if ok

71− then

90+ 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"}";

91 else abort "gitSource.nix: Cannot parse ${origSrcSubDir + "/.git"}";

76 }));

92 }));

77

93

@@ -91,37 +107,32 @@ then

91 gitModulesStr = origSrcSubDir + "/.gitmodules";

107 gitModulesStr = origSrcSubDir + "/.gitmodules";

92 gitModules = builtins.path { name = "gitmodules"; path = gitModulesStr; };

108 gitModules = builtins.path { name = "gitmodules"; path = gitModulesStr; };

93

109

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 {

110+ gitSubmoduleFiles = cleanSourceWith {

99− caller = "cleanGit";

111+ caller = "cleanGit";

100− name = (if name == null then "" else name + "-") + "gitSubmoduleFiles";

112+ name = (if name == null then "" else name + "-") + "gitSubmoduleFiles";

101− inherit src;

113+ inherit src;

102− filter = path: type:

114+ filter = path: type:

103− elem path pathsNeeded

115+ type == "directory" # TODO get sudmodule directories from `.gitmodules`

104− ||

116+ # and use that to filter directory tree here

117+ ||

118+ lib.any (i: (lib.hasSuffix i path)) [

119+ "/.git" ".gitmodules" ".git/config" ".git/index" ".git/HEAD" ".git/objects" ".git/refs" ] ||

120+ (lib.strings.hasInfix ".git/modules/" path &&

105 lib.any (i: (lib.hasSuffix i path)) [

121 lib.any (i: (lib.hasSuffix i path)) [

106− ".gitmodules" ".git/config" ".git/index" ".git/HEAD" ".git/objects" ".git/refs" ]

122+ "config" "index" "HEAD" "objects" "refs" ]);

107− ||

123+ };

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

124

115 # Make a temporary dir that looks enough like the real thing for

125 # Make a temporary dir that looks enough like the real thing for

116 # `git ls-files --recurse-submodules` to give us an accurate list

126 # `git ls-files --recurse-submodules` to give us an accurate list

117 # of all the files in the index.

127 # of all the files in the index.

118− whitelist_files = knownSubmoduleDirs:

128+ whitelist_file =

119− runCommand "git-ls-files" { preferLocalBuild = true; } ''

129+ runCommand "git-ls-files" {envVariable = true;} ''

120 tmp=$(mktemp -d)

130 tmp=$(mktemp -d)

121 cd $tmp

131 cd $tmp

122− ${ lib.optionalString hasSubmodules ''

132+ ${ lib.optionalString (!isWorktree && builtins.pathExists gitModulesStr) ''

123− cp -ra ${gitSubmoduleFiles knownSubmoduleDirs}/. $tmp

133+ cp -ra ${gitSubmoduleFiles}/. $tmp

124 chmod +w -R $tmp

134 chmod +w -R $tmp

135+ rm -rf .git

125 ''}

136 ''}

126 cp -r ${gitDir} .git

137 cp -r ${gitDir} .git

127 chmod +w -R .git

138 chmod +w -R .git

@@ -132,74 +143,22 @@ then

132 ${ lib.optionalString (isWorktree && builtins.pathExists gitModulesStr) ''

143 ${ lib.optionalString (isWorktree && builtins.pathExists gitModulesStr) ''

133 cp ${gitModules} ./.gitmodules

144 cp ${gitModules} ./.gitmodules

134 ''}

145 ''}

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

146+ ${git}/bin/git ls-files --recurse-submodules > $out

140 '';

147 '';

141

148

142− # Find the submodules

149+ 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−

167− all_paren_dirs = p:

168− if p == "." || p == "/"

169− then []

170− else [ p ] ++ all_paren_dirs (dirOf p);

171−

172− # All the paths that we need to keep as a set (including parent dirs)

173− whitelist_set = listToAttrs (

174− concatMap (p:

175− # Using `origSrcSubDir` (if present) makes it possible to cleanGit src that

176− # has already been cleaned with cleanSrcWith.

177− let full_path = toString (src.origSrcSubDir or src) + "/${p}"; in

178− map (p': { name = p'; value = true; }) (all_paren_dirs full_path)

179− ) whitelist.files

180− );

181−

182− # Identify files in the `.git` dir

183− isGitDirPath = path:

184− path == origSrcSubDir + "/.git"

185− || lib.hasPrefix (origSrcSubDir + "/.git/") path;

186

150

187− filter = path: type:

151+ filter = filter_from_list src whitelist;

188− hasAttr (toString path) whitelist_set

189− || (keepGitDir && isGitDirPath path);

190 in

152 in

191 cleanSourceWith {

153 cleanSourceWith {

192 caller = "cleanGit";

154 caller = "cleanGit";

193− inherit name src subDir includeSiblings filter;

155+ inherit name src subDir filter;

194− } // {

195− # For testing

196− # inherit whitelist whitelist_set;

197 }

156 }

198

157

199else

158else

200− trace "haskell-nix.haskellLib.cleanGit: ${origSrcSubDir} does not seem to be a git repository,\nassuming it is a clean checkout." (

159+ trace "gitSource.nix: ${origSrcSubDir} does not seem to be a git repository,\nassuming it is a clean checkout." (

201 cleanSourceWith {

160 cleanSourceWith {

202 caller = "cleanGit";

161 caller = "cleanGit";

203− inherit name src subDir includeSiblings;

162+ inherit name src subDir;

204 }

163 }

205 )

164 )

lib/clean-source-haskell.nix+15−1

@@ -35,7 +35,21 @@ rec {

35 src = lib.cleanSource src;

36 inherit name;

37 };

38+ # Copy function from 19.09 for compatibility with 19.03.

39+ # Does require at least Nix 2.0.

40+ compat = let

41+ isFiltered = src ? _isLibCleanSourceWith;

42+ origSrc = if isFiltered then src.origSrc else src;

43+ filter' = name: type: haskellSourceFilter name type && lib.cleanSourceFilter name type;

44+ name' = if name != null then name else if isFiltered then src.name else baseNameOf src;

45+ in {

46+ inherit origSrc;

47+ filter = filter';

48+ outPath = builtins.path { filter = filter'; path = origSrc; name = name'; };

49+ _isLibCleanSourceWith = true;

50+ name = name';

51+ };

38 in

52 in

39 if (builtins.typeOf src) == "path"

53 if (builtins.typeOf src) == "path"

40− then clean else src;

54+ then (if lib.versionAtLeast lib.version "19.09" then clean else compat) else src;

41}

55}

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+56−50

@@ -2,20 +2,25 @@

2# reports

3{ stdenv, pkgs, lib, haskellLib }:

4

5−# haskell.nix project

6−project:

7# List of coverage reports to accumulate

5# List of coverage reports to accumulate

8coverageReports:

6coverageReports:

9

7

10let

8let

11 toBashArray = arr: "(" + (lib.concatStringsSep " " arr) + ")";

9 toBashArray = arr: "(" + (lib.concatStringsSep " " arr) + ")";

12

10

13− # Create a list element for a project coverage index page.

11+ # Create table rows for a project coverage index page that look something like:

12+ #

13+ # | Package |

14+ # |------------------|

15+ # | cardano-shell |

16+ # | cardano-launcher |

14− coverageListElement = coverageReport:

17+ coverageTableRows = coverageReport:

15 ''

18 ''

16− <li>

19+ <tr>

20+ <td>

17− <a href="${coverageReport.passthru.name}/hpc_index.html">${coverageReport.passthru.name}</a>

21+ <a href="${coverageReport.passthru.name}/hpc_index.html">${coverageReport.passthru.name}</href>

18− </li>

22+ </td>

23+ </tr>

19 '';

24 '';

20

25

21 projectIndexHtml = pkgs.writeText "index.html" ''

26 projectIndexHtml = pkgs.writeText "index.html" ''

@@ -24,50 +29,35 @@ let

24 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

29 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

25 </head>

30 </head>

26 <body>

31 <body>

27− <div>

32+ <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.

33+ <tbody>

29− </div>

34+ <tr>

30− <div>

35+ <th>Report</th>

31− <h2>Union Report</h2>

36+ </tr>

32− <p>The following report shows how each module is covered by any test in the project:</p>

37+

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)}

38+ ${with lib; concatStringsSep "\n" (map coverageTableRows coverageReports)}

44− </ul>

39+

45− </div>

40+ </tbody>

41+ </table>

46 </body>

42 </body>

47 </html>

43 </html>

48 '';

44 '';

49

45

46+ ghc =

47+ if (builtins.length coverageReports) > 0

50− ghc = project.pkg-set.config.ghc.package;

48+ then (builtins.head coverageReports).library.project.pkg-set.config.ghc.package or pkgs.ghc

49+ else pkgs.ghc;

51

50

52− libs = lib.unique (lib.concatMap (r: r.mixLibraries) coverageReports);

51+ libs = map (r: r.library) coverageReports;

52+

53+ projectLibs = map (pkg: pkg.components.library) (lib.attrValues (haskellLib.selectProjectPackages ((lib.head libs).project.hsPkgs)));

53

54

54 mixDirs =

55 mixDirs =

55 map

56 map

56 (l: "${l}/share/hpc/vanilla/mix/${l.identifier.name}-${l.identifier.version}")

57 (l: "${l}/share/hpc/vanilla/mix/${l.identifier.name}-${l.identifier.version}")

57− libs;

58+ (projectLibs);

58−

59− srcDirs = map (l: l.srcSubDirPath) libs;

60

59

61− allCoverageReport = haskellLib.coverageReport {

60+ srcDirs = map (l: l.src.outPath) (projectLibs);

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

61

72in pkgs.runCommand "project-coverage-report"

62in pkgs.runCommand "project-coverage-report"

73 ({ nativeBuildInputs = [ (ghc.buildGHC or ghc) pkgs.buildPackages.zip ];

63 ({ nativeBuildInputs = [ (ghc.buildGHC or ghc) pkgs.buildPackages.zip ];

@@ -132,19 +122,35 @@ in pkgs.runCommand "project-coverage-report"

132 fi

122 fi

133

123

134 # Copy mix, tix, and html information over from each report

124 # Copy mix, tix, and html information over from each report

135− cp -Rn $report/share/hpc/vanilla/mix/$identifier $out/share/hpc/vanilla/mix/

125+ cp -Rn $report/share/hpc/vanilla/mix/$identifier/* $out/share/hpc/vanilla/mix/

136 cp -R $report/share/hpc/vanilla/tix/* $out/share/hpc/vanilla/tix/

126 cp -R $report/share/hpc/vanilla/tix/* $out/share/hpc/vanilla/tix/

137 cp -R $report/share/hpc/vanilla/html/* $out/share/hpc/vanilla/html/

127 cp -R $report/share/hpc/vanilla/html/* $out/share/hpc/vanilla/html/

138 '') coverageReports)}

128 '') coverageReports)}

139

129

130+ if [ ''${#tixFiles[@]} -ne 0 ]; then

131+ # Create tix file with test run information for all packages

132+ tixFile="$out/share/hpc/vanilla/tix/all/all.tix"

133+ hpcSumCmd=("hpc" "sum" "--union" "--output=$tixFile")

134+ hpcSumCmd+=("''${tixFiles[@]}")

135+ echo "''${hpcSumCmd[@]}"

136+ eval "''${hpcSumCmd[@]}"

137+

140− # Copy out "all" coverage report

138+ # Markup a HTML coverage report for the entire project

141− cp -R ${allCoverageReport}/share/hpc/vanilla/tix/all $out/share/hpc/vanilla/tix

139+ cp ${projectIndexHtml} $out/share/hpc/vanilla/html/index.html

140+ echo "report coverage-per-package $out/share/hpc/vanilla/html/index.html" >> $out/nix-support/hydra-build-products

141+

142− cp -R ${allCoverageReport}/share/hpc/vanilla/html/all $out/share/hpc/vanilla/html

142+ local markupOutDir="$out/share/hpc/vanilla/html/all"

143+ local srcDirs=${toBashArray srcDirs}

144+ local mixDirs=${toBashArray mixDirs}

145+ local allMixModules=()

146+

147+ mkdir $markupOutDir

148+ findModules allMixModules "$out/share/hpc/vanilla/mix/" "*.mix"

143

149

144− # Markup a HTML coverage summary report for the entire project

150+ markup srcDirs mixDirs allMixModules "$markupOutDir" "$tixFile"

145− cp ${projectIndexHtml} $out/share/hpc/vanilla/html/index.html

146

151

147− echo "report coverage $out/share/hpc/vanilla/html/index.html" >> $out/nix-support/hydra-build-products

152+ 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 . )

153+ ( 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

154+ echo "file zip $out/share/hpc/vanilla/html.zip" >> $out/nix-support/hydra-build-products

155+ fi

150 ''

156 ''

lib/cover.nix+70−103

@@ -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

@@ -21,12 +21,12 @@ let

21 mixDir = l: "${l}/share/hpc/vanilla/mix/${l.identifier.name}-${l.identifier.version}";

22 mixDirs = map mixDir mixLibraries;

23

24− srcDirs = map (l: l.srcSubDirPath) mixLibraries;

24+ srcDirs = map (l: l.src.outPath) mixLibraries;

25

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+30−100

@@ -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

@@ -59,23 +62,13 @@ in {

59 benchmarks = "bench";

62 benchmarks = "bench";

60 };

63 };

61

64

62− # For looking up the components attribute based on the cabal component type

63− prefixComponent =

64− lib.listToAttrs (

65− lib.mapAttrsToList (value: name: { inherit name value; })

66− componentPrefix);

67−

68 applyComponents = f: config:

65 applyComponents = f: config:

69 let

66 let

70 comps = config.components;

67 comps = config.components;

71 applyLibrary = cname: f { cname = config.package.identifier.name; ctype = "lib"; };

68 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}."); };

69 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);

70+ buildableAttrs = lib.filterAttrs (n: comp: comp.buildable or true);

78− libComp = if comps.library == null || !(isBuildable comps.library)

71+ libComp = if comps.library == null || !(comps.library.buildable or true)

79 then {}

72 then {}

80 else lib.mapAttrs applyLibrary (removeAttrs comps (subComponentTypes ++ [ "setup" ]));

73 else lib.mapAttrs applyLibrary (removeAttrs comps (subComponentTypes ++ [ "setup" ]));

81 subComps = lib.mapAttrs

74 subComps = lib.mapAttrs

@@ -101,7 +94,7 @@ in {

101

94

102 # if it's a project package it has a src attribute set with an origSubDir attribute.

95 # if it's a project package it has a src attribute set with an origSubDir attribute.

103 # project packages are a subset of localPackages

96 # project packages are a subset of localPackages

104− isProjectPackage = p: p.isProject or false;

97+ isProjectPackage = p: p ? src && p.src ? origSubDir;

105 selectProjectPackages = ps: lib.filterAttrs (n: p: p != null && isLocalPackage p && isProjectPackage p) ps;

98 selectProjectPackages = ps: lib.filterAttrs (n: p: p != null && isLocalPackage p && isProjectPackage p) ps;

106

99

107 # Format a componentId as it should appear as a target on the

100 # Format a componentId as it should appear as a target on the

@@ -133,7 +126,14 @@ in {

133 ## flatLibDepends :: Component -> [Package]

126 ## flatLibDepends :: Component -> [Package]

134 flatLibDepends = component:

127 flatLibDepends = component:

135 let

128 let

129+ # this is a minor improvement over the "cannot coerce set to string"

130+ # error. It will now say:

131+ #

132+ # > The option `packages.Win32.package.identifier.name' is used but not defined.

133+ #

134+ # which indicates that the package.Win32 is missing and not defined.

135+ 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); });

136+ makePairs = map (p: rec { key=getKey val; val=(p.components.library or p); });

137 closure = builtins.genericClosure {

138 startSet = makePairs component.depends;

139 operator = {val,...}: makePairs val.config.depends;

@@ -189,7 +189,7 @@ in {

189 collectChecks' = collectChecks (_: true);

190

191 # Replacement for lib.cleanSourceWith that has a subDir argument.

192− inherit (import ./clean-source-with.nix { inherit lib; }) cleanSourceWith;

192+ inherit (import ./clean-source-with.nix { inherit lib; }) cleanSourceWith canCleanSource;

193

194 # Use cleanSourceWith to filter just the files needed for a particular

195 # component of a package

@@ -199,7 +199,7 @@ in {

199 cleanGit = import ./clean-git.nix {

200 inherit lib cleanSourceWith;

201 git = gitMinimal;

202− inherit (pkgs.buildPackages.buildPackages) runCommand;

202+ inherit (pkgs.evalPackages) runCommand;

203 };

204

205 # Some times it is handy to temporarily use a relative path between git

@@ -229,7 +229,7 @@ in {

229

230 # Check a test component

231 check = import ./check.nix {

232− inherit stdenv lib haskellLib;

232+ inherit stdenv lib haskellLib srcOnly;

233 };

234

235 # Do coverage of a package

@@ -248,99 +248,29 @@ in {

248 # 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.

250 isCrossHost = stdenv.hostPlatform != stdenv.buildPlatform

251− && !(stdenv.buildPlatform.isLinux && stdenv.hostPlatform.isMusl && stdenv.buildPlatform.linuxArch == stdenv.hostPlatform.linuxArch);

251+ && !(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

253 isCrossTarget = stdenv.targetPlatform != stdenv.hostPlatform

254− && !(stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl && stdenv.hostPlatform.linuxArch == stdenv.targetPlatform.linuxArch);

254+ && !(stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl && stdenv.hostPlatform.isx86 && stdenv.targetPlatform.isx86);

255 # Native musl build-host-target combo

256 isNativeMusl = stdenv.hostPlatform.isMusl

257 && stdenv.buildPlatform == stdenv.hostPlatform

258 && stdenv.hostPlatform == stdenv.targetPlatform;

259

260− # Takes a version number, module or list of modules (for cabalProject)

260+ # Takes a version number or attr set of arguments (for cabalProject)

261− # and converts it to an list of project modules. This allows

261+ # 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"; ... }

263− versionOrModToMods = versionOrMod:

263+ versionOrArgsToArgs = versionOrArgs:

264− if lib.isString versionOrMod

264+ if lib.isAttrs versionOrArgs

265− then [{ version = versionOrMod; }]

265+ then versionOrArgs

266− else if lib.isList versionOrMod

266+ else { version = versionOrArgs; };

267− then versionOrMod

268− else [versionOrMod];

269

267

270 # Find the resolver in the stack.yaml file and fetch it if a sha256 value is provided

268 # Find the resolver in the stack.yaml file and fetch it if a sha256 value is provided

271 fetchResolver = import ./fetch-resolver.nix {

269 fetchResolver = import ./fetch-resolver.nix {

272− inherit (pkgs.buildPackages) pkgs;

270+ inherit (pkgs.evalPackages) pkgs;

273 };

271 };

274

272

275 inherit (import ./cabal-project-parser.nix {

273 inherit (import ./cabal-project-parser.nix {

276 inherit pkgs;

274 inherit pkgs;

277− }) parseIndexState parseSourceRepositoryPackages parseRepositories parseSourceRepositoryPackageBlock parseRepositoryBlock;

275+ }) parseIndexState parseBlock;

278−

279−

280− cabalToNixpkgsLicense = import ./spdx/cabal.nix pkgs;

281−

282− # This function is like

283− # `src + (if subDir == "" then "" else "/" + subDir)`

284− # however when `includeSiblings` is set it maintains

285− # `src.origSrc` if there is one and instead adds to

286− # `src.origSubDir`. It uses `cleanSourceWith` when possible

287− # to keep `cleanSourceWith` support in the result.

288− appendSubDir = { src, subDir, includeSiblings ? false }:

289− if subDir == ""

290− then src

291− else

292− haskellLib.cleanSourceWith {

293− inherit src subDir includeSiblings;

294− };

295−

296− # Givin a `src` split it into a `root` path (based on `src.origSrc` if

297− # present) and `subDir` (based on `src.origSubDir). The

298− # `root` will still use the `filter` of `src` if there was one.

299− rootAndSubDir = src: rec {

300− subDir = src.origSubDir or "";

301− root =

302− if subDir == ""

303− then src # if there was no subdir use the original src

304− else

305− # Use `cleanSourceWith` to make sure the `filter` is still used

306− if src ? origSrc && src ? filter

307− then haskellLib.cleanSourceWith {

308− name = src.name or "source" + "-root";

309− src = src.origSrc;

310− # Not passing src.origSubDir so that the result points `origSrc`

311− inherit (src) filter;

312− }

313− else src.origSrc or src; # If there is a subDir and origSrc (but no filter) use origSrc

314− };

315−

316− # Run evalModules passing the project function argument (m) as a module along with

317− # the the a projectType module (../modules/cabal-project.nix or ../modules/stack-project.nix).

318− # The resulting config is then passed to the project function's implementation.

319− evalProjectModule = projectType: m: f:

320− let project = f

321− (lib.evalModules {

322− modules = (if builtins.isList m then m else [m]) ++ [

323− # Include ../modules/cabal-project.nix or ../modules/stack-project.nix

324− (import ../modules/project-common.nix)

325− (import projectType)

326− # Pass the pkgs and the buildProject to the modules

327− ({ config, lib, ... }: {

328− _module.args = {

329− inherit pkgs;

330− # to make it easy to depends on build packages in, eg., shell definition:

331− inherit (project) buildProject;

332− };

333− inherit (project) hsPkgs;

334− })

335− ];

336− }).config;

337− in project;

338−

339− # Converts from a `compoent.depends` value to a library derivation.

340− # In the case of sublibs the `depends` value should already be the derivation.

341− dependToLib = d: d.components.library or d;

342−

343− projectOverlays = import ./project-overlays.nix {

344− inherit lib haskellLib;

345− };

346}

276}

lib/failed-cabal-configure.nixdeleted−9

@@ -1,9 +0,0 @@

1−let

2− configurationError = ./cabal-configure.out;

3−in

4− # Trace the error output to make sure the user has a chance to see it

5− # (even if the choose not to build anything from the project)

6− __trace ''

7− ERROR: cabal configure failed with:

8− ${__readFile configurationError}

9− '' { inherit configurationError; }

lib/fetch-resolver.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+40−81

@@ -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,30 +35,11 @@

35 version = "3.2.5";

36 materialized = ../materialized/ghcjs/alex + "/${compiler-nix-name}";

37 }

38−, cabal-install ?

38+, cabal-install ? pkgs.haskell-nix.cabal-install.${compiler-nix-name}

39− if (builtins.compareVersions ghcjsVersion "8.10.0.0" >= 0)

40− then pkgs.haskell-nix.tool compiler-nix-name "cabal" {

41− index-state = pkgs.haskell-nix.internalHackageIndexState;

42− version = "3.6.2.0";

43− materialized = ../materialized/ghcjs/cabal + "/${compiler-nix-name}";

44− }

45− else pkgs.haskell-nix.tool compiler-nix-name "cabal" {

46− index-state = pkgs.haskell-nix.internalHackageIndexState;

47− version = "3.2.0.0";

48− # Cabal 3.2.1.0 no longer supports he mix of `cabal-version`,

49− # lack of `custom-setup` and `v1-install` used by ghcjs boot.

50− cabalProjectLocal = ''

51− constraints: Cabal <3.2.1.0

52− '';

53− materialized = ../materialized/ghcjs/cabal + "/${compiler-nix-name}";

54− }

55−, overrideBootPackages ? []

56−, patches ? []

57, ...

39, ...

58}@args:

40}@args:

59let

41let

60− isGhcjs88 = builtins.compareVersions ghcjsVersion "8.8.0.0" >= 0;

42+ isGhcjs88 = builtins.compareVersions ghcjsVersion "8.8.0.0" > 0;

61− isGhcjs810 = builtins.compareVersions ghcjsVersion "8.10.0.0" >= 0;

62

43

63 # Inputs needed to configure the GHCJS source tree

44 # Inputs needed to configure the GHCJS source tree

64 configureInputs = with pkgs; [

45 configureInputs = with pkgs; [

@@ -72,26 +53,34 @@ let

72 alex

53 alex

73 cabal-install

54 cabal-install

74 ];

55 ];

75−

56+ # nixpkgs does not have an emsdk, this derivation uses symlinks to make something

76− inherit (pkgs.buildPackages) emscriptenupstream emscripten emsdk;

57+ # that matches enought for `ghcjs-boot` to work

77−

58+ emscriptenupstream = pkgs.buildPackages.emscriptenupstream;

59+ emscripten = pkgs.buildPackages.emscripten.override {

60+ emscriptenBackend = emscriptenupstream;

61+ };

62+ emsdk = pkgs.linkFarm "emsdk" [

63+ { name = "upstream/bin"; path = emscriptenupstream + "/bin"; }

64+ { name = "upstream/emscripten"; path = emscripten + "/bin"; }

65+ { name = "share"; path = emscripten + "/share"; }

66+ ];

78 # Inputs needed to boot the GHCJS compiler

67 # Inputs needed to boot the GHCJS compiler

79 bootInputs = with pkgs.buildPackages; [

68 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

69+ nodejs

85 makeWrapper

70 makeWrapper

86 xorg.lndir

71 xorg.lndir

87 gmp

72 gmp

88 pkgconfig

73 pkgconfig

89 ]

74 ]

90− ++ [ ghc cabal-install emsdk ];

75+ ++ [ ghc cabal-install ]

76+ ++ lib.optionals stdenv.isDarwin [

77+ pkgs.buildPackages.gcc # https://github.com/ghcjs/ghcjs/issues/663

78+ ]

79+ ++ lib.optional isGhcjs88 [ emsdk ];

91 # Configured the GHCJS source

80 # Configured the GHCJS source

92− configured-src = (pkgs.runCommandCC "configured-ghcjs-src" {

81+ configured-src = pkgs.runCommand "configured-ghcjs-src" {

93 buildInputs = configureInputs;

82 buildInputs = configureInputs;

94− inherit src patches;

83+ inherit src;

95 } ''

84 } ''

96 export HOME=$(pwd)

85 export HOME=$(pwd)

97 mkdir $HOME/.cabal

86 mkdir $HOME/.cabal

@@ -100,11 +89,6 @@ let

100 chmod -R +w "$out"

89 chmod -R +w "$out"

101 cd "$out"

90 cd "$out"

102

91

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

92 # TODO: Find a better way to avoid impure version numbers

109 sed -i 's/RELEASE=NO/RELEASE=YES/' ghc/configure.ac

93 sed -i 's/RELEASE=NO/RELEASE=YES/' ghc/configure.ac

110 sed -i 's/${ghcjsVersion}/${ghcVersion}/' ghcjs.cabal

94 sed -i 's/${ghcjsVersion}/${ghcVersion}/' ghcjs.cabal

@@ -122,58 +106,33 @@ let

122 rm -rf utils/pkg-cache/ghc

106 rm -rf utils/pkg-cache/ghc

123 cp -r ${ghc.generated} utils/pkg-cache/ghc

107 cp -r ${ghc.generated} utils/pkg-cache/ghc

124

108

125− for a in integer-gmp base unix; do

109+ cp ${../overlays/patches/config.sub} ghc/libraries/integer-gmp/config.sub

126− cp ${../overlays/patches/config.sub} ghc/libraries/$a/config.sub

110+ cp ${../overlays/patches/config.sub} ghc/libraries/base/config.sub

127− cp ${../overlays/patches/config.guess} ghc/libraries/$a/config.guess

111+ 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

112

133 patchShebangs .

113 patchShebangs .

134 sed -i 's/gcc /cc /g' utils/makePackages.sh

114 sed -i 's/gcc /cc /g' utils/makePackages.sh

135 ./utils/makePackages.sh copy

115 ./utils/makePackages.sh copy

136

116

137− for a in integer-gmp base unix; do

117+ ${

138− cp ${../overlays/patches/config.sub} lib/boot/pkg/$a/config.sub

118+ # nuke the HsBaseConfig.h from base.buildinfo.in; this will

139− done

119+ # prevent it from being installed and provide incorrect values.

140− ${ # it just so happens that all existing uses of overriding boot packages

120+ pkgs.lib.optionalString (!isGhcjs88) ''

141− # need to be installed right after template-haskell

121+ echo " build-tool-depends: alex:alex, happy:happy <= 1.19.9" >> lib/ghc-api-ghcjs/ghc-api-ghcjs.cabal

142− # if at some point we would need to insert them at different points

122+ sed -i 's/HsBaseConfig.h//g' lib/boot/pkg/base/base.buildinfo.in

143− # then we will have gto come up with something more clever

123+ ''

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− };

124+ }'';

159 # see https://github.com/ghcjs/ghcjs/issues/751 for the happy upper bound.

125 # see https://github.com/ghcjs/ghcjs/issues/751 for the happy upper bound.

160

126

161 ghcjsProject = pkgs.haskell-nix.cabalProject' (

127 ghcjsProject = pkgs.haskell-nix.cabalProject' (

162− (pkgs.lib.filterAttrs

128+ (pkgs.lib.filterAttrs

163 (n: _: !(builtins.any (x: x == n)

129 (n: _: !(builtins.any (x: x == n)

164− [ "src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"

130+ ["src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"])) args) // {

165− "overrideBootPackages" "patches"])) args) // {

166 src = configured-src;

131 src = configured-src;

167− index-state = "2021-03-20T00:00:00Z";

132+ index-state = "2020-11-16T00:00:00Z";

168− inherit compiler-nix-name;

133+ compiler-nix-name = if isGhcjs88 then "ghc884" else "ghc865";

169− configureArgs = pkgs.lib.optionalString (isGhcjs88 && !isGhcjs810) "--constraint='Cabal >=3.0.2.0 && <3.1'";

134+ 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}";

135+ materialized = ../materialized + (if isGhcjs88 then "/ghcjs884" else "/ghcjs865");

177 modules = [

136 modules = [

178 {

137 {

179 # we need ghc-boot in here for ghcjs.

138 # we need ghc-boot in here for ghcjs.

@@ -186,7 +145,6 @@ let

186 packages.Cabal.patches = [ ./../overlays/patches/Cabal/fix-data-dir.patch ];

145 packages.Cabal.patches = [ ./../overlays/patches/Cabal/fix-data-dir.patch ];

187 })

146 })

188 {

147 {

189− ghcOptions = ["-O2"];

190 packages.ghcjs.doHaddock = false;

148 packages.ghcjs.doHaddock = false;

191 packages.haddock-ghcjs.doHaddock = false;

149 packages.haddock-ghcjs.doHaddock = false;

192 packages.haddock-api-ghcjs.doHaddock = false;

150 packages.haddock-api-ghcjs.doHaddock = false;

@@ -216,3 +174,4 @@ in ghcjsProject // {

216 };

174 };

217 inherit configureInputs bootInputs configured-src emscriptenupstream emscripten emsdk;

175 inherit configureInputs bootInputs configured-src emscriptenupstream emscripten emsdk;

218}

176}

177+

lib/import-and-filter-project.nix+25−39

@@ -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 /

@@ -21,41 +24,24 @@ in project // {

21 packages = pkgs.lib.attrsets.mapAttrs (name: value:

24 packages = pkgs.lib.attrsets.mapAttrs (name: value:

22 if builtins.isFunction value

25 if builtins.isFunction value

23 then value

26 then value

24− else {...}@args: with pkgs.lib.strings;

27+ else {...}@args:

25− let

26− oldPkg = import value args;

28+ let oldPkg = import value args;

27− packageInfo =

29+ packageSrc = if !pkgs.lib.strings.hasPrefix (toString projectNix) (toString oldPkg.src.content)

28− if oldPkg.src ? url

30+ then toString oldPkg.src.content

29− then {

31+ else let

30− # The source is from a source-repository-package in a cabal.project file

32+ subDir = pkgs.lib.strings.removePrefix "/" (

31− # and lib/call-cabal-project-to-nix.nix should have replaced the url with

33+ pkgs.lib.strings.removePrefix (toString projectNix)

32− # an index into the sourceRepos list.

34+ (toString oldPkg.src.content));

33− isProject = false;

35+ srcRepoPrefix = projectSubDir'' + ".source-repository-packages/";

36+ in if pkgs.lib.strings.hasPrefix srcRepoPrefix subDir

37+ then

34− packageSrc = pkgs.lib.lists.elemAt sourceRepos (toInt oldPkg.src.url);

38+ pkgs.lib.lists.elemAt sourceRepos (

35− }

39+ pkgs.lib.strings.toInt (pkgs.lib.strings.removePrefix srcRepoPrefix subDir))

36− else if !hasPrefix "${projectNix}" (toString oldPkg.src.content)

40+ else if haskellLib.canCleanSource srcRoot

37− then {

41+ then haskellLib.cleanSourceWith { src = srcRoot; inherit subDir; }

38− # Source location does not match project prefix

42+ else srcRoot + (if subDir == "" then "" else "/" + subDir);

39− isProject = false;

40− packageSrc = toString oldPkg.src.content;

41− }

42− else {

43− # Source does match project prefix and it is not from a source repository

44− isProject = true;

45− packageSrc = haskellLib.appendSubDir {

46− src = srcRoot;

47− subDir = removePrefix "/" (removePrefix "${projectNix}"

48− (toString oldPkg.src.content));

49− includeSiblings = true; # Filtering sibling dirs of the package dir is done in the

50− # component builder so that relative paths can be used to

51− # reference project directories not in the package subDir.

52− };

53− };

54 in oldPkg // {

43 in oldPkg // {

55− src = (pkgs.lib).mkDefault packageInfo.packageSrc;

44+ src = (pkgs.lib).mkDefault packageSrc;

56− package = oldPkg.package // {

57− isProject = (pkgs.lib).mkDefault packageInfo.isProject;

58− };

59 }) old;

45 }) old;

60 };

46 };

61 }

47 }

lib/materialize.nix+11−23

@@ -7,9 +7,6 @@

7 # the output. If this is set but does not exist

8 # the derivation will fail but with a message

9 # advising how to populate it.

10−, this ? "this"

11− # A name to use when referring to the thing currently being

12− # materialized. Clients can pass in an attribute name or similar.

13, reasonNotSafe ? null

10, reasonNotSafe ? null

14 # Some times there a reasont the derivation will

11 # Some times there a reasont the derivation will

15 # not produce output that can be safely materialized.

12 # not produce output that can be safely materialized.

@@ -24,7 +21,7 @@

24}: derivation:

21}: derivation:

25

22

26let

23let

27− name = derivation.name + pkgs.lib.optionalString (derivation ? version) "-${derivation.version}";

24+ inherit (derivation) name;

28

25

29 traceIgnoringSha256 = reason: x:

26 traceIgnoringSha256 = reason: x:

30 if sha256 != null

27 if sha256 != null

@@ -36,15 +33,10 @@ let

36 then builtins.trace ("Warning: ignoring materialized for " + name + " " + reason) x

33 then builtins.trace ("Warning: ignoring materialized for " + name + " " + reason) x

37 else x;

34 else x;

38

35

39− traceWhenChecking = message: x:

40− if checkMaterialization

41− then builtins.trace message x

42− else x;

43−

44 unchecked =

36 unchecked =

45 let

37 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'.";

38+ sha256message = "To make this a fixed-output derivation but not materialized, set `${sha256Arg}` to the output of ${calculateMaterializedSha}";

47− materializeMessage = "${name}: To materialize ${this} entirely, pass a writable path as the `materialized` argument and run the 'updateMaterialized' script in 'passthru'.";

39+ materializeMessage = "To materialize the output entirely, pass a writable path as the `materialized` argument and pass that path to ${generateMaterialized}";

48 in if reasonNotSafe != null

40 in if reasonNotSafe != null

49 then

41 then

50 # Warn the user if they tried to pin stuff down when it is not safe

42 # Warn the user if they tried to pin stuff down when it is not safe

@@ -55,20 +47,13 @@ let

55 else if sha256 != null

47 else if sha256 != null

56 then

48 then

57 # Let the user know how to materialize if they want to.

49 # Let the user know how to materialize if they want to.

58− traceWhenChecking materializeMessage calculateUseHash

50+ builtins.trace materializeMessage calculateUseHash

59 else # materialized == null && sha256 == null

51 else # materialized == null && sha256 == null

60 # Let the user know how to calculate a sha256 or materialize if they want to.

52 # Let the user know how to calculate a sha256 or materialize if they want to.

61− traceWhenChecking sha256message (traceWhenChecking materializeMessage calculateNoHash);

53+ builtins.trace sha256message (builtins.trace materializeMessage calculateNoHash);

62

54

63 # Build fully and check the hash and materialized versions

55 # Build fully and check the hash and materialized versions

64− checked =

65− # Let the user know what we are checking. This is useful for debugging issues

66− # where materialization fails to prevent infinite recurstion when:

67− # checkMaterialization = true;

68− (if materialized != null

69− then __trace "Checking materialization in ${toString materialized}"

70− else x: x)

71− runCommand name {} (''

56+ checked = runCommand name {} (''

72 ERR=$(mktemp -d)/errors.txt

57 ERR=$(mktemp -d)/errors.txt

73 ''

58 ''

74 + (pkgs.lib.optionalString (sha256 != null) ''

59 + (pkgs.lib.optionalString (sha256 != null) ''

@@ -128,7 +113,11 @@ let

128 calculateUseMaterialized =

113 calculateUseMaterialized =

129 assert materialized != null;

114 assert materialized != null;

130 assert __pathExists materialized;

115 assert __pathExists materialized;

116+ runCommand name (pkgs.lib.optionalAttrs (sha256 == null) hashArgs) ''

131− { outPath = materialized; inherit name; };

117+ cp -Lr ${materialized} $out

118+ # Make sure output files can be removed from the sandbox

119+ chmod -R +w $out

120+ '';

132 calculateMaterializedSha =

121 calculateMaterializedSha =

133 writeShellScript "calculateSha" ''${nix}/bin/nix-hash --base32 --type sha256 ${calculateNoHash}'';

122 writeShellScript "calculateSha" ''${nix}/bin/nix-hash --base32 --type sha256 ${calculateNoHash}'';

134

123

@@ -144,7 +133,6 @@ let

144 fi

133 fi

145

134

146 # Generate the files

135 # Generate the files

147− mkdir -p $TARGET

148 rm -rf $TARGET

136 rm -rf $TARGET

149 cp -r ${calculateNoHash} "$TARGET"

137 cp -r ${calculateNoHash} "$TARGET"

150 chmod -R +w "$TARGET"

138 chmod -R +w "$TARGET"

lib/pkgconf-nixpkgs-map.nix+17−27

@@ -21,18 +21,18 @@ pkgs:

21 "cairo-ps" = [ pkgs."cairo" ];

22 "cairo-svg" = [ pkgs."cairo" ];

23 "crypt" = []; # provided by glibc

24+ "crypto" = [ pkgs."openssl" ];

24 "curses" = [ pkgs."ncurses" ];

25 "curses" = [ pkgs."ncurses" ];

25 "dbusmenu-glib-0.4" = [ pkgs."libdbusmenu" ];

26 "dbusmenu-glib-0.4" = [ pkgs."libdbusmenu" ];

26 "dbusmenu-gtk3-0.4" = [ pkgs."libdbusmenu-gtk3" ]; # do we also need pkgs."gtk3"

27 "dbusmenu-gtk3-0.4" = [ pkgs."libdbusmenu-gtk3" ]; # do we also need pkgs."gtk3"

27 "dl" = []; # provided by glibc

28 "dl" = []; # provided by glibc

28 "fftw3" = [ pkgs."fftw" ];

29 "fftw3" = [ pkgs."fftw" ];

29 "fftw3f" = [ pkgs."fftwFloat" ];

30 "fftw3f" = [ pkgs."fftwFloat" ];

30− "freetype2" = [ pkgs."freetype" ];

31 "gconf" = [ pkgs."GConf" ];

32 "gconf-2.0" = [ pkgs."GConf" ];

33 "gdk-2.0" = [ pkgs."gtk2" ];

34 "gdk-3.0" = [ pkgs."gtk3" ];

35− "gdk-pixbuf-2.0" = [ (pkgs."gdk-pixbuf" or pkgs."gdk_pixbuf") ];

35+ "gdk-pixbuf-2.0" = [ pkgs."gdk_pixbuf" ];

36 "gdk-x11-2.0" = [ pkgs."gdk_x11" ];

37 "gdk-x11-3.0" = [ pkgs."gtk3" ];

38 "gio-2.0" = [ pkgs."glib" ];

@@ -45,9 +45,7 @@ pkgs:

45 "gnome-vfs-2.0" = [ pkgs."gnome-vfs" ];

46 "gnome-vfs-module-2.0" = [ pkgs."gnome-vfs_module" ];

47 "gobject-2.0" = [ pkgs."glib" ];

48− "gmodule-2.0" = [ pkgs."glib" ];

49 "gobject-introspection-1.0" = [ pkgs."gobject-introspection" ];

48 "gobject-introspection-1.0" = [ pkgs."gobject-introspection" ];

50− "graphene-gobject-1.0" = [ pkgs."graphene" ];

51 "gstreamer-audio-0.10" = [ pkgs."gst-plugins-base" ];

49 "gstreamer-audio-0.10" = [ pkgs."gst-plugins-base" ];

52 "gstreamer-audio-1.0" = [ pkgs."gst-plugins-base" ];

50 "gstreamer-audio-1.0" = [ pkgs."gst-plugins-base" ];

53 "gstreamer-base-0.10" = [ pkgs."gst-plugins-base" ];

51 "gstreamer-base-0.10" = [ pkgs."gst-plugins-base" ];

@@ -67,7 +65,6 @@ pkgs:

67 "hidapi-libusb" = [ pkgs."hidapi" ];

65 "hidapi-libusb" = [ pkgs."hidapi" ];

68 "icudata" = [ pkgs."icu" ];

66 "icudata" = [ pkgs."icu" ];

69 "icui18n" = [ pkgs."icu" ];

67 "icui18n" = [ pkgs."icu" ];

70− "icu-i18n" = [ pkgs."icu" ];

71 "icuuc" = [ pkgs."icu" ];

68 "icuuc" = [ pkgs."icu" ];

72 "idn" = [ pkgs."libidn" ];

69 "idn" = [ pkgs."libidn" ];

73 "IL" = [ pkgs."libdevil" ];

70 "IL" = [ pkgs."libdevil" ];

@@ -83,10 +80,7 @@ pkgs:

83 "lber" = [ pkgs."openldap" ];

80 "lber" = [ pkgs."openldap" ];

84 "ldap" = [ pkgs."openldap" ];

81 "ldap" = [ pkgs."openldap" ];

85 "libavutil" = [ pkgs."ffmpeg" ];

82 "libavutil" = [ pkgs."ffmpeg" ];

86− "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" ];

@@ -94,14 +88,12 @@ pkgs:

94 "libsecp256k1" = [ pkgs."secp256k1" ];

88 "libsecp256k1" = [ pkgs."secp256k1" ];

95 "libsoup-2.4" = [ pkgs."libsoup" ];

89 "libsoup-2.4" = [ pkgs."libsoup" ];

96 "libsoup-gnome-2.4" = [ pkgs."libsoup" ];

90 "libsoup-gnome-2.4" = [ pkgs."libsoup" ];

97− "libssl" = [ pkgs."openssl".dev ];

98 "libsystemd" = [ pkgs."systemd" ];

91 "libsystemd" = [ pkgs."systemd" ];

99 "libudev" = [ pkgs."systemd" ];

92 "libudev" = [ pkgs."systemd" ];

100 "libusb-1.0" = [ pkgs."libusb1" ];

93 "libusb-1.0" = [ pkgs."libusb1" ];

101 "libxml-2.0" = [ pkgs."libxml2" ];

94 "libxml-2.0" = [ pkgs."libxml2" ];

102 "libzip" = [ pkgs."libzip" ];

95 "libzip" = [ pkgs."libzip" ];

103 "libzmq" = [ pkgs."zeromq" ];

96 "libzmq" = [ pkgs."zeromq" ];

104− "libzstd" = [ pkgs."zstd" ];

105 "m" = []; # in stdenv

97 "m" = []; # in stdenv

106 "magic" = [ pkgs."file" ];

98 "magic" = [ pkgs."file" ];

107 "MagickWand" = [ pkgs."imagemagick" ];

99 "MagickWand" = [ pkgs."imagemagick" ];

@@ -122,9 +114,7 @@ pkgs:

122 "pfs-1.2" = [ pkgs."pfstools" ];

114 "pfs-1.2" = [ pkgs."pfstools" ];

123 "png" = [ pkgs."libpng" ];

115 "png" = [ pkgs."libpng" ];

124 "poppler-glib" = [ pkgs."poppler" ];

116 "poppler-glib" = [ pkgs."poppler" ];

125− "poppler-cpp" = [ pkgs."poppler" ];

126 "pq" = [ pkgs."postgresql" ];

117 "pq" = [ pkgs."postgresql" ];

127− "libpq" = [ pkgs."postgresql" ];

128 "pthread" = [];

118 "pthread" = [];

129 "pulse" = [ pkgs."libpulseaudio" ];

119 "pulse" = [ pkgs."libpulseaudio" ];

130 "pulse-simple" = [ pkgs."libpulseaudio" ];

120 "pulse-simple" = [ pkgs."libpulseaudio" ];

@@ -146,6 +136,7 @@ pkgs:

146 "sodium" = [ pkgs."libsodium" ];

136 "sodium" = [ pkgs."libsodium" ];

147 "sqlite3" = [ pkgs."sqlite" ];

137 "sqlite3" = [ pkgs."sqlite" ];

148 "ssh2" = [ pkgs."libssh2" ];

138 "ssh2" = [ pkgs."libssh2" ];

139+ "ssl" = [ pkgs."openssl" ];

149 "statgrab" = [ pkgs."libstatgrab" ];

140 "statgrab" = [ pkgs."libstatgrab" ];

150 "stdc++" = []; # What is that?

141 "stdc++" = []; # What is that?

151 "stdc++.dll" = []; # What is that?

142 "stdc++.dll" = []; # What is that?

@@ -164,24 +155,23 @@ pkgs:

164 "webkit2gtk-4.0" = [ pkgs."webkitgtk" ];

155 "webkit2gtk-4.0" = [ pkgs."webkitgtk" ];

165 "webkit2gtk-web-extension-4.0" = [ pkgs."webkitgtk" ];

156 "webkit2gtk-web-extension-4.0" = [ pkgs."webkitgtk" ];

166 "webkitgtk-3.0" = [ pkgs."webkitgtk24x-gtk3" ]; # These are the old APIs, of which 2.4 is the last provider, so map directly to that

157 "webkitgtk-3.0" = [ pkgs."webkitgtk24x-gtk3" ]; # These are the old APIs, of which 2.4 is the last provider, so map directly to that

167− "vulkan" = [ pkgs."vulkan-loader" ]; # vulkan-loader provides vulkan.pc file for pkg-config.

168− "X11" = [ pkgs.xorg."libX11" ];

158+ "X11" = [ pkgs."libX11" ];

169− "x11" = [ pkgs.xorg."xlibsWrapper" ];

159+ "x11" = [ pkgs."xlibsWrapper" ];

170− "xau" = [ pkgs.xorg."libXau" ];

160+ "xau" = [ pkgs."libXau" ];

171− "Xcursor" = [ pkgs.xorg."libXcursor" ];

161+ "Xcursor" = [ pkgs."libXcursor" ];

172 "xerces-c" = [ pkgs."xercesc" ];

162 "xerces-c" = [ pkgs."xercesc" ];

173− "Xext" = [ pkgs.xorg."libXext" ];

163+ "Xext" = [ pkgs."libXext" ];

174− "xft" = [ pkgs.xorg."libXft" ];

164+ "xft" = [ pkgs."libXft" ];

175− "Xi" = [ pkgs.xorg."libXi" ];

165+ "Xi" = [ pkgs."libXi" ];

176− "Xinerama" = [ pkgs.xorg."libXinerama" ];

166+ "Xinerama" = [ pkgs."libXinerama" ];

177 "xkbcommon" = [ pkgs."libxkbcommon" ];

167 "xkbcommon" = [ pkgs."libxkbcommon" ];

178 "xml2" = [ pkgs."libxml2" ];

168 "xml2" = [ pkgs."libxml2" ];

179− "Xpm" = [ pkgs.xorg."libXpm" ];

169+ "Xpm" = [ pkgs."libXpm" ];

180− "Xrandr" = [ pkgs.xorg."libXrandr" ];

170+ "Xrandr" = [ pkgs."libXrandr" ];

181− "Xrender" = [ pkgs.xorg."libXrender" ];

171+ "Xrender" = [ pkgs."libXrender" ];

182− "Xss" = [ pkgs.xorg."libXScrnSaver" ];

172+ "Xss" = [ pkgs."libXScrnSaver" ];

183− "Xtst" = [ pkgs.xorg."libXtst" ];

173+ "Xtst" = [ pkgs."libXtst" ];

184− "Xxf86vm" = [ pkgs.xorg."libXxf86vm" ];

174+ "Xxf86vm" = [ pkgs."libXxf86vm" ];

185 "yaml" = [ pkgs."libyaml" ];

175 "yaml" = [ pkgs."libyaml" ];

186 "yaml-0.1" = [ pkgs."libyaml" ];

176 "yaml-0.1" = [ pkgs."libyaml" ];

187 "z" = [ pkgs."zlib" ];

177 "z" = [ pkgs."zlib" ];

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/cabal.nixdeleted−19

@@ -1,19 +0,0 @@

1−let

2− spdx = import ./parser.nix;

3−in pkgs:

4−with builtins;

5−let

6− # For better performance these are not in the

7− # let block below (probably helps by increasing

8− # the sharing)

9− license-map = import ../cabal-licenses.nix pkgs;

10− otherLicenseWarning = lic:

11− trace "WARNING: license \"${lic}\" not found"

12− license-map.LicenseRef-OtherLicense;

13−in license:

14−let

15− licenses = spdx.compound-expression license;

16−in if licenses == []

17− then otherLicenseWarning license

18− else map (lic: license-map.${lic} or (otherLicenseWarning lic))

19− (pkgs.lib.unique (head licenses)._1)

lib/spdx/licenses.nixdeleted−27

@@ -1,27 +0,0 @@

1−pkgs:

2−with builtins; let

3− spdxJson = pkgs.buildPackages.spdx-license-list-data.json or pkgs.buildPackages.spdx-license-list-data;

4− materialized' = ../../materialized + "/spdx-${spdxJson.version}";

5− licensesJSON = fromJSON (replaceStrings

6− [ "\\u0026" "\\u0027" "\\u003d" ]

7− [ "&" "'" "=" ]

8− (readFile "${pkgs.buildPackages.haskell-nix.materialize {

9− materialized = if pathExists materialized' then materialized' else null;

10− } (pkgs.buildPackages.runCommand "spdx-json" { inherit (spdxJson) version; } ''

11− mkdir $out

12− cp ${spdxJson}/json/licenses.json $out

13− '')

14− }/licenses.json")

15− );

16− dropFour = s: substring 0 (stringLength s - 4) s;

17− toSpdx = lic: with lic;

18− { spdxId = licenseId;

19− shortName = licenseId;

20− fullName = name;

21− url = dropFour detailsUrl + "html";

22− free = isOsiApproved || lic.isFsfLibre or false;

23− };

24− toNamedValue = lic: { name = lic.spdxId; value = lic; };

25−in

26−

27−listToAttrs (map (l: toNamedValue (toSpdx l)) licensesJSON.licenses)

lib/spdx/parser.nixdeleted−115

@@ -1,115 +0,0 @@

1−let String = { mempty = ""; mappend = a: b: a + b; };

2− List = { singleton = x: [x]; };

3− pair = a: b: { _1 = a; _2 = b; };

4− Pair = { pure = s: pair String.mempty s;

5− mappend = a: b: pair (String.mappend a._1 b._1) b._2;

6− map = f: p: pair (f p._1) p._2;

7− };

8− compose = f: g: x: f (g x);

9−in with builtins; rec {

10− # Parser a = String -> [(a, String)]

11− string = str: s:

12− let strL = stringLength str;

13− sL = stringLength s;

14− in if str == substring 0 strL s

15− then [ (pair str (substring strL sL s)) ]

16− else [];

17−

18− regex = capture_groups: re: s:

19− let result = match "(${re})(.*)" s;

20− in if result == null

21− then []

22− else [ (pair (elemAt result 0) (elemAt result (1 + capture_groups))) ];

23−

24− # Left-biased choice

25− choice = cs: s:

26− if cs == []

27− then []

28− else let c = head cs;

29− cs' = tail cs;

30− result = c s;

31− in if result == []

32− then choice cs' s

33− else result;

34−

35− optional = p: s:

36− let result = p s;

37− in if result == []

38− then [ (Pair.pure s) ]

39− else result;

40−

41− chain = ps: s:

42− if ps == []

43− then [ (Pair.pure s) ]

44− else let p = head ps;

45− ps' = tail ps;

46− result = p s;

47− in if result == []

48− then []

49− else let r = head result;

50− rest = chain ps' r._2;

51− in if rest == []

52− then []

53− else let r' = head rest;

54− in [ (Pair.mappend r r') ];

55−

56− idstring = regex 0 "[-\.0-9a-zA-Z]+";

57−

58− license-ref = let documentref = chain [ (string "DocumentRef-")

59− idstring

60− (string ":")

61− ];

62− in chain [

63− (optional documentref)

64− (string "LicenseRef-")

65− idstring

66− ];

67−

68− simple-expression = choice [ license-ref

69− (chain [ idstring (string "+") ])

70− idstring

71− ];

72−

73− compound-expression = let wrap = compose (map (Pair.map List.singleton));

74− in choice [

75− (s: let result = simple-expression s;

76− in if result == []

77− then []

78− else let r = head result;

79− rest = chain [(string " WITH ") idstring ] r._2;

80− in if rest == []

81− then []

82− else [(pair r._1 (head rest)._2)]

83− )

84− (s: let result = simple-expression s;

85− in if result == []

86− then []

87− else let r = head result;

88− firstLicense = r._1;

89− operator = choice [ (string " AND ")

90− (string " OR ")

91− ]

92− r._2;

93− in if operator == []

94− then []

95− else let s' = (head operator)._2;

96− licenses = compound-expression s';

97− in if licenses == []

98− then []

99− else let ls = head licenses;

100− in [(pair ([firstLicense] ++ ls._1) ls._2)]

101− )

102− (wrap simple-expression)

103− (s: let openParen = string "(" s;

104− in if openParen == []

105− then []

106− else let result = compound-expression (head openParen)._2;

107− in if result == []

108− then []

109− else let r = head result;

110− closeParen = string ")" r._2;

111− in if closeParen == []

112− then []

113− else [(pair r._1 (head closeParen)._2)])

114− ];

115−}

lib/spdx/test.nixdeleted−32

@@ -1,32 +0,0 @@

1−let spdx = import ./parser.nix;

2−in {

3− idstringF = [ (spdx.idstring "$@#!$") ];

4− idstringP = [ (spdx.idstring "blah") ];

5−

6− license-refF = [ (spdx.license-ref "LicenseRef-$@#!$") ];

7− license-refP = [ (spdx.license-ref "LicenseRef-blah")

8− (spdx.license-ref "DocumentRef-beep:LicenseRef-boop")

9− ];

10−

11− simple-expressionF = [ (spdx.simple-expression "$@#!$") ];

12− simple-expressionP = [

13− (spdx.simple-expression "blah")

14− (spdx.simple-expression "blah+")

15− (spdx.simple-expression "LicenseRef-blah")

16− (spdx.simple-expression "DocumentRef-beep:LicenseRef-boop")

17− ];

18−

19− compound-expressionF = [ (spdx.compound-expression "$@#!$") ];

20− compound-expressionP = [

21− (spdx.compound-expression "blah")

22− (spdx.compound-expression "blah+")

23− (spdx.compound-expression "LicenseRef-blah")

24− (spdx.compound-expression "DocumentRef-beep:LicenseRef-boop")

25− (spdx.compound-expression "(blah)")

26− (spdx.compound-expression "beep OR boop")

27− (spdx.compound-expression "beep AND boop")

28− (spdx.compound-expression "beep WITH boop")

29− (spdx.compound-expression "beep AND (boop OR blap)")

30− (spdx.compound-expression "(beep AND ((boop OR ((blap)))))")

31− ];

32−}

lib/stack-cache-generator.nix+31−46

@@ -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,22 +9,15 @@

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"; };

11−, branchMap ? null

12+, lookupSha256 ?

12− # A way to specify in which branch a git commit can

13− # be found

14−, lookupBranch ?

15− if branchMap != null

13+ if sha256map != null

16− then { location, tag, ...}: branchMap."${location}"."${tag}" or null

14+ then { location, tag, ...}: sha256map."${location}"."${tag}"

17 else _: null

15 else _: null

18, resolverSha256 ? null

16, resolverSha256 ? null

19−, nix-tools

17+, 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, ...

18, ...

22−}@args:

19+}:

23let

20let

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

21 # 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

22 # we want to avoid recalculating the cache unless the stack.yaml file

29 # changes.

23 # changes.

@@ -33,27 +27,20 @@ let

33 }) resolver fetchedResolver;

27 }) resolver fetchedResolver;

34

28

35 # Filter just the stack yaml file and any resolver yaml file it points to.

29 # Filter just the stack yaml file and any resolver yaml file it points to.

30+ maybeCleanedSource =

31+ if haskellLib.canCleanSource src

36− maybeCleanedSource = haskellLib.cleanSourceWith {

32+ then haskellLib.cleanSourceWith {

37− inherit src;

33+ inherit src;

38− filter = path: type:

34+ filter = path: type:

39− let

40− origSrc = if src ? _isLibCleanSourceWith then src.origSrc else src;

41− origSubDir = if src ? _isLibCleanSourceWithEx then src.origSubDir else "";

42− relPath = evalPackages.lib.removePrefix (toString origSrc + origSubDir + "/") path;

43−

44− # checks if path1 is a parent directory for path2

45− isParent = path1: path2: evalPackages.lib.hasPrefix "${path1}/" path2;

46−

47− in

48− (relPath == stackYaml)

35+ pkgs.lib.hasSuffix ("/" + stackYaml) path

49− || (resolver != null && (relPath == resolver || isParent relPath resolver))

36+ || (resolver != null && pkgs.lib.hasSuffix ("/" + resolver) path);

50− ;

51− };

37+ }

38+ else src;

52

39

53 # All repos served via ssh or git protocols are usually private

40 # All repos served via ssh or git protocols are usually private

54− private = url: evalPackages.lib.substring 0 4 url != "http";

41+ private = url: pkgs.lib.substring 0 4 url != "http";

55

42

56− repos = builtins.fromJSON (builtins.readFile (evalPackages.runCommand "stack-repos" {

43+ repos = builtins.fromJSON (builtins.readFile (pkgs.runCommand "stack-repos" {

57 buildInputs = [ nix-tools ];

44 buildInputs = [ nix-tools ];

58 } ''

45 } ''

59 TMP=$(mktemp -d)

46 TMP=$(mktemp -d)

@@ -61,43 +48,41 @@ let

61 cp -r "${maybeCleanedSource}/." $TMP

48 cp -r "${maybeCleanedSource}/." $TMP

62 chmod -R +w $TMP

49 chmod -R +w $TMP

63 substituteInPlace ${stackYaml} --replace "# nix-sha256:" "nix-sha256:"

50 substituteInPlace ${stackYaml} --replace "# nix-sha256:" "nix-sha256:"

64− ${evalPackages.lib.optionalString (fetchedResolver != null) ''

51+ ${pkgs.lib.optionalString (fetchedResolver != null) ''

65 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

52 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

66 ''}

53 ''}

67 stack-repos --stack-yaml ${stackYaml}

54 stack-repos --stack-yaml ${stackYaml}

68 cp repos.json $out

55 cp repos.json $out

69 ''));

56 ''));

70

57

71− cabalName = path: builtins.readFile (evalPackages.runCommand "cabal-name" {

58+ cabalName = path: builtins.readFile (pkgs.runCommand "cabal-name" {

72 buildInputs = [ nix-tools ];

59 buildInputs = [ nix-tools ];

73 } ''

60 } ''

74 cabal-name ${path} > $out

61 cabal-name ${path} > $out

75 '');

62 '');

76

63

77 hashPath = path:

64 hashPath = path:

78− builtins.readFile (evalPackages.runCommand "hash-path" { preferLocalBuild = true; }

65+ builtins.readFile (pkgs.runCommand "hash-path" { preferLocalBuild = true; }

79− "echo -n $(${evalPackages.nix}/bin/nix-hash --type sha256 --base32 ${path}) > $out");

66+ "echo -n $(${pkgs.nix}/bin/nix-hash --type sha256 --base32 ${path}) > $out");

80−in with evalPackages.lib;

67+in with pkgs.lib;

81concatMap (dep:

68concatMap (dep:

82 let

69 let

83 is-private = private dep.url;

70 is-private = private dep.url;

84− sha256 =

85− if dep.sha256 != null then dep.sha256

71+ sha256 = if dep.sha256 != null

86− else if sha256map != null then sha256map."${dep.url}"."${dep.rev}"

72+ then dep.sha256

87− else null;

73+ else lookupSha256 {

88− branch = lookupBranch {

89− location = dep.url;

74+ location = dep.url;

90− tag = dep.rev;

75+ tag = dep.rev;

91− };

76+ };

92 pkgsrc =

77 pkgsrc =

93 if !is-private && sha256 != null

78 if !is-private && sha256 != null

94− then evalPackages.fetchgit {

79+ then pkgs.fetchgit {

95 inherit (dep) url rev;

80 inherit (dep) url rev;

96 inherit sha256;

81 inherit sha256;

97 }

82 }

98− else builtins.fetchGit ({

83+ else builtins.fetchGit {

99 inherit (dep) url rev;

84 inherit (dep) url rev;

100− } // evalPackages.lib.optionalAttrs (branch != null) { ref = branch; });

85+ };

101 in map (subdir: {

86 in map (subdir: {

102 name = cabalName "${pkgsrc}/${subdir}";

87 name = cabalName "${pkgsrc}/${subdir}";

103 inherit (dep) url rev;

88 inherit (dep) url rev;

lib/system-nixpkgs-map.nix+82−119

@@ -1,136 +1,99 @@

1−# Maps of system pkg references from cabal file to nixpkgs pkgs.

1+# Maps of system pkg references from

2−# library name (from `extra-libraries` field of `.cabal` file) -> nixpkgs package(s) mapping.

2+# cabal file to nixpkgs pkgs.

3−# This mapping is used to construct the `libs` component attribute.

4−# See ../docs/tutorials/pkg-map.md

3+# See ../docs/dev/pkg-map.md

5pkgs:

4pkgs:

6−

5+# fetchgit should always come from the evalPackages

7−with pkgs;

6+# if it comes from the targetPackages we won't even

8−

7+# be able to execute it.

9−let

8+ { fetchgit = pkgs.evalPackages.fetchgit; }

10− # On windows systems we need these to be propagatedBuildInputs so that the DLLs will be found.

9+# haskell lib -> nix lib mapping

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

10# -- linux

21−{ crypto = [ openssl ];

11+// { crypto = pkgs.openssl;

22− "c++" = []; # no libc++

12+ "c++" = null; # no libc++

23− "stdc++" = gcclibs;

13+ "stdc++" = null; "stdc++-6" = null;

24− "stdc++-6" = gcclibs;

25− gcc_s_seh-1 = gcclibs;

26− gcc_s = gcclibs;

27− gcc = gcclibs;

28− ssl = [ openssl ];

14+ ssl = pkgs.openssl;

29− z = [ zlib ];

15+ z = pkgs.zlib;

30− m = []; # Included with ghc

31− pcap = [ libpcap ];

32− pthread = null; # available by default

16+ pthread = null; # available by default

33− GL = [ libGL ];

17+ GL = pkgs.libGL;

34− GLEW = [ glew ];

35− GLU = [ libGLU ];

18+ GLU = pkgs.libGLU;

36− alut = [ freealut ];

19+ alut = pkgs.freealut;

37− X11 = with xorg; [ libX11 ];

20+ X11 = pkgs.xorg.libX11;

38− Xrandr = [ xorg.libXrandr ];

21+ Xrandr = pkgs.xorg.libXrandr;

39− Xrender = [ xorg.libXrender ];

40− Xss = [ xorg.libXScrnSaver ];

41− Xext = [ xorg.libXext ];

22+ Xext = pkgs.xorg.libXext;

42− Xi = [ xorg.libXi ];

23+ Xi = pkgs.xorg.libXi;

43− Xxf86vm = [ xorg.libXxf86vm ];

24+ Xxf86vm = pkgs.xorg.libXxf86vm;

44− Xcursor = [ xorg.libXcursor ];

25+ Xcursor = pkgs.xorg.libXcursor;

45− Xinerama = [ xorg.libXinerama ];

26+ Xinerama = pkgs.xorg.libXinerama;

46− mysqlclient = [ mysql ];

27+ mysqlclient = pkgs.mysql;

47− Imlib2 = [ imlib2 ];

28+ Imlib2 = pkgs.imlib2;

48− asound = [ alsaLib ];

29+ asound = pkgs.alsaLib;

49− ffi = null;

30+ ffi = null;

50− bz2 = [ bzip2 ];

31+ bz2 = pkgs.bzip2;

51− util = [ utillinux ];

32+ util = pkgs.utillinux;

52− magic = [ file ];

33+ magic = pkgs.file;

53− pq = [ postgresql ];

34+ pq = pkgs.postgresql;

54− libpq = [ postgresql ];

55− iconv = [ libiconv ];

35+ iconv = pkgs.libiconv;

56− lapack = [ liblapack ];

36+ lapack = pkgs.liblapack;

57− boost_atomic = [ boost ];

37+ boost_atomic = pkgs.boost;

58− boost_chrono = [ boost ];

38+ boost_chrono = pkgs.boost;

59− boost_container = [ boost ];

39+ boost_container = pkgs.boost;

60− boost_context = [ boost ];

40+ boost_context = pkgs.boost;

61− boost_contract = [ boost ];

41+ boost_contract = pkgs.boost;

62− boost_coroutine = [ boost ];

42+ boost_coroutine = pkgs.boost;

63− boost_date_time = [ boost ];

43+ boost_date_time = pkgs.boost;

64− boost_fiber = [ boost ];

44+ boost_fiber = pkgs.boost;

65− boost_filesystem = [ boost ];

45+ boost_filesystem = pkgs.boost;

66− boost_graph = [ boost ];

46+ boost_graph = pkgs.boost;

67− boost_iostreams = [ boost ];

47+ boost_iostreams = pkgs.boost;

68− boost_locale = [ boost ];

48+ boost_locale = pkgs.boost;

69− boost_log_setup = [ boost ];

49+ boost_log_setup = pkgs.boost;

70− boost_log = [ boost ];

50+ boost_log = pkgs.boost;

71− boost_math_c99f = [ boost ];

51+ boost_math_c99f = pkgs.boost;

72− boost_math_c99l = [ boost ];

52+ boost_math_c99l = pkgs.boost;

73− boost_math_c99 = [ boost ];

53+ boost_math_c99 = pkgs.boost;

74− boost_math_tr1f = [ boost ];

54+ boost_math_tr1f = pkgs.boost;

75− boost_math_tr1l = [ boost ];

55+ boost_math_tr1l = pkgs.boost;

76− boost_math_tr1 = [ boost ];

56+ boost_math_tr1 = pkgs.boost;

77− boost_prg_exec_monitor = [ boost ];

57+ boost_prg_exec_monitor = pkgs.boost;

78− boost_program_options = [ boost ];

58+ boost_program_options = pkgs.boost;

79− boost_random = [ boost ];

59+ boost_random = pkgs.boost;

80− boost_regex = [ boost ];

60+ boost_regex = pkgs.boost;

81− boost_serialization = [ boost ];

61+ boost_serialization = pkgs.boost;

82− boost_signals = [ boost ];

62+ boost_signals = pkgs.boost;

83− boost_stacktrace_addr2line = [ boost ];

63+ boost_stacktrace_addr2line = pkgs.boost;

84− boost_stacktrace_basic = [ boost ];

64+ boost_stacktrace_basic = pkgs.boost;

85− boost_stacktrace_noop = [ boost ];

65+ boost_stacktrace_noop = pkgs.boost;

86− boost_system = [ boost ];

66+ boost_system = pkgs.boost;

87− boost_thread = [ boost ];

67+ boost_thread = pkgs.boost;

88− boost_timer = [ boost ];

68+ boost_timer = pkgs.boost;

89− boost_type_erasure = [ boost ];

69+ boost_type_erasure = pkgs.boost;

90− boost_unit_test_framework = [ boost ];

70+ boost_unit_test_framework = pkgs.boost;

91− boost_wave = [ boost ];

71+ boost_wave = pkgs.boost;

92− boost_wserialization = [ boost ];

72+ boost_wserialization = pkgs.boost;

93− tensorflow = [ libtensorflow ];

73+ tensorflow = pkgs.libtensorflow;

94− # odbc package requires unixODBC packages to be installed in order to successfully

95− # compile C sources (https://github.com/fpco/odbc/blob/master/cbits/odbc.c)

96− odbc = [ unixODBC ];

97− opencv = [ opencv3 ];

74+ opencv = pkgs.opencv3;

98− icuuc = [ icu ];

75+ icuuc = pkgs.icu;

99− icui18n = [ icu ];

76+ icui18n = pkgs.icu;

100− icu-i18n = [ icu ];

101− icudata = [ icu ];

77+ icudata = pkgs.icu;

102− vulkan = [ vulkan-loader ];

78+ vulkan = pkgs.vulkan-loader;

103− sodium = [ libsodium ];

79+ sodium = pkgs.libsodium;

104− gfortran = [ gfortran.cc.lib ];

80+ gfortran = pkgs.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−}

81+ }

118# -- windows

82# -- windows

119// { advapi32 = null; gdi32 = null; imm32 = null; msimg32 = null;

83// { advapi32 = null; gdi32 = null; imm32 = null; msimg32 = null;

120 shell32 = null; shfolder = null; shlwapi = null; user32 = null;

84 shell32 = null; shfolder = null; shlwapi = null; user32 = null;

121− ole32 = null; rpcrt4 = null;

122 winmm = null; userenv = null;

85 winmm = null; userenv = null;

123 kernel32 = null; ws2_32 = null;

86 kernel32 = null; ws2_32 = null;

124 # this should be bundled with gcc.

87 # this should be bundled with gcc.

125 # if it's not we have more severe

88 # if it's not we have more severe

126 # issues anyway.

89 # issues anyway.

90+ gcc_s_seh-1 = null;

127− ssl32 = null; eay32 = [ openssl ];

91+ ssl32 = null; eay32 = pkgs.openssl;

128 iphlpapi = null; # IP Help API

92 iphlpapi = null; # IP Help API

129 msvcrt = null; # this is the libc

93 msvcrt = null; # this is the libc

130 Crypt32 = null;

94 Crypt32 = null;

131 mswsock = null;

95 mswsock = null;

132− bcrypt = null;

133 }

96 }

134# -- os x

97# -- os x

135# NB: these map almost 1:1 to the framework names

98# NB: these map almost 1:1 to the framework names

136−// darwin.apple_sdk.frameworks

99+// pkgs.darwin.apple_sdk.frameworks

lib/system-pkgs.nixdeleted−16

@@ -1,16 +0,0 @@

1−# Cabal packages can depend on operating system packages. However

2−# package names vary between distributions - there is no standard.

3−#

4−# This file augments the nixpkgs package set with extra attributes

5−# from the system packages map file.

6−#

7−# This package set will be used when resolving system package

8−# dependencies of package descriptions.

9−

10−pkgs:

11−

12− # Base packages.

13− pkgs

14−

15− # Apply the mapping.

16− // import ./system-nixpkgs-map.nix pkgs

materialized/bootstrap/ghc8107/alex/.plan.nix/alex.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/.plan.nix/alex.nix+1−1

@@ -150,7 +150,7 @@

150 (hsPkgs."process" or (errorHandler.buildDepError "process"))

151 ];

152 build-tools = [

153− (hsPkgs.buildPackages.alex.components.exes.alex or (pkgs.buildPackages.alex or (errorHandler.buildToolDepError "alex:alex")))

153+ (hsPkgs.buildPackages.alex or (pkgs.buildPackages.alex or (errorHandler.buildToolDepError "alex")))

154 ];

155 buildable = true;

156 mainPath = [ "test.hs" ];

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+5−5

@@ -23,14 +23,14 @@

23 buildType = "Custom";

24 isLocal = true;

25 setup-depends = [

26− (hsPkgs.buildPackages.Cabal or (pkgs.buildPackages.Cabal or (errorHandler.setupDepError "Cabal")))

26+ (hsPkgs.buildPackages.Cabal or (pkgs.buildPackages.Cabal or (errorHandler.buildToolDepError "Cabal")))

27− (hsPkgs.buildPackages.base or (pkgs.buildPackages.base or (errorHandler.setupDepError "base")))

27+ (hsPkgs.buildPackages.base or (pkgs.buildPackages.base or (errorHandler.buildToolDepError "base")))

28− (hsPkgs.buildPackages.directory or (pkgs.buildPackages.directory or (errorHandler.setupDepError "directory")))

28+ (hsPkgs.buildPackages.directory or (pkgs.buildPackages.directory or (errorHandler.buildToolDepError "directory")))

29− (hsPkgs.buildPackages.filepath or (pkgs.buildPackages.filepath or (errorHandler.setupDepError "filepath")))

29+ (hsPkgs.buildPackages.filepath or (pkgs.buildPackages.filepath or (errorHandler.buildToolDepError "filepath")))

30 ];

31 detailLevel = "FullDetails";

32 licenseFiles = [ "LICENSE" ];

33− dataDir = ".";

33+ dataDir = "";

34 dataFiles = [];

35 extraSrcFiles = [

36 "ANNOUNCE"

materialized/bootstrap/ghc844/happy-1.19.11/default.nix+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/.plan.nix/happy.nix+1−1

@@ -190,7 +190,7 @@

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")))

193+ (hsPkgs.buildPackages.happy or (pkgs.buildPackages.happy or (errorHandler.buildToolDepError "happy")))

194 ];

195 buildable = true;

196 mainPath = [ "test.hs" ];

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/.plan.nix/hscolour.nix+1−1

@@ -24,7 +24,7 @@

24 isLocal = true;

25 detailLevel = "FullDetails";

26 licenseFiles = [ "LICENCE-LGPL" ];

27− dataDir = ".";

27+ dataDir = "";

28 dataFiles = [ "hscolour.css" "data/rgb24-example-.hscolour" ];

29 extraSrcFiles = [];

30 extraTmpFiles = [];

materialized/bootstrap/ghc844/hscolour/default.nix+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 = {}; }; }; })