---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
  ],
  ellipsis: false,
 },
 definition: LetIn {
  bindings: [
   Inherit(
    Some(
     Variable {
      identifier: "lib",
      position: (4, 12),
     },
    ),
    [
     Raw {
      content: "all",
      position: (5, 5),
     },
     Raw {
      content: "any",
      position: (6, 5),
     },
     Raw {
      content: "attrByPath",
      position: (7, 5),
     },
     Raw {
      content: "attrNames",
      position: (8, 5),
     },
     Raw {
      content: "catAttrs",
      position: (9, 5),
     },
     Raw {
      content: "concatLists",
      position: (10, 5),
     },
     Raw {
      content: "concatMap",
      position: (11, 5),
     },
     Raw {
      content: "concatStringsSep",
      position: (12, 5),
     },
     Raw {
      content: "elem",
      position: (13, 5),
     },
     Raw {
      content: "filter",
      position: (14, 5),
     },
     Raw {
      content: "findFirst",
      position: (15, 5),
     },
     Raw {
      content: "foldl'",
      position: (16, 5),
     },
     Raw {
      content: "getAttrFromPath",
      position: (17, 5),
     },
     Raw {
      content: "head",
      position: (18, 5),
     },
     Raw {
      content: "id",
      position: (19, 5),
     },
     Raw {
      content: "imap1",
      position: (20, 5),
     },
     Raw {
      content: "isAttrs",
      position: (21, 5),
     },
     Raw {
      content: "isBool",
      position: (22, 5),
     },
     Raw {
      content: "isFunction",
      position: (23, 5),
     },
     Raw {
      content: "isList",
      position: (24, 5),
     },
     Raw {
      content: "isString",
      position: (25, 5),
     },
     Raw {
      content: "length",
      position: (26, 5),
     },
     Raw {
      content: "mapAttrs",
      position: (27, 5),
     },
     Raw {
      content: "mapAttrsToList",
      position: (28, 5),
     },
     Raw {
      content: "mapAttrsRecursiveCond",
      position: (29, 5),
     },
     Raw {
      content: "min",
      position: (30, 5),
     },
     Raw {
      content: "optional",
      position: (31, 5),
     },
     Raw {
      content: "optionalAttrs",
      position: (32, 5),
     },
     Raw {
      content: "optionalString",
      position: (33, 5),
     },
     Raw {
      content: "recursiveUpdate",
      position: (34, 5),
     },
     Raw {
      content: "reverseList",
      position: (35, 5),
     },
     Raw {
      content: "sort",
      position: (35, 17),
     },
     Raw {
      content: "setAttrByPath",
      position: (36, 5),
     },
     Raw {
      content: "toList",
      position: (37, 5),
     },
     Raw {
      content: "types",
      position: (38, 5),
     },
     Raw {
      content: "warnIf",
      position: (39, 5),
     },
     Raw {
      content: "zipAttrsWith",
      position: (40, 5),
     },
    ],
   ),
   Inherit(
    Some(
     PropertyAccess {
      expression: Variable {
       identifier: "lib",
       position: (42, 12),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (42, 16),
        },
       ],
      },
      default: None,
     },
    ),
    [
     Raw {
      content: "isOption",
      position: (43, 5),
     },
     Raw {
      content: "mkOption",
      position: (44, 5),
     },
     Raw {
      content: "showDefs",
      position: (45, 5),
     },
     Raw {
      content: "showFiles",
      position: (46, 5),
     },
     Raw {
      content: "showOption",
      position: (47, 5),
     },
     Raw {
      content: "unknownModule",
      position: (48, 5),
     },
     Raw {
      content: "literalExpression",
      position: (49, 5),
     },
    ],
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "showDeclPrefix",
       position: (52, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "loc",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "decl",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "prefix",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: String {
        parts: [
         Raw {
          content: " - option(s) with prefix `",
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "showOption",
            position: (53, 34),
           },
           arguments: [
            BinaryOperation {
             operator: Concatenation,
             operands: [
              Variable {
               identifier: "loc",
               position: (53, 46),
              },
              List {
               elements: [
                Variable {
                 identifier: "prefix",
                 position: (53, 54),
                },
               ],
               position: (53, 53),
              },
             ],
             position: (53, 50),
            },
           ],
          },
         },
         Raw {
          content: "' in module `",
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "decl",
            position: (53, 78),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "_file",
              position: (53, 83),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "'",
         },
        ],
        position: (53, 5),
       },
       position: (52, 31),
      },
      position: (52, 25),
     },
     position: (52, 20),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "showRawDecls",
       position: (54, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "loc",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "decls",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "concatStringsSep",
        position: (55, 5),
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "\n",
          },
         ],
         position: (55, 22),
        },
        FunctionApplication {
         function: Variable {
          identifier: "sort",
          position: (56, 8),
         },
         arguments: [
          Function {
           argument: Some(
            "a",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "b",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: BinaryOperation {
             operator: LessThan,
             operands: [
              Variable {
               identifier: "a",
               position: (56, 20),
              },
              Variable {
               identifier: "b",
               position: (56, 24),
              },
             ],
             position: (56, 22),
            },
            position: (56, 17),
           },
           position: (56, 14),
          },
          FunctionApplication {
           function: Variable {
            identifier: "concatMap",
            position: (57, 10),
           },
           arguments: [
            Function {
             argument: Some(
              "decl",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: FunctionApplication {
              function: Variable {
               identifier: "map",
               position: (58, 18),
              },
              arguments: [
               FunctionApplication {
                function: Variable {
                 identifier: "showDeclPrefix",
                 position: (59, 14),
                },
                arguments: [
                 Variable {
                  identifier: "loc",
                  position: (59, 29),
                 },
                 Variable {
                  identifier: "decl",
                  position: (59, 33),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "attrNames",
                 position: (60, 14),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "decl",
                   position: (60, 24),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "options",
                     position: (60, 29),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              ],
             },
             position: (58, 12),
            },
            Variable {
             identifier: "decls",
             position: (62, 11),
            },
           ],
          },
         ],
        },
       ],
      },
      position: (54, 23),
     },
     position: (54, 18),
    },
   ),
  ],
  target: Map {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "evalModules",
        position: (104, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "evalModulesArgs",
      ),
      arguments: FunctionArguments {
       arguments: [
        FunctionArgument {
         identifier: "check",
         default: Some(
          Variable {
           identifier: "true",
           position: (115, 27),
          },
         ),
        },
        FunctionArgument {
         identifier: "args",
         default: Some(
          Map {
           bindings: [],
           recursive: false,
           position: (113, 26),
          },
         ),
        },
        FunctionArgument {
         identifier: "specialArgs",
         default: Some(
          Map {
           bindings: [],
           recursive: false,
           position: (111, 33),
          },
         ),
        },
        FunctionArgument {
         identifier: "prefix",
         default: Some(
          List {
           elements: [],
           position: (106, 28),
          },
         ),
        },
        FunctionArgument {
         identifier: "modules",
         default: None,
        },
       ],
       ellipsis: false,
      },
      definition: LetIn {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "withWarnings",
            position: (118, 7),
           },
          ],
         },
         Function {
          argument: Some(
           "x",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (119, 9),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "warnIf",
               position: (119, 13),
              },
             ],
            },
            default: None,
           },
           arguments: [
            HasProperty {
             expression: Variable {
              identifier: "evalModulesArgs",
              position: (119, 21),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "args",
                position: (119, 37),
               },
              ],
             },
             position: (119, 36),
            },
            String {
             parts: [
              Raw {
               content: "The args argument to evalModules is deprecated. Please set config._module.args instead.",
              },
             ],
             position: (119, 43),
            },
            PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (120, 9),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "warnIf",
                position: (120, 13),
               },
              ],
             },
             default: None,
            },
            HasProperty {
             expression: Variable {
              identifier: "evalModulesArgs",
              position: (120, 21),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "check",
                position: (120, 37),
               },
              ],
             },
             position: (120, 36),
            },
            String {
             parts: [
              Raw {
               content: "The check argument to evalModules is deprecated. Please set config._module.check instead.",
              },
             ],
             position: (120, 44),
            },
            Variable {
             identifier: "x",
             position: (121, 9),
            },
           ],
          },
          position: (118, 22),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "legacyModules",
            position: (123, 7),
           },
          ],
         },
         BinaryOperation {
          operator: Concatenation,
          operands: [
           FunctionApplication {
            function: Variable {
             identifier: "optional",
             position: (124, 9),
            },
            arguments: [
             HasProperty {
              expression: Variable {
               identifier: "evalModulesArgs",
               position: (124, 19),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "args",
                 position: (124, 35),
                },
               ],
              },
              position: (124, 34),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "config",
                   position: (125, 11),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "_module",
                      position: (126, 13),
                     },
                     Raw {
                      content: "args",
                      position: (126, 21),
                     },
                    ],
                   },
                   Variable {
                    identifier: "args",
                    position: (126, 28),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (125, 20),
                },
               ),
              ],
              recursive: false,
              position: (124, 41),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "optional",
             position: (129, 12),
            },
            arguments: [
             HasProperty {
              expression: Variable {
               identifier: "evalModulesArgs",
               position: (129, 22),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "check",
                 position: (129, 38),
                },
               ],
              },
              position: (129, 37),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "config",
                   position: (130, 11),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "_module",
                      position: (131, 13),
                     },
                     Raw {
                      content: "check",
                      position: (131, 21),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "mkDefault",
                     position: (131, 29),
                    },
                    arguments: [
                     Variable {
                      identifier: "check",
                      position: (131, 39),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (130, 20),
                },
               ),
              ],
              recursive: false,
              position: (129, 45),
             },
            ],
           },
          ],
          position: (129, 9),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "regularModules",
            position: (134, 7),
           },
          ],
         },
         BinaryOperation {
          operator: Concatenation,
          operands: [
           Variable {
            identifier: "modules",
            position: (134, 24),
           },
           Variable {
            identifier: "legacyModules",
            position: (134, 35),
           },
          ],
          position: (134, 32),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "internalModule",
            position: (143, 7),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "_file",
               position: (144, 9),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "lib/modules.nix",
              },
             ],
             position: (144, 17),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "key",
               position: (146, 9),
              },
             ],
            },
            Variable {
             identifier: "_file",
             position: (146, 15),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "options",
               position: (148, 9),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "_module",
                  position: (149, 11),
                 },
                 Raw {
                  content: "args",
                  position: (149, 19),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (149, 26),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (156, 13),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (156, 20),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "lazyAttrsOf",
                         position: (156, 26),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (156, 38),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "raw",
                          position: (156, 44),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "internal",
                       position: (159, 13),
                      },
                     ],
                    },
                    BinaryOperation {
                     operator: NotEqualTo,
                     operands: [
                      Variable {
                       identifier: "prefix",
                       position: (159, 24),
                      },
                      List {
                       elements: [],
                       position: (159, 34),
                      },
                     ],
                     position: (159, 31),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (163, 13),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Additional arguments passed to each module in addition to ones\nlike <literal>lib</literal>, <literal>config</literal>,\nand <literal>pkgs</literal>, <literal>modulesPath</literal>.\n</para>\n<para>\nThis option is also available to all submodules. Submodules do not\ninherit args from their parent module, nor do they provide args to\ntheir parent module or sibling submodules. The sole exception to\nthis is the argument <literal>name</literal> which is provided by\nparent modules to a submodule and contains the attribute name\nthe submodule is bound to, or a unique generated name if it is\nnot bound to an attribute.\n</para>\n<para>\nSome arguments are already passed by default, of which the\nfollowing <emphasis>cannot</emphasis> be changed with this option:\n<itemizedlist>\n <listitem>\n  <para>\n   <varname>lib</varname>: The nixpkgs library.\n  </para>\n </listitem>\n <listitem>\n  <para>\n   <varname>config</varname>: The results of all options after merging the values from all modules together.\n  </para>\n </listitem>\n <listitem>\n  <para>\n   <varname>options</varname>: The options declared in all modules.\n  </para>\n </listitem>\n <listitem>\n  <para>\n   <varname>specialArgs</varname>: The <literal>specialArgs</literal> argument passed to <literal>evalModules</literal>.\n  </para>\n </listitem>\n <listitem>\n  <para>\n   All attributes of <varname>specialArgs</varname>\n  </para>\n  <para>\n   Whereas option values can generally depend on other option values\n   thanks to laziness, this does not apply to <literal>imports</literal>, which\n   must be computed statically before anything else.\n  </para>\n  <para>\n   For this reason, callers of the module system can provide <literal>specialArgs</literal>\n   which are available during import resolution.\n  </para>\n  <para>\n   For NixOS, <literal>specialArgs</literal> includes\n   <varname>modulesPath</varname>, which allows you to import\n   extra modules from the nixpkgs package tree without having to\n   somehow make the module aware of the location of the\n   <literal>nixpkgs</literal> or NixOS directories.\n<programlisting>\n{ modulesPath, ... }: {\n  imports = [\n    (modulesPath + \"/profiles/minimal.nix\")\n  ];\n}\n</programlisting>\n  </para>\n </listitem>\n</itemizedlist>\n</para>\n<para>\nFor NixOS, the default value for this option includes at least this argument:\n<itemizedlist>\n <listitem>\n  <para>\n   <varname>pkgs</varname>: The nixpkgs package set according to\n   the <option>nixpkgs.pkgs</option> option.\n  </para>\n </listitem>\n</itemizedlist>\n",
                      },
                     ],
                     position: (163, 27),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (149, 35),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "_module",
                  position: (244, 11),
                 },
                 Raw {
                  content: "check",
                  position: (244, 19),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (244, 27),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (245, 13),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (245, 20),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bool",
                        position: (245, 26),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "internal",
                       position: (246, 13),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (246, 24),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (247, 13),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (247, 23),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (248, 13),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Whether to check whether all option definitions have matching declarations.",
                      },
                     ],
                     position: (248, 27),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (244, 36),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "_module",
                  position: (251, 11),
                 },
                 Raw {
                  content: "freeformType",
                  position: (251, 19),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (251, 34),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (252, 13),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (252, 20),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "nullOr",
                         position: (252, 26),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (252, 33),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "optionType",
                          position: (252, 39),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "internal",
                       position: (253, 13),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (253, 24),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (254, 13),
                      },
                     ],
                    },
                    Variable {
                     identifier: "null",
                     position: (254, 23),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (255, 13),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "If set, merge all definitions that don't have an associated option\ntogether using this type. The result then gets combined with the\nvalues of all declared options to produce the final <literal>\nconfig</literal> value.\n\nIf this is <literal>null</literal>, definitions without an option\nwill throw an error unless <option>_module.check</option> is\nturned off.\n",
                      },
                     ],
                     position: (255, 27),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (251, 43),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (148, 19),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "config",
               position: (268, 9),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "_module",
                  position: (269, 11),
                 },
                 Raw {
                  content: "args",
                  position: (269, 19),
                 },
                ],
               },
               Map {
                bindings: [
                 Inherit(
                  None,
                  [
                   Raw {
                    content: "extendModules",
                    position: (270, 21),
                   },
                  ],
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "moduleType",
                     position: (271, 13),
                    },
                   ],
                  },
                  Variable {
                   identifier: "type",
                   position: (271, 26),
                  },
                 ),
                ],
                recursive: false,
                position: (269, 26),
               },
              ),
             ],
             recursive: false,
             position: (268, 18),
            },
           ),
          ],
          recursive: true,
          position: (143, 24),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "merged",
            position: (276, 7),
           },
          ],
         },
         LetIn {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "collected",
               position: (277, 13),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "collectModules",
              position: (277, 25),
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "specialArgs",
                position: (278, 12),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "modulesPath",
                  position: (278, 24),
                 },
                ],
               },
               default: Some(
                String {
                 parts: [],
                 position: (278, 39),
                },
               ),
              },
              BinaryOperation {
               operator: Concatenation,
               operands: [
                Variable {
                 identifier: "regularModules",
                 position: (279, 12),
                },
                List {
                 elements: [
                  Variable {
                   identifier: "internalModule",
                   position: (279, 32),
                  },
                 ],
                 position: (279, 30),
                },
               ],
               position: (279, 27),
              },
              BinaryOperation {
               operator: Update,
               operands: [
                Map {
                 bindings: [
                  Inherit(
                   None,
                   [
                    Raw {
                     content: "lib",
                     position: (280, 22),
                    },
                    Raw {
                     content: "options",
                     position: (280, 26),
                    },
                    Raw {
                     content: "config",
                     position: (280, 34),
                    },
                    Raw {
                     content: "specialArgs",
                     position: (280, 41),
                    },
                   ],
                  ),
                 ],
                 recursive: false,
                 position: (280, 12),
                },
                Variable {
                 identifier: "specialArgs",
                 position: (280, 59),
                },
               ],
               position: (280, 56),
              },
             ],
            },
           ),
          ],
          target: FunctionApplication {
           function: Variable {
            identifier: "mergeModules",
            position: (281, 12),
           },
           arguments: [
            Variable {
             identifier: "prefix",
             position: (281, 25),
            },
            FunctionApplication {
             function: Variable {
              identifier: "reverseList",
              position: (281, 33),
             },
             arguments: [
              Variable {
               identifier: "collected",
               position: (281, 45),
              },
             ],
            },
           ],
          },
          position: (277, 9),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "options",
            position: (283, 7),
           },
          ],
         },
         PropertyAccess {
          expression: Variable {
           identifier: "merged",
           position: (283, 17),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "matchedOptions",
             position: (283, 24),
            },
           ],
          },
          default: None,
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "config",
            position: (285, 7),
           },
          ],
         },
         LetIn {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "declaredConfig",
               position: (289, 11),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mapAttrsRecursiveCond",
              position: (289, 28),
             },
             arguments: [
              Function {
               argument: Some(
                "v",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: UnaryOperation {
                operator: Not,
                operand: FunctionApplication {
                 function: Variable {
                  identifier: "isOption",
                  position: (289, 56),
                 },
                 arguments: [
                  Variable {
                   identifier: "v",
                   position: (289, 65),
                  },
                 ],
                },
                position: (289, 54),
               },
               position: (289, 51),
              },
              Function {
               argument: Some(
                "_",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: Function {
                argument: Some(
                 "v",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: PropertyAccess {
                 expression: Variable {
                  identifier: "v",
                  position: (289, 75),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "value",
                    position: (289, 77),
                   },
                  ],
                 },
                 default: None,
                },
                position: (289, 72),
               },
               position: (289, 69),
              },
              Variable {
               identifier: "options",
               position: (289, 84),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "freeformConfig",
               position: (292, 11),
              },
             ],
            },
            LetIn {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "defs",
                  position: (294, 15),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "map",
                 position: (294, 22),
                },
                arguments: [
                 Function {
                  argument: Some(
                   "def",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "file",
                        position: (295, 17),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "def",
                       position: (295, 24),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "file",
                         position: (295, 28),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "value",
                        position: (296, 17),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "setAttrByPath",
                       position: (296, 25),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "def",
                         position: (296, 39),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "prefix",
                           position: (296, 43),
                          },
                         ],
                        },
                        default: None,
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "def",
                         position: (296, 50),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "value",
                           position: (296, 54),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (294, 32),
                  },
                  position: (294, 27),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "merged",
                   position: (297, 18),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "unmatchedDefns",
                     position: (297, 25),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              ),
             ],
             target: IfThenElse {
              predicate: BinaryOperation {
               operator: EqualTo,
               operands: [
                Variable {
                 identifier: "defs",
                 position: (298, 19),
                },
                List {
                 elements: [],
                 position: (298, 27),
                },
               ],
               position: (298, 24),
              },
              then: Map {
               bindings: [],
               recursive: false,
               position: (298, 35),
              },
              else_: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "declaredConfig",
                 position: (299, 18),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "_module",
                   position: (299, 33),
                  },
                  Raw {
                   content: "freeformType",
                   position: (299, 41),
                  },
                  Raw {
                   content: "merge",
                   position: (299, 54),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Variable {
                 identifier: "prefix",
                 position: (299, 60),
                },
                Variable {
                 identifier: "defs",
                 position: (299, 67),
                },
               ],
              },
              position: (298, 16),
             },
             position: (293, 13),
            },
           ),
          ],
          target: IfThenElse {
           predicate: BinaryOperation {
            operator: EqualTo,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "declaredConfig",
               position: (301, 15),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "_module",
                 position: (301, 30),
                },
                Raw {
                 content: "freeformType",
                 position: (301, 38),
                },
               ],
              },
              default: None,
             },
             Variable {
              identifier: "null",
              position: (301, 54),
             },
            ],
            position: (301, 51),
           },
           then: Variable {
            identifier: "declaredConfig",
            position: (301, 64),
           },
           else_: FunctionApplication {
            function: Variable {
             identifier: "recursiveUpdate",
             position: (305, 16),
            },
            arguments: [
             Variable {
              identifier: "freeformConfig",
              position: (305, 32),
             },
             Variable {
              identifier: "declaredConfig",
              position: (305, 47),
             },
            ],
           },
           position: (301, 12),
          },
          position: (286, 9),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "checkUnmatched",
            position: (307, 7),
           },
          ],
         },
         IfThenElse {
          predicate: BinaryOperation {
           operator: LogicalAnd,
           operands: [
            BinaryOperation {
             operator: LogicalAnd,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (308, 12),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "_module",
                  position: (308, 19),
                 },
                 Raw {
                  content: "check",
                  position: (308, 27),
                 },
                ],
               },
               default: None,
              },
              BinaryOperation {
               operator: EqualTo,
               operands: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (308, 36),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "_module",
                    position: (308, 43),
                   },
                   Raw {
                    content: "freeformType",
                    position: (308, 51),
                   },
                  ],
                 },
                 default: None,
                },
                Variable {
                 identifier: "null",
                 position: (308, 67),
                },
               ],
               position: (308, 64),
              },
             ],
             position: (308, 33),
            },
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "merged",
                position: (308, 75),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "unmatchedDefns",
                  position: (308, 82),
                 },
                ],
               },
               default: None,
              },
              List {
               elements: [],
               position: (308, 100),
              },
             ],
             position: (308, 97),
            },
           ],
           position: (308, 72),
          },
          then: LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "firstDef",
                position: (310, 13),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "head",
               position: (310, 24),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "merged",
                 position: (310, 29),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "unmatchedDefns",
                   position: (310, 36),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "baseMsg",
                position: (311, 13),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "The option `",
               },
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "showOption",
                  position: (311, 38),
                 },
                 arguments: [
                  BinaryOperation {
                   operator: Concatenation,
                   operands: [
                    Variable {
                     identifier: "prefix",
                     position: (311, 50),
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "firstDef",
                      position: (311, 60),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "prefix",
                        position: (311, 69),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (311, 57),
                  },
                 ],
                },
               },
               Raw {
                content: "' does not exist. Definition values:",
               },
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "showDefs",
                  position: (311, 115),
                 },
                 arguments: [
                  List {
                   elements: [
                    Variable {
                     identifier: "firstDef",
                     position: (311, 126),
                    },
                   ],
                   position: (311, 124),
                  },
                 ],
                },
               },
              ],
              position: (311, 23),
             },
            ),
           ],
           target: IfThenElse {
            predicate: BinaryOperation {
             operator: EqualTo,
             operands: [
              FunctionApplication {
               function: Variable {
                identifier: "attrNames",
                position: (313, 16),
               },
               arguments: [
                Variable {
                 identifier: "options",
                 position: (313, 26),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "_module",
                  },
                 ],
                 position: (313, 39),
                },
               ],
               position: (313, 37),
              },
             ],
             position: (313, 34),
            },
            then: LetIn {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "optionName",
                  position: (316, 19),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "showOption",
                 position: (316, 32),
                },
                arguments: [
                 Variable {
                  identifier: "prefix",
                  position: (316, 43),
                 },
                ],
               },
              ),
             ],
             target: IfThenElse {
              predicate: BinaryOperation {
               operator: EqualTo,
               operands: [
                Variable {
                 identifier: "optionName",
                 position: (318, 22),
                },
                String {
                 parts: [],
                 position: (318, 36),
                },
               ],
               position: (318, 33),
              },
              then: FunctionApplication {
               function: Variable {
                identifier: "throw",
                position: (319, 26),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "",
                  },
                  Expression {
                   expression: Variable {
                    identifier: "baseMsg",
                    position: (320, 25),
                   },
                  },
                  Raw {
                   content: "\n\nIt seems as if you're trying to declare an option by placing it into `config' rather than `options'!\n",
                  },
                 ],
                 position: (319, 32),
                },
               ],
              },
              else_: FunctionApplication {
               function: Variable {
                identifier: "throw",
                position: (325, 21),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "",
                  },
                  Expression {
                   expression: Variable {
                    identifier: "baseMsg",
                    position: (326, 25),
                   },
                  },
                  Raw {
                   content: "\n\nHowever there are no options defined in `",
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "showOption",
                     position: (328, 66),
                    },
                    arguments: [
                     Variable {
                      identifier: "prefix",
                      position: (328, 77),
                     },
                    ],
                   },
                  },
                  Raw {
                   content: "'. Are you sure you've\ndeclared your options properly? This can happen if you e.g. declared your options in `types.submodule'\nunder `config' rather than `options'.\n",
                  },
                 ],
                 position: (325, 27),
                },
               ],
              },
              position: (318, 19),
             },
             position: (315, 17),
            },
            else_: FunctionApplication {
             function: Variable {
              identifier: "throw",
              position: (332, 18),
             },
             arguments: [
              Variable {
               identifier: "baseMsg",
               position: (332, 24),
              },
             ],
            },
            position: (313, 13),
           },
           position: (309, 11),
          },
          else_: Variable {
           identifier: "null",
           position: (333, 14),
          },
          position: (308, 9),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "checked",
            position: (335, 7),
           },
          ],
         },
         FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "builtins",
            position: (335, 17),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "seq",
              position: (335, 26),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Variable {
            identifier: "checkUnmatched",
            position: (335, 30),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "extendModules",
            position: (337, 7),
           },
          ],
         },
         Function {
          argument: Some(
           "extendArgs",
          ),
          arguments: FunctionArguments {
           arguments: [
            FunctionArgument {
             identifier: "prefix",
             default: Some(
              List {
               elements: [],
               position: (340, 18),
              },
             ),
            },
            FunctionArgument {
             identifier: "specialArgs",
             default: Some(
              Map {
               bindings: [],
               recursive: false,
               position: (339, 23),
              },
             ),
            },
            FunctionArgument {
             identifier: "modules",
             default: Some(
              List {
               elements: [],
               position: (338, 19),
              },
             ),
            },
           ],
           ellipsis: false,
          },
          definition: FunctionApplication {
           function: Variable {
            identifier: "evalModules",
            position: (342, 11),
           },
           arguments: [
            BinaryOperation {
             operator: Update,
             operands: [
              Variable {
               identifier: "evalModulesArgs",
               position: (342, 24),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "modules",
                    position: (343, 13),
                   },
                  ],
                 },
                 BinaryOperation {
                  operator: Concatenation,
                  operands: [
                   Variable {
                    identifier: "regularModules",
                    position: (343, 23),
                   },
                   Variable {
                    identifier: "modules",
                    position: (343, 41),
                   },
                  ],
                  position: (343, 38),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "specialArgs",
                    position: (344, 13),
                   },
                  ],
                 },
                 BinaryOperation {
                  operator: Update,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "evalModulesArgs",
                     position: (344, 27),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "specialArgs",
                       position: (344, 43),
                      },
                     ],
                    },
                    default: Some(
                     Map {
                      bindings: [],
                      recursive: false,
                      position: (344, 58),
                     },
                    ),
                   },
                   Variable {
                    identifier: "specialArgs",
                    position: (344, 64),
                   },
                  ],
                  position: (344, 61),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "prefix",
                    position: (345, 13),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "extendArgs",
                   position: (345, 22),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "prefix",
                     position: (345, 33),
                    },
                   ],
                  },
                  default: Some(
                   PropertyAccess {
                    expression: Variable {
                     identifier: "evalModulesArgs",
                     position: (345, 43),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "prefix",
                       position: (345, 59),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                 },
                ),
               ],
               recursive: false,
               position: (342, 43),
              },
             ],
             position: (342, 40),
            },
           ],
          },
          position: (337, 23),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "type",
            position: (348, 7),
           },
          ],
         },
         FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (348, 14),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "types",
              position: (348, 18),
             },
             Raw {
              content: "submoduleWith",
              position: (348, 24),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Map {
            bindings: [
             Inherit(
              None,
              [
               Raw {
                content: "modules",
                position: (349, 17),
               },
               Raw {
                content: "specialArgs",
                position: (349, 25),
               },
              ],
             ),
            ],
            recursive: false,
            position: (348, 38),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "result",
            position: (352, 7),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "withWarnings",
           position: (352, 16),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "options",
                 position: (353, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "checked",
                position: (353, 19),
               },
               arguments: [
                Variable {
                 identifier: "options",
                 position: (353, 27),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "config",
                 position: (354, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "checked",
                position: (354, 18),
               },
               arguments: [
                FunctionApplication {
                 function: Variable {
                  identifier: "removeAttrs",
                  position: (354, 27),
                 },
                 arguments: [
                  Variable {
                   identifier: "config",
                   position: (354, 39),
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "_module",
                      },
                     ],
                     position: (354, 48),
                    },
                   ],
                   position: (354, 46),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "_module",
                 position: (355, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "checked",
                position: (355, 19),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (355, 28),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "_module",
                    position: (355, 35),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ),
             Inherit(
              None,
              [
               Raw {
                content: "extendModules",
                position: (356, 17),
               },
               Raw {
                content: "type",
                position: (356, 31),
               },
              ],
             ),
            ],
            recursive: false,
            position: (352, 29),
           },
          ],
         },
        ),
       ],
       target: Variable {
        identifier: "result",
        position: (358, 8),
       },
       position: (117, 5),
      },
      position: (104, 17),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "collectModules",
        position: (364, 3),
       },
      ],
     },
     LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "loadModule",
           position: (367, 7),
          },
         ],
        },
        Function {
         argument: Some(
          "args",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Function {
          argument: Some(
           "fallbackFile",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: Function {
           argument: Some(
            "fallbackKey",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "m",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: IfThenElse {
             predicate: BinaryOperation {
              operator: LogicalOr,
              operands: [
               FunctionApplication {
                function: Variable {
                 identifier: "isFunction",
                 position: (368, 12),
                },
                arguments: [
                 Variable {
                  identifier: "m",
                  position: (368, 23),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "isAttrs",
                 position: (368, 28),
                },
                arguments: [
                 Variable {
                  identifier: "m",
                  position: (368, 36),
                 },
                ],
               },
              ],
              position: (368, 25),
             },
             then: FunctionApplication {
              function: Variable {
               identifier: "unifyModuleSyntax",
               position: (369, 11),
              },
              arguments: [
               Variable {
                identifier: "fallbackFile",
                position: (369, 29),
               },
               Variable {
                identifier: "fallbackKey",
                position: (369, 42),
               },
               FunctionApplication {
                function: Variable {
                 identifier: "applyModuleArgsIfFunction",
                 position: (369, 55),
                },
                arguments: [
                 Variable {
                  identifier: "fallbackKey",
                  position: (369, 81),
                 },
                 Variable {
                  identifier: "m",
                  position: (369, 93),
                 },
                 Variable {
                  identifier: "args",
                  position: (369, 95),
                 },
                ],
               },
              ],
             },
             else_: IfThenElse {
              predicate: FunctionApplication {
               function: Variable {
                identifier: "isList",
                position: (370, 17),
               },
               arguments: [
                Variable {
                 identifier: "m",
                 position: (370, 24),
                },
               ],
              },
              then: LetIn {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defs",
                    position: (371, 15),
                   },
                  ],
                 },
                 List {
                  elements: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "file",
                         position: (371, 25),
                        },
                       ],
                      },
                      Variable {
                       identifier: "fallbackFile",
                       position: (371, 32),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "value",
                         position: (371, 46),
                        },
                       ],
                      },
                      Variable {
                       identifier: "m",
                       position: (371, 54),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (371, 23),
                   },
                  ],
                  position: (371, 22),
                 },
                ),
               ],
               target: FunctionApplication {
                function: Variable {
                 identifier: "throw",
                 position: (372, 11),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "Module imports can't be nested lists. Perhaps you meant to remove one level of lists? Definitions: ",
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "showDefs",
                      position: (372, 119),
                     },
                     arguments: [
                      Variable {
                       identifier: "defs",
                       position: (372, 128),
                      },
                     ],
                    },
                   },
                  ],
                  position: (372, 17),
                 },
                ],
               },
               position: (371, 11),
              },
              else_: FunctionApplication {
               function: Variable {
                identifier: "unifyModuleSyntax",
                position: (373, 14),
               },
               arguments: [
                FunctionApplication {
                 function: Variable {
                  identifier: "toString",
                  position: (373, 33),
                 },
                 arguments: [
                  Variable {
                   identifier: "m",
                   position: (373, 42),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "toString",
                  position: (373, 46),
                 },
                 arguments: [
                  Variable {
                   identifier: "m",
                   position: (373, 55),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "applyModuleArgsIfFunction",
                  position: (373, 59),
                 },
                 arguments: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "toString",
                    position: (373, 86),
                   },
                   arguments: [
                    Variable {
                     identifier: "m",
                     position: (373, 95),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "import",
                    position: (373, 99),
                   },
                   arguments: [
                    Variable {
                     identifier: "m",
                     position: (373, 106),
                    },
                   ],
                  },
                  Variable {
                   identifier: "args",
                   position: (373, 109),
                  },
                 ],
                },
               ],
              },
              position: (370, 14),
             },
             position: (368, 9),
            },
            position: (367, 53),
           },
           position: (367, 40),
          },
          position: (367, 26),
         },
         position: (367, 20),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "collectStructuredModules",
           position: (400, 7),
          },
         ],
        },
        LetIn {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "collectResults",
              position: (402, 11),
             },
            ],
           },
           Function {
            argument: Some(
             "modules",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "disabled",
                  position: (403, 13),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "concatLists",
                 position: (403, 24),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "catAttrs",
                   position: (403, 37),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "disabled",
                     },
                    ],
                    position: (403, 46),
                   },
                   Variable {
                    identifier: "modules",
                    position: (403, 57),
                   },
                  ],
                 },
                ],
               },
              ),
              Inherit(
               None,
               [
                Raw {
                 content: "modules",
                 position: (404, 21),
                },
               ],
              ),
             ],
             recursive: false,
             position: (402, 37),
            },
            position: (402, 28),
           },
          ),
         ],
         target: Function {
          argument: Some(
           "parentFile",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: Function {
           argument: Some(
            "parentKey",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "initialModules",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Function {
             argument: Some(
              "args",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: FunctionApplication {
              function: Variable {
               identifier: "collectResults",
               position: (406, 57),
              },
              arguments: [
               FunctionApplication {
                function: Variable {
                 identifier: "imap1",
                 position: (406, 73),
                },
                arguments: [
                 Function {
                  argument: Some(
                   "n",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: Function {
                   argument: Some(
                    "x",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: LetIn {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "module",
                         position: (408, 13),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "loadModule",
                        position: (408, 22),
                       },
                       arguments: [
                        Variable {
                         identifier: "args",
                         position: (408, 33),
                        },
                        Variable {
                         identifier: "parentFile",
                         position: (408, 38),
                        },
                        String {
                         parts: [
                          Expression {
                           expression: Variable {
                            identifier: "parentKey",
                            position: (408, 52),
                           },
                          },
                          Raw {
                           content: ":anon-",
                          },
                          Expression {
                           expression: FunctionApplication {
                            function: Variable {
                             identifier: "toString",
                             position: (408, 70),
                            },
                            arguments: [
                             Variable {
                              identifier: "n",
                              position: (408, 79),
                             },
                            ],
                           },
                          },
                         ],
                         position: (408, 49),
                        },
                        Variable {
                         identifier: "x",
                         position: (408, 83),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "collectedImports",
                         position: (409, 13),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "collectStructuredModules",
                        position: (409, 32),
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "module",
                          position: (409, 57),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "_file",
                            position: (409, 64),
                           },
                          ],
                         },
                         default: None,
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "module",
                          position: (409, 70),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "key",
                            position: (409, 77),
                           },
                          ],
                         },
                         default: None,
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "module",
                          position: (409, 81),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "imports",
                            position: (409, 88),
                           },
                          ],
                         },
                         default: None,
                        },
                        Variable {
                         identifier: "args",
                         position: (409, 96),
                        },
                       ],
                      },
                     ),
                    ],
                    target: Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "key",
                          position: (411, 13),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "module",
                         position: (411, 19),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "key",
                           position: (411, 26),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "module",
                          position: (412, 13),
                         },
                        ],
                       },
                       Variable {
                        identifier: "module",
                        position: (412, 22),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "modules",
                          position: (413, 13),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "collectedImports",
                         position: (413, 23),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "modules",
                           position: (413, 40),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "disabled",
                          position: (414, 13),
                         },
                        ],
                       },
                       BinaryOperation {
                        operator: Concatenation,
                        operands: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "module",
                           position: (414, 24),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "disabledModules",
                             position: (414, 31),
                            },
                           ],
                          },
                          default: None,
                         },
                         PropertyAccess {
                          expression: Variable {
                           identifier: "collectedImports",
                           position: (414, 50),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "disabled",
                             position: (414, 67),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                        position: (414, 47),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (410, 14),
                    },
                    position: (407, 11),
                   },
                   position: (406, 83),
                  },
                  position: (406, 80),
                 },
                 Variable {
                  identifier: "initialModules",
                  position: (415, 14),
                 },
                ],
               },
              ],
             },
             position: (406, 51),
            },
            position: (406, 35),
           },
           position: (406, 24),
          },
          position: (406, 12),
         },
         position: (401, 9),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "filterModules",
           position: (421, 7),
          },
         ],
        },
        Function {
         argument: Some(
          "modulesPath",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Function {
          argument: None,
          arguments: FunctionArguments {
           arguments: [
            FunctionArgument {
             identifier: "modules",
             default: None,
            },
            FunctionArgument {
             identifier: "disabled",
             default: None,
            },
           ],
           ellipsis: false,
          },
          definition: LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "moduleKey",
                position: (423, 11),
               },
              ],
             },
             Function {
              argument: Some(
               "m",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: IfThenElse {
               predicate: FunctionApplication {
                function: Variable {
                 identifier: "isString",
                 position: (423, 29),
                },
                arguments: [
                 Variable {
                  identifier: "m",
                  position: (423, 38),
                 },
                ],
               },
               then: BinaryOperation {
                operator: Addition,
                operands: [
                 BinaryOperation {
                  operator: Addition,
                  operands: [
                   FunctionApplication {
                    function: Variable {
                     identifier: "toString",
                     position: (423, 45),
                    },
                    arguments: [
                     Variable {
                      identifier: "modulesPath",
                      position: (423, 54),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "/",
                     },
                    ],
                    position: (423, 68),
                   },
                  ],
                  position: (423, 66),
                 },
                 Variable {
                  identifier: "m",
                  position: (423, 74),
                 },
                ],
                position: (423, 72),
               },
               else_: FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (423, 81),
                },
                arguments: [
                 Variable {
                  identifier: "m",
                  position: (423, 90),
                 },
                ],
               },
               position: (423, 26),
              },
              position: (423, 23),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "disabledKeys",
                position: (424, 11),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "map",
               position: (424, 26),
              },
              arguments: [
               Variable {
                identifier: "moduleKey",
                position: (424, 30),
               },
               Variable {
                identifier: "disabled",
                position: (424, 40),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "keyFilter",
                position: (425, 11),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "filter",
               position: (425, 23),
              },
              arguments: [
               Function {
                argument: Some(
                 "attrs",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: UnaryOperation {
                 operator: Not,
                 operand: FunctionApplication {
                  function: Variable {
                   identifier: "elem",
                   position: (425, 40),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "attrs",
                     position: (425, 45),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "key",
                       position: (425, 51),
                      },
                     ],
                    },
                    default: None,
                   },
                   Variable {
                    identifier: "disabledKeys",
                    position: (425, 55),
                   },
                  ],
                 },
                 position: (425, 38),
                },
                position: (425, 31),
               },
              ],
             },
            ),
           ],
           target: FunctionApplication {
            function: Variable {
             identifier: "map",
             position: (426, 12),
            },
            arguments: [
             Function {
              argument: Some(
               "attrs",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: PropertyAccess {
               expression: Variable {
                identifier: "attrs",
                position: (426, 24),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "module",
                  position: (426, 30),
                 },
                ],
               },
               default: None,
              },
              position: (426, 17),
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "builtins",
                position: (426, 39),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "genericClosure",
                  position: (426, 48),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "startSet",
                     position: (427, 11),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "keyFilter",
                    position: (427, 22),
                   },
                   arguments: [
                    Variable {
                     identifier: "modules",
                     position: (427, 32),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "operator",
                     position: (428, 11),
                    },
                   ],
                  },
                  Function {
                   argument: Some(
                    "attrs",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: FunctionApplication {
                    function: Variable {
                     identifier: "keyFilter",
                     position: (428, 29),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "attrs",
                       position: (428, 39),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "modules",
                         position: (428, 45),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                   position: (428, 22),
                  },
                 ),
                ],
                recursive: false,
                position: (426, 63),
               },
              ],
             },
            ],
           },
           position: (422, 9),
          },
          position: (421, 36),
         },
         position: (421, 23),
        },
       ),
      ],
      target: Function {
       argument: Some(
        "modulesPath",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "initialModules",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Function {
         argument: Some(
          "args",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: FunctionApplication {
          function: Variable {
           identifier: "filterModules",
           position: (432, 7),
          },
          arguments: [
           Variable {
            identifier: "modulesPath",
            position: (432, 21),
           },
           FunctionApplication {
            function: Variable {
             identifier: "collectStructuredModules",
             position: (432, 34),
            },
            arguments: [
             Variable {
              identifier: "unknownModule",
              position: (432, 59),
             },
             String {
              parts: [],
              position: (432, 73),
             },
             Variable {
              identifier: "initialModules",
              position: (432, 76),
             },
             Variable {
              identifier: "args",
              position: (432, 91),
             },
            ],
           },
          ],
         },
         position: (431, 37),
        },
        position: (431, 21),
       },
       position: (431, 8),
      },
      position: (364, 20),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "setDefaultModuleLocation",
        position: (435, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "file",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "m",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "_file",
             position: (436, 7),
            },
           ],
          },
          Variable {
           identifier: "file",
           position: (436, 15),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "imports",
             position: (436, 21),
            },
           ],
          },
          List {
           elements: [
            Variable {
             identifier: "m",
             position: (436, 33),
            },
           ],
           position: (436, 31),
          },
         ),
        ],
        recursive: false,
        position: (436, 5),
       },
       position: (435, 36),
      },
      position: (435, 30),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "unifyModuleSyntax",
        position: (440, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "file",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "key",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "m",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: LetIn {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "addMeta",
              position: (442, 7),
             },
            ],
           },
           Function {
            argument: Some(
             "config",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: IfThenElse {
             predicate: HasProperty {
              expression: Variable {
               identifier: "m",
               position: (442, 28),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "meta",
                 position: (442, 32),
                },
               ],
              },
              position: (442, 30),
             },
             then: FunctionApplication {
              function: Variable {
               identifier: "mkMerge",
               position: (443, 14),
              },
              arguments: [
               List {
                elements: [
                 Variable {
                  identifier: "config",
                  position: (443, 24),
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "meta",
                       position: (443, 33),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "m",
                      position: (443, 40),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "meta",
                        position: (443, 42),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  ],
                  recursive: false,
                  position: (443, 31),
                 },
                ],
                position: (443, 22),
               },
              ],
             },
             else_: Variable {
              identifier: "config",
              position: (444, 14),
             },
             position: (442, 25),
            },
            position: (442, 17),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "addFreeformType",
              position: (445, 7),
             },
            ],
           },
           Function {
            argument: Some(
             "config",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: IfThenElse {
             predicate: HasProperty {
              expression: Variable {
               identifier: "m",
               position: (445, 36),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "freeformType",
                 position: (445, 40),
                },
               ],
              },
              position: (445, 38),
             },
             then: FunctionApplication {
              function: Variable {
               identifier: "mkMerge",
               position: (446, 14),
              },
              arguments: [
               List {
                elements: [
                 Variable {
                  identifier: "config",
                  position: (446, 24),
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "_module",
                       position: (446, 33),
                      },
                      Raw {
                       content: "freeformType",
                       position: (446, 41),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "m",
                      position: (446, 56),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "freeformType",
                        position: (446, 58),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  ],
                  recursive: false,
                  position: (446, 31),
                 },
                ],
                position: (446, 22),
               },
              ],
             },
             else_: Variable {
              identifier: "config",
              position: (447, 14),
             },
             position: (445, 33),
            },
            position: (445, 25),
           },
          ),
         ],
         target: IfThenElse {
          predicate: BinaryOperation {
           operator: LogicalOr,
           operands: [
            HasProperty {
             expression: Variable {
              identifier: "m",
              position: (449, 8),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "config",
                position: (449, 12),
               },
              ],
             },
             position: (449, 10),
            },
            HasProperty {
             expression: Variable {
              identifier: "m",
              position: (449, 22),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "options",
                position: (449, 26),
               },
              ],
             },
             position: (449, 24),
            },
           ],
           position: (449, 19),
          },
          then: LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "badAttrs",
                position: (450, 11),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "removeAttrs",
               position: (450, 22),
              },
              arguments: [
               Variable {
                identifier: "m",
                position: (450, 34),
               },
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "_file",
                   },
                  ],
                  position: (450, 37),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "key",
                   },
                  ],
                  position: (450, 45),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "disabledModules",
                   },
                  ],
                  position: (450, 51),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "imports",
                   },
                  ],
                  position: (450, 69),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "options",
                   },
                  ],
                  position: (450, 79),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "config",
                   },
                  ],
                  position: (450, 89),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "meta",
                   },
                  ],
                  position: (450, 98),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "freeformType",
                   },
                  ],
                  position: (450, 105),
                 },
                ],
                position: (450, 36),
               },
              ],
             },
            ),
           ],
           target: IfThenElse {
            predicate: BinaryOperation {
             operator: NotEqualTo,
             operands: [
              Variable {
               identifier: "badAttrs",
               position: (451, 10),
              },
              Map {
               bindings: [],
               recursive: false,
               position: (451, 22),
              },
             ],
             position: (451, 19),
            },
            then: FunctionApplication {
             function: Variable {
              identifier: "throw",
              position: (452, 9),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "Module `",
                },
                Expression {
                 expression: Variable {
                  identifier: "key",
                  position: (452, 26),
                 },
                },
                Raw {
                 content: "' has an unsupported attribute `",
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "head",
                   position: (452, 64),
                  },
                  arguments: [
                   FunctionApplication {
                    function: Variable {
                     identifier: "attrNames",
                     position: (452, 70),
                    },
                    arguments: [
                     Variable {
                      identifier: "badAttrs",
                      position: (452, 80),
                     },
                    ],
                   },
                  ],
                 },
                },
                Raw {
                 content: "'. This is caused by introducing a top-level `config' or `options' attribute. Add configuration attributes immediately on the top level instead, or move all of them (namely: ",
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "toString",
                   position: (452, 266),
                  },
                  arguments: [
                   FunctionApplication {
                    function: Variable {
                     identifier: "attrNames",
                     position: (452, 276),
                    },
                    arguments: [
                     Variable {
                      identifier: "badAttrs",
                      position: (452, 286),
                     },
                    ],
                   },
                  ],
                 },
                },
                Raw {
                 content: ") into the explicit `config' attribute.",
                },
               ],
               position: (452, 15),
              },
             ],
            },
            else_: Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "_file",
                  position: (454, 11),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (454, 19),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "m",
                   position: (454, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "_file",
                     position: (454, 30),
                    },
                   ],
                  },
                  default: Some(
                   Variable {
                    identifier: "file",
                    position: (454, 39),
                   },
                  ),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "key",
                  position: (455, 11),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (455, 17),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "m",
                   position: (455, 26),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "key",
                     position: (455, 28),
                    },
                   ],
                  },
                  default: Some(
                   Variable {
                    identifier: "key",
                    position: (455, 35),
                   },
                  ),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "disabledModules",
                  position: (456, 11),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (456, 29),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "disabledModules",
                   position: (456, 31),
                  },
                 ],
                },
                default: Some(
                 List {
                  elements: [],
                  position: (456, 50),
                 },
                ),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "imports",
                  position: (457, 11),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (457, 21),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "imports",
                   position: (457, 23),
                  },
                 ],
                },
                default: Some(
                 List {
                  elements: [],
                  position: (457, 34),
                 },
                ),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "options",
                  position: (458, 11),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (458, 21),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "options",
                   position: (458, 23),
                  },
                 ],
                },
                default: Some(
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (458, 34),
                 },
                ),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "config",
                  position: (459, 11),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "addFreeformType",
                 position: (459, 20),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "addMeta",
                   position: (459, 37),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "m",
                     position: (459, 46),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "config",
                       position: (459, 48),
                      },
                     ],
                    },
                    default: Some(
                     Map {
                      bindings: [],
                      recursive: false,
                      position: (459, 58),
                     },
                    ),
                   },
                  ],
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (454, 9),
            },
            position: (451, 7),
           },
           position: (450, 7),
          },
          else_: Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "_file",
                position: (462, 9),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "toString",
               position: (462, 17),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (462, 26),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "_file",
                   position: (462, 28),
                  },
                 ],
                },
                default: Some(
                 Variable {
                  identifier: "file",
                  position: (462, 37),
                 },
                ),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "key",
                position: (463, 9),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "toString",
               position: (463, 15),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (463, 24),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "key",
                   position: (463, 26),
                  },
                 ],
                },
                default: Some(
                 Variable {
                  identifier: "key",
                  position: (463, 33),
                 },
                ),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "disabledModules",
                position: (464, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "m",
               position: (464, 27),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "disabledModules",
                 position: (464, 29),
                },
               ],
              },
              default: Some(
               List {
                elements: [],
                position: (464, 48),
               },
              ),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "imports",
                position: (465, 9),
               },
              ],
             },
             BinaryOperation {
              operator: Concatenation,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (465, 19),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "require",
                   position: (465, 21),
                  },
                 ],
                },
                default: Some(
                 List {
                  elements: [],
                  position: (465, 32),
                 },
                ),
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (465, 38),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "imports",
                   position: (465, 40),
                  },
                 ],
                },
                default: Some(
                 List {
                  elements: [],
                  position: (465, 51),
                 },
                ),
               },
              ],
              position: (465, 35),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "options",
                position: (466, 9),
               },
              ],
             },
             Map {
              bindings: [],
              recursive: false,
              position: (466, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "config",
                position: (467, 9),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "addFreeformType",
               position: (467, 18),
              },
              arguments: [
               FunctionApplication {
                function: Variable {
                 identifier: "addMeta",
                 position: (467, 35),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "removeAttrs",
                   position: (467, 44),
                  },
                  arguments: [
                   Variable {
                    identifier: "m",
                    position: (467, 56),
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "_file",
                       },
                      ],
                      position: (467, 59),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "key",
                       },
                      ],
                      position: (467, 67),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "disabledModules",
                       },
                      ],
                      position: (467, 73),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "require",
                       },
                      ],
                      position: (467, 91),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "imports",
                       },
                      ],
                      position: (467, 101),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "freeformType",
                       },
                      ],
                      position: (467, 111),
                     },
                    ],
                    position: (467, 58),
                   },
                  ],
                 },
                ],
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (462, 7),
          },
          position: (449, 5),
         },
         position: (441, 5),
        },
        position: (440, 34),
       },
       position: (440, 29),
      },
      position: (440, 23),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "applyModuleArgsIfFunction",
        position: (470, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "key",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "f",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "args",
        ),
        arguments: FunctionArguments {
         arguments: [
          FunctionArgument {
           identifier: "lib",
           default: None,
          },
          FunctionArgument {
           identifier: "options",
           default: None,
          },
          FunctionArgument {
           identifier: "config",
           default: None,
          },
         ],
         ellipsis: true,
        },
        definition: IfThenElse {
         predicate: FunctionApplication {
          function: Variable {
           identifier: "isFunction",
           position: (470, 78),
          },
          arguments: [
           Variable {
            identifier: "f",
            position: (470, 89),
           },
          ],
         },
         then: LetIn {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "context",
               position: (484, 7),
              },
             ],
            },
            Function {
             argument: Some(
              "name",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: String {
              parts: [
               Raw {
                content: "while evaluating the module argument `",
               },
               Expression {
                expression: Variable {
                 identifier: "name",
                 position: (484, 65),
                },
               },
               Raw {
                content: "' in \"",
               },
               Expression {
                expression: Variable {
                 identifier: "key",
                 position: (484, 78),
                },
               },
               Raw {
                content: "\":",
               },
              ],
              position: (484, 23),
             },
             position: (484, 17),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraArgs",
               position: (485, 7),
              },
             ],
            },
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "builtins",
               position: (485, 19),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "mapAttrs",
                 position: (485, 28),
                },
               ],
              },
              default: None,
             },
             arguments: [
              Function {
               argument: Some(
                "name",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: Function {
                argument: Some(
                 "_",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "builtins",
                   position: (486, 9),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "addErrorContext",
                     position: (486, 18),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "context",
                    position: (486, 35),
                   },
                   arguments: [
                    Variable {
                     identifier: "name",
                     position: (486, 43),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "args",
                    position: (487, 12),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Expression {
                      expression: Variable {
                       identifier: "name",
                       position: (487, 19),
                      },
                     },
                    ],
                   },
                   default: Some(
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (487, 28),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "_module",
                        position: (487, 35),
                       },
                       Raw {
                        content: "args",
                        position: (487, 43),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "name",
                         position: (487, 50),
                        },
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  },
                 ],
                },
                position: (485, 44),
               },
               position: (485, 38),
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (488, 10),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "functionArgs",
                   position: (488, 14),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Variable {
                 identifier: "f",
                 position: (488, 27),
                },
               ],
              },
             ],
            },
           ),
          ],
          target: FunctionApplication {
           function: Variable {
            identifier: "f",
            position: (494, 8),
           },
           arguments: [
            BinaryOperation {
             operator: Update,
             operands: [
              Variable {
               identifier: "args",
               position: (494, 11),
              },
              Variable {
               identifier: "extraArgs",
               position: (494, 19),
              },
             ],
             position: (494, 16),
            },
           ],
          },
          position: (471, 5),
         },
         else_: Variable {
          identifier: "f",
          position: (496, 5),
         },
         position: (470, 75),
        },
        position: (470, 39),
       },
       position: (470, 36),
      },
      position: (470, 31),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mergeModules",
        position: (519, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "prefix",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "modules",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "mergeModules'",
         position: (520, 5),
        },
        arguments: [
         Variable {
          identifier: "prefix",
          position: (520, 19),
         },
         Variable {
          identifier: "modules",
          position: (520, 26),
         },
         FunctionApplication {
          function: Variable {
           identifier: "concatMap",
           position: (521, 8),
          },
          arguments: [
           Function {
            argument: Some(
             "m",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: FunctionApplication {
             function: Variable {
              identifier: "map",
              position: (521, 22),
             },
             arguments: [
              Function {
               argument: Some(
                "config",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "file",
                     position: (521, 37),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "m",
                    position: (521, 44),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "_file",
                      position: (521, 46),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 Inherit(
                  None,
                  [
                   Raw {
                    content: "config",
                    position: (521, 61),
                   },
                  ],
                 ),
                ],
                recursive: false,
                position: (521, 35),
               },
               position: (521, 27),
              },
              FunctionApplication {
               function: Variable {
                identifier: "pushDownProperties",
                position: (521, 73),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "m",
                  position: (521, 92),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "config",
                    position: (521, 94),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ],
            },
            position: (521, 19),
           },
           Variable {
            identifier: "modules",
            position: (521, 103),
           },
          ],
         },
        ],
       },
       position: (519, 26),
      },
      position: (519, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mergeModules'",
        position: (523, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "prefix",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "options",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "configs",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: LetIn {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "byName",
              position: (546, 7),
             },
            ],
           },
           Function {
            argument: Some(
             "attr",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Function {
             argument: Some(
              "f",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: Function {
              argument: Some(
               "modules",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: FunctionApplication {
               function: Variable {
                identifier: "zipAttrsWith",
                position: (547, 9),
               },
               arguments: [
                Function {
                 argument: Some(
                  "n",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: Variable {
                  identifier: "concatLists",
                  position: (547, 26),
                 },
                 position: (547, 23),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "map",
                  position: (548, 12),
                 },
                 arguments: [
                  Function {
                   argument: Some(
                    "module",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: LetIn {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "subtree",
                         position: (548, 29),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "module",
                        position: (548, 39),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Expression {
                          expression: Variable {
                           identifier: "attr",
                           position: (548, 48),
                          },
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                    ],
                    target: IfThenElse {
                     predicate: UnaryOperation {
                      operator: Not,
                      operand: FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "builtins",
                         position: (549, 20),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "isAttrs",
                           position: (549, 29),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        Variable {
                         identifier: "subtree",
                         position: (549, 37),
                        },
                       ],
                      },
                      position: (549, 18),
                     },
                     then: FunctionApplication {
                      function: Variable {
                       identifier: "throw",
                       position: (550, 17),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "You're trying to declare a value of type `",
                         },
                         Expression {
                          expression: FunctionApplication {
                           function: PropertyAccess {
                            expression: Variable {
                             identifier: "builtins",
                             position: (551, 63),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "typeOf",
                               position: (551, 72),
                              },
                             ],
                            },
                            default: None,
                           },
                           arguments: [
                            Variable {
                             identifier: "subtree",
                             position: (551, 79),
                            },
                           ],
                          },
                         },
                         Raw {
                          content: "'\nrather than an attribute-set for the option\n`",
                         },
                         Expression {
                          expression: FunctionApplication {
                           function: PropertyAccess {
                            expression: Variable {
                             identifier: "builtins",
                             position: (553, 22),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "concatStringsSep",
                               position: (553, 31),
                              },
                             ],
                            },
                            default: None,
                           },
                           arguments: [
                            String {
                             parts: [
                              Raw {
                               content: ".",
                              },
                             ],
                             position: (553, 48),
                            },
                            Variable {
                             identifier: "prefix",
                             position: (553, 52),
                            },
                           ],
                          },
                         },
                         Raw {
                          content: "'!\n\nThis usually happens if `",
                         },
                         Expression {
                          expression: FunctionApplication {
                           function: PropertyAccess {
                            expression: Variable {
                             identifier: "builtins",
                             position: (555, 46),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "concatStringsSep",
                               position: (555, 55),
                              },
                             ],
                            },
                            default: None,
                           },
                           arguments: [
                            String {
                             parts: [
                              Raw {
                               content: ".",
                              },
                             ],
                             position: (555, 72),
                            },
                            Variable {
                             identifier: "prefix",
                             position: (555, 76),
                            },
                           ],
                          },
                         },
                         Raw {
                          content: "' has option\ndefinitions inside that are not matched. Please check how to properly define\nthis option by e.g. referring to `man 5 configuration.nix'!\n",
                         },
                        ],
                        position: (550, 23),
                       },
                      ],
                     },
                     else_: FunctionApplication {
                      function: Variable {
                       identifier: "mapAttrs",
                       position: (560, 17),
                      },
                      arguments: [
                       Function {
                        argument: Some(
                         "n",
                        ),
                        arguments: FunctionArguments {
                         arguments: [],
                         ellipsis: false,
                        },
                        definition: FunctionApplication {
                         function: Variable {
                          identifier: "f",
                          position: (560, 30),
                         },
                         arguments: [
                          Variable {
                           identifier: "module",
                           position: (560, 32),
                          },
                         ],
                        },
                        position: (560, 27),
                       },
                       Variable {
                        identifier: "subtree",
                        position: (560, 40),
                       },
                      ],
                     },
                     position: (549, 15),
                    },
                    position: (548, 25),
                   },
                   position: (548, 17),
                  },
                  Variable {
                   identifier: "modules",
                   position: (561, 17),
                  },
                 ],
                },
               ],
              },
              position: (546, 25),
             },
             position: (546, 22),
            },
            position: (546, 16),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "declsByName",
              position: (563, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "byName",
             position: (563, 21),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "options",
               },
              ],
              position: (563, 28),
             },
             Function {
              argument: Some(
               "module",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "option",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: List {
                elements: [
                 Map {
                  bindings: [
                   Inherit(
                    Some(
                     Variable {
                      identifier: "module",
                      position: (564, 23),
                     },
                    ),
                    [
                     Raw {
                      content: "_file",
                      position: (564, 31),
                     },
                    ],
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "options",
                       position: (564, 38),
                      },
                     ],
                    },
                    Variable {
                     identifier: "option",
                     position: (564, 48),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (564, 12),
                 },
                ],
                position: (564, 11),
               },
               position: (563, 47),
              },
              position: (563, 39),
             },
             Variable {
              identifier: "options",
              position: (565, 11),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "defnsByName",
              position: (567, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "byName",
             position: (567, 21),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "config",
               },
              ],
              position: (567, 28),
             },
             Function {
              argument: Some(
               "module",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "value",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: FunctionApplication {
                function: Variable {
                 identifier: "map",
                 position: (568, 11),
                },
                arguments: [
                 Function {
                  argument: Some(
                   "config",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: Map {
                   bindings: [
                    Inherit(
                     Some(
                      Variable {
                       identifier: "module",
                       position: (568, 35),
                      },
                     ),
                     [
                      Raw {
                       content: "file",
                       position: (568, 43),
                      },
                     ],
                    ),
                    Inherit(
                     None,
                     [
                      Raw {
                       content: "config",
                       position: (568, 57),
                      },
                     ],
                    ),
                   ],
                   recursive: false,
                   position: (568, 24),
                  },
                  position: (568, 16),
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "pushDownProperties",
                   position: (568, 69),
                  },
                  arguments: [
                   Variable {
                    identifier: "value",
                    position: (568, 88),
                   },
                  ],
                 },
                ],
               },
               position: (567, 46),
              },
              position: (567, 38),
             },
             Variable {
              identifier: "configs",
              position: (569, 11),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "defnsByName'",
              position: (571, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "byName",
             position: (571, 22),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "config",
               },
              ],
              position: (571, 29),
             },
             Function {
              argument: Some(
               "module",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "value",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: List {
                elements: [
                 Map {
                  bindings: [
                   Inherit(
                    Some(
                     Variable {
                      identifier: "module",
                      position: (572, 23),
                     },
                    ),
                    [
                     Raw {
                      content: "file",
                      position: (572, 31),
                     },
                    ],
                   ),
                   Inherit(
                    None,
                    [
                     Raw {
                      content: "value",
                      position: (572, 45),
                     },
                    ],
                   ),
                  ],
                  recursive: false,
                  position: (572, 12),
                 },
                ],
                position: (572, 11),
               },
               position: (571, 47),
              },
              position: (571, 39),
             },
             Variable {
              identifier: "configs",
              position: (573, 11),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "optionTreeToOption",
              position: (576, 7),
             },
            ],
           },
           Function {
            argument: Some(
             "decl",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: IfThenElse {
             predicate: FunctionApplication {
              function: Variable {
               identifier: "isOption",
               position: (577, 12),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "decl",
                 position: (577, 21),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "options",
                   position: (577, 26),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
             then: Variable {
              identifier: "decl",
              position: (578, 14),
             },
             else_: BinaryOperation {
              operator: Update,
              operands: [
               Variable {
                identifier: "decl",
                position: (579, 14),
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "options",
                     position: (580, 13),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkOption",
                    position: (580, 23),
                   },
                   arguments: [
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "type",
                          position: (581, 15),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: PropertyAccess {
                         expression: Variable {
                          identifier: "types",
                          position: (581, 22),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "submoduleWith",
                            position: (581, 28),
                           },
                          ],
                         },
                         default: None,
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "modules",
                               position: (582, 17),
                              },
                             ],
                            },
                            List {
                             elements: [
                              Map {
                               bindings: [
                                KeyValue(
                                 AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "options",
                                    position: (582, 31),
                                   },
                                  ],
                                 },
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "decl",
                                   position: (582, 41),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "options",
                                     position: (582, 46),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ),
                               ],
                               recursive: false,
                               position: (582, 29),
                              },
                             ],
                             position: (582, 27),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "shorthandOnlyDefinesConfig",
                               position: (586, 17),
                              },
                             ],
                            },
                            Variable {
                             identifier: "null",
                             position: (586, 46),
                            },
                           ),
                          ],
                          recursive: false,
                          position: (581, 42),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (580, 32),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (579, 22),
               },
              ],
              position: (579, 19),
             },
             position: (577, 9),
            },
            position: (576, 28),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "resultsByName",
              position: (591, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mapAttrs",
             position: (591, 23),
            },
            arguments: [
             Function {
              argument: Some(
               "name",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "decls",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: LetIn {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "loc",
                     position: (594, 11),
                    },
                   ],
                  },
                  BinaryOperation {
                   operator: Concatenation,
                   operands: [
                    Variable {
                     identifier: "prefix",
                     position: (594, 17),
                    },
                    List {
                     elements: [
                      Variable {
                       identifier: "name",
                       position: (594, 28),
                      },
                     ],
                     position: (594, 27),
                    },
                   ],
                   position: (594, 24),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "defns",
                     position: (595, 11),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "defnsByName",
                    position: (595, 19),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Expression {
                      expression: Variable {
                       identifier: "name",
                       position: (595, 33),
                      },
                     },
                    ],
                   },
                   default: Some(
                    List {
                     elements: [],
                     position: (595, 42),
                    },
                   ),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "defns'",
                     position: (596, 11),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "defnsByName'",
                    position: (596, 20),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Expression {
                      expression: Variable {
                       identifier: "name",
                       position: (596, 35),
                      },
                     },
                    ],
                   },
                   default: Some(
                    List {
                     elements: [],
                     position: (596, 44),
                    },
                   ),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "optionDecls",
                     position: (597, 11),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "filter",
                    position: (597, 25),
                   },
                   arguments: [
                    Function {
                     argument: Some(
                      "m",
                     ),
                     arguments: FunctionArguments {
                      arguments: [],
                      ellipsis: false,
                     },
                     definition: FunctionApplication {
                      function: Variable {
                       identifier: "isOption",
                       position: (597, 36),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "m",
                         position: (597, 45),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "options",
                           position: (597, 47),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                     position: (597, 33),
                    },
                    Variable {
                     identifier: "decls",
                     position: (597, 56),
                    },
                   ],
                  },
                 ),
                ],
                target: IfThenElse {
                 predicate: BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   FunctionApplication {
                    function: Variable {
                     identifier: "length",
                     position: (599, 14),
                    },
                    arguments: [
                     Variable {
                      identifier: "optionDecls",
                      position: (599, 21),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "length",
                     position: (599, 36),
                    },
                    arguments: [
                     Variable {
                      identifier: "decls",
                      position: (599, 43),
                     },
                    ],
                   },
                  ],
                  position: (599, 33),
                 },
                 then: LetIn {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "opt",
                       position: (600, 17),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "fixupOptionType",
                      position: (600, 23),
                     },
                     arguments: [
                      Variable {
                       identifier: "loc",
                       position: (600, 39),
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mergeOptionDecls",
                        position: (600, 44),
                       },
                       arguments: [
                        Variable {
                         identifier: "loc",
                         position: (600, 61),
                        },
                        Variable {
                         identifier: "decls",
                         position: (600, 65),
                        },
                       ],
                      },
                     ],
                    },
                   ),
                  ],
                  target: Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "matchedOptions",
                        position: (602, 15),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "evalOptionValue",
                       position: (602, 32),
                      },
                      arguments: [
                       Variable {
                        identifier: "loc",
                        position: (602, 48),
                       },
                       Variable {
                        identifier: "opt",
                        position: (602, 52),
                       },
                       Variable {
                        identifier: "defns'",
                        position: (602, 56),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "unmatchedDefns",
                        position: (603, 15),
                       },
                      ],
                     },
                     List {
                      elements: [],
                      position: (603, 32),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (601, 16),
                  },
                  position: (600, 13),
                 },
                 else_: IfThenElse {
                  predicate: BinaryOperation {
                   operator: NotEqualTo,
                   operands: [
                    Variable {
                     identifier: "optionDecls",
                     position: (605, 19),
                    },
                    List {
                     elements: [],
                     position: (605, 34),
                    },
                   ],
                   position: (605, 31),
                  },
                  then: IfThenElse {
                   predicate: FunctionApplication {
                    function: Variable {
                     identifier: "all",
                     position: (606, 18),
                    },
                    arguments: [
                     Function {
                      argument: Some(
                       "x",
                      ),
                      arguments: FunctionArguments {
                       arguments: [],
                       ellipsis: false,
                      },
                      definition: BinaryOperation {
                       operator: EqualTo,
                       operands: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "x",
                          position: (606, 26),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "options",
                            position: (606, 28),
                           },
                           Raw {
                            content: "type",
                            position: (606, 36),
                           },
                           Raw {
                            content: "name",
                            position: (606, 41),
                           },
                          ],
                         },
                         default: None,
                        },
                        String {
                         parts: [
                          Raw {
                           content: "submodule",
                          },
                         ],
                         position: (606, 49),
                        },
                       ],
                       position: (606, 46),
                      },
                      position: (606, 23),
                     },
                     Variable {
                      identifier: "optionDecls",
                      position: (606, 62),
                     },
                    ],
                   },
                   then: LetIn {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "opt",
                         position: (617, 21),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "fixupOptionType",
                        position: (617, 27),
                       },
                       arguments: [
                        Variable {
                         identifier: "loc",
                         position: (617, 43),
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mergeOptionDecls",
                          position: (617, 48),
                         },
                         arguments: [
                          Variable {
                           identifier: "loc",
                           position: (617, 65),
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "map",
                            position: (617, 70),
                           },
                           arguments: [
                            Variable {
                             identifier: "optionTreeToOption",
                             position: (617, 74),
                            },
                            Variable {
                             identifier: "decls",
                             position: (617, 93),
                            },
                           ],
                          },
                         ],
                        },
                       ],
                      },
                     ),
                    ],
                    target: Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "matchedOptions",
                          position: (619, 19),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "evalOptionValue",
                         position: (619, 36),
                        },
                        arguments: [
                         Variable {
                          identifier: "loc",
                          position: (619, 52),
                         },
                         Variable {
                          identifier: "opt",
                          position: (619, 56),
                         },
                         Variable {
                          identifier: "defns'",
                          position: (619, 60),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "unmatchedDefns",
                          position: (620, 19),
                         },
                        ],
                       },
                       List {
                        elements: [],
                        position: (620, 36),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (618, 20),
                    },
                    position: (617, 17),
                   },
                   else_: LetIn {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "firstNonOption",
                         position: (624, 19),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "findFirst",
                        position: (624, 36),
                       },
                       arguments: [
                        Function {
                         argument: Some(
                          "m",
                         ),
                         arguments: FunctionArguments {
                          arguments: [],
                          ellipsis: false,
                         },
                         definition: UnaryOperation {
                          operator: Not,
                          operand: FunctionApplication {
                           function: Variable {
                            identifier: "isOption",
                            position: (624, 51),
                           },
                           arguments: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "m",
                              position: (624, 60),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "options",
                                position: (624, 62),
                               },
                              ],
                             },
                             default: None,
                            },
                           ],
                          },
                          position: (624, 50),
                         },
                         position: (624, 47),
                        },
                        String {
                         parts: [],
                         position: (624, 71),
                        },
                        Variable {
                         identifier: "decls",
                         position: (624, 74),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "nonOptions",
                         position: (625, 19),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "filter",
                        position: (625, 32),
                       },
                       arguments: [
                        Function {
                         argument: Some(
                          "m",
                         ),
                         arguments: FunctionArguments {
                          arguments: [],
                          ellipsis: false,
                         },
                         definition: UnaryOperation {
                          operator: Not,
                          operand: FunctionApplication {
                           function: Variable {
                            identifier: "isOption",
                            position: (625, 44),
                           },
                           arguments: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "m",
                              position: (625, 53),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "options",
                                position: (625, 55),
                               },
                              ],
                             },
                             default: None,
                            },
                           ],
                          },
                          position: (625, 43),
                         },
                         position: (625, 40),
                        },
                        Variable {
                         identifier: "decls",
                         position: (625, 64),
                        },
                       ],
                      },
                     ),
                    ],
                    target: FunctionApplication {
                     function: Variable {
                      identifier: "throw",
                      position: (627, 17),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "The option `",
                        },
                        Expression {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "showOption",
                           position: (627, 38),
                          },
                          arguments: [
                           Variable {
                            identifier: "loc",
                            position: (627, 49),
                           },
                          ],
                         },
                        },
                        Raw {
                         content: "' in module `",
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: FunctionApplication {
                           function: PropertyAccess {
                            expression: Variable {
                             identifier: "lib",
                             position: (627, 69),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "head",
                               position: (627, 73),
                              },
                             ],
                            },
                            default: None,
                           },
                           arguments: [
                            Variable {
                             identifier: "optionDecls",
                             position: (627, 78),
                            },
                           ],
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "_file",
                             position: (627, 91),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "' would be a parent of the following options, but its type `",
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: FunctionApplication {
                           function: PropertyAccess {
                            expression: Variable {
                             identifier: "lib",
                             position: (627, 160),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "head",
                               position: (627, 164),
                              },
                             ],
                            },
                            default: None,
                           },
                           arguments: [
                            Variable {
                             identifier: "optionDecls",
                             position: (627, 169),
                            },
                           ],
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "options",
                             position: (627, 182),
                            },
                            Raw {
                             content: "type",
                             position: (627, 190),
                            },
                            Raw {
                             content: "description",
                             position: (627, 195),
                            },
                           ],
                          },
                          default: Some(
                           String {
                            parts: [
                             Raw {
                              content: "<no description>",
                             },
                            ],
                            position: (627, 210),
                           },
                          ),
                         },
                        },
                        Raw {
                         content: "' does not support nested options.\n",
                        },
                        Expression {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "showRawDecls",
                           position: (628, 19),
                          },
                          arguments: [
                           Variable {
                            identifier: "loc",
                            position: (628, 32),
                           },
                           Variable {
                            identifier: "nonOptions",
                            position: (628, 36),
                           },
                          ],
                         },
                        },
                       ],
                       position: (627, 23),
                      },
                     ],
                    },
                    position: (623, 17),
                   },
                   position: (606, 15),
                  },
                  else_: FunctionApplication {
                   function: Variable {
                    identifier: "mergeModules'",
                    position: (631, 13),
                   },
                   arguments: [
                    Variable {
                     identifier: "loc",
                     position: (631, 27),
                    },
                    Variable {
                     identifier: "decls",
                     position: (631, 31),
                    },
                    Variable {
                     identifier: "defns",
                     position: (631, 37),
                    },
                   ],
                  },
                  position: (605, 16),
                 },
                 position: (599, 11),
                },
                position: (593, 9),
               },
               position: (591, 39),
              },
              position: (591, 33),
             },
             Variable {
              identifier: "declsByName",
              position: (631, 44),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "matchedOptions",
              position: (633, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mapAttrs",
             position: (633, 24),
            },
            arguments: [
             Function {
              argument: Some(
               "n",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "v",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: PropertyAccess {
                expression: Variable {
                 identifier: "v",
                 position: (633, 40),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "matchedOptions",
                   position: (633, 42),
                  },
                 ],
                },
                default: None,
               },
               position: (633, 37),
              },
              position: (633, 34),
             },
             Variable {
              identifier: "resultsByName",
              position: (633, 58),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "unmatchedDefnsByName",
              position: (636, 7),
             },
            ],
           },
           BinaryOperation {
            operator: Update,
            operands: [
             FunctionApplication {
              function: Variable {
               identifier: "mapAttrs",
               position: (638, 9),
              },
              arguments: [
               Function {
                argument: Some(
                 "n",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: Function {
                 argument: Some(
                  "v",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: PropertyAccess {
                  expression: Variable {
                   identifier: "v",
                   position: (638, 25),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "unmatchedDefns",
                     position: (638, 27),
                    },
                   ],
                  },
                  default: None,
                 },
                 position: (638, 22),
                },
                position: (638, 19),
               },
               Variable {
                identifier: "resultsByName",
                position: (638, 43),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "removeAttrs",
               position: (640, 12),
              },
              arguments: [
               Variable {
                identifier: "defnsByName'",
                position: (640, 24),
               },
               FunctionApplication {
                function: Variable {
                 identifier: "attrNames",
                 position: (640, 38),
                },
                arguments: [
                 Variable {
                  identifier: "matchedOptions",
                  position: (640, 48),
                 },
                ],
               },
              ],
             },
            ],
            position: (640, 9),
           },
          ),
         ],
         target: Map {
          bindings: [
           Inherit(
            None,
            [
             Raw {
              content: "matchedOptions",
              position: (642, 15),
             },
            ],
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "unmatchedDefns",
               position: (645, 7),
              },
             ],
            },
            IfThenElse {
             predicate: BinaryOperation {
              operator: EqualTo,
              operands: [
               Variable {
                identifier: "configs",
                position: (646, 12),
               },
               List {
                elements: [],
                position: (646, 23),
               },
              ],
              position: (646, 20),
             },
             then: List {
              elements: [],
              position: (650, 11),
             },
             else_: FunctionApplication {
              function: Variable {
               identifier: "concatLists",
               position: (652, 11),
              },
              arguments: [
               FunctionApplication {
                function: Variable {
                 identifier: "mapAttrsToList",
                 position: (652, 24),
                },
                arguments: [
                 Function {
                  argument: Some(
                   "name",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: Function {
                   argument: Some(
                    "defs",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: FunctionApplication {
                    function: Variable {
                     identifier: "map",
                     position: (653, 13),
                    },
                    arguments: [
                     Function {
                      argument: Some(
                       "def",
                      ),
                      arguments: FunctionArguments {
                       arguments: [],
                       ellipsis: false,
                      },
                      definition: BinaryOperation {
                       operator: Update,
                       operands: [
                        Variable {
                         identifier: "def",
                         position: (653, 23),
                        },
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "prefix",
                              position: (655, 15),
                             },
                            ],
                           },
                           BinaryOperation {
                            operator: Concatenation,
                            operands: [
                             List {
                              elements: [
                               Variable {
                                identifier: "name",
                                position: (655, 25),
                               },
                              ],
                              position: (655, 24),
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "def",
                               position: (655, 35),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "prefix",
                                 position: (655, 39),
                                },
                               ],
                              },
                              default: Some(
                               List {
                                elements: [],
                                position: (655, 49),
                               },
                              ),
                             },
                            ],
                            position: (655, 31),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (653, 30),
                        },
                       ],
                       position: (653, 27),
                      },
                      position: (653, 18),
                     },
                     Variable {
                      identifier: "defs",
                      position: (656, 16),
                     },
                    ],
                   },
                   position: (652, 46),
                  },
                  position: (652, 40),
                 },
                 Variable {
                  identifier: "unmatchedDefnsByName",
                  position: (657, 13),
                 },
                ],
               },
              ],
             },
             position: (646, 9),
            },
           ),
          ],
          recursive: false,
          position: (641, 8),
         },
         position: (524, 5),
        },
        position: (523, 36),
       },
       position: (523, 27),
      },
      position: (523, 19),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mergeOptionDecls",
        position: (671, 3),
       },
      ],
     },
     LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "coerceOption",
           position: (673, 5),
          },
         ],
        },
        Function {
         argument: Some(
          "file",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Function {
          argument: Some(
           "opt",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: IfThenElse {
           predicate: FunctionApplication {
            function: Variable {
             identifier: "isFunction",
             position: (674, 10),
            },
            arguments: [
             Variable {
              identifier: "opt",
              position: (674, 21),
             },
            ],
           },
           then: FunctionApplication {
            function: Variable {
             identifier: "setDefaultModuleLocation",
             position: (674, 30),
            },
            arguments: [
             Variable {
              identifier: "file",
              position: (674, 55),
             },
             Variable {
              identifier: "opt",
              position: (674, 60),
             },
            ],
           },
           else_: FunctionApplication {
            function: Variable {
             identifier: "setDefaultModuleLocation",
             position: (675, 12),
            },
            arguments: [
             Variable {
              identifier: "file",
              position: (675, 37),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "options",
                   position: (675, 44),
                  },
                 ],
                },
                Variable {
                 identifier: "opt",
                 position: (675, 54),
                },
               ),
              ],
              recursive: false,
              position: (675, 42),
             },
            ],
           },
           position: (674, 7),
          },
          position: (673, 26),
         },
         position: (673, 20),
        },
       ),
      ],
      target: Function {
       argument: Some(
        "loc",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "opts",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: FunctionApplication {
         function: Variable {
          identifier: "foldl'",
          position: (677, 5),
         },
         arguments: [
          Function {
           argument: Some(
            "res",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "opt",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: LetIn {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "t",
                  position: (678, 11),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "res",
                 position: (678, 16),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (678, 20),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "t'",
                  position: (679, 11),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "opt",
                 position: (679, 16),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "options",
                   position: (679, 20),
                  },
                  Raw {
                   content: "type",
                   position: (679, 28),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "mergedType",
                  position: (680, 11),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "t",
                  position: (680, 24),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "typeMerge",
                    position: (680, 26),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "t'",
                   position: (680, 36),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "functor",
                     position: (680, 39),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "typesMergeable",
                  position: (681, 11),
                 },
                ],
               },
               BinaryOperation {
                operator: NotEqualTo,
                operands: [
                 Variable {
                  identifier: "mergedType",
                  position: (681, 28),
                 },
                 Variable {
                  identifier: "null",
                  position: (681, 42),
                 },
                ],
                position: (681, 39),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "typeSet",
                  position: (682, 11),
                 },
                ],
               },
               IfThenElse {
                predicate: BinaryOperation {
                 operator: LogicalAnd,
                 operands: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "bothHave",
                    position: (682, 25),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "type",
                      },
                     ],
                     position: (682, 34),
                    },
                   ],
                  },
                  Variable {
                   identifier: "typesMergeable",
                   position: (682, 45),
                  },
                 ],
                 position: (682, 42),
                },
                then: Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (683, 31),
                     },
                    ],
                   },
                   Variable {
                    identifier: "mergedType",
                    position: (683, 38),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (683, 29),
                },
                else_: Map {
                 bindings: [],
                 recursive: false,
                 position: (684, 29),
                },
                position: (682, 21),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "bothHave",
                  position: (685, 11),
                 },
                ],
               },
               Function {
                argument: Some(
                 "k",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: BinaryOperation {
                 operator: LogicalAnd,
                 operands: [
                  HasProperty {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "opt",
                     position: (685, 25),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "options",
                       position: (685, 29),
                      },
                     ],
                    },
                    default: None,
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Expression {
                      expression: Variable {
                       identifier: "k",
                       position: (685, 41),
                      },
                     },
                    ],
                   },
                   position: (685, 37),
                  },
                  HasProperty {
                   expression: Variable {
                    identifier: "res",
                    position: (685, 47),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Expression {
                      expression: Variable {
                       identifier: "k",
                       position: (685, 55),
                      },
                     },
                    ],
                   },
                   position: (685, 51),
                  },
                 ],
                 position: (685, 44),
                },
                position: (685, 22),
               },
              ),
             ],
             target: IfThenElse {
              predicate: BinaryOperation {
               operator: LogicalOr,
               operands: [
                BinaryOperation {
                 operator: LogicalOr,
                 operands: [
                  BinaryOperation {
                   operator: LogicalOr,
                   operands: [
                    BinaryOperation {
                     operator: LogicalOr,
                     operands: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "bothHave",
                        position: (687, 10),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "default",
                          },
                         ],
                         position: (687, 19),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "bothHave",
                        position: (688, 10),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "example",
                          },
                         ],
                         position: (688, 19),
                        },
                       ],
                      },
                     ],
                     position: (687, 29),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "bothHave",
                      position: (689, 10),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "description",
                        },
                       ],
                       position: (689, 19),
                      },
                     ],
                    },
                   ],
                   position: (688, 29),
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "bothHave",
                    position: (690, 10),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "apply",
                      },
                     ],
                     position: (690, 19),
                    },
                   ],
                  },
                 ],
                 position: (689, 33),
                },
                BinaryOperation {
                 operator: LogicalAnd,
                 operands: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "bothHave",
                    position: (691, 11),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "type",
                      },
                     ],
                     position: (691, 20),
                    },
                   ],
                  },
                  UnaryOperation {
                   operator: Not,
                   operand: Variable {
                    identifier: "typesMergeable",
                    position: (691, 33),
                   },
                   position: (691, 31),
                  },
                 ],
                 position: (691, 27),
                },
               ],
               position: (690, 27),
              },
              then: FunctionApplication {
               function: Variable {
                identifier: "throw",
                position: (693, 9),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "The option `",
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "showOption",
                     position: (693, 30),
                    },
                    arguments: [
                     Variable {
                      identifier: "loc",
                      position: (693, 41),
                     },
                    ],
                   },
                  },
                  Raw {
                   content: "' in `",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "opt",
                     position: (693, 53),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "_file",
                       position: (693, 57),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "' is already declared in ",
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "showFiles",
                     position: (693, 90),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "res",
                       position: (693, 100),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "declarations",
                         position: (693, 104),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  },
                  Raw {
                   content: ".",
                  },
                 ],
                 position: (693, 15),
                },
               ],
              },
              else_: LetIn {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "getSubModules",
                    position: (696, 11),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "opt",
                   position: (696, 27),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "options",
                     position: (696, 31),
                    },
                    Raw {
                     content: "type",
                     position: (696, 39),
                    },
                    Raw {
                     content: "getSubModules",
                     position: (696, 44),
                    },
                   ],
                  },
                  default: Some(
                   Variable {
                    identifier: "null",
                    position: (696, 61),
                   },
                  ),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "submodules",
                    position: (697, 11),
                   },
                  ],
                 },
                 IfThenElse {
                  predicate: BinaryOperation {
                   operator: NotEqualTo,
                   operands: [
                    Variable {
                     identifier: "getSubModules",
                     position: (698, 16),
                    },
                    Variable {
                     identifier: "null",
                     position: (698, 33),
                    },
                   ],
                   position: (698, 30),
                  },
                  then: BinaryOperation {
                   operator: Concatenation,
                   operands: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "map",
                      position: (698, 43),
                     },
                     arguments: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "setDefaultModuleLocation",
                        position: (698, 48),
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "opt",
                          position: (698, 73),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "_file",
                            position: (698, 77),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                      Variable {
                       identifier: "getSubModules",
                       position: (698, 84),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "res",
                      position: (698, 101),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "options",
                        position: (698, 105),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (698, 98),
                  },
                  else_: PropertyAccess {
                   expression: Variable {
                    identifier: "res",
                    position: (699, 18),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (699, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  position: (698, 13),
                 },
                ),
               ],
               target: BinaryOperation {
                operator: Update,
                operands: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "opt",
                   position: (700, 12),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "options",
                     position: (700, 16),
                    },
                   ],
                  },
                  default: None,
                 },
                 BinaryOperation {
                  operator: Update,
                  operands: [
                   Variable {
                    identifier: "res",
                    position: (700, 27),
                   },
                   BinaryOperation {
                    operator: Update,
                    operands: [
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "declarations",
                           position: (701, 13),
                          },
                         ],
                        },
                        BinaryOperation {
                         operator: Concatenation,
                         operands: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "res",
                            position: (701, 28),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "declarations",
                              position: (701, 32),
                             },
                            ],
                           },
                           default: None,
                          },
                          List {
                           elements: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "opt",
                              position: (701, 49),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "_file",
                                position: (701, 53),
                               },
                              ],
                             },
                             default: None,
                            },
                           ],
                           position: (701, 48),
                          },
                         ],
                         position: (701, 45),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "options",
                           position: (702, 13),
                          },
                         ],
                        },
                        Variable {
                         identifier: "submodules",
                         position: (702, 23),
                        },
                       ),
                      ],
                      recursive: false,
                      position: (701, 11),
                     },
                     Variable {
                      identifier: "typeSet",
                      position: (703, 16),
                     },
                    ],
                    position: (703, 13),
                   },
                  ],
                  position: (700, 31),
                 },
                ],
                position: (700, 24),
               },
               position: (695, 9),
              },
              position: (687, 7),
             },
             position: (678, 7),
            },
            position: (677, 18),
           },
           position: (677, 13),
          },
          Map {
           bindings: [
            Inherit(
             None,
             [
              Raw {
               content: "loc",
               position: (704, 17),
              },
             ],
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "declarations",
                position: (704, 22),
               },
              ],
             },
             List {
              elements: [],
              position: (704, 37),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "options",
                position: (704, 41),
               },
              ],
             },
             List {
              elements: [],
              position: (704, 51),
             },
            ),
           ],
           recursive: false,
           position: (704, 7),
          },
          Variable {
           identifier: "opts",
           position: (704, 57),
          },
         ],
        },
        position: (676, 12),
       },
       position: (676, 7),
      },
      position: (672, 4),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "evalOptionValue",
        position: (708, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "loc",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "opt",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "defs",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: LetIn {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "defs'",
              position: (711, 7),
             },
            ],
           },
           BinaryOperation {
            operator: Concatenation,
            operands: [
             FunctionApplication {
              function: Variable {
               identifier: "optional",
               position: (712, 12),
              },
              arguments: [
               HasProperty {
                expression: Variable {
                 identifier: "opt",
                 position: (712, 22),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (712, 28),
                  },
                 ],
                },
                position: (712, 26),
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "file",
                     position: (713, 15),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "head",
                    position: (713, 22),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "opt",
                      position: (713, 27),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "declarations",
                        position: (713, 31),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "value",
                     position: (713, 45),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkOptionDefault",
                    position: (713, 53),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "opt",
                      position: (713, 69),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "default",
                        position: (713, 73),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (713, 13),
               },
              ],
             },
             Variable {
              identifier: "defs",
              position: (713, 88),
             },
            ],
            position: (713, 85),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "res",
              position: (716, 7),
             },
            ],
           },
           IfThenElse {
            predicate: BinaryOperation {
             operator: LogicalAnd,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "opt",
                position: (717, 12),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "readOnly",
                  position: (717, 16),
                 },
                ],
               },
               default: Some(
                Variable {
                 identifier: "false",
                 position: (717, 28),
                },
               ),
              },
              BinaryOperation {
               operator: GreaterThan,
               operands: [
                FunctionApplication {
                 function: Variable {
                  identifier: "length",
                  position: (717, 37),
                 },
                 arguments: [
                  Variable {
                   identifier: "defs'",
                   position: (717, 44),
                  },
                 ],
                },
                Int {
                 value: 1,
                 position: (717, 52),
                },
               ],
               position: (717, 50),
              },
             ],
             position: (717, 34),
            },
            then: LetIn {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "separateDefs",
                  position: (721, 13),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "map",
                 position: (721, 28),
                },
                arguments: [
                 Function {
                  argument: Some(
                   "def",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Update,
                   operands: [
                    Variable {
                     identifier: "def",
                     position: (721, 38),
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "value",
                          position: (722, 15),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "mergeDefinitions",
                          position: (722, 24),
                         },
                         arguments: [
                          Variable {
                           identifier: "loc",
                           position: (722, 41),
                          },
                          PropertyAccess {
                           expression: Variable {
                            identifier: "opt",
                            position: (722, 45),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (722, 49),
                             },
                            ],
                           },
                           default: None,
                          },
                          List {
                           elements: [
                            Variable {
                             identifier: "def",
                             position: (722, 56),
                            },
                           ],
                           position: (722, 54),
                          },
                         ],
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "mergedValue",
                           position: (722, 63),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                     ],
                     recursive: false,
                     position: (721, 45),
                    },
                   ],
                   position: (721, 42),
                  },
                  position: (721, 33),
                 },
                 Variable {
                  identifier: "defs'",
                  position: (723, 16),
                 },
                ],
               },
              ),
             ],
             target: FunctionApplication {
              function: Variable {
               identifier: "throw",
               position: (724, 14),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "The option `",
                 },
                 Expression {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "showOption",
                    position: (724, 35),
                   },
                   arguments: [
                    Variable {
                     identifier: "loc",
                     position: (724, 46),
                    },
                   ],
                  },
                 },
                 Raw {
                  content: "' is read-only, but it's set multiple times. Definition values:",
                 },
                 Expression {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "showDefs",
                    position: (724, 115),
                   },
                   arguments: [
                    Variable {
                     identifier: "separateDefs",
                     position: (724, 124),
                    },
                   ],
                  },
                 },
                ],
                position: (724, 20),
               },
              ],
             },
             position: (718, 11),
            },
            else_: FunctionApplication {
             function: Variable {
              identifier: "mergeDefinitions",
              position: (726, 11),
             },
             arguments: [
              Variable {
               identifier: "loc",
               position: (726, 28),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "opt",
                position: (726, 32),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (726, 36),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "defs'",
               position: (726, 41),
              },
             ],
            },
            position: (717, 9),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "value",
              position: (730, 7),
             },
            ],
           },
           IfThenElse {
            predicate: HasProperty {
             expression: Variable {
              identifier: "opt",
              position: (730, 18),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "apply",
                position: (730, 24),
               },
              ],
             },
             position: (730, 22),
            },
            then: FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "opt",
               position: (730, 35),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "apply",
                 position: (730, 39),
                },
               ],
              },
              default: None,
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "res",
                position: (730, 45),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "mergedValue",
                  position: (730, 49),
                 },
                ],
               },
               default: None,
              },
             ],
            },
            else_: PropertyAccess {
             expression: Variable {
              identifier: "res",
              position: (730, 66),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "mergedValue",
                position: (730, 70),
               },
              ],
             },
             default: None,
            },
            position: (730, 15),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "warnDeprecation",
              position: (732, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "warnIf",
             position: (733, 9),
            },
            arguments: [
             BinaryOperation {
              operator: NotEqualTo,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "opt",
                 position: (733, 17),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (733, 21),
                  },
                  Raw {
                   content: "deprecationMessage",
                   position: (733, 26),
                  },
                 ],
                },
                default: None,
               },
               Variable {
                identifier: "null",
                position: (733, 48),
               },
              ],
              position: (733, 45),
             },
             String {
              parts: [
               Raw {
                content: "The type `types.",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "opt",
                  position: (734, 30),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (734, 34),
                   },
                   Raw {
                    content: "name",
                    position: (734, 39),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "' of option `",
               },
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "showOption",
                  position: (734, 59),
                 },
                 arguments: [
                  Variable {
                   identifier: "loc",
                   position: (734, 70),
                  },
                 ],
                },
               },
               Raw {
                content: "' defined in ",
               },
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "showFiles",
                  position: (734, 89),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "opt",
                    position: (734, 99),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "declarations",
                      position: (734, 103),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               },
               Raw {
                content: " is deprecated. ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "opt",
                  position: (734, 134),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (734, 138),
                   },
                   Raw {
                    content: "deprecationMessage",
                    position: (734, 143),
                   },
                  ],
                 },
                 default: None,
                },
               },
              ],
              position: (734, 11),
             },
            ],
           },
          ),
         ],
         target: BinaryOperation {
          operator: Update,
          operands: [
           FunctionApplication {
            function: Variable {
             identifier: "warnDeprecation",
             position: (736, 8),
            },
            arguments: [
             Variable {
              identifier: "opt",
              position: (736, 24),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "value",
                 position: (737, 9),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "builtins",
                 position: (737, 17),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "addErrorContext",
                   position: (737, 26),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "while evaluating the option `",
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "showOption",
                     position: (737, 74),
                    },
                    arguments: [
                     Variable {
                      identifier: "loc",
                      position: (737, 85),
                     },
                    ],
                   },
                  },
                  Raw {
                   content: "':",
                  },
                 ],
                 position: (737, 42),
                },
                Variable {
                 identifier: "value",
                 position: (737, 93),
                },
               ],
              },
             ),
             Inherit(
              Some(
               PropertyAccess {
                expression: Variable {
                 identifier: "res",
                 position: (738, 18),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "defsFinal'",
                   position: (738, 22),
                  },
                 ],
                },
                default: None,
               },
              ),
              [
               Raw {
                content: "highestPrio",
                position: (738, 34),
               },
              ],
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "definitions",
                 position: (739, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "map",
                position: (739, 23),
               },
               arguments: [
                Function {
                 argument: Some(
                  "def",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: PropertyAccess {
                  expression: Variable {
                   identifier: "def",
                   position: (739, 33),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "value",
                     position: (739, 37),
                    },
                   ],
                  },
                  default: None,
                 },
                 position: (739, 28),
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "res",
                  position: (739, 44),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "defsFinal",
                    position: (739, 48),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "files",
                 position: (740, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "map",
                position: (740, 17),
               },
               arguments: [
                Function {
                 argument: Some(
                  "def",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: PropertyAccess {
                  expression: Variable {
                   identifier: "def",
                   position: (740, 27),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "file",
                     position: (740, 31),
                    },
                   ],
                  },
                  default: None,
                 },
                 position: (740, 22),
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "res",
                  position: (740, 37),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "defsFinal",
                    position: (740, 41),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ),
             Inherit(
              Some(
               Variable {
                identifier: "res",
                position: (741, 18),
               },
              ),
              [
               Raw {
                content: "isDefined",
                position: (741, 23),
               },
              ],
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "__toString",
                 position: (743, 9),
                },
               ],
              },
              Function {
               argument: Some(
                "_",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: FunctionApplication {
                function: Variable {
                 identifier: "showOption",
                 position: (743, 25),
                },
                arguments: [
                 Variable {
                  identifier: "loc",
                  position: (743, 36),
                 },
                ],
               },
               position: (743, 22),
              },
             ),
            ],
            recursive: false,
            position: (737, 7),
           },
          ],
          position: (736, 28),
         },
         position: (709, 5),
        },
        position: (708, 31),
       },
       position: (708, 26),
      },
      position: (708, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mergeDefinitions",
        position: (747, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "loc",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "type",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "defs",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "defsFinal'",
              position: (748, 5),
             },
            ],
           },
           LetIn {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "defs'",
                 position: (751, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "concatMap",
                position: (751, 17),
               },
               arguments: [
                Function {
                 argument: Some(
                  "m",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: FunctionApplication {
                  function: Variable {
                   identifier: "map",
                   position: (752, 11),
                  },
                  arguments: [
                   Function {
                    argument: Some(
                     "value",
                    ),
                    arguments: FunctionArguments {
                     arguments: [],
                     ellipsis: false,
                    },
                    definition: Map {
                     bindings: [
                      Inherit(
                       Some(
                        Variable {
                         identifier: "m",
                         position: (752, 34),
                        },
                       ),
                       [
                        Raw {
                         content: "file",
                         position: (752, 37),
                        },
                       ],
                      ),
                      Inherit(
                       None,
                       [
                        Raw {
                         content: "value",
                         position: (752, 51),
                        },
                       ],
                      ),
                     ],
                     recursive: false,
                     position: (752, 23),
                    },
                    position: (752, 16),
                   },
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "builtins",
                      position: (752, 62),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "addErrorContext",
                        position: (752, 71),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "while evaluating definitions from `",
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "m",
                          position: (752, 125),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "file",
                            position: (752, 127),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "':",
                       },
                      ],
                      position: (752, 87),
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "dischargeProperties",
                       position: (752, 137),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "m",
                         position: (752, 157),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "value",
                           position: (752, 159),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    ],
                   },
                  ],
                 },
                 position: (751, 28),
                },
                Variable {
                 identifier: "defs",
                 position: (753, 11),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "defs''",
                 position: (756, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "filterOverrides'",
                position: (756, 18),
               },
               arguments: [
                Variable {
                 identifier: "defs'",
                 position: (756, 35),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "defs'''",
                 position: (759, 9),
                },
               ],
              },
              IfThenElse {
               predicate: FunctionApplication {
                function: Variable {
                 identifier: "any",
                 position: (761, 14),
                },
                arguments: [
                 Function {
                  argument: Some(
                   "def",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "def",
                      position: (761, 24),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "value",
                        position: (761, 28),
                       },
                       Raw {
                        content: "_type",
                        position: (761, 34),
                       },
                      ],
                     },
                     default: Some(
                      String {
                       parts: [],
                       position: (761, 43),
                      },
                     ),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "order",
                      },
                     ],
                     position: (761, 49),
                    },
                   ],
                   position: (761, 46),
                  },
                  position: (761, 19),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "defs''",
                   position: (761, 58),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "values",
                     position: (761, 65),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
               then: FunctionApplication {
                function: Variable {
                 identifier: "sortProperties",
                 position: (762, 16),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "defs''",
                   position: (762, 31),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "values",
                     position: (762, 38),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
               else_: PropertyAccess {
                expression: Variable {
                 identifier: "defs''",
                 position: (763, 16),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "values",
                   position: (763, 23),
                  },
                 ],
                },
                default: None,
               },
               position: (761, 11),
              },
             ),
            ],
            target: Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "values",
                  position: (765, 9),
                 },
                ],
               },
               Variable {
                identifier: "defs'''",
                position: (765, 18),
               },
              ),
              Inherit(
               Some(
                Variable {
                 identifier: "defs''",
                 position: (766, 18),
                },
               ),
               [
                Raw {
                 content: "highestPrio",
                 position: (766, 26),
                },
               ],
              ),
             ],
             recursive: false,
             position: (764, 10),
            },
            position: (749, 7),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "defsFinal",
              position: (768, 5),
             },
            ],
           },
           PropertyAccess {
            expression: Variable {
             identifier: "defsFinal'",
             position: (768, 17),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "values",
               position: (768, 28),
              },
             ],
            },
            default: None,
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "mergedValue",
              position: (771, 5),
             },
            ],
           },
           IfThenElse {
            predicate: Variable {
             identifier: "isDefined",
             position: (772, 10),
            },
            then: IfThenElse {
             predicate: FunctionApplication {
              function: Variable {
               identifier: "all",
               position: (773, 12),
              },
              arguments: [
               Function {
                argument: Some(
                 "def",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "type",
                   position: (773, 22),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "check",
                     position: (773, 27),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "def",
                    position: (773, 33),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "value",
                      position: (773, 37),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
                position: (773, 17),
               },
               Variable {
                identifier: "defsFinal",
                position: (773, 44),
               },
              ],
             },
             then: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "type",
                position: (773, 59),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "merge",
                  position: (773, 64),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Variable {
                identifier: "loc",
                position: (773, 70),
               },
               Variable {
                identifier: "defsFinal",
                position: (773, 74),
               },
              ],
             },
             else_: LetIn {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "allInvalid",
                   position: (774, 18),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "filter",
                  position: (774, 31),
                 },
                 arguments: [
                  Function {
                   argument: Some(
                    "def",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: UnaryOperation {
                    operator: Not,
                    operand: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "type",
                       position: (774, 46),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "check",
                         position: (774, 51),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "def",
                        position: (774, 57),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "value",
                          position: (774, 61),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                    position: (774, 44),
                   },
                   position: (774, 39),
                  },
                  Variable {
                   identifier: "defsFinal",
                   position: (774, 68),
                  },
                 ],
                },
               ),
              ],
              target: FunctionApplication {
               function: Variable {
                identifier: "throw",
                position: (775, 12),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "A definition for option `",
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "showOption",
                     position: (775, 46),
                    },
                    arguments: [
                     Variable {
                      identifier: "loc",
                      position: (775, 57),
                     },
                    ],
                   },
                  },
                  Raw {
                   content: "' is not of type `",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "type",
                     position: (775, 81),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (775, 86),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "'. Definition values:",
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "showDefs",
                     position: (775, 121),
                    },
                    arguments: [
                     Variable {
                      identifier: "allInvalid",
                      position: (775, 130),
                     },
                    ],
                   },
                  },
                 ],
                 position: (775, 18),
                },
               ],
              },
              position: (774, 14),
             },
             position: (773, 9),
            },
            else_: FunctionApplication {
             function: Variable {
              identifier: "throw",
              position: (779, 9),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "The option `",
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "showOption",
                   position: (779, 30),
                  },
                  arguments: [
                   Variable {
                    identifier: "loc",
                    position: (779, 41),
                   },
                  ],
                 },
                },
                Raw {
                 content: "' is used but not defined.",
                },
               ],
               position: (779, 15),
              },
             ],
            },
            position: (772, 7),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "isDefined",
              position: (781, 5),
             },
            ],
           },
           BinaryOperation {
            operator: NotEqualTo,
            operands: [
             Variable {
              identifier: "defsFinal",
              position: (781, 17),
             },
             List {
              elements: [],
              position: (781, 30),
             },
            ],
            position: (781, 27),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "optionalValue",
              position: (783, 5),
             },
            ],
           },
           IfThenElse {
            predicate: Variable {
             identifier: "isDefined",
             position: (784, 10),
            },
            then: Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "value",
                  position: (784, 27),
                 },
                ],
               },
               Variable {
                identifier: "mergedValue",
                position: (784, 35),
               },
              ),
             ],
             recursive: false,
             position: (784, 25),
            },
            else_: Map {
             bindings: [],
             recursive: false,
             position: (785, 12),
            },
            position: (784, 7),
           },
          ),
         ],
         recursive: true,
         position: (747, 39),
        },
        position: (747, 33),
       },
       position: (747, 27),
      },
      position: (747, 22),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "pushDownProperties",
        position: (803, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "cfg",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: IfThenElse {
       predicate: BinaryOperation {
        operator: EqualTo,
        operands: [
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (804, 8),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "_type",
             position: (804, 12),
            },
           ],
          },
          default: Some(
           String {
            parts: [],
            position: (804, 21),
           },
          ),
         },
         String {
          parts: [
           Raw {
            content: "merge",
           },
          ],
          position: (804, 27),
         },
        ],
        position: (804, 24),
       },
       then: FunctionApplication {
        function: Variable {
         identifier: "concatMap",
         position: (805, 7),
        },
        arguments: [
         Variable {
          identifier: "pushDownProperties",
          position: (805, 17),
         },
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (805, 36),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "contents",
             position: (805, 40),
            },
           ],
          },
          default: None,
         },
        ],
       },
       else_: IfThenElse {
        predicate: BinaryOperation {
         operator: EqualTo,
         operands: [
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (806, 13),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "_type",
              position: (806, 17),
             },
            ],
           },
           default: Some(
            String {
             parts: [],
             position: (806, 26),
            },
           ),
          },
          String {
           parts: [
            Raw {
             content: "if",
            },
           ],
           position: (806, 32),
          },
         ],
         position: (806, 29),
        },
        then: FunctionApplication {
         function: Variable {
          identifier: "map",
          position: (807, 7),
         },
         arguments: [
          FunctionApplication {
           function: Variable {
            identifier: "mapAttrs",
            position: (807, 12),
           },
           arguments: [
            Function {
             argument: Some(
              "n",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: Function {
              argument: Some(
               "v",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: FunctionApplication {
               function: Variable {
                identifier: "mkIf",
                position: (807, 28),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (807, 33),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "condition",
                    position: (807, 37),
                   },
                  ],
                 },
                 default: None,
                },
                Variable {
                 identifier: "v",
                 position: (807, 47),
                },
               ],
              },
              position: (807, 25),
             },
             position: (807, 22),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "pushDownProperties",
            position: (807, 52),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (807, 71),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "content",
                position: (807, 75),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ],
        },
        else_: IfThenElse {
         predicate: BinaryOperation {
          operator: EqualTo,
          operands: [
           PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (808, 13),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "_type",
               position: (808, 17),
              },
             ],
            },
            default: Some(
             String {
              parts: [],
              position: (808, 26),
             },
            ),
           },
           String {
            parts: [
             Raw {
              content: "override",
             },
            ],
            position: (808, 32),
           },
          ],
          position: (808, 29),
         },
         then: FunctionApplication {
          function: Variable {
           identifier: "map",
           position: (809, 7),
          },
          arguments: [
           FunctionApplication {
            function: Variable {
             identifier: "mapAttrs",
             position: (809, 12),
            },
            arguments: [
             Function {
              argument: Some(
               "n",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "v",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: FunctionApplication {
                function: Variable {
                 identifier: "mkOverride",
                 position: (809, 28),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (809, 39),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "priority",
                     position: (809, 43),
                    },
                   ],
                  },
                  default: None,
                 },
                 Variable {
                  identifier: "v",
                  position: (809, 52),
                 },
                ],
               },
               position: (809, 25),
              },
              position: (809, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "pushDownProperties",
             position: (809, 57),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (809, 76),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "content",
                 position: (809, 80),
                },
               ],
              },
              default: None,
             },
            ],
           },
          ],
         },
         else_: List {
          elements: [
           Variable {
            identifier: "cfg",
            position: (811, 9),
           },
          ],
          position: (811, 7),
         },
         position: (808, 10),
        },
        position: (806, 10),
       },
       position: (804, 5),
      },
      position: (803, 24),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "dischargeProperties",
        position: (823, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "def",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: IfThenElse {
       predicate: BinaryOperation {
        operator: EqualTo,
        operands: [
         PropertyAccess {
          expression: Variable {
           identifier: "def",
           position: (824, 8),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "_type",
             position: (824, 12),
            },
           ],
          },
          default: Some(
           String {
            parts: [],
            position: (824, 21),
           },
          ),
         },
         String {
          parts: [
           Raw {
            content: "merge",
           },
          ],
          position: (824, 27),
         },
        ],
        position: (824, 24),
       },
       then: FunctionApplication {
        function: Variable {
         identifier: "concatMap",
         position: (825, 7),
        },
        arguments: [
         Variable {
          identifier: "dischargeProperties",
          position: (825, 17),
         },
         PropertyAccess {
          expression: Variable {
           identifier: "def",
           position: (825, 37),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "contents",
             position: (825, 41),
            },
           ],
          },
          default: None,
         },
        ],
       },
       else_: IfThenElse {
        predicate: BinaryOperation {
         operator: EqualTo,
         operands: [
          PropertyAccess {
           expression: Variable {
            identifier: "def",
            position: (826, 13),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "_type",
              position: (826, 17),
             },
            ],
           },
           default: Some(
            String {
             parts: [],
             position: (826, 26),
            },
           ),
          },
          String {
           parts: [
            Raw {
             content: "if",
            },
           ],
           position: (826, 32),
          },
         ],
         position: (826, 29),
        },
        then: IfThenElse {
         predicate: FunctionApplication {
          function: Variable {
           identifier: "isBool",
           position: (827, 10),
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "def",
             position: (827, 17),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "condition",
               position: (827, 21),
              },
             ],
            },
            default: None,
           },
          ],
         },
         then: IfThenElse {
          predicate: PropertyAccess {
           expression: Variable {
            identifier: "def",
            position: (828, 12),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "condition",
              position: (828, 16),
             },
            ],
           },
           default: None,
          },
          then: FunctionApplication {
           function: Variable {
            identifier: "dischargeProperties",
            position: (829, 11),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "def",
              position: (829, 31),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "content",
                position: (829, 35),
               },
              ],
             },
             default: None,
            },
           ],
          },
          else_: List {
           elements: [],
           position: (831, 11),
          },
          position: (828, 9),
         },
         else_: FunctionApplication {
          function: Variable {
           identifier: "throw",
           position: (833, 9),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: "‘mkIf’ called with a non-Boolean condition",
             },
            ],
            position: (833, 15),
           },
          ],
         },
         position: (827, 7),
        },
        else_: List {
         elements: [
          Variable {
           identifier: "def",
           position: (835, 9),
          },
         ],
         position: (835, 7),
        },
        position: (826, 10),
       },
       position: (824, 5),
      },
      position: (823, 25),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "filterOverrides",
        position: (856, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "defs",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: PropertyAccess {
       expression: FunctionApplication {
        function: Variable {
         identifier: "filterOverrides'",
         position: (856, 28),
        },
        arguments: [
         Variable {
          identifier: "defs",
          position: (856, 45),
         },
        ],
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "values",
          position: (856, 51),
         },
        ],
       },
       default: None,
      },
      position: (856, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "filterOverrides'",
        position: (858, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "defs",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: LetIn {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "getPrio",
            position: (860, 7),
           },
          ],
         },
         Function {
          argument: Some(
           "def",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: IfThenElse {
           predicate: BinaryOperation {
            operator: EqualTo,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "def",
               position: (860, 25),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "value",
                 position: (860, 29),
                },
                Raw {
                 content: "_type",
                 position: (860, 35),
                },
               ],
              },
              default: Some(
               String {
                parts: [],
                position: (860, 44),
               },
              ),
             },
             String {
              parts: [
               Raw {
                content: "override",
               },
              ],
              position: (860, 50),
             },
            ],
            position: (860, 47),
           },
           then: PropertyAccess {
            expression: Variable {
             identifier: "def",
             position: (860, 66),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "value",
               position: (860, 70),
              },
              Raw {
               content: "priority",
               position: (860, 76),
              },
             ],
            },
            default: None,
           },
           else_: Variable {
            identifier: "defaultPriority",
            position: (860, 90),
           },
           position: (860, 22),
          },
          position: (860, 17),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "highestPrio",
            position: (861, 7),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "foldl'",
           position: (861, 21),
          },
          arguments: [
           Function {
            argument: Some(
             "prio",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Function {
             argument: Some(
              "def",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: FunctionApplication {
              function: Variable {
               identifier: "min",
               position: (861, 40),
              },
              arguments: [
               FunctionApplication {
                function: Variable {
                 identifier: "getPrio",
                 position: (861, 45),
                },
                arguments: [
                 Variable {
                  identifier: "def",
                  position: (861, 53),
                 },
                ],
               },
               Variable {
                identifier: "prio",
                position: (861, 58),
               },
              ],
             },
             position: (861, 35),
            },
            position: (861, 29),
           },
           Int {
            value: 9999,
            position: (861, 64),
           },
           Variable {
            identifier: "defs",
            position: (861, 69),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "strip",
            position: (862, 7),
           },
          ],
         },
         Function {
          argument: Some(
           "def",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: IfThenElse {
           predicate: BinaryOperation {
            operator: EqualTo,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "def",
               position: (862, 23),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "value",
                 position: (862, 27),
                },
                Raw {
                 content: "_type",
                 position: (862, 33),
                },
               ],
              },
              default: Some(
               String {
                parts: [],
                position: (862, 42),
               },
              ),
             },
             String {
              parts: [
               Raw {
                content: "override",
               },
              ],
              position: (862, 48),
             },
            ],
            position: (862, 45),
           },
           then: BinaryOperation {
            operator: Update,
            operands: [
             Variable {
              identifier: "def",
              position: (862, 64),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "value",
                   position: (862, 73),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "def",
                  position: (862, 81),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "value",
                    position: (862, 85),
                   },
                   Raw {
                    content: "content",
                    position: (862, 91),
                   },
                  ],
                 },
                 default: None,
                },
               ),
              ],
              recursive: false,
              position: (862, 71),
             },
            ],
            position: (862, 68),
           },
           else_: Variable {
            identifier: "def",
            position: (862, 107),
           },
           position: (862, 20),
          },
          position: (862, 15),
         },
        ),
       ],
       target: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "values",
             position: (864, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "concatMap",
            position: (864, 16),
           },
           arguments: [
            Function {
             argument: Some(
              "def",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: IfThenElse {
              predicate: BinaryOperation {
               operator: EqualTo,
               operands: [
                FunctionApplication {
                 function: Variable {
                  identifier: "getPrio",
                  position: (864, 35),
                 },
                 arguments: [
                  Variable {
                   identifier: "def",
                   position: (864, 43),
                  },
                 ],
                },
                Variable {
                 identifier: "highestPrio",
                 position: (864, 50),
                },
               ],
               position: (864, 47),
              },
              then: List {
               elements: [
                FunctionApplication {
                 function: Variable {
                  identifier: "strip",
                  position: (864, 69),
                 },
                 arguments: [
                  Variable {
                   identifier: "def",
                   position: (864, 75),
                  },
                 ],
                },
               ],
               position: (864, 67),
              },
              else_: List {
               elements: [],
               position: (864, 86),
              },
              position: (864, 32),
             },
             position: (864, 27),
            },
            Variable {
             identifier: "defs",
             position: (864, 90),
            },
           ],
          },
         ),
         Inherit(
          None,
          [
           Raw {
            content: "highestPrio",
            position: (865, 15),
           },
          ],
         ),
        ],
        recursive: false,
        position: (863, 8),
       },
       position: (859, 5),
      },
      position: (858, 22),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "sortProperties",
        position: (871, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "defs",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: LetIn {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "strip",
            position: (873, 7),
           },
          ],
         },
         Function {
          argument: Some(
           "def",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: IfThenElse {
           predicate: BinaryOperation {
            operator: EqualTo,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "def",
               position: (874, 12),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "value",
                 position: (874, 16),
                },
                Raw {
                 content: "_type",
                 position: (874, 22),
                },
               ],
              },
              default: Some(
               String {
                parts: [],
                position: (874, 31),
               },
              ),
             },
             String {
              parts: [
               Raw {
                content: "order",
               },
              ],
              position: (874, 37),
             },
            ],
            position: (874, 34),
           },
           then: BinaryOperation {
            operator: Update,
            operands: [
             Variable {
              identifier: "def",
              position: (875, 14),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "value",
                   position: (875, 23),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "def",
                  position: (875, 31),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "value",
                    position: (875, 35),
                   },
                   Raw {
                    content: "content",
                    position: (875, 41),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               Inherit(
                Some(
                 PropertyAccess {
                  expression: Variable {
                   identifier: "def",
                   position: (875, 59),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "value",
                     position: (875, 63),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                [
                 Raw {
                  content: "priority",
                  position: (875, 70),
                 },
                ],
               ),
              ],
              recursive: false,
              position: (875, 21),
             },
            ],
            position: (875, 18),
           },
           else_: Variable {
            identifier: "def",
            position: (876, 14),
           },
           position: (874, 9),
          },
          position: (873, 15),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "defs'",
            position: (877, 7),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "map",
           position: (877, 15),
          },
          arguments: [
           Variable {
            identifier: "strip",
            position: (877, 19),
           },
           Variable {
            identifier: "defs",
            position: (877, 25),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "compare",
            position: (878, 7),
           },
          ],
         },
         Function {
          argument: Some(
           "a",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: Function {
           argument: Some(
            "b",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: BinaryOperation {
            operator: LessThan,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "a",
               position: (878, 24),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "priority",
                 position: (878, 26),
                },
               ],
              },
              default: Some(
               Int {
                value: 1000,
                position: (878, 38),
               },
              ),
             },
             PropertyAccess {
              expression: Variable {
               identifier: "b",
               position: (878, 47),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "priority",
                 position: (878, 49),
                },
               ],
              },
              default: Some(
               Int {
                value: 1000,
                position: (878, 61),
               },
              ),
             },
            ],
            position: (878, 44),
           },
           position: (878, 20),
          },
          position: (878, 17),
         },
        ),
       ],
       target: FunctionApplication {
        function: Variable {
         identifier: "sort",
         position: (879, 8),
        },
        arguments: [
         Variable {
          identifier: "compare",
          position: (879, 13),
         },
         Variable {
          identifier: "defs'",
          position: (879, 21),
         },
        ],
       },
       position: (872, 5),
      },
      position: (871, 20),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "fixupOptionType",
        position: (884, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "loc",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "opt",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: IfThenElse {
        predicate: BinaryOperation {
         operator: EqualTo,
         operands: [
          PropertyAccess {
           expression: Variable {
            identifier: "opt",
            position: (885, 8),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "type",
              position: (885, 12),
             },
             Raw {
              content: "getSubModules",
              position: (885, 17),
             },
            ],
           },
           default: Some(
            Variable {
             identifier: "null",
             position: (885, 34),
            },
           ),
          },
          Variable {
           identifier: "null",
           position: (885, 42),
          },
         ],
         position: (885, 39),
        },
        then: BinaryOperation {
         operator: Update,
         operands: [
          Variable {
           identifier: "opt",
           position: (886, 10),
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (886, 19),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "opt",
               position: (886, 26),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (886, 30),
                },
               ],
              },
              default: Some(
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (886, 38),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "unspecified",
                   position: (886, 44),
                  },
                 ],
                },
                default: None,
               },
              ),
             },
            ),
           ],
           recursive: false,
           position: (886, 17),
          },
         ],
         position: (886, 14),
        },
        else_: BinaryOperation {
         operator: Update,
         operands: [
          Variable {
           identifier: "opt",
           position: (887, 10),
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (887, 19),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "opt",
                position: (887, 26),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (887, 30),
                 },
                 Raw {
                  content: "substSubModules",
                  position: (887, 35),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "opt",
                 position: (887, 51),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "options",
                   position: (887, 55),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "options",
                position: (887, 64),
               },
              ],
             },
             List {
              elements: [],
              position: (887, 74),
             },
            ),
           ],
           recursive: false,
           position: (887, 17),
          },
         ],
         position: (887, 14),
        },
        position: (885, 5),
       },
       position: (884, 26),
      },
      position: (884, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkIf",
        position: (892, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "condition",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "content",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "_type",
             position: (893, 7),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "if",
            },
           ],
           position: (893, 15),
          },
         ),
         Inherit(
          None,
          [
           Raw {
            content: "condition",
            position: (894, 15),
           },
           Raw {
            content: "content",
            position: (894, 25),
           },
          ],
         ),
        ],
        recursive: false,
        position: (893, 5),
       },
       position: (892, 21),
      },
      position: (892, 10),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkAssert",
        position: (897, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "assertion",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "message",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "content",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: FunctionApplication {
         function: Variable {
          identifier: "mkIf",
          position: (898, 5),
         },
         arguments: [
          IfThenElse {
           predicate: Variable {
            identifier: "assertion",
            position: (899, 11),
           },
           then: Variable {
            identifier: "true",
            position: (899, 26),
           },
           else_: FunctionApplication {
            function: Variable {
             identifier: "throw",
             position: (899, 36),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "\nFailed assertion: ",
               },
               Expression {
                expression: Variable {
                 identifier: "message",
                 position: (899, 65),
                },
               },
              ],
              position: (899, 42),
             },
            ],
           },
           position: (899, 8),
          },
          Variable {
           identifier: "content",
           position: (900, 7),
          },
         ],
        },
        position: (897, 34),
       },
       position: (897, 25),
      },
      position: (897, 14),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkMerge",
        position: (902, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "contents",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "_type",
            position: (903, 7),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "merge",
           },
          ],
          position: (903, 15),
         },
        ),
        Inherit(
         None,
         [
          Raw {
           content: "contents",
           position: (904, 15),
          },
         ],
        ),
       ],
       recursive: false,
       position: (903, 5),
      },
      position: (902, 13),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkOverride",
        position: (907, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "priority",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "content",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "_type",
             position: (908, 7),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "override",
            },
           ],
           position: (908, 15),
          },
         ),
         Inherit(
          None,
          [
           Raw {
            content: "priority",
            position: (909, 15),
           },
           Raw {
            content: "content",
            position: (909, 24),
           },
          ],
         ),
        ],
        recursive: false,
        position: (908, 5),
       },
       position: (907, 26),
      },
      position: (907, 16),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkOptionDefault",
        position: (912, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "mkOverride",
       position: (912, 21),
      },
      arguments: [
       Int {
        value: 1500,
        position: (912, 32),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkDefault",
        position: (913, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "mkOverride",
       position: (913, 15),
      },
      arguments: [
       Int {
        value: 1000,
        position: (913, 26),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkImageMediaOverride",
        position: (914, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "mkOverride",
       position: (914, 26),
      },
      arguments: [
       Int {
        value: 60,
        position: (914, 37),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkForce",
        position: (915, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "mkOverride",
       position: (915, 13),
      },
      arguments: [
       Int {
        value: 50,
        position: (915, 24),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkVMOverride",
        position: (916, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "mkOverride",
       position: (916, 18),
      },
      arguments: [
       Int {
        value: 10,
        position: (916, 29),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkFixStrictness",
        position: (918, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (918, 21),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "warn",
          position: (918, 25),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "lib.mkFixStrictness has no effect and will be removed. It returns its argument unmodified, so you can just remove any calls.",
         },
        ],
        position: (918, 30),
       },
       Variable {
        identifier: "id",
        position: (918, 157),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkOrder",
        position: (920, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "priority",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "content",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "_type",
             position: (921, 7),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "order",
            },
           ],
           position: (921, 15),
          },
         ),
         Inherit(
          None,
          [
           Raw {
            content: "priority",
            position: (922, 15),
           },
           Raw {
            content: "content",
            position: (922, 24),
           },
          ],
         ),
        ],
        recursive: false,
        position: (921, 5),
       },
       position: (920, 23),
      },
      position: (920, 13),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkBefore",
        position: (925, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "mkOrder",
       position: (925, 14),
      },
      arguments: [
       Int {
        value: 500,
        position: (925, 22),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkAfter",
        position: (926, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "mkOrder",
       position: (926, 13),
      },
      arguments: [
       Int {
        value: 1500,
        position: (926, 21),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "defaultPriority",
        position: (929, 3),
       },
      ],
     },
     Int {
      value: 100,
      position: (929, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkAliasDefinitions",
        position: (950, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "mkAliasAndWrapDefinitions",
       position: (950, 24),
      },
      arguments: [
       Variable {
        identifier: "id",
        position: (950, 50),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkAliasAndWrapDefinitions",
        position: (951, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "wrap",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "option",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "mkAliasIfDef",
         position: (952, 5),
        },
        arguments: [
         Variable {
          identifier: "option",
          position: (952, 18),
         },
         FunctionApplication {
          function: Variable {
           identifier: "wrap",
           position: (952, 26),
          },
          arguments: [
           FunctionApplication {
            function: Variable {
             identifier: "mkMerge",
             position: (952, 32),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "option",
               position: (952, 40),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "definitions",
                 position: (952, 47),
                },
               ],
              },
              default: None,
             },
            ],
           },
          ],
         },
        ],
       },
       position: (951, 37),
      },
      position: (951, 31),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkAliasAndWrapDefsWithPriority",
        position: (958, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "wrap",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "option",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "prio",
             position: (960, 7),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "option",
            position: (960, 14),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "highestPrio",
              position: (960, 21),
             },
            ],
           },
           default: Some(
            Variable {
             identifier: "defaultPriority",
             position: (960, 36),
            },
           ),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "defsWithPrio",
             position: (961, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "map",
            position: (961, 22),
           },
           arguments: [
            FunctionApplication {
             function: Variable {
              identifier: "mkOverride",
              position: (961, 27),
             },
             arguments: [
              Variable {
               identifier: "prio",
               position: (961, 38),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "option",
              position: (961, 44),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "definitions",
                position: (961, 51),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ),
        ],
        target: FunctionApplication {
         function: Variable {
          identifier: "mkAliasIfDef",
          position: (962, 8),
         },
         arguments: [
          Variable {
           identifier: "option",
           position: (962, 21),
          },
          FunctionApplication {
           function: Variable {
            identifier: "wrap",
            position: (962, 29),
           },
           arguments: [
            FunctionApplication {
             function: Variable {
              identifier: "mkMerge",
              position: (962, 35),
             },
             arguments: [
              Variable {
               identifier: "defsWithPrio",
               position: (962, 43),
              },
             ],
            },
           ],
          },
         ],
        },
        position: (959, 5),
       },
       position: (958, 42),
      },
      position: (958, 36),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkAliasIfDef",
        position: (964, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "option",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (965, 5),
       },
       arguments: [
        BinaryOperation {
         operator: LogicalAnd,
         operands: [
          FunctionApplication {
           function: Variable {
            identifier: "isOption",
            position: (965, 11),
           },
           arguments: [
            Variable {
             identifier: "option",
             position: (965, 20),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "option",
            position: (965, 30),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "isDefined",
              position: (965, 37),
             },
            ],
           },
           default: None,
          },
         ],
         position: (965, 27),
        },
       ],
      },
      position: (964, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "fixMergeModules",
        position: (968, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "modules",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "args",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "evalModules",
         position: (968, 36),
        },
        arguments: [
         Map {
          bindings: [
           Inherit(
            None,
            [
             Raw {
              content: "modules",
              position: (968, 58),
             },
             Raw {
              content: "args",
              position: (968, 66),
             },
            ],
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "check",
               position: (968, 72),
              },
             ],
            },
            Variable {
             identifier: "false",
             position: (968, 80),
            },
           ),
          ],
          recursive: false,
          position: (968, 48),
         },
        ],
       },
       position: (968, 30),
      },
      position: (968, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkRemovedOptionModule",
        position: (983, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "optionName",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "replacementInstructions",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: None,
        arguments: FunctionArguments {
         arguments: [
          FunctionArgument {
           identifier: "options",
           default: None,
          },
         ],
         ellipsis: true,
        },
        definition: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "options",
              position: (985, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "setAttrByPath",
             position: (985, 17),
            },
            arguments: [
             Variable {
              identifier: "optionName",
              position: (985, 31),
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (985, 43),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "visible",
                     position: (986, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "false",
                   position: (986, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "apply",
                     position: (987, 9),
                    },
                   ],
                  },
                  Function {
                   argument: Some(
                    "x",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: FunctionApplication {
                    function: Variable {
                     identifier: "throw",
                     position: (987, 20),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "The option `",
                       },
                       Expression {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "showOption",
                          position: (987, 41),
                         },
                         arguments: [
                          Variable {
                           identifier: "optionName",
                           position: (987, 52),
                          },
                         ],
                        },
                       },
                       Raw {
                        content: "' can no longer be used since it's been removed. ",
                       },
                       Expression {
                        expression: Variable {
                         identifier: "replacementInstructions",
                         position: (987, 114),
                        },
                       },
                      ],
                      position: (987, 26),
                     },
                    ],
                   },
                   position: (987, 17),
                  },
                 ),
                ],
                recursive: false,
                position: (985, 52),
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "config",
              position: (989, 7),
             },
             Raw {
              content: "assertions",
              position: (989, 14),
             },
            ],
           },
           LetIn {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "opt",
                 position: (990, 13),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "getAttrFromPath",
                position: (990, 19),
               },
               arguments: [
                Variable {
                 identifier: "optionName",
                 position: (990, 35),
                },
                Variable {
                 identifier: "options",
                 position: (990, 46),
                },
               ],
              },
             ),
            ],
            target: List {
             elements: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "assertion",
                    position: (991, 11),
                   },
                  ],
                 },
                 UnaryOperation {
                  operator: Not,
                  operand: PropertyAccess {
                   expression: Variable {
                    identifier: "opt",
                    position: (991, 24),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "isDefined",
                      position: (991, 28),
                     },
                    ],
                   },
                   default: None,
                  },
                  position: (991, 23),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "message",
                    position: (992, 11),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The option definition `",
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "showOption",
                      position: (993, 38),
                     },
                     arguments: [
                      Variable {
                       identifier: "optionName",
                       position: (993, 49),
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "' in ",
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "showFiles",
                      position: (993, 67),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (993, 77),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "files",
                          position: (993, 81),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   },
                   Raw {
                    content: " no longer has any effect; please remove it.\n",
                   },
                   Expression {
                    expression: Variable {
                     identifier: "replacementInstructions",
                     position: (994, 15),
                    },
                   },
                   Raw {
                    content: "\n",
                   },
                  ],
                  position: (992, 21),
                 },
                ),
               ],
               recursive: false,
               position: (990, 59),
              },
             ],
             position: (990, 58),
            },
            position: (990, 9),
           },
          ),
         ],
         recursive: false,
         position: (985, 5),
        },
        position: (984, 5),
       },
       position: (983, 39),
      },
      position: (983, 27),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkRenamedOptionModule",
        position: (1012, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "from",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "to",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "doRename",
         position: (1012, 37),
        },
        arguments: [
         Map {
          bindings: [
           Inherit(
            None,
            [
             Raw {
              content: "from",
              position: (1013, 13),
             },
             Raw {
              content: "to",
              position: (1013, 18),
             },
            ],
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "visible",
               position: (1014, 5),
              },
             ],
            },
            Variable {
             identifier: "false",
             position: (1014, 15),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "warn",
               position: (1015, 5),
              },
             ],
            },
            Variable {
             identifier: "true",
             position: (1015, 12),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "use",
               position: (1016, 5),
              },
             ],
            },
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "builtins",
               position: (1016, 11),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "trace",
                 position: (1016, 20),
                },
               ],
              },
              default: None,
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "Obsolete option `",
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "showOption",
                   position: (1016, 46),
                  },
                  arguments: [
                   Variable {
                    identifier: "from",
                    position: (1016, 57),
                   },
                  ],
                 },
                },
                Raw {
                 content: "' is used. It was renamed to `",
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "showOption",
                   position: (1016, 94),
                  },
                  arguments: [
                   Variable {
                    identifier: "to",
                    position: (1016, 105),
                   },
                  ],
                 },
                },
                Raw {
                 content: "'.",
                },
               ],
               position: (1016, 26),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (1012, 46),
         },
        ],
       },
       position: (1012, 33),
      },
      position: (1012, 27),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkRenamedOptionModuleWith",
        position: (1019, 3),
       },
      ],
     },
     Function {
      argument: None,
      arguments: FunctionArguments {
       arguments: [
        FunctionArgument {
         identifier: "sinceRelease",
         default: None,
        },
        FunctionArgument {
         identifier: "to",
         default: None,
        },
        FunctionArgument {
         identifier: "from",
         default: None,
        },
       ],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "doRename",
        position: (1031, 6),
       },
       arguments: [
        Map {
         bindings: [
          Inherit(
           None,
           [
            Raw {
             content: "from",
             position: (1032, 13),
            },
            Raw {
             content: "to",
             position: (1032, 18),
            },
           ],
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "visible",
              position: (1033, 5),
             },
            ],
           },
           Variable {
            identifier: "false",
            position: (1033, 15),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "warn",
              position: (1034, 5),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (1034, 12),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "isInOldestRelease",
                position: (1034, 16),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Variable {
              identifier: "sinceRelease",
              position: (1034, 34),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "use",
              position: (1035, 5),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (1035, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "warnIf",
                position: (1035, 15),
               },
              ],
             },
             default: None,
            },
            arguments: [
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "lib",
                position: (1035, 23),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "isInOldestRelease",
                  position: (1035, 27),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Variable {
                identifier: "sinceRelease",
                position: (1035, 45),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Obsolete option `",
               },
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "showOption",
                  position: (1036, 27),
                 },
                 arguments: [
                  Variable {
                   identifier: "from",
                   position: (1036, 38),
                  },
                 ],
                },
               },
               Raw {
                content: "' is used. It was renamed to `",
               },
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "showOption",
                  position: (1036, 75),
                 },
                 arguments: [
                  Variable {
                   identifier: "to",
                   position: (1036, 86),
                  },
                 ],
                },
               },
               Raw {
                content: "'.",
               },
              ],
              position: (1036, 7),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (1031, 15),
        },
       ],
      },
      position: (1019, 31),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkMergedOptionModule",
        position: (1067, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "from",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "to",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "mergeFn",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Function {
         argument: None,
         arguments: FunctionArguments {
          arguments: [
           FunctionArgument {
            identifier: "options",
            default: None,
           },
           FunctionArgument {
            identifier: "config",
            default: None,
           },
          ],
          ellipsis: true,
         },
         definition: Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "options",
               position: (1070, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "foldl'",
              position: (1070, 17),
             },
             arguments: [
              Variable {
               identifier: "recursiveUpdate",
               position: (1070, 24),
              },
              Map {
               bindings: [],
               recursive: false,
               position: (1070, 40),
              },
              FunctionApplication {
               function: Variable {
                identifier: "map",
                position: (1070, 44),
               },
               arguments: [
                Function {
                 argument: Some(
                  "path",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: FunctionApplication {
                  function: Variable {
                   identifier: "setAttrByPath",
                   position: (1070, 55),
                  },
                  arguments: [
                   Variable {
                    identifier: "path",
                    position: (1070, 69),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "mkOption",
                     position: (1070, 75),
                    },
                    arguments: [
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "visible",
                           position: (1071, 9),
                          },
                         ],
                        },
                        Variable {
                         identifier: "false",
                         position: (1071, 19),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "default",
                           position: (1073, 9),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "_mkMergedOptionModule",
                          },
                         ],
                         position: (1073, 19),
                        },
                       ),
                      ],
                      recursive: false,
                      position: (1070, 84),
                     },
                    ],
                   },
                  ],
                 },
                 position: (1070, 49),
                },
                Variable {
                 identifier: "from",
                 position: (1074, 11),
                },
               ],
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "config",
               position: (1076, 7),
              },
             ],
            },
            BinaryOperation {
             operator: Update,
             operands: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "warnings",
                    position: (1077, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "filter",
                   position: (1077, 20),
                  },
                  arguments: [
                   Function {
                    argument: Some(
                     "x",
                    ),
                    arguments: FunctionArguments {
                     arguments: [],
                     ellipsis: false,
                    },
                    definition: BinaryOperation {
                     operator: NotEqualTo,
                     operands: [
                      Variable {
                       identifier: "x",
                       position: (1077, 31),
                      },
                      String {
                       parts: [],
                       position: (1077, 36),
                      },
                     ],
                     position: (1077, 33),
                    },
                    position: (1077, 28),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "map",
                     position: (1077, 41),
                    },
                    arguments: [
                     Function {
                      argument: Some(
                       "f",
                      ),
                      arguments: FunctionArguments {
                       arguments: [],
                       ellipsis: false,
                      },
                      definition: LetIn {
                       bindings: [
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "val",
                            position: (1078, 15),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "getAttrFromPath",
                           position: (1078, 21),
                          },
                          arguments: [
                           Variable {
                            identifier: "f",
                            position: (1078, 37),
                           },
                           Variable {
                            identifier: "config",
                            position: (1078, 39),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "opt",
                            position: (1079, 15),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "getAttrFromPath",
                           position: (1079, 21),
                          },
                          arguments: [
                           Variable {
                            identifier: "f",
                            position: (1079, 37),
                           },
                           Variable {
                            identifier: "options",
                            position: (1079, 39),
                           },
                          ],
                         },
                        ),
                       ],
                       target: FunctionApplication {
                        function: Variable {
                         identifier: "optionalString",
                         position: (1081, 11),
                        },
                        arguments: [
                         BinaryOperation {
                          operator: NotEqualTo,
                          operands: [
                           Variable {
                            identifier: "val",
                            position: (1082, 14),
                           },
                           String {
                            parts: [
                             Raw {
                              content: "_mkMergedOptionModule",
                             },
                            ],
                            position: (1082, 21),
                           },
                          ],
                          position: (1082, 18),
                         },
                         String {
                          parts: [
                           Raw {
                            content: "The option `",
                           },
                           Expression {
                            expression: FunctionApplication {
                             function: Variable {
                              identifier: "showOption",
                              position: (1083, 28),
                             },
                             arguments: [
                              Variable {
                               identifier: "f",
                               position: (1083, 39),
                              },
                             ],
                            },
                           },
                           Raw {
                            content: "' defined in ",
                           },
                           Expression {
                            expression: FunctionApplication {
                             function: Variable {
                              identifier: "showFiles",
                              position: (1083, 56),
                             },
                             arguments: [
                              PropertyAccess {
                               expression: Variable {
                                identifier: "opt",
                                position: (1083, 66),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "files",
                                  position: (1083, 70),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ],
                            },
                           },
                           Raw {
                            content: " has been changed to `",
                           },
                           Expression {
                            expression: FunctionApplication {
                             function: Variable {
                              identifier: "showOption",
                              position: (1083, 100),
                             },
                             arguments: [
                              Variable {
                               identifier: "to",
                               position: (1083, 111),
                              },
                             ],
                            },
                           },
                           Raw {
                            content: "' that has a different type. Please read `",
                           },
                           Expression {
                            expression: FunctionApplication {
                             function: Variable {
                              identifier: "showOption",
                              position: (1083, 158),
                             },
                             arguments: [
                              Variable {
                               identifier: "to",
                               position: (1083, 169),
                              },
                             ],
                            },
                           },
                           Raw {
                            content: "' documentation and update your configuration accordingly.",
                           },
                          ],
                          position: (1083, 13),
                         },
                        ],
                       },
                       position: (1078, 11),
                      },
                      position: (1077, 46),
                     },
                     Variable {
                      identifier: "from",
                      position: (1084, 11),
                     },
                    ],
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (1076, 16),
              },
              FunctionApplication {
               function: Variable {
                identifier: "setAttrByPath",
                position: (1085, 12),
               },
               arguments: [
                Variable {
                 identifier: "to",
                 position: (1085, 26),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkMerge",
                  position: (1085, 30),
                 },
                 arguments: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "optional",
                    position: (1086, 15),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "any",
                      position: (1087, 17),
                     },
                     arguments: [
                      Function {
                       argument: Some(
                        "f",
                       ),
                       arguments: FunctionArguments {
                        arguments: [],
                        ellipsis: false,
                       },
                       definition: BinaryOperation {
                        operator: NotEqualTo,
                        operands: [
                         FunctionApplication {
                          function: Variable {
                           identifier: "getAttrFromPath",
                           position: (1087, 26),
                          },
                          arguments: [
                           Variable {
                            identifier: "f",
                            position: (1087, 42),
                           },
                           Variable {
                            identifier: "config",
                            position: (1087, 44),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "_mkMergedOptionModule",
                           },
                          ],
                          position: (1087, 55),
                         },
                        ],
                        position: (1087, 52),
                       },
                       position: (1087, 22),
                      },
                      Variable {
                       identifier: "from",
                       position: (1087, 80),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "mergeFn",
                      position: (1088, 17),
                     },
                     arguments: [
                      Variable {
                       identifier: "config",
                       position: (1088, 25),
                      },
                     ],
                    },
                   ],
                  },
                 ],
                },
               ],
              },
             ],
             position: (1085, 9),
            },
           ),
          ],
          recursive: false,
          position: (1069, 5),
         },
         position: (1068, 5),
        },
        position: (1067, 36),
       },
       position: (1067, 32),
      },
      position: (1067, 26),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkChangedOptionModule",
        position: (1114, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "from",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "to",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "changeFn",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: FunctionApplication {
         function: Variable {
          identifier: "mkMergedOptionModule",
          position: (1115, 5),
         },
         arguments: [
          List {
           elements: [
            Variable {
             identifier: "from",
             position: (1115, 28),
            },
           ],
           position: (1115, 26),
          },
          Variable {
           identifier: "to",
           position: (1115, 35),
          },
          Variable {
           identifier: "changeFn",
           position: (1115, 38),
          },
         ],
        },
        position: (1114, 37),
       },
       position: (1114, 33),
      },
      position: (1114, 27),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkAliasOptionModule",
        position: (1118, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "from",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "to",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "doRename",
         position: (1118, 35),
        },
        arguments: [
         Map {
          bindings: [
           Inherit(
            None,
            [
             Raw {
              content: "from",
              position: (1119, 13),
             },
             Raw {
              content: "to",
              position: (1119, 18),
             },
            ],
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "visible",
               position: (1120, 5),
              },
             ],
            },
            Variable {
             identifier: "true",
             position: (1120, 15),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "warn",
               position: (1121, 5),
              },
             ],
            },
            Variable {
             identifier: "false",
             position: (1121, 12),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "use",
               position: (1122, 5),
              },
             ],
            },
            Variable {
             identifier: "id",
             position: (1122, 11),
            },
           ),
          ],
          recursive: false,
          position: (1118, 44),
         },
        ],
       },
       position: (1118, 31),
      },
      position: (1118, 25),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkDerivedConfig",
        position: (1140, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "opt",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "f",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "mkOverride",
         position: (1141, 5),
        },
        arguments: [
         PropertyAccess {
          expression: Variable {
           identifier: "opt",
           position: (1142, 8),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "highestPrio",
             position: (1142, 12),
            },
           ],
          },
          default: Some(
           Variable {
            identifier: "defaultPriority",
            position: (1142, 27),
           },
          ),
         },
         FunctionApplication {
          function: Variable {
           identifier: "f",
           position: (1143, 8),
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "opt",
             position: (1143, 10),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "value",
               position: (1143, 14),
              },
             ],
            },
            default: None,
           },
          ],
         },
        ],
       },
       position: (1140, 26),
      },
      position: (1140, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "doRename",
        position: (1145, 3),
       },
      ],
     },
     Function {
      argument: None,
      arguments: FunctionArguments {
       arguments: [
        FunctionArgument {
         identifier: "withPriority",
         default: Some(
          Variable {
           identifier: "true",
           position: (1145, 61),
          },
         ),
        },
        FunctionArgument {
         identifier: "use",
         default: None,
        },
        FunctionArgument {
         identifier: "warn",
         default: None,
        },
        FunctionArgument {
         identifier: "visible",
         default: None,
        },
        FunctionArgument {
         identifier: "to",
         default: None,
        },
        FunctionArgument {
         identifier: "from",
         default: None,
        },
       ],
       ellipsis: false,
      },
      definition: Function {
       argument: None,
       arguments: FunctionArguments {
        arguments: [
         FunctionArgument {
          identifier: "options",
          default: None,
         },
         FunctionArgument {
          identifier: "config",
          default: None,
         },
        ],
        ellipsis: true,
       },
       definition: LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "fromOpt",
             position: (1148, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "getAttrFromPath",
            position: (1148, 17),
           },
           arguments: [
            Variable {
             identifier: "from",
             position: (1148, 33),
            },
            Variable {
             identifier: "options",
             position: (1148, 38),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "toOf",
             position: (1149, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "attrByPath",
            position: (1149, 14),
           },
           arguments: [
            Variable {
             identifier: "to",
             position: (1149, 25),
            },
            FunctionApplication {
             function: Variable {
              identifier: "abort",
              position: (1150, 10),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "Renaming error: option `",
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "showOption",
                   position: (1150, 43),
                  },
                  arguments: [
                   Variable {
                    identifier: "to",
                    position: (1150, 54),
                   },
                  ],
                 },
                },
                Raw {
                 content: "' does not exist.",
                },
               ],
               position: (1150, 16),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "toType",
             position: (1151, 7),
            },
           ],
          },
          LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "opt",
                position: (1151, 20),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "attrByPath",
               position: (1151, 26),
              },
              arguments: [
               Variable {
                identifier: "to",
                position: (1151, 37),
               },
               Map {
                bindings: [],
                recursive: false,
                position: (1151, 40),
               },
               Variable {
                identifier: "options",
                position: (1151, 43),
               },
              ],
             },
            ),
           ],
           target: PropertyAccess {
            expression: Variable {
             identifier: "opt",
             position: (1151, 55),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "type",
               position: (1151, 59),
              },
             ],
            },
            default: Some(
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (1151, 68),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "submodule",
                  position: (1151, 74),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Map {
                bindings: [],
                recursive: false,
                position: (1151, 84),
               },
              ],
             },
            ),
           },
           position: (1151, 16),
          },
         ),
        ],
        target: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "options",
              position: (1154, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "setAttrByPath",
             position: (1154, 17),
            },
            arguments: [
             Variable {
              identifier: "from",
              position: (1154, 31),
             },
             BinaryOperation {
              operator: Update,
              operands: [
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (1154, 37),
                },
                arguments: [
                 Map {
                  bindings: [
                   Inherit(
                    None,
                    [
                     Raw {
                      content: "visible",
                      position: (1155, 17),
                     },
                    ],
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (1156, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Alias of <option>",
                      },
                      Expression {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "showOption",
                         position: (1156, 43),
                        },
                        arguments: [
                         Variable {
                          identifier: "to",
                          position: (1156, 54),
                         },
                        ],
                       },
                      },
                      Raw {
                       content: "</option>.",
                      },
                     ],
                     position: (1156, 23),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "apply",
                       position: (1157, 9),
                      },
                     ],
                    },
                    Function {
                     argument: Some(
                      "x",
                     ),
                     arguments: FunctionArguments {
                      arguments: [],
                      ellipsis: false,
                     },
                     definition: FunctionApplication {
                      function: Variable {
                       identifier: "use",
                       position: (1157, 20),
                      },
                      arguments: [
                       FunctionApplication {
                        function: Variable {
                         identifier: "toOf",
                         position: (1157, 25),
                        },
                        arguments: [
                         Variable {
                          identifier: "config",
                          position: (1157, 30),
                         },
                        ],
                       },
                      ],
                     },
                     position: (1157, 17),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (1154, 46),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "optionalAttrs",
                 position: (1158, 12),
                },
                arguments: [
                 BinaryOperation {
                  operator: NotEqualTo,
                  operands: [
                   Variable {
                    identifier: "toType",
                    position: (1158, 27),
                   },
                   Variable {
                    identifier: "null",
                    position: (1158, 37),
                   },
                  ],
                  position: (1158, 34),
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (1159, 9),
                      },
                     ],
                    },
                    Variable {
                     identifier: "toType",
                     position: (1159, 16),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (1158, 43),
                 },
                ],
               },
              ],
              position: (1158, 9),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "config",
              position: (1161, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkMerge",
             position: (1161, 16),
            },
            arguments: [
             List {
              elements: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "warnings",
                     position: (1163, 11),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "optional",
                    position: (1163, 22),
                   },
                   arguments: [
                    BinaryOperation {
                     operator: LogicalAnd,
                     operands: [
                      Variable {
                       identifier: "warn",
                       position: (1163, 32),
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "fromOpt",
                        position: (1163, 40),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "isDefined",
                          position: (1163, 48),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                     position: (1163, 37),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "The option `",
                      },
                      Expression {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "showOption",
                         position: (1164, 28),
                        },
                        arguments: [
                         Variable {
                          identifier: "from",
                          position: (1164, 39),
                         },
                        ],
                       },
                      },
                      Raw {
                       content: "' defined in ",
                      },
                      Expression {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "showFiles",
                         position: (1164, 59),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "fromOpt",
                           position: (1164, 69),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "files",
                             position: (1164, 77),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                      },
                      Raw {
                       content: " has been renamed to `",
                      },
                      Expression {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "showOption",
                         position: (1164, 107),
                        },
                        arguments: [
                         Variable {
                          identifier: "to",
                          position: (1164, 118),
                         },
                        ],
                       },
                      },
                      Raw {
                       content: "'.",
                      },
                     ],
                     position: (1164, 13),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (1162, 9),
               },
               IfThenElse {
                predicate: Variable {
                 identifier: "withPriority",
                 position: (1166, 13),
                },
                then: FunctionApplication {
                 function: Variable {
                  identifier: "mkAliasAndWrapDefsWithPriority",
                  position: (1167, 16),
                 },
                 arguments: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "setAttrByPath",
                    position: (1167, 48),
                   },
                   arguments: [
                    Variable {
                     identifier: "to",
                     position: (1167, 62),
                    },
                   ],
                  },
                  Variable {
                   identifier: "fromOpt",
                   position: (1167, 66),
                  },
                 ],
                },
                else_: FunctionApplication {
                 function: Variable {
                  identifier: "mkAliasAndWrapDefinitions",
                  position: (1168, 16),
                 },
                 arguments: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "setAttrByPath",
                    position: (1168, 43),
                   },
                   arguments: [
                    Variable {
                     identifier: "to",
                     position: (1168, 57),
                    },
                   ],
                  },
                  Variable {
                   identifier: "fromOpt",
                   position: (1168, 61),
                  },
                 ],
                },
                position: (1166, 10),
               },
              ],
              position: (1161, 24),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (1153, 5),
        },
        position: (1147, 5),
       },
       position: (1146, 5),
      },
      position: (1145, 14),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "importJSON",
        position: (1176, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "file",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "_file",
            position: (1177, 5),
           },
          ],
         },
         Variable {
          identifier: "file",
          position: (1177, 13),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "config",
            position: (1178, 5),
           },
          ],
         },
         FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (1178, 14),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "importJSON",
              position: (1178, 18),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Variable {
            identifier: "file",
            position: (1178, 29),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (1176, 22),
      },
      position: (1176, 16),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "importTOML",
        position: (1185, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "file",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "_file",
            position: (1186, 5),
           },
          ],
         },
         Variable {
          identifier: "file",
          position: (1186, 13),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "config",
            position: (1187, 5),
           },
          ],
         },
         FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (1187, 14),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "importTOML",
              position: (1187, 18),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Variable {
            identifier: "file",
            position: (1187, 29),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (1185, 22),
      },
      position: (1185, 16),
     },
    ),
   ],
   recursive: true,
   position: (67, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}