nix-community.nixvim/plugins/lsp/language-servers/rust-analyzer-config.nix

lib: pkgs:
# Future improvements:
#   - extra documentation from anyOf types, they can have `enumDescriptions` that are valuable
with lib; let
  packageJson = "${pkgs.rust-analyzer.src}/editors/code/package.json";

  options =
    (trivial.importJSON packageJson)
    .contributes
    .configuration
    .properties;

  packageJsonTxt = strings.splitString "\n" (builtins.readFile packageJson);
  vscodeStart =
    lists.findFirstIndex (x: x == "        \"configuration\": {")
    (throw "no configuration")
    packageJsonTxt;
  vscodeEnd =
    lists.findFirstIndex (strings.hasInfix "generated-start") (throw "no generated start")
    packageJsonTxt;
  vscodeOptions = lists.sublist vscodeStart (vscodeEnd - vscodeStart) packageJsonTxt;

  vscodeOptionNames =
    builtins.map
    (x: strings.removeSuffix "\": {" (strings.removePrefix "                \"" x))
    (lists.filter (strings.hasPrefix "                \"rust-analyzer.")
      vscodeOptions);

  rustAnalyzerOptions =
    builtins.removeAttrs options
    (vscodeOptionNames ++ ["\$generated-start" "\$generated-end"]);

  nullType = mkOptionType {
    name = "nullType";
    description = "null";
    descriptionClass = "noun";
    merge = mergeEqualOption;
    check = e: e == null;
  };

  mkRustAnalyzerType = opt: {
    type,
    enum ? null,
    minimum ? null,
    maximum ? null,
    items ? null,
    anyOf ? null,
    uniqueItems ? null,
    # unused, but for exhaustivness
    enumDescriptions ? null,
  } @ def:
    if enum != null
    then types.enum enum
    else if anyOf != null
    then types.oneOf (builtins.map (mkRustAnalyzerType opt) anyOf)
    else if builtins.isList type
    then
      if builtins.length type == 2 && builtins.head type == "null"
      then types.nullOr (mkRustAnalyzerType opt (def // {type = builtins.elemAt type 1;}))
      else types.oneOf (builtins.map (t: mkRustAnalyzerType opt (def // {type = t;})) type)
    else if type == "boolean"
    then types.bool
    else if type == "object"
    then types.attrsOf types.anything
    else if type == "string"
    then types.str
    else if type == "null"
    then nullType
    else if type == "array"
    then
      types.listOf (
        mkRustAnalyzerType "${opt}-items"
        (
          if items == null
          then throw "null items with array type (in ${opt})"
          else items
        )
      )
    else if type == "number"
    then
      if minimum != null && maximum != null
      then types.numbers.between minimum maximum
      else if minimum != null
      then types.addCheck types.number (x: x >= minimum)
      else if maximum != null
      then types.addCheck types.number (x: x <= maximum)
      else types.number
    else if type == "integer"
    then
      if minimum != null && maximum != null
      then types.ints.between minimum maximum
      else if minimum != null
      then types.addCheck types.int (x: x >= minimum)
      else if maximum != null
      then types.addCheck types.int (x: x <= maximum)
      else types.int
    else throw "unhandled type `${builtins.toJSON type}` (in ${opt})";

  mkRustAnalyzerOption = opt: {
    default,
    markdownDescription,
    type ? null,
    anyOf ? null,
    # Enum types
    enum ? null,
    enumDescriptions ? null,
    # Int types
    minimum ? null,
    maximum ? null,
    # List types
    items ? null,
    uniqueItems ? false,
  }:
    mkOption {
      type = types.nullOr (mkRustAnalyzerType opt {
        inherit
          type
          enum
          minimum
          maximum
          items
          anyOf
          uniqueItems
          ;
      });
      default = null;
      description =
        if enum != null
        then let
          valueDesc = builtins.map ({
            fst,
            snd,
          }: ''- ${fst}: ${snd}'') (lists.zipLists enum enumDescriptions);
        in ''
          ${markdownDescription}

          Values:
          ${builtins.concatStringsSep "\n" valueDesc}

          ```nix
          ${generators.toPretty {} default}
          ```
        ''
        else ''
          ${markdownDescription}

          default:
          ```nix
          ${generators.toPretty {} default}
          ```
        '';
    };

  nixOptions = builtins.mapAttrs mkRustAnalyzerOption rustAnalyzerOptions;

  nestOpt = opt: value: let
    parts = strings.splitString "." opt;
  in
    builtins.foldl' (current: segment: {${segment} = current;}) value (lists.reverseList parts);

  nestedNixOptions = attrsets.mapAttrsToList nestOpt nixOptions;
in
  (builtins.foldl' attrsets.recursiveUpdate {} nestedNixOptions).rust-analyzer