1 //===--- ConfigCompile.cpp - Translating Fragments into Config ------------===//
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 //
9 // Fragments are applied to Configs in two steps:
10 //
11 // 1. (When the fragment is first loaded)
12 //    FragmentCompiler::compile() traverses the Fragment and creates
13 //    function objects that know how to apply the configuration.
14 // 2. (Every time a config is required)
15 //    CompiledFragment() executes these functions to populate the Config.
16 //
17 // Work could be split between these steps in different ways. We try to
18 // do as much work as possible in the first step. For example, regexes are
19 // compiled in stage 1 and captured by the apply function. This is because:
20 //
21 //  - it's more efficient, as the work done in stage 1 must only be done once
22 //  - problems can be reported in stage 1, in stage 2 we must silently recover
23 //
24 //===----------------------------------------------------------------------===//
25 
26 #include "CompileCommands.h"
27 #include "Config.h"
28 #include "ConfigFragment.h"
29 #include "ConfigProvider.h"
30 #include "Diagnostics.h"
31 #include "Feature.h"
32 #include "TidyProvider.h"
33 #include "support/Logger.h"
34 #include "support/Path.h"
35 #include "support/Trace.h"
36 #include "llvm/ADT/None.h"
37 #include "llvm/ADT/Optional.h"
38 #include "llvm/ADT/STLExtras.h"
39 #include "llvm/ADT/SmallString.h"
40 #include "llvm/ADT/StringRef.h"
41 #include "llvm/ADT/StringSwitch.h"
42 #include "llvm/Support/Error.h"
43 #include "llvm/Support/FileSystem.h"
44 #include "llvm/Support/Format.h"
45 #include "llvm/Support/FormatVariadic.h"
46 #include "llvm/Support/Path.h"
47 #include "llvm/Support/Regex.h"
48 #include "llvm/Support/SMLoc.h"
49 #include "llvm/Support/SourceMgr.h"
50 #include <algorithm>
51 #include <string>
52 
53 namespace clang {
54 namespace clangd {
55 namespace config {
56 namespace {
57 
58 // Returns an empty stringref if Path is not under FragmentDir. Returns Path
59 // as-is when FragmentDir is empty.
60 llvm::StringRef configRelative(llvm::StringRef Path,
61                                llvm::StringRef FragmentDir) {
62   if (FragmentDir.empty())
63     return Path;
64   if (!Path.consume_front(FragmentDir))
65     return llvm::StringRef();
66   return Path.empty() ? "." : Path;
67 }
68 
69 struct CompiledFragmentImpl {
70   // The independent conditions to check before using settings from this config.
71   // The following fragment has *two* conditions:
72   //   If: { Platform: [mac, linux], PathMatch: foo/.* }
73   // All of them must be satisfied: the platform and path conditions are ANDed.
74   // The OR logic for the platform condition is implemented inside the function.
75   std::vector<llvm::unique_function<bool(const Params &) const>> Conditions;
76   // Mutations that this fragment will apply to the configuration.
77   // These are invoked only if the conditions are satisfied.
78   std::vector<llvm::unique_function<void(const Params &, Config &) const>>
79       Apply;
80 
81   bool operator()(const Params &P, Config &C) const {
82     for (const auto &C : Conditions) {
83       if (!C(P)) {
84         dlog("Config fragment {0}: condition not met", this);
85         return false;
86       }
87     }
88     dlog("Config fragment {0}: applying {1} rules", this, Apply.size());
89     for (const auto &A : Apply)
90       A(P, C);
91     return true;
92   }
93 };
94 
95 // Wrapper around condition compile() functions to reduce arg-passing.
96 struct FragmentCompiler {
97   FragmentCompiler(CompiledFragmentImpl &Out, DiagnosticCallback D,
98                    llvm::SourceMgr *SM)
99       : Out(Out), Diagnostic(D), SourceMgr(SM) {}
100   CompiledFragmentImpl &Out;
101   DiagnosticCallback Diagnostic;
102   llvm::SourceMgr *SourceMgr;
103   // Normalized Fragment::SourceInfo::Directory.
104   std::string FragmentDirectory;
105   bool Trusted = false;
106 
107   llvm::Optional<llvm::Regex>
108   compileRegex(const Located<std::string> &Text,
109                llvm::Regex::RegexFlags Flags = llvm::Regex::NoFlags) {
110     std::string Anchored = "^(" + *Text + ")$";
111     llvm::Regex Result(Anchored, Flags);
112     std::string RegexError;
113     if (!Result.isValid(RegexError)) {
114       diag(Error, "Invalid regex " + Anchored + ": " + RegexError, Text.Range);
115       return llvm::None;
116     }
117     return Result;
118   }
119 
120   llvm::Optional<std::string> makeAbsolute(Located<std::string> Path,
121                                            llvm::StringLiteral Description,
122                                            llvm::sys::path::Style Style) {
123     if (llvm::sys::path::is_absolute(*Path))
124       return *Path;
125     if (FragmentDirectory.empty()) {
126       diag(Error,
127            llvm::formatv(
128                "{0} must be an absolute path, because this fragment is not "
129                "associated with any directory.",
130                Description)
131                .str(),
132            Path.Range);
133       return llvm::None;
134     }
135     llvm::SmallString<256> AbsPath = llvm::StringRef(*Path);
136     llvm::sys::fs::make_absolute(FragmentDirectory, AbsPath);
137     llvm::sys::path::native(AbsPath, Style);
138     return AbsPath.str().str();
139   }
140 
141   // Helper with similar API to StringSwitch, for parsing enum values.
142   template <typename T> class EnumSwitch {
143     FragmentCompiler &Outer;
144     llvm::StringRef EnumName;
145     const Located<std::string> &Input;
146     llvm::Optional<T> Result;
147     llvm::SmallVector<llvm::StringLiteral> ValidValues;
148 
149   public:
150     EnumSwitch(llvm::StringRef EnumName, const Located<std::string> &In,
151                FragmentCompiler &Outer)
152         : Outer(Outer), EnumName(EnumName), Input(In) {}
153 
154     EnumSwitch &map(llvm::StringLiteral Name, T Value) {
155       assert(!llvm::is_contained(ValidValues, Name) && "Duplicate value!");
156       ValidValues.push_back(Name);
157       if (!Result && *Input == Name)
158         Result = Value;
159       return *this;
160     }
161 
162     llvm::Optional<T> value() {
163       if (!Result)
164         Outer.diag(
165             Warning,
166             llvm::formatv("Invalid {0} value '{1}'. Valid values are {2}.",
167                           EnumName, *Input, llvm::join(ValidValues, ", "))
168                 .str(),
169             Input.Range);
170       return Result;
171     };
172   };
173 
174   // Attempt to parse a specified string into an enum.
175   // Yields llvm::None and produces a diagnostic on failure.
176   //
177   // Optional<T> Value = compileEnum<En>("Foo", Frag.Foo)
178   //    .map("Foo", Enum::Foo)
179   //    .map("Bar", Enum::Bar)
180   //    .value();
181   template <typename T>
182   EnumSwitch<T> compileEnum(llvm::StringRef EnumName,
183                             const Located<std::string> &In) {
184     return EnumSwitch<T>(EnumName, In, *this);
185   }
186 
187   void compile(Fragment &&F) {
188     Trusted = F.Source.Trusted;
189     if (!F.Source.Directory.empty()) {
190       FragmentDirectory = llvm::sys::path::convert_to_slash(F.Source.Directory);
191       if (FragmentDirectory.back() != '/')
192         FragmentDirectory += '/';
193     }
194     compile(std::move(F.If));
195     compile(std::move(F.CompileFlags));
196     compile(std::move(F.Index));
197     compile(std::move(F.Diagnostics));
198     compile(std::move(F.Completion));
199   }
200 
201   void compile(Fragment::IfBlock &&F) {
202     if (F.HasUnrecognizedCondition)
203       Out.Conditions.push_back([&](const Params &) { return false; });
204 
205 #ifdef CLANGD_PATH_CASE_INSENSITIVE
206     llvm::Regex::RegexFlags Flags = llvm::Regex::IgnoreCase;
207 #else
208     llvm::Regex::RegexFlags Flags = llvm::Regex::NoFlags;
209 #endif
210 
211     auto PathMatch = std::make_unique<std::vector<llvm::Regex>>();
212     for (auto &Entry : F.PathMatch) {
213       if (auto RE = compileRegex(Entry, Flags))
214         PathMatch->push_back(std::move(*RE));
215     }
216     if (!PathMatch->empty()) {
217       Out.Conditions.push_back(
218           [PathMatch(std::move(PathMatch)),
219            FragmentDir(FragmentDirectory)](const Params &P) {
220             if (P.Path.empty())
221               return false;
222             llvm::StringRef Path = configRelative(P.Path, FragmentDir);
223             // Ignore the file if it is not nested under Fragment.
224             if (Path.empty())
225               return false;
226             return llvm::any_of(*PathMatch, [&](const llvm::Regex &RE) {
227               return RE.match(Path);
228             });
229           });
230     }
231 
232     auto PathExclude = std::make_unique<std::vector<llvm::Regex>>();
233     for (auto &Entry : F.PathExclude) {
234       if (auto RE = compileRegex(Entry, Flags))
235         PathExclude->push_back(std::move(*RE));
236     }
237     if (!PathExclude->empty()) {
238       Out.Conditions.push_back(
239           [PathExclude(std::move(PathExclude)),
240            FragmentDir(FragmentDirectory)](const Params &P) {
241             if (P.Path.empty())
242               return false;
243             llvm::StringRef Path = configRelative(P.Path, FragmentDir);
244             // Ignore the file if it is not nested under Fragment.
245             if (Path.empty())
246               return true;
247             return llvm::none_of(*PathExclude, [&](const llvm::Regex &RE) {
248               return RE.match(Path);
249             });
250           });
251     }
252   }
253 
254   void compile(Fragment::CompileFlagsBlock &&F) {
255     if (!F.Remove.empty()) {
256       auto Remove = std::make_shared<ArgStripper>();
257       for (auto &A : F.Remove)
258         Remove->strip(*A);
259       Out.Apply.push_back([Remove(std::shared_ptr<const ArgStripper>(
260                               std::move(Remove)))](const Params &, Config &C) {
261         C.CompileFlags.Edits.push_back(
262             [Remove](std::vector<std::string> &Args) {
263               Remove->process(Args);
264             });
265       });
266     }
267 
268     if (!F.Add.empty()) {
269       std::vector<std::string> Add;
270       for (auto &A : F.Add)
271         Add.push_back(std::move(*A));
272       Out.Apply.push_back([Add(std::move(Add))](const Params &, Config &C) {
273         C.CompileFlags.Edits.push_back([Add](std::vector<std::string> &Args) {
274           // The point to insert at. Just append when `--` isn't present.
275           auto It = llvm::find(Args, "--");
276           Args.insert(It, Add.begin(), Add.end());
277         });
278       });
279     }
280 
281     if (F.CompilationDatabase) {
282       llvm::Optional<Config::CDBSearchSpec> Spec;
283       if (**F.CompilationDatabase == "Ancestors") {
284         Spec.emplace();
285         Spec->Policy = Config::CDBSearchSpec::Ancestors;
286       } else if (**F.CompilationDatabase == "None") {
287         Spec.emplace();
288         Spec->Policy = Config::CDBSearchSpec::NoCDBSearch;
289       } else {
290         if (auto Path =
291                 makeAbsolute(*F.CompilationDatabase, "CompilationDatabase",
292                              llvm::sys::path::Style::native)) {
293           // Drop trailing slash to put the path in canonical form.
294           // Should makeAbsolute do this?
295           llvm::StringRef Rel = llvm::sys::path::relative_path(*Path);
296           if (!Rel.empty() && llvm::sys::path::is_separator(Rel.back()))
297             Path->pop_back();
298 
299           Spec.emplace();
300           Spec->Policy = Config::CDBSearchSpec::FixedDir;
301           Spec->FixedCDBPath = std::move(Path);
302         }
303       }
304       if (Spec)
305         Out.Apply.push_back(
306             [Spec(std::move(*Spec))](const Params &, Config &C) {
307               C.CompileFlags.CDBSearch = Spec;
308             });
309     }
310   }
311 
312   void compile(Fragment::IndexBlock &&F) {
313     if (F.Background) {
314       if (auto Val = compileEnum<Config::BackgroundPolicy>("Background",
315                                                            **F.Background)
316                          .map("Build", Config::BackgroundPolicy::Build)
317                          .map("Skip", Config::BackgroundPolicy::Skip)
318                          .value())
319         Out.Apply.push_back(
320             [Val](const Params &, Config &C) { C.Index.Background = *Val; });
321     }
322     if (F.External)
323       compile(std::move(**F.External), F.External->Range);
324   }
325 
326   void compile(Fragment::IndexBlock::ExternalBlock &&External,
327                llvm::SMRange BlockRange) {
328     if (External.Server && !Trusted) {
329       diag(Error,
330            "Remote index may not be specified by untrusted configuration. "
331            "Copy this into user config to use it.",
332            External.Server->Range);
333       return;
334     }
335 #ifndef CLANGD_ENABLE_REMOTE
336     if (External.Server) {
337       elog("Clangd isn't compiled with remote index support, ignoring Server: "
338            "{0}",
339            *External.Server);
340       External.Server.reset();
341     }
342 #endif
343     // Make sure exactly one of the Sources is set.
344     unsigned SourceCount = External.File.hasValue() +
345                            External.Server.hasValue() + *External.IsNone;
346     if (SourceCount != 1) {
347       diag(Error, "Exactly one of File, Server or None must be set.",
348            BlockRange);
349       return;
350     }
351     Config::ExternalIndexSpec Spec;
352     if (External.Server) {
353       Spec.Kind = Config::ExternalIndexSpec::Server;
354       Spec.Location = std::move(**External.Server);
355     } else if (External.File) {
356       Spec.Kind = Config::ExternalIndexSpec::File;
357       auto AbsPath = makeAbsolute(std::move(*External.File), "File",
358                                   llvm::sys::path::Style::native);
359       if (!AbsPath)
360         return;
361       Spec.Location = std::move(*AbsPath);
362     } else {
363       assert(*External.IsNone);
364       Spec.Kind = Config::ExternalIndexSpec::None;
365     }
366     if (Spec.Kind != Config::ExternalIndexSpec::None) {
367       // Make sure MountPoint is an absolute path with forward slashes.
368       if (!External.MountPoint)
369         External.MountPoint.emplace(FragmentDirectory);
370       if ((**External.MountPoint).empty()) {
371         diag(Error, "A mountpoint is required.", BlockRange);
372         return;
373       }
374       auto AbsPath = makeAbsolute(std::move(*External.MountPoint), "MountPoint",
375                                   llvm::sys::path::Style::posix);
376       if (!AbsPath)
377         return;
378       Spec.MountPoint = std::move(*AbsPath);
379     }
380     Out.Apply.push_back([Spec(std::move(Spec))](const Params &P, Config &C) {
381       if (Spec.Kind == Config::ExternalIndexSpec::None) {
382         C.Index.External = Spec;
383         return;
384       }
385       if (P.Path.empty() || !pathStartsWith(Spec.MountPoint, P.Path,
386                                             llvm::sys::path::Style::posix))
387         return;
388       C.Index.External = Spec;
389       // Disable background indexing for the files under the mountpoint.
390       // Note that this will overwrite statements in any previous fragments
391       // (including the current one).
392       C.Index.Background = Config::BackgroundPolicy::Skip;
393     });
394   }
395 
396   void compile(Fragment::DiagnosticsBlock &&F) {
397     std::vector<std::string> Normalized;
398     for (const auto &Suppressed : F.Suppress) {
399       if (*Suppressed == "*") {
400         Out.Apply.push_back([&](const Params &, Config &C) {
401           C.Diagnostics.SuppressAll = true;
402           C.Diagnostics.Suppress.clear();
403         });
404         return;
405       }
406       Normalized.push_back(normalizeSuppressedCode(*Suppressed).str());
407     }
408     if (!Normalized.empty())
409       Out.Apply.push_back(
410           [Normalized(std::move(Normalized))](const Params &, Config &C) {
411             if (C.Diagnostics.SuppressAll)
412               return;
413             for (llvm::StringRef N : Normalized)
414               C.Diagnostics.Suppress.insert(N);
415           });
416 
417     if (F.UnusedIncludes)
418       if (auto Val = compileEnum<Config::UnusedIncludesPolicy>(
419                          "UnusedIncludes", **F.UnusedIncludes)
420                          .map("Strict", Config::UnusedIncludesPolicy::Strict)
421                          .map("None", Config::UnusedIncludesPolicy::None)
422                          .value())
423         Out.Apply.push_back([Val](const Params &, Config &C) {
424           C.Diagnostics.UnusedIncludes = *Val;
425         });
426 
427     compile(std::move(F.ClangTidy));
428   }
429 
430   void compile(Fragment::StyleBlock &&F) {
431     if (!F.FullyQualifiedNamespaces.empty()) {
432       std::vector<std::string> FullyQualifiedNamespaces;
433       for (auto &N : F.FullyQualifiedNamespaces) {
434         // Normalize the data by dropping both leading and trailing ::
435         StringRef Namespace(*N);
436         Namespace.consume_front("::");
437         Namespace.consume_back("::");
438         FullyQualifiedNamespaces.push_back(Namespace.str());
439       }
440       Out.Apply.push_back([FullyQualifiedNamespaces(
441                               std::move(FullyQualifiedNamespaces))](
442                               const Params &, Config &C) {
443         C.Style.FullyQualifiedNamespaces.insert(
444             C.Style.FullyQualifiedNamespaces.begin(),
445             FullyQualifiedNamespaces.begin(), FullyQualifiedNamespaces.end());
446       });
447     }
448   }
449 
450   void appendTidyCheckSpec(std::string &CurSpec,
451                            const Located<std::string> &Arg, bool IsPositive) {
452     StringRef Str = StringRef(*Arg).trim();
453     // Don't support negating here, its handled if the item is in the Add or
454     // Remove list.
455     if (Str.startswith("-") || Str.contains(',')) {
456       diag(Error, "Invalid clang-tidy check name", Arg.Range);
457       return;
458     }
459     if (!Str.contains('*') && !isRegisteredTidyCheck(Str)) {
460       diag(Warning,
461            llvm::formatv("clang-tidy check '{0}' was not found", Str).str(),
462            Arg.Range);
463       return;
464     }
465     CurSpec += ',';
466     if (!IsPositive)
467       CurSpec += '-';
468     CurSpec += Str;
469   }
470 
471   void compile(Fragment::DiagnosticsBlock::ClangTidyBlock &&F) {
472     std::string Checks;
473     for (auto &CheckGlob : F.Add)
474       appendTidyCheckSpec(Checks, CheckGlob, true);
475 
476     for (auto &CheckGlob : F.Remove)
477       appendTidyCheckSpec(Checks, CheckGlob, false);
478 
479     if (!Checks.empty())
480       Out.Apply.push_back(
481           [Checks = std::move(Checks)](const Params &, Config &C) {
482             C.Diagnostics.ClangTidy.Checks.append(
483                 Checks,
484                 C.Diagnostics.ClangTidy.Checks.empty() ? /*skip comma*/ 1 : 0,
485                 std::string::npos);
486           });
487     if (!F.CheckOptions.empty()) {
488       std::vector<std::pair<std::string, std::string>> CheckOptions;
489       for (auto &Opt : F.CheckOptions)
490         CheckOptions.emplace_back(std::move(*Opt.first),
491                                   std::move(*Opt.second));
492       Out.Apply.push_back(
493           [CheckOptions = std::move(CheckOptions)](const Params &, Config &C) {
494             for (auto &StringPair : CheckOptions)
495               C.Diagnostics.ClangTidy.CheckOptions.insert_or_assign(
496                   StringPair.first, StringPair.second);
497           });
498     }
499   }
500 
501   void compile(Fragment::CompletionBlock &&F) {
502     if (F.AllScopes) {
503       Out.Apply.push_back(
504           [AllScopes(**F.AllScopes)](const Params &, Config &C) {
505             C.Completion.AllScopes = AllScopes;
506           });
507     }
508   }
509 
510   constexpr static llvm::SourceMgr::DiagKind Error = llvm::SourceMgr::DK_Error;
511   constexpr static llvm::SourceMgr::DiagKind Warning =
512       llvm::SourceMgr::DK_Warning;
513   void diag(llvm::SourceMgr::DiagKind Kind, llvm::StringRef Message,
514             llvm::SMRange Range) {
515     if (Range.isValid() && SourceMgr != nullptr)
516       Diagnostic(SourceMgr->GetMessage(Range.Start, Kind, Message, Range));
517     else
518       Diagnostic(llvm::SMDiagnostic("", Kind, Message));
519   }
520 };
521 
522 } // namespace
523 
524 CompiledFragment Fragment::compile(DiagnosticCallback D) && {
525   llvm::StringRef ConfigFile = "<unknown>";
526   std::pair<unsigned, unsigned> LineCol = {0, 0};
527   if (auto *SM = Source.Manager.get()) {
528     unsigned BufID = SM->getMainFileID();
529     LineCol = SM->getLineAndColumn(Source.Location, BufID);
530     ConfigFile = SM->getBufferInfo(BufID).Buffer->getBufferIdentifier();
531   }
532   trace::Span Tracer("ConfigCompile");
533   SPAN_ATTACH(Tracer, "ConfigFile", ConfigFile);
534   auto Result = std::make_shared<CompiledFragmentImpl>();
535   vlog("Config fragment: compiling {0}:{1} -> {2} (trusted={3})", ConfigFile,
536        LineCol.first, Result.get(), Source.Trusted);
537 
538   FragmentCompiler{*Result, D, Source.Manager.get()}.compile(std::move(*this));
539   // Return as cheaply-copyable wrapper.
540   return [Result(std::move(Result))](const Params &P, Config &C) {
541     return (*Result)(P, C);
542   };
543 }
544 
545 } // namespace config
546 } // namespace clangd
547 } // namespace clang
548