clang-tools  11.0.0
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/Path.h"
17 #include "llvm/Support/YAMLTraits.h"
18 #include "llvm/Support/raw_ostream.h"
19 #include <utility>
20 
21 #define DEBUG_TYPE "clang-tidy-options"
22 
26 
27 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter)
28 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter::LineRange)
29 
30 namespace llvm {
31 namespace yaml {
32 
33 // Map std::pair<int, int> to a JSON array of size 2.
34 template <> struct SequenceTraits<FileFilter::LineRange> {
35  static size_t size(IO &IO, FileFilter::LineRange &Range) {
36  return Range.first == 0 ? 0 : Range.second == 0 ? 1 : 2;
37  }
38  static unsigned &element(IO &IO, FileFilter::LineRange &Range, size_t Index) {
39  if (Index > 1)
40  IO.setError("Too many elements in line range.");
41  return Index == 0 ? Range.first : Range.second;
42  }
43 };
44 
45 template <> struct MappingTraits<FileFilter> {
46  static void mapping(IO &IO, FileFilter &File) {
47  IO.mapRequired("name", File.Name);
48  IO.mapOptional("lines", File.LineRanges);
49  }
50  static StringRef validate(IO &io, FileFilter &File) {
51  if (File.Name.empty())
52  return "No file name specified";
53  for (const FileFilter::LineRange &Range : File.LineRanges) {
54  if (Range.first <= 0 || Range.second <= 0)
55  return "Invalid line range";
56  }
57  return StringRef();
58  }
59 };
60 
61 template <> struct MappingTraits<ClangTidyOptions::StringPair> {
62  static void mapping(IO &IO, ClangTidyOptions::StringPair &KeyValue) {
63  IO.mapRequired("key", KeyValue.first);
64  IO.mapRequired("value", KeyValue.second);
65  }
66 };
67 
68 struct NOptionMap {
69  NOptionMap(IO &) {}
70  NOptionMap(IO &, const ClangTidyOptions::OptionMap &OptionMap) {
71  Options.reserve(OptionMap.size());
72  for (const auto &KeyValue : OptionMap)
73  Options.emplace_back(KeyValue.first, KeyValue.second.Value);
74  }
75  ClangTidyOptions::OptionMap denormalize(IO &) {
76  ClangTidyOptions::OptionMap Map;
77  for (const auto &KeyValue : Options)
78  Map[KeyValue.first] = ClangTidyOptions::ClangTidyValue(KeyValue.second);
79  return Map;
80  }
81  std::vector<ClangTidyOptions::StringPair> Options;
82 };
83 
84 template <> struct MappingTraits<ClangTidyOptions> {
85  static void mapping(IO &IO, ClangTidyOptions &Options) {
86  MappingNormalization<NOptionMap, ClangTidyOptions::OptionMap> NOpts(
87  IO, Options.CheckOptions);
88  bool Ignored = false;
89  IO.mapOptional("Checks", Options.Checks);
90  IO.mapOptional("WarningsAsErrors", Options.WarningsAsErrors);
91  IO.mapOptional("HeaderFilterRegex", Options.HeaderFilterRegex);
92  IO.mapOptional("AnalyzeTemporaryDtors", Ignored); // legacy compatibility
93  IO.mapOptional("FormatStyle", Options.FormatStyle);
94  IO.mapOptional("User", Options.User);
95  IO.mapOptional("CheckOptions", NOpts->Options);
96  IO.mapOptional("ExtraArgs", Options.ExtraArgs);
97  IO.mapOptional("ExtraArgsBefore", Options.ExtraArgsBefore);
98  IO.mapOptional("InheritParentConfig", Options.InheritParentConfig);
99  IO.mapOptional("UseColor", Options.UseColor);
100  }
101 };
102 
103 } // namespace yaml
104 } // namespace llvm
105 
106 namespace clang {
107 namespace tidy {
108 
110  ClangTidyOptions Options;
111  Options.Checks = "";
112  Options.WarningsAsErrors = "";
113  Options.HeaderFilterRegex = "";
114  Options.SystemHeaders = false;
115  Options.FormatStyle = "none";
116  Options.User = llvm::None;
117  unsigned Priority = 0;
118  for (const ClangTidyModuleRegistry::entry &Module :
119  ClangTidyModuleRegistry::entries())
120  Options =
121  Options.mergeWith(Module.instantiate()->getModuleOptions(), ++Priority);
122  return Options;
123 }
124 
125 template <typename T>
126 static void mergeVectors(Optional<T> &Dest, const Optional<T> &Src) {
127  if (Src) {
128  if (Dest)
129  Dest->insert(Dest->end(), Src->begin(), Src->end());
130  else
131  Dest = Src;
132  }
133 }
134 
135 static void mergeCommaSeparatedLists(Optional<std::string> &Dest,
136  const Optional<std::string> &Src) {
137  if (Src)
138  Dest = (Dest && !Dest->empty() ? *Dest + "," : "") + *Src;
139 }
140 
141 template <typename T>
142 static void overrideValue(Optional<T> &Dest, const Optional<T> &Src) {
143  if (Src)
144  Dest = Src;
145 }
146 
148  unsigned Priority) const {
149  ClangTidyOptions Result = *this;
150 
151  mergeCommaSeparatedLists(Result.Checks, Other.Checks);
152  mergeCommaSeparatedLists(Result.WarningsAsErrors, Other.WarningsAsErrors);
153  overrideValue(Result.HeaderFilterRegex, Other.HeaderFilterRegex);
154  overrideValue(Result.SystemHeaders, Other.SystemHeaders);
155  overrideValue(Result.FormatStyle, Other.FormatStyle);
156  overrideValue(Result.User, Other.User);
157  overrideValue(Result.UseColor, Other.UseColor);
158  mergeVectors(Result.ExtraArgs, Other.ExtraArgs);
159  mergeVectors(Result.ExtraArgsBefore, Other.ExtraArgsBefore);
160 
161  for (const auto &KeyValue : Other.CheckOptions) {
162  Result.CheckOptions[KeyValue.first] = ClangTidyValue(
163  KeyValue.second.Value, KeyValue.second.Priority + Priority);
164  }
165 
166  return Result;
167 }
168 
170  "clang-tidy binary";
172  "command-line option '-checks'";
173 const char
175  "command-line option '-config'";
176 
179  ClangTidyOptions Result;
180  unsigned Priority = 0;
181  for (const auto &Source : getRawOptions(FileName))
182  Result = Result.mergeWith(Source.first, ++Priority);
183  return Result;
184 }
185 
186 std::vector<OptionsSource>
188  std::vector<OptionsSource> Result;
189  Result.emplace_back(DefaultOptions, OptionsSourceTypeDefaultBinary);
190  return Result;
191 }
192 
194  const ClangTidyGlobalOptions &GlobalOptions,
195  const ClangTidyOptions &DefaultOptions,
196  const ClangTidyOptions &ConfigOptions,
197  const ClangTidyOptions &OverrideOptions,
198  llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS)
199  : FileOptionsBaseProvider(GlobalOptions, DefaultOptions, OverrideOptions,
200  FS),
201  ConfigOptions(ConfigOptions) {}
202 
203 std::vector<OptionsSource>
205  std::vector<OptionsSource> RawOptions =
207  if (ConfigOptions.InheritParentConfig.getValueOr(false)) {
208  LLVM_DEBUG(llvm::dbgs()
209  << "Getting options for file " << FileName << "...\n");
210  assert(FS && "FS must be set.");
211 
212  llvm::SmallString<128> AbsoluteFilePath(FileName);
213 
214  if (!FS->makeAbsolute(AbsoluteFilePath)) {
215  addRawFileOptions(AbsoluteFilePath, RawOptions);
216  }
217  }
218  RawOptions.emplace_back(ConfigOptions,
220  RawOptions.emplace_back(OverrideOptions,
222  return RawOptions;
223 }
224 
226  const ClangTidyGlobalOptions &GlobalOptions,
227  const ClangTidyOptions &DefaultOptions,
228  const ClangTidyOptions &OverrideOptions,
229  llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS)
230  : DefaultOptionsProvider(GlobalOptions, DefaultOptions),
231  OverrideOptions(OverrideOptions), FS(std::move(VFS)) {
232  if (!FS)
233  FS = llvm::vfs::getRealFileSystem();
234  ConfigHandlers.emplace_back(".clang-tidy", parseConfiguration);
235 }
236 
238  const ClangTidyGlobalOptions &GlobalOptions,
239  const ClangTidyOptions &DefaultOptions,
240  const ClangTidyOptions &OverrideOptions,
241  const FileOptionsBaseProvider::ConfigFileHandlers &ConfigHandlers)
242  : DefaultOptionsProvider(GlobalOptions, DefaultOptions),
243  OverrideOptions(OverrideOptions), ConfigHandlers(ConfigHandlers) {}
244 
246  llvm::StringRef AbsolutePath, std::vector<OptionsSource> &CurOptions) {
247  auto CurSize = CurOptions.size();
248 
249  // Look for a suitable configuration file in all parent directories of the
250  // file. Start with the immediate parent directory and move up.
251  StringRef Path = llvm::sys::path::parent_path(AbsolutePath);
252  for (StringRef CurrentPath = Path; !CurrentPath.empty();
253  CurrentPath = llvm::sys::path::parent_path(CurrentPath)) {
254  llvm::Optional<OptionsSource> Result;
255 
256  auto Iter = CachedOptions.find(CurrentPath);
257  if (Iter != CachedOptions.end())
258  Result = Iter->second;
259 
260  if (!Result)
261  Result = tryReadConfigFile(CurrentPath);
262 
263  if (Result) {
264  // Store cached value for all intermediate directories.
265  while (Path != CurrentPath) {
266  LLVM_DEBUG(llvm::dbgs()
267  << "Caching configuration for path " << Path << ".\n");
268  if (!CachedOptions.count(Path))
269  CachedOptions[Path] = *Result;
270  Path = llvm::sys::path::parent_path(Path);
271  }
272  CachedOptions[Path] = *Result;
273 
274  CurOptions.push_back(*Result);
275  if (!Result->first.InheritParentConfig.getValueOr(false))
276  break;
277  }
278  }
279  // Reverse order of file configs because closer configs should have higher
280  // priority.
281  std::reverse(CurOptions.begin() + CurSize, CurOptions.end());
282 }
283 
285  const ClangTidyGlobalOptions &GlobalOptions,
286  const ClangTidyOptions &DefaultOptions,
287  const ClangTidyOptions &OverrideOptions,
288  llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS)
289  : FileOptionsBaseProvider(GlobalOptions, DefaultOptions, OverrideOptions,
290  VFS){}
291 
293  const ClangTidyGlobalOptions &GlobalOptions,
294  const ClangTidyOptions &DefaultOptions,
295  const ClangTidyOptions &OverrideOptions,
296  const FileOptionsBaseProvider::ConfigFileHandlers &ConfigHandlers)
297  : FileOptionsBaseProvider(GlobalOptions, DefaultOptions, OverrideOptions,
298  ConfigHandlers) {}
299 
300 // FIXME: This method has some common logic with clang::format::getStyle().
301 // Consider pulling out common bits to a findParentFileWithName function or
302 // similar.
303 std::vector<OptionsSource>
305  LLVM_DEBUG(llvm::dbgs() << "Getting options for file " << FileName
306  << "...\n");
307  assert(FS && "FS must be set.");
308 
309  llvm::SmallString<128> AbsoluteFilePath(FileName);
310 
311  if (FS->makeAbsolute(AbsoluteFilePath))
312  return {};
313 
314  std::vector<OptionsSource> RawOptions =
315  DefaultOptionsProvider::getRawOptions(AbsoluteFilePath.str());
316  addRawFileOptions(AbsoluteFilePath, RawOptions);
317  OptionsSource CommandLineOptions(OverrideOptions,
319 
320  RawOptions.push_back(CommandLineOptions);
321  return RawOptions;
322 }
323 
324 llvm::Optional<OptionsSource>
326  assert(!Directory.empty());
327 
328  if (!llvm::sys::fs::is_directory(Directory)) {
329  llvm::errs() << "Error reading configuration from " << Directory
330  << ": directory doesn't exist.\n";
331  return llvm::None;
332  }
333 
334  for (const ConfigFileHandler &ConfigHandler : ConfigHandlers) {
335  SmallString<128> ConfigFile(Directory);
336  llvm::sys::path::append(ConfigFile, ConfigHandler.first);
337  LLVM_DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
338 
339  bool IsFile = false;
340  // Ignore errors from is_regular_file: we only need to know if we can read
341  // the file or not.
342  llvm::sys::fs::is_regular_file(Twine(ConfigFile), IsFile);
343  if (!IsFile)
344  continue;
345 
346  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
347  llvm::MemoryBuffer::getFile(ConfigFile.c_str());
348  if (std::error_code EC = Text.getError()) {
349  llvm::errs() << "Can't read " << ConfigFile << ": " << EC.message()
350  << "\n";
351  continue;
352  }
353 
354  // Skip empty files, e.g. files opened for writing via shell output
355  // redirection.
356  if ((*Text)->getBuffer().empty())
357  continue;
358  llvm::ErrorOr<ClangTidyOptions> ParsedOptions =
359  ConfigHandler.second((*Text)->getBuffer());
360  if (!ParsedOptions) {
361  if (ParsedOptions.getError())
362  llvm::errs() << "Error parsing " << ConfigFile << ": "
363  << ParsedOptions.getError().message() << "\n";
364  continue;
365  }
366  return OptionsSource(*ParsedOptions, ConfigFile.c_str());
367  }
368  return llvm::None;
369 }
370 
371 /// Parses -line-filter option and stores it to the \c Options.
372 std::error_code parseLineFilter(StringRef LineFilter,
374  llvm::yaml::Input Input(LineFilter);
375  Input >> Options.LineFilter;
376  return Input.error();
377 }
378 
379 llvm::ErrorOr<ClangTidyOptions> parseConfiguration(StringRef Config) {
380  llvm::yaml::Input Input(Config);
381  ClangTidyOptions Options;
382  Input >> Options;
383  if (Input.error())
384  return Input.error();
385  return Options;
386 }
387 
388 std::string configurationAsText(const ClangTidyOptions &Options) {
389  std::string Text;
390  llvm::raw_string_ostream Stream(Text);
391  llvm::yaml::Output Output(Stream);
392  // We use the same mapping method for input and output, so we need a non-const
393  // reference here.
394  ClangTidyOptions NonConstValue = Options;
395  Output << NonConstValue;
396  return Stream.str();
397 }
398 
399 } // namespace tidy
400 } // namespace clang
Range
CharSourceRange Range
SourceRange for the file name.
Definition: IncludeOrderCheck.cpp:38
clang::tidy::ConfigOptionsProvider::ConfigOptionsProvider
ConfigOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions, const ClangTidyOptions &DefaultOptions, const ClangTidyOptions &ConfigOptions, const ClangTidyOptions &OverrideOptions, llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > FS=nullptr)
Definition: ClangTidyOptions.cpp:193
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:187
llvm
Some operations such as code completion produce a set of candidates.
Definition: YAMLGenerator.cpp:28
clang::tidy::DefaultOptionsProvider
Implementation of the ClangTidyOptionsProvider interface, which returns the same options for all file...
Definition: ClangTidyOptions.h:171
clang::tidy::ClangTidyOptions::Checks
llvm::Optional< std::string > Checks
Checks filter.
Definition: ClangTidyOptions.h:66
clang::tidy::FileOptionsBaseProvider::ConfigHandlers
ConfigFileHandlers ConfigHandlers
Definition: ClangTidyOptions.h:234
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:372
llvm::yaml::SequenceTraits< FileFilter::LineRange >::element
static unsigned & element(IO &IO, FileFilter::LineRange &Range, size_t Index)
Definition: ClangTidyOptions.cpp:38
clang::tidy::ClangTidyOptionsProvider::OptionsSourceTypeCheckCommandLineOption
static const char OptionsSourceTypeCheckCommandLineOption[]
Definition: ClangTidyOptions.h:141
clang::tidy::FileOptionsBaseProvider::addRawFileOptions
void addRawFileOptions(llvm::StringRef AbsolutePath, std::vector< OptionsSource > &CurOptions)
Definition: ClangTidyOptions.cpp:245
Src
llvm::StringRef Src
Definition: DraftStoreTests.cpp:21
clang::tidy::ClangTidyOptions::ClangTidyValue
Helper structure for storing option value with priority of the value.
Definition: ClangTidyOptions.h:99
Text
std::string Text
Definition: HTMLGenerator.cpp:80
clang::tidy::FileFilter
Contains a list of line ranges in a single file.
Definition: ClangTidyOptions.h:29
clang::tidy::ClangTidyOptions::ExtraArgsBefore
llvm::Optional< ArgList > ExtraArgsBefore
Add extra compilation arguments to the start of the list.
Definition: ClangTidyOptions.h:122
llvm::yaml::MappingTraits< ClangTidyOptions::StringPair >::mapping
static void mapping(IO &IO, ClangTidyOptions::StringPair &KeyValue)
Definition: ClangTidyOptions.cpp:62
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::ClangTidyOptions::CheckOptions
OptionMap CheckOptions
Key-value mapping used to store check-specific options.
Definition: ClangTidyOptions.h:114
llvm::yaml::NOptionMap
Definition: ClangTidyOptions.cpp:68
llvm::yaml::SequenceTraits< FileFilter::LineRange >::size
static size_t size(IO &IO, FileFilter::LineRange &Range)
Definition: ClangTidyOptions.cpp:35
clang::tidy::mergeVectors
static void mergeVectors(Optional< T > &Dest, const Optional< T > &Src)
Definition: ClangTidyOptions.cpp:126
clang::tidy::ClangTidyOptions
Contains options for clang-tidy.
Definition: ClangTidyOptions.h:50
clang::tidy::ClangTidyOptionsProvider::OptionsSourceTypeDefaultBinary
static const char OptionsSourceTypeDefaultBinary[]
Definition: ClangTidyOptions.h:140
clang::tidy::ClangTidyOptions::InheritParentConfig
llvm::Optional< bool > InheritParentConfig
Only used in the FileOptionsProvider and ConfigOptionsProvider.
Definition: ClangTidyOptions.h:131
clang::tidy::ClangTidyOptions::FormatStyle
llvm::Optional< std::string > FormatStyle
Format code around applied fixes with clang-format using this style.
Definition: ClangTidyOptions.h:90
clang::tidy::ClangTidyOptions::UseColor
llvm::Optional< bool > UseColor
Use colors in diagnostics. If missing, it will be auto detected.
Definition: ClangTidyOptions.h:134
OptionsSource
clang::tidy::ClangTidyOptionsProvider::OptionsSource OptionsSource
Definition: ClangTidyOptions.cpp:25
clang::tidy::ClangTidyOptionsProvider::OptionsSource
std::pair< ClangTidyOptions, std::string > OptionsSource
ClangTidyOptions and its source.
Definition: ClangTidyOptions.h:157
ClangTidyModuleRegistry.h
clang::tidy::ClangTidyOptions::HeaderFilterRegex
llvm::Optional< std::string > HeaderFilterRegex
Output warnings from headers matching this filter.
Definition: ClangTidyOptions.h:73
clang::tidy::ClangTidyOptions::SystemHeaders
llvm::Optional< bool > SystemHeaders
Output warnings from system headers matching HeaderFilterRegex.
Definition: ClangTidyOptions.h:76
clang::tidy::FileOptionsBaseProvider
Definition: ClangTidyOptions.h:186
clang::tidy::FileOptionsProvider::FileOptionsProvider
FileOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions, const ClangTidyOptions &DefaultOptions, const ClangTidyOptions &OverrideOptions, llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > FS=nullptr)
Initializes the FileOptionsProvider instance.
Definition: ClangTidyOptions.cpp:284
clang::tidy::ClangTidyGlobalOptions::LineFilter
std::vector< FileFilter > LineFilter
Output warnings from certain line ranges of certain files only.
Definition: ClangTidyOptions.h:45
clang::tidy::FileOptionsBaseProvider::FS
llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > FS
Definition: ClangTidyOptions.h:235
llvm::yaml::MappingTraits< FileFilter >::validate
static StringRef validate(IO &io, FileFilter &File)
Definition: ClangTidyOptions.cpp:50
llvm::yaml::NOptionMap::Options
std::vector< ClangTidyOptions::StringPair > Options
Definition: ClangTidyOptions.cpp:81
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:304
clang::tidy::parseConfiguration
llvm::ErrorOr< ClangTidyOptions > parseConfiguration(StringRef Config)
Definition: ClangTidyOptions.cpp:379
FS
MockFS FS
Definition: ClangdLSPServerTests.cpp:66
Directory
llvm::StringRef Directory
Definition: Serialization.cpp:387
clang::tidy::FileOptionsBaseProvider::CachedOptions
llvm::StringMap< OptionsSource > CachedOptions
Definition: ClangTidyOptions.h:232
clang::tidy::configurationAsText
std::string configurationAsText(const ClangTidyOptions &Options)
Serializes configuration to a YAML-encoded string.
Definition: ClangTidyOptions.cpp:388
clang::tidy::FileOptionsBaseProvider::tryReadConfigFile
llvm::Optional< OptionsSource > tryReadConfigFile(llvm::StringRef Directory)
Try to read configuration files from Directory using registered ConfigHandlers.
Definition: ClangTidyOptions.cpp:325
Output
std::string Output
Definition: TraceTests.cpp:161
llvm::yaml::MappingTraits< FileFilter >::mapping
static void mapping(IO &IO, FileFilter &File)
Definition: ClangTidyOptions.cpp:46
clang::tidy::ClangTidyOptionsProvider::OptionsSourceTypeConfigCommandLineOption
static const char OptionsSourceTypeConfigCommandLineOption[]
Definition: ClangTidyOptions.h:142
clang::tidy::FileOptionsBaseProvider::FileOptionsBaseProvider
FileOptionsBaseProvider(const ClangTidyGlobalOptions &GlobalOptions, const ClangTidyOptions &DefaultOptions, const ClangTidyOptions &OverrideOptions, llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > FS=nullptr)
Definition: ClangTidyOptions.cpp:225
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::ClangTidyGlobalOptions
Global options.
Definition: ClangTidyOptions.h:42
Index
const SymbolIndex * Index
Definition: Dexp.cpp:95
clang::tidy::mergeCommaSeparatedLists
static void mergeCommaSeparatedLists(Optional< std::string > &Dest, const Optional< std::string > &Src)
Definition: ClangTidyOptions.cpp:135
clang::tidy::ClangTidyOptions::WarningsAsErrors
llvm::Optional< std::string > WarningsAsErrors
WarningsAsErrors filter.
Definition: ClangTidyOptions.h:69
clang::tidy::overrideValue
static void overrideValue(Optional< T > &Dest, const Optional< T > &Src)
Definition: ClangTidyOptions.cpp:142
clang::tidy::ClangTidyOptionsProvider::getOptions
ClangTidyOptions getOptions(llvm::StringRef FileName)
Returns options applying to a specific translation unit with the specified FileName.
Definition: ClangTidyOptions.cpp:178
clang::tidy::FileOptionsBaseProvider::ConfigFileHandlers
std::vector< ConfigFileHandler > ConfigFileHandlers
Configuration file handlers listed in the order of priority.
Definition: ClangTidyOptions.h:211
clang::tidy::FileOptionsBaseProvider::ConfigFileHandler
std::pair< std::string, std::function< llvm::ErrorOr< ClangTidyOptions > llvm::StringRef)> > ConfigFileHandler
Definition: ClangTidyOptions.h:192
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))
llvm::yaml::NOptionMap::denormalize
ClangTidyOptions::OptionMap denormalize(IO &)
Definition: ClangTidyOptions.cpp:75
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition: ApplyReplacements.h:27
clang::tidy::ClangTidyOptionsProvider::getRawOptions
virtual std::vector< OptionsSource > getRawOptions(llvm::StringRef FileName)=0
Returns an ordered vector of OptionsSources, in order of increasing priority.
clang::tidy::FileOptionsBaseProvider::OverrideOptions
ClangTidyOptions OverrideOptions
Definition: ClangTidyOptions.h:233
ClangTidyOptions.h
clang::tidy::ClangTidyOptions::mergeWith
ClangTidyOptions mergeWith(const ClangTidyOptions &Other, unsigned Order) const
Creates a new ClangTidyOptions instance combined from all fields of this instance overridden by the f...
Definition: ClangTidyOptions.cpp:147
FileName
PathRef FileName
Definition: CodeComplete.cpp:1043
clang::tidy::ClangTidyOptions::getDefaults
static ClangTidyOptions getDefaults()
These options are used for all settings that haven't been overridden by the OptionsProvider.
Definition: ClangTidyOptions.cpp:109
llvm::yaml::MappingTraits< ClangTidyOptions >::mapping
static void mapping(IO &IO, ClangTidyOptions &Options)
Definition: ClangTidyOptions.cpp:85
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:204
clang::tidy::ClangTidyOptions::ExtraArgs
llvm::Optional< ArgList > ExtraArgs
Add extra compilation arguments to the end of the list.
Definition: ClangTidyOptions.h:119
llvm::yaml::NOptionMap::NOptionMap
NOptionMap(IO &)
Definition: ClangTidyOptions.cpp:69
llvm::yaml::NOptionMap::NOptionMap
NOptionMap(IO &, const ClangTidyOptions::OptionMap &OptionMap)
Definition: ClangTidyOptions.cpp:70
yaml
Definition: ClangDocMain.cpp:92
Path
std::vector< HeaderHandle > Path
Definition: PreprocessorTracker.cpp:524