commit 7993e8790f45f1548adaed2782e9bb83d1dd9df8 · pyrox.dev/nixpkgs

+1 -1

pkgs/development/compilers/ghc/7.10.2.nix

···

       34
       34
        
           sha256 = "1x8m4rp2v7ydnrz6z9g8x7z3x3d3pxhv2pixy7i7hkbqbdsp7kal";

     

       35
       35
        
         };

     

       36
       36
        
       

     

       37
       37
       -
         buildInputs = [ ghc perl libxml2 libxslt docbook_xsl docbook_xml_dtd_45 docbook_xml_dtd_42 hscolour ];

     

       37
       37
       +
         buildInputs = [ ghc perl libxml2 libxslt docbook_xsl docbook_xml_dtd_45 docbook_xml_dtd_42 (stdenv.lib.getBin hscolour) ];

     

       38
       38
        
       

     

       39
       39
        
         patches = [ ./relocation.patch ];

     

       40
       40

+1 -1

pkgs/development/compilers/ghc/7.10.3.nix

···

       30
       30
        
           ./relocation.patch

     

       31
       31
        
         ];

     

       32
       32
        
       

     

       33
       33
       -
         buildInputs = [ ghc perl libxml2 libxslt docbook_xsl docbook_xml_dtd_45 docbook_xml_dtd_42 hscolour ];

     

       33
       33
       +
         buildInputs = [ ghc perl libxml2 libxslt docbook_xsl docbook_xml_dtd_45 docbook_xml_dtd_42 (stdenv.lib.getBin hscolour) ];

     

       34
       34
        
       

     

       35
       35
        
         enableParallelBuilding = true;

     

       36
       36

+1 -1

pkgs/development/compilers/ghc/8.0.2.nix

···

       23
       23
        
           ++ stdenv.lib.optional stdenv.isLinux ./ghc-no-madv-free.patch

     

       24
       24
        
           ++ stdenv.lib.optional stdenv.isDarwin ./ghc-8.0.2-no-cpp-warnings.patch;

     

       25
       25
        
       

     

       26
       26
       -
         buildInputs = [ ghc perl hscolour sphinx ];

     

       26
       26
       +
         buildInputs = [ ghc perl (stdenv.lib.getBin hscolour) sphinx ];

     

       27
       27
        
       

     

       28
       28
        
         enableParallelBuilding = true;

     

       29
       29

+1 -1

pkgs/development/compilers/ghc/8.2.1.nix

···

       10
       10
        
       let

     

       11
       11
        
         inherit (bootPkgs) ghc;

     

       12
       12
        
         version = "8.2.1";

     

       13
       13
       -
       

     

       13
       13
       +
         preReleaseName = "ghc-8.2.1";

     

       14
       14
        
         commonBuildInputs = [ alex autoconf automake ghc happy hscolour perl python3 sphinx ];

     

       15
       15
        
         commonPreConfigure =  ''

     

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

+1 -1

pkgs/development/compilers/ghc/head.nix

···

       11
       11
        
       let

     

       12
       12
        
         inherit (bootPkgs) ghc;

     

       13
       13
        
       

     

       14
       14
       -
         commonBuildInputs = [ ghc perl autoconf automake happy alex python3 ];

     

       14
       14
       +
         commonBuildInputs = [ ghc perl autoconf automake (stdenv.lib.getBin happy) (stdenv.lib.getBin alex) python3 ];

     

       15
       15
        
       

     

       16
       16
        
         rev = "14457cf6a50f708eecece8f286f08687791d51f7";

     

       17
       17

+1 -1

pkgs/development/compilers/ghcjs/base.nix

···

       113
       113
        
           lens optparse-applicative parallel safe shelly split

     

       114
       114
        
           stringsearch syb system-fileio system-filepath tar terminfo text-binary

     

       115
       115
        
           unordered-containers vector wl-pprint-text yaml

     

       116
       116
       -
           alex happy git gnumake autoconf automake libtool patch gmp

     

       116
       116
       +
           (stdenv.lib.getBin alex) (stdenv.lib.getBin happy) git gnumake autoconf automake libtool patch gmp

     

       117
       117
        
           base16-bytestring cryptohash executable-path haddock-api

     

       118
       118
        
           transformers-compat QuickCheck haddock hspec xhtml

     

       119
       119
        
           regex-posix libiconv

+2 -2

pkgs/development/compilers/halvm/2.4.0.nix

···

       20
       20
        
           sed -ie 's|ld |${targetPackages.stdenv.cc.bintools}/bin/ld |g' src/scripts/ldkernel.in

     

       21
       21
        
         '';

     

       22
       22
        
         configureFlags = stdenv.lib.optional (!enableIntegerSimple) [ "--enable-gmp" ];

     

       23
       23
       -
         propagatedNativeBuildInputs = [ alex happy ];

     

       23
       23
       +
         propagatedNativeBuildInputs = [ (stdenv.lib.getBin alex) (stdenv.lib.getBin happy) ];

     

       24
       24
        
         buildInputs =

     

       25
       25
       -
          let haskellPkgs = [ alex happy bootPkgs.hscolour bootPkgs.cabal-install bootPkgs.haddock bootPkgs.hpc

     

       25
       25
       +
          let haskellPkgs = [ (stdenv.lib.getBin alex) (stdenv.lib.getBin happy) (stdenv.lib.getBin bootPkgs.hscolour) bootPkgs.cabal-install bootPkgs.haddock bootPkgs.hpc

     

       26
       26
        
           ]; in [ bootPkgs.ghc

     

       27
       27
        
                   automake perl git targetPackages.stdenv.cc.bintools

     

       28
       28
        
                   autoconf xen zlib ncurses.dev

pkgs/development/haskell-modules/configuration-common.nix

···

       897
       897
        
         # Don't install internal mkReadme tool.

     

       898
       898
        
         hastache = overrideCabal super.hastache (drv: {

     

       899
       899
        
           doCheck = false;

     

       900
       900
       +
           enableSeparateBinOutput = false;

     

       900
       901
        
           postInstall = "rm $out/bin/mkReadme && rmdir $out/bin";

     

       901
       902
        
         });

     

       902
       903

+52 -1

pkgs/development/haskell-modules/configuration-nix.nix

···

       217
       217
        
       

     

       218
       218
        
         # wxc supports wxGTX >= 3.0, but our current default version points to 2.8.

     

       219
       219
        
         # http://hydra.cryp.to/build/1331287/log/raw

     

       220
       220
       -
         wxc = (addBuildDepend super.wxc self.split).override { wxGTK = pkgs.wxGTK30; };

     

       220
       220
       +
         wxc = (overrideCabal super.wxc (drv: {

     

       221
       221
       +
             buildDepends = (drv.buildDepends or []) ++ [self.split];

     

       222
       222
       +
             postInstall = "cp -v dist/build/libwxc.so.0.92.3.0 $lib/lib/libwxc.so";

     

       223
       223
       +
           })).override { wxGTK = pkgs.wxGTK30; };

     

       221
       224
        
         wxcore = super.wxcore.override { wxGTK = pkgs.wxGTK30; };

     

       222
       225
        
       

     

       223
       226
        
         # Test suite wants to connect to $DISPLAY.

     
···

       506
       509
        
       

     

       507
       510
        
         # Break cyclic reference that results in an infinite recursion.

     

       508
       511
        
         partial-semigroup = dontCheck super.partial-semigroup;

     

       512
       512
       +
       

     

       513
       513
       +
         # Alex has some weird files in /usr/share that create a cyclic ref with

     

       514
       514
       +
         # its bin dir.

     

       515
       515
       +
         alex = hasNoBinOutput super.alex;

     

       516
       516
       +
       

     

       517
       517
       +
         # Disable separate bin outputs for these specific packages that break with it.

     

       518
       518
       +
         H = hasNoBinOutput super.H;

     

       519
       519
       +
         cryptol = hasNoBinOutput super.cryptol;

     

       520
       520
       +
         hscolour = hasNoBinOutput super.hscolour;

     

       521
       521
       +
         sproxy = hasNoBinOutput super.sproxy;

     

       522
       522
       +
         sproxy2 = hasNoBinOutput super.sproxy2;

     

       523
       523
       +
         sproxy-web = hasNoBinOutput super.sproxy-web;

     

       524
       524
       +
         juandelacosa = hasNoBinOutput super.juandelacosa;

     

       525
       525
       +
         mywatch = hasNoBinOutput super.mywatch;

     

       526
       526
       +
         sugarhaskell = hasNoBinOutput super.sugarhaskell;

     

       527
       527
       +
         zerobin = hasNoBinOutput super.zerobin;

     

       528
       528
       +
       

     

       529
       529
       +
         git-annex = overrideCabal super.git-annex (drv: {

     

       530
       530
       +
           enableSeparateBinOutput = false;

     

       531
       531
       +
           enableSeparateEtcOutput = false;

     

       532
       532
       +
         });

     

       533
       533
       +
       

     

       534
       534
       +
         # Has extra data files which are referred to from the binary output,

     

       535
       535
       +
         # creating a store reference cycle. Putting data in separate output

     

       536
       536
       +
         # solves the problem.

     

       537
       537
       +
         happy = overrideCabal super.happy (drv: { enableSeparateDataOutput = true; });

     

       538
       538
       +
       

     

       539
       539
       +
         # Override a number of packages with specific references to $out in their

     

       540
       540
       +
         # derivations

     

       541
       541
       +
         stack = overrideCabal super.stack (drv: {

     

       542
       542
       +
           postInstall = ''

     

       543
       543
       +
             exe=$bin/bin/stack

     

       544
       544
       +
             mkdir -p $bin/share/bash-completion/completions

     

       545
       545
       +
             $exe --bash-completion-script $exe >$bin/share/bash-completion/completions/stack

     

       546
       546
       +
           '';

     

       547
       547
       +
         });

     

       548
       548
       +
         Agda = overrideCabal super.Agda (drv: {

     

       549
       549
       +
           postInstall = ''

     

       550
       550
       +
             files=("$out/share/"*"-ghc-"*"/Agda-"*"/lib/prim/Agda/"{Primitive.agda,Builtin"/"*.agda})

     

       551
       551
       +
             for f in "''${files[@]}" ; do

     

       552
       552
       +
               $bin/bin/agda $f

     

       553
       553
       +
             done

     

       554
       554
       +
             for f in "''${files[@]}" ; do

     

       555
       555
       +
               $bin/bin/agda -c --no-main $f

     

       556
       556
       +
             done

     

       557
       557
       +
             $bin/bin/agda-mode compile

     

       558
       558
       +
           '';

     

       559
       559
       +
         });

     

       509
       560
        
       

     

       510
       561
        
       }

+100 -22

pkgs/development/haskell-modules/generic-builder.nix

···

       56
       56
        
       , hardeningDisable ? lib.optional (ghc.isHaLVM or false) "all"

     

       57
       57
        
       , enableSeparateDataOutput ? false

     

       58
       58
        
       , enableSeparateDocOutput ? doHaddock

     

       59
       59
       +
       , enableSeparateBinOutput ? isExecutable

     

       60
       60
       +
       , outputsToInstall ? []

     

       61
       61
       +
       , enableSeparateLibOutput ? true

     

       62
       62
       +
       , enableSeparateEtcOutput ? (stdenv.lib.versionOlder "7.7" ghc.version)

     

       59
       63
        
       } @ args:

     

       60
       64
        
       

     

       61
       65
        
       assert editedCabalFile != null -> revision != null;

     
···

       79
       83
        
                               then "package-db"

     

       80
       84
        
                               else "package-conf";

     

       81
       85
        
       

     

       82
       82
       -
         # the target dir for haddock documentation

     

       83
       83
       -
         docdir = docoutput: docoutput + "/share/doc";

     

       84
       84
       -
       

     

       85
       86
        
         newCabalFileUrl = "http://hackage.haskell.org/package/${pname}-${version}/revision/${revision}.cabal";

     

       86
       87
        
         newCabalFile = fetchurl {

     

       87
       88
        
           url = newCabalFileUrl;

     
···

       95
       96
        
                          '';

     

       96
       97
        
       

     

       97
       98
        
         hasActiveLibrary = isLibrary && (enableStaticLibraries || enableSharedLibraries || enableLibraryProfiling);

     

       99
       99
       +
         hasLibOutput = enableSeparateLibOutput && hasActiveLibrary;

     

       100
       100
       +
         libDir = if hasLibOutput then "$lib/lib/${ghc.name}" else "$out/lib/${ghc.name}";

     

       101
       101
       +
         binDir = if enableSeparateBinOutput then "$bin/bin" else "$out/bin";

     

       102
       102
       +
         libexecDir = if enableSeparateBinOutput then "$libexec/bin" else "$out/libexec";

     

       103
       103
       +
         etcDir = if enableSeparateEtcOutput then "$etc/etc" else "$out/etc";

     

       104
       104
       +
         docDir = if enableSeparateDocOutput then "$doc/share/doc" else "$out/share/doc";

     

       105
       105
       +
         dataDir = if enableSeparateDataOutput then "$data/share/${ghc.name}" else "$out/share/${ghc.name}";

     

       98
       106
        
       

     

       99
       107
        
         # We cannot enable -j<n> parallelism for libraries because GHC is far more

     

       100
       108
        
         # likely to generate a non-determistic library ID in that case. Further

     
···

       113
       121
        
           stdenv.lib.optionalString isCross (" " + stdenv.lib.concatStringsSep " " crossCabalFlags);

     

       114
       122
        
       

     

       115
       123
        
         defaultConfigureFlags = [

     

       116
       116
       -
           "--verbose" "--prefix=$out" "--libdir=\\$prefix/lib/\\$compiler" "--libsubdir=\\$pkgid"

     

       117
       117
       -
           (optionalString enableSeparateDataOutput "--datadir=$data/share/${ghc.name}")

     

       118
       118
       -
           (optionalString enableSeparateDocOutput "--docdir=${docdir "$doc"}")

     

       124
       124
       +
           "--verbose" "--prefix=$out"

     

       125
       125
       +
           # Binary directory has to be $bin/bin instead of just $bin: this

     

       126
       126
       +
           # is so that the package is added to the PATH when it's used as a

     

       127
       127
       +
           # build input. Sadly mkDerivation won't add inputs that don't have

     

       128
       128
       +
           # bin subdirectory.

     

       129
       129
       +
           "--bindir=${binDir}"

     

       130
       130
       +
           "--libdir=${libDir}" "--libsubdir=\\$pkgid"

     

       131
       131
       +
           "--libexecdir=${libexecDir}"

     

       132
       132
       +
           (optionalString (enableSeparateEtcOutput) "--sysconfdir=${etcDir}") # Old versions of cabal don't support this flag.

     

       133
       133
       +
           "--datadir=${dataDir}"

     

       134
       134
       +
           "--docdir=${docDir}"

     

       119
       135
        
           "--with-gcc=$CC" # Clang won't work without that extra information.

     

       120
       136
        
           "--package-db=$packageConfDir"

     

       121
       121
       -
           (optionalString (enableSharedExecutables && stdenv.isLinux) "--ghc-option=-optl=-Wl,-rpath=$out/lib/${ghc.name}/${pname}-${version}")

     

       137
       137
       +
           (optionalString (enableSharedExecutables && stdenv.isLinux) "--ghc-option=-optl=-Wl,-rpath=${libDir}/${pname}-${version}")

     

       122
       138
        
           (optionalString (enableSharedExecutables && stdenv.isDarwin) "--ghc-option=-optl=-Wl,-headerpad_max_install_names")

     

       123
       139
        
           (optionalString enableParallelBuilding "--ghc-option=-j$NIX_BUILD_CORES")

     

       124
       140
        
           (optionalString useCpphs "--with-cpphs=${cpphs}/bin/cpphs --ghc-options=-cpp --ghc-options=-pgmP${cpphs}/bin/cpphs --ghc-options=-optP--cpp")

     
···

       152
       168
        
         allPkgconfigDepends = pkgconfigDepends ++ libraryPkgconfigDepends ++ executablePkgconfigDepends ++

     

       153
       169
        
                               optionals doCheck testPkgconfigDepends ++ optionals doBenchmark benchmarkPkgconfigDepends;

     

       154
       170
        
       

     

       155
       155
       -
         nativeBuildInputs = optional (allPkgconfigDepends != []) pkgconfig ++

     

       156
       156
       -
                             buildTools ++ libraryToolDepends ++ executableToolDepends ++ [ removeReferencesTo ];

     

       171
       171
       +
         nativeBuildInputs = map stdenv.lib.getBin

     

       172
       172
       +
           ( optional (allPkgconfigDepends != []) pkgconfig

     

       173
       173
       +
             ++ buildTools ++ libraryToolDepends ++ executableToolDepends

     

       174
       174
       +
             ++ [ removeReferencesTo ]

     

       175
       175
       +
           );

     

       157
       176
        
         propagatedBuildInputs = buildDepends ++ libraryHaskellDepends ++ executableHaskellDepends;

     

       158
       177
        
         otherBuildInputs = setupHaskellDepends ++ extraLibraries ++ librarySystemDepends ++ executableSystemDepends ++

     

       159
       178
        
                            optionals (allPkgconfigDepends != []) allPkgconfigDepends ++

     
···

       182
       201
        
       stdenv.mkDerivation ({

     

       183
       202
        
         name = "${pname}-${version}";

     

       184
       203
        
       

     

       185
       185
       -
         outputs = if (args ? outputs) then args.outputs else ([ "out" ] ++ (optional enableSeparateDataOutput "data") ++ (optional enableSeparateDocOutput "doc"));

     

       204
       204
       +
         outputs = if (args ? outputs) then args.outputs else

     

       205
       205
       +
           (  (optional enableSeparateBinOutput "bin")

     

       206
       206
       +
           ++ (optional enableSeparateBinOutput "libexec")

     

       207
       207
       +
           ++ [ "out" ]

     

       208
       208
       +
           ++ (optional enableSeparateDataOutput "data")

     

       209
       209
       +
           ++ (optional enableSeparateDocOutput "doc")

     

       210
       210
       +
           ++ (optional enableSeparateEtcOutput "etc")

     

       211
       211
       +
           ++ (optional hasLibOutput "lib")

     

       212
       212
       +
           );

     

       186
       213
        
         setOutputFlags = false;

     

       187
       214
        
       

     

       188
       215
        
         pos = builtins.unsafeGetAttrPos "pname" args;

     
···

       206
       233
        
       

     

       207
       234
        
         postPatch = optionalString jailbreak ''

     

       208
       235
        
           echo "Run jailbreak-cabal to lift version restrictions on build inputs."

     

       209
       209
       -
           ${jailbreak-cabal}/bin/jailbreak-cabal ${pname}.cabal

     

       236
       236
       +
           ${stdenv.lib.getBin jailbreak-cabal}/bin/jailbreak-cabal ${pname}.cabal

     

       210
       237
        
         '' + postPatch;

     

       211
       238
        
       

     

       212
       239
        
         setupCompilerEnvironmentPhase = ''

     
···

       214
       241
        
       

     

       215
       242
        
           echo "Build with ${ghc}."

     

       216
       243
        
           export PATH="${ghc}/bin:$PATH"

     

       217
       217
       -
           ${optionalString (hasActiveLibrary && hyperlinkSource) "export PATH=${hscolour}/bin:$PATH"}

     

       244
       244
       +
           ${optionalString (hasActiveLibrary && hyperlinkSource) "export PATH=${stdenv.lib.getBin hscolour}/bin:$PATH"}

     

       218
       245
        
       

     

       219
       246
        
           packageConfDir="$TMPDIR/package.conf.d"

     

       220
       247
        
           mkdir -p $packageConfDir

     
···

       241
       268
        
           #

     

       242
       269
        
           # Create a local directory with symlinks of the *.dylib (macOS shared

     

       243
       270
        
           # libraries) from all the dependencies.

     

       244
       244
       -
           local dynamicLinksDir="$out/lib/links"

     

       271
       271
       +
           local dynamicLinksDir="${libDir}/links"

     

       245
       272
        
           mkdir -p $dynamicLinksDir

     

       246
       273
        
           for d in $(grep dynamic-library-dirs "$packageConfDir/"*|awk '{print $2}'); do

     

       247
       274
        
             ln -s "$d/"*.dylib $dynamicLinksDir

     
···

       313
       340
        
       

     

       314
       341
        
           ${if !hasActiveLibrary then "${setupCommand} install" else ''

     

       315
       342
        
             ${setupCommand} copy

     

       316
       316
       -
             local packageConfDir="$out/lib/${ghc.name}/package.conf.d"

     

       343
       343
       +
             local packageConfDir="${libDir}/package.conf.d"

     

       317
       344
        
             local packageConfFile="$packageConfDir/${pname}-${version}.conf"

     

       318
       345
        
             mkdir -p "$packageConfDir"

     

       319
       346
        
             ${setupCommand} register --gen-pkg-config=$packageConfFile

     
···

       321
       348
        
             mv $packageConfFile $packageConfDir/$pkgId.conf

     

       322
       349
        
           ''}

     

       323
       350
        
           ${optionalString isGhcjs ''

     

       324
       324
       -
             for exeDir in "$out/bin/"*.jsexe; do

     

       351
       351
       +
             for exeDir in "${binDir}/"*.jsexe; do

     

       325
       352
        
               exe="''${exeDir%.jsexe}"

     

       326
       353
        
               printWords '#!${nodejs}/bin/node' > "$exe"

     

       327
       354
        
               cat "$exeDir/all.js" >> "$exe"

     
···

       330
       357
        
           ''}

     

       331
       358
        
           ${optionalString doCoverage "mkdir -p $out/share && cp -r dist/hpc $out/share"}

     

       332
       359
        
           ${optionalString (enableSharedExecutables && isExecutable && !isGhcjs && stdenv.isDarwin && stdenv.lib.versionOlder ghc.version "7.10") ''

     

       333
       333
       -
             for exe in "$out/bin/"* ; do

     

       334
       334
       -
               install_name_tool -add_rpath "$out/lib/ghc-${ghc.version}/${pname}-${version}" "$exe"

     

       360
       360
       +
             for exe in "${binDir}/"* ; do

     

       361
       361
       +
               install_name_tool -add_rpath "${libDir}/${pname}-${version}" "$exe"

     

       335
       362
        
             done

     

       336
       363
        
           ''}

     

       337
       364
        
       

     

       338
       365
        
           ${optionalString enableSeparateDocOutput ''

     

       339
       339
       -
           for x in ${docdir "$doc"}/html/src/*.html; do

     

       340
       340
       -
             remove-references-to -t $out $x

     

       366
       366
       +
           # Remove references back to $out but also back to $lib if we have

     

       367
       367
       +
           # docs. $lib is needed as it stores path to haddock interfaces in the

     

       368
       368
       +
           # conf file which creates a cycle if docs refer back to library

     

       369
       369
       +
           # path.

     

       370
       370
       +
           mkdir -p ${docDir}

     

       371
       371
       +
       

     

       372
       372
       +
           for x in ${docDir}/html/src/*.html; do

     

       373
       373
       +
             remove-references-to -t $out -t ${libDir} -t ${binDir} ${optionalString enableSeparateDataOutput "-t $data"} $x

     

       341
       374
        
           done

     

       342
       342
       -
           mkdir -p $doc

     

       375
       375
       +
           ''}

     

       376
       376
       +
       

     

       377
       377
       +
           ${optionalString hasLibOutput ''

     

       378
       378
       +
           # Even if we don't have binary output for the package, things like

     

       379
       379
       +
           # Paths files will embed paths to bin/libexec directories in themselves

     

       380
       380
       +
           # which results in .lib <-> $out cyclic store reference. We

     

       381
       381
       +
           # therefore patch out the paths from separate library if we don't have

     

       382
       382
       +
           # separate bin output too.

     

       383
       383
       +
           #

     

       384
       384
       +
           # If we _do_ have separate bin and lib outputs, we may still be in

     

       385
       385
       +
           # trouble in case of shared executables: executable contains path to

     

       386
       386
       +
           # .lib, .lib contains path (through Paths) to .bin and we have a

     

       387
       387
       +
           # cycle.

     

       388
       388
       +
           #

     

       389
       389
       +
           # Lastly we have to deal with references from .lib back into

     

       390
       390
       +
           # $out/share if we're not splitting out data directory.

     

       391
       391
       +
           #

     

       392
       392
       +
           # It may happen that we have hasLibOutput set but the library

     

       393
       393
       +
           # directory was not created: this happens in the case that library

     

       394
       394
       +
           # section is not exposing any modules. See "fail" package for an

     

       395
       395
       +
           # example where no modules are exposed for GHC >= 8.0.

     

       396
       396
       +
           if [ -d ${libDir} ]; then

     

       397
       397
       +
             find ${libDir} -type f -exec \

     

       398
       398
       +
               remove-references-to -t ${binDir} -t ${libexecDir} "{}" \;

     

       399
       399
       +
           fi

     

       400
       400
       +
           ''}

     

       401
       401
       +
       

     

       402
       402
       +
           ${optionalString (hasLibOutput && ! enableSeparateDocOutput) ''

     

       403
       403
       +
           # If we don't have separate docs, we have to patch out the ref to

     

       404
       404
       +
           # docs in package conf. This will likely break Haddock

     

       405
       405
       +
           # cross-package links but is necessary to break store cycle…

     

       406
       406
       +
           find ${libDir}/ -type f -name '*.conf' -exec \

     

       407
       407
       +
             remove-references-to -t ${docDir} "{}" \;

     

       343
       408
        
           ''}

     

       344
       344
       -
           ${optionalString enableSeparateDataOutput "mkdir -p $data"}

     

       409
       409
       +
       

     

       410
       410
       +
           ${optionalString (hasLibOutput && ! enableSeparateDataOutput) ''

     

       411
       411
       +
           # Just like for doc output path in $out potentially landing in

     

       412
       412
       +
           # *.conf, we have to also remove the data directory so that it

     

       413
       413
       +
           # doesn't appear under data-dir field creating a cycle.

     

       414
       414
       +
           find ${libDir}/ -type f -exec echo Removing ${dataDir} refs from "{}" \;

     

       415
       415
       +
           find ${libDir}/ -type f -exec \

     

       416
       416
       +
             remove-references-to -t ${dataDir} "{}" \;

     

       417
       417
       +
           ''}

     

       418
       418
       +
       

     

       419
       419
       +
           ${optionalString enableSeparateDataOutput "mkdir -p ${dataDir}"}

     

       420
       420
       +
           ${optionalString enableSeparateBinOutput "mkdir -p ${binDir} ${libexecDir}"}

     

       421
       421
       +
           ${optionalString enableSeparateEtcOutput "mkdir -p ${etcDir}"}

     

       345
       422
        
       

     

       346
       423
        
           runHook postInstall

     

       347
       424
        
         '';

     
···

       358
       435
        
           # the directory containing the haddock documentation.

     

       359
       436
        
           # `null' if no haddock documentation was built.

     

       360
       437
        
           # TODO: fetch the self from the fixpoint instead

     

       361
       361
       -
           haddockDir = self: if doHaddock then "${docdir self.doc}/html" else null;

     

       438
       438
       +
           haddockDir = self: if doHaddock then "${docDir}/html" else null;

     

       362
       439
        
       

     

       363
       440
        
           env = stdenv.mkDerivation {

     

       364
       441
        
             name = "interactive-${pname}-${version}-environment";

     
···

       386
       463
        
                // optionalAttrs (description != "")  { inherit description; }

     

       387
       464
        
                // optionalAttrs (maintainers != [])  { inherit maintainers; }

     

       388
       465
        
                // optionalAttrs (hydraPlatforms != platforms) { inherit hydraPlatforms; }

     

       466
       466
       +
                // optionalAttrs (outputsToInstall != []) { inherit outputsToInstall; }

     

       389
       467
        
                ;

     

       390
       468
        
       

     

       391
       469
        
       }

pkgs/development/haskell-modules/lib.nix

···

       147
       147
        
         overrideSrc = drv: { src, version ? drv.version }:

     

       148
       148
        
           overrideCabal drv (_: { inherit src version; editedCabalFile = null; });

     

       149
       149
        
       

     

       150
       150
       +
         hasNoBinOutput = drv: overrideCabal drv (drv: { enableSeparateBinOutput = false; });

     

       151
       151
       +
       

     

       152
       152
       +
         installOutputs = drv: outputs: overrideCabal drv

     

       153
       153
       +
           (drv: { outputsToInstall = outputs; });

     

       150
       154
        
       }

pkgs/development/haskell-modules/make-package-set.nix

···

       44
       44
        
             isLibrary = false;

     

       45
       45
        
             doHaddock = false;

     

       46
       46
        
             hyperlinkSource = false;      # Avoid depending on hscolour for this build.

     

       47
       47
       +
             enableSeparateEtcOutput = false; # The flag to support this is missing in old versions of cabal.

     

       47
       48
        
             postFixup = "rm -rf $out/lib $out/share $out/nix-support";

     

       48
       49
        
           });

     

       49
       50
        
           cpphs = overrideCabal (self.cpphs.overrideScope (self: super: {

+1 -1

pkgs/development/haskell-modules/with-packages-wrapper.nix

···

       43
       43
        
         libDir        = if isHaLVM then "$out/lib/HaLVM-${ghc.version}" else "$out/lib/${ghcCommand}-${ghc.version}";

     

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

     

       45
       45
        
         packageCfgDir = "${libDir}/package.conf.d";

     

       46
       46
       -
         paths         = lib.filter (x: x ? isHaskellLibrary) (lib.closePropagation packages);

     

       46
       46
       +
         paths         = map lib.getLib (lib.filter (x: x ? isHaskellLibrary) (lib.closePropagation packages));

     

       47
       47
        
         hasLibraries  = lib.any (x: x.isHaskellLibrary) paths;

     

       48
       48
        
         # CLang is needed on Darwin for -fllvm to work:

     

       49
       49
        
         # https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/code-generators.html

+5 -5

pkgs/top-level/all-packages.nix

···

       830
       830
        
           enableSharedExecutables = false;

     

       831
       831
        
           executableToolDepends = [ makeWrapper ];

     

       832
       832
        
           postInstall = ''

     

       833
       833
       -
             exe=$out/libexec/${drv.pname}-${drv.version}/${drv.pname}

     

       834
       834
       -
             install -D $out/bin/${drv.pname} $exe

     

       835
       835
       -
             rm -rf $out/{bin,lib,share}

     

       836
       836
       -
             makeWrapper $exe $out/bin/${drv.pname} \

     

       833
       833
       +
             exe=$libexec/bin/${drv.pname}-${drv.version}/${drv.pname}

     

       834
       834
       +
             install -D $bin/bin/${drv.pname} $exe

     

       835
       835
       +
             rm -rf $bin/bin $out/lib $out/share

     

       836
       836
       +
             makeWrapper $exe $bin/bin/${drv.pname} \

     

       837
       837
        
               --prefix PATH ":" "${nix}/bin" \

     

       838
       838
        
               --prefix PATH ":" "${nix-prefetch-scripts}/bin"

     

       839
       839
        
             mkdir -p $out/share/{bash-completion/completions,zsh/vendor-completions,fish/completions}

     
···

       847
       847
        
           executableToolDepends = [ makeWrapper ];

     

       848
       848
        
           postInstall = ''

     

       849
       849
        
             wrapProgram $out/bin/stack2nix \

     

       850
       850
       -
               --prefix PATH ":" "${git}/bin:${cabal2nix}/bin:${cabal-install}/bin:${stack}/bin"

     

       850
       850
       +
               ${lib.makeBinPath [ git cabal2nix cabal-install stack ]}

     

       851
       851
        
           '';

     

       852
       852
        
         });

     

       853
       853