blob: 83f57e5a6bf8eb601d4f5037f45e3313fc9d6e7a [file] [log] [blame]
Alexander Kornienkodad4acb2014-05-22 16:07:11 +00001//===--- 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"
Alexander Kornienko1efc4252014-10-16 11:27:57 +000011#include "ClangTidyModuleRegistry.h"
Alexander Kornienkod53d2682014-09-04 14:23:36 +000012#include "clang/Basic/LLVM.h"
13#include "llvm/ADT/SmallString.h"
14#include "llvm/Support/Debug.h"
Chandler Carruth3cbd71c2015-01-14 11:24:38 +000015#include "llvm/Support/Errc.h"
Alexander Kornienkod53d2682014-09-04 14:23:36 +000016#include "llvm/Support/FileSystem.h"
17#include "llvm/Support/Path.h"
Alexander Kornienkodad4acb2014-05-22 16:07:11 +000018#include "llvm/Support/YAMLTraits.h"
Chandler Carruth3cbd71c2015-01-14 11:24:38 +000019#include "llvm/Support/raw_ostream.h"
Alexander Kornienkod53d2682014-09-04 14:23:36 +000020#include <utility>
21
22#define DEBUG_TYPE "clang-tidy-options"
Alexander Kornienkodad4acb2014-05-22 16:07:11 +000023
Alexander Kornienkoa4695222014-06-05 13:31:45 +000024using clang::tidy::ClangTidyOptions;
Alexander Kornienkodad4acb2014-05-22 16:07:11 +000025using clang::tidy::FileFilter;
Haojian Wu12e6b8f2016-04-27 09:15:01 +000026using OptionsSource = clang::tidy::ClangTidyOptionsProvider::OptionsSource;
Alexander Kornienkodad4acb2014-05-22 16:07:11 +000027
28LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter)
29LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter::LineRange)
Benjamin Kramer39e40cc2014-09-23 14:46:55 +000030LLVM_YAML_IS_SEQUENCE_VECTOR(ClangTidyOptions::StringPair)
Alexander Kornienko64956b52015-11-09 16:28:11 +000031LLVM_YAML_IS_SEQUENCE_VECTOR(std::string)
Alexander Kornienkodad4acb2014-05-22 16:07:11 +000032
33namespace llvm {
34namespace yaml {
35
36// Map std::pair<int, int> to a JSON array of size 2.
37template <> struct SequenceTraits<FileFilter::LineRange> {
38 static size_t size(IO &IO, FileFilter::LineRange &Range) {
39 return Range.first == 0 ? 0 : Range.second == 0 ? 1 : 2;
40 }
41 static unsigned &element(IO &IO, FileFilter::LineRange &Range, size_t Index) {
42 if (Index > 1)
43 IO.setError("Too many elements in line range.");
44 return Index == 0 ? Range.first : Range.second;
45 }
46};
47
48template <> struct MappingTraits<FileFilter> {
49 static void mapping(IO &IO, FileFilter &File) {
50 IO.mapRequired("name", File.Name);
51 IO.mapOptional("lines", File.LineRanges);
52 }
53 static StringRef validate(IO &io, FileFilter &File) {
54 if (File.Name.empty())
55 return "No file name specified";
56 for (const FileFilter::LineRange &Range : File.LineRanges) {
57 if (Range.first <= 0 || Range.second <= 0)
58 return "Invalid line range";
59 }
60 return StringRef();
61 }
62};
63
Alexander Kornienko6e0cbc82014-09-12 08:53:36 +000064template <> struct MappingTraits<ClangTidyOptions::StringPair> {
65 static void mapping(IO &IO, ClangTidyOptions::StringPair &KeyValue) {
66 IO.mapRequired("key", KeyValue.first);
67 IO.mapRequired("value", KeyValue.second);
68 }
69};
70
71struct NOptionMap {
72 NOptionMap(IO &) {}
73 NOptionMap(IO &, const ClangTidyOptions::OptionMap &OptionMap)
74 : Options(OptionMap.begin(), OptionMap.end()) {}
75 ClangTidyOptions::OptionMap denormalize(IO &) {
76 ClangTidyOptions::OptionMap Map;
77 for (const auto &KeyValue : Options)
78 Map[KeyValue.first] = KeyValue.second;
79 return Map;
80 }
81 std::vector<ClangTidyOptions::StringPair> Options;
82};
83
Alexander Kornienkoa4695222014-06-05 13:31:45 +000084template <> struct MappingTraits<ClangTidyOptions> {
85 static void mapping(IO &IO, ClangTidyOptions &Options) {
Alexander Kornienko6e0cbc82014-09-12 08:53:36 +000086 MappingNormalization<NOptionMap, ClangTidyOptions::OptionMap> NOpts(
87 IO, Options.CheckOptions);
Alexander Kornienkoa4695222014-06-05 13:31:45 +000088 IO.mapOptional("Checks", Options.Checks);
Jonathan Roelofsd60388a2016-01-13 17:36:41 +000089 IO.mapOptional("WarningsAsErrors", Options.WarningsAsErrors);
Alexander Kornienkoa4695222014-06-05 13:31:45 +000090 IO.mapOptional("HeaderFilterRegex", Options.HeaderFilterRegex);
91 IO.mapOptional("AnalyzeTemporaryDtors", Options.AnalyzeTemporaryDtors);
Alexander Kornienko25613202017-04-06 13:41:29 +000092 IO.mapOptional("FormatStyle", Options.FormatStyle);
Alexander Kornienkoe9951542014-09-24 18:36:03 +000093 IO.mapOptional("User", Options.User);
Alexander Kornienko6e0cbc82014-09-12 08:53:36 +000094 IO.mapOptional("CheckOptions", NOpts->Options);
Alexander Kornienko64956b52015-11-09 16:28:11 +000095 IO.mapOptional("ExtraArgs", Options.ExtraArgs);
96 IO.mapOptional("ExtraArgsBefore", Options.ExtraArgsBefore);
Alexander Kornienkoa4695222014-06-05 13:31:45 +000097 }
98};
99
Alexander Kornienkodad4acb2014-05-22 16:07:11 +0000100} // namespace yaml
101} // namespace llvm
102
103namespace clang {
104namespace tidy {
105
Alexander Kornienko1efc4252014-10-16 11:27:57 +0000106ClangTidyOptions ClangTidyOptions::getDefaults() {
107 ClangTidyOptions Options;
108 Options.Checks = "";
Jonathan Roelofsd60388a2016-01-13 17:36:41 +0000109 Options.WarningsAsErrors = "";
Alexander Kornienko1efc4252014-10-16 11:27:57 +0000110 Options.HeaderFilterRegex = "";
Alexander Kornienko37f7abe2014-10-28 22:16:13 +0000111 Options.SystemHeaders = false;
Alexander Kornienko1efc4252014-10-16 11:27:57 +0000112 Options.AnalyzeTemporaryDtors = false;
Alexander Kornienko25613202017-04-06 13:41:29 +0000113 Options.FormatStyle = "none";
Alexander Kornienko1efc4252014-10-16 11:27:57 +0000114 Options.User = llvm::None;
115 for (ClangTidyModuleRegistry::iterator I = ClangTidyModuleRegistry::begin(),
116 E = ClangTidyModuleRegistry::end();
117 I != E; ++I)
118 Options = Options.mergeWith(I->instantiate()->getModuleOptions());
119 return Options;
120}
121
Alexander Kornienkobb560522016-08-23 14:48:29 +0000122template <typename T>
123static void mergeVectors(Optional<T> &Dest, const Optional<T> &Src) {
124 if (Src) {
125 if (Dest)
126 Dest->insert(Dest->end(), Src->begin(), Src->end());
127 else
128 Dest = Src;
129 }
130}
131
132static void mergeCommaSeparatedLists(Optional<std::string> &Dest,
133 const Optional<std::string> &Src) {
134 if (Src)
135 Dest = (Dest && !Dest->empty() ? *Dest + "," : "") + *Src;
136}
137
138template <typename T>
139static void overrideValue(Optional<T> &Dest, const Optional<T> &Src) {
140 if (Src)
141 Dest = Src;
142}
143
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000144ClangTidyOptions
145ClangTidyOptions::mergeWith(const ClangTidyOptions &Other) const {
146 ClangTidyOptions Result = *this;
147
Alexander Kornienkobb560522016-08-23 14:48:29 +0000148 mergeCommaSeparatedLists(Result.Checks, Other.Checks);
149 mergeCommaSeparatedLists(Result.WarningsAsErrors, Other.WarningsAsErrors);
150 overrideValue(Result.HeaderFilterRegex, Other.HeaderFilterRegex);
151 overrideValue(Result.SystemHeaders, Other.SystemHeaders);
152 overrideValue(Result.AnalyzeTemporaryDtors, Other.AnalyzeTemporaryDtors);
Alexander Kornienko25613202017-04-06 13:41:29 +0000153 overrideValue(Result.FormatStyle, Other.FormatStyle);
Alexander Kornienkobb560522016-08-23 14:48:29 +0000154 overrideValue(Result.User, Other.User);
155 mergeVectors(Result.ExtraArgs, Other.ExtraArgs);
156 mergeVectors(Result.ExtraArgsBefore, Other.ExtraArgsBefore);
Alexander Kornienko6e0cbc82014-09-12 08:53:36 +0000157
158 for (const auto &KeyValue : Other.CheckOptions)
159 Result.CheckOptions[KeyValue.first] = KeyValue.second;
160
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000161 return Result;
162}
163
Haojian Wu12e6b8f2016-04-27 09:15:01 +0000164const char ClangTidyOptionsProvider::OptionsSourceTypeDefaultBinary[] =
165 "clang-tidy binary";
166const char ClangTidyOptionsProvider::OptionsSourceTypeCheckCommandLineOption[] =
167 "command-line option '-checks'";
168const char
169 ClangTidyOptionsProvider::OptionsSourceTypeConfigCommandLineOption[] =
170 "command-line option '-config'";
171
172ClangTidyOptions
173ClangTidyOptionsProvider::getOptions(llvm::StringRef FileName) {
174 ClangTidyOptions Result;
175 for (const auto &Source : getRawOptions(FileName))
176 Result = Result.mergeWith(Source.first);
177 return Result;
178}
179
180std::vector<OptionsSource>
181DefaultOptionsProvider::getRawOptions(llvm::StringRef FileName) {
182 std::vector<OptionsSource> Result;
183 Result.emplace_back(DefaultOptions, OptionsSourceTypeDefaultBinary);
184 return Result;
185}
186
187ConfigOptionsProvider::ConfigOptionsProvider(
188 const ClangTidyGlobalOptions &GlobalOptions,
189 const ClangTidyOptions &DefaultOptions,
190 const ClangTidyOptions &ConfigOptions,
191 const ClangTidyOptions &OverrideOptions)
192 : DefaultOptionsProvider(GlobalOptions, DefaultOptions),
193 ConfigOptions(ConfigOptions), OverrideOptions(OverrideOptions) {}
194
195std::vector<OptionsSource>
196ConfigOptionsProvider::getRawOptions(llvm::StringRef FileName) {
197 std::vector<OptionsSource> RawOptions =
198 DefaultOptionsProvider::getRawOptions(FileName);
199 RawOptions.emplace_back(ConfigOptions,
200 OptionsSourceTypeConfigCommandLineOption);
201 RawOptions.emplace_back(OverrideOptions,
202 OptionsSourceTypeCheckCommandLineOption);
203 return RawOptions;
204}
205
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000206FileOptionsProvider::FileOptionsProvider(
207 const ClangTidyGlobalOptions &GlobalOptions,
Alexander Kornienkoe9951542014-09-24 18:36:03 +0000208 const ClangTidyOptions &DefaultOptions,
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000209 const ClangTidyOptions &OverrideOptions)
Alexander Kornienkoe9951542014-09-24 18:36:03 +0000210 : DefaultOptionsProvider(GlobalOptions, DefaultOptions),
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000211 OverrideOptions(OverrideOptions) {
Alexander Kornienko4f6b0662014-10-20 12:29:15 +0000212 ConfigHandlers.emplace_back(".clang-tidy", parseConfiguration);
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000213}
214
Alexander Kornienko4f6b0662014-10-20 12:29:15 +0000215FileOptionsProvider::FileOptionsProvider(
216 const ClangTidyGlobalOptions &GlobalOptions,
217 const ClangTidyOptions &DefaultOptions,
218 const ClangTidyOptions &OverrideOptions,
219 const FileOptionsProvider::ConfigFileHandlers &ConfigHandlers)
220 : DefaultOptionsProvider(GlobalOptions, DefaultOptions),
Mandeep Singh Grang7c7ea7d2016-11-08 07:50:19 +0000221 OverrideOptions(OverrideOptions), ConfigHandlers(ConfigHandlers) {}
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000222
223// FIXME: This method has some common logic with clang::format::getStyle().
224// Consider pulling out common bits to a findParentFileWithName function or
225// similar.
Haojian Wu12e6b8f2016-04-27 09:15:01 +0000226std::vector<OptionsSource>
227FileOptionsProvider::getRawOptions(StringRef FileName) {
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000228 DEBUG(llvm::dbgs() << "Getting options for file " << FileName << "...\n");
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000229
Haojian Wu12e6b8f2016-04-27 09:15:01 +0000230 std::vector<OptionsSource> RawOptions =
231 DefaultOptionsProvider::getRawOptions(FileName);
232 OptionsSource CommandLineOptions(OverrideOptions,
233 OptionsSourceTypeCheckCommandLineOption);
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000234 // Look for a suitable configuration file in all parent directories of the
235 // file. Start with the immediate parent directory and move up.
236 StringRef Path = llvm::sys::path::parent_path(FileName);
Haojian Wu12e6b8f2016-04-27 09:15:01 +0000237 for (StringRef CurrentPath = Path; !CurrentPath.empty();
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000238 CurrentPath = llvm::sys::path::parent_path(CurrentPath)) {
Haojian Wu12e6b8f2016-04-27 09:15:01 +0000239 llvm::Optional<OptionsSource> Result;
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000240
241 auto Iter = CachedOptions.find(CurrentPath);
242 if (Iter != CachedOptions.end())
243 Result = Iter->second;
244
245 if (!Result)
Haojian Wu12e6b8f2016-04-27 09:15:01 +0000246 Result = tryReadConfigFile(CurrentPath);
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000247
248 if (Result) {
249 // Store cached value for all intermediate directories.
250 while (Path != CurrentPath) {
251 DEBUG(llvm::dbgs() << "Caching configuration for path " << Path
252 << ".\n");
David Blaikie8e6cf9e2014-11-19 03:05:07 +0000253 CachedOptions[Path] = *Result;
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000254 Path = llvm::sys::path::parent_path(Path);
255 }
Haojian Wu12e6b8f2016-04-27 09:15:01 +0000256 CachedOptions[Path] = *Result;
257
258 RawOptions.push_back(*Result);
259 break;
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000260 }
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000261 }
Haojian Wu12e6b8f2016-04-27 09:15:01 +0000262 RawOptions.push_back(CommandLineOptions);
263 return RawOptions;
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000264}
265
Haojian Wu12e6b8f2016-04-27 09:15:01 +0000266llvm::Optional<OptionsSource>
267FileOptionsProvider::tryReadConfigFile(StringRef Directory) {
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000268 assert(!Directory.empty());
269
Alexander Kornienko4f6b0662014-10-20 12:29:15 +0000270 if (!llvm::sys::fs::is_directory(Directory)) {
271 llvm::errs() << "Error reading configuration from " << Directory
272 << ": directory doesn't exist.\n";
273 return llvm::None;
274 }
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000275
Alexander Kornienko4f6b0662014-10-20 12:29:15 +0000276 for (const ConfigFileHandler &ConfigHandler : ConfigHandlers) {
277 SmallString<128> ConfigFile(Directory);
278 llvm::sys::path::append(ConfigFile, ConfigHandler.first);
279 DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000280
Alexander Kornienko4f6b0662014-10-20 12:29:15 +0000281 bool IsFile = false;
282 // Ignore errors from is_regular_file: we only need to know if we can read
283 // the file or not.
284 llvm::sys::fs::is_regular_file(Twine(ConfigFile), IsFile);
285 if (!IsFile)
286 continue;
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000287
Alexander Kornienko4f6b0662014-10-20 12:29:15 +0000288 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
289 llvm::MemoryBuffer::getFile(ConfigFile.c_str());
290 if (std::error_code EC = Text.getError()) {
291 llvm::errs() << "Can't read " << ConfigFile << ": " << EC.message()
292 << "\n";
293 continue;
294 }
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000295
Alexander Kornienko4f6b0662014-10-20 12:29:15 +0000296 // Skip empty files, e.g. files opened for writing via shell output
297 // redirection.
298 if ((*Text)->getBuffer().empty())
299 continue;
300 llvm::ErrorOr<ClangTidyOptions> ParsedOptions =
301 ConfigHandler.second((*Text)->getBuffer());
302 if (!ParsedOptions) {
Alexander Kornienkoddf97672014-11-04 15:25:22 +0000303 if (ParsedOptions.getError())
304 llvm::errs() << "Error parsing " << ConfigFile << ": "
305 << ParsedOptions.getError().message() << "\n";
Alexander Kornienko4f6b0662014-10-20 12:29:15 +0000306 continue;
307 }
Haojian Wu12e6b8f2016-04-27 09:15:01 +0000308 return OptionsSource(*ParsedOptions, ConfigFile.c_str());
Alexander Kornienkoe9951542014-09-24 18:36:03 +0000309 }
Alexander Kornienko4f6b0662014-10-20 12:29:15 +0000310 return llvm::None;
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000311}
312
Alexander Kornienkodad4acb2014-05-22 16:07:11 +0000313/// \brief Parses -line-filter option and stores it to the \c Options.
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000314std::error_code parseLineFilter(StringRef LineFilter,
Rafael Espindola15c57842014-06-12 13:32:11 +0000315 clang::tidy::ClangTidyGlobalOptions &Options) {
Alexander Kornienkodad4acb2014-05-22 16:07:11 +0000316 llvm::yaml::Input Input(LineFilter);
317 Input >> Options.LineFilter;
318 return Input.error();
319}
320
Alexander Kornienkoe9951542014-09-24 18:36:03 +0000321llvm::ErrorOr<ClangTidyOptions> parseConfiguration(StringRef Config) {
Alexander Kornienkoa4695222014-06-05 13:31:45 +0000322 llvm::yaml::Input Input(Config);
Alexander Kornienkoe9951542014-09-24 18:36:03 +0000323 ClangTidyOptions Options;
Alexander Kornienkoa4695222014-06-05 13:31:45 +0000324 Input >> Options;
Alexander Kornienkoe9951542014-09-24 18:36:03 +0000325 if (Input.error())
326 return Input.error();
327 return Options;
Alexander Kornienkoa4695222014-06-05 13:31:45 +0000328}
329
Alexander Kornienkod53d2682014-09-04 14:23:36 +0000330std::string configurationAsText(const ClangTidyOptions &Options) {
331 std::string Text;
332 llvm::raw_string_ostream Stream(Text);
333 llvm::yaml::Output Output(Stream);
334 // We use the same mapping method for input and output, so we need a non-const
335 // reference here.
336 ClangTidyOptions NonConstValue = Options;
337 Output << NonConstValue;
338 return Stream.str();
339}
340
Alexander Kornienkodad4acb2014-05-22 16:07:11 +0000341} // namespace tidy
342} // namespace clang