---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
  ],
  ellipsis: false,
 },
 definition: LetIn {
  bindings: [
   Inherit(
    Some(
     Variable {
      identifier: "lib",
      position: (4, 12),
     },
    ),
    [
     Raw {
      content: "all",
      position: (5, 5),
     },
     Raw {
      content: "any",
      position: (6, 5),
     },
     Raw {
      content: "attrByPath",
      position: (7, 5),
     },
     Raw {
      content: "attrNames",
      position: (8, 5),
     },
     Raw {
      content: "catAttrs",
      position: (9, 5),
     },
     Raw {
      content: "concatLists",
      position: (10, 5),
     },
     Raw {
      content: "concatMap",
      position: (11, 5),
     },
     Raw {
      content: "count",
      position: (12, 5),
     },
     Raw {
      content: "elem",
      position: (13, 5),
     },
     Raw {
      content: "filter",
      position: (14, 5),
     },
     Raw {
      content: "findFirst",
      position: (15, 5),
     },
     Raw {
      content: "foldl'",
      position: (16, 5),
     },
     Raw {
      content: "getAttrFromPath",
      position: (17, 5),
     },
     Raw {
      content: "head",
      position: (18, 5),
     },
     Raw {
      content: "id",
      position: (19, 5),
     },
     Raw {
      content: "imap1",
      position: (20, 5),
     },
     Raw {
      content: "isAttrs",
      position: (21, 5),
     },
     Raw {
      content: "isBool",
      position: (22, 5),
     },
     Raw {
      content: "isFunction",
      position: (23, 5),
     },
     Raw {
      content: "isList",
      position: (24, 5),
     },
     Raw {
      content: "isString",
      position: (25, 5),
     },
     Raw {
      content: "length",
      position: (26, 5),
     },
     Raw {
      content: "mapAttrs",
      position: (27, 5),
     },
     Raw {
      content: "mapAttrsToList",
      position: (28, 5),
     },
     Raw {
      content: "mapAttrsRecursiveCond",
      position: (29, 5),
     },
     Raw {
      content: "min",
      position: (30, 5),
     },
     Raw {
      content: "optional",
      position: (31, 5),
     },
     Raw {
      content: "optionalAttrs",
      position: (32, 5),
     },
     Raw {
      content: "optionalString",
      position: (33, 5),
     },
     Raw {
      content: "recursiveUpdate",
      position: (34, 5),
     },
     Raw {
      content: "reverseList",
      position: (35, 5),
     },
     Raw {
      content: "sort",
      position: (35, 17),
     },
     Raw {
      content: "setAttrByPath",
      position: (36, 5),
     },
     Raw {
      content: "toList",
      position: (37, 5),
     },
     Raw {
      content: "types",
      position: (38, 5),
     },
     Raw {
      content: "warnIf",
      position: (39, 5),
     },
     Raw {
      content: "zipAttrsWith",
      position: (40, 5),
     },
    ],
   ),
   Inherit(
    Some(
     PropertyAccess {
      expression: Variable {
       identifier: "lib",
       position: (42, 12),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (42, 16),
        },
       ],
      },
      default: None,
     },
    ),
    [
     Raw {
      content: "isOption",
      position: (43, 5),
     },
     Raw {
      content: "mkOption",
      position: (44, 5),
     },
     Raw {
      content: "showDefs",
      position: (45, 5),
     },
     Raw {
      content: "showFiles",
      position: (46, 5),
     },
     Raw {
      content: "showOption",
      position: (47, 5),
     },
     Raw {
      content: "unknownModule",
      position: (48, 5),
     },
    ],
   ),
  ],
  target: Map {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "evalModules",
        position: (89, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "evalModulesArgs",
      ),
      arguments: FunctionArguments {
       arguments: [
        FunctionArgument {
         identifier: "check",
         default: Some(
          Variable {
           identifier: "true",
           position: (100, 27),
          },
         ),
        },
        FunctionArgument {
         identifier: "args",
         default: Some(
          Map {
           bindings: [],
           recursive: false,
           position: (98, 26),
          },
         ),
        },
        FunctionArgument {
         identifier: "specialArgs",
         default: Some(
          Map {
           bindings: [],
           recursive: false,
           position: (96, 33),
          },
         ),
        },
        FunctionArgument {
         identifier: "prefix",
         default: Some(
          List {
           elements: [],
           position: (91, 28),
          },
         ),
        },
        FunctionArgument {
         identifier: "modules",
         default: None,
        },
       ],
       ellipsis: false,
      },
      definition: LetIn {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "withWarnings",
            position: (103, 7),
           },
          ],
         },
         Function {
          argument: Some(
           "x",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (104, 9),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "warnIf",
               position: (104, 13),
              },
             ],
            },
            default: None,
           },
           arguments: [
            HasProperty {
             expression: Variable {
              identifier: "evalModulesArgs",
              position: (104, 21),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "args",
                position: (104, 37),
               },
              ],
             },
             position: (104, 36),
            },
            String {
             parts: [
              Raw {
               content: "The args argument to evalModules is deprecated. Please set config._module.args instead.",
               position: (104, 44),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (105, 9),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "warnIf",
                position: (105, 13),
               },
              ],
             },
             default: None,
            },
            HasProperty {
             expression: Variable {
              identifier: "evalModulesArgs",
              position: (105, 21),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "check",
                position: (105, 37),
               },
              ],
             },
             position: (105, 36),
            },
            String {
             parts: [
              Raw {
               content: "The check argument to evalModules is deprecated. Please set config._module.check instead.",
               position: (105, 45),
              },
             ],
            },
            Variable {
             identifier: "x",
             position: (106, 9),
            },
           ],
          },
          position: (103, 22),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "legacyModules",
            position: (108, 7),
           },
          ],
         },
         BinaryOperation {
          operator: Concatenation,
          operands: [
           FunctionApplication {
            function: Variable {
             identifier: "optional",
             position: (109, 9),
            },
            arguments: [
             HasProperty {
              expression: Variable {
               identifier: "evalModulesArgs",
               position: (109, 19),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "args",
                 position: (109, 35),
                },
               ],
              },
              position: (109, 34),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "config",
                   position: (110, 11),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "_module",
                      position: (111, 13),
                     },
                     Raw {
                      content: "args",
                      position: (111, 21),
                     },
                    ],
                   },
                   Variable {
                    identifier: "args",
                    position: (111, 28),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (110, 20),
                },
               ),
              ],
              recursive: false,
              position: (109, 41),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "optional",
             position: (114, 12),
            },
            arguments: [
             HasProperty {
              expression: Variable {
               identifier: "evalModulesArgs",
               position: (114, 22),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "check",
                 position: (114, 38),
                },
               ],
              },
              position: (114, 37),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "config",
                   position: (115, 11),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "_module",
                      position: (116, 13),
                     },
                     Raw {
                      content: "check",
                      position: (116, 21),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "mkDefault",
                     position: (116, 29),
                    },
                    arguments: [
                     Variable {
                      identifier: "check",
                      position: (116, 39),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (115, 20),
                },
               ),
              ],
              recursive: false,
              position: (114, 45),
             },
            ],
           },
          ],
          position: (114, 9),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "regularModules",
            position: (119, 7),
           },
          ],
         },
         BinaryOperation {
          operator: Concatenation,
          operands: [
           Variable {
            identifier: "modules",
            position: (119, 24),
           },
           Variable {
            identifier: "legacyModules",
            position: (119, 35),
           },
          ],
          position: (119, 32),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "internalModule",
            position: (128, 7),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "_file",
               position: (129, 9),
              },
             ],
            },
            Path {
             parts: [
              Raw {
               content: "./modules.nix",
               position: (129, 17),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "key",
               position: (131, 9),
              },
             ],
            },
            Variable {
             identifier: "_file",
             position: (131, 15),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "options",
               position: (133, 9),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "_module",
                  position: (134, 11),
                 },
                 Raw {
                  content: "args",
                  position: (134, 19),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (134, 26),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (141, 13),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (141, 20),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "lazyAttrsOf",
                         position: (141, 26),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (141, 38),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "raw",
                          position: (141, 44),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "internal",
                       position: (142, 13),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (142, 24),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (143, 13),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Arguments passed to each module.",
                       position: (143, 28),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (134, 35),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "_module",
                  position: (146, 11),
                 },
                 Raw {
                  content: "check",
                  position: (146, 19),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (146, 27),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (147, 13),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (147, 20),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bool",
                        position: (147, 26),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "internal",
                       position: (148, 13),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (148, 24),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (149, 13),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (149, 23),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (150, 13),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Whether to check whether all option definitions have matching declarations.",
                       position: (150, 28),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (146, 36),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "_module",
                  position: (153, 11),
                 },
                 Raw {
                  content: "freeformType",
                  position: (153, 19),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (153, 34),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (155, 13),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (155, 20),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "nullOr",
                         position: (155, 26),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "types",
                         position: (155, 34),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "uniq",
                           position: (155, 40),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "types",
                          position: (155, 45),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "attrs",
                            position: (155, 51),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "internal",
                       position: (156, 13),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (156, 24),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (157, 13),
                      },
                     ],
                    },
                    Variable {
                     identifier: "null",
                     position: (157, 23),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (158, 13),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "If set, merge all definitions that don't have an associated option\ntogether using this type. The result then gets combined with the\nvalues of all declared options to produce the final <literal>\nconfig</literal> value.\n\nIf this is <literal>null</literal>, definitions without an option\nwill throw an error unless <option>_module.check</option> is\nturned off.\n",
                       position: (159, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (153, 43),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (133, 19),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "config",
               position: (171, 9),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "_module",
                  position: (172, 11),
                 },
                 Raw {
                  content: "args",
                  position: (172, 19),
                 },
                ],
               },
               Map {
                bindings: [
                 Inherit(
                  None,
                  [
                   Raw {
                    content: "extendModules",
                    position: (173, 21),
                   },
                  ],
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "moduleType",
                     position: (174, 13),
                    },
                   ],
                  },
                  Variable {
                   identifier: "type",
                   position: (174, 26),
                  },
                 ),
                ],
                recursive: false,
                position: (172, 26),
               },
              ),
             ],
             recursive: false,
             position: (171, 18),
            },
           ),
          ],
          recursive: true,
          position: (128, 24),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "merged",
            position: (179, 7),
           },
          ],
         },
         LetIn {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "collected",
               position: (180, 13),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "collectModules",
              position: (180, 25),
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "specialArgs",
                position: (181, 12),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "modulesPath",
                  position: (181, 24),
                 },
                ],
               },
               default: Some(
                String {
                 parts: [],
                },
               ),
              },
              BinaryOperation {
               operator: Concatenation,
               operands: [
                Variable {
                 identifier: "regularModules",
                 position: (182, 12),
                },
                List {
                 elements: [
                  Variable {
                   identifier: "internalModule",
                   position: (182, 32),
                  },
                 ],
                 position: (182, 30),
                },
               ],
               position: (182, 27),
              },
              BinaryOperation {
               operator: Update,
               operands: [
                Map {
                 bindings: [
                  Inherit(
                   None,
                   [
                    Raw {
                     content: "lib",
                     position: (183, 22),
                    },
                    Raw {
                     content: "options",
                     position: (183, 26),
                    },
                    Raw {
                     content: "config",
                     position: (183, 34),
                    },
                    Raw {
                     content: "specialArgs",
                     position: (183, 41),
                    },
                   ],
                  ),
                 ],
                 recursive: false,
                 position: (183, 12),
                },
                Variable {
                 identifier: "specialArgs",
                 position: (183, 59),
                },
               ],
               position: (183, 56),
              },
             ],
            },
           ),
          ],
          target: FunctionApplication {
           function: Variable {
            identifier: "mergeModules",
            position: (184, 12),
           },
           arguments: [
            Variable {
             identifier: "prefix",
             position: (184, 25),
            },
            FunctionApplication {
             function: Variable {
              identifier: "reverseList",
              position: (184, 33),
             },
             arguments: [
              Variable {
               identifier: "collected",
               position: (184, 45),
              },
             ],
            },
           ],
          },
          position: (180, 9),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "options",
            position: (186, 7),
           },
          ],
         },
         PropertyAccess {
          expression: Variable {
           identifier: "merged",
           position: (186, 17),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "matchedOptions",
             position: (186, 24),
            },
           ],
          },
          default: None,
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "config",
            position: (188, 7),
           },
          ],
         },
         LetIn {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "declaredConfig",
               position: (192, 11),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mapAttrsRecursiveCond",
              position: (192, 28),
             },
             arguments: [
              Function {
               argument: Some(
                "v",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: UnaryOperation {
                operator: Not,
                operand: FunctionApplication {
                 function: Variable {
                  identifier: "isOption",
                  position: (192, 56),
                 },
                 arguments: [
                  Variable {
                   identifier: "v",
                   position: (192, 65),
                  },
                 ],
                },
                position: (192, 54),
               },
               position: (192, 51),
              },
              Function {
               argument: Some(
                "_",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: Function {
                argument: Some(
                 "v",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: PropertyAccess {
                 expression: Variable {
                  identifier: "v",
                  position: (192, 75),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "value",
                    position: (192, 77),
                   },
                  ],
                 },
                 default: None,
                },
                position: (192, 72),
               },
               position: (192, 69),
              },
              Variable {
               identifier: "options",
               position: (192, 84),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "freeformConfig",
               position: (195, 11),
              },
             ],
            },
            LetIn {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "defs",
                  position: (197, 15),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "map",
                 position: (197, 22),
                },
                arguments: [
                 Function {
                  argument: Some(
                   "def",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "file",
                        position: (198, 17),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "def",
                       position: (198, 24),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "file",
                         position: (198, 28),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "value",
                        position: (199, 17),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "setAttrByPath",
                       position: (199, 25),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "def",
                         position: (199, 39),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "prefix",
                           position: (199, 43),
                          },
                         ],
                        },
                        default: None,
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "def",
                         position: (199, 50),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "value",
                           position: (199, 54),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (197, 32),
                  },
                  position: (197, 27),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "merged",
                   position: (200, 18),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "unmatchedDefns",
                     position: (200, 25),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              ),
             ],
             target: IfThenElse {
              predicate: BinaryOperation {
               operator: EqualTo,
               operands: [
                Variable {
                 identifier: "defs",
                 position: (201, 19),
                },
                List {
                 elements: [],
                 position: (201, 27),
                },
               ],
               position: (201, 24),
              },
              then: Map {
               bindings: [],
               recursive: false,
               position: (201, 35),
              },
              else_: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "declaredConfig",
                 position: (202, 18),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "_module",
                   position: (202, 33),
                  },
                  Raw {
                   content: "freeformType",
                   position: (202, 41),
                  },
                  Raw {
                   content: "merge",
                   position: (202, 54),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Variable {
                 identifier: "prefix",
                 position: (202, 60),
                },
                Variable {
                 identifier: "defs",
                 position: (202, 67),
                },
               ],
              },
              position: (201, 16),
             },
             position: (196, 13),
            },
           ),
          ],
          target: IfThenElse {
           predicate: BinaryOperation {
            operator: EqualTo,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "declaredConfig",
               position: (204, 15),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "_module",
                 position: (204, 30),
                },
                Raw {
                 content: "freeformType",
                 position: (204, 38),
                },
               ],
              },
              default: None,
             },
             Variable {
              identifier: "null",
              position: (204, 54),
             },
            ],
            position: (204, 51),
           },
           then: Variable {
            identifier: "declaredConfig",
            position: (204, 64),
           },
           else_: FunctionApplication {
            function: Variable {
             identifier: "recursiveUpdate",
             position: (208, 16),
            },
            arguments: [
             Variable {
              identifier: "freeformConfig",
              position: (208, 32),
             },
             Variable {
              identifier: "declaredConfig",
              position: (208, 47),
             },
            ],
           },
           position: (204, 12),
          },
          position: (189, 9),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "checkUnmatched",
            position: (210, 7),
           },
          ],
         },
         IfThenElse {
          predicate: BinaryOperation {
           operator: LogicalAnd,
           operands: [
            BinaryOperation {
             operator: LogicalAnd,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (211, 12),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "_module",
                  position: (211, 19),
                 },
                 Raw {
                  content: "check",
                  position: (211, 27),
                 },
                ],
               },
               default: None,
              },
              BinaryOperation {
               operator: EqualTo,
               operands: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (211, 36),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "_module",
                    position: (211, 43),
                   },
                   Raw {
                    content: "freeformType",
                    position: (211, 51),
                   },
                  ],
                 },
                 default: None,
                },
                Variable {
                 identifier: "null",
                 position: (211, 67),
                },
               ],
               position: (211, 64),
              },
             ],
             position: (211, 33),
            },
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "merged",
                position: (211, 75),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "unmatchedDefns",
                  position: (211, 82),
                 },
                ],
               },
               default: None,
              },
              List {
               elements: [],
               position: (211, 100),
              },
             ],
             position: (211, 97),
            },
           ],
           position: (211, 72),
          },
          then: LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "firstDef",
                position: (213, 13),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "head",
               position: (213, 24),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "merged",
                 position: (213, 29),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "unmatchedDefns",
                   position: (213, 36),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "baseMsg",
                position: (214, 13),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "The option `",
                position: (214, 24),
               },
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "showOption",
                  position: (214, 38),
                 },
                 arguments: [
                  BinaryOperation {
                   operator: Concatenation,
                   operands: [
                    Variable {
                     identifier: "prefix",
                     position: (214, 50),
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "firstDef",
                      position: (214, 60),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "prefix",
                        position: (214, 69),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (214, 57),
                  },
                 ],
                },
               },
               Raw {
                content: "' does not exist. Definition values:",
                position: (214, 77),
               },
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "showDefs",
                  position: (214, 115),
                 },
                 arguments: [
                  List {
                   elements: [
                    Variable {
                     identifier: "firstDef",
                     position: (214, 126),
                    },
                   ],
                   position: (214, 124),
                  },
                 ],
                },
               },
              ],
             },
            ),
           ],
           target: IfThenElse {
            predicate: BinaryOperation {
             operator: EqualTo,
             operands: [
              FunctionApplication {
               function: Variable {
                identifier: "attrNames",
                position: (216, 16),
               },
               arguments: [
                Variable {
                 identifier: "options",
                 position: (216, 26),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "_module",
                   position: (216, 40),
                  },
                 ],
                },
               ],
               position: (216, 37),
              },
             ],
             position: (216, 34),
            },
            then: LetIn {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "optionName",
                  position: (219, 19),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "showOption",
                 position: (219, 32),
                },
                arguments: [
                 Variable {
                  identifier: "prefix",
                  position: (219, 43),
                 },
                ],
               },
              ),
             ],
             target: IfThenElse {
              predicate: BinaryOperation {
               operator: EqualTo,
               operands: [
                Variable {
                 identifier: "optionName",
                 position: (221, 22),
                },
                String {
                 parts: [],
                },
               ],
               position: (221, 33),
              },
              then: FunctionApplication {
               function: Variable {
                identifier: "throw",
                position: (222, 26),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "",
                   position: (223, 1),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "baseMsg",
                    position: (223, 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: (223, 33),
                  },
                 ],
                },
               ],
              },
              else_: FunctionApplication {
               function: Variable {
                identifier: "throw",
                position: (228, 21),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "",
                   position: (229, 1),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "baseMsg",
                    position: (229, 25),
                   },
                  },
                  Raw {
                   content: "\n\nHowever there are no options defined in `",
                   position: (229, 33),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "showOption",
                     position: (231, 66),
                    },
                    arguments: [
                     Variable {
                      identifier: "prefix",
                      position: (231, 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: (231, 84),
                  },
                 ],
                },
               ],
              },
              position: (221, 19),
             },
             position: (218, 17),
            },
            else_: FunctionApplication {
             function: Variable {
              identifier: "throw",
              position: (235, 18),
             },
             arguments: [
              Variable {
               identifier: "baseMsg",
               position: (235, 24),
              },
             ],
            },
            position: (216, 13),
           },
           position: (212, 11),
          },
          else_: Variable {
           identifier: "null",
           position: (236, 14),
          },
          position: (211, 9),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "checked",
            position: (238, 7),
           },
          ],
         },
         FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "builtins",
            position: (238, 17),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "seq",
              position: (238, 26),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Variable {
            identifier: "checkUnmatched",
            position: (238, 30),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "extendModules",
            position: (240, 7),
           },
          ],
         },
         Function {
          argument: Some(
           "extendArgs",
          ),
          arguments: FunctionArguments {
           arguments: [
            FunctionArgument {
             identifier: "prefix",
             default: Some(
              List {
               elements: [],
               position: (243, 18),
              },
             ),
            },
            FunctionArgument {
             identifier: "specialArgs",
             default: Some(
              Map {
               bindings: [],
               recursive: false,
               position: (242, 23),
              },
             ),
            },
            FunctionArgument {
             identifier: "modules",
             default: Some(
              List {
               elements: [],
               position: (241, 19),
              },
             ),
            },
           ],
           ellipsis: false,
          },
          definition: FunctionApplication {
           function: Variable {
            identifier: "evalModules",
            position: (245, 11),
           },
           arguments: [
            BinaryOperation {
             operator: Update,
             operands: [
              Variable {
               identifier: "evalModulesArgs",
               position: (245, 24),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "modules",
                    position: (246, 13),
                   },
                  ],
                 },
                 BinaryOperation {
                  operator: Concatenation,
                  operands: [
                   Variable {
                    identifier: "regularModules",
                    position: (246, 23),
                   },
                   Variable {
                    identifier: "modules",
                    position: (246, 41),
                   },
                  ],
                  position: (246, 38),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "specialArgs",
                    position: (247, 13),
                   },
                  ],
                 },
                 BinaryOperation {
                  operator: Update,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "evalModulesArgs",
                     position: (247, 27),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "specialArgs",
                       position: (247, 43),
                      },
                     ],
                    },
                    default: Some(
                     Map {
                      bindings: [],
                      recursive: false,
                      position: (247, 58),
                     },
                    ),
                   },
                   Variable {
                    identifier: "specialArgs",
                    position: (247, 64),
                   },
                  ],
                  position: (247, 61),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "prefix",
                    position: (248, 13),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "extendArgs",
                   position: (248, 22),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "prefix",
                     position: (248, 33),
                    },
                   ],
                  },
                  default: Some(
                   PropertyAccess {
                    expression: Variable {
                     identifier: "evalModulesArgs",
                     position: (248, 43),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "prefix",
                       position: (248, 59),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                 },
                ),
               ],
               recursive: false,
               position: (245, 43),
              },
             ],
             position: (245, 40),
            },
           ],
          },
          position: (240, 23),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "type",
            position: (251, 7),
           },
          ],
         },
         FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (251, 14),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "types",
              position: (251, 18),
             },
             Raw {
              content: "submoduleWith",
              position: (251, 24),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Map {
            bindings: [
             Inherit(
              None,
              [
               Raw {
                content: "modules",
                position: (252, 17),
               },
               Raw {
                content: "specialArgs",
                position: (252, 25),
               },
              ],
             ),
            ],
            recursive: false,
            position: (251, 38),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "result",
            position: (255, 7),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "withWarnings",
           position: (255, 16),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "options",
                 position: (256, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "checked",
                position: (256, 19),
               },
               arguments: [
                Variable {
                 identifier: "options",
                 position: (256, 27),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "config",
                 position: (257, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "checked",
                position: (257, 18),
               },
               arguments: [
                FunctionApplication {
                 function: Variable {
                  identifier: "removeAttrs",
                  position: (257, 27),
                 },
                 arguments: [
                  Variable {
                   identifier: "config",
                   position: (257, 39),
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "_module",
                       position: (257, 49),
                      },
                     ],
                    },
                   ],
                   position: (257, 46),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "_module",
                 position: (258, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "checked",
                position: (258, 19),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (258, 28),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "_module",
                    position: (258, 35),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ),
             Inherit(
              None,
              [
               Raw {
                content: "extendModules",
                position: (259, 17),
               },
               Raw {
                content: "type",
                position: (259, 31),
               },
              ],
             ),
            ],
            recursive: false,
            position: (255, 29),
           },
          ],
         },
        ),
       ],
       target: Variable {
        identifier: "result",
        position: (261, 8),
       },
       position: (102, 5),
      },
      position: (89, 17),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "collectModules",
        position: (267, 3),
       },
      ],
     },
     LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "loadModule",
           position: (270, 7),
          },
         ],
        },
        Function {
         argument: Some(
          "args",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Function {
          argument: Some(
           "fallbackFile",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: Function {
           argument: Some(
            "fallbackKey",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "m",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: IfThenElse {
             predicate: BinaryOperation {
              operator: LogicalOr,
              operands: [
               FunctionApplication {
                function: Variable {
                 identifier: "isFunction",
                 position: (271, 12),
                },
                arguments: [
                 Variable {
                  identifier: "m",
                  position: (271, 23),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "isAttrs",
                 position: (271, 28),
                },
                arguments: [
                 Variable {
                  identifier: "m",
                  position: (271, 36),
                 },
                ],
               },
              ],
              position: (271, 25),
             },
             then: FunctionApplication {
              function: Variable {
               identifier: "unifyModuleSyntax",
               position: (272, 11),
              },
              arguments: [
               Variable {
                identifier: "fallbackFile",
                position: (272, 29),
               },
               Variable {
                identifier: "fallbackKey",
                position: (272, 42),
               },
               FunctionApplication {
                function: Variable {
                 identifier: "applyIfFunction",
                 position: (272, 55),
                },
                arguments: [
                 Variable {
                  identifier: "fallbackKey",
                  position: (272, 71),
                 },
                 Variable {
                  identifier: "m",
                  position: (272, 83),
                 },
                 Variable {
                  identifier: "args",
                  position: (272, 85),
                 },
                ],
               },
              ],
             },
             else_: IfThenElse {
              predicate: FunctionApplication {
               function: Variable {
                identifier: "isList",
                position: (273, 17),
               },
               arguments: [
                Variable {
                 identifier: "m",
                 position: (273, 24),
                },
               ],
              },
              then: LetIn {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defs",
                    position: (274, 15),
                   },
                  ],
                 },
                 List {
                  elements: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "file",
                         position: (274, 25),
                        },
                       ],
                      },
                      Variable {
                       identifier: "fallbackFile",
                       position: (274, 32),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "value",
                         position: (274, 46),
                        },
                       ],
                      },
                      Variable {
                       identifier: "m",
                       position: (274, 54),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (274, 23),
                   },
                  ],
                  position: (274, 22),
                 },
                ),
               ],
               target: FunctionApplication {
                function: Variable {
                 identifier: "throw",
                 position: (275, 11),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "Module imports can't be nested lists. Perhaps you meant to remove one level of lists? Definitions: ",
                    position: (275, 18),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "showDefs",
                      position: (275, 119),
                     },
                     arguments: [
                      Variable {
                       identifier: "defs",
                       position: (275, 128),
                      },
                     ],
                    },
                   },
                  ],
                 },
                ],
               },
               position: (274, 11),
              },
              else_: FunctionApplication {
               function: Variable {
                identifier: "unifyModuleSyntax",
                position: (276, 14),
               },
               arguments: [
                FunctionApplication {
                 function: Variable {
                  identifier: "toString",
                  position: (276, 33),
                 },
                 arguments: [
                  Variable {
                   identifier: "m",
                   position: (276, 42),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "toString",
                  position: (276, 46),
                 },
                 arguments: [
                  Variable {
                   identifier: "m",
                   position: (276, 55),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "applyIfFunction",
                  position: (276, 59),
                 },
                 arguments: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "toString",
                    position: (276, 76),
                   },
                   arguments: [
                    Variable {
                     identifier: "m",
                     position: (276, 85),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "import",
                    position: (276, 89),
                   },
                   arguments: [
                    Variable {
                     identifier: "m",
                     position: (276, 96),
                    },
                   ],
                  },
                  Variable {
                   identifier: "args",
                   position: (276, 99),
                  },
                 ],
                },
               ],
              },
              position: (273, 14),
             },
             position: (271, 9),
            },
            position: (270, 53),
           },
           position: (270, 40),
          },
          position: (270, 26),
         },
         position: (270, 20),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "collectStructuredModules",
           position: (303, 7),
          },
         ],
        },
        LetIn {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "collectResults",
              position: (305, 11),
             },
            ],
           },
           Function {
            argument: Some(
             "modules",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "disabled",
                  position: (306, 13),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "concatLists",
                 position: (306, 24),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "catAttrs",
                   position: (306, 37),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "disabled",
                      position: (306, 47),
                     },
                    ],
                   },
                   Variable {
                    identifier: "modules",
                    position: (306, 57),
                   },
                  ],
                 },
                ],
               },
              ),
              Inherit(
               None,
               [
                Raw {
                 content: "modules",
                 position: (307, 21),
                },
               ],
              ),
             ],
             recursive: false,
             position: (305, 37),
            },
            position: (305, 28),
           },
          ),
         ],
         target: Function {
          argument: Some(
           "parentFile",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: Function {
           argument: Some(
            "parentKey",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "initialModules",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Function {
             argument: Some(
              "args",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: FunctionApplication {
              function: Variable {
               identifier: "collectResults",
               position: (309, 57),
              },
              arguments: [
               FunctionApplication {
                function: Variable {
                 identifier: "imap1",
                 position: (309, 73),
                },
                arguments: [
                 Function {
                  argument: Some(
                   "n",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: Function {
                   argument: Some(
                    "x",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: LetIn {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "module",
                         position: (311, 13),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "loadModule",
                        position: (311, 22),
                       },
                       arguments: [
                        Variable {
                         identifier: "args",
                         position: (311, 33),
                        },
                        Variable {
                         identifier: "parentFile",
                         position: (311, 38),
                        },
                        String {
                         parts: [
                          Expression {
                           expression: Variable {
                            identifier: "parentKey",
                            position: (311, 52),
                           },
                          },
                          Raw {
                           content: ":anon-",
                           position: (311, 62),
                          },
                          Expression {
                           expression: FunctionApplication {
                            function: Variable {
                             identifier: "toString",
                             position: (311, 70),
                            },
                            arguments: [
                             Variable {
                              identifier: "n",
                              position: (311, 79),
                             },
                            ],
                           },
                          },
                         ],
                        },
                        Variable {
                         identifier: "x",
                         position: (311, 83),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "collectedImports",
                         position: (312, 13),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "collectStructuredModules",
                        position: (312, 32),
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "module",
                          position: (312, 57),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "_file",
                            position: (312, 64),
                           },
                          ],
                         },
                         default: None,
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "module",
                          position: (312, 70),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "key",
                            position: (312, 77),
                           },
                          ],
                         },
                         default: None,
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "module",
                          position: (312, 81),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "imports",
                            position: (312, 88),
                           },
                          ],
                         },
                         default: None,
                        },
                        Variable {
                         identifier: "args",
                         position: (312, 96),
                        },
                       ],
                      },
                     ),
                    ],
                    target: Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "key",
                          position: (314, 13),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "module",
                         position: (314, 19),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "key",
                           position: (314, 26),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "module",
                          position: (315, 13),
                         },
                        ],
                       },
                       Variable {
                        identifier: "module",
                        position: (315, 22),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "modules",
                          position: (316, 13),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "collectedImports",
                         position: (316, 23),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "modules",
                           position: (316, 40),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "disabled",
                          position: (317, 13),
                         },
                        ],
                       },
                       BinaryOperation {
                        operator: Concatenation,
                        operands: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "module",
                           position: (317, 24),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "disabledModules",
                             position: (317, 31),
                            },
                           ],
                          },
                          default: None,
                         },
                         PropertyAccess {
                          expression: Variable {
                           identifier: "collectedImports",
                           position: (317, 50),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "disabled",
                             position: (317, 67),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                        position: (317, 47),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (313, 14),
                    },
                    position: (310, 11),
                   },
                   position: (309, 83),
                  },
                  position: (309, 80),
                 },
                 Variable {
                  identifier: "initialModules",
                  position: (318, 14),
                 },
                ],
               },
              ],
             },
             position: (309, 51),
            },
            position: (309, 35),
           },
           position: (309, 24),
          },
          position: (309, 12),
         },
         position: (304, 9),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "filterModules",
           position: (324, 7),
          },
         ],
        },
        Function {
         argument: Some(
          "modulesPath",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Function {
          argument: None,
          arguments: FunctionArguments {
           arguments: [
            FunctionArgument {
             identifier: "modules",
             default: None,
            },
            FunctionArgument {
             identifier: "disabled",
             default: None,
            },
           ],
           ellipsis: false,
          },
          definition: LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "moduleKey",
                position: (326, 11),
               },
              ],
             },
             Function {
              argument: Some(
               "m",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: IfThenElse {
               predicate: FunctionApplication {
                function: Variable {
                 identifier: "isString",
                 position: (326, 29),
                },
                arguments: [
                 Variable {
                  identifier: "m",
                  position: (326, 38),
                 },
                ],
               },
               then: BinaryOperation {
                operator: Addition,
                operands: [
                 BinaryOperation {
                  operator: Addition,
                  operands: [
                   FunctionApplication {
                    function: Variable {
                     identifier: "toString",
                     position: (326, 45),
                    },
                    arguments: [
                     Variable {
                      identifier: "modulesPath",
                      position: (326, 54),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "/",
                      position: (326, 69),
                     },
                    ],
                   },
                  ],
                  position: (326, 66),
                 },
                 Variable {
                  identifier: "m",
                  position: (326, 74),
                 },
                ],
                position: (326, 72),
               },
               else_: FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (326, 81),
                },
                arguments: [
                 Variable {
                  identifier: "m",
                  position: (326, 90),
                 },
                ],
               },
               position: (326, 26),
              },
              position: (326, 23),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "disabledKeys",
                position: (327, 11),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "map",
               position: (327, 26),
              },
              arguments: [
               Variable {
                identifier: "moduleKey",
                position: (327, 30),
               },
               Variable {
                identifier: "disabled",
                position: (327, 40),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "keyFilter",
                position: (328, 11),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "filter",
               position: (328, 23),
              },
              arguments: [
               Function {
                argument: Some(
                 "attrs",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: UnaryOperation {
                 operator: Not,
                 operand: FunctionApplication {
                  function: Variable {
                   identifier: "elem",
                   position: (328, 40),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "attrs",
                     position: (328, 45),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "key",
                       position: (328, 51),
                      },
                     ],
                    },
                    default: None,
                   },
                   Variable {
                    identifier: "disabledKeys",
                    position: (328, 55),
                   },
                  ],
                 },
                 position: (328, 38),
                },
                position: (328, 31),
               },
              ],
             },
            ),
           ],
           target: FunctionApplication {
            function: Variable {
             identifier: "map",
             position: (329, 12),
            },
            arguments: [
             Function {
              argument: Some(
               "attrs",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: PropertyAccess {
               expression: Variable {
                identifier: "attrs",
                position: (329, 24),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "module",
                  position: (329, 30),
                 },
                ],
               },
               default: None,
              },
              position: (329, 17),
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "builtins",
                position: (329, 39),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "genericClosure",
                  position: (329, 48),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "startSet",
                     position: (330, 11),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "keyFilter",
                    position: (330, 22),
                   },
                   arguments: [
                    Variable {
                     identifier: "modules",
                     position: (330, 32),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "operator",
                     position: (331, 11),
                    },
                   ],
                  },
                  Function {
                   argument: Some(
                    "attrs",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: FunctionApplication {
                    function: Variable {
                     identifier: "keyFilter",
                     position: (331, 29),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "attrs",
                       position: (331, 39),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "modules",
                         position: (331, 45),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                   position: (331, 22),
                  },
                 ),
                ],
                recursive: false,
                position: (329, 63),
               },
              ],
             },
            ],
           },
           position: (325, 9),
          },
          position: (324, 36),
         },
         position: (324, 23),
        },
       ),
      ],
      target: Function {
       argument: Some(
        "modulesPath",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "initialModules",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Function {
         argument: Some(
          "args",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: FunctionApplication {
          function: Variable {
           identifier: "filterModules",
           position: (335, 7),
          },
          arguments: [
           Variable {
            identifier: "modulesPath",
            position: (335, 21),
           },
           FunctionApplication {
            function: Variable {
             identifier: "collectStructuredModules",
             position: (335, 34),
            },
            arguments: [
             Variable {
              identifier: "unknownModule",
              position: (335, 59),
             },
             String {
              parts: [],
             },
             Variable {
              identifier: "initialModules",
              position: (335, 76),
             },
             Variable {
              identifier: "args",
              position: (335, 91),
             },
            ],
           },
          ],
         },
         position: (334, 37),
        },
        position: (334, 21),
       },
       position: (334, 8),
      },
      position: (267, 20),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "setDefaultModuleLocation",
        position: (338, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "file",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "m",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "_file",
             position: (339, 7),
            },
           ],
          },
          Variable {
           identifier: "file",
           position: (339, 15),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "imports",
             position: (339, 21),
            },
           ],
          },
          List {
           elements: [
            Variable {
             identifier: "m",
             position: (339, 33),
            },
           ],
           position: (339, 31),
          },
         ),
        ],
        recursive: false,
        position: (339, 5),
       },
       position: (338, 36),
      },
      position: (338, 30),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "unifyModuleSyntax",
        position: (343, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "file",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "key",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "m",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: LetIn {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "addMeta",
              position: (345, 7),
             },
            ],
           },
           Function {
            argument: Some(
             "config",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: IfThenElse {
             predicate: HasProperty {
              expression: Variable {
               identifier: "m",
               position: (345, 28),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "meta",
                 position: (345, 32),
                },
               ],
              },
              position: (345, 30),
             },
             then: FunctionApplication {
              function: Variable {
               identifier: "mkMerge",
               position: (346, 14),
              },
              arguments: [
               List {
                elements: [
                 Variable {
                  identifier: "config",
                  position: (346, 24),
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "meta",
                       position: (346, 33),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "m",
                      position: (346, 40),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "meta",
                        position: (346, 42),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  ],
                  recursive: false,
                  position: (346, 31),
                 },
                ],
                position: (346, 22),
               },
              ],
             },
             else_: Variable {
              identifier: "config",
              position: (347, 14),
             },
             position: (345, 25),
            },
            position: (345, 17),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "addFreeformType",
              position: (348, 7),
             },
            ],
           },
           Function {
            argument: Some(
             "config",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: IfThenElse {
             predicate: HasProperty {
              expression: Variable {
               identifier: "m",
               position: (348, 36),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "freeformType",
                 position: (348, 40),
                },
               ],
              },
              position: (348, 38),
             },
             then: FunctionApplication {
              function: Variable {
               identifier: "mkMerge",
               position: (349, 14),
              },
              arguments: [
               List {
                elements: [
                 Variable {
                  identifier: "config",
                  position: (349, 24),
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "_module",
                       position: (349, 33),
                      },
                      Raw {
                       content: "freeformType",
                       position: (349, 41),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "m",
                      position: (349, 56),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "freeformType",
                        position: (349, 58),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  ],
                  recursive: false,
                  position: (349, 31),
                 },
                ],
                position: (349, 22),
               },
              ],
             },
             else_: Variable {
              identifier: "config",
              position: (350, 14),
             },
             position: (348, 33),
            },
            position: (348, 25),
           },
          ),
         ],
         target: IfThenElse {
          predicate: BinaryOperation {
           operator: LogicalOr,
           operands: [
            HasProperty {
             expression: Variable {
              identifier: "m",
              position: (352, 8),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "config",
                position: (352, 12),
               },
              ],
             },
             position: (352, 10),
            },
            HasProperty {
             expression: Variable {
              identifier: "m",
              position: (352, 22),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "options",
                position: (352, 26),
               },
              ],
             },
             position: (352, 24),
            },
           ],
           position: (352, 19),
          },
          then: LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "badAttrs",
                position: (353, 11),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "removeAttrs",
               position: (353, 22),
              },
              arguments: [
               Variable {
                identifier: "m",
                position: (353, 34),
               },
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "_file",
                    position: (353, 38),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "key",
                    position: (353, 46),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "disabledModules",
                    position: (353, 52),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "imports",
                    position: (353, 70),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "options",
                    position: (353, 80),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "config",
                    position: (353, 90),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "meta",
                    position: (353, 99),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "freeformType",
                    position: (353, 106),
                   },
                  ],
                 },
                ],
                position: (353, 36),
               },
              ],
             },
            ),
           ],
           target: IfThenElse {
            predicate: BinaryOperation {
             operator: NotEqualTo,
             operands: [
              Variable {
               identifier: "badAttrs",
               position: (354, 10),
              },
              Map {
               bindings: [],
               recursive: false,
               position: (354, 22),
              },
             ],
             position: (354, 19),
            },
            then: FunctionApplication {
             function: Variable {
              identifier: "throw",
              position: (355, 9),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "Module `",
                 position: (355, 16),
                },
                Expression {
                 expression: Variable {
                  identifier: "key",
                  position: (355, 26),
                 },
                },
                Raw {
                 content: "' has an unsupported attribute `",
                 position: (355, 30),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "head",
                   position: (355, 64),
                  },
                  arguments: [
                   FunctionApplication {
                    function: Variable {
                     identifier: "attrNames",
                     position: (355, 70),
                    },
                    arguments: [
                     Variable {
                      identifier: "badAttrs",
                      position: (355, 80),
                     },
                    ],
                   },
                  ],
                 },
                },
                Raw {
                 content: "'. This is caused by introducing a top-level `config' or `options' attribute. Add configuration attributes immediately on the top level instead, or move all of them (namely: ",
                 position: (355, 90),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "toString",
                   position: (355, 266),
                  },
                  arguments: [
                   FunctionApplication {
                    function: Variable {
                     identifier: "attrNames",
                     position: (355, 276),
                    },
                    arguments: [
                     Variable {
                      identifier: "badAttrs",
                      position: (355, 286),
                     },
                    ],
                   },
                  ],
                 },
                },
                Raw {
                 content: ") into the explicit `config' attribute.",
                 position: (355, 296),
                },
               ],
              },
             ],
            },
            else_: Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "_file",
                  position: (357, 11),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (357, 19),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "m",
                   position: (357, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "_file",
                     position: (357, 30),
                    },
                   ],
                  },
                  default: Some(
                   Variable {
                    identifier: "file",
                    position: (357, 39),
                   },
                  ),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "key",
                  position: (358, 11),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (358, 17),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "m",
                   position: (358, 26),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "key",
                     position: (358, 28),
                    },
                   ],
                  },
                  default: Some(
                   Variable {
                    identifier: "key",
                    position: (358, 35),
                   },
                  ),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "disabledModules",
                  position: (359, 11),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (359, 29),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "disabledModules",
                   position: (359, 31),
                  },
                 ],
                },
                default: Some(
                 List {
                  elements: [],
                  position: (359, 50),
                 },
                ),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "imports",
                  position: (360, 11),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (360, 21),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "imports",
                   position: (360, 23),
                  },
                 ],
                },
                default: Some(
                 List {
                  elements: [],
                  position: (360, 34),
                 },
                ),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "options",
                  position: (361, 11),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (361, 21),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "options",
                   position: (361, 23),
                  },
                 ],
                },
                default: Some(
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (361, 34),
                 },
                ),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "config",
                  position: (362, 11),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "addFreeformType",
                 position: (362, 20),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "addMeta",
                   position: (362, 37),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "m",
                     position: (362, 46),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "config",
                       position: (362, 48),
                      },
                     ],
                    },
                    default: Some(
                     Map {
                      bindings: [],
                      recursive: false,
                      position: (362, 58),
                     },
                    ),
                   },
                  ],
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (357, 9),
            },
            position: (354, 7),
           },
           position: (353, 7),
          },
          else_: Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "_file",
                position: (365, 9),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "toString",
               position: (365, 17),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (365, 26),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "_file",
                   position: (365, 28),
                  },
                 ],
                },
                default: Some(
                 Variable {
                  identifier: "file",
                  position: (365, 37),
                 },
                ),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "key",
                position: (366, 9),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "toString",
               position: (366, 15),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (366, 24),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "key",
                   position: (366, 26),
                  },
                 ],
                },
                default: Some(
                 Variable {
                  identifier: "key",
                  position: (366, 33),
                 },
                ),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "disabledModules",
                position: (367, 9),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "m",
               position: (367, 27),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "disabledModules",
                 position: (367, 29),
                },
               ],
              },
              default: Some(
               List {
                elements: [],
                position: (367, 48),
               },
              ),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "imports",
                position: (368, 9),
               },
              ],
             },
             BinaryOperation {
              operator: Concatenation,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (368, 19),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "require",
                   position: (368, 21),
                  },
                 ],
                },
                default: Some(
                 List {
                  elements: [],
                  position: (368, 32),
                 },
                ),
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "m",
                 position: (368, 38),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "imports",
                   position: (368, 40),
                  },
                 ],
                },
                default: Some(
                 List {
                  elements: [],
                  position: (368, 51),
                 },
                ),
               },
              ],
              position: (368, 35),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "options",
                position: (369, 9),
               },
              ],
             },
             Map {
              bindings: [],
              recursive: false,
              position: (369, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "config",
                position: (370, 9),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "addFreeformType",
               position: (370, 18),
              },
              arguments: [
               FunctionApplication {
                function: Variable {
                 identifier: "addMeta",
                 position: (370, 35),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "removeAttrs",
                   position: (370, 44),
                  },
                  arguments: [
                   Variable {
                    identifier: "m",
                    position: (370, 56),
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "_file",
                        position: (370, 60),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "key",
                        position: (370, 68),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "disabledModules",
                        position: (370, 74),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "require",
                        position: (370, 92),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "imports",
                        position: (370, 102),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "freeformType",
                        position: (370, 112),
                       },
                      ],
                     },
                    ],
                    position: (370, 58),
                   },
                  ],
                 },
                ],
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (365, 7),
          },
          position: (352, 5),
         },
         position: (344, 5),
        },
        position: (343, 34),
       },
       position: (343, 29),
      },
      position: (343, 23),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "applyIfFunction",
        position: (373, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "key",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "f",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "args",
        ),
        arguments: FunctionArguments {
         arguments: [
          FunctionArgument {
           identifier: "lib",
           default: None,
          },
          FunctionArgument {
           identifier: "options",
           default: None,
          },
          FunctionArgument {
           identifier: "config",
           default: None,
          },
         ],
         ellipsis: true,
        },
        definition: IfThenElse {
         predicate: FunctionApplication {
          function: Variable {
           identifier: "isFunction",
           position: (373, 68),
          },
          arguments: [
           Variable {
            identifier: "f",
            position: (373, 79),
           },
          ],
         },
         then: LetIn {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "context",
               position: (387, 7),
              },
             ],
            },
            Function {
             argument: Some(
              "name",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: String {
              parts: [
               Raw {
                content: "while evaluating the module argument `",
                position: (387, 25),
               },
               Expression {
                expression: Variable {
                 identifier: "name",
                 position: (387, 65),
                },
               },
               Raw {
                content: "' in \"",
                position: (387, 70),
               },
               Expression {
                expression: Variable {
                 identifier: "key",
                 position: (387, 78),
                },
               },
               Raw {
                content: "\":",
                position: (387, 82),
               },
              ],
             },
             position: (387, 17),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraArgs",
               position: (388, 7),
              },
             ],
            },
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "builtins",
               position: (388, 19),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "mapAttrs",
                 position: (388, 28),
                },
               ],
              },
              default: None,
             },
             arguments: [
              Function {
               argument: Some(
                "name",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: Function {
                argument: Some(
                 "_",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "builtins",
                   position: (389, 9),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "addErrorContext",
                     position: (389, 18),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "context",
                    position: (389, 35),
                   },
                   arguments: [
                    Variable {
                     identifier: "name",
                     position: (389, 43),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "args",
                    position: (390, 12),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Expression {
                      expression: Variable {
                       identifier: "name",
                       position: (390, 19),
                      },
                     },
                    ],
                   },
                   default: Some(
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (390, 28),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "_module",
                        position: (390, 35),
                       },
                       Raw {
                        content: "args",
                        position: (390, 43),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "name",
                         position: (390, 50),
                        },
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  },
                 ],
                },
                position: (388, 44),
               },
               position: (388, 38),
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (391, 10),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "functionArgs",
                   position: (391, 14),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Variable {
                 identifier: "f",
                 position: (391, 27),
                },
               ],
              },
             ],
            },
           ),
          ],
          target: FunctionApplication {
           function: Variable {
            identifier: "f",
            position: (397, 8),
           },
           arguments: [
            BinaryOperation {
             operator: Update,
             operands: [
              Variable {
               identifier: "args",
               position: (397, 11),
              },
              Variable {
               identifier: "extraArgs",
               position: (397, 19),
              },
             ],
             position: (397, 16),
            },
           ],
          },
          position: (374, 5),
         },
         else_: Variable {
          identifier: "f",
          position: (399, 5),
         },
         position: (373, 65),
        },
        position: (373, 29),
       },
       position: (373, 26),
      },
      position: (373, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mergeModules",
        position: (422, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "prefix",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "modules",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "mergeModules'",
         position: (423, 5),
        },
        arguments: [
         Variable {
          identifier: "prefix",
          position: (423, 19),
         },
         Variable {
          identifier: "modules",
          position: (423, 26),
         },
         FunctionApplication {
          function: Variable {
           identifier: "concatMap",
           position: (424, 8),
          },
          arguments: [
           Function {
            argument: Some(
             "m",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: FunctionApplication {
             function: Variable {
              identifier: "map",
              position: (424, 22),
             },
             arguments: [
              Function {
               argument: Some(
                "config",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "file",
                     position: (424, 37),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "m",
                    position: (424, 44),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "_file",
                      position: (424, 46),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 Inherit(
                  None,
                  [
                   Raw {
                    content: "config",
                    position: (424, 61),
                   },
                  ],
                 ),
                ],
                recursive: false,
                position: (424, 35),
               },
               position: (424, 27),
              },
              FunctionApplication {
               function: Variable {
                identifier: "pushDownProperties",
                position: (424, 73),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "m",
                  position: (424, 92),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "config",
                    position: (424, 94),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ],
            },
            position: (424, 19),
           },
           Variable {
            identifier: "modules",
            position: (424, 103),
           },
          ],
         },
        ],
       },
       position: (422, 26),
      },
      position: (422, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mergeModules'",
        position: (426, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "prefix",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "options",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "configs",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: LetIn {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "byName",
              position: (449, 7),
             },
            ],
           },
           Function {
            argument: Some(
             "attr",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Function {
             argument: Some(
              "f",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: Function {
              argument: Some(
               "modules",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: FunctionApplication {
               function: Variable {
                identifier: "zipAttrsWith",
                position: (450, 9),
               },
               arguments: [
                Function {
                 argument: Some(
                  "n",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: Variable {
                  identifier: "concatLists",
                  position: (450, 26),
                 },
                 position: (450, 23),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "map",
                  position: (451, 12),
                 },
                 arguments: [
                  Function {
                   argument: Some(
                    "module",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: LetIn {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "subtree",
                         position: (451, 29),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "module",
                        position: (451, 39),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Expression {
                          expression: Variable {
                           identifier: "attr",
                           position: (451, 48),
                          },
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                    ],
                    target: IfThenElse {
                     predicate: UnaryOperation {
                      operator: Not,
                      operand: FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "builtins",
                         position: (452, 20),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "isAttrs",
                           position: (452, 29),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        Variable {
                         identifier: "subtree",
                         position: (452, 37),
                        },
                       ],
                      },
                      position: (452, 18),
                     },
                     then: FunctionApplication {
                      function: Variable {
                       identifier: "throw",
                       position: (453, 17),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "You're trying to declare a value of type `",
                          position: (454, 1),
                         },
                         Expression {
                          expression: FunctionApplication {
                           function: PropertyAccess {
                            expression: Variable {
                             identifier: "builtins",
                             position: (454, 63),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "typeOf",
                               position: (454, 72),
                              },
                             ],
                            },
                            default: None,
                           },
                           arguments: [
                            Variable {
                             identifier: "subtree",
                             position: (454, 79),
                            },
                           ],
                          },
                         },
                         Raw {
                          content: "'\nrather than an attribute-set for the option\n`",
                          position: (454, 87),
                         },
                         Expression {
                          expression: FunctionApplication {
                           function: PropertyAccess {
                            expression: Variable {
                             identifier: "builtins",
                             position: (456, 22),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "concatStringsSep",
                               position: (456, 31),
                              },
                             ],
                            },
                            default: None,
                           },
                           arguments: [
                            String {
                             parts: [
                              Raw {
                               content: ".",
                               position: (456, 49),
                              },
                             ],
                            },
                            Variable {
                             identifier: "prefix",
                             position: (456, 52),
                            },
                           ],
                          },
                         },
                         Raw {
                          content: "'!\n\nThis usually happens if `",
                          position: (456, 59),
                         },
                         Expression {
                          expression: FunctionApplication {
                           function: PropertyAccess {
                            expression: Variable {
                             identifier: "builtins",
                             position: (458, 46),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "concatStringsSep",
                               position: (458, 55),
                              },
                             ],
                            },
                            default: None,
                           },
                           arguments: [
                            String {
                             parts: [
                              Raw {
                               content: ".",
                               position: (458, 73),
                              },
                             ],
                            },
                            Variable {
                             identifier: "prefix",
                             position: (458, 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: (458, 83),
                         },
                        ],
                       },
                      ],
                     },
                     else_: FunctionApplication {
                      function: Variable {
                       identifier: "mapAttrs",
                       position: (463, 17),
                      },
                      arguments: [
                       Function {
                        argument: Some(
                         "n",
                        ),
                        arguments: FunctionArguments {
                         arguments: [],
                         ellipsis: false,
                        },
                        definition: FunctionApplication {
                         function: Variable {
                          identifier: "f",
                          position: (463, 30),
                         },
                         arguments: [
                          Variable {
                           identifier: "module",
                           position: (463, 32),
                          },
                         ],
                        },
                        position: (463, 27),
                       },
                       Variable {
                        identifier: "subtree",
                        position: (463, 40),
                       },
                      ],
                     },
                     position: (452, 15),
                    },
                    position: (451, 25),
                   },
                   position: (451, 17),
                  },
                  Variable {
                   identifier: "modules",
                   position: (464, 17),
                  },
                 ],
                },
               ],
              },
              position: (449, 25),
             },
             position: (449, 22),
            },
            position: (449, 16),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "declsByName",
              position: (466, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "byName",
             position: (466, 21),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "options",
                position: (466, 29),
               },
              ],
             },
             Function {
              argument: Some(
               "module",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "option",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: List {
                elements: [
                 Map {
                  bindings: [
                   Inherit(
                    Some(
                     Variable {
                      identifier: "module",
                      position: (467, 23),
                     },
                    ),
                    [
                     Raw {
                      content: "_file",
                      position: (467, 31),
                     },
                    ],
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "options",
                       position: (467, 38),
                      },
                     ],
                    },
                    Variable {
                     identifier: "option",
                     position: (467, 48),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (467, 12),
                 },
                ],
                position: (467, 11),
               },
               position: (466, 47),
              },
              position: (466, 39),
             },
             Variable {
              identifier: "options",
              position: (468, 11),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "defnsByName",
              position: (470, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "byName",
             position: (470, 21),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "config",
                position: (470, 29),
               },
              ],
             },
             Function {
              argument: Some(
               "module",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "value",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: FunctionApplication {
                function: Variable {
                 identifier: "map",
                 position: (471, 11),
                },
                arguments: [
                 Function {
                  argument: Some(
                   "config",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: Map {
                   bindings: [
                    Inherit(
                     Some(
                      Variable {
                       identifier: "module",
                       position: (471, 35),
                      },
                     ),
                     [
                      Raw {
                       content: "file",
                       position: (471, 43),
                      },
                     ],
                    ),
                    Inherit(
                     None,
                     [
                      Raw {
                       content: "config",
                       position: (471, 57),
                      },
                     ],
                    ),
                   ],
                   recursive: false,
                   position: (471, 24),
                  },
                  position: (471, 16),
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "pushDownProperties",
                   position: (471, 69),
                  },
                  arguments: [
                   Variable {
                    identifier: "value",
                    position: (471, 88),
                   },
                  ],
                 },
                ],
               },
               position: (470, 46),
              },
              position: (470, 38),
             },
             Variable {
              identifier: "configs",
              position: (472, 11),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "defnsByName'",
              position: (474, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "byName",
             position: (474, 22),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "config",
                position: (474, 30),
               },
              ],
             },
             Function {
              argument: Some(
               "module",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "value",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: List {
                elements: [
                 Map {
                  bindings: [
                   Inherit(
                    Some(
                     Variable {
                      identifier: "module",
                      position: (475, 23),
                     },
                    ),
                    [
                     Raw {
                      content: "file",
                      position: (475, 31),
                     },
                    ],
                   ),
                   Inherit(
                    None,
                    [
                     Raw {
                      content: "value",
                      position: (475, 45),
                     },
                    ],
                   ),
                  ],
                  recursive: false,
                  position: (475, 12),
                 },
                ],
                position: (475, 11),
               },
               position: (474, 47),
              },
              position: (474, 39),
             },
             Variable {
              identifier: "configs",
              position: (476, 11),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "resultsByName",
              position: (478, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mapAttrs",
             position: (478, 23),
            },
            arguments: [
             Function {
              argument: Some(
               "name",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "decls",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: LetIn {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "loc",
                     position: (481, 11),
                    },
                   ],
                  },
                  BinaryOperation {
                   operator: Concatenation,
                   operands: [
                    Variable {
                     identifier: "prefix",
                     position: (481, 17),
                    },
                    List {
                     elements: [
                      Variable {
                       identifier: "name",
                       position: (481, 28),
                      },
                     ],
                     position: (481, 27),
                    },
                   ],
                   position: (481, 24),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "defns",
                     position: (482, 11),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "defnsByName",
                    position: (482, 19),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Expression {
                      expression: Variable {
                       identifier: "name",
                       position: (482, 33),
                      },
                     },
                    ],
                   },
                   default: Some(
                    List {
                     elements: [],
                     position: (482, 42),
                    },
                   ),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "defns'",
                     position: (483, 11),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "defnsByName'",
                    position: (483, 20),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Expression {
                      expression: Variable {
                       identifier: "name",
                       position: (483, 35),
                      },
                     },
                    ],
                   },
                   default: Some(
                    List {
                     elements: [],
                     position: (483, 44),
                    },
                   ),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "nrOptions",
                     position: (484, 11),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "count",
                    position: (484, 23),
                   },
                   arguments: [
                    Function {
                     argument: Some(
                      "m",
                     ),
                     arguments: FunctionArguments {
                      arguments: [],
                      ellipsis: false,
                     },
                     definition: FunctionApplication {
                      function: Variable {
                       identifier: "isOption",
                       position: (484, 33),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "m",
                         position: (484, 42),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "options",
                           position: (484, 44),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                     position: (484, 30),
                    },
                    Variable {
                     identifier: "decls",
                     position: (484, 53),
                    },
                   ],
                  },
                 ),
                ],
                target: IfThenElse {
                 predicate: BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   Variable {
                    identifier: "nrOptions",
                    position: (486, 14),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "length",
                     position: (486, 27),
                    },
                    arguments: [
                     Variable {
                      identifier: "decls",
                      position: (486, 34),
                     },
                    ],
                   },
                  ],
                  position: (486, 24),
                 },
                 then: LetIn {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "opt",
                       position: (487, 17),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "fixupOptionType",
                      position: (487, 23),
                     },
                     arguments: [
                      Variable {
                       identifier: "loc",
                       position: (487, 39),
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mergeOptionDecls",
                        position: (487, 44),
                       },
                       arguments: [
                        Variable {
                         identifier: "loc",
                         position: (487, 61),
                        },
                        Variable {
                         identifier: "decls",
                         position: (487, 65),
                        },
                       ],
                      },
                     ],
                    },
                   ),
                  ],
                  target: Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "matchedOptions",
                        position: (489, 15),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "evalOptionValue",
                       position: (489, 32),
                      },
                      arguments: [
                       Variable {
                        identifier: "loc",
                        position: (489, 48),
                       },
                       Variable {
                        identifier: "opt",
                        position: (489, 52),
                       },
                       Variable {
                        identifier: "defns'",
                        position: (489, 56),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "unmatchedDefns",
                        position: (490, 15),
                       },
                      ],
                     },
                     List {
                      elements: [],
                      position: (490, 32),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (488, 16),
                  },
                  position: (487, 13),
                 },
                 else_: IfThenElse {
                  predicate: BinaryOperation {
                   operator: NotEqualTo,
                   operands: [
                    Variable {
                     identifier: "nrOptions",
                     position: (492, 19),
                    },
                    Int {
                     value: 0,
                     position: (492, 32),
                    },
                   ],
                   position: (492, 29),
                  },
                  then: LetIn {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "firstOption",
                        position: (494, 15),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "findFirst",
                       position: (494, 29),
                      },
                      arguments: [
                       Function {
                        argument: Some(
                         "m",
                        ),
                        arguments: FunctionArguments {
                         arguments: [],
                         ellipsis: false,
                        },
                        definition: FunctionApplication {
                         function: Variable {
                          identifier: "isOption",
                          position: (494, 43),
                         },
                         arguments: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "m",
                            position: (494, 52),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "options",
                              position: (494, 54),
                             },
                            ],
                           },
                           default: None,
                          },
                         ],
                        },
                        position: (494, 40),
                       },
                       String {
                        parts: [],
                       },
                       Variable {
                        identifier: "decls",
                        position: (494, 66),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "firstNonOption",
                        position: (495, 15),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "findFirst",
                       position: (495, 32),
                      },
                      arguments: [
                       Function {
                        argument: Some(
                         "m",
                        ),
                        arguments: FunctionArguments {
                         arguments: [],
                         ellipsis: false,
                        },
                        definition: UnaryOperation {
                         operator: Not,
                         operand: FunctionApplication {
                          function: Variable {
                           identifier: "isOption",
                           position: (495, 47),
                          },
                          arguments: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "m",
                             position: (495, 56),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "options",
                               position: (495, 58),
                              },
                             ],
                            },
                            default: None,
                           },
                          ],
                         },
                         position: (495, 46),
                        },
                        position: (495, 43),
                       },
                       String {
                        parts: [],
                       },
                       Variable {
                        identifier: "decls",
                        position: (495, 70),
                       },
                      ],
                     },
                    ),
                   ],
                   target: FunctionApplication {
                    function: Variable {
                     identifier: "throw",
                     position: (497, 15),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "The option `",
                        position: (497, 22),
                       },
                       Expression {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "showOption",
                          position: (497, 36),
                         },
                         arguments: [
                          Variable {
                           identifier: "loc",
                           position: (497, 47),
                          },
                         ],
                        },
                       },
                       Raw {
                        content: "' in `",
                        position: (497, 51),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "firstOption",
                          position: (497, 59),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "_file",
                            position: (497, 71),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "' is a prefix of options in `",
                        position: (497, 77),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "firstNonOption",
                          position: (497, 108),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "_file",
                            position: (497, 123),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "'.",
                        position: (497, 129),
                       },
                      ],
                     },
                    ],
                   },
                   position: (493, 13),
                  },
                  else_: FunctionApplication {
                   function: Variable {
                    identifier: "mergeModules'",
                    position: (499, 13),
                   },
                   arguments: [
                    Variable {
                     identifier: "loc",
                     position: (499, 27),
                    },
                    Variable {
                     identifier: "decls",
                     position: (499, 31),
                    },
                    Variable {
                     identifier: "defns",
                     position: (499, 37),
                    },
                   ],
                  },
                  position: (492, 16),
                 },
                 position: (486, 11),
                },
                position: (480, 9),
               },
               position: (478, 39),
              },
              position: (478, 33),
             },
             Variable {
              identifier: "declsByName",
              position: (499, 44),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "matchedOptions",
              position: (501, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mapAttrs",
             position: (501, 24),
            },
            arguments: [
             Function {
              argument: Some(
               "n",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "v",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: PropertyAccess {
                expression: Variable {
                 identifier: "v",
                 position: (501, 40),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "matchedOptions",
                   position: (501, 42),
                  },
                 ],
                },
                default: None,
               },
               position: (501, 37),
              },
              position: (501, 34),
             },
             Variable {
              identifier: "resultsByName",
              position: (501, 58),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "unmatchedDefnsByName",
              position: (504, 7),
             },
            ],
           },
           BinaryOperation {
            operator: Update,
            operands: [
             FunctionApplication {
              function: Variable {
               identifier: "mapAttrs",
               position: (506, 9),
              },
              arguments: [
               Function {
                argument: Some(
                 "n",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: Function {
                 argument: Some(
                  "v",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: PropertyAccess {
                  expression: Variable {
                   identifier: "v",
                   position: (506, 25),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "unmatchedDefns",
                     position: (506, 27),
                    },
                   ],
                  },
                  default: None,
                 },
                 position: (506, 22),
                },
                position: (506, 19),
               },
               Variable {
                identifier: "resultsByName",
                position: (506, 43),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "removeAttrs",
               position: (508, 12),
              },
              arguments: [
               Variable {
                identifier: "defnsByName'",
                position: (508, 24),
               },
               FunctionApplication {
                function: Variable {
                 identifier: "attrNames",
                 position: (508, 38),
                },
                arguments: [
                 Variable {
                  identifier: "matchedOptions",
                  position: (508, 48),
                 },
                ],
               },
              ],
             },
            ],
            position: (508, 9),
           },
          ),
         ],
         target: Map {
          bindings: [
           Inherit(
            None,
            [
             Raw {
              content: "matchedOptions",
              position: (510, 15),
             },
            ],
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "unmatchedDefns",
               position: (513, 7),
              },
             ],
            },
            IfThenElse {
             predicate: BinaryOperation {
              operator: EqualTo,
              operands: [
               Variable {
                identifier: "configs",
                position: (514, 12),
               },
               List {
                elements: [],
                position: (514, 23),
               },
              ],
              position: (514, 20),
             },
             then: List {
              elements: [],
              position: (518, 11),
             },
             else_: FunctionApplication {
              function: Variable {
               identifier: "concatLists",
               position: (520, 11),
              },
              arguments: [
               FunctionApplication {
                function: Variable {
                 identifier: "mapAttrsToList",
                 position: (520, 24),
                },
                arguments: [
                 Function {
                  argument: Some(
                   "name",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: Function {
                   argument: Some(
                    "defs",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: FunctionApplication {
                    function: Variable {
                     identifier: "map",
                     position: (521, 13),
                    },
                    arguments: [
                     Function {
                      argument: Some(
                       "def",
                      ),
                      arguments: FunctionArguments {
                       arguments: [],
                       ellipsis: false,
                      },
                      definition: BinaryOperation {
                       operator: Update,
                       operands: [
                        Variable {
                         identifier: "def",
                         position: (521, 23),
                        },
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "prefix",
                              position: (523, 15),
                             },
                            ],
                           },
                           BinaryOperation {
                            operator: Concatenation,
                            operands: [
                             List {
                              elements: [
                               Variable {
                                identifier: "name",
                                position: (523, 25),
                               },
                              ],
                              position: (523, 24),
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "def",
                               position: (523, 35),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "prefix",
                                 position: (523, 39),
                                },
                               ],
                              },
                              default: Some(
                               List {
                                elements: [],
                                position: (523, 49),
                               },
                              ),
                             },
                            ],
                            position: (523, 31),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (521, 30),
                        },
                       ],
                       position: (521, 27),
                      },
                      position: (521, 18),
                     },
                     Variable {
                      identifier: "defs",
                      position: (524, 16),
                     },
                    ],
                   },
                   position: (520, 46),
                  },
                  position: (520, 40),
                 },
                 Variable {
                  identifier: "unmatchedDefnsByName",
                  position: (525, 13),
                 },
                ],
               },
              ],
             },
             position: (514, 9),
            },
           ),
          ],
          recursive: false,
          position: (509, 8),
         },
         position: (427, 5),
        },
        position: (426, 36),
       },
       position: (426, 27),
      },
      position: (426, 19),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mergeOptionDecls",
        position: (539, 3),
       },
      ],
     },
     LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "coerceOption",
           position: (541, 5),
          },
         ],
        },
        Function {
         argument: Some(
          "file",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Function {
          argument: Some(
           "opt",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: IfThenElse {
           predicate: FunctionApplication {
            function: Variable {
             identifier: "isFunction",
             position: (542, 10),
            },
            arguments: [
             Variable {
              identifier: "opt",
              position: (542, 21),
             },
            ],
           },
           then: FunctionApplication {
            function: Variable {
             identifier: "setDefaultModuleLocation",
             position: (542, 30),
            },
            arguments: [
             Variable {
              identifier: "file",
              position: (542, 55),
             },
             Variable {
              identifier: "opt",
              position: (542, 60),
             },
            ],
           },
           else_: FunctionApplication {
            function: Variable {
             identifier: "setDefaultModuleLocation",
             position: (543, 12),
            },
            arguments: [
             Variable {
              identifier: "file",
              position: (543, 37),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "options",
                   position: (543, 44),
                  },
                 ],
                },
                Variable {
                 identifier: "opt",
                 position: (543, 54),
                },
               ),
              ],
              recursive: false,
              position: (543, 42),
             },
            ],
           },
           position: (542, 7),
          },
          position: (541, 26),
         },
         position: (541, 20),
        },
       ),
      ],
      target: Function {
       argument: Some(
        "loc",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "opts",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: FunctionApplication {
         function: Variable {
          identifier: "foldl'",
          position: (545, 5),
         },
         arguments: [
          Function {
           argument: Some(
            "res",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "opt",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: LetIn {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "t",
                  position: (546, 11),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "res",
                 position: (546, 16),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (546, 20),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "t'",
                  position: (547, 11),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "opt",
                 position: (547, 16),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "options",
                   position: (547, 20),
                  },
                  Raw {
                   content: "type",
                   position: (547, 28),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "mergedType",
                  position: (548, 11),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "t",
                  position: (548, 24),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "typeMerge",
                    position: (548, 26),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "t'",
                   position: (548, 36),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "functor",
                     position: (548, 39),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "typesMergeable",
                  position: (549, 11),
                 },
                ],
               },
               BinaryOperation {
                operator: NotEqualTo,
                operands: [
                 Variable {
                  identifier: "mergedType",
                  position: (549, 28),
                 },
                 Variable {
                  identifier: "null",
                  position: (549, 42),
                 },
                ],
                position: (549, 39),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "typeSet",
                  position: (550, 11),
                 },
                ],
               },
               IfThenElse {
                predicate: BinaryOperation {
                 operator: LogicalAnd,
                 operands: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "bothHave",
                    position: (550, 25),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "type",
                       position: (550, 35),
                      },
                     ],
                    },
                   ],
                  },
                  Variable {
                   identifier: "typesMergeable",
                   position: (550, 45),
                  },
                 ],
                 position: (550, 42),
                },
                then: Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (551, 31),
                     },
                    ],
                   },
                   Variable {
                    identifier: "mergedType",
                    position: (551, 38),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (551, 29),
                },
                else_: Map {
                 bindings: [],
                 recursive: false,
                 position: (552, 29),
                },
                position: (550, 21),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "bothHave",
                  position: (553, 11),
                 },
                ],
               },
               Function {
                argument: Some(
                 "k",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: BinaryOperation {
                 operator: LogicalAnd,
                 operands: [
                  HasProperty {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "opt",
                     position: (553, 25),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "options",
                       position: (553, 29),
                      },
                     ],
                    },
                    default: None,
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Expression {
                      expression: Variable {
                       identifier: "k",
                       position: (553, 41),
                      },
                     },
                    ],
                   },
                   position: (553, 37),
                  },
                  HasProperty {
                   expression: Variable {
                    identifier: "res",
                    position: (553, 47),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Expression {
                      expression: Variable {
                       identifier: "k",
                       position: (553, 55),
                      },
                     },
                    ],
                   },
                   position: (553, 51),
                  },
                 ],
                 position: (553, 44),
                },
                position: (553, 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: (555, 10),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "default",
                           position: (555, 20),
                          },
                         ],
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "bothHave",
                        position: (556, 10),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "example",
                           position: (556, 20),
                          },
                         ],
                        },
                       ],
                      },
                     ],
                     position: (555, 29),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "bothHave",
                      position: (557, 10),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "description",
                         position: (557, 20),
                        },
                       ],
                      },
                     ],
                    },
                   ],
                   position: (556, 29),
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "bothHave",
                    position: (558, 10),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "apply",
                       position: (558, 20),
                      },
                     ],
                    },
                   ],
                  },
                 ],
                 position: (557, 33),
                },
                BinaryOperation {
                 operator: LogicalAnd,
                 operands: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "bothHave",
                    position: (559, 11),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "type",
                       position: (559, 21),
                      },
                     ],
                    },
                   ],
                  },
                  UnaryOperation {
                   operator: Not,
                   operand: Variable {
                    identifier: "typesMergeable",
                    position: (559, 33),
                   },
                   position: (559, 31),
                  },
                 ],
                 position: (559, 27),
                },
               ],
               position: (558, 27),
              },
              then: FunctionApplication {
               function: Variable {
                identifier: "throw",
                position: (561, 9),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "The option `",
                   position: (561, 16),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "showOption",
                     position: (561, 30),
                    },
                    arguments: [
                     Variable {
                      identifier: "loc",
                      position: (561, 41),
                     },
                    ],
                   },
                  },
                  Raw {
                   content: "' in `",
                   position: (561, 45),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "opt",
                     position: (561, 53),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "_file",
                       position: (561, 57),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "' is already declared in ",
                   position: (561, 63),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "showFiles",
                     position: (561, 90),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "res",
                       position: (561, 100),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "declarations",
                         position: (561, 104),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  },
                  Raw {
                   content: ".",
                   position: (561, 117),
                  },
                 ],
                },
               ],
              },
              else_: LetIn {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "options'",
                    position: (569, 11),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "toList",
                   position: (569, 22),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "opt",
                     position: (569, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "options",
                       position: (569, 33),
                      },
                      Raw {
                       content: "options",
                       position: (569, 41),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "getSubModules",
                    position: (571, 11),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "opt",
                   position: (571, 27),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "options",
                     position: (571, 31),
                    },
                    Raw {
                     content: "type",
                     position: (571, 39),
                    },
                    Raw {
                     content: "getSubModules",
                     position: (571, 44),
                    },
                   ],
                  },
                  default: Some(
                   Variable {
                    identifier: "null",
                    position: (571, 61),
                   },
                  ),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "submodules",
                    position: (572, 11),
                   },
                  ],
                 },
                 IfThenElse {
                  predicate: BinaryOperation {
                   operator: NotEqualTo,
                   operands: [
                    Variable {
                     identifier: "getSubModules",
                     position: (573, 16),
                    },
                    Variable {
                     identifier: "null",
                     position: (573, 33),
                    },
                   ],
                   position: (573, 30),
                  },
                  then: BinaryOperation {
                   operator: Concatenation,
                   operands: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "map",
                      position: (573, 43),
                     },
                     arguments: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "setDefaultModuleLocation",
                        position: (573, 48),
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "opt",
                          position: (573, 73),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "_file",
                            position: (573, 77),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                      Variable {
                       identifier: "getSubModules",
                       position: (573, 84),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "res",
                      position: (573, 101),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "options",
                        position: (573, 105),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (573, 98),
                  },
                  else_: IfThenElse {
                   predicate: HasProperty {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "opt",
                      position: (574, 21),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "options",
                        position: (574, 25),
                       },
                      ],
                     },
                     default: None,
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "options",
                       position: (574, 35),
                      },
                     ],
                    },
                    position: (574, 33),
                   },
                   then: BinaryOperation {
                    operator: Concatenation,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "map",
                       position: (574, 48),
                      },
                      arguments: [
                       FunctionApplication {
                        function: Variable {
                         identifier: "coerceOption",
                         position: (574, 53),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "opt",
                           position: (574, 66),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "_file",
                             position: (574, 70),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                       Variable {
                        identifier: "options'",
                        position: (574, 77),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "res",
                       position: (574, 89),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "options",
                         position: (574, 93),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                    position: (574, 86),
                   },
                   else_: PropertyAccess {
                    expression: Variable {
                     identifier: "res",
                     position: (575, 18),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "options",
                       position: (575, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   position: (574, 18),
                  },
                  position: (573, 13),
                 },
                ),
               ],
               target: BinaryOperation {
                operator: Update,
                operands: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "opt",
                   position: (576, 12),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "options",
                     position: (576, 16),
                    },
                   ],
                  },
                  default: None,
                 },
                 BinaryOperation {
                  operator: Update,
                  operands: [
                   Variable {
                    identifier: "res",
                    position: (576, 27),
                   },
                   BinaryOperation {
                    operator: Update,
                    operands: [
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "declarations",
                           position: (577, 13),
                          },
                         ],
                        },
                        BinaryOperation {
                         operator: Concatenation,
                         operands: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "res",
                            position: (577, 28),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "declarations",
                              position: (577, 32),
                             },
                            ],
                           },
                           default: None,
                          },
                          List {
                           elements: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "opt",
                              position: (577, 49),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "_file",
                                position: (577, 53),
                               },
                              ],
                             },
                             default: None,
                            },
                           ],
                           position: (577, 48),
                          },
                         ],
                         position: (577, 45),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "options",
                           position: (578, 13),
                          },
                         ],
                        },
                        Variable {
                         identifier: "submodules",
                         position: (578, 23),
                        },
                       ),
                      ],
                      recursive: false,
                      position: (577, 11),
                     },
                     Variable {
                      identifier: "typeSet",
                      position: (579, 16),
                     },
                    ],
                    position: (579, 13),
                   },
                  ],
                  position: (576, 31),
                 },
                ],
                position: (576, 24),
               },
               position: (563, 9),
              },
              position: (555, 7),
             },
             position: (546, 7),
            },
            position: (545, 18),
           },
           position: (545, 13),
          },
          Map {
           bindings: [
            Inherit(
             None,
             [
              Raw {
               content: "loc",
               position: (580, 17),
              },
             ],
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "declarations",
                position: (580, 22),
               },
              ],
             },
             List {
              elements: [],
              position: (580, 37),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "options",
                position: (580, 41),
               },
              ],
             },
             List {
              elements: [],
              position: (580, 51),
             },
            ),
           ],
           recursive: false,
           position: (580, 7),
          },
          Variable {
           identifier: "opts",
           position: (580, 57),
          },
         ],
        },
        position: (544, 12),
       },
       position: (544, 7),
      },
      position: (540, 4),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "evalOptionValue",
        position: (584, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "loc",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "opt",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "defs",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: LetIn {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "defs'",
              position: (587, 7),
             },
            ],
           },
           BinaryOperation {
            operator: Concatenation,
            operands: [
             FunctionApplication {
              function: Variable {
               identifier: "optional",
               position: (588, 12),
              },
              arguments: [
               HasProperty {
                expression: Variable {
                 identifier: "opt",
                 position: (588, 22),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (588, 28),
                  },
                 ],
                },
                position: (588, 26),
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "file",
                     position: (589, 15),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "head",
                    position: (589, 22),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "opt",
                      position: (589, 27),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "declarations",
                        position: (589, 31),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "value",
                     position: (589, 45),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkOptionDefault",
                    position: (589, 53),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "opt",
                      position: (589, 69),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "default",
                        position: (589, 73),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (589, 13),
               },
              ],
             },
             Variable {
              identifier: "defs",
              position: (589, 88),
             },
            ],
            position: (589, 85),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "res",
              position: (592, 7),
             },
            ],
           },
           IfThenElse {
            predicate: BinaryOperation {
             operator: LogicalAnd,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "opt",
                position: (593, 12),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "readOnly",
                  position: (593, 16),
                 },
                ],
               },
               default: Some(
                Variable {
                 identifier: "false",
                 position: (593, 28),
                },
               ),
              },
              BinaryOperation {
               operator: GreaterThan,
               operands: [
                FunctionApplication {
                 function: Variable {
                  identifier: "length",
                  position: (593, 37),
                 },
                 arguments: [
                  Variable {
                   identifier: "defs'",
                   position: (593, 44),
                  },
                 ],
                },
                Int {
                 value: 1,
                 position: (593, 52),
                },
               ],
               position: (593, 50),
              },
             ],
             position: (593, 34),
            },
            then: LetIn {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "separateDefs",
                  position: (597, 13),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "map",
                 position: (597, 28),
                },
                arguments: [
                 Function {
                  argument: Some(
                   "def",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Update,
                   operands: [
                    Variable {
                     identifier: "def",
                     position: (597, 38),
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "value",
                          position: (598, 15),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "mergeDefinitions",
                          position: (598, 24),
                         },
                         arguments: [
                          Variable {
                           identifier: "loc",
                           position: (598, 41),
                          },
                          PropertyAccess {
                           expression: Variable {
                            identifier: "opt",
                            position: (598, 45),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (598, 49),
                             },
                            ],
                           },
                           default: None,
                          },
                          List {
                           elements: [
                            Variable {
                             identifier: "def",
                             position: (598, 56),
                            },
                           ],
                           position: (598, 54),
                          },
                         ],
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "mergedValue",
                           position: (598, 63),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                     ],
                     recursive: false,
                     position: (597, 45),
                    },
                   ],
                   position: (597, 42),
                  },
                  position: (597, 33),
                 },
                 Variable {
                  identifier: "defs'",
                  position: (599, 16),
                 },
                ],
               },
              ),
             ],
             target: FunctionApplication {
              function: Variable {
               identifier: "throw",
               position: (600, 14),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "The option `",
                  position: (600, 21),
                 },
                 Expression {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "showOption",
                    position: (600, 35),
                   },
                   arguments: [
                    Variable {
                     identifier: "loc",
                     position: (600, 46),
                    },
                   ],
                  },
                 },
                 Raw {
                  content: "' is read-only, but it's set multiple times. Definition values:",
                  position: (600, 50),
                 },
                 Expression {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "showDefs",
                    position: (600, 115),
                   },
                   arguments: [
                    Variable {
                     identifier: "separateDefs",
                     position: (600, 124),
                    },
                   ],
                  },
                 },
                ],
               },
              ],
             },
             position: (594, 11),
            },
            else_: FunctionApplication {
             function: Variable {
              identifier: "mergeDefinitions",
              position: (602, 11),
             },
             arguments: [
              Variable {
               identifier: "loc",
               position: (602, 28),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "opt",
                position: (602, 32),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (602, 36),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "defs'",
               position: (602, 41),
              },
             ],
            },
            position: (593, 9),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "value",
              position: (606, 7),
             },
            ],
           },
           IfThenElse {
            predicate: HasProperty {
             expression: Variable {
              identifier: "opt",
              position: (606, 18),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "apply",
                position: (606, 24),
               },
              ],
             },
             position: (606, 22),
            },
            then: FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "opt",
               position: (606, 35),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "apply",
                 position: (606, 39),
                },
               ],
              },
              default: None,
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "res",
                position: (606, 45),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "mergedValue",
                  position: (606, 49),
                 },
                ],
               },
               default: None,
              },
             ],
            },
            else_: PropertyAccess {
             expression: Variable {
              identifier: "res",
              position: (606, 66),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "mergedValue",
                position: (606, 70),
               },
              ],
             },
             default: None,
            },
            position: (606, 15),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "warnDeprecation",
              position: (608, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "warnIf",
             position: (609, 9),
            },
            arguments: [
             BinaryOperation {
              operator: NotEqualTo,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "opt",
                 position: (609, 17),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (609, 21),
                  },
                  Raw {
                   content: "deprecationMessage",
                   position: (609, 26),
                  },
                 ],
                },
                default: None,
               },
               Variable {
                identifier: "null",
                position: (609, 48),
               },
              ],
              position: (609, 45),
             },
             String {
              parts: [
               Raw {
                content: "The type `types.",
                position: (610, 12),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "opt",
                  position: (610, 30),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (610, 34),
                   },
                   Raw {
                    content: "name",
                    position: (610, 39),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "' of option `",
                position: (610, 44),
               },
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "showOption",
                  position: (610, 59),
                 },
                 arguments: [
                  Variable {
                   identifier: "loc",
                   position: (610, 70),
                  },
                 ],
                },
               },
               Raw {
                content: "' defined in ",
                position: (610, 74),
               },
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "showFiles",
                  position: (610, 89),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "opt",
                    position: (610, 99),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "declarations",
                      position: (610, 103),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               },
               Raw {
                content: " is deprecated. ",
                position: (610, 116),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "opt",
                  position: (610, 134),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (610, 138),
                   },
                   Raw {
                    content: "deprecationMessage",
                    position: (610, 143),
                   },
                  ],
                 },
                 default: None,
                },
               },
              ],
             },
            ],
           },
          ),
         ],
         target: BinaryOperation {
          operator: Update,
          operands: [
           FunctionApplication {
            function: Variable {
             identifier: "warnDeprecation",
             position: (612, 8),
            },
            arguments: [
             Variable {
              identifier: "opt",
              position: (612, 24),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "value",
                 position: (613, 9),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "builtins",
                 position: (613, 17),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "addErrorContext",
                   position: (613, 26),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "while evaluating the option `",
                   position: (613, 43),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "showOption",
                     position: (613, 74),
                    },
                    arguments: [
                     Variable {
                      identifier: "loc",
                      position: (613, 85),
                     },
                    ],
                   },
                  },
                  Raw {
                   content: "':",
                   position: (613, 89),
                  },
                 ],
                },
                Variable {
                 identifier: "value",
                 position: (613, 93),
                },
               ],
              },
             ),
             Inherit(
              Some(
               PropertyAccess {
                expression: Variable {
                 identifier: "res",
                 position: (614, 18),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "defsFinal'",
                   position: (614, 22),
                  },
                 ],
                },
                default: None,
               },
              ),
              [
               Raw {
                content: "highestPrio",
                position: (614, 34),
               },
              ],
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "definitions",
                 position: (615, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "map",
                position: (615, 23),
               },
               arguments: [
                Function {
                 argument: Some(
                  "def",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: PropertyAccess {
                  expression: Variable {
                   identifier: "def",
                   position: (615, 33),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "value",
                     position: (615, 37),
                    },
                   ],
                  },
                  default: None,
                 },
                 position: (615, 28),
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "res",
                  position: (615, 44),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "defsFinal",
                    position: (615, 48),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "files",
                 position: (616, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "map",
                position: (616, 17),
               },
               arguments: [
                Function {
                 argument: Some(
                  "def",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: PropertyAccess {
                  expression: Variable {
                   identifier: "def",
                   position: (616, 27),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "file",
                     position: (616, 31),
                    },
                   ],
                  },
                  default: None,
                 },
                 position: (616, 22),
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "res",
                  position: (616, 37),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "defsFinal",
                    position: (616, 41),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ),
             Inherit(
              Some(
               Variable {
                identifier: "res",
                position: (617, 18),
               },
              ),
              [
               Raw {
                content: "isDefined",
                position: (617, 23),
               },
              ],
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "__toString",
                 position: (619, 9),
                },
               ],
              },
              Function {
               argument: Some(
                "_",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: FunctionApplication {
                function: Variable {
                 identifier: "showOption",
                 position: (619, 25),
                },
                arguments: [
                 Variable {
                  identifier: "loc",
                  position: (619, 36),
                 },
                ],
               },
               position: (619, 22),
              },
             ),
            ],
            recursive: false,
            position: (613, 7),
           },
          ],
          position: (612, 28),
         },
         position: (585, 5),
        },
        position: (584, 31),
       },
       position: (584, 26),
      },
      position: (584, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mergeDefinitions",
        position: (623, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "loc",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "type",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "defs",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "defsFinal'",
              position: (624, 5),
             },
            ],
           },
           LetIn {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "defs'",
                 position: (627, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "concatMap",
                position: (627, 17),
               },
               arguments: [
                Function {
                 argument: Some(
                  "m",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: FunctionApplication {
                  function: Variable {
                   identifier: "map",
                   position: (628, 11),
                  },
                  arguments: [
                   Function {
                    argument: Some(
                     "value",
                    ),
                    arguments: FunctionArguments {
                     arguments: [],
                     ellipsis: false,
                    },
                    definition: Map {
                     bindings: [
                      Inherit(
                       Some(
                        Variable {
                         identifier: "m",
                         position: (628, 34),
                        },
                       ),
                       [
                        Raw {
                         content: "file",
                         position: (628, 37),
                        },
                       ],
                      ),
                      Inherit(
                       None,
                       [
                        Raw {
                         content: "value",
                         position: (628, 51),
                        },
                       ],
                      ),
                     ],
                     recursive: false,
                     position: (628, 23),
                    },
                    position: (628, 16),
                   },
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "builtins",
                      position: (628, 62),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "addErrorContext",
                        position: (628, 71),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "while evaluating definitions from `",
                        position: (628, 88),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "m",
                          position: (628, 125),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "file",
                            position: (628, 127),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "':",
                        position: (628, 132),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "dischargeProperties",
                       position: (628, 137),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "m",
                         position: (628, 157),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "value",
                           position: (628, 159),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    ],
                   },
                  ],
                 },
                 position: (627, 28),
                },
                Variable {
                 identifier: "defs",
                 position: (629, 11),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "defs''",
                 position: (632, 9),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "filterOverrides'",
                position: (632, 18),
               },
               arguments: [
                Variable {
                 identifier: "defs'",
                 position: (632, 35),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "defs'''",
                 position: (635, 9),
                },
               ],
              },
              IfThenElse {
               predicate: FunctionApplication {
                function: Variable {
                 identifier: "any",
                 position: (637, 14),
                },
                arguments: [
                 Function {
                  argument: Some(
                   "def",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "def",
                      position: (637, 24),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "value",
                        position: (637, 28),
                       },
                       Raw {
                        content: "_type",
                        position: (637, 34),
                       },
                      ],
                     },
                     default: Some(
                      String {
                       parts: [],
                      },
                     ),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "order",
                       position: (637, 50),
                      },
                     ],
                    },
                   ],
                   position: (637, 46),
                  },
                  position: (637, 19),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "defs''",
                   position: (637, 58),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "values",
                     position: (637, 65),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
               then: FunctionApplication {
                function: Variable {
                 identifier: "sortProperties",
                 position: (638, 16),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "defs''",
                   position: (638, 31),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "values",
                     position: (638, 38),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
               else_: PropertyAccess {
                expression: Variable {
                 identifier: "defs''",
                 position: (639, 16),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "values",
                   position: (639, 23),
                  },
                 ],
                },
                default: None,
               },
               position: (637, 11),
              },
             ),
            ],
            target: Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "values",
                  position: (641, 9),
                 },
                ],
               },
               Variable {
                identifier: "defs'''",
                position: (641, 18),
               },
              ),
              Inherit(
               Some(
                Variable {
                 identifier: "defs''",
                 position: (642, 18),
                },
               ),
               [
                Raw {
                 content: "highestPrio",
                 position: (642, 26),
                },
               ],
              ),
             ],
             recursive: false,
             position: (640, 10),
            },
            position: (625, 7),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "defsFinal",
              position: (644, 5),
             },
            ],
           },
           PropertyAccess {
            expression: Variable {
             identifier: "defsFinal'",
             position: (644, 17),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "values",
               position: (644, 28),
              },
             ],
            },
            default: None,
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "mergedValue",
              position: (647, 5),
             },
            ],
           },
           IfThenElse {
            predicate: Variable {
             identifier: "isDefined",
             position: (648, 10),
            },
            then: IfThenElse {
             predicate: FunctionApplication {
              function: Variable {
               identifier: "all",
               position: (649, 12),
              },
              arguments: [
               Function {
                argument: Some(
                 "def",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "type",
                   position: (649, 22),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "check",
                     position: (649, 27),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "def",
                    position: (649, 33),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "value",
                      position: (649, 37),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
                position: (649, 17),
               },
               Variable {
                identifier: "defsFinal",
                position: (649, 44),
               },
              ],
             },
             then: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "type",
                position: (649, 59),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "merge",
                  position: (649, 64),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Variable {
                identifier: "loc",
                position: (649, 70),
               },
               Variable {
                identifier: "defsFinal",
                position: (649, 74),
               },
              ],
             },
             else_: LetIn {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "allInvalid",
                   position: (650, 18),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "filter",
                  position: (650, 31),
                 },
                 arguments: [
                  Function {
                   argument: Some(
                    "def",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: UnaryOperation {
                    operator: Not,
                    operand: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "type",
                       position: (650, 46),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "check",
                         position: (650, 51),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "def",
                        position: (650, 57),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "value",
                          position: (650, 61),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                    position: (650, 44),
                   },
                   position: (650, 39),
                  },
                  Variable {
                   identifier: "defsFinal",
                   position: (650, 68),
                  },
                 ],
                },
               ),
              ],
              target: FunctionApplication {
               function: Variable {
                identifier: "throw",
                position: (651, 12),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "A definition for option `",
                   position: (651, 19),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "showOption",
                     position: (651, 46),
                    },
                    arguments: [
                     Variable {
                      identifier: "loc",
                      position: (651, 57),
                     },
                    ],
                   },
                  },
                  Raw {
                   content: "' is not of type `",
                   position: (651, 61),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "type",
                     position: (651, 81),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (651, 86),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "'. Definition values:",
                   position: (651, 98),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "showDefs",
                     position: (651, 121),
                    },
                    arguments: [
                     Variable {
                      identifier: "allInvalid",
                      position: (651, 130),
                     },
                    ],
                   },
                  },
                 ],
                },
               ],
              },
              position: (650, 14),
             },
             position: (649, 9),
            },
            else_: FunctionApplication {
             function: Variable {
              identifier: "throw",
              position: (655, 9),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "The option `",
                 position: (655, 16),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "showOption",
                   position: (655, 30),
                  },
                  arguments: [
                   Variable {
                    identifier: "loc",
                    position: (655, 41),
                   },
                  ],
                 },
                },
                Raw {
                 content: "' is used but not defined.",
                 position: (655, 45),
                },
               ],
              },
             ],
            },
            position: (648, 7),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "isDefined",
              position: (657, 5),
             },
            ],
           },
           BinaryOperation {
            operator: NotEqualTo,
            operands: [
             Variable {
              identifier: "defsFinal",
              position: (657, 17),
             },
             List {
              elements: [],
              position: (657, 30),
             },
            ],
            position: (657, 27),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "optionalValue",
              position: (659, 5),
             },
            ],
           },
           IfThenElse {
            predicate: Variable {
             identifier: "isDefined",
             position: (660, 10),
            },
            then: Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "value",
                  position: (660, 27),
                 },
                ],
               },
               Variable {
                identifier: "mergedValue",
                position: (660, 35),
               },
              ),
             ],
             recursive: false,
             position: (660, 25),
            },
            else_: Map {
             bindings: [],
             recursive: false,
             position: (661, 12),
            },
            position: (660, 7),
           },
          ),
         ],
         recursive: true,
         position: (623, 39),
        },
        position: (623, 33),
       },
       position: (623, 27),
      },
      position: (623, 22),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "pushDownProperties",
        position: (679, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "cfg",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: IfThenElse {
       predicate: BinaryOperation {
        operator: EqualTo,
        operands: [
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (680, 8),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "_type",
             position: (680, 12),
            },
           ],
          },
          default: Some(
           String {
            parts: [],
           },
          ),
         },
         String {
          parts: [
           Raw {
            content: "merge",
            position: (680, 28),
           },
          ],
         },
        ],
        position: (680, 24),
       },
       then: FunctionApplication {
        function: Variable {
         identifier: "concatMap",
         position: (681, 7),
        },
        arguments: [
         Variable {
          identifier: "pushDownProperties",
          position: (681, 17),
         },
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (681, 36),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "contents",
             position: (681, 40),
            },
           ],
          },
          default: None,
         },
        ],
       },
       else_: IfThenElse {
        predicate: BinaryOperation {
         operator: EqualTo,
         operands: [
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (682, 13),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "_type",
              position: (682, 17),
             },
            ],
           },
           default: Some(
            String {
             parts: [],
            },
           ),
          },
          String {
           parts: [
            Raw {
             content: "if",
             position: (682, 33),
            },
           ],
          },
         ],
         position: (682, 29),
        },
        then: FunctionApplication {
         function: Variable {
          identifier: "map",
          position: (683, 7),
         },
         arguments: [
          FunctionApplication {
           function: Variable {
            identifier: "mapAttrs",
            position: (683, 12),
           },
           arguments: [
            Function {
             argument: Some(
              "n",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: Function {
              argument: Some(
               "v",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: FunctionApplication {
               function: Variable {
                identifier: "mkIf",
                position: (683, 28),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (683, 33),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "condition",
                    position: (683, 37),
                   },
                  ],
                 },
                 default: None,
                },
                Variable {
                 identifier: "v",
                 position: (683, 47),
                },
               ],
              },
              position: (683, 25),
             },
             position: (683, 22),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "pushDownProperties",
            position: (683, 52),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (683, 71),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "content",
                position: (683, 75),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ],
        },
        else_: IfThenElse {
         predicate: BinaryOperation {
          operator: EqualTo,
          operands: [
           PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (684, 13),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "_type",
               position: (684, 17),
              },
             ],
            },
            default: Some(
             String {
              parts: [],
             },
            ),
           },
           String {
            parts: [
             Raw {
              content: "override",
              position: (684, 33),
             },
            ],
           },
          ],
          position: (684, 29),
         },
         then: FunctionApplication {
          function: Variable {
           identifier: "map",
           position: (685, 7),
          },
          arguments: [
           FunctionApplication {
            function: Variable {
             identifier: "mapAttrs",
             position: (685, 12),
            },
            arguments: [
             Function {
              argument: Some(
               "n",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "v",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: FunctionApplication {
                function: Variable {
                 identifier: "mkOverride",
                 position: (685, 28),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (685, 39),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "priority",
                     position: (685, 43),
                    },
                   ],
                  },
                  default: None,
                 },
                 Variable {
                  identifier: "v",
                  position: (685, 52),
                 },
                ],
               },
               position: (685, 25),
              },
              position: (685, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "pushDownProperties",
             position: (685, 57),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (685, 76),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "content",
                 position: (685, 80),
                },
               ],
              },
              default: None,
             },
            ],
           },
          ],
         },
         else_: List {
          elements: [
           Variable {
            identifier: "cfg",
            position: (687, 9),
           },
          ],
          position: (687, 7),
         },
         position: (684, 10),
        },
        position: (682, 10),
       },
       position: (680, 5),
      },
      position: (679, 24),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "dischargeProperties",
        position: (699, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "def",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: IfThenElse {
       predicate: BinaryOperation {
        operator: EqualTo,
        operands: [
         PropertyAccess {
          expression: Variable {
           identifier: "def",
           position: (700, 8),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "_type",
             position: (700, 12),
            },
           ],
          },
          default: Some(
           String {
            parts: [],
           },
          ),
         },
         String {
          parts: [
           Raw {
            content: "merge",
            position: (700, 28),
           },
          ],
         },
        ],
        position: (700, 24),
       },
       then: FunctionApplication {
        function: Variable {
         identifier: "concatMap",
         position: (701, 7),
        },
        arguments: [
         Variable {
          identifier: "dischargeProperties",
          position: (701, 17),
         },
         PropertyAccess {
          expression: Variable {
           identifier: "def",
           position: (701, 37),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "contents",
             position: (701, 41),
            },
           ],
          },
          default: None,
         },
        ],
       },
       else_: IfThenElse {
        predicate: BinaryOperation {
         operator: EqualTo,
         operands: [
          PropertyAccess {
           expression: Variable {
            identifier: "def",
            position: (702, 13),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "_type",
              position: (702, 17),
             },
            ],
           },
           default: Some(
            String {
             parts: [],
            },
           ),
          },
          String {
           parts: [
            Raw {
             content: "if",
             position: (702, 33),
            },
           ],
          },
         ],
         position: (702, 29),
        },
        then: IfThenElse {
         predicate: FunctionApplication {
          function: Variable {
           identifier: "isBool",
           position: (703, 10),
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "def",
             position: (703, 17),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "condition",
               position: (703, 21),
              },
             ],
            },
            default: None,
           },
          ],
         },
         then: IfThenElse {
          predicate: PropertyAccess {
           expression: Variable {
            identifier: "def",
            position: (704, 12),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "condition",
              position: (704, 16),
             },
            ],
           },
           default: None,
          },
          then: FunctionApplication {
           function: Variable {
            identifier: "dischargeProperties",
            position: (705, 11),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "def",
              position: (705, 31),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "content",
                position: (705, 35),
               },
              ],
             },
             default: None,
            },
           ],
          },
          else_: List {
           elements: [],
           position: (707, 11),
          },
          position: (704, 9),
         },
         else_: FunctionApplication {
          function: Variable {
           identifier: "throw",
           position: (709, 9),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: "‘mkIf’ called with a non-Boolean condition",
              position: (709, 16),
             },
            ],
           },
          ],
         },
         position: (703, 7),
        },
        else_: List {
         elements: [
          Variable {
           identifier: "def",
           position: (711, 9),
          },
         ],
         position: (711, 7),
        },
        position: (702, 10),
       },
       position: (700, 5),
      },
      position: (699, 25),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "filterOverrides",
        position: (732, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "defs",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: PropertyAccess {
       expression: FunctionApplication {
        function: Variable {
         identifier: "filterOverrides'",
         position: (732, 28),
        },
        arguments: [
         Variable {
          identifier: "defs",
          position: (732, 45),
         },
        ],
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "values",
          position: (732, 51),
         },
        ],
       },
       default: None,
      },
      position: (732, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "filterOverrides'",
        position: (734, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "defs",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: LetIn {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "getPrio",
            position: (736, 7),
           },
          ],
         },
         Function {
          argument: Some(
           "def",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: IfThenElse {
           predicate: BinaryOperation {
            operator: EqualTo,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "def",
               position: (736, 25),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "value",
                 position: (736, 29),
                },
                Raw {
                 content: "_type",
                 position: (736, 35),
                },
               ],
              },
              default: Some(
               String {
                parts: [],
               },
              ),
             },
             String {
              parts: [
               Raw {
                content: "override",
                position: (736, 51),
               },
              ],
             },
            ],
            position: (736, 47),
           },
           then: PropertyAccess {
            expression: Variable {
             identifier: "def",
             position: (736, 66),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "value",
               position: (736, 70),
              },
              Raw {
               content: "priority",
               position: (736, 76),
              },
             ],
            },
            default: None,
           },
           else_: Variable {
            identifier: "defaultPriority",
            position: (736, 90),
           },
           position: (736, 22),
          },
          position: (736, 17),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "highestPrio",
            position: (737, 7),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "foldl'",
           position: (737, 21),
          },
          arguments: [
           Function {
            argument: Some(
             "prio",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Function {
             argument: Some(
              "def",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: FunctionApplication {
              function: Variable {
               identifier: "min",
               position: (737, 40),
              },
              arguments: [
               FunctionApplication {
                function: Variable {
                 identifier: "getPrio",
                 position: (737, 45),
                },
                arguments: [
                 Variable {
                  identifier: "def",
                  position: (737, 53),
                 },
                ],
               },
               Variable {
                identifier: "prio",
                position: (737, 58),
               },
              ],
             },
             position: (737, 35),
            },
            position: (737, 29),
           },
           Int {
            value: 9999,
            position: (737, 64),
           },
           Variable {
            identifier: "defs",
            position: (737, 69),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "strip",
            position: (738, 7),
           },
          ],
         },
         Function {
          argument: Some(
           "def",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: IfThenElse {
           predicate: BinaryOperation {
            operator: EqualTo,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "def",
               position: (738, 23),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "value",
                 position: (738, 27),
                },
                Raw {
                 content: "_type",
                 position: (738, 33),
                },
               ],
              },
              default: Some(
               String {
                parts: [],
               },
              ),
             },
             String {
              parts: [
               Raw {
                content: "override",
                position: (738, 49),
               },
              ],
             },
            ],
            position: (738, 45),
           },
           then: BinaryOperation {
            operator: Update,
            operands: [
             Variable {
              identifier: "def",
              position: (738, 64),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "value",
                   position: (738, 73),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "def",
                  position: (738, 81),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "value",
                    position: (738, 85),
                   },
                   Raw {
                    content: "content",
                    position: (738, 91),
                   },
                  ],
                 },
                 default: None,
                },
               ),
              ],
              recursive: false,
              position: (738, 71),
             },
            ],
            position: (738, 68),
           },
           else_: Variable {
            identifier: "def",
            position: (738, 107),
           },
           position: (738, 20),
          },
          position: (738, 15),
         },
        ),
       ],
       target: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "values",
             position: (740, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "concatMap",
            position: (740, 16),
           },
           arguments: [
            Function {
             argument: Some(
              "def",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: IfThenElse {
              predicate: BinaryOperation {
               operator: EqualTo,
               operands: [
                FunctionApplication {
                 function: Variable {
                  identifier: "getPrio",
                  position: (740, 35),
                 },
                 arguments: [
                  Variable {
                   identifier: "def",
                   position: (740, 43),
                  },
                 ],
                },
                Variable {
                 identifier: "highestPrio",
                 position: (740, 50),
                },
               ],
               position: (740, 47),
              },
              then: List {
               elements: [
                FunctionApplication {
                 function: Variable {
                  identifier: "strip",
                  position: (740, 69),
                 },
                 arguments: [
                  Variable {
                   identifier: "def",
                   position: (740, 75),
                  },
                 ],
                },
               ],
               position: (740, 67),
              },
              else_: List {
               elements: [],
               position: (740, 86),
              },
              position: (740, 32),
             },
             position: (740, 27),
            },
            Variable {
             identifier: "defs",
             position: (740, 90),
            },
           ],
          },
         ),
         Inherit(
          None,
          [
           Raw {
            content: "highestPrio",
            position: (741, 15),
           },
          ],
         ),
        ],
        recursive: false,
        position: (739, 8),
       },
       position: (735, 5),
      },
      position: (734, 22),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "sortProperties",
        position: (747, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "defs",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: LetIn {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "strip",
            position: (749, 7),
           },
          ],
         },
         Function {
          argument: Some(
           "def",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: IfThenElse {
           predicate: BinaryOperation {
            operator: EqualTo,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "def",
               position: (750, 12),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "value",
                 position: (750, 16),
                },
                Raw {
                 content: "_type",
                 position: (750, 22),
                },
               ],
              },
              default: Some(
               String {
                parts: [],
               },
              ),
             },
             String {
              parts: [
               Raw {
                content: "order",
                position: (750, 38),
               },
              ],
             },
            ],
            position: (750, 34),
           },
           then: BinaryOperation {
            operator: Update,
            operands: [
             Variable {
              identifier: "def",
              position: (751, 14),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "value",
                   position: (751, 23),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "def",
                  position: (751, 31),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "value",
                    position: (751, 35),
                   },
                   Raw {
                    content: "content",
                    position: (751, 41),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               Inherit(
                Some(
                 PropertyAccess {
                  expression: Variable {
                   identifier: "def",
                   position: (751, 59),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "value",
                     position: (751, 63),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                [
                 Raw {
                  content: "priority",
                  position: (751, 70),
                 },
                ],
               ),
              ],
              recursive: false,
              position: (751, 21),
             },
            ],
            position: (751, 18),
           },
           else_: Variable {
            identifier: "def",
            position: (752, 14),
           },
           position: (750, 9),
          },
          position: (749, 15),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "defs'",
            position: (753, 7),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "map",
           position: (753, 15),
          },
          arguments: [
           Variable {
            identifier: "strip",
            position: (753, 19),
           },
           Variable {
            identifier: "defs",
            position: (753, 25),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "compare",
            position: (754, 7),
           },
          ],
         },
         Function {
          argument: Some(
           "a",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: Function {
           argument: Some(
            "b",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: BinaryOperation {
            operator: LessThan,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "a",
               position: (754, 24),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "priority",
                 position: (754, 26),
                },
               ],
              },
              default: Some(
               Int {
                value: 1000,
                position: (754, 38),
               },
              ),
             },
             PropertyAccess {
              expression: Variable {
               identifier: "b",
               position: (754, 47),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "priority",
                 position: (754, 49),
                },
               ],
              },
              default: Some(
               Int {
                value: 1000,
                position: (754, 61),
               },
              ),
             },
            ],
            position: (754, 44),
           },
           position: (754, 20),
          },
          position: (754, 17),
         },
        ),
       ],
       target: FunctionApplication {
        function: Variable {
         identifier: "sort",
         position: (755, 8),
        },
        arguments: [
         Variable {
          identifier: "compare",
          position: (755, 13),
         },
         Variable {
          identifier: "defs'",
          position: (755, 21),
         },
        ],
       },
       position: (748, 5),
      },
      position: (747, 20),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "fixupOptionType",
        position: (760, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "loc",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "opt",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "options",
             position: (762, 7),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "opt",
            position: (762, 17),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "options",
              position: (762, 21),
             },
            ],
           },
           default: Some(
            FunctionApplication {
             function: Variable {
              identifier: "throw",
              position: (763, 10),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "Option `",
                 position: (763, 17),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "showOption",
                   position: (763, 27),
                  },
                  arguments: [
                   Variable {
                    identifier: "loc",
                    position: (763, 38),
                   },
                  ],
                 },
                },
                Raw {
                 content: "' has type optionSet but has no option attribute, in ",
                 position: (763, 42),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "showFiles",
                   position: (763, 97),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "opt",
                     position: (763, 107),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "declarations",
                       position: (763, 111),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Raw {
                 content: ".",
                 position: (763, 124),
                },
               ],
              },
             ],
            },
           ),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "f",
             position: (764, 7),
            },
           ],
          },
          Function {
           argument: Some(
            "tp",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: LetIn {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "optionSetIn",
                 position: (765, 13),
                },
               ],
              },
              Function {
               argument: Some(
                "type",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: BinaryOperation {
                operator: LogicalAnd,
                operands: [
                 BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "tp",
                     position: (765, 34),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "name",
                       position: (765, 37),
                      },
                     ],
                    },
                    default: None,
                   },
                   Variable {
                    identifier: "type",
                    position: (765, 45),
                   },
                  ],
                  position: (765, 42),
                 },
                 BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "tp",
                     position: (765, 55),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "functor",
                       position: (765, 58),
                      },
                      Raw {
                       content: "wrapped",
                       position: (765, 66),
                      },
                      Raw {
                       content: "name",
                       position: (765, 74),
                      },
                     ],
                    },
                    default: None,
                   },
                   String {
                    parts: [
                     Raw {
                      content: "optionSet",
                      position: (765, 83),
                     },
                    ],
                   },
                  ],
                  position: (765, 79),
                 },
                ],
                position: (765, 51),
               },
               position: (765, 27),
              },
             ),
            ],
            target: IfThenElse {
             predicate: BinaryOperation {
              operator: LogicalOr,
              operands: [
               BinaryOperation {
                operator: EqualTo,
                operands: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "tp",
                   position: (767, 12),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "name",
                     position: (767, 15),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "option set",
                    position: (767, 24),
                   },
                  ],
                 },
                ],
                position: (767, 20),
               },
               BinaryOperation {
                operator: EqualTo,
                operands: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "tp",
                   position: (767, 39),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "name",
                     position: (767, 42),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "submodule",
                    position: (767, 51),
                   },
                  ],
                 },
                ],
                position: (767, 47),
               },
              ],
              position: (767, 36),
             },
             then: FunctionApplication {
              function: Variable {
               identifier: "throw",
               position: (768, 11),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "The option ",
                  position: (768, 18),
                 },
                 Expression {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "showOption",
                    position: (768, 31),
                   },
                   arguments: [
                    Variable {
                     identifier: "loc",
                     position: (768, 42),
                    },
                   ],
                  },
                 },
                 Raw {
                  content: " uses submodules without a wrapping type, in ",
                  position: (768, 46),
                 },
                 Expression {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "showFiles",
                    position: (768, 93),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "opt",
                      position: (768, 103),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "declarations",
                        position: (768, 107),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 },
                 Raw {
                  content: ".",
                  position: (768, 120),
                 },
                ],
               },
              ],
             },
             else_: IfThenElse {
              predicate: FunctionApplication {
               function: Variable {
                identifier: "optionSetIn",
                position: (769, 17),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "attrsOf",
                   position: (769, 30),
                  },
                 ],
                },
               ],
              },
              then: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (769, 44),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "attrsOf",
                   position: (769, 50),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (769, 59),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "submodule",
                     position: (769, 65),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  Variable {
                   identifier: "options",
                   position: (769, 75),
                  },
                 ],
                },
               ],
              },
              else_: IfThenElse {
               predicate: FunctionApplication {
                function: Variable {
                 identifier: "optionSetIn",
                 position: (770, 17),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "listOf",
                    position: (770, 30),
                   },
                  ],
                 },
                ],
               },
               then: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (770, 44),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "listOf",
                    position: (770, 50),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (770, 59),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "submodule",
                      position: (770, 65),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "options",
                    position: (770, 75),
                   },
                  ],
                 },
                ],
               },
               else_: IfThenElse {
                predicate: FunctionApplication {
                 function: Variable {
                  identifier: "optionSetIn",
                  position: (771, 17),
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "nullOr",
                     position: (771, 30),
                    },
                   ],
                  },
                 ],
                },
                then: FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (771, 44),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "nullOr",
                     position: (771, 50),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (771, 59),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "submodule",
                       position: (771, 65),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "options",
                     position: (771, 75),
                    },
                   ],
                  },
                 ],
                },
                else_: Variable {
                 identifier: "tp",
                 position: (772, 14),
                },
                position: (771, 14),
               },
               position: (770, 14),
              },
              position: (769, 14),
             },
             position: (767, 9),
            },
            position: (765, 9),
           },
           position: (764, 11),
          },
         ),
        ],
        target: IfThenElse {
         predicate: BinaryOperation {
          operator: EqualTo,
          operands: [
           PropertyAccess {
            expression: Variable {
             identifier: "opt",
             position: (774, 10),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "type",
               position: (774, 14),
              },
              Raw {
               content: "getSubModules",
               position: (774, 19),
              },
             ],
            },
            default: Some(
             Variable {
              identifier: "null",
              position: (774, 36),
             },
            ),
           },
           Variable {
            identifier: "null",
            position: (774, 44),
           },
          ],
          position: (774, 41),
         },
         then: BinaryOperation {
          operator: Update,
          operands: [
           Variable {
            identifier: "opt",
            position: (775, 12),
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (775, 21),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "f",
                position: (775, 28),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "opt",
                  position: (775, 31),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (775, 35),
                   },
                  ],
                 },
                 default: Some(
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (775, 43),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "unspecified",
                      position: (775, 49),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (775, 19),
           },
          ],
          position: (775, 16),
         },
         else_: BinaryOperation {
          operator: Update,
          operands: [
           Variable {
            identifier: "opt",
            position: (776, 12),
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (776, 21),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "opt",
                 position: (776, 28),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (776, 32),
                  },
                  Raw {
                   content: "substSubModules",
                   position: (776, 37),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "opt",
                  position: (776, 53),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "options",
                    position: (776, 57),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "options",
                 position: (776, 66),
                },
               ],
              },
              List {
               elements: [],
               position: (776, 76),
              },
             ),
            ],
            recursive: false,
            position: (776, 19),
           },
          ],
          position: (776, 16),
         },
         position: (774, 7),
        },
        position: (761, 5),
       },
       position: (760, 26),
      },
      position: (760, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkIf",
        position: (781, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "condition",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "content",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "_type",
             position: (782, 7),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "if",
             position: (782, 16),
            },
           ],
          },
         ),
         Inherit(
          None,
          [
           Raw {
            content: "condition",
            position: (783, 15),
           },
           Raw {
            content: "content",
            position: (783, 25),
           },
          ],
         ),
        ],
        recursive: false,
        position: (782, 5),
       },
       position: (781, 21),
      },
      position: (781, 10),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkAssert",
        position: (786, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "assertion",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "message",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "content",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: FunctionApplication {
         function: Variable {
          identifier: "mkIf",
          position: (787, 5),
         },
         arguments: [
          IfThenElse {
           predicate: Variable {
            identifier: "assertion",
            position: (788, 11),
           },
           then: Variable {
            identifier: "true",
            position: (788, 26),
           },
           else_: FunctionApplication {
            function: Variable {
             identifier: "throw",
             position: (788, 36),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "\nFailed assertion: ",
                position: (788, 43),
               },
               Expression {
                expression: Variable {
                 identifier: "message",
                 position: (788, 65),
                },
               },
              ],
             },
            ],
           },
           position: (788, 8),
          },
          Variable {
           identifier: "content",
           position: (789, 7),
          },
         ],
        },
        position: (786, 34),
       },
       position: (786, 25),
      },
      position: (786, 14),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkMerge",
        position: (791, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "contents",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "_type",
            position: (792, 7),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "merge",
            position: (792, 16),
           },
          ],
         },
        ),
        Inherit(
         None,
         [
          Raw {
           content: "contents",
           position: (793, 15),
          },
         ],
        ),
       ],
       recursive: false,
       position: (792, 5),
      },
      position: (791, 13),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkOverride",
        position: (796, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "priority",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "content",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "_type",
             position: (797, 7),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "override",
             position: (797, 16),
            },
           ],
          },
         ),
         Inherit(
          None,
          [
           Raw {
            content: "priority",
            position: (798, 15),
           },
           Raw {
            content: "content",
            position: (798, 24),
           },
          ],
         ),
        ],
        recursive: false,
        position: (797, 5),
       },
       position: (796, 26),
      },
      position: (796, 16),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkOptionDefault",
        position: (801, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "mkOverride",
       position: (801, 21),
      },
      arguments: [
       Int {
        value: 1500,
        position: (801, 32),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkDefault",
        position: (802, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "mkOverride",
       position: (802, 15),
      },
      arguments: [
       Int {
        value: 1000,
        position: (802, 26),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkImageMediaOverride",
        position: (803, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "mkOverride",
       position: (803, 26),
      },
      arguments: [
       Int {
        value: 60,
        position: (803, 37),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkForce",
        position: (804, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "mkOverride",
       position: (804, 13),
      },
      arguments: [
       Int {
        value: 50,
        position: (804, 24),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkVMOverride",
        position: (805, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "mkOverride",
       position: (805, 18),
      },
      arguments: [
       Int {
        value: 10,
        position: (805, 29),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkFixStrictness",
        position: (807, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (807, 21),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "warn",
          position: (807, 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: (807, 31),
         },
        ],
       },
       Variable {
        identifier: "id",
        position: (807, 157),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkOrder",
        position: (809, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "priority",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "content",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "_type",
             position: (810, 7),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "order",
             position: (810, 16),
            },
           ],
          },
         ),
         Inherit(
          None,
          [
           Raw {
            content: "priority",
            position: (811, 15),
           },
           Raw {
            content: "content",
            position: (811, 24),
           },
          ],
         ),
        ],
        recursive: false,
        position: (810, 5),
       },
       position: (809, 23),
      },
      position: (809, 13),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkBefore",
        position: (814, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "mkOrder",
       position: (814, 14),
      },
      arguments: [
       Int {
        value: 500,
        position: (814, 22),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkAfter",
        position: (815, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "mkOrder",
       position: (815, 13),
      },
      arguments: [
       Int {
        value: 1500,
        position: (815, 21),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "defaultPriority",
        position: (818, 3),
       },
      ],
     },
     Int {
      value: 100,
      position: (818, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkAliasDefinitions",
        position: (839, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "mkAliasAndWrapDefinitions",
       position: (839, 24),
      },
      arguments: [
       Variable {
        identifier: "id",
        position: (839, 50),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkAliasAndWrapDefinitions",
        position: (840, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "wrap",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "option",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "mkAliasIfDef",
         position: (841, 5),
        },
        arguments: [
         Variable {
          identifier: "option",
          position: (841, 18),
         },
         FunctionApplication {
          function: Variable {
           identifier: "wrap",
           position: (841, 26),
          },
          arguments: [
           FunctionApplication {
            function: Variable {
             identifier: "mkMerge",
             position: (841, 32),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "option",
               position: (841, 40),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "definitions",
                 position: (841, 47),
                },
               ],
              },
              default: None,
             },
            ],
           },
          ],
         },
        ],
       },
       position: (840, 37),
      },
      position: (840, 31),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkAliasAndWrapDefsWithPriority",
        position: (847, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "wrap",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "option",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "prio",
             position: (849, 7),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "option",
            position: (849, 14),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "highestPrio",
              position: (849, 21),
             },
            ],
           },
           default: Some(
            Variable {
             identifier: "defaultPriority",
             position: (849, 36),
            },
           ),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "defsWithPrio",
             position: (850, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "map",
            position: (850, 22),
           },
           arguments: [
            FunctionApplication {
             function: Variable {
              identifier: "mkOverride",
              position: (850, 27),
             },
             arguments: [
              Variable {
               identifier: "prio",
               position: (850, 38),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "option",
              position: (850, 44),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "definitions",
                position: (850, 51),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ),
        ],
        target: FunctionApplication {
         function: Variable {
          identifier: "mkAliasIfDef",
          position: (851, 8),
         },
         arguments: [
          Variable {
           identifier: "option",
           position: (851, 21),
          },
          FunctionApplication {
           function: Variable {
            identifier: "wrap",
            position: (851, 29),
           },
           arguments: [
            FunctionApplication {
             function: Variable {
              identifier: "mkMerge",
              position: (851, 35),
             },
             arguments: [
              Variable {
               identifier: "defsWithPrio",
               position: (851, 43),
              },
             ],
            },
           ],
          },
         ],
        },
        position: (848, 5),
       },
       position: (847, 42),
      },
      position: (847, 36),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkAliasIfDef",
        position: (853, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "option",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (854, 5),
       },
       arguments: [
        BinaryOperation {
         operator: LogicalAnd,
         operands: [
          FunctionApplication {
           function: Variable {
            identifier: "isOption",
            position: (854, 11),
           },
           arguments: [
            Variable {
             identifier: "option",
             position: (854, 20),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "option",
            position: (854, 30),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "isDefined",
              position: (854, 37),
             },
            ],
           },
           default: None,
          },
         ],
         position: (854, 27),
        },
       ],
      },
      position: (853, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "fixMergeModules",
        position: (857, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "modules",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "args",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "evalModules",
         position: (857, 36),
        },
        arguments: [
         Map {
          bindings: [
           Inherit(
            None,
            [
             Raw {
              content: "modules",
              position: (857, 58),
             },
             Raw {
              content: "args",
              position: (857, 66),
             },
            ],
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "check",
               position: (857, 72),
              },
             ],
            },
            Variable {
             identifier: "false",
             position: (857, 80),
            },
           ),
          ],
          recursive: false,
          position: (857, 48),
         },
        ],
       },
       position: (857, 30),
      },
      position: (857, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkRemovedOptionModule",
        position: (872, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "optionName",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "replacementInstructions",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: None,
        arguments: FunctionArguments {
         arguments: [
          FunctionArgument {
           identifier: "options",
           default: None,
          },
         ],
         ellipsis: true,
        },
        definition: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "options",
              position: (874, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "setAttrByPath",
             position: (874, 17),
            },
            arguments: [
             Variable {
              identifier: "optionName",
              position: (874, 31),
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (874, 43),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "visible",
                     position: (875, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "false",
                   position: (875, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "apply",
                     position: (876, 9),
                    },
                   ],
                  },
                  Function {
                   argument: Some(
                    "x",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: FunctionApplication {
                    function: Variable {
                     identifier: "throw",
                     position: (876, 20),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "The option `",
                        position: (876, 27),
                       },
                       Expression {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "showOption",
                          position: (876, 41),
                         },
                         arguments: [
                          Variable {
                           identifier: "optionName",
                           position: (876, 52),
                          },
                         ],
                        },
                       },
                       Raw {
                        content: "' can no longer be used since it's been removed. ",
                        position: (876, 63),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "replacementInstructions",
                         position: (876, 114),
                        },
                       },
                      ],
                     },
                    ],
                   },
                   position: (876, 17),
                  },
                 ),
                ],
                recursive: false,
                position: (874, 52),
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "config",
              position: (878, 7),
             },
             Raw {
              content: "assertions",
              position: (878, 14),
             },
            ],
           },
           LetIn {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "opt",
                 position: (879, 13),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "getAttrFromPath",
                position: (879, 19),
               },
               arguments: [
                Variable {
                 identifier: "optionName",
                 position: (879, 35),
                },
                Variable {
                 identifier: "options",
                 position: (879, 46),
                },
               ],
              },
             ),
            ],
            target: List {
             elements: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "assertion",
                    position: (880, 11),
                   },
                  ],
                 },
                 UnaryOperation {
                  operator: Not,
                  operand: PropertyAccess {
                   expression: Variable {
                    identifier: "opt",
                    position: (880, 24),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "isDefined",
                      position: (880, 28),
                     },
                    ],
                   },
                   default: None,
                  },
                  position: (880, 23),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "message",
                    position: (881, 11),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The option definition `",
                    position: (882, 1),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "showOption",
                      position: (882, 38),
                     },
                     arguments: [
                      Variable {
                       identifier: "optionName",
                       position: (882, 49),
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "' in ",
                    position: (882, 60),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "showFiles",
                      position: (882, 67),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (882, 77),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "files",
                          position: (882, 81),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   },
                   Raw {
                    content: " no longer has any effect; please remove it.\n",
                    position: (882, 87),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "replacementInstructions",
                     position: (883, 15),
                    },
                   },
                   Raw {
                    content: "\n",
                    position: (883, 39),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (879, 59),
              },
             ],
             position: (879, 58),
            },
            position: (879, 9),
           },
          ),
         ],
         recursive: false,
         position: (874, 5),
        },
        position: (873, 5),
       },
       position: (872, 39),
      },
      position: (872, 27),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkRenamedOptionModule",
        position: (901, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "from",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "to",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "doRename",
         position: (901, 37),
        },
        arguments: [
         Map {
          bindings: [
           Inherit(
            None,
            [
             Raw {
              content: "from",
              position: (902, 13),
             },
             Raw {
              content: "to",
              position: (902, 18),
             },
            ],
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "visible",
               position: (903, 5),
              },
             ],
            },
            Variable {
             identifier: "false",
             position: (903, 15),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "warn",
               position: (904, 5),
              },
             ],
            },
            Variable {
             identifier: "true",
             position: (904, 12),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "use",
               position: (905, 5),
              },
             ],
            },
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "builtins",
               position: (905, 11),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "trace",
                 position: (905, 20),
                },
               ],
              },
              default: None,
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "Obsolete option `",
                 position: (905, 27),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "showOption",
                   position: (905, 46),
                  },
                  arguments: [
                   Variable {
                    identifier: "from",
                    position: (905, 57),
                   },
                  ],
                 },
                },
                Raw {
                 content: "' is used. It was renamed to `",
                 position: (905, 62),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "showOption",
                   position: (905, 94),
                  },
                  arguments: [
                   Variable {
                    identifier: "to",
                    position: (905, 105),
                   },
                  ],
                 },
                },
                Raw {
                 content: "'.",
                 position: (905, 108),
                },
               ],
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (901, 46),
         },
        ],
       },
       position: (901, 33),
      },
      position: (901, 27),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkMergedOptionModule",
        position: (936, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "from",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "to",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "mergeFn",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Function {
         argument: None,
         arguments: FunctionArguments {
          arguments: [
           FunctionArgument {
            identifier: "options",
            default: None,
           },
           FunctionArgument {
            identifier: "config",
            default: None,
           },
          ],
          ellipsis: true,
         },
         definition: Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "options",
               position: (939, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "foldl'",
              position: (939, 17),
             },
             arguments: [
              Variable {
               identifier: "recursiveUpdate",
               position: (939, 24),
              },
              Map {
               bindings: [],
               recursive: false,
               position: (939, 40),
              },
              FunctionApplication {
               function: Variable {
                identifier: "map",
                position: (939, 44),
               },
               arguments: [
                Function {
                 argument: Some(
                  "path",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: FunctionApplication {
                  function: Variable {
                   identifier: "setAttrByPath",
                   position: (939, 55),
                  },
                  arguments: [
                   Variable {
                    identifier: "path",
                    position: (939, 69),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "mkOption",
                     position: (939, 75),
                    },
                    arguments: [
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "visible",
                           position: (940, 9),
                          },
                         ],
                        },
                        Variable {
                         identifier: "false",
                         position: (940, 19),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "default",
                           position: (942, 9),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "_mkMergedOptionModule",
                           position: (942, 20),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (939, 84),
                     },
                    ],
                   },
                  ],
                 },
                 position: (939, 49),
                },
                Variable {
                 identifier: "from",
                 position: (943, 11),
                },
               ],
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "config",
               position: (945, 7),
              },
             ],
            },
            BinaryOperation {
             operator: Update,
             operands: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "warnings",
                    position: (946, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "filter",
                   position: (946, 20),
                  },
                  arguments: [
                   Function {
                    argument: Some(
                     "x",
                    ),
                    arguments: FunctionArguments {
                     arguments: [],
                     ellipsis: false,
                    },
                    definition: BinaryOperation {
                     operator: NotEqualTo,
                     operands: [
                      Variable {
                       identifier: "x",
                       position: (946, 31),
                      },
                      String {
                       parts: [],
                      },
                     ],
                     position: (946, 33),
                    },
                    position: (946, 28),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "map",
                     position: (946, 41),
                    },
                    arguments: [
                     Function {
                      argument: Some(
                       "f",
                      ),
                      arguments: FunctionArguments {
                       arguments: [],
                       ellipsis: false,
                      },
                      definition: LetIn {
                       bindings: [
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "val",
                            position: (947, 15),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "getAttrFromPath",
                           position: (947, 21),
                          },
                          arguments: [
                           Variable {
                            identifier: "f",
                            position: (947, 37),
                           },
                           Variable {
                            identifier: "config",
                            position: (947, 39),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "opt",
                            position: (948, 15),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "getAttrFromPath",
                           position: (948, 21),
                          },
                          arguments: [
                           Variable {
                            identifier: "f",
                            position: (948, 37),
                           },
                           Variable {
                            identifier: "options",
                            position: (948, 39),
                           },
                          ],
                         },
                        ),
                       ],
                       target: FunctionApplication {
                        function: Variable {
                         identifier: "optionalString",
                         position: (950, 11),
                        },
                        arguments: [
                         BinaryOperation {
                          operator: NotEqualTo,
                          operands: [
                           Variable {
                            identifier: "val",
                            position: (951, 14),
                           },
                           String {
                            parts: [
                             Raw {
                              content: "_mkMergedOptionModule",
                              position: (951, 22),
                             },
                            ],
                           },
                          ],
                          position: (951, 18),
                         },
                         String {
                          parts: [
                           Raw {
                            content: "The option `",
                            position: (952, 14),
                           },
                           Expression {
                            expression: FunctionApplication {
                             function: Variable {
                              identifier: "showOption",
                              position: (952, 28),
                             },
                             arguments: [
                              Variable {
                               identifier: "f",
                               position: (952, 39),
                              },
                             ],
                            },
                           },
                           Raw {
                            content: "' defined in ",
                            position: (952, 41),
                           },
                           Expression {
                            expression: FunctionApplication {
                             function: Variable {
                              identifier: "showFiles",
                              position: (952, 56),
                             },
                             arguments: [
                              PropertyAccess {
                               expression: Variable {
                                identifier: "opt",
                                position: (952, 66),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "files",
                                  position: (952, 70),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ],
                            },
                           },
                           Raw {
                            content: " has been changed to `",
                            position: (952, 76),
                           },
                           Expression {
                            expression: FunctionApplication {
                             function: Variable {
                              identifier: "showOption",
                              position: (952, 100),
                             },
                             arguments: [
                              Variable {
                               identifier: "to",
                               position: (952, 111),
                              },
                             ],
                            },
                           },
                           Raw {
                            content: "' that has a different type. Please read `",
                            position: (952, 114),
                           },
                           Expression {
                            expression: FunctionApplication {
                             function: Variable {
                              identifier: "showOption",
                              position: (952, 158),
                             },
                             arguments: [
                              Variable {
                               identifier: "to",
                               position: (952, 169),
                              },
                             ],
                            },
                           },
                           Raw {
                            content: "' documentation and update your configuration accordingly.",
                            position: (952, 172),
                           },
                          ],
                         },
                        ],
                       },
                       position: (947, 11),
                      },
                      position: (946, 46),
                     },
                     Variable {
                      identifier: "from",
                      position: (953, 11),
                     },
                    ],
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (945, 16),
              },
              FunctionApplication {
               function: Variable {
                identifier: "setAttrByPath",
                position: (954, 12),
               },
               arguments: [
                Variable {
                 identifier: "to",
                 position: (954, 26),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkMerge",
                  position: (954, 30),
                 },
                 arguments: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "optional",
                    position: (955, 15),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "any",
                      position: (956, 17),
                     },
                     arguments: [
                      Function {
                       argument: Some(
                        "f",
                       ),
                       arguments: FunctionArguments {
                        arguments: [],
                        ellipsis: false,
                       },
                       definition: BinaryOperation {
                        operator: NotEqualTo,
                        operands: [
                         FunctionApplication {
                          function: Variable {
                           identifier: "getAttrFromPath",
                           position: (956, 26),
                          },
                          arguments: [
                           Variable {
                            identifier: "f",
                            position: (956, 42),
                           },
                           Variable {
                            identifier: "config",
                            position: (956, 44),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "_mkMergedOptionModule",
                            position: (956, 56),
                           },
                          ],
                         },
                        ],
                        position: (956, 52),
                       },
                       position: (956, 22),
                      },
                      Variable {
                       identifier: "from",
                       position: (956, 80),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "mergeFn",
                      position: (957, 17),
                     },
                     arguments: [
                      Variable {
                       identifier: "config",
                       position: (957, 25),
                      },
                     ],
                    },
                   ],
                  },
                 ],
                },
               ],
              },
             ],
             position: (954, 9),
            },
           ),
          ],
          recursive: false,
          position: (938, 5),
         },
         position: (937, 5),
        },
        position: (936, 36),
       },
       position: (936, 32),
      },
      position: (936, 26),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkChangedOptionModule",
        position: (983, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "from",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "to",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "changeFn",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: FunctionApplication {
         function: Variable {
          identifier: "mkMergedOptionModule",
          position: (984, 5),
         },
         arguments: [
          List {
           elements: [
            Variable {
             identifier: "from",
             position: (984, 28),
            },
           ],
           position: (984, 26),
          },
          Variable {
           identifier: "to",
           position: (984, 35),
          },
          Variable {
           identifier: "changeFn",
           position: (984, 38),
          },
         ],
        },
        position: (983, 37),
       },
       position: (983, 33),
      },
      position: (983, 27),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkAliasOptionModule",
        position: (987, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "from",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "to",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "doRename",
         position: (987, 35),
        },
        arguments: [
         Map {
          bindings: [
           Inherit(
            None,
            [
             Raw {
              content: "from",
              position: (988, 13),
             },
             Raw {
              content: "to",
              position: (988, 18),
             },
            ],
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "visible",
               position: (989, 5),
              },
             ],
            },
            Variable {
             identifier: "true",
             position: (989, 15),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "warn",
               position: (990, 5),
              },
             ],
            },
            Variable {
             identifier: "false",
             position: (990, 12),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "use",
               position: (991, 5),
              },
             ],
            },
            Variable {
             identifier: "id",
             position: (991, 11),
            },
           ),
          ],
          recursive: false,
          position: (987, 44),
         },
        ],
       },
       position: (987, 31),
      },
      position: (987, 25),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkDerivedConfig",
        position: (1009, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "opt",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "f",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "mkOverride",
         position: (1010, 5),
        },
        arguments: [
         PropertyAccess {
          expression: Variable {
           identifier: "opt",
           position: (1011, 8),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "highestPrio",
             position: (1011, 12),
            },
           ],
          },
          default: Some(
           Variable {
            identifier: "defaultPriority",
            position: (1011, 27),
           },
          ),
         },
         FunctionApplication {
          function: Variable {
           identifier: "f",
           position: (1012, 8),
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "opt",
             position: (1012, 10),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "value",
               position: (1012, 14),
              },
             ],
            },
            default: None,
           },
          ],
         },
        ],
       },
       position: (1009, 26),
      },
      position: (1009, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "doRename",
        position: (1014, 3),
       },
      ],
     },
     Function {
      argument: None,
      arguments: FunctionArguments {
       arguments: [
        FunctionArgument {
         identifier: "withPriority",
         default: Some(
          Variable {
           identifier: "true",
           position: (1014, 61),
          },
         ),
        },
        FunctionArgument {
         identifier: "use",
         default: None,
        },
        FunctionArgument {
         identifier: "warn",
         default: None,
        },
        FunctionArgument {
         identifier: "visible",
         default: None,
        },
        FunctionArgument {
         identifier: "to",
         default: None,
        },
        FunctionArgument {
         identifier: "from",
         default: None,
        },
       ],
       ellipsis: false,
      },
      definition: Function {
       argument: None,
       arguments: FunctionArguments {
        arguments: [
         FunctionArgument {
          identifier: "options",
          default: None,
         },
         FunctionArgument {
          identifier: "config",
          default: None,
         },
        ],
        ellipsis: true,
       },
       definition: LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "fromOpt",
             position: (1017, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "getAttrFromPath",
            position: (1017, 17),
           },
           arguments: [
            Variable {
             identifier: "from",
             position: (1017, 33),
            },
            Variable {
             identifier: "options",
             position: (1017, 38),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "toOf",
             position: (1018, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "attrByPath",
            position: (1018, 14),
           },
           arguments: [
            Variable {
             identifier: "to",
             position: (1018, 25),
            },
            FunctionApplication {
             function: Variable {
              identifier: "abort",
              position: (1019, 10),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "Renaming error: option `",
                 position: (1019, 17),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "showOption",
                   position: (1019, 43),
                  },
                  arguments: [
                   Variable {
                    identifier: "to",
                    position: (1019, 54),
                   },
                  ],
                 },
                },
                Raw {
                 content: "' does not exist.",
                 position: (1019, 57),
                },
               ],
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "toType",
             position: (1020, 7),
            },
           ],
          },
          LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "opt",
                position: (1020, 20),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "attrByPath",
               position: (1020, 26),
              },
              arguments: [
               Variable {
                identifier: "to",
                position: (1020, 37),
               },
               Map {
                bindings: [],
                recursive: false,
                position: (1020, 40),
               },
               Variable {
                identifier: "options",
                position: (1020, 43),
               },
              ],
             },
            ),
           ],
           target: PropertyAccess {
            expression: Variable {
             identifier: "opt",
             position: (1020, 55),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "type",
               position: (1020, 59),
              },
             ],
            },
            default: Some(
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (1020, 68),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "submodule",
                  position: (1020, 74),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Map {
                bindings: [],
                recursive: false,
                position: (1020, 84),
               },
              ],
             },
            ),
           },
           position: (1020, 16),
          },
         ),
        ],
        target: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "options",
              position: (1023, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "setAttrByPath",
             position: (1023, 17),
            },
            arguments: [
             Variable {
              identifier: "from",
              position: (1023, 31),
             },
             BinaryOperation {
              operator: Update,
              operands: [
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (1023, 37),
                },
                arguments: [
                 Map {
                  bindings: [
                   Inherit(
                    None,
                    [
                     Raw {
                      content: "visible",
                      position: (1024, 17),
                     },
                    ],
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (1025, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Alias of <option>",
                       position: (1025, 24),
                      },
                      Expression {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "showOption",
                         position: (1025, 43),
                        },
                        arguments: [
                         Variable {
                          identifier: "to",
                          position: (1025, 54),
                         },
                        ],
                       },
                      },
                      Raw {
                       content: "</option>.",
                       position: (1025, 57),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "apply",
                       position: (1026, 9),
                      },
                     ],
                    },
                    Function {
                     argument: Some(
                      "x",
                     ),
                     arguments: FunctionArguments {
                      arguments: [],
                      ellipsis: false,
                     },
                     definition: FunctionApplication {
                      function: Variable {
                       identifier: "use",
                       position: (1026, 20),
                      },
                      arguments: [
                       FunctionApplication {
                        function: Variable {
                         identifier: "toOf",
                         position: (1026, 25),
                        },
                        arguments: [
                         Variable {
                          identifier: "config",
                          position: (1026, 30),
                         },
                        ],
                       },
                      ],
                     },
                     position: (1026, 17),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (1023, 46),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "optionalAttrs",
                 position: (1027, 12),
                },
                arguments: [
                 BinaryOperation {
                  operator: NotEqualTo,
                  operands: [
                   Variable {
                    identifier: "toType",
                    position: (1027, 27),
                   },
                   Variable {
                    identifier: "null",
                    position: (1027, 37),
                   },
                  ],
                  position: (1027, 34),
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (1028, 9),
                      },
                     ],
                    },
                    Variable {
                     identifier: "toType",
                     position: (1028, 16),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (1027, 43),
                 },
                ],
               },
              ],
              position: (1027, 9),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "config",
              position: (1030, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkMerge",
             position: (1030, 16),
            },
            arguments: [
             List {
              elements: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "warnings",
                     position: (1032, 11),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "optional",
                    position: (1032, 22),
                   },
                   arguments: [
                    BinaryOperation {
                     operator: LogicalAnd,
                     operands: [
                      Variable {
                       identifier: "warn",
                       position: (1032, 32),
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "fromOpt",
                        position: (1032, 40),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "isDefined",
                          position: (1032, 48),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                     position: (1032, 37),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "The option `",
                       position: (1033, 14),
                      },
                      Expression {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "showOption",
                         position: (1033, 28),
                        },
                        arguments: [
                         Variable {
                          identifier: "from",
                          position: (1033, 39),
                         },
                        ],
                       },
                      },
                      Raw {
                       content: "' defined in ",
                       position: (1033, 44),
                      },
                      Expression {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "showFiles",
                         position: (1033, 59),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "fromOpt",
                           position: (1033, 69),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "files",
                             position: (1033, 77),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                      },
                      Raw {
                       content: " has been renamed to `",
                       position: (1033, 83),
                      },
                      Expression {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "showOption",
                         position: (1033, 107),
                        },
                        arguments: [
                         Variable {
                          identifier: "to",
                          position: (1033, 118),
                         },
                        ],
                       },
                      },
                      Raw {
                       content: "'.",
                       position: (1033, 121),
                      },
                     ],
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (1031, 9),
               },
               IfThenElse {
                predicate: Variable {
                 identifier: "withPriority",
                 position: (1035, 13),
                },
                then: FunctionApplication {
                 function: Variable {
                  identifier: "mkAliasAndWrapDefsWithPriority",
                  position: (1036, 16),
                 },
                 arguments: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "setAttrByPath",
                    position: (1036, 48),
                   },
                   arguments: [
                    Variable {
                     identifier: "to",
                     position: (1036, 62),
                    },
                   ],
                  },
                  Variable {
                   identifier: "fromOpt",
                   position: (1036, 66),
                  },
                 ],
                },
                else_: FunctionApplication {
                 function: Variable {
                  identifier: "mkAliasAndWrapDefinitions",
                  position: (1037, 16),
                 },
                 arguments: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "setAttrByPath",
                    position: (1037, 43),
                   },
                   arguments: [
                    Variable {
                     identifier: "to",
                     position: (1037, 57),
                    },
                   ],
                  },
                  Variable {
                   identifier: "fromOpt",
                   position: (1037, 61),
                  },
                 ],
                },
                position: (1035, 10),
               },
              ],
              position: (1030, 24),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (1022, 5),
        },
        position: (1016, 5),
       },
       position: (1015, 5),
      },
      position: (1014, 14),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "importJSON",
        position: (1045, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "file",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "_file",
            position: (1046, 5),
           },
          ],
         },
         Variable {
          identifier: "file",
          position: (1046, 13),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "config",
            position: (1047, 5),
           },
          ],
         },
         FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (1047, 14),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "importJSON",
              position: (1047, 18),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Variable {
            identifier: "file",
            position: (1047, 29),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (1045, 22),
      },
      position: (1045, 16),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "importTOML",
        position: (1054, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "file",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "_file",
            position: (1055, 5),
           },
          ],
         },
         Variable {
          identifier: "file",
          position: (1055, 13),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "config",
            position: (1056, 5),
           },
          ],
         },
         FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (1056, 14),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "importTOML",
              position: (1056, 18),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Variable {
            identifier: "file",
            position: (1056, 29),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (1054, 22),
      },
      position: (1054, 16),
     },
    ),
   ],
   recursive: true,
   position: (52, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}