commit 224426ba6d4370ede958c127d9b9866a189522f9 · pyrox.dev/nixpkgs

+7 -1

lib/modules.nix

···

       113
       113
        
                         args ? {}

     

       114
       114
        
                       , # This would be remove in the future, Prefer _module.check option instead.

     

       115
       115
        
                         check ? true

     

       116
       116
       +
                         # Internal variable to avoid `_key` collisions regardless

     

       117
       117
       +
                         # of `extendModules`. Used in `submoduleWith`.

     

       118
       118
       +
                         # Test case: lib/tests/modules, "168767"

     

       119
       119
       +
                       , extensionOffset ? 0

     

       116
       120
        
                       }:

     

       117
       121
        
           let

     

       118
       122
        
             withWarnings = x:

     
···

       338
       342
        
               modules ? [],

     

       339
       343
        
               specialArgs ? {},

     

       340
       344
        
               prefix ? [],

     

       345
       345
       +
               extensionOffset ? length modules,

     

       341
       346
        
               }:

     

       342
       347
        
                 evalModules (evalModulesArgs // {

     

       343
       348
        
                   modules = regularModules ++ modules;

     

       344
       349
        
                   specialArgs = evalModulesArgs.specialArgs or {} // specialArgs;

     

       345
       350
        
                   prefix = extendArgs.prefix or evalModulesArgs.prefix;

     

       351
       351
       +
                   inherit extensionOffset;

     

       346
       352
        
                 });

     

       347
       353
        
       

     

       348
       354
        
             type = lib.types.submoduleWith {

     

       349
       349
       -
               inherit modules specialArgs;

     

       355
       355
       +
               inherit modules specialArgs extensionOffset;

     

       350
       356
        
             };

     

       351
       357
        
       

     

       352
       358
        
             result = withWarnings {

+5 -1

lib/tests/modules.sh

···

       293
       293
        
       

     

       294
       294
        
       # moduleType

     

       295
       295
        
       checkConfigOutput '^"a b"$' config.resultFoo ./declare-variants.nix ./define-variant.nix

     

       296
       296
       -
       checkConfigOutput '^"a y z"$' config.resultFooBar ./declare-variants.nix ./define-variant.nix

     

       296
       296
       +
       checkConfigOutput '^"a b y z"$' config.resultFooBar ./declare-variants.nix ./define-variant.nix

     

       297
       297
        
       checkConfigOutput '^"a b c"$' config.resultFooFoo ./declare-variants.nix ./define-variant.nix

     

       298
       298
        
       

     

       299
       299
        
       ## emptyValue's

     
···

       326
       326
        
       

     

       327
       327
        
       # Test that types.optionType leaves types untouched as long as they don't need to be merged

     

       328
       328
        
       checkConfigOutput 'ok' config.freeformItems.foo.bar ./adhoc-freeformType-survives-type-merge.nix

     

       329
       329
       +
       

     

       330
       330
       +
       # Anonymous submodules don't get nixed by import resolution/deduplication

     

       331
       331
       +
       # because of an `extendModules` bug, issue 168767.

     

       332
       332
       +
       checkConfigOutput '^1$' config.sub.specialisation.value ./extendModules-168767-imports.nix

     

       329
       333
        
       

     

       330
       334
        
       cat <<EOF

     

       331
       335
        
       ====== module tests ======

+41

lib/tests/modules/extendModules-168767-imports.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , extendModules

     

       3
       3
       +
       , ...

     

       4
       4
       +
       }:

     

       5
       5
       +
       with lib;

     

       6
       6
       +
       {

     

       7
       7
       +
         imports = [

     

       8
       8
       +
       

     

       9
       9
       +
           {

     

       10
       10
       +
             options.sub = mkOption {

     

       11
       11
       +
               default = { };

     

       12
       12
       +
               type = types.submodule (

     

       13
       13
       +
                 { config

     

       14
       14
       +
                 , extendModules

     

       15
       15
       +
                 , ...

     

       16
       16
       +
                 }:

     

       17
       17
       +
                 {

     

       18
       18
       +
                   options.value = mkOption {

     

       19
       19
       +
                     type = types.int;

     

       20
       20
       +
                   };

     

       21
       21
       +
       

     

       22
       22
       +
                   options.specialisation = mkOption {

     

       23
       23
       +
                     default = { };

     

       24
       24
       +
                     inherit

     

       25
       25
       +
                       (extendModules {

     

       26
       26
       +
                         modules = [{

     

       27
       27
       +
                           specialisation = mkOverride 0 { };

     

       28
       28
       +
                         }];

     

       29
       29
       +
                       })

     

       30
       30
       +
                       type;

     

       31
       31
       +
                   };

     

       32
       32
       +
                 }

     

       33
       33
       +
               );

     

       34
       34
       +
             };

     

       35
       35
       +
           }

     

       36
       36
       +
       

     

       37
       37
       +
           { config.sub.value = 1; }

     

       38
       38
       +
       

     

       39
       39
       +
       

     

       40
       40
       +
         ];

     

       41
       41
       +
       }

+8 -2

lib/types.nix

···

       568
       568
        
             { modules

     

       569
       569
        
             , specialArgs ? {}

     

       570
       570
        
             , shorthandOnlyDefinesConfig ? false

     

       571
       571
       +
       

     

       572
       572
       +
               # Internal variable to avoid `_key` collisions regardless

     

       573
       573
       +
               # of `extendModules`. Wired through by `evalModules`.

     

       574
       574
       +
               # Test case: lib/tests/modules, "168767"

     

       575
       575
       +
             , extensionOffset ? 0

     

       571
       576
        
             }@attrs:

     

       572
       577
        
             let

     

       573
       578
        
               inherit (lib.modules) evalModules;

     
···

       579
       584
        
               allModules = defs: imap1 (n: { value, file }:

     

       580
       585
        
                 if isFunction value

     

       581
       586
        
                 then setFunctionArgs

     

       582
       582
       -
                       (args: lib.modules.unifyModuleSyntax file "${toString file}-${toString n}" (value args))

     

       587
       587
       +
                       (args: lib.modules.unifyModuleSyntax file "${toString file}-${toString (n + extensionOffset)}" (value args))

     

       583
       588
        
                       (functionArgs value)

     

       584
       589
        
                 else if isAttrs value

     

       585
       590
        
                 then

     

       586
       586
       -
                   lib.modules.unifyModuleSyntax file "${toString file}-${toString n}" (shorthandToModule value)

     

       591
       591
       +
                   lib.modules.unifyModuleSyntax file "${toString file}-${toString (n + extensionOffset)}" (shorthandToModule value)

     

       587
       592
        
                 else value

     

       588
       593
        
               ) defs;

     

       589
       594
        
       

     
···

       620
       625
        
                 (base.extendModules {

     

       621
       626
        
                   modules = [ { _module.args.name = last loc; } ] ++ allModules defs;

     

       622
       627
        
                   prefix = loc;

     

       628
       628
       +
                   extensionOffset = extensionOffset + length defs;

     

       623
       629
        
                 }).config;

     

       624
       630
        
               emptyValue = { value = {}; };

     

       625
       631
        
               getSubOptions = prefix: (base.extendModules