---
Function {
 argument: Destructured {
  identifier: None,
  arguments: [
   DestructuredArgument {
    identifier: "lib",
    default: None,
   },
  ],
  ellipsis: false,
 },
 definition: LetIn {
  bindings: [
   Inherit {
    from: Some(
     Variable {
      identifier: "lib",
      position: (4, 12),
     },
    ),
    attributes: [
     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 {
    from: Some(
     PropertyAccess {
      expression: Variable {
       identifier: "lib",
       position: (42, 12),
      },
      attribute_path: AttributePath {
       parts: [
        Raw {
         content: "options",
         position: (42, 16),
        },
       ],
      },
      default: None,
     },
    ),
    attributes: [
     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),
     },
    ],
   },
   Binding {
    from: AttributePath {
     parts: [
      Raw {
       content: "showDeclPrefix",
       position: (52, 3),
      },
     ],
    },
    to: Function {
     argument: Simple {
      identifier: "loc",
     },
     definition: Function {
      argument: Simple {
       identifier: "decl",
      },
      definition: Function {
       argument: Simple {
        identifier: "prefix",
       },
       definition: String {
        parts: [
         Raw {
          content: " - option(s) with prefix `",
          position: (53, 6),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "showOption",
            position: (53, 34),
           },
           arguments: [
            Parentheses {
             expression: BinaryOperation {
              operator: Concatenation,
              operands: [
               Variable {
                identifier: "loc",
                position: (53, 46),
               },
               List {
                elements: [
                 Variable {
                  identifier: "prefix",
                  position: (53, 54),
                 },
                ],
                position: (53, 53),
               },
              ],
              position: (53, 50),
             },
             position: (53, 45),
            },
           ],
          },
         },
         Raw {
          content: "' in module `",
          position: (53, 63),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "decl",
            position: (53, 78),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "_file",
              position: (53, 83),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "'",
          position: (53, 89),
         },
        ],
        position: (53, 5),
       },
       position: (52, 31),
      },
      position: (52, 25),
     },
     position: (52, 20),
    },
   },
   Binding {
    from: AttributePath {
     parts: [
      Raw {
       content: "showRawDecls",
       position: (54, 3),
      },
     ],
    },
    to: Function {
     argument: Simple {
      identifier: "loc",
     },
     definition: Function {
      argument: Simple {
       identifier: "decls",
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "concatStringsSep",
        position: (55, 5),
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "\n",
           position: (55, 23),
          },
         ],
         position: (55, 22),
        },
        Parentheses {
         expression: FunctionApplication {
          function: Variable {
           identifier: "sort",
           position: (56, 8),
          },
          arguments: [
           Parentheses {
            expression: Function {
             argument: Simple {
              identifier: "a",
             },
             definition: Function {
              argument: Simple {
               identifier: "b",
              },
              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),
            },
            position: (56, 13),
           },
           Parentheses {
            expression: FunctionApplication {
             function: Variable {
              identifier: "concatMap",
              position: (57, 10),
             },
             arguments: [
              Parentheses {
               expression: Function {
                argument: Simple {
                 identifier: "decl",
                },
                definition: FunctionApplication {
                 function: Variable {
                  identifier: "map",
                  position: (58, 18),
                 },
                 arguments: [
                  Parentheses {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "showDeclPrefix",
                     position: (59, 14),
                    },
                    arguments: [
                     Variable {
                      identifier: "loc",
                      position: (59, 29),
                     },
                     Variable {
                      identifier: "decl",
                      position: (59, 33),
                     },
                    ],
                   },
                   position: (59, 13),
                  },
                  Parentheses {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "attrNames",
                     position: (60, 14),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "decl",
                       position: (60, 24),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "options",
                         position: (60, 29),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                   position: (60, 13),
                  },
                 ],
                },
                position: (58, 12),
               },
               position: (58, 11),
              },
              Variable {
               identifier: "decls",
               position: (62, 11),
              },
             ],
            },
            position: (57, 9),
           },
          ],
         },
         position: (56, 7),
        },
       ],
      },
      position: (54, 23),
     },
     position: (54, 18),
    },
   },
  ],
  target: Map {
   bindings: [
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "evalModules",
        position: (104, 3),
       },
      ],
     },
     to: Function {
      argument: Destructured {
       identifier: LeftAt(
        "evalModulesArgs",
       ),
       arguments: [
        DestructuredArgument {
         identifier: "modules",
         default: None,
        },
        DestructuredArgument {
         identifier: "prefix",
         default: Some(
          List {
           elements: [],
           position: (106, 28),
          },
         ),
        },
        DestructuredArgument {
         identifier: "specialArgs",
         default: Some(
          Map {
           bindings: [],
           recursive: false,
           position: (111, 33),
          },
         ),
        },
        DestructuredArgument {
         identifier: "args",
         default: Some(
          Map {
           bindings: [],
           recursive: false,
           position: (113, 26),
          },
         ),
        },
        DestructuredArgument {
         identifier: "check",
         default: Some(
          Variable {
           identifier: "true",
           position: (115, 27),
          },
         ),
        },
       ],
       ellipsis: false,
      },
      definition: LetIn {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "withWarnings",
            position: (118, 7),
           },
          ],
         },
         to: Function {
          argument: Simple {
           identifier: "x",
          },
          definition: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (119, 9),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "warnIf",
               position: (119, 13),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Parentheses {
             expression: HasProperty {
              expression: Variable {
               identifier: "evalModulesArgs",
               position: (119, 21),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "args",
                 position: (119, 37),
                },
               ],
              },
              position: (119, 36),
             },
             position: (119, 20),
            },
            String {
             parts: [
              Raw {
               content: "The args argument to evalModules is deprecated. Please set config._module.args instead.",
               position: (119, 44),
              },
             ],
             position: (119, 43),
            },
            PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (120, 9),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "warnIf",
                position: (120, 13),
               },
              ],
             },
             default: None,
            },
            Parentheses {
             expression: HasProperty {
              expression: Variable {
               identifier: "evalModulesArgs",
               position: (120, 21),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "check",
                 position: (120, 37),
                },
               ],
              },
              position: (120, 36),
             },
             position: (120, 20),
            },
            String {
             parts: [
              Raw {
               content: "The check argument to evalModules is deprecated. Please set config._module.check instead.",
               position: (120, 45),
              },
             ],
             position: (120, 44),
            },
            Variable {
             identifier: "x",
             position: (121, 9),
            },
           ],
          },
          position: (118, 22),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "legacyModules",
            position: (123, 7),
           },
          ],
         },
         to: BinaryOperation {
          operator: Concatenation,
          operands: [
           FunctionApplication {
            function: Variable {
             identifier: "optional",
             position: (124, 9),
            },
            arguments: [
             Parentheses {
              expression: HasProperty {
               expression: Variable {
                identifier: "evalModulesArgs",
                position: (124, 19),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "args",
                  position: (124, 35),
                 },
                ],
               },
               position: (124, 34),
              },
              position: (124, 18),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "config",
                   position: (125, 11),
                  },
                 ],
                },
                to: Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "_module",
                      position: (126, 13),
                     },
                     Raw {
                      content: "args",
                      position: (126, 21),
                     },
                    ],
                   },
                   to: 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: [
             Parentheses {
              expression: HasProperty {
               expression: Variable {
                identifier: "evalModulesArgs",
                position: (129, 22),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "check",
                  position: (129, 38),
                 },
                ],
               },
               position: (129, 37),
              },
              position: (129, 21),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "config",
                   position: (130, 11),
                  },
                 ],
                },
                to: Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "_module",
                      position: (131, 13),
                     },
                     Raw {
                      content: "check",
                      position: (131, 21),
                     },
                    ],
                   },
                   to: 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),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "regularModules",
            position: (134, 7),
           },
          ],
         },
         to: BinaryOperation {
          operator: Concatenation,
          operands: [
           Variable {
            identifier: "modules",
            position: (134, 24),
           },
           Variable {
            identifier: "legacyModules",
            position: (134, 35),
           },
          ],
          position: (134, 32),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "internalModule",
            position: (143, 7),
           },
          ],
         },
         to: Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "_file",
               position: (144, 9),
              },
             ],
            },
            to: String {
             parts: [
              Raw {
               content: "lib/modules.nix",
               position: (144, 18),
              },
             ],
             position: (144, 17),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "key",
               position: (146, 9),
              },
             ],
            },
            to: Variable {
             identifier: "_file",
             position: (146, 15),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "options",
               position: (148, 9),
              },
             ],
            },
            to: Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "_module",
                  position: (149, 11),
                 },
                 Raw {
                  content: "args",
                  position: (149, 19),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (149, 26),
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "type",
                       position: (156, 13),
                      },
                     ],
                    },
                    to: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (156, 20),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "lazyAttrsOf",
                         position: (156, 26),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (156, 38),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "raw",
                          position: (156, 44),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "internal",
                       position: (159, 13),
                      },
                     ],
                    },
                    to: BinaryOperation {
                     operator: NotEqualTo,
                     operands: [
                      Variable {
                       identifier: "prefix",
                       position: (159, 24),
                      },
                      List {
                       elements: [],
                       position: (159, 34),
                      },
                     ],
                     position: (159, 31),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (163, 13),
                      },
                     ],
                    },
                    to: 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: (164, 1),
                      },
                     ],
                     position: (163, 27),
                    },
                   },
                  ],
                  recursive: false,
                  position: (149, 35),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "_module",
                  position: (244, 11),
                 },
                 Raw {
                  content: "check",
                  position: (244, 19),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (244, 27),
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "type",
                       position: (245, 13),
                      },
                     ],
                    },
                    to: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (245, 20),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "bool",
                        position: (245, 26),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "internal",
                       position: (246, 13),
                      },
                     ],
                    },
                    to: Variable {
                     identifier: "true",
                     position: (246, 24),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "default",
                       position: (247, 13),
                      },
                     ],
                    },
                    to: Variable {
                     identifier: "true",
                     position: (247, 23),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (248, 13),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "Whether to check whether all option definitions have matching declarations.",
                       position: (248, 28),
                      },
                     ],
                     position: (248, 27),
                    },
                   },
                  ],
                  recursive: false,
                  position: (244, 36),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "_module",
                  position: (251, 11),
                 },
                 Raw {
                  content: "freeformType",
                  position: (251, 19),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (251, 34),
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "type",
                       position: (252, 13),
                      },
                     ],
                    },
                    to: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (252, 20),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "nullOr",
                         position: (252, 26),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (252, 33),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "optionType",
                          position: (252, 39),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "internal",
                       position: (253, 13),
                      },
                     ],
                    },
                    to: Variable {
                     identifier: "true",
                     position: (253, 24),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "default",
                       position: (254, 13),
                      },
                     ],
                    },
                    to: Variable {
                     identifier: "null",
                     position: (254, 23),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (255, 13),
                      },
                     ],
                    },
                    to: 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: (256, 1),
                      },
                     ],
                     position: (255, 27),
                    },
                   },
                  ],
                  recursive: false,
                  position: (251, 43),
                 },
                ],
               },
              },
             ],
             recursive: false,
             position: (148, 19),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "config",
               position: (268, 9),
              },
             ],
            },
            to: Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "_module",
                  position: (269, 11),
                 },
                 Raw {
                  content: "args",
                  position: (269, 19),
                 },
                ],
               },
               to: Map {
                bindings: [
                 Inherit {
                  from: None,
                  attributes: [
                   Raw {
                    content: "extendModules",
                    position: (270, 21),
                   },
                  ],
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "moduleType",
                     position: (271, 13),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "type",
                   position: (271, 26),
                  },
                 },
                ],
                recursive: false,
                position: (269, 26),
               },
              },
             ],
             recursive: false,
             position: (268, 18),
            },
           },
          ],
          recursive: true,
          position: (143, 24),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "merged",
            position: (276, 7),
           },
          ],
         },
         to: LetIn {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "collected",
               position: (277, 13),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "collectModules",
              position: (277, 25),
             },
             arguments: [
              Parentheses {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "specialArgs",
                 position: (278, 12),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "modulesPath",
                   position: (278, 24),
                  },
                 ],
                },
                default: Some(
                 String {
                  parts: [],
                  position: (278, 39),
                 },
                ),
               },
               position: (278, 11),
              },
              Parentheses {
               expression: BinaryOperation {
                operator: Concatenation,
                operands: [
                 Variable {
                  identifier: "regularModules",
                  position: (279, 12),
                 },
                 List {
                  elements: [
                   Variable {
                    identifier: "internalModule",
                    position: (279, 32),
                   },
                  ],
                  position: (279, 30),
                 },
                ],
                position: (279, 27),
               },
               position: (279, 11),
              },
              Parentheses {
               expression: BinaryOperation {
                operator: Update,
                operands: [
                 Map {
                  bindings: [
                   Inherit {
                    from: None,
                    attributes: [
                     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),
               },
               position: (280, 11),
              },
             ],
            },
           },
          ],
          target: FunctionApplication {
           function: Variable {
            identifier: "mergeModules",
            position: (281, 12),
           },
           arguments: [
            Variable {
             identifier: "prefix",
             position: (281, 25),
            },
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "reverseList",
               position: (281, 33),
              },
              arguments: [
               Variable {
                identifier: "collected",
                position: (281, 45),
               },
              ],
             },
             position: (281, 32),
            },
           ],
          },
          position: (277, 9),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "options",
            position: (283, 7),
           },
          ],
         },
         to: PropertyAccess {
          expression: Variable {
           identifier: "merged",
           position: (283, 17),
          },
          attribute_path: AttributePath {
           parts: [
            Raw {
             content: "matchedOptions",
             position: (283, 24),
            },
           ],
          },
          default: None,
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "config",
            position: (285, 7),
           },
          ],
         },
         to: LetIn {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "declaredConfig",
               position: (289, 11),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mapAttrsRecursiveCond",
              position: (289, 28),
             },
             arguments: [
              Parentheses {
               expression: Function {
                argument: Simple {
                 identifier: "v",
                },
                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),
               },
               position: (289, 50),
              },
              Parentheses {
               expression: Function {
                argument: Simple {
                 identifier: "_",
                },
                definition: Function {
                 argument: Simple {
                  identifier: "v",
                 },
                 definition: PropertyAccess {
                  expression: Variable {
                   identifier: "v",
                   position: (289, 75),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "value",
                     position: (289, 77),
                    },
                   ],
                  },
                  default: None,
                 },
                 position: (289, 72),
                },
                position: (289, 69),
               },
               position: (289, 68),
              },
              Variable {
               identifier: "options",
               position: (289, 84),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "freeformConfig",
               position: (292, 11),
              },
             ],
            },
            to: LetIn {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "defs",
                  position: (294, 15),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "map",
                 position: (294, 22),
                },
                arguments: [
                 Parentheses {
                  expression: Function {
                   argument: Simple {
                    identifier: "def",
                   },
                   definition: Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "file",
                         position: (295, 17),
                        },
                       ],
                      },
                      to: PropertyAccess {
                       expression: Variable {
                        identifier: "def",
                        position: (295, 24),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "file",
                          position: (295, 28),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "value",
                         position: (296, 17),
                        },
                       ],
                      },
                      to: FunctionApplication {
                       function: Variable {
                        identifier: "setAttrByPath",
                        position: (296, 25),
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "def",
                          position: (296, 39),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           Raw {
                            content: "prefix",
                            position: (296, 43),
                           },
                          ],
                         },
                         default: None,
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "def",
                          position: (296, 50),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           Raw {
                            content: "value",
                            position: (296, 54),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                     },
                    ],
                    recursive: false,
                    position: (294, 32),
                   },
                   position: (294, 27),
                  },
                  position: (294, 26),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "merged",
                   position: (297, 18),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    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 {
                 parts: [
                  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 {
               parts: [
                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),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "checkUnmatched",
            position: (307, 7),
           },
          ],
         },
         to: IfThenElse {
          predicate: BinaryOperation {
           operator: LogicalAnd,
           operands: [
            BinaryOperation {
             operator: LogicalAnd,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (308, 12),
               },
               attribute_path: AttributePath {
                parts: [
                 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 {
                  parts: [
                   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 {
                parts: [
                 Raw {
                  content: "unmatchedDefns",
                  position: (308, 82),
                 },
                ],
               },
               default: None,
              },
              List {
               elements: [],
               position: (308, 100),
              },
             ],
             position: (308, 97),
            },
           ],
           position: (308, 72),
          },
          then: LetIn {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "firstDef",
                position: (310, 13),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "head",
               position: (310, 24),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "merged",
                 position: (310, 29),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "unmatchedDefns",
                   position: (310, 36),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "baseMsg",
                position: (311, 13),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "The option `",
                position: (311, 24),
               },
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "showOption",
                  position: (311, 38),
                 },
                 arguments: [
                  Parentheses {
                   expression: BinaryOperation {
                    operator: Concatenation,
                    operands: [
                     Variable {
                      identifier: "prefix",
                      position: (311, 50),
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "firstDef",
                       position: (311, 60),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "prefix",
                         position: (311, 69),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                    position: (311, 57),
                   },
                   position: (311, 49),
                  },
                 ],
                },
               },
               Raw {
                content: "' does not exist. Definition values:",
                position: (311, 77),
               },
               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, 40),
                  },
                 ],
                 position: (313, 39),
                },
               ],
               position: (313, 37),
              },
             ],
             position: (313, 34),
            },
            then: LetIn {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "optionName",
                  position: (316, 19),
                 },
                ],
               },
               to: 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: "",
                   position: (320, 1),
                  },
                  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: (320, 33),
                  },
                 ],
                 position: (319, 32),
                },
               ],
              },
              else_: FunctionApplication {
               function: Variable {
                identifier: "throw",
                position: (325, 21),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "",
                   position: (326, 1),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "baseMsg",
                    position: (326, 25),
                   },
                  },
                  Raw {
                   content: "\n\nHowever there are no options defined in `",
                   position: (326, 33),
                  },
                  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: (328, 84),
                  },
                 ],
                 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),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "checked",
            position: (335, 7),
           },
          ],
         },
         to: FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "builtins",
            position: (335, 17),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "seq",
              position: (335, 26),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Variable {
            identifier: "checkUnmatched",
            position: (335, 30),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "extendModules",
            position: (337, 7),
           },
          ],
         },
         to: Function {
          argument: Destructured {
           identifier: LeftAt(
            "extendArgs",
           ),
           arguments: [
            DestructuredArgument {
             identifier: "modules",
             default: Some(
              List {
               elements: [],
               position: (338, 19),
              },
             ),
            },
            DestructuredArgument {
             identifier: "specialArgs",
             default: Some(
              Map {
               bindings: [],
               recursive: false,
               position: (339, 23),
              },
             ),
            },
            DestructuredArgument {
             identifier: "prefix",
             default: Some(
              List {
               elements: [],
               position: (340, 18),
              },
             ),
            },
           ],
           ellipsis: false,
          },
          definition: FunctionApplication {
           function: Variable {
            identifier: "evalModules",
            position: (342, 11),
           },
           arguments: [
            Parentheses {
             expression: BinaryOperation {
              operator: Update,
              operands: [
               Variable {
                identifier: "evalModulesArgs",
                position: (342, 24),
               },
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "modules",
                     position: (343, 13),
                    },
                   ],
                  },
                  to: BinaryOperation {
                   operator: Concatenation,
                   operands: [
                    Variable {
                     identifier: "regularModules",
                     position: (343, 23),
                    },
                    Variable {
                     identifier: "modules",
                     position: (343, 41),
                    },
                   ],
                   position: (343, 38),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "specialArgs",
                     position: (344, 13),
                    },
                   ],
                  },
                  to: BinaryOperation {
                   operator: Update,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "evalModulesArgs",
                      position: (344, 27),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "specialArgs",
                        position: (344, 43),
                       },
                      ],
                     },
                     default: Some(
                      Map {
                       bindings: [],
                       recursive: false,
                       position: (344, 58),
                      },
                     ),
                    },
                    Variable {
                     identifier: "specialArgs",
                     position: (344, 64),
                    },
                   ],
                   position: (344, 61),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "prefix",
                     position: (345, 13),
                    },
                   ],
                  },
                  to: PropertyAccess {
                   expression: Variable {
                    identifier: "extendArgs",
                    position: (345, 22),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "prefix",
                      position: (345, 33),
                     },
                    ],
                   },
                   default: Some(
                    PropertyAccess {
                     expression: Variable {
                      identifier: "evalModulesArgs",
                      position: (345, 43),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "prefix",
                        position: (345, 59),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  },
                 },
                ],
                recursive: false,
                position: (342, 43),
               },
              ],
              position: (342, 40),
             },
             position: (342, 23),
            },
           ],
          },
          position: (337, 23),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "type",
            position: (348, 7),
           },
          ],
         },
         to: FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (348, 14),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "types",
              position: (348, 18),
             },
             Raw {
              content: "submoduleWith",
              position: (348, 24),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Map {
            bindings: [
             Inherit {
              from: None,
              attributes: [
               Raw {
                content: "modules",
                position: (349, 17),
               },
               Raw {
                content: "specialArgs",
                position: (349, 25),
               },
              ],
             },
            ],
            recursive: false,
            position: (348, 38),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "result",
            position: (352, 7),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "withWarnings",
           position: (352, 16),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "options",
                 position: (353, 9),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "checked",
                position: (353, 19),
               },
               arguments: [
                Variable {
                 identifier: "options",
                 position: (353, 27),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "config",
                 position: (354, 9),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "checked",
                position: (354, 18),
               },
               arguments: [
                Parentheses {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "removeAttrs",
                   position: (354, 27),
                  },
                  arguments: [
                   Variable {
                    identifier: "config",
                    position: (354, 39),
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "_module",
                        position: (354, 49),
                       },
                      ],
                      position: (354, 48),
                     },
                    ],
                    position: (354, 46),
                   },
                  ],
                 },
                 position: (354, 26),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "_module",
                 position: (355, 9),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "checked",
                position: (355, 19),
               },
               arguments: [
                Parentheses {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (355, 28),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "_module",
                     position: (355, 35),
                    },
                   ],
                  },
                  default: None,
                 },
                 position: (355, 27),
                },
               ],
              },
             },
             Inherit {
              from: None,
              attributes: [
               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),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "collectModules",
        position: (364, 3),
       },
      ],
     },
     to: LetIn {
      bindings: [
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "loadModule",
           position: (367, 7),
          },
         ],
        },
        to: Function {
         argument: Simple {
          identifier: "args",
         },
         definition: Function {
          argument: Simple {
           identifier: "fallbackFile",
          },
          definition: Function {
           argument: Simple {
            identifier: "fallbackKey",
           },
           definition: Function {
            argument: Simple {
             identifier: "m",
            },
            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),
               },
               Parentheses {
                expression: 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),
                  },
                 ],
                },
                position: (369, 54),
               },
              ],
             },
             else_: IfThenElse {
              predicate: FunctionApplication {
               function: Variable {
                identifier: "isList",
                position: (370, 17),
               },
               arguments: [
                Variable {
                 identifier: "m",
                 position: (370, 24),
                },
               ],
              },
              then: LetIn {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "defs",
                    position: (371, 15),
                   },
                  ],
                 },
                 to: List {
                  elements: [
                   Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "file",
                         position: (371, 25),
                        },
                       ],
                      },
                      to: Variable {
                       identifier: "fallbackFile",
                       position: (371, 32),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "value",
                         position: (371, 46),
                        },
                       ],
                      },
                      to: 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: ",
                    position: (372, 18),
                   },
                   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: [
                Parentheses {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "toString",
                   position: (373, 33),
                  },
                  arguments: [
                   Variable {
                    identifier: "m",
                    position: (373, 42),
                   },
                  ],
                 },
                 position: (373, 32),
                },
                Parentheses {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "toString",
                   position: (373, 46),
                  },
                  arguments: [
                   Variable {
                    identifier: "m",
                    position: (373, 55),
                   },
                  ],
                 },
                 position: (373, 45),
                },
                Parentheses {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "applyModuleArgsIfFunction",
                   position: (373, 59),
                  },
                  arguments: [
                   Parentheses {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "toString",
                      position: (373, 86),
                     },
                     arguments: [
                      Variable {
                       identifier: "m",
                       position: (373, 95),
                      },
                     ],
                    },
                    position: (373, 85),
                   },
                   Parentheses {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "import",
                      position: (373, 99),
                     },
                     arguments: [
                      Variable {
                       identifier: "m",
                       position: (373, 106),
                      },
                     ],
                    },
                    position: (373, 98),
                   },
                   Variable {
                    identifier: "args",
                    position: (373, 109),
                   },
                  ],
                 },
                 position: (373, 58),
                },
               ],
              },
              position: (370, 14),
             },
             position: (368, 9),
            },
            position: (367, 53),
           },
           position: (367, 40),
          },
          position: (367, 26),
         },
         position: (367, 20),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "collectStructuredModules",
           position: (400, 7),
          },
         ],
        },
        to: LetIn {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "collectResults",
              position: (402, 11),
             },
            ],
           },
           to: Function {
            argument: Simple {
             identifier: "modules",
            },
            definition: Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "disabled",
                  position: (403, 13),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "concatLists",
                 position: (403, 24),
                },
                arguments: [
                 Parentheses {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "catAttrs",
                    position: (403, 37),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "disabled",
                       position: (403, 47),
                      },
                     ],
                     position: (403, 46),
                    },
                    Variable {
                     identifier: "modules",
                     position: (403, 57),
                    },
                   ],
                  },
                  position: (403, 36),
                 },
                ],
               },
              },
              Inherit {
               from: None,
               attributes: [
                Raw {
                 content: "modules",
                 position: (404, 21),
                },
               ],
              },
             ],
             recursive: false,
             position: (402, 37),
            },
            position: (402, 28),
           },
          },
         ],
         target: Function {
          argument: Simple {
           identifier: "parentFile",
          },
          definition: Function {
           argument: Simple {
            identifier: "parentKey",
           },
           definition: Function {
            argument: Simple {
             identifier: "initialModules",
            },
            definition: Function {
             argument: Simple {
              identifier: "args",
             },
             definition: FunctionApplication {
              function: Variable {
               identifier: "collectResults",
               position: (406, 57),
              },
              arguments: [
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "imap1",
                  position: (406, 73),
                 },
                 arguments: [
                  Parentheses {
                   expression: Function {
                    argument: Simple {
                     identifier: "n",
                    },
                    definition: Function {
                     argument: Simple {
                      identifier: "x",
                     },
                     definition: LetIn {
                      bindings: [
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "module",
                           position: (408, 13),
                          },
                         ],
                        },
                        to: 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-",
                             position: (408, 62),
                            },
                            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),
                          },
                         ],
                        },
                       },
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "collectedImports",
                           position: (409, 13),
                          },
                         ],
                        },
                        to: FunctionApplication {
                         function: Variable {
                          identifier: "collectStructuredModules",
                          position: (409, 32),
                         },
                         arguments: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "module",
                            position: (409, 57),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "_file",
                              position: (409, 64),
                             },
                            ],
                           },
                           default: None,
                          },
                          PropertyAccess {
                           expression: Variable {
                            identifier: "module",
                            position: (409, 70),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "key",
                              position: (409, 77),
                             },
                            ],
                           },
                           default: None,
                          },
                          PropertyAccess {
                           expression: Variable {
                            identifier: "module",
                            position: (409, 81),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "imports",
                              position: (409, 88),
                             },
                            ],
                           },
                           default: None,
                          },
                          Variable {
                           identifier: "args",
                           position: (409, 96),
                          },
                         ],
                        },
                       },
                      ],
                      target: Map {
                       bindings: [
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "key",
                            position: (411, 13),
                           },
                          ],
                         },
                         to: PropertyAccess {
                          expression: Variable {
                           identifier: "module",
                           position: (411, 19),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "key",
                             position: (411, 26),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "module",
                            position: (412, 13),
                           },
                          ],
                         },
                         to: Variable {
                          identifier: "module",
                          position: (412, 22),
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "modules",
                            position: (413, 13),
                           },
                          ],
                         },
                         to: PropertyAccess {
                          expression: Variable {
                           identifier: "collectedImports",
                           position: (413, 23),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "modules",
                             position: (413, 40),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "disabled",
                            position: (414, 13),
                           },
                          ],
                         },
                         to: BinaryOperation {
                          operator: Concatenation,
                          operands: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "module",
                             position: (414, 24),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "disabledModules",
                               position: (414, 31),
                              },
                             ],
                            },
                            default: None,
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "collectedImports",
                             position: (414, 50),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              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),
                   },
                   position: (406, 79),
                  },
                  Variable {
                   identifier: "initialModules",
                   position: (415, 14),
                  },
                 ],
                },
                position: (406, 72),
               },
              ],
             },
             position: (406, 51),
            },
            position: (406, 35),
           },
           position: (406, 24),
          },
          position: (406, 12),
         },
         position: (401, 9),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "filterModules",
           position: (421, 7),
          },
         ],
        },
        to: Function {
         argument: Simple {
          identifier: "modulesPath",
         },
         definition: Function {
          argument: Destructured {
           identifier: None,
           arguments: [
            DestructuredArgument {
             identifier: "disabled",
             default: None,
            },
            DestructuredArgument {
             identifier: "modules",
             default: None,
            },
           ],
           ellipsis: false,
          },
          definition: LetIn {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "moduleKey",
                position: (423, 11),
               },
              ],
             },
             to: Function {
              argument: Simple {
               identifier: "m",
              },
              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, 69),
                     },
                    ],
                    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),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "disabledKeys",
                position: (424, 11),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "map",
               position: (424, 26),
              },
              arguments: [
               Variable {
                identifier: "moduleKey",
                position: (424, 30),
               },
               Variable {
                identifier: "disabled",
                position: (424, 40),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "keyFilter",
                position: (425, 11),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "filter",
               position: (425, 23),
              },
              arguments: [
               Parentheses {
                expression: Function {
                 argument: Simple {
                  identifier: "attrs",
                 },
                 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 {
                      parts: [
                       Raw {
                        content: "key",
                        position: (425, 51),
                       },
                      ],
                     },
                     default: None,
                    },
                    Variable {
                     identifier: "disabledKeys",
                     position: (425, 55),
                    },
                   ],
                  },
                  position: (425, 38),
                 },
                 position: (425, 31),
                },
                position: (425, 30),
               },
              ],
             },
            },
           ],
           target: FunctionApplication {
            function: Variable {
             identifier: "map",
             position: (426, 12),
            },
            arguments: [
             Parentheses {
              expression: Function {
               argument: Simple {
                identifier: "attrs",
               },
               definition: PropertyAccess {
                expression: Variable {
                 identifier: "attrs",
                 position: (426, 24),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "module",
                   position: (426, 30),
                  },
                 ],
                },
                default: None,
               },
               position: (426, 17),
              },
              position: (426, 16),
             },
             Parentheses {
              expression: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "builtins",
                 position: (426, 39),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "genericClosure",
                   position: (426, 48),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "startSet",
                      position: (427, 11),
                     },
                    ],
                   },
                   to: FunctionApplication {
                    function: Variable {
                     identifier: "keyFilter",
                     position: (427, 22),
                    },
                    arguments: [
                     Variable {
                      identifier: "modules",
                      position: (427, 32),
                     },
                    ],
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "operator",
                      position: (428, 11),
                     },
                    ],
                   },
                   to: Function {
                    argument: Simple {
                     identifier: "attrs",
                    },
                    definition: FunctionApplication {
                     function: Variable {
                      identifier: "keyFilter",
                      position: (428, 29),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "attrs",
                        position: (428, 39),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "modules",
                          position: (428, 45),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                    position: (428, 22),
                   },
                  },
                 ],
                 recursive: false,
                 position: (426, 63),
                },
               ],
              },
              position: (426, 38),
             },
            ],
           },
           position: (422, 9),
          },
          position: (421, 36),
         },
         position: (421, 23),
        },
       },
      ],
      target: Function {
       argument: Simple {
        identifier: "modulesPath",
       },
       definition: Function {
        argument: Simple {
         identifier: "initialModules",
        },
        definition: Function {
         argument: Simple {
          identifier: "args",
         },
         definition: FunctionApplication {
          function: Variable {
           identifier: "filterModules",
           position: (432, 7),
          },
          arguments: [
           Variable {
            identifier: "modulesPath",
            position: (432, 21),
           },
           Parentheses {
            expression: 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: (432, 33),
           },
          ],
         },
         position: (431, 37),
        },
        position: (431, 21),
       },
       position: (431, 8),
      },
      position: (364, 20),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "setDefaultModuleLocation",
        position: (435, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "file",
      },
      definition: Function {
       argument: Simple {
        identifier: "m",
       },
       definition: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "_file",
             position: (436, 7),
            },
           ],
          },
          to: Variable {
           identifier: "file",
           position: (436, 15),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "imports",
             position: (436, 21),
            },
           ],
          },
          to: List {
           elements: [
            Variable {
             identifier: "m",
             position: (436, 33),
            },
           ],
           position: (436, 31),
          },
         },
        ],
        recursive: false,
        position: (436, 5),
       },
       position: (435, 36),
      },
      position: (435, 30),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "unifyModuleSyntax",
        position: (440, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "file",
      },
      definition: Function {
       argument: Simple {
        identifier: "key",
       },
       definition: Function {
        argument: Simple {
         identifier: "m",
        },
        definition: LetIn {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "addMeta",
              position: (442, 7),
             },
            ],
           },
           to: Function {
            argument: Simple {
             identifier: "config",
            },
            definition: IfThenElse {
             predicate: HasProperty {
              expression: Variable {
               identifier: "m",
               position: (442, 28),
              },
              attribute_path: AttributePath {
               parts: [
                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: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "meta",
                       position: (443, 33),
                      },
                     ],
                    },
                    to: PropertyAccess {
                     expression: Variable {
                      identifier: "m",
                      position: (443, 40),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       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),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "addFreeformType",
              position: (445, 7),
             },
            ],
           },
           to: Function {
            argument: Simple {
             identifier: "config",
            },
            definition: IfThenElse {
             predicate: HasProperty {
              expression: Variable {
               identifier: "m",
               position: (445, 36),
              },
              attribute_path: AttributePath {
               parts: [
                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: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "_module",
                       position: (446, 33),
                      },
                      Raw {
                       content: "freeformType",
                       position: (446, 41),
                      },
                     ],
                    },
                    to: PropertyAccess {
                     expression: Variable {
                      identifier: "m",
                      position: (446, 56),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       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 {
              parts: [
               Raw {
                content: "config",
                position: (449, 12),
               },
              ],
             },
             position: (449, 10),
            },
            HasProperty {
             expression: Variable {
              identifier: "m",
              position: (449, 22),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "options",
                position: (449, 26),
               },
              ],
             },
             position: (449, 24),
            },
           ],
           position: (449, 19),
          },
          then: LetIn {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "badAttrs",
                position: (450, 11),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "removeAttrs",
               position: (450, 22),
              },
              arguments: [
               Variable {
                identifier: "m",
                position: (450, 34),
               },
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "_file",
                    position: (450, 38),
                   },
                  ],
                  position: (450, 37),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "key",
                    position: (450, 46),
                   },
                  ],
                  position: (450, 45),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "disabledModules",
                    position: (450, 52),
                   },
                  ],
                  position: (450, 51),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "imports",
                    position: (450, 70),
                   },
                  ],
                  position: (450, 69),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "options",
                    position: (450, 80),
                   },
                  ],
                  position: (450, 79),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "config",
                    position: (450, 90),
                   },
                  ],
                  position: (450, 89),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "meta",
                    position: (450, 99),
                   },
                  ],
                  position: (450, 98),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "freeformType",
                    position: (450, 106),
                   },
                  ],
                  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 `",
                 position: (452, 16),
                },
                Expression {
                 expression: Variable {
                  identifier: "key",
                  position: (452, 26),
                 },
                },
                Raw {
                 content: "' has an unsupported attribute `",
                 position: (452, 30),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "head",
                   position: (452, 64),
                  },
                  arguments: [
                   Parentheses {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "attrNames",
                      position: (452, 70),
                     },
                     arguments: [
                      Variable {
                       identifier: "badAttrs",
                       position: (452, 80),
                      },
                     ],
                    },
                    position: (452, 69),
                   },
                  ],
                 },
                },
                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: ",
                 position: (452, 90),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "toString",
                   position: (452, 266),
                  },
                  arguments: [
                   Parentheses {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "attrNames",
                      position: (452, 276),
                     },
                     arguments: [
                      Variable {
                       identifier: "badAttrs",
                       position: (452, 286),
                      },
                     ],
                    },
                    position: (452, 275),
                   },
                  ],
                 },
                },
                Raw {
                 content: ") into the explicit `config' attribute.",
                 position: (452, 296),
                },
               ],
               position: (452, 15),
              },
             ],
            },
            else_: Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "_file",
                  position: (454, 11),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (454, 19),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "m",
                   position: (454, 28),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "_file",
                     position: (454, 30),
                    },
                   ],
                  },
                  default: Some(
                   Variable {
                    identifier: "file",
                    position: (454, 39),
                   },
                  ),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "key",
                  position: (455, 11),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (455, 17),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "m",
                   position: (455, 26),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "key",
                     position: (455, 28),
                    },
                   ],
                  },
                  default: Some(
                   Variable {
                    identifier: "key",
                    position: (455, 35),
                   },
                  ),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "disabledModules",
                  position: (456, 11),
                 },
                ],
               },
               to: PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (456, 29),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "disabledModules",
                   position: (456, 31),
                  },
                 ],
                },
                default: Some(
                 List {
                  elements: [],
                  position: (456, 50),
                 },
                ),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "imports",
                  position: (457, 11),
                 },
                ],
               },
               to: PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (457, 21),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "imports",
                   position: (457, 23),
                  },
                 ],
                },
                default: Some(
                 List {
                  elements: [],
                  position: (457, 34),
                 },
                ),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "options",
                  position: (458, 11),
                 },
                ],
               },
               to: PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (458, 21),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "options",
                   position: (458, 23),
                  },
                 ],
                },
                default: Some(
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (458, 34),
                 },
                ),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "config",
                  position: (459, 11),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "addFreeformType",
                 position: (459, 20),
                },
                arguments: [
                 Parentheses {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "addMeta",
                    position: (459, 37),
                   },
                   arguments: [
                    Parentheses {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "m",
                       position: (459, 46),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "config",
                         position: (459, 48),
                        },
                       ],
                      },
                      default: Some(
                       Map {
                        bindings: [],
                        recursive: false,
                        position: (459, 58),
                       },
                      ),
                     },
                     position: (459, 45),
                    },
                   ],
                  },
                  position: (459, 36),
                 },
                ],
               },
              },
             ],
             recursive: false,
             position: (454, 9),
            },
            position: (451, 7),
           },
           position: (450, 7),
          },
          else_: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "_file",
                position: (462, 9),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "toString",
               position: (462, 17),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (462, 26),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "_file",
                   position: (462, 28),
                  },
                 ],
                },
                default: Some(
                 Variable {
                  identifier: "file",
                  position: (462, 37),
                 },
                ),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "key",
                position: (463, 9),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "toString",
               position: (463, 15),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (463, 24),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "key",
                   position: (463, 26),
                  },
                 ],
                },
                default: Some(
                 Variable {
                  identifier: "key",
                  position: (463, 33),
                 },
                ),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "disabledModules",
                position: (464, 9),
               },
              ],
             },
             to: PropertyAccess {
              expression: Variable {
               identifier: "m",
               position: (464, 27),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "disabledModules",
                 position: (464, 29),
                },
               ],
              },
              default: Some(
               List {
                elements: [],
                position: (464, 48),
               },
              ),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "imports",
                position: (465, 9),
               },
              ],
             },
             to: BinaryOperation {
              operator: Concatenation,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (465, 19),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "require",
                   position: (465, 21),
                  },
                 ],
                },
                default: Some(
                 List {
                  elements: [],
                  position: (465, 32),
                 },
                ),
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (465, 38),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "imports",
                   position: (465, 40),
                  },
                 ],
                },
                default: Some(
                 List {
                  elements: [],
                  position: (465, 51),
                 },
                ),
               },
              ],
              position: (465, 35),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "options",
                position: (466, 9),
               },
              ],
             },
             to: Map {
              bindings: [],
              recursive: false,
              position: (466, 19),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "config",
                position: (467, 9),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "addFreeformType",
               position: (467, 18),
              },
              arguments: [
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "addMeta",
                  position: (467, 35),
                 },
                 arguments: [
                  Parentheses {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "removeAttrs",
                     position: (467, 44),
                    },
                    arguments: [
                     Variable {
                      identifier: "m",
                      position: (467, 56),
                     },
                     List {
                      elements: [
                       String {
                        parts: [
                         Raw {
                          content: "_file",
                          position: (467, 60),
                         },
                        ],
                        position: (467, 59),
                       },
                       String {
                        parts: [
                         Raw {
                          content: "key",
                          position: (467, 68),
                         },
                        ],
                        position: (467, 67),
                       },
                       String {
                        parts: [
                         Raw {
                          content: "disabledModules",
                          position: (467, 74),
                         },
                        ],
                        position: (467, 73),
                       },
                       String {
                        parts: [
                         Raw {
                          content: "require",
                          position: (467, 92),
                         },
                        ],
                        position: (467, 91),
                       },
                       String {
                        parts: [
                         Raw {
                          content: "imports",
                          position: (467, 102),
                         },
                        ],
                        position: (467, 101),
                       },
                       String {
                        parts: [
                         Raw {
                          content: "freeformType",
                          position: (467, 112),
                         },
                        ],
                        position: (467, 111),
                       },
                      ],
                      position: (467, 58),
                     },
                    ],
                   },
                   position: (467, 43),
                  },
                 ],
                },
                position: (467, 34),
               },
              ],
             },
            },
           ],
           recursive: false,
           position: (462, 7),
          },
          position: (449, 5),
         },
         position: (441, 5),
        },
        position: (440, 34),
       },
       position: (440, 29),
      },
      position: (440, 23),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "applyModuleArgsIfFunction",
        position: (470, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "key",
      },
      definition: Function {
       argument: Simple {
        identifier: "f",
       },
       definition: Function {
        argument: Destructured {
         identifier: LeftAt(
          "args",
         ),
         arguments: [
          DestructuredArgument {
           identifier: "config",
           default: None,
          },
          DestructuredArgument {
           identifier: "options",
           default: None,
          },
          DestructuredArgument {
           identifier: "lib",
           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: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "context",
               position: (484, 7),
              },
             ],
            },
            to: Function {
             argument: Simple {
              identifier: "name",
             },
             definition: String {
              parts: [
               Raw {
                content: "while evaluating the module argument `",
                position: (484, 25),
               },
               Expression {
                expression: Variable {
                 identifier: "name",
                 position: (484, 65),
                },
               },
               Raw {
                content: "' in \"",
                position: (484, 70),
               },
               Expression {
                expression: Variable {
                 identifier: "key",
                 position: (484, 78),
                },
               },
               Raw {
                content: "\":",
                position: (484, 82),
               },
              ],
              position: (484, 23),
             },
             position: (484, 17),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "extraArgs",
               position: (485, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "builtins",
               position: (485, 19),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "mapAttrs",
                 position: (485, 28),
                },
               ],
              },
              default: None,
             },
             arguments: [
              Parentheses {
               expression: Function {
                argument: Simple {
                 identifier: "name",
                },
                definition: Function {
                 argument: Simple {
                  identifier: "_",
                 },
                 definition: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "builtins",
                    position: (486, 9),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "addErrorContext",
                      position: (486, 18),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Parentheses {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "context",
                      position: (486, 35),
                     },
                     arguments: [
                      Variable {
                       identifier: "name",
                       position: (486, 43),
                      },
                     ],
                    },
                    position: (486, 34),
                   },
                   Parentheses {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "args",
                      position: (487, 12),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Expression {
                        expression: Variable {
                         identifier: "name",
                         position: (487, 19),
                        },
                       },
                      ],
                     },
                     default: Some(
                      PropertyAccess {
                       expression: Variable {
                        identifier: "config",
                        position: (487, 28),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "_module",
                          position: (487, 35),
                         },
                         Raw {
                          content: "args",
                          position: (487, 43),
                         },
                         Expression {
                          expression: Variable {
                           identifier: "name",
                           position: (487, 50),
                          },
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                    },
                    position: (487, 11),
                   },
                  ],
                 },
                 position: (485, 44),
                },
                position: (485, 38),
               },
               position: (485, 37),
              },
              Parentheses {
               expression: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "lib",
                  position: (488, 10),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "functionArgs",
                    position: (488, 14),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Variable {
                  identifier: "f",
                  position: (488, 27),
                 },
                ],
               },
               position: (488, 9),
              },
             ],
            },
           },
          ],
          target: FunctionApplication {
           function: Variable {
            identifier: "f",
            position: (494, 8),
           },
           arguments: [
            Parentheses {
             expression: BinaryOperation {
              operator: Update,
              operands: [
               Variable {
                identifier: "args",
                position: (494, 11),
               },
               Variable {
                identifier: "extraArgs",
                position: (494, 19),
               },
              ],
              position: (494, 16),
             },
             position: (494, 10),
            },
           ],
          },
          position: (471, 5),
         },
         else_: Variable {
          identifier: "f",
          position: (496, 5),
         },
         position: (470, 75),
        },
        position: (470, 39),
       },
       position: (470, 36),
      },
      position: (470, 31),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mergeModules",
        position: (519, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "prefix",
      },
      definition: Function {
       argument: Simple {
        identifier: "modules",
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "mergeModules'",
         position: (520, 5),
        },
        arguments: [
         Variable {
          identifier: "prefix",
          position: (520, 19),
         },
         Variable {
          identifier: "modules",
          position: (520, 26),
         },
         Parentheses {
          expression: FunctionApplication {
           function: Variable {
            identifier: "concatMap",
            position: (521, 8),
           },
           arguments: [
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "m",
              },
              definition: FunctionApplication {
               function: Variable {
                identifier: "map",
                position: (521, 22),
               },
               arguments: [
                Parentheses {
                 expression: Function {
                  argument: Simple {
                   identifier: "config",
                  },
                  definition: Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "file",
                        position: (521, 37),
                       },
                      ],
                     },
                     to: PropertyAccess {
                      expression: Variable {
                       identifier: "m",
                       position: (521, 44),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "_file",
                         position: (521, 46),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Inherit {
                     from: None,
                     attributes: [
                      Raw {
                       content: "config",
                       position: (521, 61),
                      },
                     ],
                    },
                   ],
                   recursive: false,
                   position: (521, 35),
                  },
                  position: (521, 27),
                 },
                 position: (521, 26),
                },
                Parentheses {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "pushDownProperties",
                   position: (521, 73),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "m",
                     position: (521, 92),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "config",
                       position: (521, 94),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                 position: (521, 72),
                },
               ],
              },
              position: (521, 19),
             },
             position: (521, 18),
            },
            Variable {
             identifier: "modules",
             position: (521, 103),
            },
           ],
          },
          position: (521, 7),
         },
        ],
       },
       position: (519, 26),
      },
      position: (519, 18),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mergeModules'",
        position: (523, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "prefix",
      },
      definition: Function {
       argument: Simple {
        identifier: "options",
       },
       definition: Function {
        argument: Simple {
         identifier: "configs",
        },
        definition: LetIn {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "byName",
              position: (546, 7),
             },
            ],
           },
           to: Function {
            argument: Simple {
             identifier: "attr",
            },
            definition: Function {
             argument: Simple {
              identifier: "f",
             },
             definition: Function {
              argument: Simple {
               identifier: "modules",
              },
              definition: FunctionApplication {
               function: Variable {
                identifier: "zipAttrsWith",
                position: (547, 9),
               },
               arguments: [
                Parentheses {
                 expression: Function {
                  argument: Simple {
                   identifier: "n",
                  },
                  definition: Variable {
                   identifier: "concatLists",
                   position: (547, 26),
                  },
                  position: (547, 23),
                 },
                 position: (547, 22),
                },
                Parentheses {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "map",
                   position: (548, 12),
                  },
                  arguments: [
                   Parentheses {
                    expression: Function {
                     argument: Simple {
                      identifier: "module",
                     },
                     definition: LetIn {
                      bindings: [
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "subtree",
                           position: (548, 29),
                          },
                         ],
                        },
                        to: PropertyAccess {
                         expression: Variable {
                          identifier: "module",
                          position: (548, 39),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           Expression {
                            expression: Variable {
                             identifier: "attr",
                             position: (548, 48),
                            },
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                      ],
                      target: IfThenElse {
                       predicate: UnaryOperation {
                        operator: Not,
                        operand: Parentheses {
                         expression: FunctionApplication {
                          function: PropertyAccess {
                           expression: Variable {
                            identifier: "builtins",
                            position: (549, 20),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "isAttrs",
                              position: (549, 29),
                             },
                            ],
                           },
                           default: None,
                          },
                          arguments: [
                           Variable {
                            identifier: "subtree",
                            position: (549, 37),
                           },
                          ],
                         },
                         position: (549, 19),
                        },
                        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 `",
                            position: (551, 1),
                           },
                           Expression {
                            expression: FunctionApplication {
                             function: PropertyAccess {
                              expression: Variable {
                               identifier: "builtins",
                               position: (551, 63),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                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`",
                            position: (551, 87),
                           },
                           Expression {
                            expression: FunctionApplication {
                             function: PropertyAccess {
                              expression: Variable {
                               identifier: "builtins",
                               position: (553, 22),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                Raw {
                                 content: "concatStringsSep",
                                 position: (553, 31),
                                },
                               ],
                              },
                              default: None,
                             },
                             arguments: [
                              String {
                               parts: [
                                Raw {
                                 content: ".",
                                 position: (553, 49),
                                },
                               ],
                               position: (553, 48),
                              },
                              Variable {
                               identifier: "prefix",
                               position: (553, 52),
                              },
                             ],
                            },
                           },
                           Raw {
                            content: "'!\n\nThis usually happens if `",
                            position: (553, 59),
                           },
                           Expression {
                            expression: FunctionApplication {
                             function: PropertyAccess {
                              expression: Variable {
                               identifier: "builtins",
                               position: (555, 46),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                Raw {
                                 content: "concatStringsSep",
                                 position: (555, 55),
                                },
                               ],
                              },
                              default: None,
                             },
                             arguments: [
                              String {
                               parts: [
                                Raw {
                                 content: ".",
                                 position: (555, 73),
                                },
                               ],
                               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: (555, 83),
                           },
                          ],
                          position: (550, 23),
                         },
                        ],
                       },
                       else_: FunctionApplication {
                        function: Variable {
                         identifier: "mapAttrs",
                         position: (560, 17),
                        },
                        arguments: [
                         Parentheses {
                          expression: Function {
                           argument: Simple {
                            identifier: "n",
                           },
                           definition: FunctionApplication {
                            function: Variable {
                             identifier: "f",
                             position: (560, 30),
                            },
                            arguments: [
                             Variable {
                              identifier: "module",
                              position: (560, 32),
                             },
                            ],
                           },
                           position: (560, 27),
                          },
                          position: (560, 26),
                         },
                         Variable {
                          identifier: "subtree",
                          position: (560, 40),
                         },
                        ],
                       },
                       position: (549, 15),
                      },
                      position: (548, 25),
                     },
                     position: (548, 17),
                    },
                    position: (548, 16),
                   },
                   Variable {
                    identifier: "modules",
                    position: (561, 17),
                   },
                  ],
                 },
                 position: (548, 11),
                },
               ],
              },
              position: (546, 25),
             },
             position: (546, 22),
            },
            position: (546, 16),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "declsByName",
              position: (563, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "byName",
             position: (563, 21),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "options",
                position: (563, 29),
               },
              ],
              position: (563, 28),
             },
             Parentheses {
              expression: Function {
               argument: Simple {
                identifier: "module",
               },
               definition: Function {
                argument: Simple {
                 identifier: "option",
                },
                definition: List {
                 elements: [
                  Map {
                   bindings: [
                    Inherit {
                     from: Some(
                      Variable {
                       identifier: "module",
                       position: (564, 23),
                      },
                     ),
                     attributes: [
                      Raw {
                       content: "_file",
                       position: (564, 31),
                      },
                     ],
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "options",
                        position: (564, 38),
                       },
                      ],
                     },
                     to: Variable {
                      identifier: "option",
                      position: (564, 48),
                     },
                    },
                   ],
                   recursive: false,
                   position: (564, 12),
                  },
                 ],
                 position: (564, 11),
                },
                position: (563, 47),
               },
               position: (563, 39),
              },
              position: (563, 38),
             },
             Variable {
              identifier: "options",
              position: (565, 11),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "defnsByName",
              position: (567, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "byName",
             position: (567, 21),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "config",
                position: (567, 29),
               },
              ],
              position: (567, 28),
             },
             Parentheses {
              expression: Function {
               argument: Simple {
                identifier: "module",
               },
               definition: Function {
                argument: Simple {
                 identifier: "value",
                },
                definition: FunctionApplication {
                 function: Variable {
                  identifier: "map",
                  position: (568, 11),
                 },
                 arguments: [
                  Parentheses {
                   expression: Function {
                    argument: Simple {
                     identifier: "config",
                    },
                    definition: Map {
                     bindings: [
                      Inherit {
                       from: Some(
                        Variable {
                         identifier: "module",
                         position: (568, 35),
                        },
                       ),
                       attributes: [
                        Raw {
                         content: "file",
                         position: (568, 43),
                        },
                       ],
                      },
                      Inherit {
                       from: None,
                       attributes: [
                        Raw {
                         content: "config",
                         position: (568, 57),
                        },
                       ],
                      },
                     ],
                     recursive: false,
                     position: (568, 24),
                    },
                    position: (568, 16),
                   },
                   position: (568, 15),
                  },
                  Parentheses {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "pushDownProperties",
                     position: (568, 69),
                    },
                    arguments: [
                     Variable {
                      identifier: "value",
                      position: (568, 88),
                     },
                    ],
                   },
                   position: (568, 68),
                  },
                 ],
                },
                position: (567, 46),
               },
               position: (567, 38),
              },
              position: (567, 37),
             },
             Variable {
              identifier: "configs",
              position: (569, 11),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "defnsByName'",
              position: (571, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "byName",
             position: (571, 22),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "config",
                position: (571, 30),
               },
              ],
              position: (571, 29),
             },
             Parentheses {
              expression: Function {
               argument: Simple {
                identifier: "module",
               },
               definition: Function {
                argument: Simple {
                 identifier: "value",
                },
                definition: List {
                 elements: [
                  Map {
                   bindings: [
                    Inherit {
                     from: Some(
                      Variable {
                       identifier: "module",
                       position: (572, 23),
                      },
                     ),
                     attributes: [
                      Raw {
                       content: "file",
                       position: (572, 31),
                      },
                     ],
                    },
                    Inherit {
                     from: None,
                     attributes: [
                      Raw {
                       content: "value",
                       position: (572, 45),
                      },
                     ],
                    },
                   ],
                   recursive: false,
                   position: (572, 12),
                  },
                 ],
                 position: (572, 11),
                },
                position: (571, 47),
               },
               position: (571, 39),
              },
              position: (571, 38),
             },
             Variable {
              identifier: "configs",
              position: (573, 11),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "optionTreeToOption",
              position: (576, 7),
             },
            ],
           },
           to: Function {
            argument: Simple {
             identifier: "decl",
            },
            definition: IfThenElse {
             predicate: FunctionApplication {
              function: Variable {
               identifier: "isOption",
               position: (577, 12),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "decl",
                 position: (577, 21),
                },
                attribute_path: AttributePath {
                 parts: [
                  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: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "options",
                     position: (580, 13),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: Variable {
                    identifier: "mkOption",
                    position: (580, 23),
                   },
                   arguments: [
                    Map {
                     bindings: [
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "type",
                          position: (581, 15),
                         },
                        ],
                       },
                       to: FunctionApplication {
                        function: PropertyAccess {
                         expression: Variable {
                          identifier: "types",
                          position: (581, 22),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           Raw {
                            content: "submoduleWith",
                            position: (581, 28),
                           },
                          ],
                         },
                         default: None,
                        },
                        arguments: [
                         Map {
                          bindings: [
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "modules",
                               position: (582, 17),
                              },
                             ],
                            },
                            to: List {
                             elements: [
                              Map {
                               bindings: [
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "options",
                                    position: (582, 31),
                                   },
                                  ],
                                 },
                                 to: PropertyAccess {
                                  expression: Variable {
                                   identifier: "decl",
                                   position: (582, 41),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "options",
                                     position: (582, 46),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                },
                               ],
                               recursive: false,
                               position: (582, 29),
                              },
                             ],
                             position: (582, 27),
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "shorthandOnlyDefinesConfig",
                               position: (586, 17),
                              },
                             ],
                            },
                            to: 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),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "resultsByName",
              position: (591, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mapAttrs",
             position: (591, 23),
            },
            arguments: [
             Parentheses {
              expression: Function {
               argument: Simple {
                identifier: "name",
               },
               definition: Function {
                argument: Simple {
                 identifier: "decls",
                },
                definition: LetIn {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "loc",
                      position: (594, 11),
                     },
                    ],
                   },
                   to: BinaryOperation {
                    operator: Concatenation,
                    operands: [
                     Variable {
                      identifier: "prefix",
                      position: (594, 17),
                     },
                     List {
                      elements: [
                       Variable {
                        identifier: "name",
                        position: (594, 28),
                       },
                      ],
                      position: (594, 27),
                     },
                    ],
                    position: (594, 24),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "defns",
                      position: (595, 11),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "defnsByName",
                     position: (595, 19),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Expression {
                       expression: Variable {
                        identifier: "name",
                        position: (595, 33),
                       },
                      },
                     ],
                    },
                    default: Some(
                     List {
                      elements: [],
                      position: (595, 42),
                     },
                    ),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "defns'",
                      position: (596, 11),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "defnsByName'",
                     position: (596, 20),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Expression {
                       expression: Variable {
                        identifier: "name",
                        position: (596, 35),
                       },
                      },
                     ],
                    },
                    default: Some(
                     List {
                      elements: [],
                      position: (596, 44),
                     },
                    ),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "optionDecls",
                      position: (597, 11),
                     },
                    ],
                   },
                   to: FunctionApplication {
                    function: Variable {
                     identifier: "filter",
                     position: (597, 25),
                    },
                    arguments: [
                     Parentheses {
                      expression: Function {
                       argument: Simple {
                        identifier: "m",
                       },
                       definition: FunctionApplication {
                        function: Variable {
                         identifier: "isOption",
                         position: (597, 36),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "m",
                           position: (597, 45),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "options",
                             position: (597, 47),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                       position: (597, 33),
                      },
                      position: (597, 32),
                     },
                     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: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "opt",
                        position: (600, 17),
                       },
                      ],
                     },
                     to: FunctionApplication {
                      function: Variable {
                       identifier: "fixupOptionType",
                       position: (600, 23),
                      },
                      arguments: [
                       Variable {
                        identifier: "loc",
                        position: (600, 39),
                       },
                       Parentheses {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "mergeOptionDecls",
                          position: (600, 44),
                         },
                         arguments: [
                          Variable {
                           identifier: "loc",
                           position: (600, 61),
                          },
                          Variable {
                           identifier: "decls",
                           position: (600, 65),
                          },
                         ],
                        },
                        position: (600, 43),
                       },
                      ],
                     },
                    },
                   ],
                   target: Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "matchedOptions",
                         position: (602, 15),
                        },
                       ],
                      },
                      to: 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),
                        },
                       ],
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "unmatchedDefns",
                         position: (603, 15),
                        },
                       ],
                      },
                      to: 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: [
                      Parentheses {
                       expression: Function {
                        argument: Simple {
                         identifier: "x",
                        },
                        definition: BinaryOperation {
                         operator: EqualTo,
                         operands: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "x",
                            position: (606, 26),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             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, 50),
                            },
                           ],
                           position: (606, 49),
                          },
                         ],
                         position: (606, 46),
                        },
                        position: (606, 23),
                       },
                       position: (606, 22),
                      },
                      Variable {
                       identifier: "optionDecls",
                       position: (606, 62),
                      },
                     ],
                    },
                    then: LetIn {
                     bindings: [
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "opt",
                          position: (617, 21),
                         },
                        ],
                       },
                       to: FunctionApplication {
                        function: Variable {
                         identifier: "fixupOptionType",
                         position: (617, 27),
                        },
                        arguments: [
                         Variable {
                          identifier: "loc",
                          position: (617, 43),
                         },
                         Parentheses {
                          expression: FunctionApplication {
                           function: Variable {
                            identifier: "mergeOptionDecls",
                            position: (617, 48),
                           },
                           arguments: [
                            Variable {
                             identifier: "loc",
                             position: (617, 65),
                            },
                            Parentheses {
                             expression: FunctionApplication {
                              function: Variable {
                               identifier: "map",
                               position: (617, 70),
                              },
                              arguments: [
                               Variable {
                                identifier: "optionTreeToOption",
                                position: (617, 74),
                               },
                               Variable {
                                identifier: "decls",
                                position: (617, 93),
                               },
                              ],
                             },
                             position: (617, 69),
                            },
                           ],
                          },
                          position: (617, 47),
                         },
                        ],
                       },
                      },
                     ],
                     target: Map {
                      bindings: [
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "matchedOptions",
                           position: (619, 19),
                          },
                         ],
                        },
                        to: 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),
                          },
                         ],
                        },
                       },
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "unmatchedDefns",
                           position: (620, 19),
                          },
                         ],
                        },
                        to: List {
                         elements: [],
                         position: (620, 36),
                        },
                       },
                      ],
                      recursive: false,
                      position: (618, 20),
                     },
                     position: (617, 17),
                    },
                    else_: LetIn {
                     bindings: [
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "firstNonOption",
                          position: (624, 19),
                         },
                        ],
                       },
                       to: FunctionApplication {
                        function: Variable {
                         identifier: "findFirst",
                         position: (624, 36),
                        },
                        arguments: [
                         Parentheses {
                          expression: Function {
                           argument: Simple {
                            identifier: "m",
                           },
                           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 {
                                parts: [
                                 Raw {
                                  content: "options",
                                  position: (624, 62),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ],
                            },
                            position: (624, 50),
                           },
                           position: (624, 47),
                          },
                          position: (624, 46),
                         },
                         String {
                          parts: [],
                          position: (624, 71),
                         },
                         Variable {
                          identifier: "decls",
                          position: (624, 74),
                         },
                        ],
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "nonOptions",
                          position: (625, 19),
                         },
                        ],
                       },
                       to: FunctionApplication {
                        function: Variable {
                         identifier: "filter",
                         position: (625, 32),
                        },
                        arguments: [
                         Parentheses {
                          expression: Function {
                           argument: Simple {
                            identifier: "m",
                           },
                           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 {
                                parts: [
                                 Raw {
                                  content: "options",
                                  position: (625, 55),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ],
                            },
                            position: (625, 43),
                           },
                           position: (625, 40),
                          },
                          position: (625, 39),
                         },
                         Variable {
                          identifier: "decls",
                          position: (625, 64),
                         },
                        ],
                       },
                      },
                     ],
                     target: FunctionApplication {
                      function: Variable {
                       identifier: "throw",
                       position: (627, 17),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "The option `",
                          position: (627, 24),
                         },
                         Expression {
                          expression: FunctionApplication {
                           function: Variable {
                            identifier: "showOption",
                            position: (627, 38),
                           },
                           arguments: [
                            Variable {
                             identifier: "loc",
                             position: (627, 49),
                            },
                           ],
                          },
                         },
                         Raw {
                          content: "' in module `",
                          position: (627, 53),
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Parentheses {
                            expression: FunctionApplication {
                             function: PropertyAccess {
                              expression: Variable {
                               identifier: "lib",
                               position: (627, 69),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                Raw {
                                 content: "head",
                                 position: (627, 73),
                                },
                               ],
                              },
                              default: None,
                             },
                             arguments: [
                              Variable {
                               identifier: "optionDecls",
                               position: (627, 78),
                              },
                             ],
                            },
                            position: (627, 68),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "_file",
                              position: (627, 91),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "' would be a parent of the following options, but its type `",
                          position: (627, 97),
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Parentheses {
                            expression: FunctionApplication {
                             function: PropertyAccess {
                              expression: Variable {
                               identifier: "lib",
                               position: (627, 160),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                Raw {
                                 content: "head",
                                 position: (627, 164),
                                },
                               ],
                              },
                              default: None,
                             },
                             arguments: [
                              Variable {
                               identifier: "optionDecls",
                               position: (627, 169),
                              },
                             ],
                            },
                            position: (627, 159),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             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, 211),
                              },
                             ],
                             position: (627, 210),
                            },
                           ),
                          },
                         },
                         Raw {
                          content: "' does not support nested options.\n",
                          position: (627, 229),
                         },
                         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),
              },
              position: (591, 32),
             },
             Variable {
              identifier: "declsByName",
              position: (631, 44),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "matchedOptions",
              position: (633, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mapAttrs",
             position: (633, 24),
            },
            arguments: [
             Parentheses {
              expression: Function {
               argument: Simple {
                identifier: "n",
               },
               definition: Function {
                argument: Simple {
                 identifier: "v",
                },
                definition: PropertyAccess {
                 expression: Variable {
                  identifier: "v",
                  position: (633, 40),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "matchedOptions",
                    position: (633, 42),
                   },
                  ],
                 },
                 default: None,
                },
                position: (633, 37),
               },
               position: (633, 34),
              },
              position: (633, 33),
             },
             Variable {
              identifier: "resultsByName",
              position: (633, 58),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "unmatchedDefnsByName",
              position: (636, 7),
             },
            ],
           },
           to: BinaryOperation {
            operator: Update,
            operands: [
             FunctionApplication {
              function: Variable {
               identifier: "mapAttrs",
               position: (638, 9),
              },
              arguments: [
               Parentheses {
                expression: Function {
                 argument: Simple {
                  identifier: "n",
                 },
                 definition: Function {
                  argument: Simple {
                   identifier: "v",
                  },
                  definition: PropertyAccess {
                   expression: Variable {
                    identifier: "v",
                    position: (638, 25),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "unmatchedDefns",
                      position: (638, 27),
                     },
                    ],
                   },
                   default: None,
                  },
                  position: (638, 22),
                 },
                 position: (638, 19),
                },
                position: (638, 18),
               },
               Variable {
                identifier: "resultsByName",
                position: (638, 43),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "removeAttrs",
               position: (640, 12),
              },
              arguments: [
               Variable {
                identifier: "defnsByName'",
                position: (640, 24),
               },
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "attrNames",
                  position: (640, 38),
                 },
                 arguments: [
                  Variable {
                   identifier: "matchedOptions",
                   position: (640, 48),
                  },
                 ],
                },
                position: (640, 37),
               },
              ],
             },
            ],
            position: (640, 9),
           },
          },
         ],
         target: Map {
          bindings: [
           Inherit {
            from: None,
            attributes: [
             Raw {
              content: "matchedOptions",
              position: (642, 15),
             },
            ],
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "unmatchedDefns",
               position: (645, 7),
              },
             ],
            },
            to: 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: [
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "mapAttrsToList",
                  position: (652, 24),
                 },
                 arguments: [
                  Parentheses {
                   expression: Function {
                    argument: Simple {
                     identifier: "name",
                    },
                    definition: Function {
                     argument: Simple {
                      identifier: "defs",
                     },
                     definition: FunctionApplication {
                      function: Variable {
                       identifier: "map",
                       position: (653, 13),
                      },
                      arguments: [
                       Parentheses {
                        expression: Function {
                         argument: Simple {
                          identifier: "def",
                         },
                         definition: BinaryOperation {
                          operator: Update,
                          operands: [
                           Variable {
                            identifier: "def",
                            position: (653, 23),
                           },
                           Map {
                            bindings: [
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "prefix",
                                 position: (655, 15),
                                },
                               ],
                              },
                              to: BinaryOperation {
                               operator: Concatenation,
                               operands: [
                                List {
                                 elements: [
                                  Variable {
                                   identifier: "name",
                                   position: (655, 25),
                                  },
                                 ],
                                 position: (655, 24),
                                },
                                Parentheses {
                                 expression: PropertyAccess {
                                  expression: Variable {
                                   identifier: "def",
                                   position: (655, 35),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "prefix",
                                     position: (655, 39),
                                    },
                                   ],
                                  },
                                  default: Some(
                                   List {
                                    elements: [],
                                    position: (655, 49),
                                   },
                                  ),
                                 },
                                 position: (655, 34),
                                },
                               ],
                               position: (655, 31),
                              },
                             },
                            ],
                            recursive: false,
                            position: (653, 30),
                           },
                          ],
                          position: (653, 27),
                         },
                         position: (653, 18),
                        },
                        position: (653, 17),
                       },
                       Variable {
                        identifier: "defs",
                        position: (656, 16),
                       },
                      ],
                     },
                     position: (652, 46),
                    },
                    position: (652, 40),
                   },
                   position: (652, 39),
                  },
                  Variable {
                   identifier: "unmatchedDefnsByName",
                   position: (657, 13),
                  },
                 ],
                },
                position: (652, 23),
               },
              ],
             },
             position: (646, 9),
            },
           },
          ],
          recursive: false,
          position: (641, 8),
         },
         position: (524, 5),
        },
        position: (523, 36),
       },
       position: (523, 27),
      },
      position: (523, 19),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mergeOptionDecls",
        position: (671, 3),
       },
      ],
     },
     to: LetIn {
      bindings: [
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "coerceOption",
           position: (673, 5),
          },
         ],
        },
        to: Function {
         argument: Simple {
          identifier: "file",
         },
         definition: Function {
          argument: Simple {
           identifier: "opt",
          },
          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: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "options",
                   position: (675, 44),
                  },
                 ],
                },
                to: Variable {
                 identifier: "opt",
                 position: (675, 54),
                },
               },
              ],
              recursive: false,
              position: (675, 42),
             },
            ],
           },
           position: (674, 7),
          },
          position: (673, 26),
         },
         position: (673, 20),
        },
       },
      ],
      target: Function {
       argument: Simple {
        identifier: "loc",
       },
       definition: Function {
        argument: Simple {
         identifier: "opts",
        },
        definition: FunctionApplication {
         function: Variable {
          identifier: "foldl'",
          position: (677, 5),
         },
         arguments: [
          Parentheses {
           expression: Function {
            argument: Simple {
             identifier: "res",
            },
            definition: Function {
             argument: Simple {
              identifier: "opt",
             },
             definition: LetIn {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "t",
                   position: (678, 11),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "res",
                  position: (678, 16),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (678, 20),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "t'",
                   position: (679, 11),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "opt",
                  position: (679, 16),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "options",
                    position: (679, 20),
                   },
                   Raw {
                    content: "type",
                    position: (679, 28),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "mergedType",
                   position: (680, 11),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "t",
                   position: (680, 24),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "typeMerge",
                     position: (680, 26),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "t'",
                    position: (680, 36),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "functor",
                      position: (680, 39),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "typesMergeable",
                   position: (681, 11),
                  },
                 ],
                },
                to: BinaryOperation {
                 operator: NotEqualTo,
                 operands: [
                  Variable {
                   identifier: "mergedType",
                   position: (681, 28),
                  },
                  Variable {
                   identifier: "null",
                   position: (681, 42),
                  },
                 ],
                 position: (681, 39),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "typeSet",
                   position: (682, 11),
                  },
                 ],
                },
                to: IfThenElse {
                 predicate: BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   Parentheses {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "bothHave",
                      position: (682, 25),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "type",
                         position: (682, 35),
                        },
                       ],
                       position: (682, 34),
                      },
                     ],
                    },
                    position: (682, 24),
                   },
                   Variable {
                    identifier: "typesMergeable",
                    position: (682, 45),
                   },
                  ],
                  position: (682, 42),
                 },
                 then: Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "type",
                       position: (683, 31),
                      },
                     ],
                    },
                    to: Variable {
                     identifier: "mergedType",
                     position: (683, 38),
                    },
                   },
                  ],
                  recursive: false,
                  position: (683, 29),
                 },
                 else_: Map {
                  bindings: [],
                  recursive: false,
                  position: (684, 29),
                 },
                 position: (682, 21),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "bothHave",
                   position: (685, 11),
                  },
                 ],
                },
                to: Function {
                 argument: Simple {
                  identifier: "k",
                 },
                 definition: BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   HasProperty {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "opt",
                      position: (685, 25),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "options",
                        position: (685, 29),
                       },
                      ],
                     },
                     default: None,
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Expression {
                       expression: Variable {
                        identifier: "k",
                        position: (685, 41),
                       },
                      },
                     ],
                    },
                    position: (685, 37),
                   },
                   HasProperty {
                    expression: Variable {
                     identifier: "res",
                     position: (685, 47),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      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, 20),
                           },
                          ],
                          position: (687, 19),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "bothHave",
                         position: (688, 10),
                        },
                        arguments: [
                         String {
                          parts: [
                           Raw {
                            content: "example",
                            position: (688, 20),
                           },
                          ],
                          position: (688, 19),
                         },
                        ],
                       },
                      ],
                      position: (687, 29),
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "bothHave",
                       position: (689, 10),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "description",
                          position: (689, 20),
                         },
                        ],
                        position: (689, 19),
                       },
                      ],
                     },
                    ],
                    position: (688, 29),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "bothHave",
                     position: (690, 10),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "apply",
                        position: (690, 20),
                       },
                      ],
                      position: (690, 19),
                     },
                    ],
                   },
                  ],
                  position: (689, 33),
                 },
                 Parentheses {
                  expression: BinaryOperation {
                   operator: LogicalAnd,
                   operands: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "bothHave",
                      position: (691, 11),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "type",
                         position: (691, 21),
                        },
                       ],
                       position: (691, 20),
                      },
                     ],
                    },
                    Parentheses {
                     expression: UnaryOperation {
                      operator: Not,
                      operand: Variable {
                       identifier: "typesMergeable",
                       position: (691, 33),
                      },
                      position: (691, 31),
                     },
                     position: (691, 30),
                    },
                   ],
                   position: (691, 27),
                  },
                  position: (691, 10),
                 },
                ],
                position: (690, 27),
               },
               then: FunctionApplication {
                function: Variable {
                 identifier: "throw",
                 position: (693, 9),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "The option `",
                    position: (693, 16),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "showOption",
                      position: (693, 30),
                     },
                     arguments: [
                      Variable {
                       identifier: "loc",
                       position: (693, 41),
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "' in `",
                    position: (693, 45),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "opt",
                      position: (693, 53),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "_file",
                        position: (693, 57),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "' is already declared in ",
                    position: (693, 63),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "showFiles",
                      position: (693, 90),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "res",
                        position: (693, 100),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "declarations",
                          position: (693, 104),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   },
                   Raw {
                    content: ".",
                    position: (693, 117),
                   },
                  ],
                  position: (693, 15),
                 },
                ],
               },
               else_: LetIn {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "getSubModules",
                     position: (696, 11),
                    },
                   ],
                  },
                  to: PropertyAccess {
                   expression: Variable {
                    identifier: "opt",
                    position: (696, 27),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     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),
                    },
                   ),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "submodules",
                     position: (697, 11),
                    },
                   ],
                  },
                  to: 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: [
                       Parentheses {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "setDefaultModuleLocation",
                          position: (698, 48),
                         },
                         arguments: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "opt",
                            position: (698, 73),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "_file",
                              position: (698, 77),
                             },
                            ],
                           },
                           default: None,
                          },
                         ],
                        },
                        position: (698, 47),
                       },
                       Variable {
                        identifier: "getSubModules",
                        position: (698, 84),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "res",
                       position: (698, 101),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "options",
                         position: (698, 105),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                    position: (698, 98),
                   },
                   else_: PropertyAccess {
                    expression: Variable {
                     identifier: "res",
                     position: (699, 18),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      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 {
                    parts: [
                     Raw {
                      content: "options",
                      position: (700, 16),
                     },
                    ],
                   },
                   default: None,
                  },
                  BinaryOperation {
                   operator: Update,
                   operands: [
                    Variable {
                     identifier: "res",
                     position: (700, 27),
                    },
                    BinaryOperation {
                     operator: Update,
                     operands: [
                      Map {
                       bindings: [
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "declarations",
                            position: (701, 13),
                           },
                          ],
                         },
                         to: BinaryOperation {
                          operator: Concatenation,
                          operands: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "res",
                             position: (701, 28),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "declarations",
                               position: (701, 32),
                              },
                             ],
                            },
                            default: None,
                           },
                           List {
                            elements: [
                             PropertyAccess {
                              expression: Variable {
                               identifier: "opt",
                               position: (701, 49),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                Raw {
                                 content: "_file",
                                 position: (701, 53),
                                },
                               ],
                              },
                              default: None,
                             },
                            ],
                            position: (701, 48),
                           },
                          ],
                          position: (701, 45),
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "options",
                            position: (702, 13),
                           },
                          ],
                         },
                         to: 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),
           },
           position: (677, 12),
          },
          Map {
           bindings: [
            Inherit {
             from: None,
             attributes: [
              Raw {
               content: "loc",
               position: (704, 17),
              },
             ],
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "declarations",
                position: (704, 22),
               },
              ],
             },
             to: List {
              elements: [],
              position: (704, 37),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "options",
                position: (704, 41),
               },
              ],
             },
             to: 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),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "evalOptionValue",
        position: (708, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "loc",
      },
      definition: Function {
       argument: Simple {
        identifier: "opt",
       },
       definition: Function {
        argument: Simple {
         identifier: "defs",
        },
        definition: LetIn {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "defs'",
              position: (711, 7),
             },
            ],
           },
           to: BinaryOperation {
            operator: Concatenation,
            operands: [
             Parentheses {
              expression: FunctionApplication {
               function: Variable {
                identifier: "optional",
                position: (712, 12),
               },
               arguments: [
                Parentheses {
                 expression: HasProperty {
                  expression: Variable {
                   identifier: "opt",
                   position: (712, 22),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (712, 28),
                    },
                   ],
                  },
                  position: (712, 26),
                 },
                 position: (712, 21),
                },
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "file",
                      position: (713, 15),
                     },
                    ],
                   },
                   to: FunctionApplication {
                    function: Variable {
                     identifier: "head",
                     position: (713, 22),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "opt",
                       position: (713, 27),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "declarations",
                         position: (713, 31),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "value",
                      position: (713, 45),
                     },
                    ],
                   },
                   to: FunctionApplication {
                    function: Variable {
                     identifier: "mkOptionDefault",
                     position: (713, 53),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "opt",
                       position: (713, 69),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "default",
                         position: (713, 73),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  },
                 ],
                 recursive: false,
                 position: (713, 13),
                },
               ],
              },
              position: (712, 11),
             },
             Variable {
              identifier: "defs",
              position: (713, 88),
             },
            ],
            position: (713, 85),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "res",
              position: (716, 7),
             },
            ],
           },
           to: IfThenElse {
            predicate: BinaryOperation {
             operator: LogicalAnd,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "opt",
                position: (717, 12),
               },
               attribute_path: AttributePath {
                parts: [
                 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: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "separateDefs",
                  position: (721, 13),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "map",
                 position: (721, 28),
                },
                arguments: [
                 Parentheses {
                  expression: Function {
                   argument: Simple {
                    identifier: "def",
                   },
                   definition: BinaryOperation {
                    operator: Update,
                    operands: [
                     Variable {
                      identifier: "def",
                      position: (721, 38),
                     },
                     Map {
                      bindings: [
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "value",
                           position: (722, 15),
                          },
                         ],
                        },
                        to: PropertyAccess {
                         expression: Parentheses {
                          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 {
                              parts: [
                               Raw {
                                content: "type",
                                position: (722, 49),
                               },
                              ],
                             },
                             default: None,
                            },
                            List {
                             elements: [
                              Variable {
                               identifier: "def",
                               position: (722, 56),
                              },
                             ],
                             position: (722, 54),
                            },
                           ],
                          },
                          position: (722, 23),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           Raw {
                            content: "mergedValue",
                            position: (722, 63),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                      ],
                      recursive: false,
                      position: (721, 45),
                     },
                    ],
                    position: (721, 42),
                   },
                   position: (721, 33),
                  },
                  position: (721, 32),
                 },
                 Variable {
                  identifier: "defs'",
                  position: (723, 16),
                 },
                ],
               },
              },
             ],
             target: FunctionApplication {
              function: Variable {
               identifier: "throw",
               position: (724, 14),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "The option `",
                  position: (724, 21),
                 },
                 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:",
                  position: (724, 50),
                 },
                 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 {
                parts: [
                 Raw {
                  content: "type",
                  position: (726, 36),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "defs'",
               position: (726, 41),
              },
             ],
            },
            position: (717, 9),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "value",
              position: (730, 7),
             },
            ],
           },
           to: IfThenElse {
            predicate: HasProperty {
             expression: Variable {
              identifier: "opt",
              position: (730, 18),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "apply",
                position: (730, 24),
               },
              ],
             },
             position: (730, 22),
            },
            then: FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "opt",
               position: (730, 35),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "apply",
                 position: (730, 39),
                },
               ],
              },
              default: None,
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "res",
                position: (730, 45),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "mergedValue",
                  position: (730, 49),
                 },
                ],
               },
               default: None,
              },
             ],
            },
            else_: PropertyAccess {
             expression: Variable {
              identifier: "res",
              position: (730, 66),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "mergedValue",
                position: (730, 70),
               },
              ],
             },
             default: None,
            },
            position: (730, 15),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "warnDeprecation",
              position: (732, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "warnIf",
             position: (733, 9),
            },
            arguments: [
             Parentheses {
              expression: BinaryOperation {
               operator: NotEqualTo,
               operands: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "opt",
                  position: (733, 17),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (733, 21),
                   },
                   Raw {
                    content: "deprecationMessage",
                    position: (733, 26),
                   },
                  ],
                 },
                 default: None,
                },
                Variable {
                 identifier: "null",
                 position: (733, 48),
                },
               ],
               position: (733, 45),
              },
              position: (733, 16),
             },
             String {
              parts: [
               Raw {
                content: "The type `types.",
                position: (734, 12),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "opt",
                  position: (734, 30),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (734, 34),
                   },
                   Raw {
                    content: "name",
                    position: (734, 39),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "' of option `",
                position: (734, 44),
               },
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "showOption",
                  position: (734, 59),
                 },
                 arguments: [
                  Variable {
                   identifier: "loc",
                   position: (734, 70),
                  },
                 ],
                },
               },
               Raw {
                content: "' defined in ",
                position: (734, 74),
               },
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "showFiles",
                  position: (734, 89),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "opt",
                    position: (734, 99),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "declarations",
                      position: (734, 103),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               },
               Raw {
                content: " is deprecated. ",
                position: (734, 116),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "opt",
                  position: (734, 134),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   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: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "value",
                 position: (737, 9),
                },
               ],
              },
              to: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "builtins",
                 position: (737, 17),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "addErrorContext",
                   position: (737, 26),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "while evaluating the option `",
                   position: (737, 43),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "showOption",
                     position: (737, 74),
                    },
                    arguments: [
                     Variable {
                      identifier: "loc",
                      position: (737, 85),
                     },
                    ],
                   },
                  },
                  Raw {
                   content: "':",
                   position: (737, 89),
                  },
                 ],
                 position: (737, 42),
                },
                Variable {
                 identifier: "value",
                 position: (737, 93),
                },
               ],
              },
             },
             Inherit {
              from: Some(
               PropertyAccess {
                expression: Variable {
                 identifier: "res",
                 position: (738, 18),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "defsFinal'",
                   position: (738, 22),
                  },
                 ],
                },
                default: None,
               },
              ),
              attributes: [
               Raw {
                content: "highestPrio",
                position: (738, 34),
               },
              ],
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "definitions",
                 position: (739, 9),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "map",
                position: (739, 23),
               },
               arguments: [
                Parentheses {
                 expression: Function {
                  argument: Simple {
                   identifier: "def",
                  },
                  definition: PropertyAccess {
                   expression: Variable {
                    identifier: "def",
                    position: (739, 33),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "value",
                      position: (739, 37),
                     },
                    ],
                   },
                   default: None,
                  },
                  position: (739, 28),
                 },
                 position: (739, 27),
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "res",
                  position: (739, 44),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "defsFinal",
                    position: (739, 48),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "files",
                 position: (740, 9),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "map",
                position: (740, 17),
               },
               arguments: [
                Parentheses {
                 expression: Function {
                  argument: Simple {
                   identifier: "def",
                  },
                  definition: PropertyAccess {
                   expression: Variable {
                    identifier: "def",
                    position: (740, 27),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "file",
                      position: (740, 31),
                     },
                    ],
                   },
                   default: None,
                  },
                  position: (740, 22),
                 },
                 position: (740, 21),
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "res",
                  position: (740, 37),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "defsFinal",
                    position: (740, 41),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             },
             Inherit {
              from: Some(
               Variable {
                identifier: "res",
                position: (741, 18),
               },
              ),
              attributes: [
               Raw {
                content: "isDefined",
                position: (741, 23),
               },
              ],
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "__toString",
                 position: (743, 9),
                },
               ],
              },
              to: Function {
               argument: Simple {
                identifier: "_",
               },
               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),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mergeDefinitions",
        position: (747, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "loc",
      },
      definition: Function {
       argument: Simple {
        identifier: "type",
       },
       definition: Function {
        argument: Simple {
         identifier: "defs",
        },
        definition: Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "defsFinal'",
              position: (748, 5),
             },
            ],
           },
           to: LetIn {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "defs'",
                 position: (751, 9),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "concatMap",
                position: (751, 17),
               },
               arguments: [
                Parentheses {
                 expression: Function {
                  argument: Simple {
                   identifier: "m",
                  },
                  definition: FunctionApplication {
                   function: Variable {
                    identifier: "map",
                    position: (752, 11),
                   },
                   arguments: [
                    Parentheses {
                     expression: Function {
                      argument: Simple {
                       identifier: "value",
                      },
                      definition: Map {
                       bindings: [
                        Inherit {
                         from: Some(
                          Variable {
                           identifier: "m",
                           position: (752, 34),
                          },
                         ),
                         attributes: [
                          Raw {
                           content: "file",
                           position: (752, 37),
                          },
                         ],
                        },
                        Inherit {
                         from: None,
                         attributes: [
                          Raw {
                           content: "value",
                           position: (752, 51),
                          },
                         ],
                        },
                       ],
                       recursive: false,
                       position: (752, 23),
                      },
                      position: (752, 16),
                     },
                     position: (752, 15),
                    },
                    Parentheses {
                     expression: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "builtins",
                        position: (752, 62),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "addErrorContext",
                          position: (752, 71),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "while evaluating definitions from `",
                          position: (752, 88),
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "m",
                            position: (752, 125),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "file",
                              position: (752, 127),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "':",
                          position: (752, 132),
                         },
                        ],
                        position: (752, 87),
                       },
                       Parentheses {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "dischargeProperties",
                          position: (752, 137),
                         },
                         arguments: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "m",
                            position: (752, 157),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "value",
                              position: (752, 159),
                             },
                            ],
                           },
                           default: None,
                          },
                         ],
                        },
                        position: (752, 136),
                       },
                      ],
                     },
                     position: (752, 61),
                    },
                   ],
                  },
                  position: (751, 28),
                 },
                 position: (751, 27),
                },
                Variable {
                 identifier: "defs",
                 position: (753, 11),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "defs''",
                 position: (756, 9),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "filterOverrides'",
                position: (756, 18),
               },
               arguments: [
                Variable {
                 identifier: "defs'",
                 position: (756, 35),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "defs'''",
                 position: (759, 9),
                },
               ],
              },
              to: IfThenElse {
               predicate: FunctionApplication {
                function: Variable {
                 identifier: "any",
                 position: (761, 14),
                },
                arguments: [
                 Parentheses {
                  expression: Function {
                   argument: Simple {
                    identifier: "def",
                   },
                   definition: BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "def",
                       position: (761, 24),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        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, 50),
                       },
                      ],
                      position: (761, 49),
                     },
                    ],
                    position: (761, 46),
                   },
                   position: (761, 19),
                  },
                  position: (761, 18),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "defs''",
                   position: (761, 58),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    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 {
                   parts: [
                    Raw {
                     content: "values",
                     position: (762, 38),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
               else_: PropertyAccess {
                expression: Variable {
                 identifier: "defs''",
                 position: (763, 16),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "values",
                   position: (763, 23),
                  },
                 ],
                },
                default: None,
               },
               position: (761, 11),
              },
             },
            ],
            target: Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "values",
                  position: (765, 9),
                 },
                ],
               },
               to: Variable {
                identifier: "defs'''",
                position: (765, 18),
               },
              },
              Inherit {
               from: Some(
                Variable {
                 identifier: "defs''",
                 position: (766, 18),
                },
               ),
               attributes: [
                Raw {
                 content: "highestPrio",
                 position: (766, 26),
                },
               ],
              },
             ],
             recursive: false,
             position: (764, 10),
            },
            position: (749, 7),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "defsFinal",
              position: (768, 5),
             },
            ],
           },
           to: PropertyAccess {
            expression: Variable {
             identifier: "defsFinal'",
             position: (768, 17),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "values",
               position: (768, 28),
              },
             ],
            },
            default: None,
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "mergedValue",
              position: (771, 5),
             },
            ],
           },
           to: IfThenElse {
            predicate: Variable {
             identifier: "isDefined",
             position: (772, 10),
            },
            then: IfThenElse {
             predicate: FunctionApplication {
              function: Variable {
               identifier: "all",
               position: (773, 12),
              },
              arguments: [
               Parentheses {
                expression: Function {
                 argument: Simple {
                  identifier: "def",
                 },
                 definition: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "type",
                    position: (773, 22),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "check",
                      position: (773, 27),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "def",
                     position: (773, 33),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "value",
                       position: (773, 37),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                 position: (773, 17),
                },
                position: (773, 16),
               },
               Variable {
                identifier: "defsFinal",
                position: (773, 44),
               },
              ],
             },
             then: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "type",
                position: (773, 59),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "merge",
                  position: (773, 64),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Variable {
                identifier: "loc",
                position: (773, 70),
               },
               Variable {
                identifier: "defsFinal",
                position: (773, 74),
               },
              ],
             },
             else_: LetIn {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "allInvalid",
                   position: (774, 18),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "filter",
                  position: (774, 31),
                 },
                 arguments: [
                  Parentheses {
                   expression: Function {
                    argument: Simple {
                     identifier: "def",
                    },
                    definition: UnaryOperation {
                     operator: Not,
                     operand: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "type",
                        position: (774, 46),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "check",
                          position: (774, 51),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "def",
                         position: (774, 57),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "value",
                           position: (774, 61),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                     position: (774, 44),
                    },
                    position: (774, 39),
                   },
                   position: (774, 38),
                  },
                  Variable {
                   identifier: "defsFinal",
                   position: (774, 68),
                  },
                 ],
                },
               },
              ],
              target: FunctionApplication {
               function: Variable {
                identifier: "throw",
                position: (775, 12),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "A definition for option `",
                   position: (775, 19),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "showOption",
                     position: (775, 46),
                    },
                    arguments: [
                     Variable {
                      identifier: "loc",
                      position: (775, 57),
                     },
                    ],
                   },
                  },
                  Raw {
                   content: "' is not of type `",
                   position: (775, 61),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "type",
                     position: (775, 81),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (775, 86),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "'. Definition values:",
                   position: (775, 98),
                  },
                  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 `",
                 position: (779, 16),
                },
                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, 45),
                },
               ],
               position: (779, 15),
              },
             ],
            },
            position: (772, 7),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "isDefined",
              position: (781, 5),
             },
            ],
           },
           to: BinaryOperation {
            operator: NotEqualTo,
            operands: [
             Variable {
              identifier: "defsFinal",
              position: (781, 17),
             },
             List {
              elements: [],
              position: (781, 30),
             },
            ],
            position: (781, 27),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "optionalValue",
              position: (783, 5),
             },
            ],
           },
           to: IfThenElse {
            predicate: Variable {
             identifier: "isDefined",
             position: (784, 10),
            },
            then: Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "value",
                  position: (784, 27),
                 },
                ],
               },
               to: 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),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "pushDownProperties",
        position: (803, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "cfg",
      },
      definition: IfThenElse {
       predicate: BinaryOperation {
        operator: EqualTo,
        operands: [
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (804, 8),
          },
          attribute_path: AttributePath {
           parts: [
            Raw {
             content: "_type",
             position: (804, 12),
            },
           ],
          },
          default: Some(
           String {
            parts: [],
            position: (804, 21),
           },
          ),
         },
         String {
          parts: [
           Raw {
            content: "merge",
            position: (804, 28),
           },
          ],
          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 {
           parts: [
            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 {
            parts: [
             Raw {
              content: "_type",
              position: (806, 17),
             },
            ],
           },
           default: Some(
            String {
             parts: [],
             position: (806, 26),
            },
           ),
          },
          String {
           parts: [
            Raw {
             content: "if",
             position: (806, 33),
            },
           ],
           position: (806, 32),
          },
         ],
         position: (806, 29),
        },
        then: FunctionApplication {
         function: Variable {
          identifier: "map",
          position: (807, 7),
         },
         arguments: [
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "mapAttrs",
             position: (807, 12),
            },
            arguments: [
             Parentheses {
              expression: Function {
               argument: Simple {
                identifier: "n",
               },
               definition: Function {
                argument: Simple {
                 identifier: "v",
                },
                definition: FunctionApplication {
                 function: Variable {
                  identifier: "mkIf",
                  position: (807, 28),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (807, 33),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "condition",
                      position: (807, 37),
                     },
                    ],
                   },
                   default: None,
                  },
                  Variable {
                   identifier: "v",
                   position: (807, 47),
                  },
                 ],
                },
                position: (807, 25),
               },
               position: (807, 22),
              },
              position: (807, 21),
             },
            ],
           },
           position: (807, 11),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "pushDownProperties",
             position: (807, 52),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (807, 71),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "content",
                 position: (807, 75),
                },
               ],
              },
              default: None,
             },
            ],
           },
           position: (807, 51),
          },
         ],
        },
        else_: IfThenElse {
         predicate: BinaryOperation {
          operator: EqualTo,
          operands: [
           PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (808, 13),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "_type",
               position: (808, 17),
              },
             ],
            },
            default: Some(
             String {
              parts: [],
              position: (808, 26),
             },
            ),
           },
           String {
            parts: [
             Raw {
              content: "override",
              position: (808, 33),
             },
            ],
            position: (808, 32),
           },
          ],
          position: (808, 29),
         },
         then: FunctionApplication {
          function: Variable {
           identifier: "map",
           position: (809, 7),
          },
          arguments: [
           Parentheses {
            expression: FunctionApplication {
             function: Variable {
              identifier: "mapAttrs",
              position: (809, 12),
             },
             arguments: [
              Parentheses {
               expression: Function {
                argument: Simple {
                 identifier: "n",
                },
                definition: Function {
                 argument: Simple {
                  identifier: "v",
                 },
                 definition: FunctionApplication {
                  function: Variable {
                   identifier: "mkOverride",
                   position: (809, 28),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (809, 39),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "priority",
                       position: (809, 43),
                      },
                     ],
                    },
                    default: None,
                   },
                   Variable {
                    identifier: "v",
                    position: (809, 52),
                   },
                  ],
                 },
                 position: (809, 25),
                },
                position: (809, 22),
               },
               position: (809, 21),
              },
             ],
            },
            position: (809, 11),
           },
           Parentheses {
            expression: FunctionApplication {
             function: Variable {
              identifier: "pushDownProperties",
              position: (809, 57),
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (809, 76),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "content",
                  position: (809, 80),
                 },
                ],
               },
               default: None,
              },
             ],
            },
            position: (809, 56),
           },
          ],
         },
         else_: List {
          elements: [
           Variable {
            identifier: "cfg",
            position: (811, 9),
           },
          ],
          position: (811, 7),
         },
         position: (808, 10),
        },
        position: (806, 10),
       },
       position: (804, 5),
      },
      position: (803, 24),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "dischargeProperties",
        position: (823, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "def",
      },
      definition: IfThenElse {
       predicate: BinaryOperation {
        operator: EqualTo,
        operands: [
         PropertyAccess {
          expression: Variable {
           identifier: "def",
           position: (824, 8),
          },
          attribute_path: AttributePath {
           parts: [
            Raw {
             content: "_type",
             position: (824, 12),
            },
           ],
          },
          default: Some(
           String {
            parts: [],
            position: (824, 21),
           },
          ),
         },
         String {
          parts: [
           Raw {
            content: "merge",
            position: (824, 28),
           },
          ],
          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 {
           parts: [
            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 {
            parts: [
             Raw {
              content: "_type",
              position: (826, 17),
             },
            ],
           },
           default: Some(
            String {
             parts: [],
             position: (826, 26),
            },
           ),
          },
          String {
           parts: [
            Raw {
             content: "if",
             position: (826, 33),
            },
           ],
           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 {
             parts: [
              Raw {
               content: "condition",
               position: (827, 21),
              },
             ],
            },
            default: None,
           },
          ],
         },
         then: IfThenElse {
          predicate: PropertyAccess {
           expression: Variable {
            identifier: "def",
            position: (828, 12),
           },
           attribute_path: AttributePath {
            parts: [
             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 {
              parts: [
               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, 16),
             },
            ],
            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),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "filterOverrides",
        position: (856, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "defs",
      },
      definition: PropertyAccess {
       expression: Parentheses {
        expression: FunctionApplication {
         function: Variable {
          identifier: "filterOverrides'",
          position: (856, 28),
         },
         arguments: [
          Variable {
           identifier: "defs",
           position: (856, 45),
          },
         ],
        },
        position: (856, 27),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "values",
          position: (856, 51),
         },
        ],
       },
       default: None,
      },
      position: (856, 21),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "filterOverrides'",
        position: (858, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "defs",
      },
      definition: LetIn {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "getPrio",
            position: (860, 7),
           },
          ],
         },
         to: Function {
          argument: Simple {
           identifier: "def",
          },
          definition: IfThenElse {
           predicate: BinaryOperation {
            operator: EqualTo,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "def",
               position: (860, 25),
              },
              attribute_path: AttributePath {
               parts: [
                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, 51),
               },
              ],
              position: (860, 50),
             },
            ],
            position: (860, 47),
           },
           then: PropertyAccess {
            expression: Variable {
             identifier: "def",
             position: (860, 66),
            },
            attribute_path: AttributePath {
             parts: [
              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),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "highestPrio",
            position: (861, 7),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "foldl'",
           position: (861, 21),
          },
          arguments: [
           Parentheses {
            expression: Function {
             argument: Simple {
              identifier: "prio",
             },
             definition: Function {
              argument: Simple {
               identifier: "def",
              },
              definition: FunctionApplication {
               function: Variable {
                identifier: "min",
                position: (861, 40),
               },
               arguments: [
                Parentheses {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "getPrio",
                   position: (861, 45),
                  },
                  arguments: [
                   Variable {
                    identifier: "def",
                    position: (861, 53),
                   },
                  ],
                 },
                 position: (861, 44),
                },
                Variable {
                 identifier: "prio",
                 position: (861, 58),
                },
               ],
              },
              position: (861, 35),
             },
             position: (861, 29),
            },
            position: (861, 28),
           },
           Int {
            value: 9999,
            position: (861, 64),
           },
           Variable {
            identifier: "defs",
            position: (861, 69),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "strip",
            position: (862, 7),
           },
          ],
         },
         to: Function {
          argument: Simple {
           identifier: "def",
          },
          definition: IfThenElse {
           predicate: BinaryOperation {
            operator: EqualTo,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "def",
               position: (862, 23),
              },
              attribute_path: AttributePath {
               parts: [
                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, 49),
               },
              ],
              position: (862, 48),
             },
            ],
            position: (862, 45),
           },
           then: BinaryOperation {
            operator: Update,
            operands: [
             Variable {
              identifier: "def",
              position: (862, 64),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "value",
                   position: (862, 73),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "def",
                  position: (862, 81),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   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: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "values",
             position: (864, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "concatMap",
            position: (864, 16),
           },
           arguments: [
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "def",
              },
              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: [
                 Parentheses {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "strip",
                    position: (864, 69),
                   },
                   arguments: [
                    Variable {
                     identifier: "def",
                     position: (864, 75),
                    },
                   ],
                  },
                  position: (864, 68),
                 },
                ],
                position: (864, 67),
               },
               else_: List {
                elements: [],
                position: (864, 86),
               },
               position: (864, 32),
              },
              position: (864, 27),
             },
             position: (864, 26),
            },
            Variable {
             identifier: "defs",
             position: (864, 90),
            },
           ],
          },
         },
         Inherit {
          from: None,
          attributes: [
           Raw {
            content: "highestPrio",
            position: (865, 15),
           },
          ],
         },
        ],
        recursive: false,
        position: (863, 8),
       },
       position: (859, 5),
      },
      position: (858, 22),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "sortProperties",
        position: (871, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "defs",
      },
      definition: LetIn {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "strip",
            position: (873, 7),
           },
          ],
         },
         to: Function {
          argument: Simple {
           identifier: "def",
          },
          definition: IfThenElse {
           predicate: BinaryOperation {
            operator: EqualTo,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "def",
               position: (874, 12),
              },
              attribute_path: AttributePath {
               parts: [
                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, 38),
               },
              ],
              position: (874, 37),
             },
            ],
            position: (874, 34),
           },
           then: BinaryOperation {
            operator: Update,
            operands: [
             Variable {
              identifier: "def",
              position: (875, 14),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "value",
                   position: (875, 23),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "def",
                  position: (875, 31),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "value",
                    position: (875, 35),
                   },
                   Raw {
                    content: "content",
                    position: (875, 41),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Inherit {
                from: Some(
                 PropertyAccess {
                  expression: Variable {
                   identifier: "def",
                   position: (875, 59),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "value",
                     position: (875, 63),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                attributes: [
                 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),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "defs'",
            position: (877, 7),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "map",
           position: (877, 15),
          },
          arguments: [
           Variable {
            identifier: "strip",
            position: (877, 19),
           },
           Variable {
            identifier: "defs",
            position: (877, 25),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "compare",
            position: (878, 7),
           },
          ],
         },
         to: Function {
          argument: Simple {
           identifier: "a",
          },
          definition: Function {
           argument: Simple {
            identifier: "b",
           },
           definition: BinaryOperation {
            operator: LessThan,
            operands: [
             Parentheses {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "a",
                position: (878, 24),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "priority",
                  position: (878, 26),
                 },
                ],
               },
               default: Some(
                Int {
                 value: 1000,
                 position: (878, 38),
                },
               ),
              },
              position: (878, 23),
             },
             Parentheses {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "b",
                position: (878, 47),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "priority",
                  position: (878, 49),
                 },
                ],
               },
               default: Some(
                Int {
                 value: 1000,
                 position: (878, 61),
                },
               ),
              },
              position: (878, 46),
             },
            ],
            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),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "fixupOptionType",
        position: (884, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "loc",
      },
      definition: Function {
       argument: Simple {
        identifier: "opt",
       },
       definition: IfThenElse {
        predicate: BinaryOperation {
         operator: EqualTo,
         operands: [
          PropertyAccess {
           expression: Variable {
            identifier: "opt",
            position: (885, 8),
           },
           attribute_path: AttributePath {
            parts: [
             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: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "type",
                position: (886, 19),
               },
              ],
             },
             to: PropertyAccess {
              expression: Variable {
               identifier: "opt",
               position: (886, 26),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "type",
                 position: (886, 30),
                },
               ],
              },
              default: Some(
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (886, 38),
                },
                attribute_path: AttributePath {
                 parts: [
                  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: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "type",
                position: (887, 19),
               },
              ],
             },
             to: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "opt",
                position: (887, 26),
               },
               attribute_path: AttributePath {
                parts: [
                 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 {
                 parts: [
                  Raw {
                   content: "options",
                   position: (887, 55),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "options",
                position: (887, 64),
               },
              ],
             },
             to: List {
              elements: [],
              position: (887, 74),
             },
            },
           ],
           recursive: false,
           position: (887, 17),
          },
         ],
         position: (887, 14),
        },
        position: (885, 5),
       },
       position: (884, 26),
      },
      position: (884, 21),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkIf",
        position: (892, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "condition",
      },
      definition: Function {
       argument: Simple {
        identifier: "content",
       },
       definition: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "_type",
             position: (893, 7),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "if",
             position: (893, 16),
            },
           ],
           position: (893, 15),
          },
         },
         Inherit {
          from: None,
          attributes: [
           Raw {
            content: "condition",
            position: (894, 15),
           },
           Raw {
            content: "content",
            position: (894, 25),
           },
          ],
         },
        ],
        recursive: false,
        position: (893, 5),
       },
       position: (892, 21),
      },
      position: (892, 10),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkAssert",
        position: (897, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "assertion",
      },
      definition: Function {
       argument: Simple {
        identifier: "message",
       },
       definition: Function {
        argument: Simple {
         identifier: "content",
        },
        definition: FunctionApplication {
         function: Variable {
          identifier: "mkIf",
          position: (898, 5),
         },
         arguments: [
          Parentheses {
           expression: 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: ",
                 position: (899, 43),
                },
                Expression {
                 expression: Variable {
                  identifier: "message",
                  position: (899, 65),
                 },
                },
               ],
               position: (899, 42),
              },
             ],
            },
            position: (899, 8),
           },
           position: (899, 7),
          },
          Variable {
           identifier: "content",
           position: (900, 7),
          },
         ],
        },
        position: (897, 34),
       },
       position: (897, 25),
      },
      position: (897, 14),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkMerge",
        position: (902, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "contents",
      },
      definition: Map {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "_type",
            position: (903, 7),
           },
          ],
         },
         to: String {
          parts: [
           Raw {
            content: "merge",
            position: (903, 16),
           },
          ],
          position: (903, 15),
         },
        },
        Inherit {
         from: None,
         attributes: [
          Raw {
           content: "contents",
           position: (904, 15),
          },
         ],
        },
       ],
       recursive: false,
       position: (903, 5),
      },
      position: (902, 13),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkOverride",
        position: (907, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "priority",
      },
      definition: Function {
       argument: Simple {
        identifier: "content",
       },
       definition: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "_type",
             position: (908, 7),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "override",
             position: (908, 16),
            },
           ],
           position: (908, 15),
          },
         },
         Inherit {
          from: None,
          attributes: [
           Raw {
            content: "priority",
            position: (909, 15),
           },
           Raw {
            content: "content",
            position: (909, 24),
           },
          ],
         },
        ],
        recursive: false,
        position: (908, 5),
       },
       position: (907, 26),
      },
      position: (907, 16),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkOptionDefault",
        position: (912, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "mkOverride",
       position: (912, 21),
      },
      arguments: [
       Int {
        value: 1500,
        position: (912, 32),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkDefault",
        position: (913, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "mkOverride",
       position: (913, 15),
      },
      arguments: [
       Int {
        value: 1000,
        position: (913, 26),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkImageMediaOverride",
        position: (914, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "mkOverride",
       position: (914, 26),
      },
      arguments: [
       Int {
        value: 60,
        position: (914, 37),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkForce",
        position: (915, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "mkOverride",
       position: (915, 13),
      },
      arguments: [
       Int {
        value: 50,
        position: (915, 24),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkVMOverride",
        position: (916, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "mkOverride",
       position: (916, 18),
      },
      arguments: [
       Int {
        value: 10,
        position: (916, 29),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkFixStrictness",
        position: (918, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (918, 21),
       },
       attribute_path: AttributePath {
        parts: [
         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, 31),
         },
        ],
        position: (918, 30),
       },
       Variable {
        identifier: "id",
        position: (918, 157),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkOrder",
        position: (920, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "priority",
      },
      definition: Function {
       argument: Simple {
        identifier: "content",
       },
       definition: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "_type",
             position: (921, 7),
            },
           ],
          },
          to: String {
           parts: [
            Raw {
             content: "order",
             position: (921, 16),
            },
           ],
           position: (921, 15),
          },
         },
         Inherit {
          from: None,
          attributes: [
           Raw {
            content: "priority",
            position: (922, 15),
           },
           Raw {
            content: "content",
            position: (922, 24),
           },
          ],
         },
        ],
        recursive: false,
        position: (921, 5),
       },
       position: (920, 23),
      },
      position: (920, 13),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkBefore",
        position: (925, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "mkOrder",
       position: (925, 14),
      },
      arguments: [
       Int {
        value: 500,
        position: (925, 22),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkAfter",
        position: (926, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "mkOrder",
       position: (926, 13),
      },
      arguments: [
       Int {
        value: 1500,
        position: (926, 21),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "defaultPriority",
        position: (929, 3),
       },
      ],
     },
     to: Int {
      value: 100,
      position: (929, 21),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkAliasDefinitions",
        position: (950, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "mkAliasAndWrapDefinitions",
       position: (950, 24),
      },
      arguments: [
       Variable {
        identifier: "id",
        position: (950, 50),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkAliasAndWrapDefinitions",
        position: (951, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "wrap",
      },
      definition: Function {
       argument: Simple {
        identifier: "option",
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "mkAliasIfDef",
         position: (952, 5),
        },
        arguments: [
         Variable {
          identifier: "option",
          position: (952, 18),
         },
         Parentheses {
          expression: FunctionApplication {
           function: Variable {
            identifier: "wrap",
            position: (952, 26),
           },
           arguments: [
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "mkMerge",
               position: (952, 32),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "option",
                 position: (952, 40),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "definitions",
                   position: (952, 47),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
             position: (952, 31),
            },
           ],
          },
          position: (952, 25),
         },
        ],
       },
       position: (951, 37),
      },
      position: (951, 31),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkAliasAndWrapDefsWithPriority",
        position: (958, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "wrap",
      },
      definition: Function {
       argument: Simple {
        identifier: "option",
       },
       definition: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "prio",
             position: (960, 7),
            },
           ],
          },
          to: PropertyAccess {
           expression: Variable {
            identifier: "option",
            position: (960, 14),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "highestPrio",
              position: (960, 21),
             },
            ],
           },
           default: Some(
            Variable {
             identifier: "defaultPriority",
             position: (960, 36),
            },
           ),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "defsWithPrio",
             position: (961, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "map",
            position: (961, 22),
           },
           arguments: [
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "mkOverride",
               position: (961, 27),
              },
              arguments: [
               Variable {
                identifier: "prio",
                position: (961, 38),
               },
              ],
             },
             position: (961, 26),
            },
            PropertyAccess {
             expression: Variable {
              identifier: "option",
              position: (961, 44),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "definitions",
                position: (961, 51),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
        ],
        target: FunctionApplication {
         function: Variable {
          identifier: "mkAliasIfDef",
          position: (962, 8),
         },
         arguments: [
          Variable {
           identifier: "option",
           position: (962, 21),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "wrap",
             position: (962, 29),
            },
            arguments: [
             Parentheses {
              expression: FunctionApplication {
               function: Variable {
                identifier: "mkMerge",
                position: (962, 35),
               },
               arguments: [
                Variable {
                 identifier: "defsWithPrio",
                 position: (962, 43),
                },
               ],
              },
              position: (962, 34),
             },
            ],
           },
           position: (962, 28),
          },
         ],
        },
        position: (959, 5),
       },
       position: (958, 42),
      },
      position: (958, 36),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkAliasIfDef",
        position: (964, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "option",
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (965, 5),
       },
       arguments: [
        Parentheses {
         expression: 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 {
             parts: [
              Raw {
               content: "isDefined",
               position: (965, 37),
              },
             ],
            },
            default: None,
           },
          ],
          position: (965, 27),
         },
         position: (965, 10),
        },
       ],
      },
      position: (964, 18),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "fixMergeModules",
        position: (968, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "modules",
      },
      definition: Function {
       argument: Simple {
        identifier: "args",
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "evalModules",
         position: (968, 36),
        },
        arguments: [
         Map {
          bindings: [
           Inherit {
            from: None,
            attributes: [
             Raw {
              content: "modules",
              position: (968, 58),
             },
             Raw {
              content: "args",
              position: (968, 66),
             },
            ],
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "check",
               position: (968, 72),
              },
             ],
            },
            to: Variable {
             identifier: "false",
             position: (968, 80),
            },
           },
          ],
          recursive: false,
          position: (968, 48),
         },
        ],
       },
       position: (968, 30),
      },
      position: (968, 21),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkRemovedOptionModule",
        position: (983, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "optionName",
      },
      definition: Function {
       argument: Simple {
        identifier: "replacementInstructions",
       },
       definition: Function {
        argument: Destructured {
         identifier: None,
         arguments: [
          DestructuredArgument {
           identifier: "options",
           default: None,
          },
         ],
         ellipsis: true,
        },
        definition: Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "options",
              position: (985, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "setAttrByPath",
             position: (985, 17),
            },
            arguments: [
             Variable {
              identifier: "optionName",
              position: (985, 31),
             },
             Parentheses {
              expression: FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (985, 43),
               },
               arguments: [
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "visible",
                      position: (986, 9),
                     },
                    ],
                   },
                   to: Variable {
                    identifier: "false",
                    position: (986, 19),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "apply",
                      position: (987, 9),
                     },
                    ],
                   },
                   to: Function {
                    argument: Simple {
                     identifier: "x",
                    },
                    definition: FunctionApplication {
                     function: Variable {
                      identifier: "throw",
                      position: (987, 20),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "The option `",
                         position: (987, 27),
                        },
                        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. ",
                         position: (987, 63),
                        },
                        Expression {
                         expression: Variable {
                          identifier: "replacementInstructions",
                          position: (987, 114),
                         },
                        },
                       ],
                       position: (987, 26),
                      },
                     ],
                    },
                    position: (987, 17),
                   },
                  },
                 ],
                 recursive: false,
                 position: (985, 52),
                },
               ],
              },
              position: (985, 42),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "config",
              position: (989, 7),
             },
             Raw {
              content: "assertions",
              position: (989, 14),
             },
            ],
           },
           to: LetIn {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "opt",
                 position: (990, 13),
                },
               ],
              },
              to: 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: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "assertion",
                    position: (991, 11),
                   },
                  ],
                 },
                 to: UnaryOperation {
                  operator: Not,
                  operand: PropertyAccess {
                   expression: Variable {
                    identifier: "opt",
                    position: (991, 24),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "isDefined",
                      position: (991, 28),
                     },
                    ],
                   },
                   default: None,
                  },
                  position: (991, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "message",
                    position: (992, 11),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "The option definition `",
                    position: (993, 1),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "showOption",
                      position: (993, 38),
                     },
                     arguments: [
                      Variable {
                       identifier: "optionName",
                       position: (993, 49),
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "' in ",
                    position: (993, 60),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "showFiles",
                      position: (993, 67),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (993, 77),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "files",
                          position: (993, 81),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   },
                   Raw {
                    content: " no longer has any effect; please remove it.\n",
                    position: (993, 87),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "replacementInstructions",
                     position: (994, 15),
                    },
                   },
                   Raw {
                    content: "\n",
                    position: (994, 39),
                   },
                  ],
                  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),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkRenamedOptionModule",
        position: (1012, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "from",
      },
      definition: Function {
       argument: Simple {
        identifier: "to",
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "doRename",
         position: (1012, 37),
        },
        arguments: [
         Map {
          bindings: [
           Inherit {
            from: None,
            attributes: [
             Raw {
              content: "from",
              position: (1013, 13),
             },
             Raw {
              content: "to",
              position: (1013, 18),
             },
            ],
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "visible",
               position: (1014, 5),
              },
             ],
            },
            to: Variable {
             identifier: "false",
             position: (1014, 15),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "warn",
               position: (1015, 5),
              },
             ],
            },
            to: Variable {
             identifier: "true",
             position: (1015, 12),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "use",
               position: (1016, 5),
              },
             ],
            },
            to: FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "builtins",
               position: (1016, 11),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "trace",
                 position: (1016, 20),
                },
               ],
              },
              default: None,
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "Obsolete option `",
                 position: (1016, 27),
                },
                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 `",
                 position: (1016, 62),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "showOption",
                   position: (1016, 94),
                  },
                  arguments: [
                   Variable {
                    identifier: "to",
                    position: (1016, 105),
                   },
                  ],
                 },
                },
                Raw {
                 content: "'.",
                 position: (1016, 108),
                },
               ],
               position: (1016, 26),
              },
             ],
            },
           },
          ],
          recursive: false,
          position: (1012, 46),
         },
        ],
       },
       position: (1012, 33),
      },
      position: (1012, 27),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkRenamedOptionModuleWith",
        position: (1019, 3),
       },
      ],
     },
     to: Function {
      argument: Destructured {
       identifier: None,
       arguments: [
        DestructuredArgument {
         identifier: "from",
         default: None,
        },
        DestructuredArgument {
         identifier: "to",
         default: None,
        },
        DestructuredArgument {
         identifier: "sinceRelease",
         default: None,
        },
       ],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "doRename",
        position: (1031, 6),
       },
       arguments: [
        Map {
         bindings: [
          Inherit {
           from: None,
           attributes: [
            Raw {
             content: "from",
             position: (1032, 13),
            },
            Raw {
             content: "to",
             position: (1032, 18),
            },
           ],
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "visible",
              position: (1033, 5),
             },
            ],
           },
           to: Variable {
            identifier: "false",
            position: (1033, 15),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "warn",
              position: (1034, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (1034, 12),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "isInOldestRelease",
                position: (1034, 16),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Variable {
              identifier: "sinceRelease",
              position: (1034, 34),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "use",
              position: (1035, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (1035, 11),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "warnIf",
                position: (1035, 15),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Parentheses {
              expression: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (1035, 23),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "isInOldestRelease",
                   position: (1035, 27),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Variable {
                 identifier: "sinceRelease",
                 position: (1035, 45),
                },
               ],
              },
              position: (1035, 22),
             },
             String {
              parts: [
               Raw {
                content: "Obsolete option `",
                position: (1036, 8),
               },
               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 `",
                position: (1036, 43),
               },
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "showOption",
                  position: (1036, 75),
                 },
                 arguments: [
                  Variable {
                   identifier: "to",
                   position: (1036, 86),
                  },
                 ],
                },
               },
               Raw {
                content: "'.",
                position: (1036, 89),
               },
              ],
              position: (1036, 7),
             },
            ],
           },
          },
         ],
         recursive: false,
         position: (1031, 15),
        },
       ],
      },
      position: (1019, 31),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkMergedOptionModule",
        position: (1067, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "from",
      },
      definition: Function {
       argument: Simple {
        identifier: "to",
       },
       definition: Function {
        argument: Simple {
         identifier: "mergeFn",
        },
        definition: Function {
         argument: Destructured {
          identifier: None,
          arguments: [
           DestructuredArgument {
            identifier: "config",
            default: None,
           },
           DestructuredArgument {
            identifier: "options",
            default: None,
           },
          ],
          ellipsis: true,
         },
         definition: Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "options",
               position: (1070, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "foldl'",
              position: (1070, 17),
             },
             arguments: [
              Variable {
               identifier: "recursiveUpdate",
               position: (1070, 24),
              },
              Map {
               bindings: [],
               recursive: false,
               position: (1070, 40),
              },
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "map",
                 position: (1070, 44),
                },
                arguments: [
                 Parentheses {
                  expression: Function {
                   argument: Simple {
                    identifier: "path",
                   },
                   definition: FunctionApplication {
                    function: Variable {
                     identifier: "setAttrByPath",
                     position: (1070, 55),
                    },
                    arguments: [
                     Variable {
                      identifier: "path",
                      position: (1070, 69),
                     },
                     Parentheses {
                      expression: FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (1070, 75),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          Binding {
                           from: AttributePath {
                            parts: [
                             Raw {
                              content: "visible",
                              position: (1071, 9),
                             },
                            ],
                           },
                           to: Variable {
                            identifier: "false",
                            position: (1071, 19),
                           },
                          },
                          Binding {
                           from: AttributePath {
                            parts: [
                             Raw {
                              content: "default",
                              position: (1073, 9),
                             },
                            ],
                           },
                           to: String {
                            parts: [
                             Raw {
                              content: "_mkMergedOptionModule",
                              position: (1073, 20),
                             },
                            ],
                            position: (1073, 19),
                           },
                          },
                         ],
                         recursive: false,
                         position: (1070, 84),
                        },
                       ],
                      },
                      position: (1070, 74),
                     },
                    ],
                   },
                   position: (1070, 49),
                  },
                  position: (1070, 48),
                 },
                 Variable {
                  identifier: "from",
                  position: (1074, 11),
                 },
                ],
               },
               position: (1070, 43),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "config",
               position: (1076, 7),
              },
             ],
            },
            to: BinaryOperation {
             operator: Update,
             operands: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "warnings",
                    position: (1077, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "filter",
                   position: (1077, 20),
                  },
                  arguments: [
                   Parentheses {
                    expression: Function {
                     argument: Simple {
                      identifier: "x",
                     },
                     definition: BinaryOperation {
                      operator: NotEqualTo,
                      operands: [
                       Variable {
                        identifier: "x",
                        position: (1077, 31),
                       },
                       String {
                        parts: [],
                        position: (1077, 36),
                       },
                      ],
                      position: (1077, 33),
                     },
                     position: (1077, 28),
                    },
                    position: (1077, 27),
                   },
                   Parentheses {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "map",
                      position: (1077, 41),
                     },
                     arguments: [
                      Parentheses {
                       expression: Function {
                        argument: Simple {
                         identifier: "f",
                        },
                        definition: LetIn {
                         bindings: [
                          Binding {
                           from: AttributePath {
                            parts: [
                             Raw {
                              content: "val",
                              position: (1078, 15),
                             },
                            ],
                           },
                           to: FunctionApplication {
                            function: Variable {
                             identifier: "getAttrFromPath",
                             position: (1078, 21),
                            },
                            arguments: [
                             Variable {
                              identifier: "f",
                              position: (1078, 37),
                             },
                             Variable {
                              identifier: "config",
                              position: (1078, 39),
                             },
                            ],
                           },
                          },
                          Binding {
                           from: AttributePath {
                            parts: [
                             Raw {
                              content: "opt",
                              position: (1079, 15),
                             },
                            ],
                           },
                           to: 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: [
                           Parentheses {
                            expression: BinaryOperation {
                             operator: NotEqualTo,
                             operands: [
                              Variable {
                               identifier: "val",
                               position: (1082, 14),
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "_mkMergedOptionModule",
                                 position: (1082, 22),
                                },
                               ],
                               position: (1082, 21),
                              },
                             ],
                             position: (1082, 18),
                            },
                            position: (1082, 13),
                           },
                           String {
                            parts: [
                             Raw {
                              content: "The option `",
                              position: (1083, 14),
                             },
                             Expression {
                              expression: FunctionApplication {
                               function: Variable {
                                identifier: "showOption",
                                position: (1083, 28),
                               },
                               arguments: [
                                Variable {
                                 identifier: "f",
                                 position: (1083, 39),
                                },
                               ],
                              },
                             },
                             Raw {
                              content: "' defined in ",
                              position: (1083, 41),
                             },
                             Expression {
                              expression: FunctionApplication {
                               function: Variable {
                                identifier: "showFiles",
                                position: (1083, 56),
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "opt",
                                  position: (1083, 66),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "files",
                                    position: (1083, 70),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             },
                             Raw {
                              content: " has been changed to `",
                              position: (1083, 76),
                             },
                             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 `",
                              position: (1083, 114),
                             },
                             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, 172),
                             },
                            ],
                            position: (1083, 13),
                           },
                          ],
                         },
                         position: (1078, 11),
                        },
                        position: (1077, 46),
                       },
                       position: (1077, 45),
                      },
                      Variable {
                       identifier: "from",
                       position: (1084, 11),
                      },
                     ],
                    },
                    position: (1077, 40),
                   },
                  ],
                 },
                },
               ],
               recursive: false,
               position: (1076, 16),
              },
              FunctionApplication {
               function: Variable {
                identifier: "setAttrByPath",
                position: (1085, 12),
               },
               arguments: [
                Variable {
                 identifier: "to",
                 position: (1085, 26),
                },
                Parentheses {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "mkMerge",
                   position: (1085, 30),
                  },
                  arguments: [
                   Parentheses {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "optional",
                      position: (1086, 15),
                     },
                     arguments: [
                      Parentheses {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "any",
                         position: (1087, 17),
                        },
                        arguments: [
                         Parentheses {
                          expression: Function {
                           argument: Simple {
                            identifier: "f",
                           },
                           definition: BinaryOperation {
                            operator: NotEqualTo,
                            operands: [
                             Parentheses {
                              expression: FunctionApplication {
                               function: Variable {
                                identifier: "getAttrFromPath",
                                position: (1087, 26),
                               },
                               arguments: [
                                Variable {
                                 identifier: "f",
                                 position: (1087, 42),
                                },
                                Variable {
                                 identifier: "config",
                                 position: (1087, 44),
                                },
                               ],
                              },
                              position: (1087, 25),
                             },
                             String {
                              parts: [
                               Raw {
                                content: "_mkMergedOptionModule",
                                position: (1087, 56),
                               },
                              ],
                              position: (1087, 55),
                             },
                            ],
                            position: (1087, 52),
                           },
                           position: (1087, 22),
                          },
                          position: (1087, 21),
                         },
                         Variable {
                          identifier: "from",
                          position: (1087, 80),
                         },
                        ],
                       },
                       position: (1087, 16),
                      },
                      Parentheses {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "mergeFn",
                         position: (1088, 17),
                        },
                        arguments: [
                         Variable {
                          identifier: "config",
                          position: (1088, 25),
                         },
                        ],
                       },
                       position: (1088, 16),
                      },
                     ],
                    },
                    position: (1086, 14),
                   },
                  ],
                 },
                 position: (1085, 29),
                },
               ],
              },
             ],
             position: (1085, 9),
            },
           },
          ],
          recursive: false,
          position: (1069, 5),
         },
         position: (1068, 5),
        },
        position: (1067, 36),
       },
       position: (1067, 32),
      },
      position: (1067, 26),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkChangedOptionModule",
        position: (1114, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "from",
      },
      definition: Function {
       argument: Simple {
        identifier: "to",
       },
       definition: Function {
        argument: Simple {
         identifier: "changeFn",
        },
        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),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkAliasOptionModule",
        position: (1118, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "from",
      },
      definition: Function {
       argument: Simple {
        identifier: "to",
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "doRename",
         position: (1118, 35),
        },
        arguments: [
         Map {
          bindings: [
           Inherit {
            from: None,
            attributes: [
             Raw {
              content: "from",
              position: (1119, 13),
             },
             Raw {
              content: "to",
              position: (1119, 18),
             },
            ],
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "visible",
               position: (1120, 5),
              },
             ],
            },
            to: Variable {
             identifier: "true",
             position: (1120, 15),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "warn",
               position: (1121, 5),
              },
             ],
            },
            to: Variable {
             identifier: "false",
             position: (1121, 12),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "use",
               position: (1122, 5),
              },
             ],
            },
            to: Variable {
             identifier: "id",
             position: (1122, 11),
            },
           },
          ],
          recursive: false,
          position: (1118, 44),
         },
        ],
       },
       position: (1118, 31),
      },
      position: (1118, 25),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkDerivedConfig",
        position: (1140, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "opt",
      },
      definition: Function {
       argument: Simple {
        identifier: "f",
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "mkOverride",
         position: (1141, 5),
        },
        arguments: [
         Parentheses {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "opt",
            position: (1142, 8),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "highestPrio",
              position: (1142, 12),
             },
            ],
           },
           default: Some(
            Variable {
             identifier: "defaultPriority",
             position: (1142, 27),
            },
           ),
          },
          position: (1142, 7),
         },
         Parentheses {
          expression: FunctionApplication {
           function: Variable {
            identifier: "f",
            position: (1143, 8),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "opt",
              position: (1143, 10),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "value",
                position: (1143, 14),
               },
              ],
             },
             default: None,
            },
           ],
          },
          position: (1143, 7),
         },
        ],
       },
       position: (1140, 26),
      },
      position: (1140, 21),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "doRename",
        position: (1145, 3),
       },
      ],
     },
     to: Function {
      argument: Destructured {
       identifier: None,
       arguments: [
        DestructuredArgument {
         identifier: "from",
         default: None,
        },
        DestructuredArgument {
         identifier: "to",
         default: None,
        },
        DestructuredArgument {
         identifier: "visible",
         default: None,
        },
        DestructuredArgument {
         identifier: "warn",
         default: None,
        },
        DestructuredArgument {
         identifier: "use",
         default: None,
        },
        DestructuredArgument {
         identifier: "withPriority",
         default: Some(
          Variable {
           identifier: "true",
           position: (1145, 61),
          },
         ),
        },
       ],
       ellipsis: false,
      },
      definition: Function {
       argument: Destructured {
        identifier: None,
        arguments: [
         DestructuredArgument {
          identifier: "config",
          default: None,
         },
         DestructuredArgument {
          identifier: "options",
          default: None,
         },
        ],
        ellipsis: true,
       },
       definition: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "fromOpt",
             position: (1148, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "getAttrFromPath",
            position: (1148, 17),
           },
           arguments: [
            Variable {
             identifier: "from",
             position: (1148, 33),
            },
            Variable {
             identifier: "options",
             position: (1148, 38),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "toOf",
             position: (1149, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "attrByPath",
            position: (1149, 14),
           },
           arguments: [
            Variable {
             identifier: "to",
             position: (1149, 25),
            },
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "abort",
               position: (1150, 10),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "Renaming error: option `",
                  position: (1150, 17),
                 },
                 Expression {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "showOption",
                    position: (1150, 43),
                   },
                   arguments: [
                    Variable {
                     identifier: "to",
                     position: (1150, 54),
                    },
                   ],
                  },
                 },
                 Raw {
                  content: "' does not exist.",
                  position: (1150, 57),
                 },
                ],
                position: (1150, 16),
               },
              ],
             },
             position: (1150, 9),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "toType",
             position: (1151, 7),
            },
           ],
          },
          to: LetIn {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "opt",
                position: (1151, 20),
               },
              ],
             },
             to: 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 {
             parts: [
              Raw {
               content: "type",
               position: (1151, 59),
              },
             ],
            },
            default: Some(
             Parentheses {
              expression: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (1151, 68),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "submodule",
                   position: (1151, 74),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Map {
                 bindings: [],
                 recursive: false,
                 position: (1151, 84),
                },
               ],
              },
              position: (1151, 67),
             },
            ),
           },
           position: (1151, 16),
          },
         },
        ],
        target: Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "options",
              position: (1154, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "setAttrByPath",
             position: (1154, 17),
            },
            arguments: [
             Variable {
              identifier: "from",
              position: (1154, 31),
             },
             Parentheses {
              expression: BinaryOperation {
               operator: Update,
               operands: [
                FunctionApplication {
                 function: Variable {
                  identifier: "mkOption",
                  position: (1154, 37),
                 },
                 arguments: [
                  Map {
                   bindings: [
                    Inherit {
                     from: None,
                     attributes: [
                      Raw {
                       content: "visible",
                       position: (1155, 17),
                      },
                     ],
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "description",
                        position: (1156, 9),
                       },
                      ],
                     },
                     to: String {
                      parts: [
                       Raw {
                        content: "Alias of <option>",
                        position: (1156, 24),
                       },
                       Expression {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "showOption",
                          position: (1156, 43),
                         },
                         arguments: [
                          Variable {
                           identifier: "to",
                           position: (1156, 54),
                          },
                         ],
                        },
                       },
                       Raw {
                        content: "</option>.",
                        position: (1156, 57),
                       },
                      ],
                      position: (1156, 23),
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "apply",
                        position: (1157, 9),
                       },
                      ],
                     },
                     to: Function {
                      argument: Simple {
                       identifier: "x",
                      },
                      definition: FunctionApplication {
                       function: Variable {
                        identifier: "use",
                        position: (1157, 20),
                       },
                       arguments: [
                        Parentheses {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "toOf",
                           position: (1157, 25),
                          },
                          arguments: [
                           Variable {
                            identifier: "config",
                            position: (1157, 30),
                           },
                          ],
                         },
                         position: (1157, 24),
                        },
                       ],
                      },
                      position: (1157, 17),
                     },
                    },
                   ],
                   recursive: false,
                   position: (1154, 46),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optionalAttrs",
                  position: (1158, 12),
                 },
                 arguments: [
                  Parentheses {
                   expression: BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     Variable {
                      identifier: "toType",
                      position: (1158, 27),
                     },
                     Variable {
                      identifier: "null",
                      position: (1158, 37),
                     },
                    ],
                    position: (1158, 34),
                   },
                   position: (1158, 26),
                  },
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "type",
                        position: (1159, 9),
                       },
                      ],
                     },
                     to: Variable {
                      identifier: "toType",
                      position: (1159, 16),
                     },
                    },
                   ],
                   recursive: false,
                   position: (1158, 43),
                  },
                 ],
                },
               ],
               position: (1158, 9),
              },
              position: (1154, 36),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "config",
              position: (1161, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkMerge",
             position: (1161, 16),
            },
            arguments: [
             List {
              elements: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "warnings",
                     position: (1163, 11),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: Variable {
                    identifier: "optional",
                    position: (1163, 22),
                   },
                   arguments: [
                    Parentheses {
                     expression: BinaryOperation {
                      operator: LogicalAnd,
                      operands: [
                       Variable {
                        identifier: "warn",
                        position: (1163, 32),
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "fromOpt",
                         position: (1163, 40),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "isDefined",
                           position: (1163, 48),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                      position: (1163, 37),
                     },
                     position: (1163, 31),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "The option `",
                       position: (1164, 14),
                      },
                      Expression {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "showOption",
                         position: (1164, 28),
                        },
                        arguments: [
                         Variable {
                          identifier: "from",
                          position: (1164, 39),
                         },
                        ],
                       },
                      },
                      Raw {
                       content: "' defined in ",
                       position: (1164, 44),
                      },
                      Expression {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "showFiles",
                         position: (1164, 59),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "fromOpt",
                           position: (1164, 69),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "files",
                             position: (1164, 77),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                      },
                      Raw {
                       content: " has been renamed to `",
                       position: (1164, 83),
                      },
                      Expression {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "showOption",
                         position: (1164, 107),
                        },
                        arguments: [
                         Variable {
                          identifier: "to",
                          position: (1164, 118),
                         },
                        ],
                       },
                      },
                      Raw {
                       content: "'.",
                       position: (1164, 121),
                      },
                     ],
                     position: (1164, 13),
                    },
                   ],
                  },
                 },
                ],
                recursive: false,
                position: (1162, 9),
               },
               Parentheses {
                expression: IfThenElse {
                 predicate: Variable {
                  identifier: "withPriority",
                  position: (1166, 13),
                 },
                 then: FunctionApplication {
                  function: Variable {
                   identifier: "mkAliasAndWrapDefsWithPriority",
                   position: (1167, 16),
                  },
                  arguments: [
                   Parentheses {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "setAttrByPath",
                      position: (1167, 48),
                     },
                     arguments: [
                      Variable {
                       identifier: "to",
                       position: (1167, 62),
                      },
                     ],
                    },
                    position: (1167, 47),
                   },
                   Variable {
                    identifier: "fromOpt",
                    position: (1167, 66),
                   },
                  ],
                 },
                 else_: FunctionApplication {
                  function: Variable {
                   identifier: "mkAliasAndWrapDefinitions",
                   position: (1168, 16),
                  },
                  arguments: [
                   Parentheses {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "setAttrByPath",
                      position: (1168, 43),
                     },
                     arguments: [
                      Variable {
                       identifier: "to",
                       position: (1168, 57),
                      },
                     ],
                    },
                    position: (1168, 42),
                   },
                   Variable {
                    identifier: "fromOpt",
                    position: (1168, 61),
                   },
                  ],
                 },
                 position: (1166, 10),
                },
                position: (1166, 9),
               },
              ],
              position: (1161, 24),
             },
            ],
           },
          },
         ],
         recursive: false,
         position: (1153, 5),
        },
        position: (1147, 5),
       },
       position: (1146, 5),
      },
      position: (1145, 14),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "importJSON",
        position: (1176, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "file",
      },
      definition: Map {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "_file",
            position: (1177, 5),
           },
          ],
         },
         to: Variable {
          identifier: "file",
          position: (1177, 13),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "config",
            position: (1178, 5),
           },
          ],
         },
         to: FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (1178, 14),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "importJSON",
              position: (1178, 18),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Variable {
            identifier: "file",
            position: (1178, 29),
           },
          ],
         },
        },
       ],
       recursive: false,
       position: (1176, 22),
      },
      position: (1176, 16),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "importTOML",
        position: (1185, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "file",
      },
      definition: Map {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "_file",
            position: (1186, 5),
           },
          ],
         },
         to: Variable {
          identifier: "file",
          position: (1186, 13),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "config",
            position: (1187, 5),
           },
          ],
         },
         to: FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (1187, 14),
           },
           attribute_path: AttributePath {
            parts: [
             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),
}