iko/ghcjs-patch-master..355cd37 · haskell.nix

git.iko.soy/haskell.nix

1118 files changed+11330−156475

unifiedsplit

.buildkite/pipeline.yml−12

@@ -38,15 +38,3 @@ steps:

3838 command:

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

4040 - ./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

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

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

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

182

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

build.nix+8−21

@@ -8,9 +8,8 @@ in

88{ nixpkgs ? haskellNix.sources.nixpkgs-2111

99, nixpkgsArgs ? haskellNix.nixpkgsArgs

1010, pkgs ? import nixpkgs nixpkgsArgs

11−, evalPackages ? import nixpkgs nixpkgsArgs

1211, nixpkgsForHydra ? haskellNix.sources.nixpkgs-2105

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

12+, pkgsForHydra ? import nixpkgsForHydra nixpkgsArgs

1413, ifdLevel ? 1000

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

1615}:

@@ -20,22 +19,14 @@ let

2019 buildHaskell = pkgs.buildPackages.haskell-nix;

2120 tool = buildHaskell.tool;

2221in rec {

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

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

2423

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

2625 pkgs.recurseIntoAttrs ({

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

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

29− inherit evalPackages;

30− version = {

31− "ghc865" = "3.2.8";

32− "ghc882" = "3.3.6";

33− "ghc883" = "3.3.6";

34− "ghc884" = "3.3.6";

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

36− };

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

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

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

27+ } // pkgs.lib.optionalAttrs (!__elem compiler-nix-name ["ghc901" "ghc902" "ghc921"]) {

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

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

3930 })

4031 );

4132

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

7768 ];

7869 };

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

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

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

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

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

84− };

71+ check-path-support = pkgs.buildPackages.callPackage ./scripts/check-path-support.nix {};

8572 };

8673

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

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

8976 maintainer-script-cache = pkgs.recurseIntoAttrs (

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

77+ (pkgs.lib.optionalAttrs pkgs.stdenv.hostPlatform.isLinux {

9178 inherit (maintainer-scripts) check-hydra;

9279 })

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

builder/comp-builder.nix+29−74

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

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

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

22lib.makeOverridable (

33let self =

44{ componentId

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

5050, writeHieFiles ? component.writeHieFiles

5151

5252, ghcOptions ? component.ghcOptions

53−, contentAddressed ? component.contentAddressed

5453

5554# Options for Haddock generation

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

@@ -100,10 +99,9 @@ let

10099 && !stdenv.hostPlatform.isMusl

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

102101

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

102+ ghc = if enableDWARF then defaults.ghc.dwarf else

103+ if smallAddressSpace then defaults.ghc.smallAddressSpace else defaults.ghc;

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

107105

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

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

@@ -205,7 +203,7 @@ let

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

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

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

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

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

209207 # component.

210208 "--disable-executable-dynamic"

211209 "--ghc-option=-optl=-pthread"

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

225223 "--ghc-option=-fPIC" "--gcc-option=-fPIC"

226224 ]

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

236226 );

237227

238228 executableToolDepends =

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

246236 shellWrappers = ghcForComponent {

247237 componentName = fullName;

248238 inherit configFiles enableDWARF;

249− inherit (component) plugins;

250239 };

251240

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

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

317306 componentDrv = drv;

318307 };

319308

320− contentAddressedAttrs = lib.optionalAttrs contentAddressed {

321− __contentAddressed = true;

322− outputHashMode = "recursive";

323− outputHashAlgo = "sha256";

324− };

325−

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

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

327310 pname = nameOnly;

328311 inherit (package.identifier) version;

329312

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

356339 description = package.synopsis or "";

357340 license = haskellLib.cabalToNixpkgsLicense package.license;

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

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

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

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

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

363− # attempt to run, for example,

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

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

366− mainProgram = exeName;

367342 };

368343

369344 propagatedBuildInputs =

370345 frameworks # Frameworks will be needed at link time

371346 # Not sure why pkgconfig needs to be propagatedBuildInputs but

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

373− ++ builtins.concatLists pkgconfig

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

375− (lib.flatten component.libs

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

348+ ++ builtins.concatLists pkgconfig;

377349

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

379− (lib.flatten component.libs

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

350+ buildInputs = component.libs

351+ ++ map haskellLib.dependToLib component.depends;

381352

382353 nativeBuildInputs =

383354 [shellWrappers buildPackages.removeReferencesTo]

@@ -411,36 +382,18 @@ let

411382 runHook postConfigure

412383 '';

413384

414− buildPhase =

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

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

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

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

419− # list when we need it.

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

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

422− '') +

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

424−

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

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

427− # where the binary cache becomes useless

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

429− (if contentAddressed then ''

430− runHook preBuild

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

432− runHook postBuild

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

434− runHook preBuild

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

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

437− runHook postBuild

438− '' else ''

439− runHook preBuild

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

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

442− runHook postBuild

443− '');

385+ buildPhase = if stdenv.hostPlatform.isGhcjs then ''

386+ runHook preBuild

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

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

389+ runHook postBuild

390+ '' else ''

391+ runHook preBuild

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

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

394+ runHook postBuild

395+ ''

396+ ;

444397

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

446399 #

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

520473 fi

521474 '')

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

523− + (lib.optionalString enableSeparateDataOutput ''

524− mkdir -p $data

525− '')

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

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

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

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

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

530481 done

531482 ''

532483 # symlink all .dlls into the local directory.

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

485+ # to symlink over dlls as needed.

533486 + ''

534− for p in $pkgsHostTargetAsString; do

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

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

487+ echo "Symlink library dependencies..."

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

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

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

491+ fi

537492 done

538493 ''))

539494 + (lib.optionalString doCoverage ''

builder/default.nix+10−17

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

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

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

33let

44 # Builds a single component of a package.

@@ -46,28 +46,21 @@ let

4646 hoogleLocal = let

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

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

49− inherit evalPackages;

50− version = "5.0.18.3";

49+ version = "5.0.18.2";

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

5251 }

5352 }:

54− let

55− haskellPackages = {

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

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

58− then ghc.buildGHC

59− else ghc;

60− inherit packages hoogle;

61− };

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

63− then haskellLib.weakCallPackage pkgs nixpkgsHoogle {

64− inherit haskellPackages;

65− } (p: p.packages)

66− else haskellLib.weakCallPackage pkgs nixpkgsHoogle haskellPackages;

53+ haskellLib.weakCallPackage pkgs nixpkgsHoogle {

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

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

56+ then ghc.buildGHC

57+ else ghc;

58+ inherit packages hoogle;

59+ };

6760

6861 # Same as haskellPackages.shellFor in nixpkgs.

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

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

63+ inherit hsPkgs ghcForComponent makeConfigFiles hoogleLocal haskellLib buildPackages compiler;

7164 inherit (buildPackages) glibcLocales;

7265 };

7366

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

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

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

1414, postInstall ? ""

1515, enableDWARF

16−, plugins

1716}:

1817

1918let

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

3837 ''

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

4039

41− ''

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

43− + ''

40+ # Start with a ghc...

4441 mkdir -p $out/bin

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

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

4644 rm -rf ${libDir}/*/

47− ''

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

49− + ''

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

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

51− ''

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

53− + ''

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

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

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

5650 fi

57− ''

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

59− + ''

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

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

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

6254 fi

63− ''

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

65− + ''

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

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

6757

68− ''

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

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

71− # initialize them with the given arguments.

72− #

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

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

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

76− + ''

77− GHC_PLUGINS="["

78− LIST_PREFIX=""

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

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

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

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

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

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

85− LIST_PREFIX=""

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

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

88− LIST_PREFIX=","

89− '') plugin.args)}

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

91− LIST_PREFIX=","

92− '') plugins)}

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

94−

95− ''

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

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

98− + ''

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

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

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

10061

101− ''

102− # Wrap compiler executables with correct env variables.

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

104− + ''

62+ # Wrap compiler executables with correct env variables.

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

64+

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

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

10767 rm -f $out/bin/$prg

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

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

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

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

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

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

11574 fi

11675 done

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

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

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

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

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

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

12886 fi

12987 done

13088

131− ''

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

133− + ''

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

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

13591 rm -f $out/bin/haddock

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

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

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

13995 fi

14096

141− ''

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

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

144− + ''

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

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

99+

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

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

147102 rm -f $out/bin/$prg

builder/haddock-builder.nix−2

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

4141 inherit (package) identifier;

4242 inherit component fullName flags needsProfiling;

4343 chooseDrv = p: p.haddock;

44− inherit (componentDrv) enableDWARF;

4544 };

4645

4746 finalConfigureFlags = lib.concatStringsSep " " (

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

5655 componentName = fullName;

5756 configFiles = docsConfigFiles;

5857 inherit (componentDrv) enableDWARF;

59− inherit (component) plugins;

6058 };

6159

6260 drv = stdenv.mkDerivation (commonAttrs // {

builder/hspkg-builder.nix+31−32

@@ -23,14 +23,7 @@ assert (if ghc.isHaskellNixCompiler or false then true

2323 + pkgs.lib.optionalString (name != null) (" for " + name)));

2424

2525let

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

3427 fetchurl {

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

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

@@ -39,28 +32,41 @@ let

3932

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

4134

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

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

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

45− # version of Cabal bundled with GHC).

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

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

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

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

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

39+ cabalLibDepends = lib.optional (

40+ stdenv.hostPlatform.isGhcjs || (

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

42+ &&

43+ !builtins.elem package.identifier.name

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

45+ "filepath" "base-compat-batteries" "base-compat" "unix" "directory" "transformers"

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

47+ )

48+ )

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

4750

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`

51+ # This logic is needed so that we don't get duplicate packages if we

52+ # add a custom Cabal package to the dependencies. That way custom

53+ # setups won't complain about e.g. binary from the Cabal dependencies

54+ # and binary from the global package-db.

55+ nonReinstallablePkgs = if (

56+ stdenv.hostPlatform.isGhcjs || (

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

58+ &&

5559 !builtins.elem package.identifier.name

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

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

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

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

63+ )

64+ ) then [] else null;

5965

6066 defaultSetup = setup-builder ({

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

6268 component = {

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

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

6470 libs = [];

6571 frameworks = [];

6672 doExactConfig = false;

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

8894 synopsis = null;

8995 license = "MIT";

9096 };

91− src = null;

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

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

9398 mkdir $out

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

95100 '';

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

102+ } // (if nonReinstallablePkgs == null then {} else { inherit nonReinstallablePkgs; }));

104103

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

106105 # cat ${defaultSetupSrc} > Setup.hs

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

131130 checks = pkgs.recurseIntoAttrs (builtins.mapAttrs

132131 (_: d: haskellLib.check d)

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

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

133+ inherit (package) identifier detailLevel isLocal isProject;

135134 inherit setup cabalFile;

136135 isHaskell = true;

137136 inherit src;

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

@@ -3,10 +3,6 @@

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

55let

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−

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

117

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

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

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

8682

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

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

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

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

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

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

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

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

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

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

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

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

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

9688 })}

9789

9890 ghc=${ghc}

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

10092 ''

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

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

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

10395 done

10496 ''}

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

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

158150 ''}

159151 done

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

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

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

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

163155 fi

164156 done

165157 '' + lib.optionalString component.doExactConfig ''

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

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

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

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

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

builder/setup-builder.nix+4−8

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

88, preInstall ? component.preInstall , postInstall ? component.postInstall

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

1010, nonReinstallablePkgs ? defaults.nonReinstallablePkgs

11−, smallAddressSpace ? false

1211}@drvArgs:

1312

1413let

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

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

17−

1814 cleanSrc' = haskellLib.rootAndSubDir cleanSrc;

1915

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

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

5753 cleanSrc = cleanSrc';

5854 inherit configFiles;

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

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

6156 };

6257

6358 meta = {

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

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

7772 if [ -f $f ]; then

7873 echo Compiling package $f

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

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

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

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

76+ setup=$(pwd)/Setup

8177 fi

8278 done

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

84− runHook postBuild

80+ runHook preBuild

8581 '';

8682

8783 installPhase = ''

builder/shell-for.nix+6−16

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

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

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

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

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

@@ -71,12 +71,9 @@ let

7171 removeSelectedInputs =

7272 lib.filter (input: !(isSelectedComponent input));

7373

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.

74+ # The configs of all the selected components

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

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

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

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

8077

8178 name = if lib.length selectedPackages == 1

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

@@ -99,14 +96,13 @@ let

9996 component = {

10097 depends = packageInputs;

10198 libs = [];

102− pkgconfig = [];

10399 frameworks = [];

104100 doExactConfig = false;

105101 };

106102 configFiles = makeConfigFiles {

107103 fullName = args.name or name;

108104 identifier.name = name;

109− inherit component enableDWARF;

105+ inherit component;

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

111107 };

112108 ghcEnv = ghcForComponent {

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

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

117113 '';

118114 inherit enableDWARF;

119− plugins = [];

120115 };

121116

122117 hoogleIndex = let

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

133128 # inherit (hsPkgs) hoogle;

134129 } // (

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

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

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

138− name = "hoogle";

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

140− inherit evalPackages;

141− }]);

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

142132 }

143133 ));

144134

@@ -152,7 +142,7 @@ in

152142 nativeBuildInputs = [ ghcEnv ]

153143 ++ nativeBuildInputs

154144 ++ mkDrvArgs.nativeBuildInputs or []

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

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

156146 # If this shell is a cross compilation shell include

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

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

changelog.md−33

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

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

22that will impact users.

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−

374## Aug 6, 2021

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

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

ci.nix+28−39

@@ -10,18 +10,12 @@

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

1111 inherit (pkgs.haskell-nix) sources;

1212 nixpkgsVersions = {

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

1314 "R2111" = "nixpkgs-2111";

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

1515 "unstable" = "nixpkgs-unstable";

1616 };

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

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

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

2519 inherit runTests;

2620 }) (

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

@@ -30,46 +24,40 @@

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

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

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

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

27+ nixpkgs.lib.optionalAttrs (nixpkgsName == "R2105") {

3428 ghc865 = false;

35− ghc8107 = true;

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

29+ ghc8107 = false;

30+ } // nixpkgs.lib.optionalAttrs (nixpkgsName == "R2111") {

3731 ghc865 = false;

3832 ghc8107 = true;

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

4034 ghc865 = false;

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

36+ ghc8104 = false;

37+ ghc8105 = false;

38+ ghc8106 = false;

4239 ghc8107 = true;

40+ ghc901 = false;

4341 ghc902 = true;

44− ghc924 = true;

42+ ghc921 = true;

43+ ghc810420210212 = false;

4544 });

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

47− nixpkgs.lib.filter (v:

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

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

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

51− &&

52− # aarch64-darwin requires ghc 8.10.7

53− (v != "aarch64-darwin" || (

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

55− &&

56− # aarch64-linux requires ghc 8.8.4

57− (v != "aarch64-linux" || (

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

59− ))) supportedSystems) (v: v);

46+ nixpkgs.lib.filter (v: v != "aarch64-darwin" || (

47+ # aarch64-darwin requires ghc 8.10.7 and does not work on older nixpkgs

48+ !__elem compiler-nix-name ["ghc865" "ghc884" "ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901"]

49+ && !__elem nixpkgsName ["R2105"])) supportedSystems) (v: v);

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

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

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

6353 let lib = nixpkgs.lib;

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

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

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

54+ in lib.optionalAttrs (nixpkgsName == "unstable" && (__elem compiler-nix-name ["ghc8107"]) && system != "aarch64-darwin") {

6755 inherit (lib.systems.examples) ghcjs;

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

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

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

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

57+ nixpkgsName == "unstable" && (__elem compiler-nix-name ["ghc8107"])) {

58+ # Windows cross compilation is currently broken on macOS

7159 inherit (lib.systems.examples) mingwW64;

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

60+ } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && compiler-nix-name == "ghc8107") {

7361 # Musl cross only works on linux

7462 # aarch64 cross only works on linux

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

@@ -78,11 +66,12 @@

7866in

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

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

81− evalPackages = import pinnedNixpkgsSrc nixpkgsArgs;

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

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

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

70+ genericPkgs = import pinnedNixpkgsSrc {};

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

72+ dimension "System" (systems nixpkgsName genericPkgs compiler-nix-name) (systemName: system:

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

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

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

8675 platformFilter = platformFilterGeneric pkgs system;

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

8877 # Native builds

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

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

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

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

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

9988 });

10089 }

10190 //

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

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

10392 # Cross builds

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

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

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

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

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

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

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

@@ -0,0 +1,132 @@

1+{ stdenv, lib, fetchurl

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

3+, targetPrefix

4+, targetPlatform, hostPlatform

5+, targetPackages

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

7+, autoreconfHook, toolsForTarget, bash

8+, libDeps

9+, useLLVM, llvmPackages

10+, targetCC

11+, enableIntegerSimple, targetGmp

12+, enableDWARF, elfutils

13+, ncurses, targetLibffi, libiconv, targetIconv

14+, disableLargeAddressSpace

15+, buildMK

16+}:

17+stdenv.mkDerivation (rec {

18+

19+ version = ghc-version;

20+ patches = ghc-patches;

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

22+

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

24+ strictDeps = true;

25+

26+ nativeBuildInputs = [

27+ perl autoconf automake m4 python3 sphinx

28+ ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour

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

30+

31+ # For building runtime libs

32+ depsBuildTarget = toolsForTarget;

33+

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

35+

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

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

38+

39+ postPatch = "patchShebangs .";

40+

41+ src = if src-spec ? file

42+ then src-spec.file

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

44+

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

46+ preConfigure = ''

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

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

49+ done

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

51+ # the *host* tools.

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

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

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

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

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

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

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

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

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

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

62+

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

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

65+ '' + lib.optionalString useLLVM ''

66+ export LLC="${llvmPackages.llvm}/bin/llc"

67+ export OPT="${llvmPackages.llvm}/bin/opt"

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

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

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

71+ export NIX_LDFLAGS+=" -no_dtrace_dof"

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

73+ sed -i -e '5i ,("armv7a-unknown-linux-androideabi", ("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", "cortex-a8", ""))' llvm-targets

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

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

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

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

78+ echo "(go go gadget sed)"

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

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

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

82+

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

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

85+ for x in configure aclocal.m4; do

86+ substituteInPlace $x \

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

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

89+ done

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

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

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

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

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

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

96+ '';

97+

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

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

100+ configureFlags = [

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

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

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

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

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

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

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

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

109+ "--with-iconv-includes=${targetIconv}/include" "--with-iconv-libraries=${targetIconv}/lib"

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

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

112+ ] ++ lib.optionals (disableLargeAddressSpace) [

113+ "--disable-large-address-space"

114+ ] ++ lib.optionals (targetPlatform.isAarch32) [

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

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

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

118+ ] ++ lib.optionals enableDWARF [

119+ "--enable-dwarf-unwind"

120+ "--with-libdw-includes=${lib.getDev elfutils}/include"

121+ "--with-libdw-libraries=${lib.getLib elfutils}/lib"

122+ ];

123+

124+ outputs = [ "out" "doc" ];

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

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

127+ ++ [ "configurePhase" "installPhase" ];

128+ installPhase = ''

129+ cp -r . $out

130+ mkdir $doc

131+ '';

132+})

compiler/ghc/default.nix+61−199

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

1313, autoreconfHook

1414, bash

1515

16−, libiconv ? null

17−

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

16+, libiconv ? null, ncurses

1917

2018, installDeps

2119

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

3129, # If enabled, GHC will be built with the GPL-free but slower integer-simple

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

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

34−, # If enabled, GHC will be built with the GPL-free native backend of the

35− # bignum library that is nearly as fast as GMP

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

3732

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

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

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

4641

4742, enableDWARF ? false

4843

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)

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

45+ enableTerminfo ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.isMusl

5246

5347, # Wheter to build in NUMA support

5448 enableNUMA ? true

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

7468, extra-passthru ? {}

7569}@args:

7670

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

78−

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

80−assert enableNativeBignum -> !enableIntegerSimple;

81−assert enableIntegerSimple -> !enableNativeBignum;

71+assert !enableIntegerSimple -> gmp != null;

8272

8373let

8474 inherit (stdenv) buildPlatform hostPlatform targetPlatform;

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

8676

8777 inherit (bootPkgs) ghc;

8878

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−

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

10180 targetLibffi =

10281 # on native platforms targetPlatform.{libffi, gmp} do not exist; thus fall back

@@ -111,8 +90,6 @@ let

11190

11291 targetIconv = targetPackages.libiconv or libiconv;

11392

114− targetNumactl = targetPackages.numactl or numactl;

115−

11693 # TODO(@Ericson2314) Make unconditional

11794 targetPrefix = lib.optionalString

11895 (targetPlatform != hostPlatform)

@@ -124,7 +101,7 @@ let

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

125102 endif

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

127− '' + bignumSpec + ''

104+ INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}

128105 EXTRA_HADDOCK_OPTS += --quickjump --hyperlinked-source

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

130107 CrossCompilePrefix = ${targetPrefix}

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

139116 '' + lib.optionalString enableRelocatedStaticLibs ''

140117 GhcLibHcOpts += -fPIC

141118 GhcRtsHcOpts += -fPIC

142− GhcRtsCcOpts += -fPIC

143− '' + lib.optionalString (enableRelocatedStaticLibs && targetPlatform.isx86_64 && !targetPlatform.isWindows) ''

144− GhcLibHcOpts += -fexternal-dynamic-refs

145− GhcRtsHcOpts += -fexternal-dynamic-refs

146119 '' + lib.optionalString enableDWARF ''

147120 GhcLibHcOpts += -g3

148121 GhcRtsHcOpts += -g3

@@ -169,13 +142,11 @@ let

169142 '';

170143

171144 # Splicer will pull out correct variations

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

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

173146 ++ [targetLibffi]

174147 ++ lib.optional (!enableIntegerSimple) gmp

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

176− ++ lib.optional (enableNUMA && platform.isLinux && !platform.isAarch32 && !platform.isAndroid) numactl

177− # Even with terminfo disabled some older ghc cross arm and windows compilers do not build unless `ncurses` is found and they seem to want the buildPlatform version

178− ++ lib.optional (!enableTerminfo && haskell-nix.haskellLib.isCrossTarget && (stdenv.targetPlatform.isAarch64 || stdenv.targetPlatform.isWindows) && builtins.compareVersions ghc-version "8.10" < 0) ncurses.dev;

149+ ++ lib.optional (enableNUMA && platform.isLinux && !platform.isAarch32 && !platform.isAndroid) numactl;

179150

180151 toolsForTarget =

181152 if hostPlatform == buildPlatform then

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

185156

186157 targetCC = builtins.head toolsForTarget;

187158

159+ configured-src = import ./configured-src.nix {

160+ inherit stdenv lib fetchurl

161+ ghc-version ghc-version-date ghc-patches src-spec

162+ targetPrefix

163+ targetPlatform hostPlatform

164+ targetPackages

165+ perl autoconf automake m4 python3 sphinx ghc bootPkgs

166+ autoreconfHook toolsForTarget bash

167+ libDeps

168+ useLLVM llvmPackages

169+ targetCC

170+ enableIntegerSimple targetGmp

171+ enableDWARF elfutils

172+ ncurses targetLibffi libiconv targetIconv

173+ disableLargeAddressSpace

174+ buildMK

175+ ;

176+ };

188177in

189178stdenv.mkDerivation (rec {

190179 version = ghc-version;

@@ -192,102 +181,45 @@ stdenv.mkDerivation (rec {

192181

193182 patches = ghc-patches;

194183

195− src = if src-spec ? file

196− then src-spec.file

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

184+ # for this to properly work (with inheritance of patches, postPatch, ...)

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

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

187+ # attrset.

188+ src = configured-src;

198189

199190 # configure was run by configured-src already.

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

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

202− ++ [ "configurePhase" "buildPhase"

191+ phases = [ "unpackPhase" "buildPhase"

203192 "checkPhase" "installPhase"

204193 "fixupPhase"

205194 "installCheckPhase"

206195 "distPhase"

207196 ];

208197

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

210− preConfigure =

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

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

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

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

215− done

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

217− # the *host* tools.

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

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

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

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

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

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

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

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

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

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

228− '' + ''

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

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

231− '' + lib.optionalString useLLVM ''

232− export LLC="${llvmPackages.llvm}/bin/llc"

233− export OPT="${llvmPackages.llvm}/bin/opt"

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

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

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

237− export NIX_LDFLAGS+=" -no_dtrace_dof"

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

239− sed -i -e '5i ,("armv7a-unknown-linux-androideabi", ("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", "cortex-a8", ""))' llvm-targets

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

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

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

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

244− echo "(go go gadget sed)"

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

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

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

248−

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

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

251− for x in configure aclocal.m4; do

252− substituteInPlace $x \

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

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

255− done

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

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

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

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

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

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

262− '' + lib.optionalString (builtins.compareVersions ghc-version "9.2.3" >= 0) ''

263− ./boot

264− '';

265−

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

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

268− configureFlags = [

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

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

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

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

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

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

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

276− ] ++ lib.optional (targetPlatform != hostPlatform) [

277− "--with-iconv-includes=${targetIconv}/include" "--with-iconv-libraries=${targetIconv}/lib"

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

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

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

281− "--disable-large-address-space"

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

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

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

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

286− ] ++ lib.optionals enableDWARF [

287− "--enable-dwarf-unwind"

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

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

290− ];

198+ # ghc hardcodes the TOP dir during config, this breaks when

199+ # splitting the configured src from the build process.

200+ postUnpack = ''

201+ (cd $sourceRoot

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

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

204+

205+ # these two are required

206+ substituteInPlace mk/config.mk --replace "$TOP" "$PWD" \

207+ --replace "$PREFIX" "$out" \

208+ --replace "${configured-src.doc}" "$doc"

209+

210+ substituteInPlace mk/install.mk --replace "$TOP" "$PWD" \

211+ --replace "$PREFIX" "$out" \

212+ --replace "${configured-src.doc}" "$doc"

213+

214+ # these two only for convencience.

215+ substituteInPlace config.log --replace "$TOP" "$PWD" \

216+ --replace "$PREFIX" "$out" \

217+ --replace "${configured-src.doc}" "$doc"

218+

219+ substituteInPlace config.status --replace "$TOP" "$PWD" \

220+ --replace "$PREFIX" "$out" \

221+ --replace "${configured-src.doc}" "$doc")

222+ '';

291223

292224 enableParallelBuilding = true;

293225 postPatch = "patchShebangs .";

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

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

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

329261

330− postInstall = lib.optionalString (enableNUMA && targetPlatform.isLinux) ''

331− # Patch rts.conf to ensure libnuma can be found

332−

333− for file in $(find "$out/lib" -name "rts*.conf"); do

334− if grep -q numa $file; then

335− substituteInPlace $file \

336− --replace "library-dirs:" "library-dirs: ${targetNumactl}/lib" \

337− --replace "include-dirs:" "include-dirs: ${targetNumactl}/include"

338− "$out/bin/${targetPrefix}ghc-pkg" recache

339− fi

340− done

341− '' + ''

262+ postInstall = ''

342263 # Install the bash completion file.

343264 install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc

344265

@@ -354,7 +275,7 @@ stdenv.mkDerivation (rec {

354275 $i

355276 done

356277

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

278+ # Save generated files for needed when building ghcjs

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

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

360281 $generated/includes/dist-derivedconstants/header

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

365286 fi

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

367288 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

377289 mkdir -p $generated/rts/build

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

379291

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

417329 # Our Cabal compiler name

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

419331

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

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

332+ configured-src = configured-src;

454333

455334 # Used to detect non haskell-nix compilers (accidental use of nixpkgs compilers can lead to unexpected errors)

456335 isHaskellNixCompiler = true;

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

483362 dontStrip = true;

484363 dontPatchELF = true;

485364 noAuditTmpdir = true;

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

365+} // lib.optionalAttrs stdenv.buildPlatform.isDarwin {

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

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

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

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

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

370+ preBuild = ''

492371 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

510372 '';

511373});

512374in self

compiler/ghcjs/ghcjs.nix+1−8

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

77 then "ghc884"

88 else "ghc865"

99, ghc ? pkgs.buildPackages.ghc

10−, overrideBootPackages ? [] # adds if not present, overrides if present.

1110}:

1211let

1312 isGhcjs88 = builtins.compareVersions ghcjsVersion "8.8.0.0" >= 0;

@@ -15,14 +14,8 @@ let

1514

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

1716 src = ghcjsSrc;

18− inherit ghcjsVersion compiler-nix-name overrideBootPackages;

17+ inherit ghcjsVersion compiler-nix-name;

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

2619# plan-sha256 = "1wy2lr08maxyi7r8jiwf2gj6pdayk5vxxwh42bj4s2gg4035z0yc";

2720# materialized = ../../materialized/ghcjs;

2821 };

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/patches/810/boot-optimization-flags.patchdeleted−14

@@ -1,14 +0,0 @@

1−diff --git a/src-bin/Boot.hs b/src-bin/Boot.hs

2−index 2e35a26..5db2f9b 100755

3−--- a/src-bin/Boot.hs

4−+++ b/src-bin/Boot.hs

5−@@ -721,6 +721,9 @@ cabalConfigureFlags = do

6− , "--prefix", T.pack (locs ^. blGhcjsTopDir)

7− , "--configure-option", "--host=js-unknown-ghcjs"

8− , "--ghcjs-options=-fwrite-ide-info"

9−+ , "--ghcjs-options=-O2"

10−+ , "--ghcjs-options=-fexpose-all-unfoldings"

11−+ , "--ghcjs-options=-fspecialise-aggressively"

12− , "--enable-debug-info"

13− , "--disable-library-stripping"

14− , "--disable-executable-stripping"

compiler/ghcjs/patches/810/fast-weak.patchdeleted−87

@@ -1,87 +0,0 @@

1−diff --git a/lib/boot/shims/src/gc.js.pp b/lib/boot/shims/src/gc.js.pp

2−index 76321b2..a2cf416 100644

3−--- a/lib/boot/shims/src/gc.js.pp

4−+++ b/lib/boot/shims/src/gc.js.pp

5−@@ -444,6 +444,50 @@ function h$follow(obj, sp) {

6− } else if(typeof c.len === 'number' && c.buf instanceof ArrayBuffer) {

7− TRACE_GC("marking ByteArray");

8− MARK_OBJ(c);

9−+ } else if(c instanceof h$FastWeak) {

10−+ MARK_OBJ(c);

11−+ if(c.ticket !== null && !IS_MARKED(c.ticket)) {

12−+ c.ticket = null; // If the ticket isn't reachable, this will let it get cleaned up by the JS gc; if it is reachable, it'll fill this back in

13−+ }

14−+ } else if(c instanceof h$FastWeakTicket) {

15−+ MARK_OBJ(c);

16−+ if(!IS_MARKED(c.val)) {

17−+ ADDW(c.val);

18−+ }

19−+ if(IS_MARKED(c.weak)) {

20−+ // In this case, the weak side has been marked first, which means it's been cleared; restore it

21−+ c.weak.ticket = c;

22−+ }

23−+ } else if(c instanceof h$FastWeakBag) {

24−+ MARK_OBJ(c);

25−+ var j = 0; // j should always be equal to the number of not-yet-necessarily-dead tickets that have been traversed; this should always be less than or equal to i

26−+ for(i = 0; i < c.tickets.length; i++) {

27−+ // Any nulls left in the array prior to checking on the tickets must be tickets that died in the last GC, so we ignore them

28−+ if(c.tickets[i] !== null) {

29−+ if(j !== i) {

30−+ c.tickets[i].pos = j;

31−+ }

32−+ if(!IS_MARKED(c.tickets[i])) {

33−+ // If the ticket isn't reachable, this will let it get cleaned up by the JS gc; if it is reachable, it'll fill this back in

34−+ c.tickets[j] = null;

35−+ } else if(j !== i) {

36−+ // We need to move the item

37−+ c.tickets[j] = c.tickets[i];

38−+ } // If it's marked and not moving, don't do anything

39−+ j++;

40−+ }

41−+ }

42−+ c.tickets.length = j; // Shrink the array if any nulls have been dropped

43−+ } else if(c instanceof h$FastWeakBagTicket) {

44−+ MARK_OBJ(c);

45−+ if(!IS_MARKED(c.val)) {

46−+ ADDW(c.val);

47−+ }

48−+ if(IS_MARKED(c.bag)) {

49−+ // In this case, the weak side has been marked first, which means it's been cleared; restore it

50−+ c.bag.tickets[c.pos] = c;

51−+ }

52−+

53− } else if(c instanceof h$Weak) {

54− MARK_OBJ(c);

55− } else if(c instanceof h$MVar) {

56−diff --git a/lib/boot/shims/src/weak.js.pp b/lib/boot/shims/src/weak.js.pp

57−index 8df313b..d537027 100644

58−--- a/lib/boot/shims/src/weak.js.pp

59−+++ b/lib/boot/shims/src/weak.js.pp

60−@@ -87,3 +87,27 @@ function h$finalizeWeak(w) {

61− RETURN_UBX_TUP2(r, 1);

62− }

63− }

64−+

65−+function h$FastWeak(ticket) {

66−+ this.ticket = ticket;

67−+ this.m = 0;

68−+}

69−+

70−+function h$FastWeakTicket(val) {

71−+ this.val = val;

72−+ this.weak = new h$FastWeak(this);

73−+ this.m = 0;

74−+}

75−+

76−+function h$FastWeakBag() {

77−+ this.tickets = [];

78−+ this.m = 0;

79−+}

80−+

81−+function h$FastWeakBagTicket(bag, val) {

82−+ this.val = val;

83−+ this.bag = bag;

84−+ this.pos = bag.tickets.length;

85−+ bag.tickets.push(this);

86−+ this.m = 0;

87−+};

compiler/windows/include/synchapi.hdeleted−1

@@ -1 +0,0 @@

1−#include <windows.h>

compiler/windows/include/windows.hdeleted−18

@@ -1,18 +0,0 @@

1−// Just enoough windows.h stuff to make rts headers usable when building GHC cross compiler.

2−// See compiler/ghc/default.nix for where this is used.

3−#ifndef _WINDOWS_

4−#define _WINDOWS_

5−

6−#define __stdcall

7−

8−typedef unsigned long DWORD;

9−typedef void * PVOID;

10−

11−typedef struct _RTL_CONDITION_VARIABLE { PVOID Ptr; } RTL_CONDITION_VARIABLE;

12−typedef RTL_CONDITION_VARIABLE CONDITION_VARIABLE;

13−

14−typedef struct _RTL_SRWLOCK { PVOID Ptr; } RTL_SRWLOCK;

15−typedef RTL_SRWLOCK SRWLOCK;

16−

17−#endif

18−

config.nix+4

@@ -2,7 +2,11 @@

22 # allow building for windows

33 allowUnsupportedSystem = true;

44 # we want the 64bit wine version

5+ # See overlays/wine.nix as well!

56 wine.build = "wine64";

67 wine.release = "stable";

9+ # This is marked insecure on 20.03, but many packages still depend on it

10+ permittedInsecurePackages = [ "openssl-1.0.2u" ];

711}

812

docs/reference/library.md−1

@@ -167,7 +167,6 @@ Then feeding its result into [mkCabalProjectPkgSet](#mkcabalprojectpkgset) passi

167167| `ghcWithPackages` | Function | [`ghcWithPackages`](#ghcwithpackages) |

168168| `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 |

169169| `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. |

171170

172171## project, cabalProject and stackProject

173172

docs/reference/supported-ghc-versions.md+9−5

@@ -8,7 +8,6 @@ for each, though not all are cached or tested by CI):

88- 8.10.{1,2,3,4,5}

99- 9.0.1

1010- 9.2.1

11−- 9.2.2

1211

1312The following table shows the Nixpkgs/GHC versions which are built/cached, and

1413which of those are further tested. If you use a combination of Nixpkgs version

@@ -21,13 +20,18 @@ really should use an instance of Nixpkgs provided by `haskell.nix` itself.

2120

2322|------------------|--------------------|-------------|-----------------------|---------------|

24−| 21.11 | `nixpkgs-2111` | 8.6.5 | `ghc865` | No |

25−| 21.11 | `nixpkgs-2111` | 8.10.7 | `ghc8107` | Yes |

23+| 21.05 | `nixpkgs-2105` | 8.6.5 | `ghc865` | No |

24+| 21.05 | `nixpkgs-2105` | 8.10.7 | `ghc8107` | No |

25+| 21.11 | `nixpkgs-2105` | 8.6.5 | `ghc865` | No |

26+| 21.11 | `nixpkgs-2105` | 8.10.7 | `ghc8107` | Yes |

2627| unstable | `nixpkgs-unstable` | 8.6.5 | `ghc865` | No |

2728| unstable | `nixpkgs-unstable` | 8.8.4 | `ghc884` | No |

29+| unstable | `nixpkgs-unstable` | 8.10.4 | `ghc8104` | No |

30+| unstable | `nixpkgs-unstable` | 8.10.5 | `ghc8105` | No |

31+| unstable | `nixpkgs-unstable` | 8.10.6 | `ghc8106` | No |

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

33+| unstable | `nixpkgs-unstable` | 9.0.1 | `ghc901` | No |

34+| unstable | `nixpkgs-unstable` | 9.2.1 | `ghc921` | Yes |

3135

3236See [ci.nix](https://github.com/input-output-hk/haskell.nix/blob/master/ci.nix)

3337for the source of truth about what is built and tested (in the off chance this

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

@@ -22,34 +22,10 @@ You need to add the following sections to `/etc/nix/nix.conf` or, if you are a t

2222

2323```

2424trusted-public-keys = [...] hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ= [...]

25−substituters = [...] https://cache.iog.io [...]

25+substituters = [...] https://hydra.iohk.io [...]

2626```

2727

28−If you're running NixOS, you need to add/update the following in your `/etc/nixos/configuration.nix` files instead.

29−

30−```

31−# Binary Cache for Haskell.nix

32−nix.settings.trusted-public-keys = [

33− "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

34−];

35−nix.settings.substituters = [

36− "https://cache.iog.io"

37−];

38−```

39−

40−NixOS-21.11 and older use slightly different settings.

41−

42−```

43−# Binary Cache for Haskell.nix

44−nix.binaryCachePublicKeys = [

45− "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

46−];

47−nix.binaryCaches = [

48− "https://cache.iog.io"

49−];

50−```

51−

52−This can be tricky to get setup properly. If you're still having trouble getting cache hits, consult the corresponding [troubleshooting section](../troubleshooting.md#why-am-i-building-ghc).

28+This can be tricky to get setup properly. If you're still having trouble getting cache hits, consult the corresponding [troubleshooting section](../reference/troubleshooting#why-am-i-building-ghc).

5329

5430## Scaffolding

5531

@@ -86,14 +62,14 @@ Add `flake.nix`:

8662 nixpkgs-fmt

8763 ];

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

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

65+ shell.crossPlatform = p: [p.ghcjs];

9066 };

9167 })

9268 ];

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

9470 flake = pkgs.helloProject.flake {

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

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

72+ crossPlatforms = p: [p.ghcjs];

9773 };

9874 in flake // {

9975 # Built by `nix build .`

docs/tutorials/getting-started-hix.md+2−26

@@ -29,34 +29,10 @@ You need to add the following sections to `/etc/nix/nix.conf` or, if you are a t

2929

3030```

3131trusted-public-keys = [...] hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ= [...]

32−substituters = [...] https://cache.iog.io [...]

32+substituters = [...] https://hydra.iohk.io [...]

3333```

3434

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

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

6036

6137## Installing Hix

6238

docs/tutorials/getting-started.md+4−16

@@ -18,34 +18,22 @@ You need to add the following sections to `/etc/nix/nix.conf` or, if you are a t

1818

1919```

2020trusted-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 [...]

2222```

2323

2424If you're running NixOS, you need to add/update the following in your `/etc/nixos/configuration.nix` files instead.

2525

2626```

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

4028nix.binaryCachePublicKeys = [

4129 "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

4230];

4331nix.binaryCaches = [

44− "https://cache.iog.io"

45−];

32+ "https://hydra.iohk.io"

33+];

4634```

4735

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

36+This can be tricky to get setup properly. If you're still having trouble getting cache hits, consult the corresponding [troubleshooting section](../../troubleshooting#why-am-i-building-ghc).

4937

5038## Niv

5139

flake.lock+30−137

@@ -20,10 +20,10 @@

2020 "flake": false,

2121 "locked": {

2222 "lastModified": 1603716527,

23− "narHash": "sha256-X0TFfdD4KZpwl0Zr6x+PLxUt/VyKQfX7ylXHdmZIL+w=",

23+ "narHash": "sha256-sDbrmur9Zfp4mPKohCD8IDZfXJ0Tjxpmr2R+kg5PpSY=",

2424 "owner": "haskell",

2525 "repo": "cabal",

26− "rev": "48bf10787e27364730dd37a42b603cee8d6af7ee",

26+ "rev": "94aaa8e4720081f9c75497e2735b90f6a819b08e",

2727 "type": "github"

2828 },

2929 "original": {

@@ -36,11 +36,11 @@

3636 "cabal-34": {

3737 "flake": false,

3838 "locked": {

39− "lastModified": 1640353650,

40− "narHash": "sha256-N1t6M3/wqj90AEdRkeC8i923gQYUpzSr8b40qVOZ1Rk=",

39+ "lastModified": 1622475795,

40+ "narHash": "sha256-chwTL304Cav+7p38d9mcb+egABWmxo2Aq+xgVBgEb/U=",

4141 "owner": "haskell",

4242 "repo": "cabal",

43− "rev": "942639c18c0cd8ec53e0a6f8d120091af35312cd",

43+ "rev": "b086c1995cdd616fc8d91f46a21e905cc50a1049",

4444 "type": "github"

4545 },

4646 "original": {

@@ -53,11 +53,11 @@

5353 "cabal-36": {

5454 "flake": false,

5555 "locked": {

56− "lastModified": 1641652457,

57− "narHash": "sha256-BlFPKP4C4HRUJeAbdembX1Rms1LD380q9s0qVDeoAak=",

56+ "lastModified": 1640163203,

57+ "narHash": "sha256-TwDWP2CffT0j40W6zr0J1Qbu+oh3nsF1lUx9446qxZM=",

5858 "owner": "haskell",

5959 "repo": "cabal",

60− "rev": "f27667f8ec360c475027dcaee0138c937477b070",

60+ "rev": "ecf418050c1821f25e2e218f1be94c31e0465df1",

6161 "type": "github"

6262 },

6363 "original": {

@@ -85,11 +85,11 @@

8585 },

8686 "flake-utils": {

8787 "locked": {

88− "lastModified": 1644229661,

89− "narHash": "sha256-1YdnJAsNy69bpcjuoKdOYQX0YxZBiCYZo4Twxerqv7k=",

88+ "lastModified": 1623875721,

89+ "narHash": "sha256-A8BU7bjS5GirpAUv4QA+QnJ4CceLHkcXdRp4xITDB0s=",

9090 "owner": "numtide",

9191 "repo": "flake-utils",

92− "rev": "3cecb5b042f7f209c56ffd8371b2711a290ec797",

92+ "rev": "f7e004a55b120c02ecb6219596820fcd32ca8772",

9393 "type": "github"

9494 },

9595 "original": {

@@ -118,11 +118,11 @@

118118 "hackage": {

119119 "flake": false,

120120 "locked": {

121− "lastModified": 1659402819,

122− "narHash": "sha256-1ghmulyIk+obGnyFeouVHBQXxUHMBmgCIRazLfEoT34=",

121+ "lastModified": 1643937230,

122+ "narHash": "sha256-G1oZXEKm+Z6fSzrXLeY9BSK5MJdzEFeGHKQpaXiokmc=",

123123 "owner": "input-output-hk",

124124 "repo": "hackage.nix",

125− "rev": "2f6f97ca3db96f91eea674ef46f4a0785d1e9d9c",

125+ "rev": "204d96c5cdeab48dc8e5ccb8773df2df9a909901",

126126 "type": "github"

127127 },

128128 "original": {

@@ -147,73 +147,14 @@

147147 "type": "github"

148148 }

149149 },

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

209150 "nix-tools": {

210151 "flake": false,

211152 "locked": {

212− "lastModified": 1658968505,

213− "narHash": "sha256-UnbQ/Ig/23e9hUdDOBwYHwHgHmQawZ2uazpJ8DLIJgE=",

153+ "lastModified": 1636018067,

154+ "narHash": "sha256-ng306fkuwr6V/malWtt3979iAC4yMVDDH2ViwYB6sQE=",

214155 "owner": "input-output-hk",

215156 "repo": "nix-tools",

216− "rev": "8a754bdcf20b20e116409c2341cf69065d083053",

157+ "rev": "ed5bd7215292deba55d6ab7a4e8c21f8b1564dda",

217158 "type": "github"

218159 },

219160 "original": {

@@ -222,21 +163,6 @@

222163 "type": "github"

223164 }

224165 },

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

240166 "nixpkgs-2003": {

241167 "locked": {

242168 "lastModified": 1620055814,

@@ -255,11 +181,11 @@

255181 },

256182 "nixpkgs-2105": {

257183 "locked": {

258− "lastModified": 1655034179,

259− "narHash": "sha256-rf1/7AbzuYDw6+8Xvvf3PtEOygymLBrFsFxvext5ZjI=",

184+ "lastModified": 1640283157,

185+ "narHash": "sha256-6Ddfop+rKE+Gl9Tjp9YIrkfoYPzb8F80ergdjcq3/MY=",

260186 "owner": "NixOS",

261187 "repo": "nixpkgs",

262− "rev": "046ee4af7a9f016a364f8f78eeaa356ba524ac31",

188+ "rev": "dde1557825c5644c869c5efc7448dc03722a8f09",

263189 "type": "github"

264190 },

265191 "original": {

@@ -271,11 +197,11 @@

271197 },

272198 "nixpkgs-2111": {

273199 "locked": {

274− "lastModified": 1656782578,

275− "narHash": "sha256-1eMCBEqJplPotTo/SZ/t5HU6Sf2I8qKlZi9MX7jv9fw=",

200+ "lastModified": 1640283207,

201+ "narHash": "sha256-SCwl7ZnCfMDsuSYvwIroiAlk7n33bW8HFfY8NvKhcPA=",

276202 "owner": "NixOS",

277203 "repo": "nixpkgs",

278− "rev": "573603b7fdb9feb0eb8efc16ee18a015c667ab1b",

204+ "rev": "64c7e3388bbd9206e437713351e814366e0c3284",

279205 "type": "github"

280206 },

281207 "original": {

@@ -285,44 +211,13 @@

285211 "type": "github"

286212 }

287213 },

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

319214 "nixpkgs-unstable": {

320215 "locked": {

321− "lastModified": 1657888067,

322− "narHash": "sha256-GnwJoFBTPfW3+mz7QEeJEEQ9OMHZOiIJ/qDhZxrlKh8=",

216+ "lastModified": 1641285291,

217+ "narHash": "sha256-KYaOBNGar3XWTxTsYPr9P6u74KAqNq0wobEC236U+0c=",

323218 "owner": "NixOS",

324219 "repo": "nixpkgs",

325− "rev": "65fae659e31098ca4ac825a6fef26d890aaf3f4e",

220+ "rev": "0432195a4b8d68faaa7d3d4b355260a3120aeeae",

326221 "type": "github"

327222 },

328223 "original": {

@@ -360,15 +255,13 @@

360255 "ghc-8.6.5-iohk": "ghc-8.6.5-iohk",

361256 "hackage": "hackage",

362257 "hpc-coveralls": "hpc-coveralls",

363− "hydra": "hydra",

364258 "nix-tools": "nix-tools",

365259 "nixpkgs": [

366− "nixpkgs-unstable"

260+ "nixpkgs-2111"

367261 ],

368262 "nixpkgs-2003": "nixpkgs-2003",

369263 "nixpkgs-2105": "nixpkgs-2105",

370264 "nixpkgs-2111": "nixpkgs-2111",

371− "nixpkgs-2205": "nixpkgs-2205",

372265 "nixpkgs-unstable": "nixpkgs-unstable",

373266 "old-ghc-nix": "old-ghc-nix",

374267 "stackage": "stackage"

@@ -377,11 +270,11 @@

377270 "stackage": {

378271 "flake": false,

379272 "locked": {

380− "lastModified": 1659402917,

381− "narHash": "sha256-zRDOtN4A2KmfzmZiqqxOAIw1YVPhnoIaszKKd+qCEcQ=",

273+ "lastModified": 1643937352,

274+ "narHash": "sha256-dOMDnNYXmUgJEG1ucgb33R8Q0qvwQ1UTA4MeYzCz/7I=",

382275 "owner": "input-output-hk",

383276 "repo": "stackage.nix",

384− "rev": "778df3c4b35eac853d57fac7bafc7c9f2dde917f",

277+ "rev": "0f598eb78f1ab10f91a1077bbc1fbd569ee6568d",

385278 "type": "github"

386279 },

387280 "original": {

flake.nix+4−14

@@ -2,14 +2,12 @@

22 description = "Alternative Haskell Infrastructure for Nixpkgs";

44 inputs = {

5− nixpkgs.follows = "nixpkgs-unstable";

5+ nixpkgs.follows = "nixpkgs-2111";

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

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

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

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

109 nixpkgs-unstable = { url = "github:NixOS/nixpkgs/nixpkgs-unstable"; };

1110 flake-utils = { url = "github:numtide/flake-utils"; };

12− hydra.url = "hydra";

1311 hackage = {

1412 url = "github:input-output-hk/hackage.nix";

1513 flake = false;

@@ -59,8 +57,8 @@

5957 };

6058 };

6159

62− outputs = { self, nixpkgs, nixpkgs-unstable, nixpkgs-2105, nixpkgs-2111, nixpkgs-2205, flake-utils, ... }@inputs:

63− let compiler = "ghc924";

60+ outputs = { self, nixpkgs, nixpkgs-unstable, nixpkgs-2105, flake-utils, ... }@inputs:

61+ let compiler = "ghc884";

6462 config = import ./config.nix;

6563 in {

6664 inherit config;

@@ -101,12 +99,6 @@

10199 };

102100 pkgs = import nixpkgs

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

110102 pkgs-unstable = import nixpkgs-unstable

111103 (nixpkgsArgs // { localSystem = { inherit system; }; });

112104 hix = import ./hix/default.nix { inherit pkgs; };

@@ -118,7 +110,7 @@

118110 # supported by haskell.nix, e.g. with remote builders, in order to check this flake.

119111 # If you want to run the tests for just your platform, run `./test/tests.sh` or

120112 # `nix-build -A checks.$PLATFORM`

121− } // flake-utils.lib.eachSystem [ "x86_64-linux" "x86_64-darwin" "aarch64-linux" "aarch64-darwin" ] (system: rec {

113+ } // flake-utils.lib.eachSystem [ "x86_64-linux" "x86_64-darwin" "aarch64-linux" "aarch64-darwin" ] (system: {

122114 legacyPackages = (self.internal.compat { inherit system; }).pkgs;

123115 legacyPackagesUnstable = (self.internal.compat { inherit system; }).pkgs-unstable;

124116

@@ -132,8 +124,6 @@

132124 compiler-nix-name = compiler;

133125 pkgs = haskellNix.pkgs;

134126 })));

135− # Exposed so that buildkite can check that `allow-import-from-derivation=false` works for core of haskell.nix

136− roots = legacyPackagesUnstable.haskell-nix.roots compiler;

137127

138128 devShell = with self.legacyPackages.${system};

139129 mkShell {

hix/project.nix+5−5

@@ -56,20 +56,20 @@ let

5656 nixpkgsArgs = config.haskellNix.nixpkgsArgs // {

5757 overlays = config.haskellNix.nixpkgsArgs.overlays ++ config.overlays;

5858 };

59− _module.args.pkgs = import config.nixpkgs config.nixpkgsArgs;

60− project = pkgs.haskell-nix.project [

59+ pkgs = import config.nixpkgs config.nixpkgsArgs;

60+ project = config.pkgs.haskell-nix.project [

6161 (import ../modules/hix-project.nix)

6262 userDefaults

6363 projectDefaults

6464 commandArgs'

65− ({config, ...}: {

65+ {

6666 src =

6767 if __pathExists (toString (src.origSrcSubDir or src) + "/.git")

68− then config.evalPackages.haskell-nix.haskellLib.cleanGit {

68+ then config.pkgs.haskell-nix.haskellLib.cleanGit {

6969 inherit src name;

7070 }

7171 else src;

72− })

72+ }

7373 ];

7474 })

7575 ];

lib/cabal-project-parser.nix+5−114

@@ -74,21 +74,17 @@ let

7474 # --shar256: 003lm3pm0000hbfmii7xcdd9v20000flxf7gdl2pyxia7p014i8z

7575 # will be trated like a field and returned here

7676 # (used in call-cabal-project-to-nix.nix to create a fixed-output derivation)

77− extractSourceRepoPackageData = cabalProjectFileName: sha256map: repo: {

77+ extractRepoData = cabalProjectFileName: lookupSha256: repo: {

7878 url = repo.location;

7979 ref = repo.tag;

80− sha256 = repo."--sha256" or (

81− if sha256map != null

82− then sha256map."${repo.location}"."${repo.tag}"

83− else null);

80+ sha256 = repo."--sha256" or (lookupSha256 repo);

8481 subdirs = if repo ? subdir

8582 then pkgs.lib.filter (x: x != "") (pkgs.lib.splitString " " repo.subdir)

8683 else ["."];

8784 };

8885

8986 # 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:

87+ parseBlock = cabalProjectFileName: lookupSha256: block:

9288 let

9389 x = span (pkgs.lib.strings.hasPrefix " ") (pkgs.lib.splitString "\n" block);

9490 attrs = parseBlockLines x.fst;

@@ -99,115 +95,10 @@ let

9995 otherText = "\nsource-repository-package\n" + block;

10096 }

10197 else {

102− sourceRepo = extractSourceRepoPackageData cabalProjectFileName sha256map attrs;

98+ sourceRepo = extractRepoData cabalProjectFileName lookupSha256 attrs;

10399 otherText = pkgs.lib.strings.concatStringsSep "\n" x.snd;

104100 };

105101

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−

209102in {

210− inherit parseIndexState parseSourceRepositoryPackages parseRepositories

211− # These are only exposed for tests

212− parseSourceRepositoryPackageBlock parseRepositoryBlock;

103+ inherit parseIndexState parseBlockLines parseBlock;

213104}

lib/call-cabal-project-to-nix.nix+56−74

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

22let readIfExists = src: fileName:

33 let origSrcDir = src.origSrcSubDir or src;

44 in

@@ -30,22 +30,13 @@ in

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

3131 # cabal.project file:

3232 # 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− # = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q";

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

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

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

39− # };

40−, inputMap ? {}

41− # An alternative to providing a `sha256` handy for flakes

42− # cabal.project file:

43− # inputs.pandoc-citeproc.url = "github:jgm/pandoc-citeproc/0.17";

44− # inputs.pandoc-citeproc.flake = false;

45− # outputs = inputs:

46− # ...

47− # inputMap."https://github.com/jgm/pandoc-citeproc" = inputs.inputs.pandoc-citeproc;

48−, extra-hackage-tarballs ? {}

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

34+ # = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q"; };

35+, lookupSha256 ?

36+ if sha256map != null

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

38+ else _: null

39+, extra-hackage-tarballs ? []

4940, source-repo-override ? {} # Cabal seems to behave incoherently when

5041 # two source-repository-package entries

5142 # provide the same packages, making it

@@ -64,13 +55,10 @@ in

6455 # would result in the "foo" subdirectory of

6556 # any plutus-apps input being used for a

6657 # package.

67−, evalPackages

6858, ...

6959}@args:

7060

7161let

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

73−

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

7563 # lazy enough to avoid infinite recursion issues.

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

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

114102 ghc = ghc';

115103 subDir' = src.origSubDir or "";

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

117−

118− cleanedSource = haskellLib.cleanSourceWith {

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

120− src = src.origSrc or src;

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

122− type == "directory" ||

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

105+ maybeCleanedSource =

106+ if haskellLib.canCleanSource src

107+ then (haskellLib.cleanSourceWith {

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

109+ src = src.origSrc or src;

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

111+ type == "directory" ||

112+ pkgs.lib.any (i: (pkgs.lib.hasSuffix i path)) [ ".cabal" "package.yaml" ]); })

113+ else src.origSrc or src;

124114

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

126116 # access to the store is restricted. If origSrc was already in the store

@@ -202,28 +192,21 @@ let

202192

203193 replaceSourceRepos = projectFile:

204194 let

205− fetchPackageRepo = fetchgit: repoData:

195+ fetchRepo = fetchgit: repoData:

206196 let

207197 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

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

198+ if repoData.sha256 != null

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

217200 else

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

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

203+ (__trace "Consider adding `--sha256: ${hashPath drv}` to the ${cabalProjectFileName} file or passing in a lookupSha256 argument"

221204 drv);

222205 in {

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

224207 # 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 ];

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

209+ nativeBuildInputs = [ pkgs.evalPackages.rsync pkgs.evalPackages.git ];

227210 } ''

228211 mkdir $out

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

@@ -238,30 +221,30 @@ let

238221 tag = "minimal";

239222 };

240223

241− # Parse the `source-repository-package` blocks

242− sourceRepoPackageResult = pkgs.haskell-nix.haskellLib.parseSourceRepositoryPackages

243− cabalProjectFileName sha256map source-repo-override projectFile;

244−

245− # Parse the `repository` blocks

246− repoResult = pkgs.haskell-nix.haskellLib.parseRepositories

247− evalPackages cabalProjectFileName sha256map inputMap cabal-install nix-tools sourceRepoPackageResult.otherText;

224+ blocks = pkgs.lib.splitString "\nsource-repository-package\n" ("\n" + projectFile);

225+ initialText = pkgs.lib.lists.take 1 blocks;

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

227+ overrideSourceRepo = sourceRepo: (source-repo-override.${sourceRepo.url} or (pkgs.lib.id)) sourceRepo;

228+ sourceRepoData = pkgs.lib.lists.map (x: overrideSourceRepo x.sourceRepo) repoBlocks;

229+ otherText = pkgs.evalPackages.writeText "cabal.project" (pkgs.lib.strings.concatStringsSep "\n" (

230+ initialText

231+ ++ (builtins.map (x: x.otherText) repoBlocks)));

248232

249233 # we need the repository content twice:

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

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

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

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

253237 # * at built time (passed out)

254238 # Here we want to use plain pkgs.fetchgit, which is what a builder

255239 # on the target system would use, so that the derivation is unaffected

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

257241 # as built by a darwin builder, and fetch it from a cache

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

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

242+ sourceReposEval = builtins.map (fetchRepo pkgs.evalPackages.fetchgit) sourceRepoData;

243+ sourceReposBuild = builtins.map (x: (fetchRepo pkgs.fetchgit x).fetched) sourceRepoData;

260244 in {

261245 sourceRepos = sourceReposBuild;

262− inherit (repoResult) repos extra-hackages;

263246 makeFixedProjectFile = ''

264− cp -f ${evalPackages.writeText "cabal.project" sourceRepoPackageResult.otherText} ./cabal.project

247+ cp -f ${otherText} ./cabal.project

265248 '' +

266249 pkgs.lib.optionalString (builtins.length sourceReposEval != 0) (''

267250 chmod +w -R ./cabal.project

@@ -296,7 +279,7 @@ let

296279

297280 fixedProject =

298281 if rawCabalProject == null

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

282+ then { sourceRepos = []; makeFixedProjectFile = ""; replaceLocations = ""; }

300283 else replaceSourceRepos rawCabalProject;

301284

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

@@ -368,12 +351,12 @@ let

368351 '');

369352

370353 # Dummy `ghc` that uses the captured output

371− dummy-ghc = evalPackages.writeTextFile {

354+ dummy-ghc = pkgs.evalPackages.writeTextFile {

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

373356 executable = true;

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

375358 text = ''

376− #!${evalPackages.runtimeShell}

359+ #!${pkgs.evalPackages.runtimeShell}

377360 case "$*" in

378361 --version*)

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

@@ -411,12 +394,12 @@ let

411394 };

412395

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

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

397+ dummy-ghc-pkg = pkgs.evalPackages.writeTextFile {

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

416399 executable = true;

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

418401 text = ''

419− #!${evalPackages.runtimeShell}

402+ #!${pkgs.evalPackages.runtimeShell}

420403 case "$*" in

421404 --version)

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

@@ -452,10 +435,10 @@ let

452435 else null;

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

454437 inherit checkMaterialization;

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

456− nativeBuildInputs = [ nix-tools dummy-ghc dummy-ghc-pkg cabal-install evalPackages.rsync evalPackages.gitMinimal ];

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

439+ nativeBuildInputs = [ nix-tools dummy-ghc dummy-ghc-pkg cabal-install pkgs.evalPackages.rsync pkgs.evalPackages.git ];

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

441+ LOCALE_ARCHIVE = pkgs.lib.optionalString (pkgs.evalPackages.stdenv.buildPlatform.libc == "glibc") "${pkgs.evalPackages.glibcLocales}/lib/locale/locale-archive";

459442 LANG = "en_US.UTF-8";

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

461444 preferLocalBuild = false;

@@ -477,11 +460,11 @@ let

477460 '';

478461 in {

479462 # These check for cabal configure failure

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

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

481464 ${checkCabalConfigure}

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

483466 '';

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

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

485468 ${checkCabalConfigure}

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

487470 '';

@@ -489,17 +472,17 @@ let

489472 } ''

490473 tmp=$(mktemp -d)

491474 cd $tmp

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

475+ # if maybeCleanedSource is empty, this means it's a new

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

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

495478 # message to prevent headaches (#290).

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

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

497480 echo "cleaned source is empty. Did you forget to 'git add -A'?"

498481 ${pkgs.lib.optionalString (__length fixedProject.sourceRepos == 0) ''

499482 exit 1

500483 ''}

501484 else

502− cp -r ${cleanedSource}/* .

485+ cp -r ${maybeCleanedSource}/* .

503486 fi

504487 chmod +w -R .

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

@@ -523,7 +506,7 @@ let

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

524507 ${fixedProject.makeFixedProjectFile}

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

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

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

527510 cabal.project.freeze

528511 chmod +w cabal.project.freeze

529512 ''}

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

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

543526 dotCabal {

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

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

546528 index-state = cached-index-state;

547529 sha256 = index-sha256-found;

548530 }

549− } cabal v2-freeze ${

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

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

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

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

554− } \

531+ } cabal v2-freeze \

532+ --index-state=${

533+ # Setting the desired `index-state` here in case it was not

534+ # from the cabal.project file. This will further restrict the

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

536+ index-state-found} \

555537 -w ${

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

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

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

628610 projectNix = plan-nix;

629611 index-state = index-state-found;

630612 inherit src;

631− inherit (fixedProject) sourceRepos extra-hackages;

613+ inherit (fixedProject) sourceRepos;

632614}

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

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

55 *

66 * see also `call-cabal-project-to-nix`!

77 */

8+{ runCommand, pkgs, mkCacheFile, materialize, haskellLib }:

89{ name ? src.name or null # optional name for better error messages

910, src

1011, stackYaml ? "stack.yaml"

@@ -14,24 +15,24 @@

1415, resolverSha256 ? null

1516, materialized ? null # Location of a materialized copy of the nix files

1617, checkMaterialization ? null # If true the nix files will be generated used to check plan-sha256 and material

17−, nix-tools

18−, evalPackages

19−, ... }@args:

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)

19+, ... }:

2020let

21− inherit (evalPackages) runCommand;

22− inherit (evalPackages.haskell-nix) mkCacheFile materialize haskellLib;

2321 inherit (haskellLib.fetchResolver {

2422 inherit src stackYaml resolverSha256;

2523 }) resolver fetchedResolver;

2624

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

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

27+ maybeCleanedSource =

28+ if haskellLib.canCleanSource src

29+ then (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+ pkgs.lib.any (i: (pkgs.lib.hasSuffix i path)) [ stackYaml ".cabal" "package.yaml" ]); })

35+ else src.origSrc or src;

3536

3637 stackToNixArgs = builtins.concatStringsSep " " [

3738 "--full"

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

4546 sha256Arg = "stack-sha256";

4647 reasonNotSafe = null;

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

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

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

4950 inherit checkMaterialization;

5051 }) (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 ];

52+ nativeBuildInputs = [ nix-tools pkgs.nix-prefetch-git pkgs.cacert pkgs.xorg.lndir ];

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

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

5455 LANG = "en_US.UTF-8";

5556 LC_ALL = "en_US.UTF-8";

5657 preferLocalBuild = false;

@@ -58,18 +59,18 @@ let

5859 mkdir -p $out${subDir'}

5960 SRC=$(mktemp -d)

6061 cd $SRC

61− # if cleanedSource is empty, this means it's a new

62+ # if maybeCleanedSource is empty, this means it's a new

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

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

6465 # message to prevent headaches (#290).

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

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

6667 echo "cleaned source is empty. Did you forget to 'git add -A'?"; exit 1;

6768 fi

68− lndir -silent "${cleanedSource}/." $SRC

69− ${evalPackages.lib.optionalString (subDir != "") "cd ${subDir}"}

69+ lndir -silent "${maybeCleanedSource}/." $SRC

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

7071 ${

7172 # If a resolver was fetched use the it instead of the original stack.yaml

72− evalPackages.lib.optionalString (fetchedResolver != null)

73+ pkgs.lib.optionalString (fetchedResolver != null)

7374 # Replace the resolver path in the stack.yaml with the fetched version

7475 ''

7576 rm ${stackYaml}

@@ -77,7 +78,7 @@ let

7778 chmod +w ${stackYaml}

7879 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

7980 ''}

80− ${evalPackages.lib.optionalString (cache != null) ''

81+ ${pkgs.lib.optionalString (cache != null) ''

8182 cp ${mkCacheFile cache}/.stack-to-nix.cache* $out${subDir'}

8283 ''}

8384 (cd $out${subDir'} && stack-to-nix ${stackToNixArgs})

lib/check.nix+14−19

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

1−{ stdenv, lib, haskellLib }:

1+{ stdenv, lib, haskellLib, srcOnly }:

22drv:

44let

@@ -7,25 +7,13 @@ let

77# This derivation can be used to execute test component.

88# The $out of the derivation is a file containing the resulting

99# stdout output.

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− }) // {

10+in stdenv.mkDerivation ({

2711 name = (drv.name + "-check");

2812

13+ # Using `srcOnly` (rather than getting the `src` via a `drv.passthru`)

14+ # should correctly apply the patches from `drv` (if any).

15+ src = drv.source or (srcOnly drv);

16+

2917 passthru = {

3018 inherit (drv) identifier config configFiles executableToolDepends cleanSrc env exeName;

3119 };

@@ -34,12 +22,19 @@ in stdenv.mkDerivation ((

3422

3523 inherit (component) doCheck doCrossCheck;

3624

37− phases = ["unpackPhase" "patchPhase" "buildPhase"];

25+ phases = ["unpackPhase" "buildPhase"];

3826

3927 # If doCheck or doCrossCheck are false we may still build this

4028 # component and we want it to quietly succeed.

4129 buildPhase = ''

4230 mkdir $out

31+ ${

32+ # Change to the source sub directory if there is one.

33+ lib.optionalString (drv.srcSubDir or "" != "") ''

34+ cd ${lib.removePrefix "/" drv.srcSubDir}

35+ ''

36+ }

37+

4338 runHook preCheck

4439

4540 ${toString component.testWrapper} ${drv}/bin/${drv.exeName} ${lib.concatStringsSep " " component.testFlags} | tee $out/test-stdout

lib/clean-cabal-component.nix+2−2

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

11# Use cleanSourceWith to filter just the files needed for a particular

22# component of the package

3−{ lib, cleanSourceWith }: package: component: componentName: src:

3+{ lib, cleanSourceWith, canCleanSource }: package: component: componentName: src:

44let

55 srcStr' = src.origSrc or null;

66 subDir = if src.origSubDir or "" == ""

@@ -56,7 +56,7 @@ let

5656 then p

5757 else p + "/";

5858in

59− if srcStr' == null || package.detailLevel != "FullDetails"

59+ if srcStr' == null || package.detailLevel != "FullDetails" || !canCleanSource src

6060 then src

6161 else

6262 let

lib/clean-git.nix+4−8

@@ -65,13 +65,9 @@ then

6565 first_line = head git_content;

6666 prefix = "gitdir: ";

6767 ok = length git_content == 1 && lib.hasPrefix prefix first_line;

68− raw_path = remove_prefix prefix first_line;

6968 in

7069 if ok

71− then

72− if lib.hasPrefix "/" raw_path

73− then /. + raw_path

74− else /. + builtins.toPath (origSrcSubDir + "/" + raw_path)

70+ then /. + remove_prefix prefix first_line

7571 else abort "gitSource.nix: Cannot parse ${origSrcSubDir + "/.git"}";

7672 }));

7773

@@ -116,7 +112,7 @@ then

116112 # `git ls-files --recurse-submodules` to give us an accurate list

117113 # of all the files in the index.

118114 whitelist_files = knownSubmoduleDirs:

119− runCommand "git-ls-files" { preferLocalBuild = true; } ''

115+ runCommand "git-ls-files" {} ''

120116 tmp=$(mktemp -d)

121117 cd $tmp

122118 ${ lib.optionalString hasSubmodules ''

@@ -139,7 +135,7 @@ then

139135 ${git}/bin/git ls-files --recurse-submodules > $out/files

140136 '';

141137

142− # Find the submodules

138+ # Find the submodules

143139 whitelist_recursive = knownSubmoduleDirs:

144140 let

145141 # Get the new list of submoduleDirs and files

@@ -180,7 +176,7 @@ then

180176 );

181177

182178 # Identify files in the `.git` dir

183− isGitDirPath = path:

179+ isGitDirPath = path:

184180 path == origSrcSubDir + "/.git"

185181 || lib.hasPrefix (origSrcSubDir + "/.git/") path;

186182

lib/clean-source-with.nix+8−35

@@ -50,33 +50,6 @@

5050 # (and forward a `name` argument) can use this to make

5151 # the message to the use more meaningful.

5252 #

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

8053 cleanSourceWith = { filter ? _path: _type: true, src, subDir ? "", name ? null

8154 , caller ? "cleanSourceWith", includeSiblings ? false }:

8255 let

@@ -130,21 +103,21 @@

130103 __trace (

131104 "WARNING: `${caller}` called on ${toString src} without a `name`. "

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

140106 in {

141107 inherit origSrc origSubDir origSrcSubDir;

142108 filter = filter';

143− outPath = (filterPath { filter = filter'; path = origSrc; name = name'; }) + origSubDir;

109+ outPath = (builtins.path { filter = filter'; path = origSrc; name = name'; }) + origSubDir;

144110 _isLibCleanSourceWithEx = true;

145111 # It is only safe for older cleanSourceWith to filter this one

146112 # if the we are still looking at the root of origSrc

147113 _isLibCleanSourceWith = origSubDir == "";

148114 name = name';

149115 };

116+

117+ pathHasContext = builtins.hasContext or (lib.hasPrefix builtins.storeDir);

118+

119+ canCleanSource = src:

120+ src ? _isLibCleanSourceWithEx

121+ || src ? _isLibCleanSourceWith

122+ || !(pathHasContext (toString src));

150123}

lib/cover-project.nix+47−44

@@ -10,12 +10,19 @@ coverageReports:

1010let

1111 toBashArray = arr: "(" + (lib.concatStringsSep " " arr) + ")";

1212

13− # Create a list element for a project coverage index page.

14− coverageListElement = coverageReport:

13+ # Create table rows for a project coverage index page that look something like:

14+ #

15+ # | Package |

16+ # |------------------|

17+ # | cardano-shell |

18+ # | cardano-launcher |

19+ coverageTableRows = coverageReport:

1520 ''

16− <li>

17− <a href="${coverageReport.passthru.name}/hpc_index.html">${coverageReport.passthru.name}</a>

18− </li>

21+ <tr>

22+ <td>

23+ <a href="${coverageReport.passthru.name}/hpc_index.html">${coverageReport.passthru.name}</href>

24+ </td>

25+ </tr>

1926 '';

2027

2128 projectIndexHtml = pkgs.writeText "index.html" ''

@@ -24,32 +31,23 @@ let

2431 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

2532 </head>

2633 <body>

27− <div>

28− WARNING: Modules with no coverage are not included in any of these reports, this is just how HPC works under the hood.

29− </div>

30− <div>

31− <h2>Union Report</h2>

32− <p>The following report shows how each module is covered by any test in the project:</p>

33− <ul>

34− <li>

35− <a href="all/hpc_index.html">all</a>

36− </li>

37− </ul>

38− </div>

39− <div>

40− <h2>Individual Reports</h2>

41− <p>The following reports show how the tests of each package cover modules in the project:</p>

42− <ul>

43− ${with lib; concatStringsSep "\n" (map coverageListElement coverageReports)}

44− </ul>

45− </div>

34+ <table border="1" width="100%">

35+ <tbody>

36+ <tr>

37+ <th>Report</th>

38+ </tr>

39+

40+ ${with lib; concatStringsSep "\n" (map coverageTableRows coverageReports)}

41+

42+ </tbody>

43+ </table>

4644 </body>

4745 </html>

4846 '';

4947

5048 ghc = project.pkg-set.config.ghc.package;

5149

52− libs = lib.unique (lib.concatMap (r: r.mixLibraries) coverageReports);

50+ libs = lib.remove null (map (r: r.library) coverageReports);

5351

5452 mixDirs =

5553 map

@@ -58,17 +56,6 @@ let

5856

5957 srcDirs = map (l: l.srcSubDirPath) libs;

6058

61− allCoverageReport = haskellLib.coverageReport {

62− name = "all";

63− checks = lib.flatten (lib.concatMap

64− (pkg: lib.optional (pkg ? checks) (lib.filter lib.isDerivation (lib.attrValues pkg.checks)))

65− (lib.attrValues (haskellLib.selectProjectPackages project.hsPkgs)));

66− mixLibraries = lib.concatMap

67− (pkg: lib.optional (pkg.components ? library) pkg.components.library)

68− (lib.attrValues (haskellLib.selectProjectPackages project.hsPkgs));

69− ghc = project.pkg-set.config.ghc.package;

70− };

71−

7259in pkgs.runCommand "project-coverage-report"

7360 ({ nativeBuildInputs = [ (ghc.buildGHC or ghc) pkgs.buildPackages.zip ];

7461 LANG = "en_US.UTF-8";

@@ -137,14 +124,30 @@ in pkgs.runCommand "project-coverage-report"

137124 cp -R $report/share/hpc/vanilla/html/* $out/share/hpc/vanilla/html/

138125 '') coverageReports)}

139126

140− # Copy out "all" coverage report

141− cp -R ${allCoverageReport}/share/hpc/vanilla/tix/all $out/share/hpc/vanilla/tix

142− cp -R ${allCoverageReport}/share/hpc/vanilla/html/all $out/share/hpc/vanilla/html

127+ if [ ''${#tixFiles[@]} -ne 0 ]; then

128+ # Create tix file with test run information for all packages

129+ tixFile="$out/share/hpc/vanilla/tix/all/all.tix"

130+ hpcSumCmd=("hpc" "sum" "--union" "--output=$tixFile")

131+ hpcSumCmd+=("''${tixFiles[@]}")

132+ echo "''${hpcSumCmd[@]}"

133+ eval "''${hpcSumCmd[@]}"

134+

135+ # Markup a HTML coverage report for the entire project

136+ cp ${projectIndexHtml} $out/share/hpc/vanilla/html/index.html

137+ echo "report coverage-per-package $out/share/hpc/vanilla/html/index.html" >> $out/nix-support/hydra-build-products

138+

139+ local markupOutDir="$out/share/hpc/vanilla/html/all"

140+ local srcDirs=${toBashArray srcDirs}

141+ local mixDirs=${toBashArray mixDirs}

142+ local allMixModules=()

143+

144+ mkdir $markupOutDir

145+ findModules allMixModules "$out/share/hpc/vanilla/mix/" "*.mix"

143146

144− # Markup a HTML coverage summary report for the entire project

145− cp ${projectIndexHtml} $out/share/hpc/vanilla/html/index.html

147+ markup srcDirs mixDirs allMixModules "$markupOutDir" "$tixFile"

146148

147− echo "report coverage $out/share/hpc/vanilla/html/index.html" >> $out/nix-support/hydra-build-products

148− ( cd $out/share/hpc/vanilla/html ; zip -r $out/share/hpc/vanilla/html.zip . )

149− echo "file zip $out/share/hpc/vanilla/html.zip" >> $out/nix-support/hydra-build-products

149+ echo "report coverage $markupOutDir/hpc_index.html" >> $out/nix-support/hydra-build-products

150+ ( cd $out/share/hpc/vanilla/html ; zip -r $out/share/hpc/vanilla/html.zip . )

151+ echo "file zip $out/share/hpc/vanilla/html.zip" >> $out/nix-support/hydra-build-products

152+ fi

150153 ''

lib/cover.nix+69−102

@@ -1,18 +1,18 @@

1−# The following collects coverage information from a set of given "checks" and

2−# provides a coverage report showing how those "checks" cover a set of given

3−# "mixLibraries".

41{ stdenv, lib, haskellLib, pkgs }:

6−# Name of the coverage report, which should be unique.

3+# Name of the coverage report, which should be unique

74{ name

8−# List of check derivations that generate coverage.

9−, checks ? []

10−# List of libraries to include in the coverage report. If one of the above

11−# checks generates coverage for a particular library, coverage will only

12−# be included if that library is in this list.

13−, mixLibraries ? []

14−# Hack for project-less projects.

15−, ghc ? if mixLibraries == [] then null else (lib.head mixLibraries).project.pkg-set.config.ghc.package

5+# Library to check coverage of

6+, library

7+# List of check derivations that generate coverage

8+, checks

9+# List of other libraries to include in the coverage report. The

10+# default value if just the derivation provided as the `library`

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 ? [library]

14+# hack for project-less projects

15+, ghc ? library.project.pkg-set.config.ghc.package

1616}:

1717

1818let

@@ -26,7 +26,7 @@ let

2626in pkgs.runCommand (name + "-coverage-report")

2727 ({nativeBuildInputs = [ (ghc.buildGHC or ghc) pkgs.buildPackages.zip ];

2828 passthru = {

29− inherit name checks mixLibraries;

29+ inherit name library checks;

3030 };

3131 # HPC will fail if the Haskell file contains non-ASCII characters,

3232 # unless our locale is set correctly. This has been fixed, but we

@@ -70,105 +70,71 @@ in pkgs.runCommand (name + "-coverage-report")

7070 local -n tixFs=$2

7171 local outFile="$3"

7272

73− if (( "''${#tixFs[@]}" > 0 )); then

74− local hpcSumCmd=("hpc" "sum" "--union" "--output=$outFile")

73+ local hpcSumCmd=("hpc" "sum" "--union" "--output=$outFile")

7574

76− for module in "''${includedModules[@]}"; do

77− hpcSumCmd+=("--include=$module")

78− done

75+ for module in "''${includedModules[@]}"; do

76+ hpcSumCmd+=("--include=$module")

77+ done

7978

80− for tixFile in "''${tixFs[@]}"; do

81− hpcSumCmd+=("$tixFile")

82− done

79+ for tixFile in "''${tixFs[@]}"; do

80+ hpcSumCmd+=("$tixFile")

81+ done

8382

84− echo "''${hpcSumCmd[@]}"

85− eval "''${hpcSumCmd[@]}"

86− else

87− # If there are no tix files we output an empty tix file so that we can

88− # markup an empty HTML coverage report. This is preferable to failing to

89− # output a HTML report.

90− echo 'Tix []' > $outFile

91− fi

83+ echo "''${hpcSumCmd[@]}"

84+ eval "''${hpcSumCmd[@]}"

9285 }

9386

9487 function findModules() {

95− local -n result=$1

96− local -n searchDirs=$2

88+ local searchDir=$2

9789 local pattern=$3

9890

99− for dir in "''${searchDirs[@]}"; do

100− pushd $dir

101− local temp=()

102− mapfile -d $'\0' temp < <(find ./ -type f \

103− -wholename "$pattern" -not -name "Paths*" \

104− -exec basename {} \; \

105− | sed "s/\.mix$//" \

106− | tr "\n" "\0")

107− result+=("''${temp[@]}")

108− popd

109− done

91+ pushd $searchDir

92+ mapfile -d $'\0' $1 < <(find ./ -type f \

93+ -wholename "$pattern" -not -name "Paths*" \

94+ -exec basename {} \; \

95+ | sed "s/\.mix$//" \

96+ | tr "\n" "\0")

97+ popd

11098 }

11199

100+ local mixDirs=${toBashArray mixDirs}

101+

112102 mkdir -p $out/nix-support

113− mkdir -p $out/share/hpc/vanilla/mix/

103+ mkdir -p $out/share/hpc/vanilla/mix/${name}

114104 mkdir -p $out/share/hpc/vanilla/tix/${name}

115105 mkdir -p $out/share/hpc/vanilla/html/${name}

116106

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

121108 for dir in "''${mixDirs[@]}"; do

122109 if [ -d "$dir" ]; then

123− cp -R "$dir" $out/share/hpc/vanilla/mix/

110+ cp -R "$dir"/* $out/share/hpc/vanilla/mix/${name}

124111 fi

125112 done

126113

127− local mixModules=()

128− # Mix modules for all packages in "mixLibraries"

129− findModules mixModules mixDirs "*.mix"

130−

131− # We need to make a distinction between library "exposed-modules" and

132− # "other-modules" used in test suites:

133− # - "exposed-modules" are addressed as "$library-$version-$hash/module"

134− # - "other-modules" are addressed as "module"

135− #

136− # This complicates the code required to find the mix modules. For a given mix directory:

137− #

138− # mix

139− # └── ntp-client-0.0.1

140− # └── ntp-client-0.0.1-gYjRsBHUCaHX7ENcjHnw5

141− # ├── Network.NTP.Client.mix

142− # ├── Network.NTP.Client.Packet.mix

143− # └── Network.NTP.Client.Query.mix

144− #

145− # Iff ntp-client uses "other-modules" in a test suite, both:

146− # - "mix/ntp-client-0.0.1", and

147− # - "mix/ntp-client-0.0.1/ntp-client-0.0.1-gYjRsBHUCaHX7ENcjHnw5"

148− # need to be provided to hpc as search directories.

149− #

150− # I'd prefer to just exclude "other-modules", but I can't think of an easy

151− # way to do that in bash.

152− #

153− # Here we expand the search dirs and modify the mix dirs accordingly:

154− for dir in "''${mixDirs[@]}"; do

155− local otherModulesSearchDirs=()

156− # Simply consider any directory with a mix file as a search directory.

157− mapfile -d $'\0' otherModulesSearchDirs < <(find $dir -type f \

158− -wholename "*.mix" \

159− -exec dirname {} \; \

160− | uniq \

161− | tr "\n" "\0")

162− mixDirs+=("''${otherModulesSearchDirs[@]}")

163− done

164−

114+ local srcDirs=${toBashArray srcDirs}

115+ local allMixModules=()

116+ local pkgMixModules=()

117+

118+ # The behaviour of stack coverage reports is to provide tix files

119+ # that include coverage information for every local package, but

120+ # to provide HTML reports that only include coverage info for the

121+ # current package. We emulate the same behaviour here. If the user

122+ # includes all local packages in the mix libraries argument, they

123+ # will get a coverage report very similar to stack.

124+

125+ # All mix modules

126+ findModules allMixModules "$out/share/hpc/vanilla/mix/${name}" "*.mix"

127+ # Only mix modules corresponding to this package

128+ findModules pkgMixModules "$out/share/hpc/vanilla/mix/${name}" "*${name}*/*.mix"

129+

130+ # For each test

165131 local tixFiles=()

166132 ${lib.concatStringsSep "\n" (builtins.map (check: ''

167133 if [ -d "${check}/share/hpc/vanilla/tix" ]; then

168134 pushd ${check}/share/hpc/vanilla/tix

169135

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

172138

173139 mkdir -p "$(dirname $newTixFile)"

174140 # Copy over the tix file verbatim

@@ -177,28 +143,29 @@ in pkgs.runCommand (name + "-coverage-report")

177143 # Add the tix file to our list

178144 tixFiles+=("$newTixFile")

179145

180− # Create a coverage report for *just that check* affecting any of the

181− # "mixLibraries"

182− markup srcDirs mixDirs mixModules "$out/share/hpc/vanilla/html/${check.name}/" "$newTixFile"

146+ # Create a coverage report for *just that test*

147+ markup srcDirs mixDirs pkgMixModules "$out/share/hpc/vanilla/html/${name}/${check.exeName}/" "$newTixFile"

183148

184149 popd

185150 fi

186151 '') checks)

187152 }

188153

189− # Sum tix files to create a tix file with tix information from all tests in

190− # the package and markup a HTML report from this info.

191− local sumTixFile="$out/share/hpc/vanilla/tix/${name}/${name}.tix"

192− local markupOutDir="$out/share/hpc/vanilla/html/${name}"

154+ # Sum tix files to create a tix file with all relevant tix

155+ # information and markup a HTML report from this info.

156+ if (( "''${#tixFiles[@]}" > 0 )); then

157+ local sumTixFile="$out/share/hpc/vanilla/tix/${name}/${name}.tix"

158+ local markupOutDir="$out/share/hpc/vanilla/html/${name}"

193159

194− # Sum all of our tix files

195− sumTix mixModules tixFiles "$sumTixFile"

160+ # Sum all of our tix file, including modules from any local package

161+ sumTix allMixModules tixFiles "$sumTixFile"

196162

197− # Markup a HTML report

198− markup srcDirs mixDirs mixModules "$markupOutDir" "$sumTixFile"

163+ # Markup a HTML report, included modules from only this package

164+ markup srcDirs mixDirs pkgMixModules "$markupOutDir" "$sumTixFile"

199165

200− # Provide a HTML zipfile and Hydra links

201− ( cd "$markupOutDir" ; zip -r $out/share/hpc/vanilla/${name}-html.zip . )

202− echo "report coverage $markupOutDir/hpc_index.html" >> $out/nix-support/hydra-build-products

203− echo "file zip $out/share/hpc/vanilla/${name}-html.zip" >> $out/nix-support/hydra-build-products

166+ # Provide a HTML zipfile and Hydra links

167+ ( cd "$markupOutDir" ; zip -r $out/share/hpc/vanilla/${name}-html.zip . )

168+ echo "report coverage $markupOutDir/hpc_index.html" >> $out/nix-support/hydra-build-products

169+ echo "file zip $out/share/hpc/vanilla/${name}-html.zip" >> $out/nix-support/hydra-build-products

170+ fi

204171 ''

lib/default.nix+38−24

@@ -4,8 +4,11 @@

44with haskellLib;

66let

7− # Why `final.buildPackages.buildPackages.gitMinimal`?

8− # Why not just final.buildPackages.gitMinimal?

7+ # Why `final.evalPackages.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.

912 #

1013 # It turns out `git` depends on `gdb` in a round about way:

1114 # git -> openssh -> libfido2 -> systemd -> python libxml -> Cython -> gdb

@@ -21,7 +24,7 @@ let

2124 # * When `gdb` does not exist for `js`, so when cross

2225 # compiling with ghcjs `final.buildPackages.git` fails

2326 # to build at all.

24− inherit (pkgs.buildPackages.buildPackages) gitMinimal;

27+ inherit (pkgs.evalPackages.buildPackages) gitMinimal;

2528

2629in {

2730 # Within the package components, these are the attribute names of

@@ -189,17 +192,17 @@ in {

189192 collectChecks' = collectChecks (_: true);

190193

191194 # Replacement for lib.cleanSourceWith that has a subDir argument.

192− inherit (import ./clean-source-with.nix { inherit lib; }) cleanSourceWith;

195+ inherit (import ./clean-source-with.nix { inherit lib; }) cleanSourceWith canCleanSource;

193196

194197 # Use cleanSourceWith to filter just the files needed for a particular

195198 # component of a package

196− cleanCabalComponent = import ./clean-cabal-component.nix { inherit lib cleanSourceWith; };

199+ cleanCabalComponent = import ./clean-cabal-component.nix { inherit lib cleanSourceWith canCleanSource; };

197200

198201 # Clean git directory based on `git ls-files --recurse-submodules`

199202 cleanGit = import ./clean-git.nix {

200203 inherit lib cleanSourceWith;

201204 git = gitMinimal;

202− inherit (pkgs.buildPackages.buildPackages) runCommand;

205+ inherit (pkgs.evalPackages.buildPackages) runCommand;

203206 };

204207

205208 # Some times it is handy to temporarily use a relative path between git

@@ -229,7 +232,7 @@ in {

229232

230233 # Check a test component

231234 check = import ./check.nix {

232− inherit stdenv lib haskellLib;

235+ inherit stdenv lib haskellLib srcOnly;

233236 };

234237

235238 # Do coverage of a package

@@ -257,24 +260,22 @@ in {

257260 && stdenv.buildPlatform == stdenv.hostPlatform

258261 && stdenv.hostPlatform == stdenv.targetPlatform;

259262

260− # Takes a version number, module or list of modules (for cabalProject)

261− # and converts it to an list of project modules. This allows

263+ # Takes a version number or attr set of arguments (for cabalProject)

264+ # and converts it to an attr set of arguments. This allows

262265 # the use of "1.0.0.0" or { version = "1.0.0.0"; ... }

263− versionOrModToMods = versionOrMod:

264− if lib.isString versionOrMod

265− then [{ version = versionOrMod; }]

266− else if lib.isList versionOrMod

267− then versionOrMod

268− else [versionOrMod];

266+ versionOrArgsToArgs = versionOrArgs:

267+ if lib.isAttrs versionOrArgs

268+ then versionOrArgs

269+ else { version = versionOrArgs; };

269270

270271 # Find the resolver in the stack.yaml file and fetch it if a sha256 value is provided

271272 fetchResolver = import ./fetch-resolver.nix {

272− inherit (pkgs.buildPackages) pkgs;

273+ inherit (pkgs.evalPackages) pkgs;

273274 };

274275

275276 inherit (import ./cabal-project-parser.nix {

276277 inherit pkgs;

277− }) parseIndexState parseSourceRepositoryPackages parseRepositories parseSourceRepositoryPackageBlock parseRepositoryBlock;

278+ }) parseIndexState parseBlock;

278279

279280

280281 cabalToNixpkgsLicense = import ./spdx/cabal.nix pkgs;

@@ -289,9 +290,26 @@ in {

289290 if subDir == ""

290291 then src

291292 else

292− haskellLib.cleanSourceWith {

293− inherit src subDir includeSiblings;

294− };

293+ if haskellLib.canCleanSource src

294+ then haskellLib.cleanSourceWith {

295+ inherit src subDir includeSiblings;

296+ }

297+ else let name = src.name or "source" + "-" + __replaceStrings ["/"] ["-"] subDir;

298+ in if includeSiblings

299+ then rec {

300+ # Keep `src.origSrc` so it can be used to allow references

301+ # to other parts of that root.

302+ inherit name;

303+ origSrc = src.origSrc or src;

304+ origSubDir = src.origSubDir or "" + "/" + subDir;

305+ outPath = origSrc + origSubDir;

306+ }

307+ else {

308+ # We are not going to need other parts of `origSrc` if there

309+ # was one and we can ignore it

310+ inherit name;

311+ outPath = src + "/" + subDir;

312+ };

295313

296314 # Givin a `src` split it into a `root` path (based on `src.origSrc` if

297315 # present) and `subDir` (based on `src.origSubDir). The

@@ -339,8 +357,4 @@ in {

339357 # Converts from a `compoent.depends` value to a library derivation.

340358 # In the case of sublibs the `depends` value should already be the derivation.

341359 dependToLib = d: d.components.library or d;

342−

343− projectOverlays = import ./project-overlays.nix {

344− inherit lib haskellLib;

345− };

346360}

lib/ghcjs-project.nix+7−36

@@ -52,8 +52,6 @@

5252 '';

5353 materialized = ../materialized/ghcjs/cabal + "/${compiler-nix-name}";

5454 }

55−, overrideBootPackages ? []

56−, patches ? []

5755, ...

5856}@args:

5957let

@@ -77,11 +75,9 @@ let

7775

7876 # Inputs needed to boot the GHCJS compiler

7977 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

78+ # pin nodejs to the 12 series for now, as strings can only be half the length in node 14+

79+ # see https://github.com/nodejs/node/issues/33960, this can break large TH splices for now.

80+ nodejs-12_x

8581 makeWrapper

8682 xorg.lndir

8783 gmp

@@ -89,9 +85,9 @@ let

8985 ]

9086 ++ [ ghc cabal-install emsdk ];

9187 # Configured the GHCJS source

92− configured-src = (pkgs.runCommandCC "configured-ghcjs-src" {

88+ configured-src = pkgs.runCommandCC "configured-ghcjs-src" {

9389 buildInputs = configureInputs;

94− inherit src patches;

90+ inherit src;

9591 } ''

9692 export HOME=$(pwd)

9793 mkdir $HOME/.cabal

@@ -100,11 +96,6 @@ let

10096 chmod -R +w "$out"

10197 cd "$out"

10298

103− for p in $patches

104− do

105− patch -p1 <$p

106− done

107−

10899 # TODO: Find a better way to avoid impure version numbers

109100 sed -i 's/RELEASE=NO/RELEASE=YES/' ghc/configure.ac

110101 sed -i 's/${ghcjsVersion}/${ghcVersion}/' ghcjs.cabal

@@ -137,32 +128,13 @@ let

137128 for a in integer-gmp base unix; do

138129 cp ${../overlays/patches/config.sub} lib/boot/pkg/$a/config.sub

139130 done

140− ${ # it just so happens that all existing uses of overriding boot packages

141− # need to be installed right after template-haskell

142− # if at some point we would need to insert them at different points

143− # then we will have gto come up with something more clever

144− builtins.concatStringsSep "\n" (map ({name, src}: ''

145− rm -rf $out/lib/boot/pkg/${name}

146− cp -r ${src} $out/lib/boot/pkg/${name}

147− sed -i 's/^ - ${name}$//g' $out/lib/boot/boot.yaml

148− sed -i 's/^ - template-haskell$/ - template-haskell\n - ${name}/g' $out/lib/boot/boot.yaml

149− echo "Added ${name} to boot.yaml"

150− ''

151− ) (pkgs.lib.reverseList overrideBootPackages))

152− }

153−

154− chmod -R +w $out/lib/boot/pkg

155− '') // {

156− # The configured source includes /nix/store paths and so filtering can fail.

157− filterPath = { path, ... }: path;

158− };

131+ '';

159132 # see https://github.com/ghcjs/ghcjs/issues/751 for the happy upper bound.

160133

161134 ghcjsProject = pkgs.haskell-nix.cabalProject' (

162135 (pkgs.lib.filterAttrs

163136 (n: _: !(builtins.any (x: x == n)

164− [ "src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"

165− "overrideBootPackages" "patches"])) args) // {

137+ ["src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"])) args) // {

166138 src = configured-src;

167139 index-state = "2021-03-20T00:00:00Z";

168140 inherit compiler-nix-name;

@@ -186,7 +158,6 @@ let

186158 packages.Cabal.patches = [ ./../overlays/patches/Cabal/fix-data-dir.patch ];

187159 })

188160 {

189− ghcOptions = ["-O2"];

190161 packages.ghcjs.doHaddock = false;

191162 packages.haddock-ghcjs.doHaddock = false;

192163 packages.haddock-api-ghcjs.doHaddock = false;

lib/import-and-filter-project.nix+10−7

@@ -6,11 +6,14 @@

66let

77 # Full source including possible relative paths form the

88 # project directory.

9− srcRoot = haskellLib.cleanSourceWith {

10− name = if src ? name then "${src.name}-root" else "source-root";

11− src = src.origSrc or src;

12− filter = src.filter or (_: _: true);

13− };

9+ srcRoot =

10+ if haskellLib.canCleanSource src

11+ then haskellLib.cleanSourceWith {

12+ name = if src ? name then "${src.name}-root" else "source-root";

13+ src = src.origSrc or src;

14+ filter = src.filter or (_: _: true);

15+ }

16+ else src.origSrc or src;

1417 # The sub directory containing the cabal.project or stack.yaml file

1518 projectSubDir' = src.origSubDir or ""; # With leading /

1619 projectSubDir = pkgs.lib.strings.removePrefix "/" projectSubDir'; # Without /

@@ -33,7 +36,7 @@ in project // {

3336 isProject = false;

3437 packageSrc = pkgs.lib.lists.elemAt sourceRepos (toInt oldPkg.src.url);

3538 }

36− else if !hasPrefix "${projectNix}" (toString oldPkg.src.content)

39+ else if !hasPrefix (toString projectNix) (toString oldPkg.src.content)

3740 then {

3841 # Source location does not match project prefix

3942 isProject = false;

@@ -44,7 +47,7 @@ in project // {

4447 isProject = true;

4548 packageSrc = haskellLib.appendSubDir {

4649 src = srcRoot;

47− subDir = removePrefix "/" (removePrefix "${projectNix}"

50+ subDir = removePrefix "/" (removePrefix (toString projectNix)

4851 (toString oldPkg.src.content));

4952 includeSiblings = true; # Filtering sibling dirs of the package dir is done in the

5053 # component builder so that relative paths can be used to

lib/materialize.nix+10−12

@@ -24,7 +24,7 @@

2424}: derivation:

2525

2626let

27− name = derivation.name + pkgs.lib.optionalString (derivation ? version) "-${derivation.version}";

27+ inherit (derivation) name;

2828

2929 traceIgnoringSha256 = reason: x:

3030 if sha256 != null

@@ -36,15 +36,10 @@ let

3636 then builtins.trace ("Warning: ignoring materialized for " + name + " " + reason) x

3737 else x;

3838

39− traceWhenChecking = message: x:

40− if checkMaterialization

41− then builtins.trace message x

42− else x;

43−

4439 unchecked =

4540 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'.";

47− materializeMessage = "${name}: To materialize ${this} entirely, pass a writable path as the `materialized` argument and run the 'updateMaterialized' script in 'passthru'.";

41+ sha256message = "To make ${this} a fixed-output derivation but not materialized, set `${sha256Arg}` to the output of the 'calculateMaterializedSha' script in 'passthru'.";

42+ materializeMessage = "To materialize ${this} entirely, pass a writable path as the `materialized` argument and run the 'updateMaterialized' script in 'passthru'.";

4843 in if reasonNotSafe != null

4944 then

5045 # Warn the user if they tried to pin stuff down when it is not safe

@@ -55,10 +50,10 @@ let

5550 else if sha256 != null

5651 then

5752 # Let the user know how to materialize if they want to.

58− traceWhenChecking materializeMessage calculateUseHash

53+ builtins.trace materializeMessage calculateUseHash

5954 else # materialized == null && sha256 == null

6055 # Let the user know how to calculate a sha256 or materialize if they want to.

61− traceWhenChecking sha256message (traceWhenChecking materializeMessage calculateNoHash);

56+ builtins.trace sha256message (builtins.trace materializeMessage calculateNoHash);

6257

6358 # Build fully and check the hash and materialized versions

6459 checked =

@@ -128,7 +123,11 @@ let

128123 calculateUseMaterialized =

129124 assert materialized != null;

130125 assert __pathExists materialized;

131− { outPath = materialized; inherit name; };

126+ runCommand name (pkgs.lib.optionalAttrs (sha256 == null) hashArgs) ''

127+ cp -Lr ${materialized} $out

128+ # Make sure output files can be removed from the sandbox

129+ chmod -R +w $out

130+ '';

132131 calculateMaterializedSha =

133132 writeShellScript "calculateSha" ''${nix}/bin/nix-hash --base32 --type sha256 ${calculateNoHash}'';

134133

@@ -144,7 +143,6 @@ let

144143 fi

145144

146145 # Generate the files

147− mkdir -p $TARGET

148146 rm -rf $TARGET

149147 cp -r ${calculateNoHash} "$TARGET"

150148 chmod -R +w "$TARGET"

lib/pkgconf-nixpkgs-map.nix+1−7

@@ -27,12 +27,11 @@ pkgs:

2727 "dl" = []; # provided by glibc

2828 "fftw3" = [ pkgs."fftw" ];

2929 "fftw3f" = [ pkgs."fftwFloat" ];

30− "freetype2" = [ pkgs."freetype" ];

3130 "gconf" = [ pkgs."GConf" ];

3231 "gconf-2.0" = [ pkgs."GConf" ];

3332 "gdk-2.0" = [ pkgs."gtk2" ];

3433 "gdk-3.0" = [ pkgs."gtk3" ];

35− "gdk-pixbuf-2.0" = [ (pkgs."gdk-pixbuf" or pkgs."gdk_pixbuf") ];

34+ "gdk-pixbuf-2.0" = [ pkgs."gdk_pixbuf" ];

3635 "gdk-x11-2.0" = [ pkgs."gdk_x11" ];

3736 "gdk-x11-3.0" = [ pkgs."gtk3" ];

3837 "gio-2.0" = [ pkgs."glib" ];

@@ -47,7 +46,6 @@ pkgs:

4746 "gobject-2.0" = [ pkgs."glib" ];

4847 "gmodule-2.0" = [ pkgs."glib" ];

4948 "gobject-introspection-1.0" = [ pkgs."gobject-introspection" ];

50− "graphene-gobject-1.0" = [ pkgs."graphene" ];

5149 "gstreamer-audio-0.10" = [ pkgs."gst-plugins-base" ];

5250 "gstreamer-audio-1.0" = [ pkgs."gst-plugins-base" ];

5351 "gstreamer-base-0.10" = [ pkgs."gst-plugins-base" ];

@@ -67,7 +65,6 @@ pkgs:

6765 "hidapi-libusb" = [ pkgs."hidapi" ];

6866 "icudata" = [ pkgs."icu" ];

6967 "icui18n" = [ pkgs."icu" ];

70− "icu-i18n" = [ pkgs."icu" ];

7168 "icuuc" = [ pkgs."icu" ];

7269 "idn" = [ pkgs."libidn" ];

7370 "IL" = [ pkgs."libdevil" ];

@@ -84,9 +81,7 @@ pkgs:

8481 "ldap" = [ pkgs."openldap" ];

8582 "libavutil" = [ pkgs."ffmpeg" ];

8683 "libcrypto" = [ pkgs."openssl".dev ];

87− "libfreenect" = [ pkgs."freenect" ];

8884 "libgsasl" = [ pkgs."gsasl" ];

89− "liboath" = [ pkgs."liboauth" ];

9085 "libpcre" = [ pkgs."pcre" ];

9186 "libqrencode" = [ pkgs."qrencode" ];

9287 "libR" = [ pkgs."R" ];

@@ -122,7 +117,6 @@ pkgs:

122117 "pfs-1.2" = [ pkgs."pfstools" ];

123118 "png" = [ pkgs."libpng" ];

124119 "poppler-glib" = [ pkgs."poppler" ];

125− "poppler-cpp" = [ pkgs."poppler" ];

126120 "pq" = [ pkgs."postgresql" ];

127121 "libpq" = [ pkgs."postgresql" ];

128122 "pthread" = [];

lib/project-overlays.nixdeleted−37

@@ -1,37 +0,0 @@

1−{

2− lib

3−, haskellLib

4−}: {

5− # Provide a devshell profile (https://github.com/numtide/devshell),

6− # adapted from the project normal shell.

7− devshell = final: prev: {

8− devshell = let

9− in {

10− packages = final.shell.nativeBuildInputs

11− # devshell does not use pkgs.mkShell / pkgs.stdenv.mkDerivation,

12− # so we need to explicit required dependencies which

13− # are provided implicitely by stdenv when using the normal shell:

14− ++ (lib.filter lib.isDerivation final.shell.stdenv.defaultNativeBuildInputs)

15− ++ [ final.pkgs.buildPackages.binutils ];

16− env = lib.mapAttrsToList lib.nameValuePair {

17− inherit (final.shell) CABAL_CONFIG NIX_GHC_LIBDIR;

18− };

19− };

20− };

21−

22− # Provides easily accessible attrset for each type of

23− # components belonging to the project packages.

24− projectComponents = final: prev: {

25− # local project packages:

26− packages = haskellLib.selectProjectPackages final.hsPkgs;

27− # set of all exes (as first level entries):

28− exes = lib.foldl' lib.mergeAttrs { } (map (p: p.components.exes) (lib.attrValues final.packages));

29− # `tests` are the test suites which have been built.

30− tests = haskellLib.collectComponents' "tests" final.packages;

31− # `benchmarks` (only built, not run).

32− benchmarks = haskellLib.collectComponents' "benchmarks" final.packages;

33− # `checks` collect results of executing the tests:

34− checks = haskellLib.collectChecks' final.packages;

35− };

36−

37−}

lib/spdx/licenses.nix+1−9

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

11pkgs:

22with builtins; let

3− spdxJson = pkgs.buildPackages.spdx-license-list-data.json or pkgs.buildPackages.spdx-license-list-data;

4− materialized' = ../../materialized + "/spdx-${spdxJson.version}";

53 licensesJSON = fromJSON (replaceStrings

64 [ "\\u0026" "\\u0027" "\\u003d" ]

75 [ "&" "'" "=" ]

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

6+ (readFile "${pkgs.evalPackages.spdx-license-list-data}/json/licenses.json")

157 );

168 dropFour = s: substring 0 (stringLength s - 4) s;

179 toSpdx = lic: with lic;

lib/stack-cache-generator.nix+39−33

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

11# Generate cache entries for dependencies of package defined in `src`

3+{ pkgs, haskellLib }:

34{ src

45, stackYaml ? "stack.yaml"

56, sha256map ? null

@@ -8,6 +9,10 @@

89 # sha256map =

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

1011 # = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q"; };

12+, lookupSha256 ?

13+ if sha256map != null

14+ then { location, tag, ...}: sha256map."${location}"."${tag}"

15+ else _: null

1116, branchMap ? null

1217 # A way to specify in which branch a git commit can

1318 # be found

@@ -16,14 +21,10 @@

1621 then { location, tag, ...}: branchMap."${location}"."${tag}" or null

1722 else _: null

1823, resolverSha256 ? null

19−, nix-tools

20−, evalPackages

24+, nix-tools ? pkgs.haskell-nix.internal-nix-tools # When building stack projects we use the internal nix-tools (compiled with a fixed GHC version)

2125, ...

22−}@args:

26+}:

2327let

24− inherit (evalPackages) runCommand;

25− inherit (evalPackages.haskell-nix) haskellLib;

26−

2728 # We only care about the stackYaml file. If src is a local directory

2829 # we want to avoid recalculating the cache unless the stack.yaml file

2930 # changes.

@@ -33,27 +34,30 @@ let

3334 }) resolver fetchedResolver;

3435

3536 # Filter just the stack yaml file and any resolver yaml file it points to.

36− maybeCleanedSource = haskellLib.cleanSourceWith {

37− inherit src;

38− filter = path: type:

39− let

40− origSrc = if src ? _isLibCleanSourceWith then src.origSrc else src;

41− origSubDir = if src ? _isLibCleanSourceWithEx then src.origSubDir else "";

42− relPath = evalPackages.lib.removePrefix (toString origSrc + origSubDir + "/") path;

37+ maybeCleanedSource =

38+ if haskellLib.canCleanSource src

39+ then haskellLib.cleanSourceWith {

40+ inherit src;

41+ filter = path: type:

42+ let

43+ origSrc = if src ? _isLibCleanSourceWith then src.origSrc else src;

44+ origSubDir = if src ? _isLibCleanSourceWithEx then src.origSubDir else "";

45+ relPath = pkgs.lib.removePrefix (toString origSrc + origSubDir + "/") path;

4346

44− # checks if path1 is a parent directory for path2

45− isParent = path1: path2: evalPackages.lib.hasPrefix "${path1}/" path2;

47+ # checks if path1 is a parent directory for path2

48+ isParent = path1: path2: pkgs.lib.hasPrefix "${path1}/" path2;

4649

47− in

48− (relPath == stackYaml)

49− || (resolver != null && (relPath == resolver || isParent relPath resolver))

50− ;

51− };

50+ in

51+ (relPath == stackYaml)

52+ || (resolver != null && (relPath == resolver || isParent relPath resolver))

53+ ;

54+ }

55+ else src;

5256

5357 # All repos served via ssh or git protocols are usually private

54− private = url: evalPackages.lib.substring 0 4 url != "http";

58+ private = url: pkgs.lib.substring 0 4 url != "http";

5559

56− repos = builtins.fromJSON (builtins.readFile (evalPackages.runCommand "stack-repos" {

60+ repos = builtins.fromJSON (builtins.readFile (pkgs.runCommand "stack-repos" {

5761 buildInputs = [ nix-tools ];

5862 } ''

5963 TMP=$(mktemp -d)

@@ -61,43 +65,45 @@ let

6165 cp -r "${maybeCleanedSource}/." $TMP

6266 chmod -R +w $TMP

6367 substituteInPlace ${stackYaml} --replace "# nix-sha256:" "nix-sha256:"

64− ${evalPackages.lib.optionalString (fetchedResolver != null) ''

68+ ${pkgs.lib.optionalString (fetchedResolver != null) ''

6569 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

6670 ''}

6771 stack-repos --stack-yaml ${stackYaml}

6872 cp repos.json $out

6973 ''));

7074

71− cabalName = path: builtins.readFile (evalPackages.runCommand "cabal-name" {

75+ cabalName = path: builtins.readFile (pkgs.runCommand "cabal-name" {

7276 buildInputs = [ nix-tools ];

7377 } ''

7478 cabal-name ${path} > $out

7579 '');

7680

7781 hashPath = path:

78− builtins.readFile (evalPackages.runCommand "hash-path" { preferLocalBuild = true; }

79− "echo -n $(${evalPackages.nix}/bin/nix-hash --type sha256 --base32 ${path}) > $out");

80−in with evalPackages.lib;

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

83+ "echo -n $(${pkgs.nix}/bin/nix-hash --type sha256 --base32 ${path}) > $out");

84+in with pkgs.lib;

8185concatMap (dep:

8286 let

8387 is-private = private dep.url;

84− sha256 =

85− if dep.sha256 != null then dep.sha256

86− else if sha256map != null then sha256map."${dep.url}"."${dep.rev}"

87− else null;

88+ sha256 = if dep.sha256 != null

89+ then dep.sha256

90+ else lookupSha256 {

91+ location = dep.url;

92+ tag = dep.rev;

93+ };

8894 branch = lookupBranch {

8995 location = dep.url;

9096 tag = dep.rev;

9197 };

9298 pkgsrc =

9399 if !is-private && sha256 != null

94− then evalPackages.fetchgit {

100+ then pkgs.fetchgit {

95101 inherit (dep) url rev;

96102 inherit sha256;

97103 }

98104 else builtins.fetchGit ({

99105 inherit (dep) url rev;

100− } // evalPackages.lib.optionalAttrs (branch != null) { ref = branch; });

106+ } // pkgs.lib.optionalAttrs (branch != null) { ref = branch; });

101107 in map (subdir: {

102108 name = cabalName "${pkgsrc}/${subdir}";

103109 inherit (dep) url rev;

lib/system-nixpkgs-map.nix+5−32

@@ -6,32 +6,16 @@ pkgs:

77with pkgs;

9−let

10− # On windows systems we need these to be propagatedBuildInputs so that the DLLs will be found.

11− gcclibs = if pkgs.stdenv.hostPlatform.isWindows then [

12− pkgs.windows.mcfgthreads

13− # If we just use `pkgs.buildPackages.gcc.cc` here it breaks the `th-dlls` test. TODO figure out why exactly.

14− (pkgs.buildPackages.runCommand "gcc-only" { nativeBuildInputs = [ pkgs.buildPackages.xorg.lndir ]; } ''

15− mkdir $out

16− lndir ${pkgs.buildPackages.gcc.cc} $out

17− '')

18− ] else [];

19−in

209# -- linux

2110{ crypto = [ openssl ];

22− "c++" = []; # no libc++

23− "stdc++" = gcclibs;

24− "stdc++-6" = gcclibs;

25− gcc_s_seh-1 = gcclibs;

26− gcc_s = gcclibs;

27− gcc = gcclibs;

11+ "c++" = null; # no libc++

12+ "stdc++" = null;

13+ "stdc++-6" = null;

2814 ssl = [ openssl ];

2915 z = [ zlib ];

30− m = []; # Included with ghc

3116 pcap = [ libpcap ];

3217 pthread = null; # available by default

3318 GL = [ libGL ];

34− GLEW = [ glew ];

3519 GLU = [ libGLU ];

3620 alut = [ freealut ];

3721 X11 = with xorg; [ libX11 ];

@@ -51,7 +35,6 @@ in

5135 util = [ utillinux ];

5236 magic = [ file ];

5337 pq = [ postgresql ];

54− libpq = [ postgresql ];

5538 iconv = [ libiconv ];

5639 lapack = [ liblapack ];

5740 boost_atomic = [ boost ];

@@ -97,23 +80,12 @@ in

9780 opencv = [ opencv3 ];

9881 icuuc = [ icu ];

9982 icui18n = [ icu ];

100− icu-i18n = [ icu ];

10183 icudata = [ icu ];

10284 vulkan = [ vulkan-loader ];

10385 sodium = [ libsodium ];

10486 gfortran = [ gfortran.cc.lib ];

10587 ssh2 = [ libssh2 ];

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

11789}

11890# -- windows

11991// { advapi32 = null; gdi32 = null; imm32 = null; msimg32 = null;

@@ -124,12 +96,13 @@ in

12496 # this should be bundled with gcc.

12597 # if it's not we have more severe

12698 # issues anyway.

99+ gcc_s_seh-1 = null;

100+ gcc_s = null;

127101 ssl32 = null; eay32 = [ openssl ];

128102 iphlpapi = null; # IP Help API

129103 msvcrt = null; # this is the libc

130104 Crypt32 = null;

131105 mswsock = null;

132− bcrypt = null;

133106 }

134107# -- os x

135108# NB: these map almost 1:1 to the framework names

lib/system-pkgs.nix+18−1

@@ -9,8 +9,25 @@

1010pkgs:

1111

12+let

13+ buildEnvMaybe = name: paths:

14+ if builtins.length paths == 1

15+ then builtins.head paths

16+ else pkgs.buildEnv { name = "${name}-env"; inherit paths; };

17+

18+ mapPackages = name: ps:

19+ if builtins.typeOf ps == "list"

20+ then buildEnvMaybe name ps

21+ else ps;

22+

23+in

1224 # Base packages.

1325 pkgs

1426

27+ # fetchgit should always come from the evalPackages

28+ # if it comes from the targetPackages we won't even

29+ # be able to execute it.

30+ // { fetchgit = pkgs.evalPackages.fetchgit; }

31+

1532 # Apply the mapping.

16− // import ./system-nixpkgs-map.nix pkgs

33+ // builtins.mapAttrs mapPackages (import ./system-nixpkgs-map.nix pkgs)

materialized/bootstrap/ghc883/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/ghc883/alex/default.nixdeleted−65

@@ -1,65 +0,0 @@

1−{

2− pkgs = hackage:

3− {

4− packages = {

5− "array".revision = (((hackage."array")."0.5.4.0").revisions).default;

6− "bytestring".revision = (((hackage."bytestring")."0.10.10.0").revisions).default;

7− "filepath".revision = (((hackage."filepath")."1.4.2.1").revisions).default;

8− "ghc-prim".revision = (((hackage."ghc-prim")."0.5.3").revisions).default;

9− "base".revision = (((hackage."base")."4.13.0.0").revisions).default;

10− "time".revision = (((hackage."time")."1.9.3").revisions).default;

11− "directory".revision = (((hackage."directory")."1.3.6.0").revisions).default;

12− "rts".revision = (((hackage."rts")."1.0").revisions).default;

13− "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;

14− "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;

15− "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

16− "containers".revision = (((hackage."containers")."0.6.2.1").revisions).default;

17− };

18− compiler = {

19− version = "8.8.3";

20− nix-name = "ghc883";

21− packages = {

22− "array" = "0.5.4.0";

23− "bytestring" = "0.10.10.0";

24− "filepath" = "1.4.2.1";

25− "ghc-prim" = "0.5.3";

26− "base" = "4.13.0.0";

27− "time" = "1.9.3";

28− "directory" = "1.3.6.0";

29− "rts" = "1.0";

30− "deepseq" = "1.4.4.0";

31− "unix" = "2.7.2.2";

32− "integer-gmp" = "1.0.2.0";

33− "containers" = "0.6.2.1";

34− };

35− };

36− };

37− extras = hackage:

38− { packages = { alex = ./.plan.nix/alex.nix; }; };

39− modules = [

40− ({ lib, ... }:

41− {

42− packages = {

43− "alex" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

44− };

45− })

46− ({ lib, ... }:

47− {

48− packages = {

49− "filepath".components.library.planned = lib.mkOverride 900 true;

50− "bytestring".components.library.planned = lib.mkOverride 900 true;

51− "ghc-prim".components.library.planned = lib.mkOverride 900 true;

52− "array".components.library.planned = lib.mkOverride 900 true;

53− "rts".components.library.planned = lib.mkOverride 900 true;

54− "unix".components.library.planned = lib.mkOverride 900 true;

55− "directory".components.library.planned = lib.mkOverride 900 true;

56− "time".components.library.planned = lib.mkOverride 900 true;

57− "alex".components.exes."alex".planned = lib.mkOverride 900 true;

58− "deepseq".components.library.planned = lib.mkOverride 900 true;

59− "base".components.library.planned = lib.mkOverride 900 true;

60− "integer-gmp".components.library.planned = lib.mkOverride 900 true;

61− "containers".components.library.planned = lib.mkOverride 900 true;

62− };

63− })

64− ];

65− }

materialized/bootstrap/ghc883/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/ghc883/happy-1.19.12/default.nixdeleted−56

@@ -1,56 +0,0 @@

1−{

2− pkgs = hackage:

3− {

4− packages = {

5− "array".revision = (((hackage."array")."0.5.4.0").revisions).default;

6− "mtl".revision = (((hackage."mtl")."2.2.2").revisions).default;

7− "ghc-prim".revision = (((hackage."ghc-prim")."0.5.3").revisions).default;

8− "base".revision = (((hackage."base")."4.13.0.0").revisions).default;

9− "rts".revision = (((hackage."rts")."1.0").revisions).default;

10− "transformers".revision = (((hackage."transformers")."0.5.6.2").revisions).default;

11− "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;

12− "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

13− "containers".revision = (((hackage."containers")."0.6.2.1").revisions).default;

14− };

15− compiler = {

16− version = "8.8.3";

17− nix-name = "ghc883";

18− packages = {

19− "array" = "0.5.4.0";

20− "mtl" = "2.2.2";

21− "ghc-prim" = "0.5.3";

22− "base" = "4.13.0.0";

23− "rts" = "1.0";

24− "transformers" = "0.5.6.2";

25− "deepseq" = "1.4.4.0";

26− "integer-gmp" = "1.0.2.0";

27− "containers" = "0.6.2.1";

28− };

29− };

30− };

31− extras = hackage:

32− { packages = { happy = ./.plan.nix/happy.nix; }; };

33− modules = [

34− ({ lib, ... }:

35− {

36− packages = {

37− "happy" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

38− };

39− })

40− ({ lib, ... }:

41− {

42− packages = {

43− "ghc-prim".components.library.planned = lib.mkOverride 900 true;

44− "array".components.library.planned = lib.mkOverride 900 true;

45− "rts".components.library.planned = lib.mkOverride 900 true;

46− "happy".components.exes."happy".planned = lib.mkOverride 900 true;

47− "mtl".components.library.planned = lib.mkOverride 900 true;

48− "transformers".components.library.planned = lib.mkOverride 900 true;

49− "deepseq".components.library.planned = lib.mkOverride 900 true;

50− "base".components.library.planned = lib.mkOverride 900 true;

51− "integer-gmp".components.library.planned = lib.mkOverride 900 true;

52− "containers".components.library.planned = lib.mkOverride 900 true;

53− };

54− })

55− ];

56− }

materialized/bootstrap/ghc883/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/ghc883/hscolour/default.nixdeleted−47

@@ -1,47 +0,0 @@

1−{

2− pkgs = hackage:

3− {

4− packages = {

5− "array".revision = (((hackage."array")."0.5.4.0").revisions).default;

6− "ghc-prim".revision = (((hackage."ghc-prim")."0.5.3").revisions).default;

7− "base".revision = (((hackage."base")."4.13.0.0").revisions).default;

8− "rts".revision = (((hackage."rts")."1.0").revisions).default;

9− "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;

10− "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

11− "containers".revision = (((hackage."containers")."0.6.2.1").revisions).default;

12− };

13− compiler = {

14− version = "8.8.3";

15− nix-name = "ghc883";

16− packages = {

17− "array" = "0.5.4.0";

18− "ghc-prim" = "0.5.3";

19− "base" = "4.13.0.0";

20− "rts" = "1.0";

21− "deepseq" = "1.4.4.0";

22− "integer-gmp" = "1.0.2.0";

23− "containers" = "0.6.2.1";

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− "ghc-prim".components.library.planned = lib.mkOverride 900 true;

36− "array".components.library.planned = lib.mkOverride 900 true;

37− "rts".components.library.planned = lib.mkOverride 900 true;

38− "hscolour".components.library.planned = lib.mkOverride 900 true;

39− "hscolour".components.exes."HsColour".planned = lib.mkOverride 900 true;

40− "deepseq".components.library.planned = lib.mkOverride 900 true;

41− "base".components.library.planned = lib.mkOverride 900 true;

42− "integer-gmp".components.library.planned = lib.mkOverride 900 true;

43− "containers".components.library.planned = lib.mkOverride 900 true;

44− };

45− })

46− ];

47− }

materialized/bootstrap/ghc884/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";

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/ghc884/alex/default.nixdeleted−65

@@ -1,65 +0,0 @@

1−{

2− pkgs = hackage:

3− {

4− packages = {

5− "array".revision = (((hackage."array")."0.5.4.0").revisions).default;

6− "bytestring".revision = (((hackage."bytestring")."0.10.10.1").revisions).default;