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