commit a1d38823079bdf7836dd44392e5e1029087d8c85 · pyrox.dev/nixpkgs

+11 -4

lib/modules.nix

···

       537
       537
        
           mergeModules' prefix modules

     

       538
       538
        
             (concatMap (m: map (config: { file = m._file; inherit config; }) (pushDownProperties m.config)) modules);

     

       539
       539
        
       

     

       540
       540
       -
         mergeModules' = prefix: options: configs:

     

       540
       540
       +
         mergeModules' = prefix: modules: configs:

     

       541
       541
        
           let

     

       542
       542
        
             # an attrset 'name' => list of submodules that declare ‘name’.

     

       543
       543
        
             declsByName =

     
···

       554
       554
        
                     else

     

       555
       555
        
                       mapAttrs

     

       556
       556
        
                         (n: option:

     

       557
       557
       -
                           [{ inherit (module) _file; options = option; }]

     

       557
       557
       +
                           [{ inherit (module) _file; pos = builtins.unsafeGetAttrPos n subtree; options = option; }]

     

       558
       558
        
                         )

     

       559
       559
        
                         subtree

     

       560
       560
        
                     )

     

       561
       561
       -
                   options);

     

       561
       561
       +
                   modules);

     

       562
       562
        
       

     

       563
       563
        
             # The root of any module definition must be an attrset.

     

       564
       564
        
             checkedConfigs =

     
···

       730
       730
        
                   else res.options;

     

       731
       731
        
               in opt.options // res //

     

       732
       732
        
                 { declarations = res.declarations ++ [opt._file];

     

       733
       733
       +
                   # In the case of modules that are generated dynamically, we won't

     

       734
       734
       +
                   # have exact declaration lines; fall back to just the file being

     

       735
       735
       +
                   # evaluated.

     

       736
       736
       +
                   declarationPositions = res.declarationPositions

     

       737
       737
       +
                     ++ (if opt.pos != null

     

       738
       738
       +
                       then [opt.pos]

     

       739
       739
       +
                       else [{ file = opt._file; line = null; column = null; }]);

     

       733
       740
        
                   options = submodules;

     

       734
       741
        
                 } // typeSet

     

       735
       735
       -
           ) { inherit loc; declarations = []; options = []; } opts;

     

       742
       742
       +
           ) { inherit loc; declarations = []; declarationPositions = []; options = []; } opts;

     

       736
       743
        
       

     

       737
       744
        
         /* Merge all the definitions of an option to produce the final

     

       738
       745
        
            config value. */

+19 -1

lib/tests/modules.sh

···

       39
       39
        
       checkConfigOutput() {

     

       40
       40
        
           local outputContains=$1

     

       41
       41
        
           shift

     

       42
       42
       -
           if evalConfig "$@" 2>/dev/null | grep --silent "$outputContains" ; then

     

       42
       42
       +
           if evalConfig "$@" 2>/dev/null | grep -E --silent "$outputContains" ; then

     

       43
       43
        
               ((++pass))

     

       44
       44
        
           else

     

       45
       45
        
               echo 2>&1 "error: Expected result matching '$outputContains', while evaluating"

     
···

       438
       438
        
       # Anonymous modules get deduplicated by key

     

       439
       439
        
       checkConfigOutput '^"pear"$' config.once.raw ./merge-module-with-key.nix

     

       440
       440
        
       checkConfigOutput '^"pear\\npear"$' config.twice.raw ./merge-module-with-key.nix

     

       441
       441
       +
       

     

       442
       442
       +
       # Declaration positions

     

       443
       443
       +
       # Line should be present for direct options

     

       444
       444
       +
       checkConfigOutput '^10$' options.imported.line10.declarationPositions.0.line ./declaration-positions.nix

     

       445
       445
       +
       checkConfigOutput '/declaration-positions.nix"$' options.imported.line10.declarationPositions.0.file ./declaration-positions.nix

     

       446
       446
       +
       # Generated options may not have line numbers but they will at least get the

     

       447
       447
       +
       # right file

     

       448
       448
       +
       checkConfigOutput '/declaration-positions.nix"$' options.generated.line18.declarationPositions.0.file ./declaration-positions.nix

     

       449
       449
       +
       checkConfigOutput '^null$' options.generated.line18.declarationPositions.0.line ./declaration-positions.nix

     

       450
       450
       +
       # Submodules don't break it

     

       451
       451
       +
       checkConfigOutput '^39$' config.submoduleLine34.submodDeclLine39.0.line ./declaration-positions.nix

     

       452
       452
       +
       checkConfigOutput '/declaration-positions.nix"$' config.submoduleLine34.submodDeclLine39.0.file ./declaration-positions.nix

     

       453
       453
       +
       # New options under freeform submodules get collected into the parent submodule

     

       454
       454
       +
       # (consistent with .declarations behaviour, but weird; notably appears in system.build)

     

       455
       455
       +
       checkConfigOutput '^34|23$' options.submoduleLine34.declarationPositions.0.line ./declaration-positions.nix

     

       456
       456
       +
       checkConfigOutput '^34|23$' options.submoduleLine34.declarationPositions.1.line ./declaration-positions.nix

     

       457
       457
       +
       # nested options work

     

       458
       458
       +
       checkConfigOutput '^30$' options.nested.nestedLine30.declarationPositions.0.line ./declaration-positions.nix

     

       441
       459
        
       

     

       442
       460
        
       cat <<EOF

     

       443
       461
        
       ====== module tests ======

+49

lib/tests/modules/declaration-positions.nix

···

       1
       1
       +
       { lib, options, ... }:

     

       2
       2
       +
       let discardPositions = lib.mapAttrs (k: v: v);

     

       3
       3
       +
       in

     

       4
       4
       +
       # unsafeGetAttrPos is unspecified best-effort behavior, so we only want to consider this test on an evaluator that satisfies some basic assumptions about this function.

     

       5
       5
       +
       assert builtins.unsafeGetAttrPos "a" { a = true; } != null;

     

       6
       6
       +
       assert builtins.unsafeGetAttrPos "a" (discardPositions { a = true; }) == null;

     

       7
       7
       +
       {

     

       8
       8
       +
         imports = [

     

       9
       9
       +
           {

     

       10
       10
       +
             options.imported.line10 = lib.mkOption {

     

       11
       11
       +
               type = lib.types.int;

     

       12
       12
       +
             };

     

       13
       13
       +
       

     

       14
       14
       +
             # Simulates various patterns of generating modules such as

     

       15
       15
       +
             # programs.firefox.nativeMessagingHosts.ff2mpv. We don't expect to get

     

       16
       16
       +
             # line numbers for these, but we can fall back on knowing the file.

     

       17
       17
       +
             options.generated = discardPositions {

     

       18
       18
       +
               line18 = lib.mkOption {

     

       19
       19
       +
                 type = lib.types.int;

     

       20
       20
       +
               };

     

       21
       21
       +
             };

     

       22
       22
       +
       

     

       23
       23
       +
             options.submoduleLine34.extraOptLine23 = lib.mkOption {

     

       24
       24
       +
               default = 1;

     

       25
       25
       +
               type = lib.types.int;

     

       26
       26
       +
             };

     

       27
       27
       +
           }

     

       28
       28
       +
         ];

     

       29
       29
       +
       

     

       30
       30
       +
         options.nested.nestedLine30 = lib.mkOption {

     

       31
       31
       +
           type = lib.types.int;

     

       32
       32
       +
         };

     

       33
       33
       +
       

     

       34
       34
       +
         options.submoduleLine34 = lib.mkOption {

     

       35
       35
       +
           default = { };

     

       36
       36
       +
           type = lib.types.submoduleWith {

     

       37
       37
       +
             modules = [

     

       38
       38
       +
               ({ options, ... }: {

     

       39
       39
       +
                 options.submodDeclLine39 = lib.mkOption { };

     

       40
       40
       +
               })

     

       41
       41
       +
               { freeformType = with lib.types; lazyAttrsOf (uniq unspecified); }

     

       42
       42
       +
             ];

     

       43
       43
       +
           };

     

       44
       44
       +
         };

     

       45
       45
       +
       

     

       46
       46
       +
         config = {

     

       47
       47
       +
           submoduleLine34.submodDeclLine39 = (options.submoduleLine34.type.getSubOptions [ ]).submodDeclLine39.declarationPositions;

     

       48
       48
       +
         };

     

       49
       49
       +
       }