commit 7b5b5fe515d4abe9fbc081deba0d59e96d35a401 · pyrox.dev/nixpkgs

+1 -1

doc/release-notes/rl-2511.section.md

···

       46
       46
        
       

     

       47
       47
        
       - `conduwuit` was removed due to upstream ceasing development and deleting their repository. For existing data, a migration to `matrix-conduit`, `matrix-continuwuity` or `matrix-tuwunel` may be possible.

     

       48
       48
        
       

     

       49
       49
       -
       - The GHCJS 8.10.7, exposed via `haskell.compiler.ghcjs` and `haskell.compiler.ghcjs810`, has been removed. Downstream users should migrate their projects to the new JavaScript backend of GHC proper which can be used via `pkgsCross.ghcjs` from Nixpkgs.

     

       49
       49
       +
       - The GHCJS 8.10.7, exposed via `haskell.compiler.ghcjs` and `haskell.compiler.ghcjs810`, has been removed. Downstream users should migrate their projects to the new JavaScript backend of GHC proper which can be used via `pkgsCross.ghcjs` from Nixpkgs. Haskell packaging code, like `haskellPackages.mkDerivation`, `ghcWithPackages` and `hoogleWithPackages`, also no longer supports GHCJS.

     

       50
       50
        
       

     

       51
       51
        
       - The `ghcInfo` and `controlPhases` functions have been removed from `haskell.lib.compose` and `haskell.lib`. They were unused and would return incorrect results.

     

       52
       52

+6 -27

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

···

       16
       16
        
       let

     

       17
       17
        
         isCross = stdenv.buildPlatform != stdenv.hostPlatform;

     

       18
       18
        
       

     

       19
       19
       -
         # Note that ghc.isGhcjs != stdenv.hostPlatform.isGhcjs.

     

       20
       20
       -
         # ghc.isGhcjs implies that we are using ghcjs, a project separate from GHC.

     

       21
       21
       -
         # (mere) stdenv.hostPlatform.isGhcjs means that we are using GHC's JavaScript

     

       22
       22
       -
         # backend. The latter is a normal cross compilation backend and needs little

     

       23
       23
       -
         # special accommodation.

     

       24
       24
       -
         outputsJS = ghc.isGhcjs or false || stdenv.hostPlatform.isGhcjs;

     

       25
       25
       -
       

     

       26
       19
        
         # Pass the "wrong" C compiler rather than none at all so packages that just

     

       27
       20
        
         # use the C preproccessor still work, see

     

       28
       21
        
         # https://github.com/haskell/cabal/issues/6466 for details.

     
···

       47
       40
        
       

     

       48
       41
        
       {

     

       49
       42
        
         pname,

     

       50
       50
       -
         dontStrip ? outputsJS,

     

       43
       43
       +
         dontStrip ? stdenv.hostPlatform.isGhcjs,

     

       51
       44
        
         version,

     

       52
       45
        
         revision ? null,

     

       53
       46
        
         sha256 ? null,

     
···

       80
       73
        
         doHaddockQuickjump ? doHoogle,

     

       81
       74
        
         doInstallIntermediates ? false,

     

       82
       75
        
         editedCabalFile ? null,

     

       83
       83
       -
         enableLibraryProfiling ? !outputsJS,

     

       76
       76
       +
         enableLibraryProfiling ? !stdenv.hostPlatform.isGhcjs,

     

       84
       77
        
         enableExecutableProfiling ? false,

     

       85
       78
        
         profilingDetail ? "exported-functions",

     

       86
       79
        
         # TODO enable shared libs for cross-compiling

     
···

       90
       83
        
           && (ghc.enableShared or false)

     

       91
       84
        
           && !stdenv.hostPlatform.useAndroidPrebuilt, # TODO: figure out why /build leaks into RPATH

     

       92
       85
        
         enableDeadCodeElimination ? (!stdenv.hostPlatform.isDarwin), # TODO: use -dead_strip for darwin

     

       93
       93
       -
         # Disabling this for ghcjs prevents this crash: https://gitlab.haskell.org/ghc/ghc/-/issues/23235

     

       86
       86
       +
         # Disabling this for JS prevents this crash: https://gitlab.haskell.org/ghc/ghc/-/issues/23235

     

       94
       87
        
         enableStaticLibraries ?

     

       95
       88
        
           !(stdenv.hostPlatform.isWindows || stdenv.hostPlatform.isWasm || stdenv.hostPlatform.isGhcjs),

     

       96
       89
        
         enableHsc2hsViaAsm ? stdenv.hostPlatform.isWindows,

     
···

       228
       221
        
           optionalAttrs

     

       229
       222
        
           ;

     

       230
       223
        
       

     

       231
       231
       -
         isGhcjs = ghc.isGhcjs or false;

     

       232
       224
        
         isHaLVM = ghc.isHaLVM or false;

     

       233
       225
        
       

     

       234
       226
        
         # GHC used for building Setup.hs

     

       235
       227
        
         #

     

       236
       228
        
         # Same as our GHC, unless we're cross, in which case it is native GHC with the

     

       237
       237
       -
         # same version, or ghcjs, in which case its the ghc used to build ghcjs.

     

       229
       229
       +
         # same version.

     

       238
       230
        
         nativeGhc = buildHaskellPackages.ghc;

     

       239
       231
        
       

     

       240
       232
        
         # the target dir for haddock documentation

     
···

       358
       350
        
           (enableFeature (!dontStrip) "library-stripping")

     

       359
       351
        
           (enableFeature (!dontStrip) "executable-stripping")

     

       360
       352
        
         ]

     

       361
       361
       -
         ++ optionals isGhcjs [

     

       362
       362
       -
           "--ghcjs"

     

       363
       363
       -
         ]

     

       364
       353
        
         ++ optionals isCross (

     

       365
       354
        
           [

     

       366
       355
        
             "--configure-option=--host=${stdenv.hostPlatform.config}"

     
···

       490
       479
        
       

     

       491
       480
        
         setupCommand = "./Setup";

     

       492
       481
        
       

     

       493
       493
       -
         ghcCommand' = if isGhcjs then "ghcjs" else "ghc";

     

       482
       482
       +
         ghcCommand' = "ghc";

     

       494
       483
        
         ghcCommand = "${ghc.targetPrefix}${ghcCommand'}";

     

       495
       484
        
       

     

       496
       485
        
         ghcNameWithPrefix = "${ghc.targetPrefix}${ghc.haskellCompilerName}";

     
···

       519
       508
        
       

     

       520
       509
        
         intermediatesDir = "share/haskell/${ghc.version}/${pname}-${version}/dist";

     

       521
       510
        
       

     

       522
       522
       -
         # On old ghcjs, the jsexe directories are the output but on the js backend they seem to be treated as intermediates

     

       523
       511
        
         jsexe = rec {

     

       524
       524
       -
           shouldUseNode = isGhcjs;

     

       525
       512
        
           shouldAdd = stdenv.hostPlatform.isGhcjs && isExecutable;

     

       526
       513
        
           shouldCopy = shouldAdd && !doInstallIntermediates;

     

       527
       514
        
           shouldSymlink = shouldAdd && doInstallIntermediates;

     
···

       849
       836
        
                   ''

     

       850
       837
        
               }

     

       851
       838
        
       

     

       852
       852
       -
               ${optionalString jsexe.shouldUseNode ''

     

       853
       853
       -
                 for exeDir in "${binDir}/"*.jsexe; do

     

       854
       854
       -
                   exe="''${exeDir%.jsexe}"

     

       855
       855
       -
                   printWords '#!${nodejs}/bin/node' > "$exe"

     

       856
       856
       -
                   echo >> "$exe"

     

       857
       857
       -
                   cat "$exeDir/all.js" >> "$exe"

     

       858
       858
       -
                   chmod +x "$exe"

     

       859
       859
       -
                 done

     

       860
       860
       -
               ''}

     

       839
       839
       +
       

     

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

     

       862
       841
        
       

     

       863
       842
        
               ${optionalString jsexe.shouldCopy ''

+3 -13

pkgs/development/haskell-modules/hoogle.nix

···

       23
       23
        
         packages = selectPackages haskellPackages;

     

       24
       24
        
       

     

       25
       25
        
         wrapper = ./hoogle-local-wrapper.sh;

     

       26
       26
       -
         isGhcjs = ghc.isGhcjs or false;

     

       27
       27
       -
         opts = lib.optionalString;

     

       28
       28
       -
         haddockExe = if !isGhcjs then "haddock" else "haddock-ghcjs";

     

       29
       29
       -
         ghcDocLibDir = if !isGhcjs then ghc.doc + "/share/doc/ghc*/html/libraries" else ghc + "/doc/lib";

     

       30
       30
       -
         # On GHCJS, use a stripped down version of GHC's prologue.txt

     

       31
       31
       -
         prologue =

     

       32
       32
       -
           if !isGhcjs then

     

       33
       33
       -
             "${ghcDocLibDir}/prologue.txt"

     

       34
       34
       -
           else

     

       35
       35
       -
             writeText "ghcjs-prologue.txt" ''

     

       36
       36
       -
               This index includes documentation for many Haskell modules.

     

       37
       37
       -
             '';

     

       26
       26
       +
         haddockExe = "haddock";

     

       27
       27
       +
         ghcDocLibDir = ghc.doc + "/share/doc/ghc*/html/libraries";

     

       28
       28
       +
         prologue = "${ghcDocLibDir}/prologue.txt";

     

       38
       29
        
       

     

       39
       30
        
         docPackages =

     

       40
       31
        
           lib.closePropagation

     
···

       84
       75
        
           echo importing builtin packages

     

       85
       76
        
           for docdir in ${ghcDocLibDir}"/"*; do

     

       86
       77
        
             name="$(basename $docdir)"

     

       87
       87
       -
             ${opts isGhcjs ''docdir="$docdir/html"''}

     

       88
       78
        
             if [[ -d $docdir ]]; then

     

       89
       79
        
               ln -sfn $docdir $out/share/doc/hoogle/$name

     

       90
       80
        
             fi

+28 -45

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

···

       13
       13
        
         installDocumentation ? true,

     

       14
       14
        
         hoogleWithPackages,

     

       15
       15
        
         postBuild ? "",

     

       16
       16
       -
         ghcLibdir ? null, # only used by ghcjs, when resolving plugins

     

       17
       16
        
       }:

     

       18
       17
        
       

     

       19
       18
        
       # This argument is a function which selects a list of Haskell packages from any

     
···

       51
       50
        
       

     

       52
       51
        
         packages = selectPackages haskellPackages ++ [ hoogleWithPackages' ];

     

       53
       52
        
       

     

       54
       54
       -
         isGhcjs = ghc.isGhcjs or false;

     

       55
       53
        
         isHaLVM = ghc.isHaLVM or false;

     

       56
       56
       -
         ghcCommand' = if isGhcjs then "ghcjs" else "ghc";

     

       54
       54
       +
         ghcCommand' = "ghc";

     

       57
       55
        
         ghcCommand = "${ghc.targetPrefix}${ghcCommand'}";

     

       58
       56
        
         ghcCommandCaps = lib.toUpper ghcCommand';

     

       59
       57
        
         libDir =

     
···

       77
       75
        
         );

     

       78
       76
        
       in

     

       79
       77
        
       

     

       80
       80
       -
       assert ghcLibdir != null -> (ghc.isGhcjs or false);

     

       81
       81
       -
       

     

       82
       78
        
       if paths == [ ] && !useLLVM then

     

       83
       79
        
         ghc

     

       84
       80
        
       else

     
···

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

     

       102
       98
        
                   --set "NIX_${ghcCommandCaps}_DOCDIR" "${docDir}"                  \

     

       103
       99
        
                   --set "NIX_${ghcCommandCaps}_LIBDIR" "${libDir}"                  \

     

       104
       104
       -
                   ${

     

       105
       105
       -
                     lib.optionalString (ghc.isGhcjs or false) ''--set NODE_PATH "${ghc.socket-io}/lib/node_modules"''

     

       106
       106
       -
                   } \

     

       107
       100
        
                   ${lib.optionalString useLLVM ''--prefix "PATH" ":" "${llvm}"''}

     

       108
       101
        
               fi

     

       109
       102
        
             done

     
···

       136
       129
        
             fi

     

       137
       130
        
       

     

       138
       131
        
           ''

     

       139
       139
       -
           + (lib.optionalString (stdenv.targetPlatform.isDarwin && !isGhcjs && !stdenv.targetPlatform.isiOS)

     

       140
       140
       -
             ''

     

       141
       141
       -
               # Work around a linker limit in macOS Sierra (see generic-builder.nix):

     

       142
       142
       -
               local packageConfDir="${packageCfgDir}";

     

       143
       143
       -
               local dynamicLinksDir="$out/lib/links";

     

       144
       144
       -
               mkdir -p $dynamicLinksDir

     

       145
       145
       -
               # Clean up the old links that may have been (transitively) included by

     

       146
       146
       -
               # symlinkJoin:

     

       147
       147
       -
               rm -f $dynamicLinksDir/*

     

       132
       132
       +
           + (lib.optionalString (stdenv.targetPlatform.isDarwin && !stdenv.targetPlatform.isiOS) ''

     

       133
       133
       +
             # Work around a linker limit in macOS Sierra (see generic-builder.nix):

     

       134
       134
       +
             local packageConfDir="${packageCfgDir}";

     

       135
       135
       +
             local dynamicLinksDir="$out/lib/links";

     

       136
       136
       +
             mkdir -p $dynamicLinksDir

     

       137
       137
       +
             # Clean up the old links that may have been (transitively) included by

     

       138
       138
       +
             # symlinkJoin:

     

       139
       139
       +
             rm -f $dynamicLinksDir/*

     

       148
       140
        
       

     

       149
       149
       -
               dynamicLibraryDirs=()

     

       141
       141
       +
             dynamicLibraryDirs=()

     

       150
       142
        
       

     

       151
       151
       -
               for pkg in $($out/bin/ghc-pkg list --simple-output); do

     

       152
       152
       -
                 dynamicLibraryDirs+=($($out/bin/ghc-pkg --simple-output field "$pkg" dynamic-library-dirs))

     

       153
       153
       -
               done

     

       143
       143
       +
             for pkg in $($out/bin/ghc-pkg list --simple-output); do

     

       144
       144
       +
               dynamicLibraryDirs+=($($out/bin/ghc-pkg --simple-output field "$pkg" dynamic-library-dirs))

     

       145
       145
       +
             done

     

       154
       146
        
       

     

       155
       155
       -
               for dynamicLibraryDir in $(echo "''${dynamicLibraryDirs[@]}" | tr ' ' '\n' | sort -u); do

     

       156
       156
       -
                 echo "Linking $dynamicLibraryDir/*.dylib from $dynamicLinksDir"

     

       157
       157
       -
                 find "$dynamicLibraryDir" -name '*.dylib' -exec ln -s {} "$dynamicLinksDir" \;

     

       158
       158
       -
               done

     

       147
       147
       +
             for dynamicLibraryDir in $(echo "''${dynamicLibraryDirs[@]}" | tr ' ' '\n' | sort -u); do

     

       148
       148
       +
               echo "Linking $dynamicLibraryDir/*.dylib from $dynamicLinksDir"

     

       149
       149
       +
               find "$dynamicLibraryDir" -name '*.dylib' -exec ln -s {} "$dynamicLinksDir" \;

     

       150
       150
       +
             done

     

       159
       151
        
       

     

       160
       160
       -
               for f in $packageConfDir/*.conf; do

     

       161
       161
       -
                 # Initially, $f is a symlink to a read-only file in one of the inputs

     

       162
       162
       -
                 # (as a result of this symlinkJoin derivation).

     

       163
       163
       -
                 # Replace it with a copy whose dynamic-library-dirs points to

     

       164
       164
       -
                 # $dynamicLinksDir

     

       165
       165
       -
                 cp $f $f-tmp

     

       166
       166
       -
                 rm $f

     

       167
       167
       -
                 sed "N;s,dynamic-library-dirs:\s*.*\n,dynamic-library-dirs: $dynamicLinksDir\n," $f-tmp > $f

     

       168
       168
       -
                 rm $f-tmp

     

       169
       169
       -
               done

     

       170
       170
       -
             ''

     

       171
       171
       -
           )

     

       152
       152
       +
             for f in $packageConfDir/*.conf; do

     

       153
       153
       +
               # Initially, $f is a symlink to a read-only file in one of the inputs

     

       154
       154
       +
               # (as a result of this symlinkJoin derivation).

     

       155
       155
       +
               # Replace it with a copy whose dynamic-library-dirs points to

     

       156
       156
       +
               # $dynamicLinksDir

     

       157
       157
       +
               cp $f $f-tmp

     

       158
       158
       +
               rm $f

     

       159
       159
       +
               sed "N;s,dynamic-library-dirs:\s*.*\n,dynamic-library-dirs: $dynamicLinksDir\n," $f-tmp > $f

     

       160
       160
       +
               rm $f-tmp

     

       161
       161
       +
             done

     

       162
       162
       +
           '')

     

       172
       163
        
           + ''

     

       173
       164
        
             ${lib.optionalString hasLibraries ''

     

       174
       165
        
               # GHC 8.10 changes.

     
···

       182
       173
        
       

     

       183
       174
        
               $out/bin/${ghcCommand}-pkg recache

     

       184
       175
        
             ''}

     

       185
       185
       -
             ${

     

       186
       186
       -
               # ghcjs will read the ghc_libdir file when resolving plugins.

     

       187
       187
       -
               lib.optionalString (isGhcjs && ghcLibdir != null) ''

     

       188
       188
       -
                 mkdir -p "${libDir}"

     

       189
       189
       -
                 rm -f "${libDir}/ghc_libdir"

     

       190
       190
       -
                 printf '%s' '${ghcLibdir}' > "${libDir}/ghc_libdir"

     

       191
       191
       -
               ''

     

       192
       192
       -
             }

     

       193
       176
        
             $out/bin/${ghcCommand}-pkg check

     

       194
       177
        
           ''

     

       195
       178
        
           + postBuild;