clang-tools 6.0.0

ClangTidyOptions.cpp
Go to the documentation of this file.
1 //===--- ClangTidyOptions.cpp - clang-tidy ----------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "ClangTidyOptions.h"
11 #include "ClangTidyModuleRegistry.h"
12 #include "clang/Basic/LLVM.h"
13 #include "llvm/ADT/SmallString.h"
14 #include "llvm/Support/Debug.h"
15 #include "llvm/Support/Errc.h"
16 #include "llvm/Support/FileSystem.h"
17 #include "llvm/Support/Path.h"
18 #include "llvm/Support/YAMLTraits.h"
19 #include "llvm/Support/raw_ostream.h"
20 #include <utility>
21
22 #define DEBUG_TYPE "clang-tidy-options"
23
24 using clang::tidy::ClangTidyOptions;
25 using clang::tidy::FileFilter;
26 using OptionsSource = clang::tidy::ClangTidyOptionsProvider::OptionsSource;
27
28 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter)
29 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter::LineRange)
30
31 namespace llvm {
32 namespace yaml {
33
34 // Map std::pair<int, int> to a JSON array of size 2.
35 template <> struct SequenceTraits<FileFilter::LineRange> {
36 static size_t size(IO &IO, FileFilter::LineRange &Range) {
37 return Range.first == 0 ? 0 : Range.second == 0 ? 1 : 2;
38 }
39 static unsigned &element(IO &IO, FileFilter::LineRange &Range, size_t Index) {
40 if (Index > 1)
41 IO.setError("Too many elements in line range.");
42 return Index == 0 ? Range.first : Range.second;
43 }
44 };
45
46 template <> struct MappingTraits<FileFilter> {
47 static void mapping(IO &IO, FileFilter &File) {
48 IO.mapRequired("name", File.Name);
49 IO.mapOptional("lines", File.LineRanges);
50 }
51 static StringRef validate(IO &io, FileFilter &File) {
52 if (File.Name.empty())
53 return "No file name specified";
54 for (const FileFilter::LineRange &Range : File.LineRanges) {
55 if (Range.first <= 0 || Range.second <= 0)
56 return "Invalid line range";
57 }
58 return StringRef();
59 }
60 };
61
62 template <> struct MappingTraits<ClangTidyOptions::StringPair> {
63 static void mapping(IO &IO, ClangTidyOptions::StringPair &KeyValue) {
64 IO.mapRequired("key", KeyValue.first);
65 IO.mapRequired("value", KeyValue.second);
66 }
67 };
68
69 struct NOptionMap {
70 NOptionMap(IO &) {}
71 NOptionMap(IO &, const ClangTidyOptions::OptionMap &OptionMap)
72 : Options(OptionMap.begin(), OptionMap.end()) {}
73 ClangTidyOptions::OptionMap denormalize(IO &) {
74 ClangTidyOptions::OptionMap Map;
75 for (const auto &KeyValue : Options)
76 Map[KeyValue.first] = KeyValue.second;
77 return Map;
78 }
79 std::vector<ClangTidyOptions::StringPair> Options;
80 };
81
82 template <> struct MappingTraits<ClangTidyOptions> {
83 static void mapping(IO &IO, ClangTidyOptions &Options) {
84 MappingNormalization<NOptionMap, ClangTidyOptions::OptionMap> NOpts(
85 IO, Options.CheckOptions);
86 IO.mapOptional("Checks", Options.Checks);
87 IO.mapOptional("WarningsAsErrors", Options.WarningsAsErrors);
88 IO.mapOptional("HeaderFilterRegex", Options.HeaderFilterRegex);
89 IO.mapOptional("AnalyzeTemporaryDtors", Options.AnalyzeTemporaryDtors);
90 IO.mapOptional("FormatStyle", Options.FormatStyle);
91 IO.mapOptional("User", Options.User);
92 IO.mapOptional("CheckOptions", NOpts->Options);
93 IO.mapOptional("ExtraArgs", Options.ExtraArgs);
94 IO.mapOptional("ExtraArgsBefore", Options.ExtraArgsBefore);
95 }
96 };
97
98 } // namespace yaml
99 } // namespace llvm
100
101 namespace clang {
102 namespace tidy {
103
104 ClangTidyOptions ClangTidyOptions::getDefaults() {
105 ClangTidyOptions Options;
106 Options.Checks = "";
107 Options.WarningsAsErrors = "";
108 Options.HeaderFilterRegex = "";
109 Options.SystemHeaders = false;
110 Options.AnalyzeTemporaryDtors = false;
111 Options.FormatStyle = "none";
112 Options.User = llvm::None;
113 for (ClangTidyModuleRegistry::iterator I = ClangTidyModuleRegistry::begin(),
114 E = ClangTidyModuleRegistry::end();
115 I != E; ++I)
116 Options = Options.mergeWith(I->instantiate()->getModuleOptions());
117 return Options;
118 }
119
120 template <typename T>
121 static void mergeVectors(Optional<T> &Dest, const Optional<T> &Src) {
122 if (Src) {
123 if (Dest)
124 Dest->insert(Dest->end(), Src->begin(), Src->end());
125 else
126 Dest = Src;
127 }
128 }
129
130 static void mergeCommaSeparatedLists(Optional<std::string> &Dest,
131 const Optional<std::string> &Src) {
132 if (Src)
133 Dest = (Dest && !Dest->empty() ? *Dest + "," : "") + *Src;
134 }
135
136 template <typename T>
137 static void overrideValue(Optional<T> &Dest, const Optional<T> &Src) {
138 if (Src)
139 Dest = Src;
140 }
141
142 ClangTidyOptions
143 ClangTidyOptions::mergeWith(const ClangTidyOptions &Other) const {
144 ClangTidyOptions Result = *this;
145
146 mergeCommaSeparatedLists(Result.Checks, Other.Checks);
147 mergeCommaSeparatedLists(Result.WarningsAsErrors, Other.WarningsAsErrors);
148 overrideValue(Result.HeaderFilterRegex, Other.HeaderFilterRegex);
149 overrideValue(Result.SystemHeaders, Other.SystemHeaders);
150 overrideValue(Result.AnalyzeTemporaryDtors, Other.AnalyzeTemporaryDtors);
151 overrideValue(Result.FormatStyle, Other.FormatStyle);
152 overrideValue(Result.User, Other.User);
153 mergeVectors(Result.ExtraArgs, Other.ExtraArgs);
154 mergeVectors(Result.ExtraArgsBefore, Other.ExtraArgsBefore);
155
156 for (const auto &KeyValue : Other.CheckOptions)
157 Result.CheckOptions[KeyValue.first] = KeyValue.second;
158
159 return Result;
160 }
161
162 const char ClangTidyOptionsProvider::OptionsSourceTypeDefaultBinary[] =
163 "clang-tidy binary";
164 const char ClangTidyOptionsProvider::OptionsSourceTypeCheckCommandLineOption[] =
165 "command-line option '-checks'";
166 const char
167 ClangTidyOptionsProvider::OptionsSourceTypeConfigCommandLineOption[] =
168 "command-line option '-config'";
169
170 ClangTidyOptions
171 ClangTidyOptionsProvider::getOptions(llvm::StringRef FileName) {
172 ClangTidyOptions Result;
173 for (const auto &Source : getRawOptions(FileName))
174 Result = Result.mergeWith(Source.first);
175 return Result;
176 }
177
178 std::vector<OptionsSource>
179 DefaultOptionsProvider::getRawOptions(llvm::StringRef FileName) {
180 std::vector<OptionsSource> Result;
181 Result.emplace_back(DefaultOptions, OptionsSourceTypeDefaultBinary);
182 return Result;
183 }
184
185 ConfigOptionsProvider::ConfigOptionsProvider(
186 const ClangTidyGlobalOptions &GlobalOptions,
187 const ClangTidyOptions &DefaultOptions,
188 const ClangTidyOptions &ConfigOptions,
189 const ClangTidyOptions &OverrideOptions)
190 : DefaultOptionsProvider(GlobalOptions, DefaultOptions),
191 ConfigOptions(ConfigOptions), OverrideOptions(OverrideOptions) {}
192
193 std::vector<OptionsSource>
194 ConfigOptionsProvider::getRawOptions(llvm::StringRef FileName) {
195 std::vector<OptionsSource> RawOptions =
196 DefaultOptionsProvider::getRawOptions(FileName);
197 RawOptions.emplace_back(ConfigOptions,
198 OptionsSourceTypeConfigCommandLineOption);
199 RawOptions.emplace_back(OverrideOptions,
200 OptionsSourceTypeCheckCommandLineOption);
201 return RawOptions;
202 }
203
204 FileOptionsProvider::FileOptionsProvider(
205 const ClangTidyGlobalOptions &GlobalOptions,
206 const ClangTidyOptions &DefaultOptions,
207 const ClangTidyOptions &OverrideOptions)
208 : DefaultOptionsProvider(GlobalOptions, DefaultOptions),
209 OverrideOptions(OverrideOptions) {
210 ConfigHandlers.emplace_back(".clang-tidy", parseConfiguration);
211 }
212
213 FileOptionsProvider::FileOptionsProvider(
214 const ClangTidyGlobalOptions &GlobalOptions,
215 const ClangTidyOptions &DefaultOptions,
216 const ClangTidyOptions &OverrideOptions,
217 const FileOptionsProvider::ConfigFileHandlers &ConfigHandlers)
218 : DefaultOptionsProvider(GlobalOptions, DefaultOptions),
219 OverrideOptions(OverrideOptions), ConfigHandlers(ConfigHandlers) {}
220
221 // FIXME: This method has some common logic with clang::format::getStyle().
222 // Consider pulling out common bits to a findParentFileWithName function or
223 // similar.
224 std::vector<OptionsSource>
225 FileOptionsProvider::getRawOptions(StringRef FileName) {
226 DEBUG(llvm::dbgs() << "Getting options for file " << FileName << "...\n");
227
228 std::vector<OptionsSource> RawOptions =
229 DefaultOptionsProvider::getRawOptions(FileName);
230 OptionsSource CommandLineOptions(OverrideOptions,
231 OptionsSourceTypeCheckCommandLineOption);
232 // Look for a suitable configuration file in all parent directories of the
233 // file. Start with the immediate parent directory and move up.
234 StringRef Path = llvm::sys::path::parent_path(FileName);
235 for (StringRef CurrentPath = Path; !CurrentPath.empty();
236 CurrentPath = llvm::sys::path::parent_path(CurrentPath)) {
237 llvm::Optional<OptionsSource> Result;
238
239 auto Iter = CachedOptions.find(CurrentPath);
240 if (Iter != CachedOptions.end())
241 Result = Iter->second;
242
243 if (!Result)
244 Result = tryReadConfigFile(CurrentPath);
245
246 if (Result) {
247 // Store cached value for all intermediate directories.
248 while (Path != CurrentPath) {
249 DEBUG(llvm::dbgs() << "Caching configuration for path " << Path
250 << ".\n");
251 CachedOptions[Path] = *Result;
252 Path = llvm::sys::path::parent_path(Path);
253 }
254 CachedOptions[Path] = *Result;
255
256 RawOptions.push_back(*Result);
257 break;
258 }
259 }
260 RawOptions.push_back(CommandLineOptions);
261 return RawOptions;
262 }
263
264 llvm::Optional<OptionsSource>
265 FileOptionsProvider::tryReadConfigFile(StringRef Directory) {
266 assert(!Directory.empty());
267
268 if (!llvm::sys::fs::is_directory(Directory)) {
269 llvm::errs() << "Error reading configuration from " << Directory
270 << ": directory doesn't exist.\n";
271 return llvm::None;
272 }
273
274 for (const ConfigFileHandler &ConfigHandler : ConfigHandlers) {
275 SmallString<128> ConfigFile(Directory);
276 llvm::sys::path::append(ConfigFile, ConfigHandler.first);
277 DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
278
279 bool IsFile = false;
280 // Ignore errors from is_regular_file: we only need to know if we can read
281 // the file or not.
282 llvm::sys::fs::is_regular_file(Twine(ConfigFile), IsFile);
283 if (!IsFile)
284 continue;
285
286 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
287 llvm::MemoryBuffer::getFile(ConfigFile.c_str());
288 if (std::error_code EC = Text.getError()) {
289 llvm::errs() << "Can't read " << ConfigFile << ": " << EC.message()
290 << "\n";
291 continue;
292 }
293
294 // Skip empty files, e.g. files opened for writing via shell output
295 // redirection.
296 if ((*Text)->getBuffer().empty())
297 continue;
298 llvm::ErrorOr<ClangTidyOptions> ParsedOptions =
299 ConfigHandler.second((*Text)->getBuffer());
300 if (!ParsedOptions) {
301 if (ParsedOptions.getError())
302 llvm::errs() << "Error parsing " << ConfigFile << ": "
303 << ParsedOptions.getError().message() << "\n";
304 continue;
305 }
306 return OptionsSource(*ParsedOptions, ConfigFile.c_str());
307 }
308 return llvm::None;
309 }
310
311 /// \brief Parses -line-filter option and stores it to the \c Options.
312 std::error_code parseLineFilter(StringRef LineFilter,
313 clang::tidy::ClangTidyGlobalOptions &Options) {
314 llvm::yaml::Input Input(LineFilter);
315 Input >> Options.LineFilter;
316 return Input.error();
317 }
318
319 llvm::ErrorOr<ClangTidyOptions> parseConfiguration(StringRef Config) {
320 llvm::yaml::Input Input(Config);
321 ClangTidyOptions Options;
322 Input >> Options;
323 if (Input.error())
324 return Input.error();
325 return Options;
326 }
327
328 std::string configurationAsText(const ClangTidyOptions &Options) {
329 std::string Text;
330 llvm::raw_string_ostream Stream(Text);
331 llvm::yaml::Output Output(Stream);
332 // We use the same mapping method for input and output, so we need a non-const
333 // reference here.
334 ClangTidyOptions NonConstValue = Options;
335 Output << NonConstValue;
336 return Stream.str();
337 }
338
339 } // namespace tidy
340 } // namespace clang
clang::tidy::ClangTidyOptions::Checks
llvm::Optional< std::string > Checks
Checks filter.
Definition: ClangTidyOptions.h:63
clang::tidy::ClangTidyOptions::mergeWith
ClangTidyOptions mergeWith(const ClangTidyOptions &Other) const
Creates a new ClangTidyOptions instance combined from all fields of this instance overridden by the f...
Definition: ClangTidyOptions.cpp:143
clang::tidy::DefaultOptionsProvider::getRawOptions
std::vector< OptionsSource > getRawOptions(llvm::StringRef FileName) override
Returns an ordered vector of OptionsSources, in order of increasing priority.
Definition: ClangTidyOptions.cpp:179
clang::tidy::ClangTidyOptions::ExtraArgs
llvm::Optional< ArgList > ExtraArgs
Add extra compilation arguments to the end of the list.
Definition: ClangTidyOptions.h:107
llvm
Definition: ClangTidyOptions.cpp:31
clang::tidy::ClangTidyOptions::User
llvm::Optional< std::string > User
Specifies the name or e-mail of the user running clang-tidy.
Definition: ClangTidyOptions.h:96
clang::tidy::mergeVectors
static void mergeVectors(Optional< T > &Dest, const Optional< T > &Src)
Definition: ClangTidyOptions.cpp:121
File
HeaderHandle File
Definition: PreprocessorTracker.cpp:526
Config
static cl::opt< std::string > Config("config", cl::desc(R"( Specifies a configuration in YAML/JSON format: -config="{Checks:' *', CheckOptions:[{key:x, value:y}]}" When the value is empty, clang-tidy will attempt to find a file named .clang-tidy for each source file in its parent directories. )"), cl::init(""), cl::cat(ClangTidyCategory))
clang::tidy::ClangTidyOptions::HeaderFilterRegex
llvm::Optional< std::string > HeaderFilterRegex
Output warnings from headers matching this filter.
Definition: ClangTidyOptions.h:70
llvm::yaml::MappingTraits< FileFilter >::mapping
static void mapping(IO &IO, FileFilter &File)
Definition: ClangTidyOptions.cpp:47
clang::tidy::ClangTidyOptionsProvider::OptionsSourceTypeCheckCommandLineOption
static const char OptionsSourceTypeCheckCommandLineOption[]
Definition: ClangTidyOptions.h:117
clang::tidy::ClangTidyOptions
Contains options for clang-tidy.
Definition: ClangTidyOptions.h:49
clang::tidy::ClangTidyGlobalOptions
Global options.
Definition: ClangTidyOptions.h:41
clang::tidy::ClangTidyOptionsProvider::OptionsSourceTypeConfigCommandLineOption
static const char OptionsSourceTypeConfigCommandLineOption[]
Definition: ClangTidyOptions.h:118
clang::tidy::FileOptionsProvider::getRawOptions
std::vector< OptionsSource > getRawOptions(llvm::StringRef FileName) override
Returns an ordered vector of OptionsSources, in order of increasing priority.
Definition: ClangTidyOptions.cpp:225
clang::tidy::parseLineFilter
std::error_code parseLineFilter(StringRef LineFilter, clang::tidy::ClangTidyGlobalOptions &Options)
Parses -line-filter option and stores it to the Options.
Definition: ClangTidyOptions.cpp:312
Path
std::vector< HeaderHandle > Path
Definition: PreprocessorTracker.cpp:538
clang::tidy::parseConfiguration
llvm::ErrorOr< ClangTidyOptions > parseConfiguration(StringRef Config)
Definition: ClangTidyOptions.cpp:319
llvm::yaml::MappingTraits< FileFilter >::validate
static StringRef validate(IO &io, FileFilter &File)
Definition: ClangTidyOptions.cpp:51
llvm::yaml::NOptionMap::NOptionMap
NOptionMap(IO &, const ClangTidyOptions::OptionMap &OptionMap)
Definition: ClangTidyOptions.cpp:71
clang::tidy::ClangTidyOptions::CheckOptions
OptionMap CheckOptions
Key-value mapping used to store check-specific options.
Definition: ClangTidyOptions.h:102
clang::tidy::ClangTidyOptions::SystemHeaders
llvm::Optional< bool > SystemHeaders
Output warnings from system headers matching HeaderFilterRegex.
Definition: ClangTidyOptions.h:73
clang::tidy::FileOptionsProvider::OverrideOptions
ClangTidyOptions OverrideOptions
Definition: ClangTidyOptions.h:256
ClangTidyOptions.h
clang::tidy::FileOptionsProvider::ConfigHandlers
ConfigFileHandlers ConfigHandlers
Definition: ClangTidyOptions.h:257
clang::tidy::ClangTidyOptions::ExtraArgsBefore
llvm::Optional< ArgList > ExtraArgsBefore
Add extra compilation arguments to the start of the list.
Definition: ClangTidyOptions.h:110
clang::tidy::ClangTidyOptions::FormatStyle
llvm::Optional< std::string > FormatStyle
Format code around applied fixes with clang-format using this style.
Definition: ClangTidyOptions.h:90
Directory
static cl::opt< std::string > Directory(cl::Positional, cl::Required, cl::desc("<Search Root Directory>"))
LineFilter
static cl::opt< std::string > LineFilter("line-filter", cl::desc(R"( List of files with line ranges to filter the warnings. Can be used together with -header-filter. The format of the list is a JSON array of objects: [ {"name":"file1.cpp","lines":[[1,3],[5,7]]}, {"name":"file2.h"} ] )"), cl::init(""), cl::cat(ClangTidyCategory))
clang::tidy::ConfigOptionsProvider::getRawOptions
std::vector< OptionsSource > getRawOptions(llvm::StringRef FileName) override
Returns an ordered vector of OptionsSources, in order of increasing priority.
Definition: ClangTidyOptions.cpp:194
clang::tidy::configurationAsText
std::string configurationAsText(const ClangTidyOptions &Options)
Serializes configuration to a YAML-encoded string.
Definition: ClangTidyOptions.cpp:328
ClangTidyModuleRegistry.h
llvm::yaml::SequenceTraits< FileFilter::LineRange >::element
static unsigned & element(IO &IO, FileFilter::LineRange &Range, size_t Index)
Definition: ClangTidyOptions.cpp:39
clang::tidy::FileOptionsProvider::CachedOptions
llvm::StringMap< OptionsSource > CachedOptions
Definition: ClangTidyOptions.h:255
llvm::yaml::NOptionMap
Definition: ClangTidyOptions.cpp:69
llvm::yaml::MappingTraits< ClangTidyOptions >::mapping
static void mapping(IO &IO, ClangTidyOptions &Options)
Definition: ClangTidyOptions.cpp:83
clang::tidy::ClangTidyGlobalOptions::LineFilter
std::vector< FileFilter > LineFilter
Output warnings from certain line ranges of certain files only.
Definition: ClangTidyOptions.h:44
llvm::yaml::MappingTraits< ClangTidyOptions::StringPair >::mapping
static void mapping(IO &IO, ClangTidyOptions::StringPair &KeyValue)
Definition: ClangTidyOptions.cpp:63
clang::tidy::FileOptionsProvider::ConfigFileHandler
std::pair< std::string, std::function< llvm::ErrorOr< ClangTidyOptions > llvm::StringRef)> > ConfigFileHandler
Definition: ClangTidyOptions.h:191
clang::tidy::ClangTidyOptions::WarningsAsErrors
llvm::Optional< std::string > WarningsAsErrors
WarningsAsErrors filter.
Definition: ClangTidyOptions.h:66
clang::tidy::mergeCommaSeparatedLists
static void mergeCommaSeparatedLists(Optional< std::string > &Dest, const Optional< std::string > &Src)
Definition: ClangTidyOptions.cpp:130
clang::tidy::FileOptionsProvider::ConfigFileHandlers
std::vector< ConfigFileHandler > ConfigFileHandlers
Configuration file handlers listed in the order of priority.
Definition: ClangTidyOptions.h:210
clang::tidy::FileFilter
Contains a list of line ranges in a single file.
Definition: ClangTidyOptions.h:28
clang::tidy::ClangTidyOptions::AnalyzeTemporaryDtors
llvm::Optional< bool > AnalyzeTemporaryDtors
Turns on temporary destructor-based analysis.
Definition: ClangTidyOptions.h:76
clang
Definition: AndroidTidyModule.cpp:28
Range
CharSourceRange Range
SourceRange for the file name.
Definition: IncludeOrderCheck.cpp:37
llvm::yaml::NOptionMap::Options
std::vector< ClangTidyOptions::StringPair > Options
Definition: ClangTidyOptions.cpp:79
llvm::yaml::SequenceTraits< FileFilter::LineRange >::size
static size_t size(IO &IO, FileFilter::LineRange &Range)
Definition: ClangTidyOptions.cpp:36
clang::tidy::overrideValue
static void overrideValue(Optional< T > &Dest, const Optional< T > &Src)
Definition: ClangTidyOptions.cpp:137
llvm::yaml::NOptionMap::NOptionMap
NOptionMap(IO &)
Definition: ClangTidyOptions.cpp:70
clang::tidy::ClangTidyOptionsProvider::OptionsSource
std::pair< ClangTidyOptions, std::string > OptionsSource
ClangTidyOptions and its source.
Definition: ClangTidyOptions.h:133
llvm::yaml::NOptionMap::denormalize
ClangTidyOptions::OptionMap denormalize(IO &)
Definition: ClangTidyOptions.cpp:73
clang::tidy::FileFilter::LineRanges
std::vector< LineRange > LineRanges
A list of line ranges in this file, for which we show warnings.
Definition: ClangTidyOptions.h:36
OptionsSource
clang::tidy::ClangTidyOptionsProvider::OptionsSource OptionsSource
Definition: ClangTidyOptions.cpp:26
clang::tidy::FileOptionsProvider::FileOptionsProvider
FileOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions, const ClangTidyOptions &DefaultOptions, const ClangTidyOptions &OverrideOptions)
Initializes the FileOptionsProvider instance.
Definition: ClangTidyOptions.cpp:204
clang::tidy::FileFilter::Name
std::string Name
File name.
Definition: ClangTidyOptions.h:30
clang::tidy::FileOptionsProvider::tryReadConfigFile
llvm::Optional< OptionsSource > tryReadConfigFile(llvm::StringRef Directory)
Try to read configuration files from Directory using registered ConfigHandlers.
Definition: ClangTidyOptions.cpp:265
clang::tidy::DefaultOptionsProvider
Implementation of the ClangTidyOptionsProvider interface, which returns the same options for all file...
Definition: ClangTidyOptions.h:147