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

Generated by: LCOV version 1.13