···

       
87
       
 
       
    let

     

       
88
       
 
       
      toClosureList = file: parentKey: imap (n: x:

     

       
89
       
 
       
        if isAttrs x || isFunction x then

     

       
90
       
-
       
          unifyModuleSyntax file "${parentKey}:anon-${toString n}" (applyIfFunction x args)

     

       
91
       
 
       
        else

     

       
92
       
 
       
          unifyModuleSyntax (toString x) (toString x) (applyIfFunction (import x) args));

     

       
93
       
 
       
    in

     
···

       
120
       
 
       


     

       
121
       
 
       
  applyIfFunction = f: arg@{ config, options, lib }: if isFunction f then

     

       
122
       
 
       
    let

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
123
       
 
       
      requiredArgs = builtins.attrNames (builtins.functionArgs f);

     

       
124
       
 
       
      extraArgs = builtins.listToAttrs (map (name: {

     

       
125
       
 
       
        inherit name;

     
···

       
128
       
 
       
    in f (extraArgs // arg)

     

       
129
       
 
       
  else

     

       
130
       
 
       
    f;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
131
       
 
       


     

       
132
       
 
       
  /* Merge a list of modules.  This will recurse over the option

     

       
133
       
 
       
     declarations in all modules, combining them into a single set.

     
···

       
206
       
 
       
             current option declaration as the file use for the submodule.  If the

     

       
207
       
 
       
             submodule defines any filename, then we ignore the enclosing option file. */

     

       
208
       
 
       
          options' = toList opt.options.options;

     

       
209
       
-
       
          addModuleFile = m:

     

       
210
       
-
       
            if isFunction m then args: { _file = opt.file; } // (m args)

     

       
211
       
-
       
            else { _file = opt.file; } // m;

     

       
212
       
 
       
          coerceOption = file: opt:

     

       
213
       
-
       
            if isFunction opt then args: { _file = file; } // (opt args)

     

       
214
       
-
       
            else { _file = file; options = opt; };

     

       
215
       
 
       
          getSubModules = opt.options.type.getSubModules or null;

     

       
216
       
 
       
          submodules =

     

       
217
       
-
       
            if getSubModules != null then map addModuleFile getSubModules ++ res.options

     

       
218
       
 
       
            else if opt.options ? options then map (coerceOption opt.file) options' ++ res.options

     

       
219
       
 
       
            else res.options;

     

       
220
       
 
       
        in opt.options // res //

     

···

       
87
       
 
       
    let

     

       
88
       
 
       
      toClosureList = file: parentKey: imap (n: x:

     

       
89
       
 
       
        if isAttrs x || isFunction x then

     

       
90
       
+
       
          unifyModuleSyntax file "${parentKey}:anon-${toString n}" (unpackSubmodule applyIfFunction x args)

     

       
91
       
 
       
        else

     

       
92
       
 
       
          unifyModuleSyntax (toString x) (toString x) (applyIfFunction (import x) args));

     

       
93
       
 
       
    in

     
···

       
120
       
 
       


     

       
121
       
 
       
  applyIfFunction = f: arg@{ config, options, lib }: if isFunction f then

     

       
122
       
 
       
    let

     

       
123
       
+
       
      # Module arguments are resolved in a strict manner when attribute set

     

       
124
       
+
       
      # deconstruction is used.  As the arguments are now defined with the

     

       
125
       
+
       
      # config.__interanl.args option, the strictness used on the attribute

     

       
126
       
+
       
      # set argument would cause an infinite loop, if the result of the

     

       
127
       
+
       
      # option is given as argument.

     

       
128
       
+
       
      #

     

       
129
       
+
       
      # To work-around the strictness issue on the deconstruction of the

     

       
130
       
+
       
      # attributes set argument, we create a new attribute set which is

     

       
131
       
+
       
      # constructed to satisfy the expected set of attributes.  Thus calling

     

       
132
       
+
       
      # a module will resolve strictly the attributes used as argument but

     

       
133
       
+
       
      # not their values.  The values are forwarding the result of the

     

       
134
       
+
       
      # evaluation of the option.

     

       
135
       
 
       
      requiredArgs = builtins.attrNames (builtins.functionArgs f);

     

       
136
       
 
       
      extraArgs = builtins.listToAttrs (map (name: {

     

       
137
       
 
       
        inherit name;

     
···

       
140
       
 
       
    in f (extraArgs // arg)

     

       
141
       
 
       
  else

     

       
142
       
 
       
    f;

     

       
143
       
+
       


     

       
144
       
+
       
  /* We have to pack and unpack submodules. We cannot wrap the expected

     

       
145
       
+
       
     result of the function as we would no longer be able to list the arguments

     

       
146
       
+
       
     of the submodule. (see applyIfFunction) */

     

       
147
       
+
       
  unpackSubmodule = unpack: m: args:

     

       
148
       
+
       
    if isType "submodule" m then

     

       
149
       
+
       
      { _file = m.file; } // (unpack m.submodule args)

     

       
150
       
+
       
    else unpack m args;

     

       
151
       
+
       


     

       
152
       
+
       
  packSubmodule = file: m:

     

       
153
       
+
       
    { _type = "submodule"; file = file; submodule = m; };

     

       
154
       
 
       


     

       
155
       
 
       
  /* Merge a list of modules.  This will recurse over the option

     

       
156
       
 
       
     declarations in all modules, combining them into a single set.

     
···

       
229
       
 
       
             current option declaration as the file use for the submodule.  If the

     

       
230
       
 
       
             submodule defines any filename, then we ignore the enclosing option file. */

     

       
231
       
 
       
          options' = toList opt.options.options;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
232
       
 
       
          coerceOption = file: opt:

     

       
233
       
+
       
            if isFunction opt then packSubmodule file opt

     

       
234
       
+
       
            else packSubmodule file { options = opt; };

     

       
235
       
 
       
          getSubModules = opt.options.type.getSubModules or null;

     

       
236
       
 
       
          submodules =

     

       
237
       
+
       
            if getSubModules != null then map (packSubmodule opt.file) getSubModules ++ res.options

     

       
238
       
 
       
            else if opt.options ? options then map (coerceOption opt.file) options' ++ res.options

     

       
239
       
 
       
            else res.options;

     

       
240
       
 
       
        in opt.options // res //