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