commit 83fed2e6ff84609bd59054dae96534f360b9d660 · pyrox.dev/nixpkgs

+46 -3

lib/modules.nix

···

       1121
       1121
        
             files = map (def: def.file) res.defsFinal;

     

       1122
       1122
        
             definitionsWithLocations = res.defsFinal;

     

       1123
       1123
        
             inherit (res) isDefined;

     

       1124
       1124
       +
             inherit (res.checkedAndMerged) valueMeta;

     

       1124
       1125
        
             # This allows options to be correctly displayed using `${options.path.to.it}`

     

       1125
       1126
        
             __toString = _: showOption loc;

     

       1126
       1127
        
           };

     
···

       1164
       1165
        
           # Type-check the remaining definitions, and merge them. Or throw if no definitions.

     

       1165
       1166
        
           mergedValue =

     

       1166
       1167
        
             if isDefined then

     

       1167
       1167
       -
               if all (def: type.check def.value) defsFinal then

     

       1168
       1168
       +
               if type.merge ? v2 then

     

       1169
       1169
       +
                 # check and merge share the same closure

     

       1170
       1170
       +
                 # .headError is either not-present, null, or a string describing the error

     

       1171
       1171
       +
                 if checkedAndMerged.headError or null != null then

     

       1172
       1172
       +
                   throw "A definition for option `${showOption loc}' is not of type `${type.description}'. TypeError: ${checkedAndMerged.headError.message}"

     

       1173
       1173
       +
                 else

     

       1174
       1174
       +
                   checkedAndMerged.value

     

       1175
       1175
       +
               else if all (def: type.check def.value) defsFinal then

     

       1168
       1176
        
                 type.merge loc defsFinal

     

       1169
       1177
        
               else

     

       1170
       1178
        
                 let

     
···

       1176
       1184
        
               # handling.  If changed here, please change it there too.)

     

       1177
       1185
        
               throw

     

       1178
       1186
        
                 "The option `${showOption loc}' was accessed but has no value defined. Try setting the option.";

     

       1187
       1187
       +
       

     

       1188
       1188
       +
           checkedAndMerged =

     

       1189
       1189
       +
             (

     

       1190
       1190
       +
               # This function (which is immediately applied) checks that type.merge

     

       1191
       1191
       +
               # returns the proper attrset.

     

       1192
       1192
       +
               # Once use of the merge.v2 feature has propagated, consider removing this

     

       1193
       1193
       +
               # for an estimated one thousandth performance improvement (NixOS by nr.thunks).

     

       1194
       1194
       +
               {

     

       1195
       1195
       +
                 headError,

     

       1196
       1196
       +
                 value,

     

       1197
       1197
       +
                 valueMeta,

     

       1198
       1198
       +
               }@args:

     

       1199
       1199
       +
               args

     

       1200
       1200
       +
             )

     

       1201
       1201
       +
               (

     

       1202
       1202
       +
                 if type.merge ? v2 then

     

       1203
       1203
       +
                   let

     

       1204
       1204
       +
                     r = type.merge.v2 {

     

       1205
       1205
       +
                       inherit loc;

     

       1206
       1206
       +
                       defs = defsFinal;

     

       1207
       1207
       +
                     };

     

       1208
       1208
       +
                   in

     

       1209
       1209
       +
                   r

     

       1210
       1210
       +
                   // {

     

       1211
       1211
       +
                     valueMeta = r.valueMeta // {

     

       1212
       1212
       +
                       _internal = {

     

       1213
       1213
       +
                         inherit type;

     

       1214
       1214
       +
                       };

     

       1215
       1215
       +
                     };

     

       1216
       1216
       +
                   }

     

       1217
       1217
       +
                 else

     

       1218
       1218
       +
                   {

     

       1219
       1219
       +
                     headError = null;

     

       1220
       1220
       +
                     value = mergedValue;

     

       1221
       1221
       +
                     valueMeta = { };

     

       1222
       1222
       +
                   }

     

       1223
       1223
       +
               );

     

       1179
       1224
        
       

     

       1180
       1225
        
           isDefined = defsFinal != [ ];

     

       1181
       1226
        
       

     
···

       1586
       1631
        
               New option path as list of strings.

     

       1587
       1632
        
             */

     

       1588
       1633
        
             to,

     

       1589
       1589
       -
       

     

       1590
       1634
        
             /**

     

       1591
       1635
        
               Release number of the first release that contains the rename, ignoring backports.

     

       1592
       1636
        
               Set it to the upcoming release, matching the nixpkgs/.version file.

     

       1593
       1637
        
             */

     

       1594
       1638
        
             sinceRelease,

     

       1595
       1595
       -
       

     

       1596
       1639
        
           }:

     

       1597
       1640
        
           doRename {

     

       1598
       1641
        
             inherit from to;

+379

lib/tests/checkAndMergeCompat.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         pkgs ? import ../.. { },

     

       3
       3
       +
         currLibPath ? ../.,

     

       4
       4
       +
         prevLibPath ? "${

     

       5
       5
       +
           pkgs.fetchFromGitHub {

     

       6
       6
       +
             owner = "nixos";

     

       7
       7
       +
             repo = "nixpkgs";

     

       8
       8
       +
             # Parent commit of [#391544](https://github.com/NixOS/nixpkgs/pull/391544)

     

       9
       9
       +
             # Which was before the type.merge.v2 introduction

     

       10
       10
       +
             rev = "bcf94dd3f07189b7475d823c8d67d08b58289905";

     

       11
       11
       +
             hash = "sha256-MuMiIY3MX5pFSOCvutmmRhV6RD0R3CG0Hmazkg8cMFI=";

     

       12
       12
       +
           }

     

       13
       13
       +
         }/lib",

     

       14
       14
       +
       }:

     

       15
       15
       +
       let

     

       16
       16
       +
         lib = import currLibPath;

     

       17
       17
       +
       

     

       18
       18
       +
         lib_with_merge_v2 = lib;

     

       19
       19
       +
         lib_with_merge_v1 = import prevLibPath;

     

       20
       20
       +
       

     

       21
       21
       +
         getMatrix =

     

       22
       22
       +
           {

     

       23
       23
       +
             getType ? null,

     

       24
       24
       +
             # If getType is set this is only used as test prefix

     

       25
       25
       +
             # And the type from getType is used

     

       26
       26
       +
             outerTypeName,

     

       27
       27
       +
             innerTypeName,

     

       28
       28
       +
             value,

     

       29
       29
       +
             testAttrs,

     

       30
       30
       +
           }:

     

       31
       31
       +
           let

     

       32
       32
       +
             evalModules.call_v1 = lib_with_merge_v1.evalModules;

     

       33
       33
       +
             evalModules.call_v2 = lib_with_merge_v2.evalModules;

     

       34
       34
       +
             outerTypes.outer_v1 = lib_with_merge_v1.types;

     

       35
       35
       +
             outerTypes.outer_v2 = lib_with_merge_v2.types;

     

       36
       36
       +
             innerTypes.inner_v1 = lib_with_merge_v1.types;

     

       37
       37
       +
             innerTypes.inner_v2 = lib_with_merge_v2.types;

     

       38
       38
       +
           in

     

       39
       39
       +
           lib.mapAttrs (

     

       40
       40
       +
             _: evalModules:

     

       41
       41
       +
             lib.mapAttrs (

     

       42
       42
       +
               _: outerTypes:

     

       43
       43
       +
               lib.mapAttrs (_: innerTypes: {

     

       44
       44
       +
                 "test_${outerTypeName}_${innerTypeName}" = testAttrs // {

     

       45
       45
       +
                   expr =

     

       46
       46
       +
                     (evalModules {

     

       47
       47
       +
                       modules = [

     

       48
       48
       +
                         (m: {

     

       49
       49
       +
                           options.foo = m.lib.mkOption {

     

       50
       50
       +
                             type =

     

       51
       51
       +
                               if getType != null then

     

       52
       52
       +
                                 getType outerTypes innerTypes

     

       53
       53
       +
                               else

     

       54
       54
       +
                                 outerTypes.${outerTypeName} innerTypes.${innerTypeName};

     

       55
       55
       +
                             default = value;

     

       56
       56
       +
                           };

     

       57
       57
       +
                         })

     

       58
       58
       +
                       ];

     

       59
       59
       +
                     }).config.foo;

     

       60
       60
       +
                 };

     

       61
       61
       +
               }) innerTypes

     

       62
       62
       +
             ) outerTypes

     

       63
       63
       +
           ) evalModules;

     

       64
       64
       +
       in

     

       65
       65
       +
       {

     

       66
       66
       +
         # AttrsOf string

     

       67
       67
       +
         attrsOf_str_ok = getMatrix {

     

       68
       68
       +
           outerTypeName = "attrsOf";

     

       69
       69
       +
           innerTypeName = "str";

     

       70
       70
       +
           value = {

     

       71
       71
       +
             bar = "test";

     

       72
       72
       +
           };

     

       73
       73
       +
           testAttrs = {

     

       74
       74
       +
             expected = {

     

       75
       75
       +
               bar = "test";

     

       76
       76
       +
             };

     

       77
       77
       +
           };

     

       78
       78
       +
         };

     

       79
       79
       +
         attrsOf_str_err_inner = getMatrix {

     

       80
       80
       +
           outerTypeName = "attrsOf";

     

       81
       81
       +
           innerTypeName = "str";

     

       82
       82
       +
           value = {

     

       83
       83
       +
             bar = 1; # not a string

     

       84
       84
       +
           };

     

       85
       85
       +
           testAttrs = {

     

       86
       86
       +
             expectedError = {

     

       87
       87
       +
               type = "ThrownError";

     

       88
       88
       +
               msg = "A definition for option `foo.bar' is not of type `string'.*";

     

       89
       89
       +
             };

     

       90
       90
       +
           };

     

       91
       91
       +
         };

     

       92
       92
       +
         attrsOf_str_err_outer = getMatrix {

     

       93
       93
       +
           outerTypeName = "attrsOf";

     

       94
       94
       +
           innerTypeName = "str";

     

       95
       95
       +
           value = [ "foo" ]; # not an attrset

     

       96
       96
       +
           testAttrs = {

     

       97
       97
       +
             expectedError = {

     

       98
       98
       +
               type = "ThrownError";

     

       99
       99
       +
               msg = "A definition for option `foo' is not of type `attribute set of string'.*";

     

       100
       100
       +
             };

     

       101
       101
       +
           };

     

       102
       102
       +
         };

     

       103
       103
       +
       

     

       104
       104
       +
         # listOf string

     

       105
       105
       +
         listOf_str_ok = getMatrix {

     

       106
       106
       +
           outerTypeName = "listOf";

     

       107
       107
       +
           innerTypeName = "str";

     

       108
       108
       +
           value = [

     

       109
       109
       +
             "foo"

     

       110
       110
       +
             "bar"

     

       111
       111
       +
           ];

     

       112
       112
       +
           testAttrs = {

     

       113
       113
       +
             expected = [

     

       114
       114
       +
               "foo"

     

       115
       115
       +
               "bar"

     

       116
       116
       +
             ];

     

       117
       117
       +
           };

     

       118
       118
       +
         };

     

       119
       119
       +
         listOf_str_err_inner = getMatrix {

     

       120
       120
       +
           outerTypeName = "listOf";

     

       121
       121
       +
           innerTypeName = "str";

     

       122
       122
       +
           value = [

     

       123
       123
       +
             "foo"

     

       124
       124
       +
             1

     

       125
       125
       +
           ]; # not a string

     

       126
       126
       +
           testAttrs = {

     

       127
       127
       +
             expectedError = {

     

       128
       128
       +
               type = "ThrownError";

     

       129
       129
       +
               msg = ''A definition for option `foo."\[definition 1-entry 2\]"' is not of type `string'.'';

     

       130
       130
       +
             };

     

       131
       131
       +
           };

     

       132
       132
       +
         };

     

       133
       133
       +
         listOf_str_err_outer = getMatrix {

     

       134
       134
       +
           outerTypeName = "listOf";

     

       135
       135
       +
           innerTypeName = "str";

     

       136
       136
       +
           value = {

     

       137
       137
       +
             foo = 42;

     

       138
       138
       +
           }; # not a list

     

       139
       139
       +
           testAttrs = {

     

       140
       140
       +
             expectedError = {

     

       141
       141
       +
               type = "ThrownError";

     

       142
       142
       +
               msg = "A definition for option `foo' is not of type `list of string'.*";

     

       143
       143
       +
             };

     

       144
       144
       +
           };

     

       145
       145
       +
         };

     

       146
       146
       +
       

     

       147
       147
       +
         attrsOf_submodule_ok = getMatrix {

     

       148
       148
       +
           getType =

     

       149
       149
       +
             a: b:

     

       150
       150
       +
             a.attrsOf (

     

       151
       151
       +
               b.submodule (m: {

     

       152
       152
       +
                 options.nested = m.lib.mkOption {

     

       153
       153
       +
                   type = m.lib.types.str;

     

       154
       154
       +
                 };

     

       155
       155
       +
               })

     

       156
       156
       +
             );

     

       157
       157
       +
           outerTypeName = "attrsOf";

     

       158
       158
       +
           innerTypeName = "submodule";

     

       159
       159
       +
           value = {

     

       160
       160
       +
             foo = {

     

       161
       161
       +
               nested = "test1";

     

       162
       162
       +
             };

     

       163
       163
       +
             bar = {

     

       164
       164
       +
               nested = "test2";

     

       165
       165
       +
             };

     

       166
       166
       +
           };

     

       167
       167
       +
           testAttrs = {

     

       168
       168
       +
             expected = {

     

       169
       169
       +
               foo = {

     

       170
       170
       +
                 nested = "test1";

     

       171
       171
       +
               };

     

       172
       172
       +
               bar = {

     

       173
       173
       +
                 nested = "test2";

     

       174
       174
       +
               };

     

       175
       175
       +
             };

     

       176
       176
       +
           };

     

       177
       177
       +
         };

     

       178
       178
       +
         attrsOf_submodule_err_inner = getMatrix {

     

       179
       179
       +
           outerTypeName = "attrsOf";

     

       180
       180
       +
           innerTypeName = "submodule";

     

       181
       181
       +
           getType =

     

       182
       182
       +
             a: b:

     

       183
       183
       +
             a.attrsOf (

     

       184
       184
       +
               b.submodule (m: {

     

       185
       185
       +
                 options.nested = m.lib.mkOption {

     

       186
       186
       +
                   type = m.lib.types.str;

     

       187
       187
       +
                 };

     

       188
       188
       +
               })

     

       189
       189
       +
             );

     

       190
       190
       +
           value = {

     

       191
       191
       +
             foo = [ 1 ]; # not a submodule

     

       192
       192
       +
             bar = {

     

       193
       193
       +
               nested = "test2";

     

       194
       194
       +
             };

     

       195
       195
       +
           };

     

       196
       196
       +
           testAttrs = {

     

       197
       197
       +
             expectedError = {

     

       198
       198
       +
               type = "ThrownError";

     

       199
       199
       +
               msg = "A definition for option `foo.foo' is not of type `submodule'.*";

     

       200
       200
       +
             };

     

       201
       201
       +
           };

     

       202
       202
       +
         };

     

       203
       203
       +
         attrsOf_submodule_err_outer = getMatrix {

     

       204
       204
       +
           outerTypeName = "attrsOf";

     

       205
       205
       +
           innerTypeName = "submodule";

     

       206
       206
       +
           getType =

     

       207
       207
       +
             a: b:

     

       208
       208
       +
             a.attrsOf (

     

       209
       209
       +
               b.submodule (m: {

     

       210
       210
       +
                 options.nested = m.lib.mkOption {

     

       211
       211
       +
                   type = m.lib.types.str;

     

       212
       212
       +
                 };

     

       213
       213
       +
               })

     

       214
       214
       +
             );

     

       215
       215
       +
           value = [ 123 ]; # not an attrsOf

     

       216
       216
       +
           testAttrs = {

     

       217
       217
       +
             expectedError = {

     

       218
       218
       +
               type = "ThrownError";

     

       219
       219
       +
               msg = ''A definition for option `foo' is not of type `attribute set of \(submodule\).*'';

     

       220
       220
       +
             };

     

       221
       221
       +
           };

     

       222
       222
       +
         };

     

       223
       223
       +
       

     

       224
       224
       +
         # either

     

       225
       225
       +
         either_str_attrsOf_ok = getMatrix {

     

       226
       226
       +
           outerTypeName = "either";

     

       227
       227
       +
           innerTypeName = "str_or_attrsOf_str";

     

       228
       228
       +
       

     

       229
       229
       +
           getType = a: b: a.either b.str (b.attrsOf a.str);

     

       230
       230
       +
           value = "string value";

     

       231
       231
       +
           testAttrs = {

     

       232
       232
       +
             expected = "string value";

     

       233
       233
       +
           };

     

       234
       234
       +
         };

     

       235
       235
       +
         either_str_attrsOf_err_1 = getMatrix {

     

       236
       236
       +
           outerTypeName = "either";

     

       237
       237
       +
           innerTypeName = "str_or_attrsOf_str";

     

       238
       238
       +
       

     

       239
       239
       +
           getType = a: b: a.either b.str (b.attrsOf a.str);

     

       240
       240
       +
           value = 1;

     

       241
       241
       +
           testAttrs = {

     

       242
       242
       +
             expectedError = {

     

       243
       243
       +
               type = "ThrownError";

     

       244
       244
       +
               msg = "A definition for option `foo' is not of type `string or attribute set of string'.*";

     

       245
       245
       +
             };

     

       246
       246
       +
           };

     

       247
       247
       +
         };

     

       248
       248
       +
         either_str_attrsOf_err_2 = getMatrix {

     

       249
       249
       +
           outerTypeName = "either";

     

       250
       250
       +
           innerTypeName = "str_or_attrsOf_str";

     

       251
       251
       +
       

     

       252
       252
       +
           getType = a: b: a.either b.str (b.attrsOf a.str);

     

       253
       253
       +
           value = {

     

       254
       254
       +
             bar = 1; # not a string

     

       255
       255
       +
           };

     

       256
       256
       +
           testAttrs = {

     

       257
       257
       +
             expectedError = {

     

       258
       258
       +
               type = "ThrownError";

     

       259
       259
       +
               msg = "A definition for option `foo.bar' is not of type `string'.*";

     

       260
       260
       +
             };

     

       261
       261
       +
           };

     

       262
       262
       +
         };

     

       263
       263
       +
       

     

       264
       264
       +
         # Coereced to

     

       265
       265
       +
         coerce_attrsOf_str_to_listOf_str_run = getMatrix {

     

       266
       266
       +
           outerTypeName = "coercedTo";

     

       267
       267
       +
           innerTypeName = "attrsOf_str->listOf_str";

     

       268
       268
       +
           getType = a: b: a.coercedTo (b.attrsOf b.str) builtins.attrValues (b.listOf b.str);

     

       269
       269
       +
           value = {

     

       270
       270
       +
             bar = "test1"; # coerced to listOf string

     

       271
       271
       +
             foo = "test2"; # coerced to listOf string

     

       272
       272
       +
           };

     

       273
       273
       +
           testAttrs = {

     

       274
       274
       +
             expected = [

     

       275
       275
       +
               "test1"

     

       276
       276
       +
               "test2"

     

       277
       277
       +
             ];

     

       278
       278
       +
           };

     

       279
       279
       +
         };

     

       280
       280
       +
         coerce_attrsOf_str_to_listOf_str_final = getMatrix {

     

       281
       281
       +
           outerTypeName = "coercedTo";

     

       282
       282
       +
           innerTypeName = "attrsOf_str->listOf_str";

     

       283
       283
       +
           getType = a: b: a.coercedTo (b.attrsOf b.str) (abort "This shouldnt run") (b.listOf b.str);

     

       284
       284
       +
           value = [

     

       285
       285
       +
             "test1"

     

       286
       286
       +
             "test2"

     

       287
       287
       +
           ]; # already a listOf string

     

       288
       288
       +
           testAttrs = {

     

       289
       289
       +
             expected = [

     

       290
       290
       +
               "test1"

     

       291
       291
       +
               "test2"

     

       292
       292
       +
             ]; # Order should be kept

     

       293
       293
       +
           };

     

       294
       294
       +
         };

     

       295
       295
       +
         coerce_attrsOf_str_to_listOf_err_coercer_input = getMatrix {

     

       296
       296
       +
           outerTypeName = "coercedTo";

     

       297
       297
       +
           innerTypeName = "attrsOf_str->listOf_str";

     

       298
       298
       +
           getType = a: b: a.coercedTo (b.attrsOf b.str) builtins.attrValues (b.listOf b.str);

     

       299
       299
       +
           value = [

     

       300
       300
       +
             { }

     

       301
       301
       +
             { }

     

       302
       302
       +
           ]; # not coercible to listOf string, with the given coercer

     

       303
       303
       +
           testAttrs = {

     

       304
       304
       +
             expectedError = {

     

       305
       305
       +
               type = "ThrownError";

     

       306
       306
       +
               msg = ''A definition for option `foo."\[definition 1-entry 1\]"' is not of type `string'.*'';

     

       307
       307
       +
             };

     

       308
       308
       +
           };

     

       309
       309
       +
         };

     

       310
       310
       +
         coerce_attrsOf_str_to_listOf_err_coercer_ouput = getMatrix {

     

       311
       311
       +
           outerTypeName = "coercedTo";

     

       312
       312
       +
           innerTypeName = "attrsOf_str->listOf_str";

     

       313
       313
       +
           getType = a: b: a.coercedTo (b.attrsOf b.str) builtins.attrValues (b.listOf b.str);

     

       314
       314
       +
           value = {

     

       315
       315
       +
             foo = {

     

       316
       316
       +
               bar = 1;

     

       317
       317
       +
             }; # coercer produces wrong type -> [ { bar = 1; } ]

     

       318
       318
       +
           };

     

       319
       319
       +
           testAttrs = {

     

       320
       320
       +
             expectedError = {

     

       321
       321
       +
               type = "ThrownError";

     

       322
       322
       +
               msg = ''A definition for option `foo."\[definition 1-entry 1\]"' is not of type `string'.*'';

     

       323
       323
       +
             };

     

       324
       324
       +
           };

     

       325
       325
       +
         };

     

       326
       326
       +
         coerce_str_to_int_coercer_ouput = getMatrix {

     

       327
       327
       +
           outerTypeName = "coercedTo";

     

       328
       328
       +
           innerTypeName = "int->str";

     

       329
       329
       +
           getType = a: b: a.coercedTo b.int builtins.toString a.str;

     

       330
       330
       +
           value = [ ];

     

       331
       331
       +
           testAttrs = {

     

       332
       332
       +
             expectedError = {

     

       333
       333
       +
               type = "ThrownError";

     

       334
       334
       +
               msg = ''A definition for option `foo' is not of type `string or signed integer convertible to it.*'';

     

       335
       335
       +
             };

     

       336
       336
       +
           };

     

       337
       337
       +
         };

     

       338
       338
       +
       

     

       339
       339
       +
         # Submodule

     

       340
       340
       +
         submodule_with_ok = getMatrix {

     

       341
       341
       +
           outerTypeName = "submoduleWith";

     

       342
       342
       +
           innerTypeName = "mixed_types";

     

       343
       343
       +
           getType =

     

       344
       344
       +
             a: b:

     

       345
       345
       +
             a.submodule (m: {

     

       346
       346
       +
               options.attrs = m.lib.mkOption {

     

       347
       347
       +
                 type = b.attrsOf b.str;

     

       348
       348
       +
               };

     

       349
       349
       +
               options.list = m.lib.mkOption {

     

       350
       350
       +
                 type = b.listOf b.str;

     

       351
       351
       +
               };

     

       352
       352
       +
               options.either = m.lib.mkOption {

     

       353
       353
       +
                 type = b.either a.str a.int;

     

       354
       354
       +
               };

     

       355
       355
       +
             });

     

       356
       356
       +
           value = {

     

       357
       357
       +
             attrs = {

     

       358
       358
       +
               foo = "bar";

     

       359
       359
       +
             };

     

       360
       360
       +
             list = [

     

       361
       361
       +
               "foo"

     

       362
       362
       +
               "bar"

     

       363
       363
       +
             ];

     

       364
       364
       +
             either = 123; # int

     

       365
       365
       +
           };

     

       366
       366
       +
           testAttrs = {

     

       367
       367
       +
             expected = {

     

       368
       368
       +
               attrs = {

     

       369
       369
       +
                 foo = "bar";

     

       370
       370
       +
               };

     

       371
       371
       +
               list = [

     

       372
       372
       +
                 "foo"

     

       373
       373
       +
                 "bar"

     

       374
       374
       +
               ];

     

       375
       375
       +
               either = 123;

     

       376
       376
       +
             };

     

       377
       377
       +
           };

     

       378
       378
       +
         };

     

       379
       379
       +
       }

+22 -2

lib/tests/modules.sh

···

       345
       345
        
       set --

     

       346
       346
        
       checkConfigOutput '^"42"$' config.value ./declare-coerced-value.nix

     

       347
       347
        
       checkConfigOutput '^"24"$' config.value ./declare-coerced-value.nix ./define-value-string.nix

     

       348
       348
       -
       checkConfigError 'A definition for option .* is not.*string or signed integer convertible to it.*. Definition values:\n\s*- In .*: \[ \]' config.value ./declare-coerced-value.nix ./define-value-list.nix

     

       348
       348
       +
       checkConfigError 'A definition for option .*. is not of type .*.\n\s*- In .*: \[ \]' config.value ./declare-coerced-value.nix ./define-value-list.nix

     

       349
       349
        
       

     

       350
       350
        
       # Check coerced option merging.

     

       351
       351
        
       checkConfigError 'The option .value. in .*/declare-coerced-value.nix. is already declared in .*/declare-coerced-value-no-default.nix.' config.value ./declare-coerced-value.nix ./declare-coerced-value-no-default.nix

     

       352
       352
        
       

     

       353
       353
        
       # Check coerced value with unsound coercion

     

       354
       354
        
       checkConfigOutput '^12$' config.value ./declare-coerced-value-unsound.nix

     

       355
       355
       -
       checkConfigError 'A definition for option .* is not of type .*. Definition values:\n\s*- In .*: "1000"' config.value ./declare-coerced-value-unsound.nix ./define-value-string-bigint.nix

     

       355
       355
       +
       checkConfigError 'A definition for option .* is not of type .*.\n\s*- In .*: "1000"' config.value ./declare-coerced-value-unsound.nix ./define-value-string-bigint.nix

     

       356
       356
        
       checkConfigError 'toInt: Could not convert .* to int' config.value ./declare-coerced-value-unsound.nix ./define-value-string-arbitrary.nix

     

       357
       357
        
       

     

       358
       358
        
       # Check `graph` attribute

     
···

       761
       761
        
       checkConfigError 'attribute .*bar.* not found' config.sub.conditionalImportAsNixos.bar ./specialArgs-class.nix

     

       762
       762
        
       checkConfigError 'attribute .*foo.* not found' config.sub.conditionalImportAsDarwin.foo ./specialArgs-class.nix

     

       763
       763
        
       checkConfigOutput '"foo"' config.sub.conditionalImportAsDarwin.bar ./specialArgs-class.nix

     

       764
       764
       +
       # Check that some types expose the 'valueMeta'

     

       765
       765
       +
       checkConfigOutput '\{\}' options.str.valueMeta ./types-valueMeta.nix

     

       766
       766
       +
       checkConfigOutput '["foo", "bar"]' config.attrsOfResult ./types-valueMeta.nix

     

       767
       767
       +
       checkConfigOutput '2' config.listOfResult ./types-valueMeta.nix

     

       768
       768
       +
       

     

       769
       769
       +
       # Check that composed types expose the 'valueMeta'

     

       770
       770
       +
       # attrsOf submodule (also on merged options,types)

     

       771
       771
       +
       checkConfigOutput '42' options.attrsOfModule.valueMeta.attrs.foo.configuration.options.bar.value ./composed-types-valueMeta.nix

     

       772
       772
       +
       checkConfigOutput '42' options.mergedAttrsOfModule.valueMeta.attrs.foo.configuration.options.bar.value ./composed-types-valueMeta.nix

     

       773
       773
       +
       

     

       774
       774
       +
       # listOf submodule (also on merged options,types)

     

       775
       775
       +
       checkConfigOutput '42' config.listResult ./composed-types-valueMeta.nix

     

       776
       776
       +
       checkConfigOutput '42' config.mergedListResult ./composed-types-valueMeta.nix

     

       777
       777
       +
       

     

       778
       778
       +
       # Add check

     

       779
       779
       +
       checkConfigOutput '^0$' config.v1CheckedPass ./add-check.nix

     

       780
       780
       +
       checkConfigError 'A definition for option .* is not of type .signed integer.*' config.v1CheckedFail ./add-check.nix

     

       781
       781
       +
       checkConfigOutput '^true$' config.v2checkedPass ./add-check.nix

     

       782
       782
       +
       checkConfigError 'A definition for option .* is not of type .attribute set of signed integer.*' config.v2checkedFail ./add-check.nix

     

       783
       783
       +
       

     

       764
       784
        
       

     

       765
       785
        
       cat <<EOF

     

       766
       786
        
       ====== module tests ======

+36

lib/tests/modules/add-check.nix

···

       1
       1
       +
       (

     

       2
       2
       +
         { lib, ... }:

     

       3
       3
       +
         let

     

       4
       4
       +
           inherit (lib) types mkOption;

     

       5
       5
       +
           inherit (types) addCheck int attrsOf;

     

       6
       6
       +
       

     

       7
       7
       +
           # type with a v1 merge

     

       8
       8
       +
           v1Type = addCheck int (v: v == 0);

     

       9
       9
       +
       

     

       10
       10
       +
           # type with a v2 merge

     

       11
       11
       +
           v2Type = addCheck (attrsOf int) (v: v ? foo);

     

       12
       12
       +
         in

     

       13
       13
       +
         {

     

       14
       14
       +
           options.v1CheckedPass = mkOption {

     

       15
       15
       +
             type = v1Type;

     

       16
       16
       +
             default = 0;

     

       17
       17
       +
           };

     

       18
       18
       +
           options.v1CheckedFail = mkOption {

     

       19
       19
       +
             type = v1Type;

     

       20
       20
       +
             default = 1;

     

       21
       21
       +
           };

     

       22
       22
       +
           options.v2checkedPass = mkOption {

     

       23
       23
       +
             type = v2Type;

     

       24
       24
       +
             default = {

     

       25
       25
       +
               foo = 1;

     

       26
       26
       +
             };

     

       27
       27
       +
             # plug the value to make test script regex simple

     

       28
       28
       +
             apply = v: v.foo == 1;

     

       29
       29
       +
           };

     

       30
       30
       +
           options.v2checkedFail = mkOption {

     

       31
       31
       +
             type = v2Type;

     

       32
       32
       +
             default = { };

     

       33
       33
       +
             apply = v: lib.deepSeq v v;

     

       34
       34
       +
           };

     

       35
       35
       +
         }

     

       36
       36
       +
       )

+75

lib/tests/modules/composed-types-valueMeta.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) types mkOption;

     

       4
       4
       +
       

     

       5
       5
       +
         attrsOfModule = mkOption {

     

       6
       6
       +
           type = types.attrsOf (

     

       7
       7
       +
             types.submodule {

     

       8
       8
       +
               options.bar = mkOption {

     

       9
       9
       +
                 type = types.int;

     

       10
       10
       +
               };

     

       11
       11
       +
             }

     

       12
       12
       +
           );

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         listOfModule = mkOption {

     

       16
       16
       +
           type = types.listOf (

     

       17
       17
       +
             types.submodule {

     

       18
       18
       +
               options.bar = mkOption {

     

       19
       19
       +
                 type = types.int;

     

       20
       20
       +
               };

     

       21
       21
       +
             }

     

       22
       22
       +
           );

     

       23
       23
       +
         };

     

       24
       24
       +
       

     

       25
       25
       +
       in

     

       26
       26
       +
       {

     

       27
       27
       +
         imports = [

     

       28
       28
       +
           #  Module A

     

       29
       29
       +
           ({

     

       30
       30
       +
             options.attrsOfModule = attrsOfModule;

     

       31
       31
       +
             options.mergedAttrsOfModule = attrsOfModule;

     

       32
       32
       +
             options.listOfModule = listOfModule;

     

       33
       33
       +
             options.mergedListOfModule = listOfModule;

     

       34
       34
       +
           })

     

       35
       35
       +
           # Module B

     

       36
       36
       +
           ({

     

       37
       37
       +
             options.mergedAttrsOfModule = attrsOfModule;

     

       38
       38
       +
             options.mergedListOfModule = listOfModule;

     

       39
       39
       +
           })

     

       40
       40
       +
           # Values

     

       41
       41
       +
           # It is important that the value is defined in a separate module

     

       42
       42
       +
           # Without valueMeta the actual value and sub-options wouldn't be accessible via:

     

       43
       43
       +
           # options.attrsOfModule.type.getSubOptions

     

       44
       44
       +
           ({

     

       45
       45
       +
             attrsOfModule = {

     

       46
       46
       +
               foo.bar = 42;

     

       47
       47
       +
             };

     

       48
       48
       +
             mergedAttrsOfModule = {

     

       49
       49
       +
               foo.bar = 42;

     

       50
       50
       +
             };

     

       51
       51
       +
           })

     

       52
       52
       +
           (

     

       53
       53
       +
             { options, ... }:

     

       54
       54
       +
             {

     

       55
       55
       +
               config.listOfModule = [

     

       56
       56
       +
                 {

     

       57
       57
       +
                   bar = 42;

     

       58
       58
       +
                 }

     

       59
       59
       +
               ];

     

       60
       60
       +
               config.mergedListOfModule = [

     

       61
       61
       +
                 {

     

       62
       62
       +
                   bar = 42;

     

       63
       63
       +
                 }

     

       64
       64
       +
               ];

     

       65
       65
       +
               # Result options to expose the list module to bash as plain attribute path

     

       66
       66
       +
               options.listResult = mkOption {

     

       67
       67
       +
                 default = (builtins.head options.listOfModule.valueMeta.list).configuration.options.bar.value;

     

       68
       68
       +
               };

     

       69
       69
       +
               options.mergedListResult = mkOption {

     

       70
       70
       +
                 default = (builtins.head options.mergedListOfModule.valueMeta.list).configuration.options.bar.value;

     

       71
       71
       +
               };

     

       72
       72
       +
             }

     

       73
       73
       +
           )

     

       74
       74
       +
         ];

     

       75
       75
       +
       }

+60

lib/tests/modules/types-valueMeta.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) types mkOption;

     

       4
       4
       +
       

     

       5
       5
       +
         inherit (types)

     

       6
       6
       +
           # attrsOf uses attrsWith internally

     

       7
       7
       +
           attrsOf

     

       8
       8
       +
           listOf

     

       9
       9
       +
           submoduleOf

     

       10
       10
       +
           str

     

       11
       11
       +
           ;

     

       12
       12
       +
       in

     

       13
       13
       +
       {

     

       14
       14
       +
         imports = [

     

       15
       15
       +
           (

     

       16
       16
       +
             { options, ... }:

     

       17
       17
       +
             {

     

       18
       18
       +
               # Should have an empty valueMeta

     

       19
       19
       +
               options.str = mkOption {

     

       20
       20
       +
                 type = str;

     

       21
       21
       +
               };

     

       22
       22
       +
       

     

       23
       23
       +
               # Should have some valueMeta which is an attribute set of the nested valueMeta

     

       24
       24
       +
               options.attrsOf = mkOption {

     

       25
       25
       +
                 type = attrsOf str;

     

       26
       26
       +
                 default = {

     

       27
       27
       +
                   foo = "foo";

     

       28
       28
       +
                   bar = "bar";

     

       29
       29
       +
                 };

     

       30
       30
       +
               };

     

       31
       31
       +
               options.attrsOfResult = mkOption {

     

       32
       32
       +
                 default = builtins.attrNames options.attrsOf.valueMeta.attrs;

     

       33
       33
       +
               };

     

       34
       34
       +
       

     

       35
       35
       +
               # Should have some valueMeta which is the list of the nested valueMeta of types.str

     

       36
       36
       +
               # [ {} {} ]

     

       37
       37
       +
               options.listOf = mkOption {

     

       38
       38
       +
                 type = listOf str;

     

       39
       39
       +
                 default = [

     

       40
       40
       +
                   "foo"

     

       41
       41
       +
                   "bar"

     

       42
       42
       +
                 ];

     

       43
       43
       +
               };

     

       44
       44
       +
               options.listOfResult = mkOption {

     

       45
       45
       +
                 default = builtins.length options.listOf.valueMeta.list;

     

       46
       46
       +
               };

     

       47
       47
       +
       

     

       48
       48
       +
               # Should have some valueMeta which is the submodule evaluation

     

       49
       49
       +
               # { _module, options, config, ...}

     

       50
       50
       +
               options.submoduleOf = mkOption {

     

       51
       51
       +
                 type = submoduleOf {

     

       52
       52
       +
                   options.str = mkOption {

     

       53
       53
       +
                     type = str;

     

       54
       54
       +
                   };

     

       55
       55
       +
                 };

     

       56
       56
       +
               };

     

       57
       57
       +
             }

     

       58
       58
       +
           )

     

       59
       59
       +
         ];

     

       60
       60
       +
       }

+25

lib/tests/nix-unit.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         pkgs ? import ../.. { },

     

       3
       3
       +
       }:

     

       4
       4
       +
       let

     

       5
       5
       +
         prevNixpkgs = pkgs.fetchFromGitHub {

     

       6
       6
       +
           owner = "nixos";

     

       7
       7
       +
           repo = "nixpkgs";

     

       8
       8
       +
           # Parent commit of [#391544](https://github.com/NixOS/nixpkgs/pull/391544)

     

       9
       9
       +
           # Which was before the type.merge.v2 introduction

     

       10
       10
       +
           rev = "bcf94dd3f07189b7475d823c8d67d08b58289905";

     

       11
       11
       +
           hash = "sha256-MuMiIY3MX5pFSOCvutmmRhV6RD0R3CG0Hmazkg8cMFI=";

     

       12
       12
       +
         };

     

       13
       13
       +
       in

     

       14
       14
       +
       (pkgs.runCommand "lib-cross-eval-merge-v2"

     

       15
       15
       +
         {

     

       16
       16
       +
           nativeBuildInputs = [ pkgs.nix-unit ];

     

       17
       17
       +
         }

     

       18
       18
       +
         ''

     

       19
       19
       +
           export HOME=$TMPDIR

     

       20
       20
       +
           nix-unit --eval-store "$HOME" ${./checkAndMergeCompat.nix} \

     

       21
       21
       +
             --arg currLibPath "${../.}" \

     

       22
       22
       +
             --arg prevLibPath "${prevNixpkgs}/lib"

     

       23
       23
       +
           mkdir $out

     

       24
       24
       +
         ''

     

       25
       25
       +
       )

lib/tests/release.nix

···

       29
       29
        
       pkgsBB.symlinkJoin {

     

       30
       30
        
         name = "nixpkgs-lib-tests";

     

       31
       31
        
         paths = map testWithNix nixVersions ++ [

     

       32
       32
       +
           (import ./nix-unit.nix {

     

       33
       33
       +
             inherit pkgs;

     

       34
       34
       +
           })

     

       32
       35
        
           (import ./maintainers.nix {

     

       33
       36
        
             inherit pkgs;

     

       34
       37
        
             lib = import ../.;

+201 -76

lib/types.nix

···

       20
       20
        
           toList

     

       21
       21
        
           ;

     

       22
       22
        
         inherit (lib.lists)

     

       23
       23
       -
           all

     

       24
       23
        
           concatLists

     

       25
       24
        
           count

     

       26
       25
        
           elemAt

     
···

       48
       47
        
           mergeOneOption

     

       49
       48
        
           mergeUniqueOption

     

       50
       49
        
           showFiles

     

       50
       50
       +
           showDefs

     

       51
       51
        
           showOption

     

       52
       52
        
           ;

     

       53
       53
        
         inherit (lib.strings)

     
···

       98
       98
        
               lib.optionalString (loc != null) "of the option `${showOption loc}` "

     

       99
       99
        
             }is accessed, use `${lib.optionalString (loc != null) "type."}nestedTypes.elemType` instead.

     

       100
       100
        
           '' payload.elemType;

     

       101
       101
       +
       

     

       102
       102
       +
         checkDefsForError =

     

       103
       103
       +
           check: loc: defs:

     

       104
       104
       +
           let

     

       105
       105
       +
             invalidDefs = filter (def: !check def.value) defs;

     

       106
       106
       +
           in

     

       107
       107
       +
           if invalidDefs != [ ] then { message = "Definition values: ${showDefs invalidDefs}"; } else null;

     

       101
       108
        
       

     

       102
       109
        
         outer_types = rec {

     

       103
       110
        
           isType = type: x: (x._type or "") == type;

     
···

       705
       712
        
                 }";

     

       706
       713
        
                 descriptionClass = "composite";

     

       707
       714
        
                 check = isList;

     

       708
       708
       -
                 merge =

     

       709
       709
       -
                   loc: defs:

     

       710
       710
       -
                   map (x: x.value) (

     

       711
       711
       -
                     filter (x: x ? value) (

     

       712
       712
       -
                       concatLists (

     

       713
       713
       -
                         imap1 (

     

       714
       714
       -
                           n: def:

     

       715
       715
       +
                 merge = {

     

       716
       716
       +
                   __functor =

     

       717
       717
       +
                     self: loc: defs:

     

       718
       718
       +
                     (self.v2 { inherit loc defs; }).value;

     

       719
       719
       +
                   v2 =

     

       720
       720
       +
                     { loc, defs }:

     

       721
       721
       +
                     let

     

       722
       722
       +
                       evals = filter (x: x.optionalValue ? value) (

     

       723
       723
       +
                         concatLists (

     

       715
       724
        
                           imap1 (

     

       716
       716
       -
                             m: def':

     

       717
       717
       -
                             (mergeDefinitions (loc ++ [ "[definition ${toString n}-entry ${toString m}]" ]) elemType [

     

       718
       718
       -
                               {

     

       719
       719
       -
                                 inherit (def) file;

     

       720
       720
       -
                                 value = def';

     

       721
       721
       -
                               }

     

       722
       722
       -
                             ]).optionalValue

     

       723
       723
       -
                           ) def.value

     

       724
       724
       -
                         ) defs

     

       725
       725
       -
                       )

     

       726
       726
       -
                     )

     

       727
       727
       -
                   );

     

       725
       725
       +
                             n: def:

     

       726
       726
       +
                             imap1 (

     

       727
       727
       +
                               m: def':

     

       728
       728
       +
                               (mergeDefinitions (loc ++ [ "[definition ${toString n}-entry ${toString m}]" ]) elemType [

     

       729
       729
       +
                                 {

     

       730
       730
       +
                                   inherit (def) file;

     

       731
       731
       +
                                   value = def';

     

       732
       732
       +
                                 }

     

       733
       733
       +
                               ])

     

       734
       734
       +
                             ) def.value

     

       735
       735
       +
                           ) defs

     

       736
       736
       +
                         )

     

       737
       737
       +
                       );

     

       738
       738
       +
                     in

     

       739
       739
       +
                     {

     

       740
       740
       +
                       headError = checkDefsForError check loc defs;

     

       741
       741
       +
                       value = map (x: x.optionalValue.value or x.mergedValue) evals;

     

       742
       742
       +
                       valueMeta.list = map (v: v.checkedAndMerged.valueMeta) evals;

     

       743
       743
       +
                     };

     

       744
       744
       +
                 };

     

       728
       745
        
                 emptyValue = {

     

       729
       746
        
                   value = [ ];

     

       730
       747
        
                 };

     
···

       801
       818
        
                 lazy ? false,

     

       802
       819
        
                 placeholder ? "name",

     

       803
       820
        
               }:

     

       804
       804
       -
               mkOptionType {

     

       821
       821
       +
               mkOptionType rec {

     

       805
       822
        
                 name = if lazy then "lazyAttrsOf" else "attrsOf";

     

       806
       823
        
                 description =

     

       807
       824
        
                   (if lazy then "lazy attribute set" else "attribute set")

     

       808
       825
        
                   + " of ${optionDescriptionPhrase (class: class == "noun" || class == "composite") elemType}";

     

       809
       826
        
                 descriptionClass = "composite";

     

       810
       827
        
                 check = isAttrs;

     

       811
       811
       -
                 merge =

     

       812
       812
       -
                   if lazy then

     

       813
       813
       -
                     (

     

       814
       814
       -
                       # Lazy merge Function

     

       815
       815
       -
                       loc: defs:

     

       816
       816
       -
                       zipAttrsWith

     

       817
       817
       -
                         (

     

       818
       818
       -
                           name: defs:

     

       819
       819
       -
                           let

     

       820
       820
       -
                             merged = mergeDefinitions (loc ++ [ name ]) elemType defs;

     

       821
       821
       -
                             # mergedValue will trigger an appropriate error when accessed

     

       822
       822
       -
                           in

     

       823
       823
       -
                           merged.optionalValue.value or elemType.emptyValue.value or merged.mergedValue

     

       824
       824
       -
                         )

     

       825
       825
       -
                         # Push down position info.

     

       826
       826
       -
                         (pushPositions defs)

     

       827
       827
       -
                     )

     

       828
       828
       -
                   else

     

       829
       829
       -
                     (

     

       830
       830
       -
                       # Non-lazy merge Function

     

       831
       831
       -
                       loc: defs:

     

       832
       832
       -
                       mapAttrs (n: v: v.value) (

     

       833
       833
       -
                         filterAttrs (n: v: v ? value) (

     

       834
       834
       -
                           zipAttrsWith (name: defs: (mergeDefinitions (loc ++ [ name ]) elemType (defs)).optionalValue)

     

       835
       835
       -
                             # Push down position info.

     

       836
       836
       -
                             (pushPositions defs)

     

       837
       837
       -
                         )

     

       838
       838
       -
                       )

     

       839
       839
       -
                     );

     

       828
       828
       +
                 merge = {

     

       829
       829
       +
                   __functor =

     

       830
       830
       +
                     self: loc: defs:

     

       831
       831
       +
                     (self.v2 { inherit loc defs; }).value;

     

       832
       832
       +
                   v2 =

     

       833
       833
       +
                     { loc, defs }:

     

       834
       834
       +
                     let

     

       835
       835
       +
                       evals =

     

       836
       836
       +
                         if lazy then

     

       837
       837
       +
                           zipAttrsWith (name: defs: mergeDefinitions (loc ++ [ name ]) elemType defs) (pushPositions defs)

     

       838
       838
       +
                         else

     

       839
       839
       +
                           # Filtering makes the merge function more strict

     

       840
       840
       +
                           # Meaning it is less lazy

     

       841
       841
       +
                           filterAttrs (n: v: v.optionalValue ? value) (

     

       842
       842
       +
                             zipAttrsWith (name: defs: mergeDefinitions (loc ++ [ name ]) elemType defs) (pushPositions defs)

     

       843
       843
       +
                           );

     

       844
       844
       +
                     in

     

       845
       845
       +
                     {

     

       846
       846
       +
                       headError = checkDefsForError check loc defs;

     

       847
       847
       +
                       value = mapAttrs (

     

       848
       848
       +
                         n: v:

     

       849
       849
       +
                         if lazy then

     

       850
       850
       +
                           v.optionalValue.value or elemType.emptyValue.value or v.mergedValue

     

       851
       851
       +
                         else

     

       852
       852
       +
                           v.optionalValue.value

     

       853
       853
       +
                       ) evals;

     

       854
       854
       +
                       valueMeta.attrs = mapAttrs (n: v: v.checkedAndMerged.valueMeta) evals;

     

       855
       855
       +
                     };

     

       856
       856
       +
                 };

     

       857
       857
       +
       

     

       840
       858
        
                 emptyValue = {

     

       841
       859
        
                   value = { };

     

       842
       860
        
                 };

     
···

       1218
       1236
        
       

     

       1219
       1237
        
                 name = "submodule";

     

       1220
       1238
        
       

     

       1239
       1239
       +
                 check = x: isAttrs x || isFunction x || path.check x;

     

       1221
       1240
        
               in

     

       1222
       1241
        
               mkOptionType {

     

       1223
       1242
        
                 inherit name;

     
···

       1229
       1248
        
                       docsEval = base.extendModules { modules = [ noCheckForDocsModule ]; };

     

       1230
       1249
        
                     in

     

       1231
       1250
        
                     docsEval._module.freeformType.description or name;

     

       1232
       1232
       -
                 check = x: isAttrs x || isFunction x || path.check x;

     

       1233
       1233
       -
                 merge =

     

       1234
       1234
       -
                   loc: defs:

     

       1235
       1235
       -
                   (base.extendModules {

     

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

     

       1237
       1237
       -
                     prefix = loc;

     

       1238
       1238
       -
                   }).config;

     

       1251
       1251
       +
                 inherit check;

     

       1252
       1252
       +
                 merge = {

     

       1253
       1253
       +
                   __functor =

     

       1254
       1254
       +
                     self: loc: defs:

     

       1255
       1255
       +
                     (self.v2 { inherit loc defs; }).value;

     

       1256
       1256
       +
                   v2 =

     

       1257
       1257
       +
                     { loc, defs }:

     

       1258
       1258
       +
                     let

     

       1259
       1259
       +
                       configuration = base.extendModules {

     

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

     

       1261
       1261
       +
                         prefix = loc;

     

       1262
       1262
       +
                       };

     

       1263
       1263
       +
                     in

     

       1264
       1264
       +
                     {

     

       1265
       1265
       +
                       headError = checkDefsForError check loc defs;

     

       1266
       1266
       +
                       value = configuration.config;

     

       1267
       1267
       +
                       valueMeta = { inherit configuration; };

     

       1268
       1268
       +
                     };

     

       1269
       1269
       +
                 };

     

       1239
       1270
        
                 emptyValue = {

     

       1240
       1271
        
                   value = { };

     

       1241
       1272
        
                 };

     
···

       1383
       1414
        
                     }";

     

       1384
       1415
        
                 descriptionClass = "conjunction";

     

       1385
       1416
        
                 check = x: t1.check x || t2.check x;

     

       1386
       1386
       -
                 merge =

     

       1387
       1387
       -
                   loc: defs:

     

       1388
       1388
       -
                   let

     

       1389
       1389
       -
                     defList = map (d: d.value) defs;

     

       1390
       1390
       -
                   in

     

       1391
       1391
       -
                   if all (x: t1.check x) defList then

     

       1392
       1392
       -
                     t1.merge loc defs

     

       1393
       1393
       -
                   else if all (x: t2.check x) defList then

     

       1394
       1394
       -
                     t2.merge loc defs

     

       1395
       1395
       -
                   else

     

       1396
       1396
       -
                     mergeOneOption loc defs;

     

       1417
       1417
       +
                 merge = {

     

       1418
       1418
       +
                   __functor =

     

       1419
       1419
       +
                     self: loc: defs:

     

       1420
       1420
       +
                     (self.v2 { inherit loc defs; }).value;

     

       1421
       1421
       +
                   v2 =

     

       1422
       1422
       +
                     { loc, defs }:

     

       1423
       1423
       +
                     let

     

       1424
       1424
       +
                       t1CheckedAndMerged =

     

       1425
       1425
       +
                         if t1.merge ? v2 then

     

       1426
       1426
       +
                           t1.merge.v2 { inherit loc defs; }

     

       1427
       1427
       +
                         else

     

       1428
       1428
       +
                           {

     

       1429
       1429
       +
                             value = t1.merge loc defs;

     

       1430
       1430
       +
                             headError = checkDefsForError t1.check loc defs;

     

       1431
       1431
       +
                             valueMeta = { };

     

       1432
       1432
       +
                           };

     

       1433
       1433
       +
                       t2CheckedAndMerged =

     

       1434
       1434
       +
                         if t2.merge ? v2 then

     

       1435
       1435
       +
                           t2.merge.v2 { inherit loc defs; }

     

       1436
       1436
       +
                         else

     

       1437
       1437
       +
                           {

     

       1438
       1438
       +
                             value = t2.merge loc defs;

     

       1439
       1439
       +
                             headError = checkDefsForError t2.check loc defs;

     

       1440
       1440
       +
                             valueMeta = { };

     

       1441
       1441
       +
                           };

     

       1442
       1442
       +
       

     

       1443
       1443
       +
                       checkedAndMerged =

     

       1444
       1444
       +
                         if t1CheckedAndMerged.headError == null then

     

       1445
       1445
       +
                           t1CheckedAndMerged

     

       1446
       1446
       +
                         else if t2CheckedAndMerged.headError == null then

     

       1447
       1447
       +
                           t2CheckedAndMerged

     

       1448
       1448
       +
                         else

     

       1449
       1449
       +
                           rec {

     

       1450
       1450
       +
                             valueMeta = {

     

       1451
       1451
       +
                               inherit headError;

     

       1452
       1452
       +
                             };

     

       1453
       1453
       +
                             headError = {

     

       1454
       1454
       +
                               message = "The option `${showOption loc}` is neither a value of type `${t1.description}` nor `${t2.description}`, Definition values: ${showDefs defs}";

     

       1455
       1455
       +
                             };

     

       1456
       1456
       +
                             value = abort "(t.merge.v2 defs).value must only be accessed when `.headError == null`. This is a bug in code that consumes a module system type.";

     

       1457
       1457
       +
                           };

     

       1458
       1458
       +
                     in

     

       1459
       1459
       +
                     checkedAndMerged;

     

       1460
       1460
       +
                 };

     

       1397
       1461
        
                 typeMerge =

     

       1398
       1462
        
                   f':

     

       1399
       1463
        
                   let

     
···

       1434
       1498
        
                   optionDescriptionPhrase (class: class == "noun") coercedType

     

       1435
       1499
        
                 } convertible to it";

     

       1436
       1500
        
                 check = x: (coercedType.check x && finalType.check (coerceFunc x)) || finalType.check x;

     

       1437
       1437
       -
                 merge =

     

       1438
       1438
       -
                   loc: defs:

     

       1439
       1439
       -
                   let

     

       1440
       1440
       -
                     coerceVal = val: if coercedType.check val then coerceFunc val else val;

     

       1441
       1441
       -
                   in

     

       1442
       1442
       -
                   finalType.merge loc (map (def: def // { value = coerceVal def.value; }) defs);

     

       1501
       1501
       +
                 merge = {

     

       1502
       1502
       +
                   __functor =

     

       1503
       1503
       +
                     self: loc: defs:

     

       1504
       1504
       +
                     (self.v2 { inherit loc defs; }).value;

     

       1505
       1505
       +
                   v2 =

     

       1506
       1506
       +
                     { loc, defs }:

     

       1507
       1507
       +
                     let

     

       1508
       1508
       +
                       finalDefs = (

     

       1509
       1509
       +
                         map (

     

       1510
       1510
       +
                           def:

     

       1511
       1511
       +
                           def

     

       1512
       1512
       +
                           // {

     

       1513
       1513
       +
                             value =

     

       1514
       1514
       +
                               let

     

       1515
       1515
       +
                                 merged = coercedType.merge.v2 {

     

       1516
       1516
       +
                                   inherit loc;

     

       1517
       1517
       +
                                   defs = [ def ];

     

       1518
       1518
       +
                                 };

     

       1519
       1519
       +
                               in

     

       1520
       1520
       +
                               if coercedType.merge ? v2 then

     

       1521
       1521
       +
                                 if merged.headError == null then coerceFunc def.value else def.value

     

       1522
       1522
       +
                               else if coercedType.check def.value then

     

       1523
       1523
       +
                                 coerceFunc def.value

     

       1524
       1524
       +
                               else

     

       1525
       1525
       +
                                 def.value;

     

       1526
       1526
       +
                           }

     

       1527
       1527
       +
                         ) defs

     

       1528
       1528
       +
                       );

     

       1529
       1529
       +
                     in

     

       1530
       1530
       +
                     if finalType.merge ? v2 then

     

       1531
       1531
       +
                       finalType.merge.v2 {

     

       1532
       1532
       +
                         inherit loc;

     

       1533
       1533
       +
                         defs = finalDefs;

     

       1534
       1534
       +
                       }

     

       1535
       1535
       +
                     else

     

       1536
       1536
       +
                       {

     

       1537
       1537
       +
                         value = finalType.merge loc finalDefs;

     

       1538
       1538
       +
                         valueMeta = { };

     

       1539
       1539
       +
                         headError = checkDefsForError check loc defs;

     

       1540
       1540
       +
                       };

     

       1541
       1541
       +
                 };

     

       1443
       1542
        
                 emptyValue = finalType.emptyValue;

     

       1444
       1543
        
                 getSubOptions = finalType.getSubOptions;

     

       1445
       1544
        
                 getSubModules = finalType.getSubModules;

     
···

       1451
       1550
        
                 nestedTypes.coercedType = coercedType;

     

       1452
       1551
        
                 nestedTypes.finalType = finalType;

     

       1453
       1552
        
               };

     

       1553
       1553
       +
       

     

       1454
       1554
        
             /**

     

       1455
       1555
        
               Augment the given type with an additional type check function.

     

       1456
       1556
        
       

     
···

       1459
       1559
        
               Fixing is not trivial, we appreciate any help!

     

       1460
       1560
        
               :::

     

       1461
       1561
        
             */

     

       1462
       1462
       -
             addCheck = elemType: check: elemType // { check = x: elemType.check x && check x; };

     

       1463
       1463
       -
       

     

       1562
       1562
       +
             addCheck =

     

       1563
       1563
       +
               elemType: check:

     

       1564
       1564
       +
               if elemType.merge ? v2 then

     

       1565
       1565
       +
                 elemType

     

       1566
       1566
       +
                 // {

     

       1567
       1567
       +
                   check = x: elemType.check x && check x;

     

       1568
       1568
       +
                   merge = {

     

       1569
       1569
       +
                     __functor =

     

       1570
       1570
       +
                       self: loc: defs:

     

       1571
       1571
       +
                       (self.v2 { inherit loc defs; }).value;

     

       1572
       1572
       +
                     v2 =

     

       1573
       1573
       +
                       { loc, defs }:

     

       1574
       1574
       +
                       let

     

       1575
       1575
       +
                         orig = elemType.merge.v2 { inherit loc defs; };

     

       1576
       1576
       +
                         headError' = if orig.headError != null then orig.headError else checkDefsForError check loc defs;

     

       1577
       1577
       +
                       in

     

       1578
       1578
       +
                       orig

     

       1579
       1579
       +
                       // {

     

       1580
       1580
       +
                         headError = headError';

     

       1581
       1581
       +
                       };

     

       1582
       1582
       +
                   };

     

       1583
       1583
       +
                 }

     

       1584
       1584
       +
               else

     

       1585
       1585
       +
                 elemType

     

       1586
       1586
       +
                 // {

     

       1587
       1587
       +
                   check = x: elemType.check x && check x;

     

       1588
       1588
       +
                 };

     

       1464
       1589
        
           };

     

       1465
       1590
        
       

     

       1466
       1591
        
           /**