commit 48293bd6b6b791b9af745e9b7b94a6856e279fa0 · pyrox.dev/nixpkgs

+3 -1

lib/tests/modules.sh

···

       254
       254
        
       checkConfigOutput null config.value.null ./types-anything/equal-atoms.nix

     

       255
       255
        
       checkConfigOutput 0.1 config.value.float ./types-anything/equal-atoms.nix

     

       256
       256
        
       # Functions can't be merged together

     

       257
       257
       -
       checkConfigError "The option .* has conflicting definition values" config.value.multiple-lambdas ./types-anything/functions.nix

     

       257
       257
       +
       checkConfigError "The option .value.multiple-lambdas.<function body>. has conflicting option types" config.applied.multiple-lambdas ./types-anything/functions.nix

     

       258
       258
        
       checkConfigOutput '<LAMBDA>' config.value.single-lambda ./types-anything/functions.nix

     

       259
       259
       +
       checkConfigOutput 'null' config.applied.merging-lambdas.x ./types-anything/functions.nix

     

       260
       260
       +
       checkConfigOutput 'null' config.applied.merging-lambdas.y ./types-anything/functions.nix

     

       259
       261
        
       # Check that all mk* modifiers are applied

     

       260
       262
        
       checkConfigError 'attribute .* not found' config.value.mkiffalse ./types-anything/mk-mods.nix

     

       261
       263
        
       checkConfigOutput '{ }' config.value.mkiftrue ./types-anything/mk-mods.nix

+9 -3

lib/tests/modules/types-anything/functions.nix

···

       1
       1
       -
       { lib, ... }: {

     

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

     

       2
       2
        
       

     

       3
       3
        
         options.value = lib.mkOption {

     

       4
       4
        
           type = lib.types.anything;

     

       5
       5
       +
         };

     

       6
       6
       +
       

     

       7
       7
       +
         options.applied = lib.mkOption {

     

       8
       8
       +
           default = lib.mapAttrs (name: fun: fun null) config.value;

     

       5
       9
        
         };

     

       6
       10
        
       

     

       7
       11
        
         config = lib.mkMerge [

     

       8
       12
        
           {

     

       9
       13
        
             value.single-lambda = x: x;

     

       10
       10
       -
             value.multiple-lambdas = x: x;

     

       14
       14
       +
             value.multiple-lambdas = x: { inherit x; };

     

       15
       15
       +
             value.merging-lambdas = x: { inherit x; };

     

       11
       16
        
           }

     

       12
       17
        
           {

     

       13
       13
       -
             value.multiple-lambdas = x: x;

     

       18
       18
       +
             value.multiple-lambdas = x: [ x ];

     

       19
       19
       +
             value.merging-lambdas = y: { inherit y; };

     

       14
       20
        
           }

     

       15
       21
        
         ];

     

       16
       22

+6

lib/types.nix

···

       192
       192
        
                     else (listOf anything).merge;

     

       193
       193
        
                   # This is the type of packages, only accept a single definition

     

       194
       194
        
                   stringCoercibleSet = mergeOneOption;

     

       195
       195
       +
                   lambda = loc: defs: arg: anything.merge

     

       196
       196
       +
                     (loc ++ [ "<function body>" ])

     

       197
       197
       +
                     (map (def: {

     

       198
       198
       +
                       file = def.file;

     

       199
       199
       +
                       value = def.value arg;

     

       200
       200
       +
                     }) defs);

     

       195
       201
        
                   # Otherwise fall back to only allowing all equal definitions

     

       196
       202
        
                 }.${commonType} or mergeEqualOption;

     

       197
       203
        
               in mergeFunction loc defs;