clang-tools 20.0.0git
ClangTidyOptions.cpp
Go to the documentation of this file.
1//===--- ClangTidyOptions.cpp - clang-tidy ----------------------*- C++ -*-===//
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 "ClangTidyOptions.h"
11#include "clang/Basic/LLVM.h"
12#include "llvm/ADT/SmallString.h"
13#include "llvm/Support/Debug.h"
14#include "llvm/Support/Errc.h"
15#include "llvm/Support/FileSystem.h"
16#include "llvm/Support/MemoryBufferRef.h"
17#include "llvm/Support/Path.h"
18#include "llvm/Support/YAMLTraits.h"
19#include <algorithm>
20#include <optional>
21#include <utility>
22
23#define DEBUG_TYPE "clang-tidy-options"
24
28
29LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter)
30LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter::LineRange)
31
32namespace llvm::yaml {
33
34// Map std::pair<int, int> to a JSON array of size 2.
35template <> 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
46template <> 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 std::string 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 "";
59 }
60};
61
62template <> 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
69struct NOptionMap {
70 NOptionMap(IO &) {}
71 NOptionMap(IO &, const ClangTidyOptions::OptionMap &OptionMap) {
72 Options.reserve(OptionMap.size());
73 for (const auto &KeyValue : OptionMap)
74 Options.emplace_back(std::string(KeyValue.getKey()), KeyValue.getValue().Value);
75 }
76 ClangTidyOptions::OptionMap denormalize(IO &) {
77 ClangTidyOptions::OptionMap Map;
78 for (const auto &KeyValue : Options)
79 Map[KeyValue.first] = ClangTidyOptions::ClangTidyValue(KeyValue.second);
80 return Map;
81 }
82 std::vector<ClangTidyOptions::StringPair> Options;
83};
84
85template <>
86void yamlize(IO &IO, ClangTidyOptions::OptionMap &Val, bool,
87 EmptyContext &Ctx) {
88 if (IO.outputting()) {
89 // Ensure check options are sorted
90 std::vector<std::pair<StringRef, StringRef>> SortedOptions;
91 SortedOptions.reserve(Val.size());
92 for (auto &Key : Val) {
93 SortedOptions.emplace_back(Key.getKey(), Key.getValue().Value);
94 }
95 std::sort(SortedOptions.begin(), SortedOptions.end());
96
97 IO.beginMapping();
98 // Only output as a map
99 for (auto &Option : SortedOptions) {
100 bool UseDefault = false;
101 void *SaveInfo = nullptr;
102 IO.preflightKey(Option.first.data(), true, false, UseDefault, SaveInfo);
103 IO.scalarString(Option.second, needsQuotes(Option.second));
104 IO.postflightKey(SaveInfo);
105 }
106 IO.endMapping();
107 } else {
108 // We need custom logic here to support the old method of specifying check
109 // options using a list of maps containing key and value keys.
110 auto &I = reinterpret_cast<Input &>(IO);
111 if (isa<SequenceNode>(I.getCurrentNode())) {
112 MappingNormalization<NOptionMap, ClangTidyOptions::OptionMap> NOpts(IO,
113 Val);
114 EmptyContext Ctx;
115 yamlize(IO, NOpts->Options, true, Ctx);
116 } else if (isa<MappingNode>(I.getCurrentNode())) {
117 IO.beginMapping();
118 for (StringRef Key : IO.keys()) {
119 IO.mapRequired(Key.data(), Val[Key].Value);
120 }
121 IO.endMapping();
122 } else {
123 IO.setError("expected a sequence or map");
124 }
125 }
126}
127
129 std::optional<std::string> AsString;
130 std::optional<std::vector<std::string>> AsVector;
131};
132
133template <> void yamlize(IO &IO, ChecksVariant &Val, bool, EmptyContext &Ctx) {
134 if (!IO.outputting()) {
135 // Special case for reading from YAML
136 // Must support reading from both a string or a list
137 auto &I = reinterpret_cast<Input &>(IO);
138 if (isa<ScalarNode, BlockScalarNode>(I.getCurrentNode())) {
139 Val.AsString = std::string();
140 yamlize(IO, *Val.AsString, true, Ctx);
141 } else if (isa<SequenceNode>(I.getCurrentNode())) {
142 Val.AsVector = std::vector<std::string>();
143 yamlize(IO, *Val.AsVector, true, Ctx);
144 } else {
145 IO.setError("expected string or sequence");
146 }
147 }
148}
149
150static void mapChecks(IO &IO, std::optional<std::string> &Checks) {
151 if (IO.outputting()) {
152 // Output always a string
153 IO.mapOptional("Checks", Checks);
154 } else {
155 // Input as either a string or a list
156 ChecksVariant ChecksAsVariant;
157 IO.mapOptional("Checks", ChecksAsVariant);
158 if (ChecksAsVariant.AsString)
159 Checks = ChecksAsVariant.AsString;
160 else if (ChecksAsVariant.AsVector)
161 Checks = llvm::join(*ChecksAsVariant.AsVector, ",");
162 }
163}
164
165template <> struct MappingTraits<ClangTidyOptions> {
166 static void mapping(IO &IO, ClangTidyOptions &Options) {
167 mapChecks(IO, Options.Checks);
168 IO.mapOptional("WarningsAsErrors", Options.WarningsAsErrors);
169 IO.mapOptional("HeaderFileExtensions", Options.HeaderFileExtensions);
170 IO.mapOptional("ImplementationFileExtensions",
172 IO.mapOptional("HeaderFilterRegex", Options.HeaderFilterRegex);
173 IO.mapOptional("ExcludeHeaderFilterRegex",
175 IO.mapOptional("FormatStyle", Options.FormatStyle);
176 IO.mapOptional("User", Options.User);
177 IO.mapOptional("CheckOptions", Options.CheckOptions);
178 IO.mapOptional("ExtraArgs", Options.ExtraArgs);
179 IO.mapOptional("ExtraArgsBefore", Options.ExtraArgsBefore);
180 IO.mapOptional("InheritParentConfig", Options.InheritParentConfig);
181 IO.mapOptional("UseColor", Options.UseColor);
182 IO.mapOptional("SystemHeaders", Options.SystemHeaders);
183 }
184};
185
186} // namespace llvm::yaml
187
188namespace clang::tidy {
189
191 ClangTidyOptions Options;
192 Options.Checks = "";
193 Options.WarningsAsErrors = "";
194 Options.HeaderFileExtensions = {"", "h", "hh", "hpp", "hxx"};
195 Options.ImplementationFileExtensions = {"c", "cc", "cpp", "cxx"};
196 Options.HeaderFilterRegex = std::nullopt;
197 Options.ExcludeHeaderFilterRegex = std::nullopt;
198 Options.SystemHeaders = false;
199 Options.FormatStyle = "none";
200 Options.User = std::nullopt;
201 for (const ClangTidyModuleRegistry::entry &Module :
202 ClangTidyModuleRegistry::entries())
203 Options.mergeWith(Module.instantiate()->getModuleOptions(), 0);
204 return Options;
205}
206
207template <typename T>
208static void mergeVectors(std::optional<T> &Dest, const std::optional<T> &Src) {
209 if (Src) {
210 if (Dest)
211 Dest->insert(Dest->end(), Src->begin(), Src->end());
212 else
213 Dest = Src;
214 }
215}
216
217static void mergeCommaSeparatedLists(std::optional<std::string> &Dest,
218 const std::optional<std::string> &Src) {
219 if (Src)
220 Dest = (Dest && !Dest->empty() ? *Dest + "," : "") + *Src;
221}
222
223template <typename T>
224static void overrideValue(std::optional<T> &Dest, const std::optional<T> &Src) {
225 if (Src)
226 Dest = Src;
227}
228
230 unsigned Order) {
240 overrideValue(User, Other.User);
244
245 for (const auto &KeyValue : Other.CheckOptions) {
246 CheckOptions.insert_or_assign(
247 KeyValue.getKey(),
248 ClangTidyValue(KeyValue.getValue().Value,
249 KeyValue.getValue().Priority + Order));
250 }
251 return *this;
252}
253
255 unsigned Order) const {
256 ClangTidyOptions Result = *this;
257 Result.mergeWith(Other, Order);
258 return Result;
259}
260
262 "clang-tidy binary";
264 "command-line option '-checks'";
265const char
267 "command-line option '-config'";
268
271 ClangTidyOptions Result;
272 unsigned Priority = 0;
273 for (auto &Source : getRawOptions(FileName))
274 Result.mergeWith(Source.first, ++Priority);
275 return Result;
276}
277
278std::vector<OptionsSource>
280 std::vector<OptionsSource> Result;
281 Result.emplace_back(DefaultOptions, OptionsSourceTypeDefaultBinary);
282 return Result;
283}
284
286 ClangTidyGlobalOptions GlobalOptions, ClangTidyOptions DefaultOptions,
287 ClangTidyOptions ConfigOptions, ClangTidyOptions OverrideOptions,
288 llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS)
289 : FileOptionsBaseProvider(std::move(GlobalOptions),
290 std::move(DefaultOptions),
291 std::move(OverrideOptions), std::move(FS)),
292 ConfigOptions(std::move(ConfigOptions)) {}
293
294std::vector<OptionsSource>
296 std::vector<OptionsSource> RawOptions =
298 if (ConfigOptions.InheritParentConfig.value_or(false)) {
299 LLVM_DEBUG(llvm::dbgs()
300 << "Getting options for file " << FileName << "...\n");
301 assert(FS && "FS must be set.");
302
303 llvm::SmallString<128> AbsoluteFilePath(FileName);
304
305 if (!FS->makeAbsolute(AbsoluteFilePath)) {
306 addRawFileOptions(AbsoluteFilePath, RawOptions);
307 }
308 }
309 RawOptions.emplace_back(ConfigOptions,
311 RawOptions.emplace_back(OverrideOptions,
313 return RawOptions;
314}
315
317 ClangTidyGlobalOptions GlobalOptions, ClangTidyOptions DefaultOptions,
318 ClangTidyOptions OverrideOptions,
319 llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS)
320 : DefaultOptionsProvider(std::move(GlobalOptions),
321 std::move(DefaultOptions)),
322 OverrideOptions(std::move(OverrideOptions)), FS(std::move(VFS)) {
323 if (!FS)
324 FS = llvm::vfs::getRealFileSystem();
325 ConfigHandlers.emplace_back(".clang-tidy", parseConfiguration);
326}
327
329 ClangTidyGlobalOptions GlobalOptions, ClangTidyOptions DefaultOptions,
330 ClangTidyOptions OverrideOptions,
332 : DefaultOptionsProvider(std::move(GlobalOptions),
333 std::move(DefaultOptions)),
334 OverrideOptions(std::move(OverrideOptions)),
335 ConfigHandlers(std::move(ConfigHandlers)) {}
336
338 llvm::StringRef AbsolutePath, std::vector<OptionsSource> &CurOptions) {
339 auto CurSize = CurOptions.size();
340
341 // Look for a suitable configuration file in all parent directories of the
342 // file. Start with the immediate parent directory and move up.
343 StringRef Path = llvm::sys::path::parent_path(AbsolutePath);
344 for (StringRef CurrentPath = Path; !CurrentPath.empty();
345 CurrentPath = llvm::sys::path::parent_path(CurrentPath)) {
346 std::optional<OptionsSource> Result;
347
348 auto Iter = CachedOptions.find(CurrentPath);
349 if (Iter != CachedOptions.end())
350 Result = Iter->second;
351
352 if (!Result)
353 Result = tryReadConfigFile(CurrentPath);
354
355 if (Result) {
356 // Store cached value for all intermediate directories.
357 while (Path != CurrentPath) {
358 LLVM_DEBUG(llvm::dbgs()
359 << "Caching configuration for path " << Path << ".\n");
360 if (!CachedOptions.count(Path))
361 CachedOptions[Path] = *Result;
362 Path = llvm::sys::path::parent_path(Path);
363 }
364 CachedOptions[Path] = *Result;
365
366 CurOptions.push_back(*Result);
367 if (!Result->first.InheritParentConfig.value_or(false))
368 break;
369 }
370 }
371 // Reverse order of file configs because closer configs should have higher
372 // priority.
373 std::reverse(CurOptions.begin() + CurSize, CurOptions.end());
374}
375
377 ClangTidyGlobalOptions GlobalOptions, ClangTidyOptions DefaultOptions,
378 ClangTidyOptions OverrideOptions,
379 llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS)
380 : FileOptionsBaseProvider(std::move(GlobalOptions),
381 std::move(DefaultOptions),
382 std::move(OverrideOptions), std::move(VFS)) {}
383
385 ClangTidyGlobalOptions GlobalOptions, ClangTidyOptions DefaultOptions,
386 ClangTidyOptions OverrideOptions,
389 std::move(GlobalOptions), std::move(DefaultOptions),
390 std::move(OverrideOptions), std::move(ConfigHandlers)) {}
391
392// FIXME: This method has some common logic with clang::format::getStyle().
393// Consider pulling out common bits to a findParentFileWithName function or
394// similar.
395std::vector<OptionsSource>
397 LLVM_DEBUG(llvm::dbgs() << "Getting options for file " << FileName
398 << "...\n");
399 assert(FS && "FS must be set.");
400
401 llvm::SmallString<128> AbsoluteFilePath(FileName);
402
403 if (FS->makeAbsolute(AbsoluteFilePath))
404 return {};
405
406 std::vector<OptionsSource> RawOptions =
407 DefaultOptionsProvider::getRawOptions(AbsoluteFilePath.str());
408 addRawFileOptions(AbsoluteFilePath, RawOptions);
409 OptionsSource CommandLineOptions(OverrideOptions,
411
412 RawOptions.push_back(CommandLineOptions);
413 return RawOptions;
414}
415
416std::optional<OptionsSource>
418 assert(!Directory.empty());
419
420 llvm::ErrorOr<llvm::vfs::Status> DirectoryStatus = FS->status(Directory);
421
422 if (!DirectoryStatus || !DirectoryStatus->isDirectory()) {
423 llvm::errs() << "Error reading configuration from " << Directory
424 << ": directory doesn't exist.\n";
425 return std::nullopt;
426 }
427
428 for (const ConfigFileHandler &ConfigHandler : ConfigHandlers) {
429 SmallString<128> ConfigFile(Directory);
430 llvm::sys::path::append(ConfigFile, ConfigHandler.first);
431 LLVM_DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
432
433 llvm::ErrorOr<llvm::vfs::Status> FileStatus = FS->status(ConfigFile);
434
435 if (!FileStatus || !FileStatus->isRegularFile())
436 continue;
437
438 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
439 FS->getBufferForFile(ConfigFile);
440 if (std::error_code EC = Text.getError()) {
441 llvm::errs() << "Can't read " << ConfigFile << ": " << EC.message()
442 << "\n";
443 continue;
444 }
445
446 // Skip empty files, e.g. files opened for writing via shell output
447 // redirection.
448 if ((*Text)->getBuffer().empty())
449 continue;
450 llvm::ErrorOr<ClangTidyOptions> ParsedOptions =
451 ConfigHandler.second({(*Text)->getBuffer(), ConfigFile});
452 if (!ParsedOptions) {
453 if (ParsedOptions.getError())
454 llvm::errs() << "Error parsing " << ConfigFile << ": "
455 << ParsedOptions.getError().message() << "\n";
456 continue;
457 }
458 return OptionsSource(*ParsedOptions, std::string(ConfigFile));
459 }
460 return std::nullopt;
461}
462
463/// Parses -line-filter option and stores it to the \c Options.
464std::error_code parseLineFilter(StringRef LineFilter,
466 llvm::yaml::Input Input(LineFilter);
467 Input >> Options.LineFilter;
468 return Input.error();
469}
470
471llvm::ErrorOr<ClangTidyOptions>
472parseConfiguration(llvm::MemoryBufferRef Config) {
473 llvm::yaml::Input Input(Config);
474 ClangTidyOptions Options;
475 Input >> Options;
476 if (Input.error())
477 return Input.error();
478 return Options;
479}
480
481static void diagHandlerImpl(const llvm::SMDiagnostic &Diag, void *Ctx) {
482 (*reinterpret_cast<DiagCallback *>(Ctx))(Diag);
483}
484
485llvm::ErrorOr<ClangTidyOptions>
487 DiagCallback Handler) {
488 llvm::yaml::Input Input(Config, nullptr, Handler ? diagHandlerImpl : nullptr,
489 &Handler);
490 ClangTidyOptions Options;
491 Input >> Options;
492 if (Input.error())
493 return Input.error();
494 return Options;
495}
496
497std::string configurationAsText(const ClangTidyOptions &Options) {
498 std::string Text;
499 llvm::raw_string_ostream Stream(Text);
500 llvm::yaml::Output Output(Stream);
501 // We use the same mapping method for input and output, so we need a non-const
502 // reference here.
503 ClangTidyOptions NonConstValue = Options;
504 Output << NonConstValue;
505 return Stream.str();
506}
507
508} // namespace clang::tidy
static cl::opt< std::string > ConfigFile("config-file", desc(R"( Specify the path of .clang-tidy or custom config file: e.g. --config-file=/some/path/myTidyConfigFile This option internally works exactly the same way as --config option after reading specified config file. Use either --config-file or --config, not both. )"), cl::init(""), cl::cat(ClangTidyCategory))
static cl::opt< std::string > Config("config", desc(R"( Specifies a configuration in YAML/JSON format: -config="{Checks:' *', CheckOptions:{x: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))
static cl::opt< std::string > LineFilter("line-filter", 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::ClangTidyOptionsProvider::OptionsSource OptionsSource
std::string Text
CharSourceRange Range
SourceRange for the file name.
StringRef FileName
std::vector< HeaderHandle > Path
llvm::StringRef Directory
llvm::StringRef Src
std::string Output
Definition: TraceTests.cpp:159
ClangTidyOptions getOptions(llvm::StringRef FileName)
Returns options applying to a specific translation unit with the specified FileName.
static const char OptionsSourceTypeCheckCommandLineOption[]
virtual std::vector< OptionsSource > getRawOptions(llvm::StringRef FileName)=0
Returns an ordered vector of OptionsSources, in order of increasing priority.
std::pair< ClangTidyOptions, std::string > OptionsSource
ClangTidyOptions and its source.
static const char OptionsSourceTypeConfigCommandLineOption[]
static const char OptionsSourceTypeDefaultBinary[]
ConfigOptionsProvider(ClangTidyGlobalOptions GlobalOptions, ClangTidyOptions DefaultOptions, ClangTidyOptions ConfigOptions, ClangTidyOptions OverrideOptions, llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > FS=nullptr)
std::vector< OptionsSource > getRawOptions(llvm::StringRef FileName) override
Returns an ordered vector of OptionsSources, in order of increasing priority.
Implementation of the ClangTidyOptionsProvider interface, which returns the same options for all file...
std::vector< OptionsSource > getRawOptions(llvm::StringRef FileName) override
Returns an ordered vector of OptionsSources, in order of increasing priority.
std::optional< OptionsSource > tryReadConfigFile(llvm::StringRef Directory)
Try to read configuration files from Directory using registered ConfigHandlers.
llvm::StringMap< OptionsSource > CachedOptions
llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > FS
FileOptionsBaseProvider(ClangTidyGlobalOptions GlobalOptions, ClangTidyOptions DefaultOptions, ClangTidyOptions OverrideOptions, llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > FS)
std::vector< ConfigFileHandler > ConfigFileHandlers
Configuration file handlers listed in the order of priority.
void addRawFileOptions(llvm::StringRef AbsolutePath, std::vector< OptionsSource > &CurOptions)
std::pair< std::string, std::function< llvm::ErrorOr< ClangTidyOptions >(llvm::MemoryBufferRef)> > ConfigFileHandler
std::vector< OptionsSource > getRawOptions(llvm::StringRef FileName) override
Returns an ordered vector of OptionsSources, in order of increasing priority.
FileOptionsProvider(ClangTidyGlobalOptions GlobalOptions, ClangTidyOptions DefaultOptions, ClangTidyOptions OverrideOptions, llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > FS=nullptr)
Initializes the FileOptionsProvider instance.
std::error_code parseLineFilter(StringRef LineFilter, clang::tidy::ClangTidyGlobalOptions &Options)
Parses -line-filter option and stores it to the Options.
static void diagHandlerImpl(const llvm::SMDiagnostic &Diag, void *Ctx)
static void mergeVectors(std::optional< T > &Dest, const std::optional< T > &Src)
llvm::function_ref< void(const llvm::SMDiagnostic &)> DiagCallback
llvm::ErrorOr< ClangTidyOptions > parseConfigurationWithDiags(llvm::MemoryBufferRef Config, DiagCallback Handler)
static void mergeCommaSeparatedLists(std::optional< std::string > &Dest, const std::optional< std::string > &Src)
std::string configurationAsText(const ClangTidyOptions &Options)
Serializes configuration to a YAML-encoded string.
llvm::ErrorOr< ClangTidyOptions > parseConfiguration(llvm::MemoryBufferRef Config)
Parses configuration from JSON and returns ClangTidyOptions or an error.
static void overrideValue(std::optional< T > &Dest, const std::optional< T > &Src)
static void mapChecks(IO &IO, std::optional< std::string > &Checks)
void yamlize(IO &IO, ClangTidyOptions::OptionMap &Val, bool, EmptyContext &Ctx)
std::vector< FileFilter > LineFilter
Output warnings from certain line ranges of certain files only.
Helper structure for storing option value with priority of the value.
Contains options for clang-tidy.
OptionMap CheckOptions
Key-value mapping used to store check-specific options.
ClangTidyOptions merge(const ClangTidyOptions &Other, unsigned Order) const
Creates a new ClangTidyOptions instance combined from all fields of this instance overridden by the f...
std::optional< bool > InheritParentConfig
Only used in the FileOptionsProvider and ConfigOptionsProvider.
std::optional< std::string > HeaderFilterRegex
Output warnings from headers matching this filter.
std::optional< std::string > Checks
Checks filter.
std::optional< std::string > WarningsAsErrors
WarningsAsErrors filter.
std::optional< std::vector< std::string > > ImplementationFileExtensions
File extensions to consider to determine if a given diagnostic is located is located in an implementa...
ClangTidyOptions & mergeWith(const ClangTidyOptions &Other, unsigned Order)
Overwrites all fields in here by the fields of Other that have a value.
std::optional< std::string > User
Specifies the name or e-mail of the user running clang-tidy.
std::optional< std::vector< std::string > > HeaderFileExtensions
File extensions to consider to determine if a given diagnostic is located in a header file.
std::optional< bool > UseColor
Use colors in diagnostics. If missing, it will be auto detected.
std::optional< bool > SystemHeaders
Output warnings from system headers matching HeaderFilterRegex.
static ClangTidyOptions getDefaults()
These options are used for all settings that haven't been overridden by the OptionsProvider.
std::optional< std::string > ExcludeHeaderFilterRegex
Exclude warnings from headers matching this filter, even if they match HeaderFilterRegex.
std::optional< ArgList > ExtraArgsBefore
Add extra compilation arguments to the start of the list.
std::optional< std::string > FormatStyle
Format code around applied fixes with clang-format using this style.
std::optional< ArgList > ExtraArgs
Add extra compilation arguments to the end of the list.
Contains a list of line ranges in a single file.
std::pair< unsigned int, unsigned int > LineRange
LineRange is a pair<start, end> (inclusive).
std::optional< std::string > AsString
std::optional< std::vector< std::string > > AsVector
static void mapping(IO &IO, ClangTidyOptions &Options)
static void mapping(IO &IO, ClangTidyOptions::StringPair &KeyValue)
static std::string validate(IO &Io, FileFilter &File)
static void mapping(IO &IO, FileFilter &File)
ClangTidyOptions::OptionMap denormalize(IO &)
NOptionMap(IO &, const ClangTidyOptions::OptionMap &OptionMap)
std::vector< ClangTidyOptions::StringPair > Options
static unsigned & element(IO &IO, FileFilter::LineRange &Range, size_t Index)
static size_t size(IO &IO, FileFilter::LineRange &Range)