LCOV - code coverage report
Current view: top level - clang/tools/extra/clang-tidy - ClangTidyOptions.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 4 7 57.1 %
Date: 2017-09-14 15:23:50 Functions: 3 7 42.9 %
Legend: Lines: hit not hit

          Line data    Source code
       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          12 : 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.
      41         557 : struct ClangTidyGlobalOptions {
      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.
      49       34760 : struct ClangTidyOptions {
      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.
      56             :   static ClangTidyOptions getDefaults();
      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.
     102             :   OptionMap CheckOptions;
     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.
     114             : class ClangTidyOptionsProvider {
     115             : public:
     116             :   static const char OptionsSourceTypeDefaultBinary[];
     117             :   static const char OptionsSourceTypeCheckCommandLineOption[];
     118             :   static const char OptionsSourceTypeConfigCommandLineOption[];
     119             : 
     120             :   virtual ~ClangTidyOptionsProvider() {}
     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.
     147           0 : class DefaultOptionsProvider : public ClangTidyOptionsProvider {
     148             : public:
     149             :   DefaultOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions,
     150             :                          const ClangTidyOptions &Options)
     151         274 :       : GlobalOptions(GlobalOptions), DefaultOptions(Options) {}
     152           0 :   const ClangTidyGlobalOptions &getGlobalOptions() override {
     153           0 :     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.
     164             : class ConfigOptionsProvider : public DefaultOptionsProvider {
     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.
     185             : class FileOptionsProvider : public DefaultOptionsProvider {
     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)>>
     191             :       ConfigFileHandler;
     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,
     224             :                       const ClangTidyOptions &OverrideOptions);
     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,
     245             :                       const ClangTidyOptions &OverrideOptions,
     246             :                       const ConfigFileHandlers &ConfigHandlers);
     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;
     256             :   ClangTidyOptions OverrideOptions;
     257             :   ConfigFileHandlers ConfigHandlers;
     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

Generated by: LCOV version 1.13