1 //===--- ConfigProvider.cpp - Loading of user configuration ---------------===//
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 #include "ConfigProvider.h"
10 #include "Config.h"
11 #include "ConfigFragment.h"
12 #include "support/FileCache.h"
13 #include "support/ThreadsafeFS.h"
14 #include "support/Trace.h"
15 #include "llvm/ADT/ScopeExit.h"
16 #include "llvm/ADT/StringMap.h"
17 #include "llvm/ADT/StringRef.h"
18 #include "llvm/Support/Path.h"
19 #include <chrono>
20 #include <mutex>
21 #include <string>
22
23 namespace clang {
24 namespace clangd {
25 namespace config {
26
27 // Threadsafe cache around reading a YAML config file from disk.
28 class FileConfigCache : public FileCache {
29 mutable llvm::SmallVector<CompiledFragment, 1> CachedValue;
30 std::string Directory;
31
32 public:
FileConfigCache(llvm::StringRef Path,llvm::StringRef Directory)33 FileConfigCache(llvm::StringRef Path, llvm::StringRef Directory)
34 : FileCache(Path), Directory(Directory) {}
35
get(const ThreadsafeFS & TFS,DiagnosticCallback DC,std::chrono::steady_clock::time_point FreshTime,std::vector<CompiledFragment> & Out) const36 void get(const ThreadsafeFS &TFS, DiagnosticCallback DC,
37 std::chrono::steady_clock::time_point FreshTime,
38 std::vector<CompiledFragment> &Out) const {
39 read(
40 TFS, FreshTime,
41 [&](llvm::Optional<llvm::StringRef> Data) {
42 CachedValue.clear();
43 if (Data)
44 for (auto &Fragment : Fragment::parseYAML(*Data, path(), DC)) {
45 Fragment.Source.Directory = Directory;
46 CachedValue.push_back(std::move(Fragment).compile(DC));
47 }
48 },
49 [&]() { llvm::copy(CachedValue, std::back_inserter(Out)); });
50 }
51 };
52
fromYAMLFile(llvm::StringRef AbsPath,llvm::StringRef Directory,const ThreadsafeFS & FS)53 std::unique_ptr<Provider> Provider::fromYAMLFile(llvm::StringRef AbsPath,
54 llvm::StringRef Directory,
55 const ThreadsafeFS &FS) {
56 class AbsFileProvider : public Provider {
57 mutable FileConfigCache Cache; // threadsafe
58 const ThreadsafeFS &FS;
59
60 std::vector<CompiledFragment>
61 getFragments(const Params &P, DiagnosticCallback DC) const override {
62 std::vector<CompiledFragment> Result;
63 Cache.get(FS, DC, P.FreshTime, Result);
64 return Result;
65 };
66
67 public:
68 AbsFileProvider(llvm::StringRef Path, llvm::StringRef Directory,
69 const ThreadsafeFS &FS)
70 : Cache(Path, Directory), FS(FS) {
71 assert(llvm::sys::path::is_absolute(Path));
72 }
73 };
74
75 return std::make_unique<AbsFileProvider>(AbsPath, Directory, FS);
76 }
77
78 std::unique_ptr<Provider>
fromAncestorRelativeYAMLFiles(llvm::StringRef RelPath,const ThreadsafeFS & FS)79 Provider::fromAncestorRelativeYAMLFiles(llvm::StringRef RelPath,
80 const ThreadsafeFS &FS) {
81 class RelFileProvider : public Provider {
82 std::string RelPath;
83 const ThreadsafeFS &FS;
84
85 mutable std::mutex Mu;
86 // Keys are the (posix-style) ancestor directory, not the config within it.
87 // We only insert into this map, so pointers to values are stable forever.
88 // Mutex guards the map itself, not the values (which are threadsafe).
89 mutable llvm::StringMap<FileConfigCache> Cache;
90
91 std::vector<CompiledFragment>
92 getFragments(const Params &P, DiagnosticCallback DC) const override {
93 namespace path = llvm::sys::path;
94
95 if (P.Path.empty())
96 return {};
97
98 // Compute absolute paths to all ancestors (substrings of P.Path).
99 llvm::StringRef Parent = path::parent_path(P.Path);
100 llvm::SmallVector<llvm::StringRef, 8> Ancestors;
101 for (auto I = path::begin(Parent, path::Style::posix),
102 E = path::end(Parent);
103 I != E; ++I) {
104 // Avoid weird non-substring cases like phantom "." components.
105 // In practice, Component is a substring for all "normal" ancestors.
106 if (I->end() < Parent.begin() || I->end() > Parent.end())
107 continue;
108 Ancestors.emplace_back(Parent.begin(), I->end() - Parent.begin());
109 }
110 // Ensure corresponding cache entries exist in the map.
111 llvm::SmallVector<FileConfigCache *, 8> Caches;
112 {
113 std::lock_guard<std::mutex> Lock(Mu);
114 for (llvm::StringRef Ancestor : Ancestors) {
115 auto It = Cache.find(Ancestor);
116 // Assemble the actual config file path only once.
117 if (It == Cache.end()) {
118 llvm::SmallString<256> ConfigPath = Ancestor;
119 path::append(ConfigPath, RelPath);
120 // Use native slashes for reading the file, affects diagnostics.
121 llvm::sys::path::native(ConfigPath);
122 It = Cache.try_emplace(Ancestor, ConfigPath.str(), Ancestor).first;
123 }
124 Caches.push_back(&It->second);
125 }
126 }
127 // Finally query each individual file.
128 // This will take a (per-file) lock for each file that actually exists.
129 std::vector<CompiledFragment> Result;
130 for (FileConfigCache *Cache : Caches)
131 Cache->get(FS, DC, P.FreshTime, Result);
132 return Result;
133 };
134
135 public:
136 RelFileProvider(llvm::StringRef RelPath, const ThreadsafeFS &FS)
137 : RelPath(RelPath), FS(FS) {
138 assert(llvm::sys::path::is_relative(RelPath));
139 }
140 };
141
142 return std::make_unique<RelFileProvider>(RelPath, FS);
143 }
144
145 std::unique_ptr<Provider>
combine(std::vector<const Provider * > Providers)146 Provider::combine(std::vector<const Provider *> Providers) {
147 class CombinedProvider : public Provider {
148 std::vector<const Provider *> Providers;
149
150 std::vector<CompiledFragment>
151 getFragments(const Params &P, DiagnosticCallback DC) const override {
152 std::vector<CompiledFragment> Result;
153 for (const auto &Provider : Providers) {
154 for (auto &Fragment : Provider->getFragments(P, DC))
155 Result.push_back(std::move(Fragment));
156 }
157 return Result;
158 }
159
160 public:
161 CombinedProvider(std::vector<const Provider *> Providers)
162 : Providers(std::move(Providers)) {}
163 };
164
165 return std::make_unique<CombinedProvider>(std::move(Providers));
166 }
167
getConfig(const Params & P,DiagnosticCallback DC) const168 Config Provider::getConfig(const Params &P, DiagnosticCallback DC) const {
169 trace::Span Tracer("getConfig");
170 if (!P.Path.empty())
171 SPAN_ATTACH(Tracer, "path", P.Path);
172 Config C;
173 for (const auto &Fragment : getFragments(P, DC))
174 Fragment(P, C);
175 return C;
176 }
177
178 } // namespace config
179 } // namespace clangd
180 } // namespace clang
181