clang-tools  5.0.0
ClangTidyOptions.h
Go to the documentation of this file.
1 //===--- ClangTidyOptions.h - 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 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYOPTIONS_H
11 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYOPTIONS_H
12 
13 #include "llvm/ADT/Optional.h"
14 #include "llvm/ADT/StringMap.h"
15 #include "llvm/ADT/StringRef.h"
16 #include "llvm/Support/ErrorOr.h"
17 #include <functional>
18 #include <map>
19 #include <string>
20 #include <system_error>
21 #include <utility>
22 #include <vector>
23 
24 namespace clang {
25 namespace tidy {
26 
27 /// \brief Contains a list of line ranges in a single file.
28 struct FileFilter {
29  /// \brief File name.
30  std::string Name;
31 
32  /// \brief LineRange is a pair<start, end> (inclusive).
33  typedef std::pair<unsigned, unsigned> LineRange;
34 
35  /// \brief A list of line ranges in this file, for which we show warnings.
36  std::vector<LineRange> LineRanges;
37 };
38 
39 /// \brief Global options. These options are neither stored nor read from
40 /// configuration files.
42  /// \brief Output warnings from certain line ranges of certain files only.
43  /// If empty, no warnings will be filtered.
44  std::vector<FileFilter> LineFilter;
45 };
46 
47 /// \brief Contains options for clang-tidy. These options may be read from
48 /// configuration files, and may be different for different translation units.
50  /// \brief These options are used for all settings that haven't been
51  /// overridden by the \c OptionsProvider.
52  ///
53  /// Allow no checks and no headers by default. This method initializes
54  /// check-specific options by calling \c ClangTidyModule::getModuleOptions()
55  /// of each registered \c ClangTidyModule.
57 
58  /// \brief Creates a new \c ClangTidyOptions instance combined from all fields
59  /// of this instance overridden by the fields of \p Other that have a value.
60  ClangTidyOptions mergeWith(const ClangTidyOptions &Other) const;
61 
62  /// \brief Checks filter.
63  llvm::Optional<std::string> Checks;
64 
65  /// \brief WarningsAsErrors filter.
66  llvm::Optional<std::string> WarningsAsErrors;
67 
68  /// \brief Output warnings from headers matching this filter. Warnings from
69  /// main files will always be displayed.
70  llvm::Optional<std::string> HeaderFilterRegex;
71 
72  /// \brief Output warnings from system headers matching \c HeaderFilterRegex.
73  llvm::Optional<bool> SystemHeaders;
74 
75  /// \brief Turns on temporary destructor-based analysis.
76  llvm::Optional<bool> AnalyzeTemporaryDtors;
77 
78  /// \brief Format code around applied fixes with clang-format using this
79  /// style.
80  ///
81  /// Can be one of:
82  /// * 'none' - don't format code around applied fixes;
83  /// * 'llvm', 'google', 'mozilla' or other predefined clang-format style
84  /// names;
85  /// * 'file' - use the .clang-format file in the closest parent directory of
86  /// each source file;
87  /// * '{inline-formatting-style-in-yaml-format}'.
88  ///
89  /// See clang-format documentation for more about configuring format style.
90  llvm::Optional<std::string> FormatStyle;
91 
92  /// \brief Specifies the name or e-mail of the user running clang-tidy.
93  ///
94  /// This option is used, for example, to place the correct user name in TODO()
95  /// comments in the relevant check.
96  llvm::Optional<std::string> User;
97 
98  typedef std::pair<std::string, std::string> StringPair;
99  typedef std::map<std::string, std::string> OptionMap;
100 
101  /// \brief Key-value mapping used to store check-specific options.
103 
104  typedef std::vector<std::string> ArgList;
105 
106  /// \brief Add extra compilation arguments to the end of the list.
107  llvm::Optional<ArgList> ExtraArgs;
108 
109  /// \brief Add extra compilation arguments to the start of the list.
110  llvm::Optional<ArgList> ExtraArgsBefore;
111 };
112 
113 /// \brief Abstract interface for retrieving various ClangTidy options.
115 public:
116  static const char OptionsSourceTypeDefaultBinary[];
119 
121 
122  /// \brief Returns global options, which are independent of the file.
123  virtual const ClangTidyGlobalOptions &getGlobalOptions() = 0;
124 
125  /// \brief ClangTidyOptions and its source.
126  //
127  /// clang-tidy has 3 types of the sources in order of increasing priority:
128  /// * clang-tidy binary.
129  /// * '-config' commandline option or a specific configuration file. If the
130  /// commandline option is specified, clang-tidy will ignore the
131  /// configuration file.
132  /// * '-checks' commandline option.
133  typedef std::pair<ClangTidyOptions, std::string> OptionsSource;
134 
135  /// \brief Returns an ordered vector of OptionsSources, in order of increasing
136  /// priority.
137  virtual std::vector<OptionsSource>
138  getRawOptions(llvm::StringRef FileName) = 0;
139 
140  /// \brief Returns options applying to a specific translation unit with the
141  /// specified \p FileName.
142  ClangTidyOptions getOptions(llvm::StringRef FileName);
143 };
144 
145 /// \brief Implementation of the \c ClangTidyOptionsProvider interface, which
146 /// returns the same options for all files.
148 public:
150  const ClangTidyOptions &Options)
151  : GlobalOptions(GlobalOptions), DefaultOptions(Options) {}
153  return GlobalOptions;
154  }
155  std::vector<OptionsSource> getRawOptions(llvm::StringRef FileName) override;
156 
157 private:
158  ClangTidyGlobalOptions GlobalOptions;
159  ClangTidyOptions DefaultOptions;
160 };
161 
162 /// \brief Implementation of ClangTidyOptions interface, which is used for
163 /// '-config' command-line option.
165 public:
166  ConfigOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions,
167  const ClangTidyOptions &DefaultOptions,
168  const ClangTidyOptions &ConfigOptions,
169  const ClangTidyOptions &OverrideOptions);
170  std::vector<OptionsSource> getRawOptions(llvm::StringRef FileName) override;
171 
172 private:
173  ClangTidyOptions ConfigOptions;
174  ClangTidyOptions OverrideOptions;
175 };
176 
177 /// \brief Implementation of the \c ClangTidyOptionsProvider interface, which
178 /// tries to find a configuration file in the closest parent directory of each
179 /// source file.
180 ///
181 /// By default, files named ".clang-tidy" will be considered, and the
182 /// \c clang::tidy::parseConfiguration function will be used for parsing, but a
183 /// custom set of configuration file names and parsing functions can be
184 /// specified using the appropriate constructor.
186 public:
187  // \brief A pair of configuration file base name and a function parsing
188  // configuration from text in the corresponding format.
189  typedef std::pair<std::string, std::function<llvm::ErrorOr<ClangTidyOptions>(
190  llvm::StringRef)>>
192 
193  /// \brief Configuration file handlers listed in the order of priority.
194  ///
195  /// Custom configuration file formats can be supported by constructing the
196  /// list of handlers and passing it to the appropriate \c FileOptionsProvider
197  /// constructor. E.g. initialization of a \c FileOptionsProvider with support
198  /// of a custom configuration file format for files named ".my-tidy-config"
199  /// could look similar to this:
200  /// \code
201  /// FileOptionsProvider::ConfigFileHandlers ConfigHandlers;
202  /// ConfigHandlers.emplace_back(".my-tidy-config", parseMyConfigFormat);
203  /// ConfigHandlers.emplace_back(".clang-tidy", parseConfiguration);
204  /// return llvm::make_unique<FileOptionsProvider>(
205  /// GlobalOptions, DefaultOptions, OverrideOptions, ConfigHandlers);
206  /// \endcode
207  ///
208  /// With the order of handlers shown above, the ".my-tidy-config" file would
209  /// take precedence over ".clang-tidy" if both reside in the same directory.
210  typedef std::vector<ConfigFileHandler> ConfigFileHandlers;
211 
212  /// \brief Initializes the \c FileOptionsProvider instance.
213  ///
214  /// \param GlobalOptions are just stored and returned to the caller of
215  /// \c getGlobalOptions.
216  ///
217  /// \param DefaultOptions are used for all settings not specified in a
218  /// configuration file.
219  ///
220  /// If any of the \param OverrideOptions fields are set, they will override
221  /// whatever options are read from the configuration file.
222  FileOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions,
223  const ClangTidyOptions &DefaultOptions,
225 
226  /// \brief Initializes the \c FileOptionsProvider instance with a custom set
227  /// of configuration file handlers.
228  ///
229  /// \param GlobalOptions are just stored and returned to the caller of
230  /// \c getGlobalOptions.
231  ///
232  /// \param DefaultOptions are used for all settings not specified in a
233  /// configuration file.
234  ///
235  /// If any of the \param OverrideOptions fields are set, they will override
236  /// whatever options are read from the configuration file.
237  ///
238  /// \param ConfigHandlers specifies a custom set of configuration file
239  /// handlers. Each handler is a pair of configuration file name and a function
240  /// that can parse configuration from this file type. The configuration files
241  /// in each directory are searched for in the order of appearance in
242  /// \p ConfigHandlers.
243  FileOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions,
244  const ClangTidyOptions &DefaultOptions,
247 
248  std::vector<OptionsSource> getRawOptions(llvm::StringRef FileName) override;
249 
250 protected:
251  /// \brief Try to read configuration files from \p Directory using registered
252  /// \c ConfigHandlers.
253  llvm::Optional<OptionsSource> tryReadConfigFile(llvm::StringRef Directory);
254 
255  llvm::StringMap<OptionsSource> CachedOptions;
258 };
259 
260 /// \brief Parses LineFilter from JSON and stores it to the \p Options.
261 std::error_code parseLineFilter(llvm::StringRef LineFilter,
262  ClangTidyGlobalOptions &Options);
263 
264 /// \brief Parses configuration from JSON and returns \c ClangTidyOptions or an
265 /// error.
266 llvm::ErrorOr<ClangTidyOptions> parseConfiguration(llvm::StringRef Config);
267 
268 /// \brief Serializes configuration to a YAML-encoded string.
269 std::string configurationAsText(const ClangTidyOptions &Options);
270 
271 } // end namespace tidy
272 } // end namespace clang
273 
274 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYOPTIONS_H
llvm::Optional< std::string > Checks
Checks filter.
std::vector< OptionsSource > getRawOptions(llvm::StringRef FileName) override
Returns an ordered vector of OptionsSources, in order of increasing priority.
llvm::Optional< ArgList > ExtraArgs
Add extra compilation arguments to the end of the list.
Implementation of the ClangTidyOptionsProvider interface, which tries to find a configuration file in...
llvm::Optional< std::string > User
Specifies the name or e-mail of the user running clang-tidy.
std::vector< std::string > ArgList
std::pair< std::string, std::string > StringPair
Implementation of ClangTidyOptions interface, which is used for '-config' command-line option...
virtual std::vector< OptionsSource > getRawOptions(llvm::StringRef FileName)=0
Returns an ordered vector of OptionsSources, in order of increasing priority.
llvm::Optional< std::string > HeaderFilterRegex
Output warnings from headers matching this filter.
static const char OptionsSourceTypeCheckCommandLineOption[]
Contains options for clang-tidy.
static const char OptionsSourceTypeConfigCommandLineOption[]
std::vector< OptionsSource > getRawOptions(llvm::StringRef FileName) override
Returns an ordered vector of OptionsSources, in order of increasing priority.
std::error_code parseLineFilter(StringRef LineFilter, clang::tidy::ClangTidyGlobalOptions &Options)
Parses -line-filter option and stores it to the Options.
llvm::ErrorOr< ClangTidyOptions > parseConfiguration(StringRef Config)
OptionMap CheckOptions
Key-value mapping used to store check-specific options.
llvm::Optional< bool > SystemHeaders
Output warnings from system headers matching HeaderFilterRegex.
llvm::Optional< ArgList > ExtraArgsBefore
Add extra compilation arguments to the start of the list.
llvm::Optional< std::string > FormatStyle
Format code around applied fixes with clang-format using this style.
static cl::opt< std::string > Directory(cl::Positional, cl::Required, cl::desc("<Search Root Directory>"))
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))
std::pair< unsigned, unsigned > LineRange
LineRange is a pair<start, end> (inclusive).
std::vector< OptionsSource > getRawOptions(llvm::StringRef FileName) override
Returns an ordered vector of OptionsSources, in order of increasing priority.
std::string configurationAsText(const ClangTidyOptions &Options)
Serializes configuration to a YAML-encoded string.
llvm::StringMap< OptionsSource > CachedOptions
std::map< std::string, std::string > OptionMap
std::vector< FileFilter > LineFilter
Output warnings from certain line ranges of certain files only.
ClangTidyOptions mergeWith(const ClangTidyOptions &Other) const
Creates a new ClangTidyOptions instance combined from all fields of this instance overridden by the f...
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))
std::pair< std::string, std::function< llvm::ErrorOr< ClangTidyOptions > llvm::StringRef)> > ConfigFileHandler
llvm::Optional< std::string > WarningsAsErrors
WarningsAsErrors filter.
virtual const ClangTidyGlobalOptions & getGlobalOptions()=0
Returns global options, which are independent of the file.
std::vector< ConfigFileHandler > ConfigFileHandlers
Configuration file handlers listed in the order of priority.
Contains a list of line ranges in a single file.
llvm::Optional< bool > AnalyzeTemporaryDtors
Turns on temporary destructor-based analysis.
DefaultOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions, const ClangTidyOptions &Options)
std::pair< ClangTidyOptions, std::string > OptionsSource
ClangTidyOptions and its source.
std::vector< LineRange > LineRanges
A list of line ranges in this file, for which we show warnings.
static ClangTidyOptions getDefaults()
These options are used for all settings that haven't been overridden by the OptionsProvider.
ClangTidyOptions getOptions(llvm::StringRef FileName)
Returns options applying to a specific translation unit with the specified FileName.
Abstract interface for retrieving various ClangTidy options.
const ClangTidyGlobalOptions & getGlobalOptions() override
Returns global options, which are independent of the file.
FileOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions, const ClangTidyOptions &DefaultOptions, const ClangTidyOptions &OverrideOptions)
Initializes the FileOptionsProvider instance.
std::string Name
File name.
llvm::Optional< OptionsSource > tryReadConfigFile(llvm::StringRef Directory)
Try to read configuration files from Directory using registered ConfigHandlers.
ConfigOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions, const ClangTidyOptions &DefaultOptions, const ClangTidyOptions &ConfigOptions, const ClangTidyOptions &OverrideOptions)
Implementation of the ClangTidyOptionsProvider interface, which returns the same options for all file...
static const char OptionsSourceTypeDefaultBinary[]