commit bde196dde968e4bf591599beb92e135f1f178d14 · pyrox.dev/nixpkgs

+21 -8

lib/customisation.nix

···

       278
       278
        
               };

     

       279
       279
        
           in self;

     

       280
       280
        
       

     

       281
       281
       +
         /* backward compatibility with old uncurried form; deprecated */

     

       282
       282
       +
         makeScopeWithSplicing =

     

       283
       283
       +
           splicePackages: newScope: otherSplices: keep: extra: f:

     

       284
       284
       +
           makeScopeWithSplicing' {

     

       285
       285
       +
             inherit splicePackages newScope otherSplices keep extra f;

     

       286
       286
       +
           };

     

       287
       287
       +
       

     

       281
       288
        
         /* Like the above, but aims to support cross compilation. It's still ugly, but

     

       282
       289
        
            hopefully it helps a little bit. */

     

       283
       283
       -
         makeScopeWithSplicing = splicePackages: newScope: otherSplices: keep: extra: f:

     

       290
       290
       +
         makeScopeWithSplicing' =

     

       291
       291
       +
           { splicePackages

     

       292
       292
       +
           , newScope

     

       293
       293
       +
           }:

     

       294
       294
       +
           { otherSplices

     

       295
       295
       +
           , keep ? (_self: {})

     

       296
       296
       +
           , extra ? (_spliced0: {})

     

       297
       297
       +
           , f

     

       298
       298
       +
           }:

     

       284
       299
        
           let

     

       285
       300
        
             spliced0 = splicePackages {

     

       286
       301
        
               pkgsBuildBuild = otherSplices.selfBuildBuild;

     
···

       296
       311
        
               callPackage = newScope spliced; # == self.newScope {};

     

       297
       312
        
               # N.B. the other stages of the package set spliced in are *not*

     

       298
       313
        
               # overridden.

     

       299
       299
       -
               overrideScope = g: makeScopeWithSplicing

     

       300
       300
       -
                 splicePackages

     

       301
       301
       -
                 newScope

     

       302
       302
       -
                 otherSplices

     

       303
       303
       -
                 keep

     

       304
       304
       -
                 extra

     

       305
       305
       -
                 (lib.fixedPoints.extends g f);

     

       314
       314
       +
               overrideScope = g: (makeScopeWithSplicing'

     

       315
       315
       +
                 { inherit splicePackages newScope; }

     

       316
       316
       +
                 { inherit otherSplices keep extra;

     

       317
       317
       +
                   f = lib.fixedPoints.extends g f;

     

       318
       318
       +
                 });

     

       306
       319
        
               packages = f;

     

       307
       320
        
             };

     

       308
       321
        
           in self;

+1 -1

lib/default.nix

···

       112
       112
        
             noDepEntry fullDepEntry packEntry stringAfter;

     

       113
       113
        
           inherit (self.customisation) overrideDerivation makeOverridable

     

       114
       114
        
             callPackageWith callPackagesWith extendDerivation hydraJob

     

       115
       115
       -
             makeScope makeScopeWithSplicing;

     

       115
       115
       +
             makeScope makeScopeWithSplicing makeScopeWithSplicing';

     

       116
       116
        
           inherit (self.derivations) lazyDerivation;

     

       117
       117
        
           inherit (self.meta) addMetaAttrs dontDistribute setName updateName

     

       118
       118
        
             appendToName mapDerivationAttrset setPrio lowPrio lowPrioSet hiPrio

+6 -12

pkgs/desktops/xfce/default.nix

···

       2
       2
        
       , lib

     

       3
       3
        
       , pkgs

     

       4
       4
        
       , generateSplicesForMkScope

     

       5
       5
       -
       , makeScopeWithSplicing

     

       5
       5
       +
       , makeScopeWithSplicing'

     

       6
       6
        
       }:

     

       7
       7
        
       

     

       8
       8
       -
       let

     

       9
       9
       -
         keep = _self: { };

     

       10
       10
       -
         extra = _spliced0: { };

     

       11
       11
       -
       

     

       12
       12
       -
       in

     

       13
       13
       -
       makeScopeWithSplicing

     

       14
       14
       -
         (generateSplicesForMkScope "xfce")

     

       15
       15
       -
         keep

     

       16
       16
       -
         extra

     

       17
       17
       -
         (self:

     

       8
       8
       +
       makeScopeWithSplicing' {

     

       9
       9
       +
         otherSplices = generateSplicesForMkScope "xfce";

     

       10
       10
       +
         f = (self:

     

       18
       11
        
           let

     

       19
       12
        
             inherit (self) callPackage;

     

       20
       13
        
           in

     
···

       177
       170
        
             thunar-bare = self.thunar.override { thunarPlugins = [ ]; }; # added 2019-11-04

     

       178
       171
        
       

     

       179
       172
        
             xfce4-hardware-monitor-plugin = throw "xfce.xfce4-hardware-monitor-plugin has been removed: abandoned by upstream and does not build"; # added 2023-01-15

     

       180
       180
       -
           })

     

       173
       173
       +
           });

     

       174
       174
       +
       }

+5 -8

pkgs/development/interpreters/lua-5/default.nix

···

       23
       23
        
               # - imports lua-packages.nix

     

       24
       24
        
               # - adds spliced package sets to the package set

     

       25
       25
        
               # - applies overrides from `packageOverrides`

     

       26
       26
       -
               ({ lua, overrides, callPackage, makeScopeWithSplicing }: let

     

       26
       26
       +
               ({ lua, overrides, callPackage, makeScopeWithSplicing' }: let

     

       27
       27
        
                 luaPackagesFun = callPackage ../../../top-level/lua-packages.nix {

     

       28
       28
        
                   lua = self;

     

       29
       29
        
                 };

     
···

       39
       39
        
                   selfHostHost = luaOnHostForHost.pkgs;

     

       40
       40
        
                   selfTargetTarget = luaOnTargetForTarget.pkgs or {};

     

       41
       41
        
                 };

     

       42
       42
       -
                 keep = self: { };

     

       43
       43
       -
                 extra = spliced0: {};

     

       44
       42
        
                 extensions = lib.composeManyExtensions [

     

       45
       43
        
                   generatedPackages

     

       46
       44
        
                   overriddenPackages

     

       47
       45
        
                   overrides

     

       48
       46
        
                 ];

     

       49
       49
       -
               in makeScopeWithSplicing

     

       50
       50
       -
                 otherSplices

     

       51
       51
       -
                 keep

     

       52
       52
       -
                 extra

     

       53
       53
       -
                 (lib.extends extensions luaPackagesFun))

     

       47
       47
       +
               in makeScopeWithSplicing' {

     

       48
       48
       +
                 inherit otherSplices;

     

       49
       49
       +
                 f = lib.extends extensions luaPackagesFun;

     

       50
       50
       +
               })

     

       54
       51
        
               {

     

       55
       52
        
                 overrides = packageOverrides;

     

       56
       53
        
                 lua = self;

+5 -8

pkgs/development/interpreters/perl/default.nix

···

       17
       17
        
               # Function that when called

     

       18
       18
        
               # - imports perl-packages.nix

     

       19
       19
        
               # - adds spliced package sets to the package set

     

       20
       20
       -
               ({ stdenv, pkgs, perl, callPackage, makeScopeWithSplicing }: let

     

       20
       20
       +
               ({ stdenv, pkgs, perl, callPackage, makeScopeWithSplicing' }: let

     

       21
       21
        
                 perlPackagesFun = callPackage ../../../top-level/perl-packages.nix {

     

       22
       22
        
                   # allow 'perlPackages.override { pkgs = pkgs // { imagemagick = imagemagickBig; }; }' like in python3Packages

     

       23
       23
        
                   # most perl packages aren't called with callPackage so it's not possible to override their arguments individually

     
···

       34
       34
        
                   selfHostHost = perlOnHostForHost.pkgs;

     

       35
       35
        
                   selfTargetTarget = perlOnTargetForTarget.pkgs or {};

     

       36
       36
        
                 };

     

       37
       37
       -
                 keep = self: { };

     

       38
       38
       -
                 extra = spliced0: {};

     

       39
       39
       -
               in makeScopeWithSplicing

     

       40
       40
       -
                 otherSplices

     

       41
       41
       -
                 keep

     

       42
       42
       -
                 extra

     

       43
       43
       -
                 perlPackagesFun)

     

       37
       37
       +
               in makeScopeWithSplicing' {

     

       38
       38
       +
                 inherit otherSplices;

     

       39
       39
       +
                 f = perlPackagesFun;

     

       40
       40
       +
               })

     

       44
       41
        
               {

     

       45
       42
        
                 perl = self;

     

       46
       43
        
               };

+1 -1

pkgs/development/interpreters/python/default.nix

···

       5
       5
        
       , db

     

       6
       6
        
       , lib

     

       7
       7
        
       , libffiBoot

     

       8
       8
       -
       , makeScopeWithSplicing

     

       8
       8
       +
       , makeScopeWithSplicing'

     

       9
       9
        
       , pythonPackagesExtensions

     

       10
       10
        
       , stdenv

     

       11
       11
        
       }@args:

+5 -8

pkgs/development/interpreters/python/passthrufun.nix

···

       1
       1
       -
       { lib, stdenv, callPackage, pythonPackagesExtensions, config, makeScopeWithSplicing, ... }:

     

       1
       1
       +
       { lib, stdenv, callPackage, pythonPackagesExtensions, config, makeScopeWithSplicing', ... }:

     

       2
       2
        
       

     

       3
       3
        
       { implementation

     

       4
       4
        
       , libPrefix

     
···

       48
       48
        
             };

     

       49
       49
        
             hooks = import ./hooks/default.nix;

     

       50
       50
        
             keep = lib.extends hooks pythonPackagesFun;

     

       51
       51
       -
             extra = _: {};

     

       52
       51
        
             optionalExtensions = cond: as: lib.optionals cond as;

     

       53
       52
        
             pythonExtension = import ../../../top-level/python-packages.nix;

     

       54
       53
        
             python2Extension = import ../../../top-level/python2-packages.nix;

     
···

       60
       59
        
               overrides

     

       61
       60
        
             ]);

     

       62
       61
        
             aliases = self: super: lib.optionalAttrs config.allowAliases (import ../../../top-level/python-aliases.nix lib self super);

     

       63
       63
       -
           in makeScopeWithSplicing

     

       64
       64
       -
             otherSplices

     

       65
       65
       -
             keep

     

       66
       66
       -
             extra

     

       67
       67
       -
             (lib.extends (lib.composeExtensions aliases extensions) keep))

     

       68
       68
       -
           {

     

       62
       62
       +
           in makeScopeWithSplicing' {

     

       63
       63
       +
             inherit otherSplices keep;

     

       64
       64
       +
             f = lib.extends (lib.composeExtensions aliases extensions) keep;

     

       65
       65
       +
           }) {

     

       69
       66
        
             overrides = packageOverrides;

     

       70
       67
        
             python = self;

     

       71
       68
        
           });

+5 -2

pkgs/development/libraries/qt-5/5.15/default.nix

···

       7
       7
        
       

     

       8
       8
        
       */

     

       9
       9
        
       

     

       10
       10
       -
       { makeScopeWithSplicing, generateSplicesForMkScope

     

       10
       10
       +
       { makeScopeWithSplicing', generateSplicesForMkScope

     

       11
       11
        
       , lib, stdenv, fetchurl, fetchgit, fetchpatch, fetchFromGitHub, makeSetupHook, makeWrapper

     

       12
       12
        
       , bison, cups ? null, harfbuzz, libGL, perl, python3

     

       13
       13
        
       , gstreamer, gst-plugins-base, gtk3, dconf

     
···

       332
       332
        
             } ../hooks/wrap-qt-apps-hook.sh;

     

       333
       333
        
           };

     

       334
       334
        
       

     

       335
       335
       -
       in makeScopeWithSplicing (generateSplicesForMkScope "qt5") (_: {}) (_: {}) addPackages

     

       335
       335
       +
       in makeScopeWithSplicing' {

     

       336
       336
       +
         otherSplices = generateSplicesForMkScope "qt5";

     

       337
       337
       +
         f = addPackages;

     

       338
       338
       +
       }

+1 -1

pkgs/development/libraries/qt-6/default.nix

···

       169
       169
        
               } ./hooks/qmake-hook.sh;

     

       170
       170
        
           };

     

       171
       171
        
       

     

       172
       172
       -
         # TODO(@Artturin): convert to makeScopeWithSplicing

     

       172
       172
       +
         # TODO(@Artturin): convert to makeScopeWithSplicing'

     

       173
       173
        
         # simple example of how to do that in 5568a4d25ca406809530420996d57e0876ca1a01

     

       174
       174
        
         self = lib.makeScope newScope addPackages;

     

       175
       175
        
       in

+5 -4

pkgs/games/steam/default.nix

···

       1
       1
       -
       { makeScopeWithSplicing, generateSplicesForMkScope

     

       1
       1
       +
       { makeScopeWithSplicing', generateSplicesForMkScope

     

       2
       2
        
       , stdenv, buildFHSEnv, pkgsi686Linux, glxinfo

     

       3
       3
        
       }:

     

       4
       4
        
       

     
···

       32
       32
        
       

     

       33
       33
        
           steamcmd = callPackage ./steamcmd.nix { };

     

       34
       34
        
         };

     

       35
       35
       -
         keep = self: { };

     

       36
       36
       -
         extra = spliced0: { };

     

       37
       37
       -
       in makeScopeWithSplicing (generateSplicesForMkScope "steamPackages") keep extra steamPackagesFun

     

       35
       35
       +
       in makeScopeWithSplicing' {

     

       36
       36
       +
         otherSplices = generateSplicesForMkScope "steamPackages";

     

       37
       37
       +
         f = steamPackagesFun;

     

       38
       38
       +
       }

+6 -7

pkgs/os-specific/bsd/freebsd/default.nix

···

       1
       1
        
       { stdenv, lib, stdenvNoCC

     

       2
       2
       -
       , makeScopeWithSplicing, generateSplicesForMkScope

     

       2
       2
       +
       , makeScopeWithSplicing', generateSplicesForMkScope

     

       3
       3
        
       , buildPackages

     

       4
       4
        
       , bsdSetupHook, makeSetupHook

     

       5
       5
        
       , fetchgit, fetchzip, coreutils, groff, mandoc, byacc, flex, which, m4, gawk, substituteAll, runtimeShell

     
···

       66
       66
        
           done

     

       67
       67
        
         '';

     

       68
       68
        
       

     

       69
       69
       -
       in makeScopeWithSplicing

     

       70
       70
       -
         (generateSplicesForMkScope "freebsd")

     

       71
       71
       -
         (_: {})

     

       72
       72
       -
         (_: {})

     

       73
       73
       -
         (self: let

     

       69
       69
       +
       in makeScopeWithSplicing' {

     

       70
       70
       +
         otherSplices = generateSplicesForMkScope "freebsd";

     

       71
       71
       +
         f = (self: let

     

       74
       72
        
           inherit (self) mkDerivation;

     

       75
       73
        
         in {

     

       76
       74
        
         inherit freebsdSrc;

     
···

       898
       896
        
           '';

     

       899
       897
        
         });

     

       900
       898
        
       

     

       901
       901
       -
       })

     

       899
       899
       +
       });

     

       900
       900
       +
       }

+7 -8

pkgs/os-specific/bsd/netbsd/default.nix

···

       1
       1
        
       { stdenv, lib, stdenvNoCC

     

       2
       2
       -
       , makeScopeWithSplicing, generateSplicesForMkScope

     

       2
       2
       +
       , makeScopeWithSplicing', generateSplicesForMkScope

     

       3
       3
        
       , buildPackages

     

       4
       4
        
       , bsdSetupHook, makeSetupHook, fetchcvs, groff, mandoc, byacc, flex

     

       5
       5
        
       , zlib

     
···

       26
       26
        
             else "no"}"

     

       27
       27
        
         ];

     

       28
       28
        
       

     

       29
       29
       -
       in makeScopeWithSplicing

     

       30
       30
       -
         (generateSplicesForMkScope "netbsd")

     

       31
       31
       -
         (_: {})

     

       32
       32
       -
         (_: {})

     

       33
       33
       -
         (self: let

     

       29
       29
       +
       in makeScopeWithSplicing' {

     

       30
       30
       +
         otherSplices = generateSplicesForMkScope "netbsd";

     

       31
       31
       +
         f = (self: let

     

       34
       32
        
           inherit (self) mkDerivation;

     

       35
       33
        
         in {

     

       36
       34
        
       

     

       37
       35
        
         # Why do we have splicing and yet do `nativeBuildInputs = with self; ...`?

     

       38
       36
        
         #

     

       39
       39
       -
         # We use `makeScopeWithSplicing` because this should be used for all

     

       37
       37
       +
         # We use `makeScopeWithSplicing'` because this should be used for all

     

       40
       38
        
         # nested package sets which support cross, so the inner `callPackage` works

     

       41
       39
        
         # correctly. But for the inline packages we don't bother to use

     

       42
       40
        
         # `callPackage`.

     
···

       1011
       1009
        
         # END MISCELLANEOUS

     

       1012
       1010
        
         #

     

       1013
       1011
        
       

     

       1014
       1014
       -
       })

     

       1012
       1012
       +
       });

     

       1013
       1013
       +
       }

+5 -9

pkgs/top-level/all-packages.nix

···

       24572
       24572
        
         qt5 = recurseIntoAttrs (makeOverridable

     

       24573
       24573
        
           (import ../development/libraries/qt-5/5.15) {

     

       24574
       24574
        
             inherit (__splicedPackages)

     

       24575
       24575
       -
               makeScopeWithSplicing generateSplicesForMkScope lib fetchurl fetchpatch fetchgit fetchFromGitHub makeSetupHook makeWrapper

     

       24575
       24575
       +
               makeScopeWithSplicing' generateSplicesForMkScope lib fetchurl fetchpatch fetchgit fetchFromGitHub makeSetupHook makeWrapper

     

       24576
       24576
        
               bison cups dconf harfbuzz libGL perl gtk3 python3

     

       24577
       24577
        
               darwin buildPackages;

     

       24578
       24578
        
             inherit (__splicedPackages.gst_all_1) gstreamer gst-plugins-base;

     
···

       27409
       27409
        
         };

     

       27410
       27410
        
       

     

       27411
       27411
        
         xorg = let

     

       27412
       27412
       -
           keep = _self: { };

     

       27413
       27413
       -
           extra = _spliced0: { };

     

       27414
       27414
       -
       

     

       27415
       27412
        
           # Use `lib.callPackageWith __splicedPackages` rather than plain `callPackage`

     

       27416
       27413
        
           # so as not to have the newly bound xorg items already in scope,  which would

     

       27417
       27414
        
           # have created a cycle.

     
···

       27426
       27423
        
       

     

       27427
       27424
        
           generatedPackages = lib.callPackageWith __splicedPackages ../servers/x11/xorg/default.nix { };

     

       27428
       27425
        
       

     

       27429
       27429
       -
           xorgPackages = makeScopeWithSplicing

     

       27430
       27430
       -
             (generateSplicesForMkScope "xorg")

     

       27431
       27431
       -
             keep

     

       27432
       27432
       -
             extra

     

       27433
       27433
       -
             (lib.extends overrides generatedPackages);

     

       27426
       27426
       +
           xorgPackages = makeScopeWithSplicing' {

     

       27427
       27427
       +
             otherSplices = generateSplicesForMkScope "xorg";

     

       27428
       27428
       +
             f = lib.extends overrides generatedPackages;

     

       27429
       27429
       +
           };

     

       27434
       27430
        
       

     

       27435
       27431
        
         in recurseIntoAttrs xorgPackages;

     

       27436
       27432

+7 -3

pkgs/top-level/darwin-packages.nix

···

       1
       1
        
       { lib

     

       2
       2
        
       , buildPackages, pkgs, targetPackages

     

       3
       3
       -
       , generateSplicesForMkScope, makeScopeWithSplicing

     

       3
       3
       +
       , generateSplicesForMkScope, makeScopeWithSplicing'

     

       4
       4
        
       , stdenv

     

       5
       5
        
       , preLibcCrossHeaders

     

       6
       6
        
       , config

     
···

       15
       15
        
                                               (stdenv.targetPlatform.config + "-");

     

       16
       16
        
       in

     

       17
       17
        
       

     

       18
       18
       -
       makeScopeWithSplicing (generateSplicesForMkScope "darwin") (_: {}) (spliced: spliced.apple_sdk.frameworks) (self: let

     

       18
       18
       +
       makeScopeWithSplicing' {

     

       19
       19
       +
         otherSplices = generateSplicesForMkScope "darwin";

     

       20
       20
       +
         extra = spliced: spliced.apple_sdk.frameworks;

     

       21
       21
       +
         f = (self: let

     

       19
       22
        
         inherit (self) mkDerivation callPackage;

     

       20
       23
        
       

     

       21
       24
        
         # Must use pkgs.callPackage to avoid infinite recursion.

     
···

       251
       254
        
       

     

       252
       255
        
       } // lib.optionalAttrs config.allowAliases {

     

       253
       256
        
         builder = throw "'darwin.builder' has been changed and renamed to 'darwin.linux-builder'. The default ssh port is now 31022. Please update your configuration or override the port back to 22. See https://nixos.org/manual/nixpkgs/unstable/#sec-darwin-builder"; # added 2023-07-06

     

       254
       254
       -
       })

     

       257
       257
       +
       });

     

       258
       258
       +
       }

+1

pkgs/top-level/splice.nix

···

       145
       145
        
       

     

       146
       146
        
         # prefill 2 fields of the function for convenience

     

       147
       147
        
         makeScopeWithSplicing = lib.makeScopeWithSplicing splicePackages pkgs.newScope;

     

       148
       148
       +
         makeScopeWithSplicing' = lib.makeScopeWithSplicing' { inherit splicePackages; inherit (pkgs) newScope; };

     

       148
       149
        
       

     

       149
       150
        
         # generate 'otherSplices' for 'makeScopeWithSplicing'

     

       150
       151
        
         generateSplicesForMkScope = attr: