clang-tools-extra/clangd/ConfigYAML.cpp

   1 //===--- ConfigYAML.cpp - Loading configuration fragments from YAML files -===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 #include "ConfigFragment.h"
   9 #include "llvm/ADT/SmallSet.h"
  10 #include "llvm/ADT/SmallString.h"
  11 #include "llvm/ADT/StringRef.h"
  12 #include "llvm/Support/MemoryBuffer.h"
  13 #include "llvm/Support/SourceMgr.h"
  14 #include "llvm/Support/YAMLParser.h"
  15 #include <optional>
  16 #include <string>
  17 #include <system_error>
  18
  19 namespace clang {
  20 namespace clangd {
  21 namespace config {
  22 namespace {
  23 using llvm::yaml::BlockScalarNode;
  24 using llvm::yaml::MappingNode;
  25 using llvm::yaml::Node;
  26 using llvm::yaml::ScalarNode;
  27 using llvm::yaml::SequenceNode;
  28
  29 std::optional<llvm::StringRef>
  30 bestGuess(llvm::StringRef Search,
  31           llvm::ArrayRef<llvm::StringRef> AllowedValues) {
  32   unsigned MaxEdit = (Search.size() + 1) / 3;
  33   if (!MaxEdit)
  34     return std::nullopt;
  35   std::optional<llvm::StringRef> Result;
  36   for (const auto &AllowedValue : AllowedValues) {
  37     unsigned EditDistance = Search.edit_distance(AllowedValue, true, MaxEdit);
  38     // We can't do better than an edit distance of 1, so just return this and
  39     // save computing other values.
  40     if (EditDistance == 1U)
  41       return AllowedValue;
  42     if (EditDistance == MaxEdit && !Result) {
  43       Result = AllowedValue;
  44     } else if (EditDistance < MaxEdit) {
  45       Result = AllowedValue;
  46       MaxEdit = EditDistance;
  47     }
  48   }
  49   return Result;
  50 }
  51
  52 class Parser {
  53   llvm::SourceMgr &SM;
  54   bool HadError = false;
  55
  56 public:
  57   Parser(llvm::SourceMgr &SM) : SM(SM) {}
  58
  59   // Tries to parse N into F, returning false if it failed and we couldn't
  60   // meaningfully recover (YAML syntax error, or hard semantic error).
  61   bool parse(Fragment &F, Node &N) {
  62     DictParser Dict("Config", this);
  63     Dict.handle("If", [&](Node &N) { parse(F.If, N); });
  64     Dict.handle("CompileFlags", [&](Node &N) { parse(F.CompileFlags, N); });
  65     Dict.handle("Index", [&](Node &N) { parse(F.Index, N); });
  66     Dict.handle("Style", [&](Node &N) { parse(F.Style, N); });
  67     Dict.handle("Diagnostics", [&](Node &N) { parse(F.Diagnostics, N); });
  68     Dict.handle("Completion", [&](Node &N) { parse(F.Completion, N); });
  69     Dict.handle("Hover", [&](Node &N) { parse(F.Hover, N); });
  70     Dict.handle("InlayHints", [&](Node &N) { parse(F.InlayHints, N); });
  71     Dict.handle("SemanticTokens", [&](Node &N) { parse(F.SemanticTokens, N); });
  72     Dict.parse(N);
  73     return !(N.failed() || HadError);
  74   }
  75
  76 private:
  77   void parse(Fragment::IfBlock &F, Node &N) {
  78     DictParser Dict("If", this);
  79     Dict.unrecognized([&](Located<std::string>, Node &) {
  80       F.HasUnrecognizedCondition = true;
  81       return true; // Emit a warning for the unrecognized key.
  82     });
  83     Dict.handle("PathMatch", [&](Node &N) {
  84       if (auto Values = scalarValues(N))
  85         F.PathMatch = std::move(*Values);
  86     });
  87     Dict.handle("PathExclude", [&](Node &N) {
  88       if (auto Values = scalarValues(N))
  89         F.PathExclude = std::move(*Values);
  90     });
  91     Dict.parse(N);
  92   }
  93
  94   void parse(Fragment::CompileFlagsBlock &F, Node &N) {
  95     DictParser Dict("CompileFlags", this);
  96     Dict.handle("Compiler", [&](Node &N) {
  97       if (auto Value = scalarValue(N, "Compiler"))
  98         F.Compiler = std::move(*Value);
  99     });
 100     Dict.handle("Add", [&](Node &N) {
 101       if (auto Values = scalarValues(N))
 102         F.Add = std::move(*Values);
 103     });
 104     Dict.handle("Remove", [&](Node &N) {
 105       if (auto Values = scalarValues(N))
 106         F.Remove = std::move(*Values);
 107     });
 108     Dict.handle("CompilationDatabase", [&](Node &N) {
 109       F.CompilationDatabase = scalarValue(N, "CompilationDatabase");
 110     });
 111     Dict.parse(N);
 112   }
 113
 114   void parse(Fragment::StyleBlock &F, Node &N) {
 115     DictParser Dict("Style", this);
 116     Dict.handle("FullyQualifiedNamespaces", [&](Node &N) {
 117       if (auto Values = scalarValues(N))
 118         F.FullyQualifiedNamespaces = std::move(*Values);
 119     });
 120     Dict.parse(N);
 121   }
 122
 123   void parse(Fragment::DiagnosticsBlock &F, Node &N) {
 124     DictParser Dict("Diagnostics", this);
 125     Dict.handle("Suppress", [&](Node &N) {
 126       if (auto Values = scalarValues(N))
 127         F.Suppress = std::move(*Values);
 128     });
 129     Dict.handle("UnusedIncludes", [&](Node &N) {
 130       F.UnusedIncludes = scalarValue(N, "UnusedIncludes");
 131     });
 132     Dict.handle("MissingIncludes", [&](Node &N) {
 133       F.MissingIncludes = scalarValue(N, "MissingIncludes");
 134     });
 135     Dict.handle("Includes", [&](Node &N) { parse(F.Includes, N); });
 136     Dict.handle("ClangTidy", [&](Node &N) { parse(F.ClangTidy, N); });
 137     Dict.parse(N);
 138   }
 139
 140   void parse(Fragment::DiagnosticsBlock::ClangTidyBlock &F, Node &N) {
 141     DictParser Dict("ClangTidy", this);
 142     Dict.handle("Add", [&](Node &N) {
 143       if (auto Values = scalarValues(N))
 144         F.Add = std::move(*Values);
 145     });
 146     Dict.handle("Remove", [&](Node &N) {
 147       if (auto Values = scalarValues(N))
 148         F.Remove = std::move(*Values);
 149     });
 150     Dict.handle("CheckOptions", [&](Node &N) {
 151       DictParser CheckOptDict("CheckOptions", this);
 152       CheckOptDict.unrecognized([&](Located<std::string> &&Key, Node &Val) {
 153         if (auto Value = scalarValue(Val, *Key))
 154           F.CheckOptions.emplace_back(std::move(Key), std::move(*Value));
 155         return false; // Don't emit a warning
 156       });
 157       CheckOptDict.parse(N);
 158     });
 159     Dict.handle("FastCheckFilter", [&](Node &N) {
 160       if (auto FastCheckFilter = scalarValue(N, "FastCheckFilter"))
 161         F.FastCheckFilter = *FastCheckFilter;
 162     });
 163     Dict.parse(N);
 164   }
 165
 166   void parse(Fragment::DiagnosticsBlock::IncludesBlock &F, Node &N) {
 167     DictParser Dict("Includes", this);
 168     Dict.handle("IgnoreHeader", [&](Node &N) {
 169       if (auto Values = scalarValues(N))
 170         F.IgnoreHeader = std::move(*Values);
 171     });
 172     Dict.handle("AnalyzeAngledIncludes", [&](Node &N) {
 173       if (auto Value = boolValue(N, "AnalyzeAngledIncludes"))
 174         F.AnalyzeAngledIncludes = *Value;
 175     });
 176     Dict.parse(N);
 177   }
 178
 179   void parse(Fragment::IndexBlock &F, Node &N) {
 180     DictParser Dict("Index", this);
 181     Dict.handle("Background",
 182                 [&](Node &N) { F.Background = scalarValue(N, "Background"); });
 183     Dict.handle("External", [&](Node &N) {
 184       Fragment::IndexBlock::ExternalBlock External;
 185       // External block can either be a mapping or a scalar value. Dispatch
 186       // accordingly.
 187       if (N.getType() == Node::NK_Mapping) {
 188         parse(External, N);
 189       } else if (N.getType() == Node::NK_Scalar ||
 190                  N.getType() == Node::NK_BlockScalar) {
 191         parse(External, *scalarValue(N, "External"));
 192       } else {
 193         error("External must be either a scalar or a mapping.", N);
 194         return;
 195       }
 196       F.External.emplace(std::move(External));
 197       F.External->Range = N.getSourceRange();
 198     });
 199     Dict.handle("StandardLibrary", [&](Node &N) {
 200       if (auto StandardLibrary = boolValue(N, "StandardLibrary"))
 201         F.StandardLibrary = *StandardLibrary;
 202     });
 203     Dict.parse(N);
 204   }
 205
 206   void parse(Fragment::IndexBlock::ExternalBlock &F,
 207              Located<std::string> ExternalVal) {
 208     if (!llvm::StringRef(*ExternalVal).equals_insensitive("none")) {
 209       error("Only scalar value supported for External is 'None'",
 210             ExternalVal.Range);
 211       return;
 212     }
 213     F.IsNone = true;
 214     F.IsNone.Range = ExternalVal.Range;
 215   }
 216
 217   void parse(Fragment::IndexBlock::ExternalBlock &F, Node &N) {
 218     DictParser Dict("External", this);
 219     Dict.handle("File", [&](Node &N) { F.File = scalarValue(N, "File"); });
 220     Dict.handle("Server",
 221                 [&](Node &N) { F.Server = scalarValue(N, "Server"); });
 222     Dict.handle("MountPoint",
 223                 [&](Node &N) { F.MountPoint = scalarValue(N, "MountPoint"); });
 224     Dict.parse(N);
 225   }
 226
 227   void parse(Fragment::CompletionBlock &F, Node &N) {
 228     DictParser Dict("Completion", this);
 229     Dict.handle("AllScopes", [&](Node &N) {
 230       if (auto AllScopes = boolValue(N, "AllScopes"))
 231         F.AllScopes = *AllScopes;
 232     });
 233     Dict.parse(N);
 234   }
 235
 236   void parse(Fragment::HoverBlock &F, Node &N) {
 237     DictParser Dict("Hover", this);
 238     Dict.handle("ShowAKA", [&](Node &N) {
 239       if (auto ShowAKA = boolValue(N, "ShowAKA"))
 240         F.ShowAKA = *ShowAKA;
 241     });
 242     Dict.parse(N);
 243   }
 244
 245   void parse(Fragment::InlayHintsBlock &F, Node &N) {
 246     DictParser Dict("InlayHints", this);
 247     Dict.handle("Enabled", [&](Node &N) {
 248       if (auto Value = boolValue(N, "Enabled"))
 249         F.Enabled = *Value;
 250     });
 251     Dict.handle("ParameterNames", [&](Node &N) {
 252       if (auto Value = boolValue(N, "ParameterNames"))
 253         F.ParameterNames = *Value;
 254     });
 255     Dict.handle("DeducedTypes", [&](Node &N) {
 256       if (auto Value = boolValue(N, "DeducedTypes"))
 257         F.DeducedTypes = *Value;
 258     });
 259     Dict.handle("Designators", [&](Node &N) {
 260       if (auto Value = boolValue(N, "Designators"))
 261         F.Designators = *Value;
 262     });
 263     Dict.handle("BlockEnd", [&](Node &N) {
 264       if (auto Value = boolValue(N, "BlockEnd"))
 265         F.BlockEnd = *Value;
 266     });
 267     Dict.handle("TypeNameLimit", [&](Node &N) {
 268       if (auto Value = uint32Value(N, "TypeNameLimit"))
 269         F.TypeNameLimit = *Value;
 270     });
 271     Dict.parse(N);
 272   }
 273
 274   void parse(Fragment::SemanticTokensBlock &F, Node &N) {
 275     DictParser Dict("SemanticTokens", this);
 276     Dict.handle("DisabledKinds", [&](Node &N) {
 277       if (auto Values = scalarValues(N))
 278         F.DisabledKinds = std::move(*Values);
 279     });
 280     Dict.handle("DisabledModifiers", [&](Node &N) {
 281       if (auto Values = scalarValues(N))
 282         F.DisabledModifiers = std::move(*Values);
 283     });
 284     Dict.parse(N);
 285   }
 286
 287   // Helper for parsing mapping nodes (dictionaries).
 288   // We don't use YamlIO as we want to control over unknown keys.
 289   class DictParser {
 290     llvm::StringRef Description;
 291     std::vector<std::pair<llvm::StringRef, std::function<void(Node &)>>> Keys;
 292     std::function<bool(Located<std::string>, Node &)> UnknownHandler;
 293     Parser *Outer;
 294
 295   public:
 296     DictParser(llvm::StringRef Description, Parser *Outer)
 297         : Description(Description), Outer(Outer) {}
 298
 299     // Parse is called when Key is encountered, and passed the associated value.
 300     // It should emit diagnostics if the value is invalid (e.g. wrong type).
 301     // If Key is seen twice, Parse runs only once and an error is reported.
 302     void handle(llvm::StringLiteral Key, std::function<void(Node &)> Parse) {
 303       for (const auto &Entry : Keys) {
 304         (void)Entry;
 305         assert(Entry.first != Key && "duplicate key handler");
 306       }
 307       Keys.emplace_back(Key, std::move(Parse));
 308     }
 309
 310     // Handler is called when a Key is not matched by any handle().
 311     // If this is unset or the Handler returns true, a warning is emitted for
 312     // the unknown key.
 313     void
 314     unrecognized(std::function<bool(Located<std::string>, Node &)> Handler) {
 315       UnknownHandler = std::move(Handler);
 316     }
 317
 318     // Process a mapping node and call handlers for each key/value pair.
 319     void parse(Node &N) const {
 320       if (N.getType() != Node::NK_Mapping) {
 321         Outer->error(Description + " should be a dictionary", N);
 322         return;
 323       }
 324       llvm::SmallSet<std::string, 8> Seen;
 325       llvm::SmallVector<Located<std::string>, 0> UnknownKeys;
 326       // We *must* consume all items, even on error, or the parser will assert.
 327       for (auto &KV : llvm::cast<MappingNode>(N)) {
 328         auto *K = KV.getKey();
 329         if (!K) // YAMLParser emitted an error.
 330           continue;
 331         auto Key = Outer->scalarValue(*K, "Dictionary key");
 332         if (!Key)
 333           continue;
 334         if (!Seen.insert(**Key).second) {
 335           Outer->warning("Duplicate key " + **Key + " is ignored", *K);
 336           if (auto *Value = KV.getValue())
 337             Value->skip();
 338           continue;
 339         }
 340         auto *Value = KV.getValue();
 341         if (!Value) // YAMLParser emitted an error.
 342           continue;
 343         bool Matched = false;
 344         for (const auto &Handler : Keys) {
 345           if (Handler.first == **Key) {
 346             Matched = true;
 347             Handler.second(*Value);
 348             break;
 349           }
 350         }
 351         if (!Matched) {
 352           bool Warn = !UnknownHandler;
 353           if (UnknownHandler)
 354             Warn = UnknownHandler(
 355                 Located<std::string>(**Key, K->getSourceRange()), *Value);
 356           if (Warn)
 357             UnknownKeys.push_back(std::move(*Key));
 358         }
 359       }
 360       if (!UnknownKeys.empty())
 361         warnUnknownKeys(UnknownKeys, Seen);
 362     }
 363
 364   private:
 365     void warnUnknownKeys(llvm::ArrayRef<Located<std::string>> UnknownKeys,
 366                          const llvm::SmallSet<std::string, 8> &SeenKeys) const {
 367       llvm::SmallVector<llvm::StringRef> UnseenKeys;
 368       for (const auto &KeyAndHandler : Keys)
 369         if (!SeenKeys.count(KeyAndHandler.first.str()))
 370           UnseenKeys.push_back(KeyAndHandler.first);
 371
 372       for (const Located<std::string> &UnknownKey : UnknownKeys)
 373         if (auto BestGuess = bestGuess(*UnknownKey, UnseenKeys))
 374           Outer->warning("Unknown " + Description + " key '" + *UnknownKey +
 375                              "'; did you mean '" + *BestGuess + "'?",
 376                          UnknownKey.Range);
 377         else
 378           Outer->warning("Unknown " + Description + " key '" + *UnknownKey +
 379                              "'",
 380                          UnknownKey.Range);
 381     }
 382   };
 383
 384   // Try to parse a single scalar value from the node, warn on failure.
 385   std::optional<Located<std::string>> scalarValue(Node &N,
 386                                                   llvm::StringRef Desc) {
 387     llvm::SmallString<256> Buf;
 388     if (auto *S = llvm::dyn_cast<ScalarNode>(&N))
 389       return Located<std::string>(S->getValue(Buf).str(), N.getSourceRange());
 390     if (auto *BS = llvm::dyn_cast<BlockScalarNode>(&N))
 391       return Located<std::string>(BS->getValue().str(), N.getSourceRange());
 392     warning(Desc + " should be scalar", N);
 393     return std::nullopt;
 394   }
 395
 396   std::optional<Located<bool>> boolValue(Node &N, llvm::StringRef Desc) {
 397     if (auto Scalar = scalarValue(N, Desc)) {
 398       if (auto Bool = llvm::yaml::parseBool(**Scalar))
 399         return Located<bool>(*Bool, Scalar->Range);
 400       warning(Desc + " should be a boolean", N);
 401     }
 402     return std::nullopt;
 403   }
 404
 405   std::optional<Located<uint32_t>> uint32Value(Node &N, llvm::StringRef Desc) {
 406     if (auto Scalar = scalarValue(N, Desc)) {
 407       unsigned long long Num;
 408       if (!llvm::getAsUnsignedInteger(**Scalar, 0, Num)) {
 409         return Located<uint32_t>(Num, Scalar->Range);
 410       }
 411     }
 412     warning(Desc + " invalid number", N);
 413     return std::nullopt;
 414   }
 415
 416   // Try to parse a list of single scalar values, or just a single value.
 417   std::optional<std::vector<Located<std::string>>> scalarValues(Node &N) {
 418     std::vector<Located<std::string>> Result;
 419     if (auto *S = llvm::dyn_cast<ScalarNode>(&N)) {
 420       llvm::SmallString<256> Buf;
 421       Result.emplace_back(S->getValue(Buf).str(), N.getSourceRange());
 422     } else if (auto *S = llvm::dyn_cast<BlockScalarNode>(&N)) {
 423       Result.emplace_back(S->getValue().str(), N.getSourceRange());
 424     } else if (auto *S = llvm::dyn_cast<SequenceNode>(&N)) {
 425       // We *must* consume all items, even on error, or the parser will assert.
 426       for (auto &Child : *S) {
 427         if (auto Value = scalarValue(Child, "List item"))
 428           Result.push_back(std::move(*Value));
 429       }
 430     } else {
 431       warning("Expected scalar or list of scalars", N);
 432       return std::nullopt;
 433     }
 434     return Result;
 435   }
 436
 437   // Report a "hard" error, reflecting a config file that can never be valid.
 438   void error(const llvm::Twine &Msg, llvm::SMRange Range) {
 439     HadError = true;
 440     SM.PrintMessage(Range.Start, llvm::SourceMgr::DK_Error, Msg, Range);
 441   }
 442   void error(const llvm::Twine &Msg, const Node &N) {
 443     return error(Msg, N.getSourceRange());
 444   }
 445
 446   // Report a "soft" error that could be caused by e.g. version skew.
 447   void warning(const llvm::Twine &Msg, llvm::SMRange Range) {
 448     SM.PrintMessage(Range.Start, llvm::SourceMgr::DK_Warning, Msg, Range);
 449   }
 450   void warning(const llvm::Twine &Msg, const Node &N) {
 451     return warning(Msg, N.getSourceRange());
 452   }
 453 };
 454
 455 } // namespace
 456
 457 std::vector<Fragment> Fragment::parseYAML(llvm::StringRef YAML,
 458                                           llvm::StringRef BufferName,
 459                                           DiagnosticCallback Diags) {
 460   // The YAML document may contain multiple conditional fragments.
 461   // The SourceManager is shared for all of them.
 462   auto SM = std::make_shared<llvm::SourceMgr>();
 463   auto Buf = llvm::MemoryBuffer::getMemBufferCopy(YAML, BufferName);
 464   // Adapt DiagnosticCallback to function-pointer interface.
 465   // Callback receives both errors we emit and those from the YAML parser.
 466   SM->setDiagHandler(
 467       [](const llvm::SMDiagnostic &Diag, void *Ctx) {
 468         (*reinterpret_cast<DiagnosticCallback *>(Ctx))(Diag);
 469       },
 470       &Diags);
 471   std::vector<Fragment> Result;
 472   for (auto &Doc : llvm::yaml::Stream(*Buf, *SM)) {
 473     if (Node *N = Doc.getRoot()) {
 474       Fragment Fragment;
 475       Fragment.Source.Manager = SM;
 476       Fragment.Source.Location = N->getSourceRange().Start;
 477       SM->PrintMessage(Fragment.Source.Location, llvm::SourceMgr::DK_Note,
 478                        "Parsing config fragment");
 479       if (Parser(*SM).parse(Fragment, *N))
 480         Result.push_back(std::move(Fragment));
 481     }
 482   }
 483   SM->PrintMessage(SM->FindLocForLineAndColumn(SM->getMainFileID(), 0, 0),
 484                    llvm::SourceMgr::DK_Note,
 485                    "Parsed " + llvm::Twine(Result.size()) +
 486                        " fragments from file");
 487   // Hack: stash the buffer in the SourceMgr to keep it alive.
 488   // SM has two entries: "main" non-owning buffer, and ignored owning buffer.
 489   SM->AddNewSourceBuffer(std::move(Buf), llvm::SMLoc());
 490   return Result;
 491 }
 492
 493 } // namespace config
 494 } // namespace clangd
 495 } // namespace clang