[clang-tidy] Remove OptionError

[njames93]

Summary

The interface served a purpose, but since the ability to emit diagnostics when parsing configuration was added, its become mostly redundant. Emitting the diagnostic and removing the boilerplate is much cleaner.

[aaron.ballman]

LGTM, nice cleanup!

clang-tools-extra/clang-tidy/ClangTidyCheck.h

 //===--- ClangTidyCheck.h - clang-tidy --------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYCHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYCHECK_H
 
 #include "ClangTidyDiagnosticConsumer.h"
 #include "ClangTidyOptions.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/Diagnostic.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/Support/Error.h"
 #include <type_traits>
 #include <utility>
 #include <vector>
 
 namespace clang {
 
 class CompilerInstance;
 class SourceManager;
 
 namespace tidy {
 
 /// This class should be specialized by any enum type that needs to be converted
 /// to and from an \ref llvm::StringRef.
 template <class T> struct OptionEnumMapping {
   // Specializations of this struct must implement this function.
   static ArrayRef<std::pair<T, StringRef>> getEnumMapping() = delete;
 };
 
-template <typename T> class OptionError : public llvm::ErrorInfo<T> {
-  std::error_code convertToErrorCode() const override {
-    return llvm::inconvertibleErrorCode();
-  }
-
-public:
-  void log(raw_ostream &OS) const override { OS << this->message(); }
-};
-
-class MissingOptionError : public OptionError<MissingOptionError> {
-public:
-  explicit MissingOptionError(std::string OptionName)
-      : OptionName(OptionName) {}
-
-  std::string message() const override;
-  static char ID;
-private:
-  const std::string OptionName;
-};
-
-class UnparseableEnumOptionError
-    : public OptionError<UnparseableEnumOptionError> {
-public:
-  explicit UnparseableEnumOptionError(std::string LookupName,
-                                      std::string LookupValue)
-      : LookupName(LookupName), LookupValue(LookupValue) {}
-  explicit UnparseableEnumOptionError(std::string LookupName,
-                                      std::string LookupValue,
-                                      std::string SuggestedValue)
-      : LookupName(LookupName), LookupValue(LookupValue),
-        SuggestedValue(SuggestedValue) {}
-
-  std::string message() const override;
-  static char ID;
-
-private:
-  const std::string LookupName;
-  const std::string LookupValue;
-  const llvm::Optional<std::string> SuggestedValue;
-};
-
-class UnparseableIntegerOptionError
-    : public OptionError<UnparseableIntegerOptionError> {
-public:
-  explicit UnparseableIntegerOptionError(std::string LookupName,
-                                         std::string LookupValue,
-                                         bool IsBoolean = false)
-      : LookupName(LookupName), LookupValue(LookupValue), IsBoolean(IsBoolean) {
-  }
-
-  std::string message() const override;
-  static char ID;
-
-private:
-  const std::string LookupName;
-  const std::string LookupValue;
-  const bool IsBoolean;
-};
-
 /// Base class for all clang-tidy checks.
 ///
 /// To implement a ``ClangTidyCheck``, write a subclass and override some of the
 /// base class's methods. E.g. to implement a check that validates namespace
 /// declarations, override ``registerMatchers``:
 ///
 /// ~~~{.cpp}
 /// void registerMatchers(ast_matchers::MatchFinder *Finder) override {
public:
   virtual void storeOptions(ClangTidyOptions::OptionMap &Options) {}
 
   /// Provides access to the ``ClangTidyCheck`` options via check-local
   /// names.
   ///
   /// Methods of this class prepend ``CheckName + "."`` to translate check-local
   /// option names to global option names.
   class OptionsView {
+    void diagnoseBadIntegerOption(const Twine &Lookup,
+                                  StringRef Unparsed) const;
+    void diagnoseBadBooleanOption(const Twine &Lookup,
+                                  StringRef Unparsed) const;
+    void diagnoseBadEnumOption(const Twine &Lookup, StringRef Unparsed,
+                               StringRef Suggestion = StringRef()) const;
+
   public:
     /// Initializes the instance using \p CheckName + "." as a prefix.
     OptionsView(StringRef CheckName,
                 const ClangTidyOptions::OptionMap &CheckOptions,
                 ClangTidyContext *Context);
 
     /// Read a named option from the ``Context``.
     ///
     /// Reads the option with the check-local name \p LocalName from the
-    /// ``CheckOptions``. If the corresponding key is not present, returns
-    /// a ``MissingOptionError``.
-    llvm::Expected<std::string> get(StringRef LocalName) const;
+    /// ``CheckOptions``. If the corresponding key is not present, return
+    /// ``None``.
+    llvm::Optional<std::string> get(StringRef LocalName) const;
 
     /// Read a named option from the ``Context``.
     ///
     /// Reads the option with the check-local name \p LocalName from the
     /// ``CheckOptions``. If the corresponding key is not present, returns
     /// \p Default.
-    std::string get(StringRef LocalName, StringRef Default) const {
-      if (llvm::Expected<std::string> Val = get(LocalName))
-        return *Val;
-      else
-        llvm::consumeError(Val.takeError());
-      return Default.str();
-    }
+    std::string get(StringRef LocalName, StringRef Default) const;
 
     /// Read a named option from the ``Context``.
     ///
     /// Reads the option with the check-local name \p LocalName from local or
     /// global ``CheckOptions``. Gets local option first. If local is not
     /// present, falls back to get global option. If global option is not
-    /// present either, returns a ``MissingOptionError``.
-    llvm::Expected<std::string> getLocalOrGlobal(StringRef LocalName) const;
+    /// present either, return ``None``.
+    llvm::Optional<std::string> getLocalOrGlobal(StringRef LocalName) const;
 
     /// Read a named option from the ``Context``.
     ///
     /// Reads the option with the check-local name \p LocalName from local or
     /// global ``CheckOptions``. Gets local option first. If local is not
     /// present, falls back to get global option. If global option is not
     /// present either, returns \p Default.
-    std::string getLocalOrGlobal(StringRef LocalName, StringRef Default) const {
-      if (llvm::Expected<std::string> Val = getLocalOrGlobal(LocalName))
-        return *Val;
-      else
-        llvm::consumeError(Val.takeError());
-      return Default.str();
-    }
+    std::string getLocalOrGlobal(StringRef LocalName, StringRef Default) const;
 
     /// Read a named option from the ``Context`` and parse it as an
     /// integral type ``T``.
     ///
     /// Reads the option with the check-local name \p LocalName from the
-    /// ``CheckOptions``. If the corresponding key is not present, returns
-    /// a ``MissingOptionError``. If the corresponding key can't be parsed as
-    /// a ``T``, return an ``UnparseableIntegerOptionError``.
+    /// ``CheckOptions``. If the corresponding key is not present, return
+    /// ``None``.
+    ///
+    /// If the corresponding key can't be parsed as a ``T``, emit a
+    /// diagnostic and return ``None``.
     template <typename T>
-    std::enable_if_t<std::is_integral<T>::value, llvm::Expected<T>>
+    std::enable_if_t<std::is_integral<T>::value, llvm::Optional<T>>
     get(StringRef LocalName) const {
-      if (llvm::Expected<std::string> Value = get(LocalName)) {
+      if (llvm::Optional<std::string> Value = get(LocalName)) {
         T Result{};
         if (!StringRef(*Value).getAsInteger(10, Result))
           return Result;
-        return llvm::make_error<UnparseableIntegerOptionError>(
-            (NamePrefix + LocalName).str(), *Value);
-      } else
-        return std::move(Value.takeError());
+        diagnoseBadIntegerOption(NamePrefix + LocalName, *Value);
+      }
+      return None;
     }
 
     /// Read a named option from the ``Context`` and parse it as an
     /// integral type ``T``.
     ///
     /// Reads the option with the check-local name \p LocalName from the
-    /// ``CheckOptions``. If the corresponding key is not present or it can't be
-    /// parsed as a ``T``, returns \p Default.
+    /// ``CheckOptions``. If the corresponding key is not present, return
+    /// \p Default.
+    ///
+    /// If the corresponding key can't be parsed as a ``T``, emit a
+    /// diagnostic and return \p Default.
     template <typename T>
     std::enable_if_t<std::is_integral<T>::value, T> get(StringRef LocalName,
                                                         T Default) const {
-      if (llvm::Expected<T> ValueOr = get<T>(LocalName))
-        return *ValueOr;
-      else
-        reportOptionParsingError(ValueOr.takeError());
-      return Default;
+      return get<T>(LocalName).getValueOr(Default);
     }
 
     /// Read a named option from the ``Context`` and parse it as an
     /// integral type ``T``.
     ///
     /// Reads the option with the check-local name \p LocalName from local or
     /// global ``CheckOptions``. Gets local option first. If local is not
     /// present, falls back to get global option. If global option is not
-    /// present either, returns a ``MissingOptionError``. If the corresponding
-    /// key can't be parsed as a ``T``, return an
-    /// ``UnparseableIntegerOptionError``.
+    /// present either, return ``None``.
+    ///
+    /// If the corresponding key can't be parsed as a ``T``, emit a
+    /// diagnostic and return ``None``.
     template <typename T>
-    std::enable_if_t<std::is_integral<T>::value, llvm::Expected<T>>
+    std::enable_if_t<std::is_integral<T>::value, llvm::Optional<T>>
     getLocalOrGlobal(StringRef LocalName) const {
-      llvm::Expected<std::string> ValueOr = get(LocalName);
+      llvm::Optional<std::string> ValueOr = get(LocalName);
       bool IsGlobal = false;
       if (!ValueOr) {
         IsGlobal = true;
-        llvm::consumeError(ValueOr.takeError());
         ValueOr = getLocalOrGlobal(LocalName);
         if (!ValueOr)
-          return std::move(ValueOr.takeError());
+          return None;
       }
       T Result{};
       if (!StringRef(*ValueOr).getAsInteger(10, Result))
         return Result;
-      return llvm::make_error<UnparseableIntegerOptionError>(
-          (IsGlobal ? LocalName.str() : (NamePrefix + LocalName).str()),
-          *ValueOr);
+      diagnoseBadIntegerOption(
+          IsGlobal ? Twine(LocalName) : NamePrefix + LocalName, *ValueOr);
+      return None;
     }
 
     /// Read a named option from the ``Context`` and parse it as an
     /// integral type ``T``.
     ///
     /// Reads the option with the check-local name \p LocalName from local or
     /// global ``CheckOptions``. Gets local option first. If local is not
     /// present, falls back to get global option. If global option is not
-    /// present either or it can't be parsed as a ``T``, returns \p Default.
+    /// present either, return \p Default.
+    ///
+    /// If the corresponding key can't be parsed as a ``T``, emit a
+    /// diagnostic and return \p Default.
     template <typename T>
     std::enable_if_t<std::is_integral<T>::value, T>
     getLocalOrGlobal(StringRef LocalName, T Default) const {
-      if (llvm::Expected<T> ValueOr = getLocalOrGlobal<T>(LocalName))
-        return *ValueOr;
-      else
-        reportOptionParsingError(ValueOr.takeError());
-      return Default;
+      return getLocalOrGlobal<T>(LocalName).getValueOr(Default);
     }
 
     /// Read a named option from the ``Context`` and parse it as an
     /// enum type ``T``.
     ///
     /// Reads the option with the check-local name \p LocalName from the
-    /// ``CheckOptions``. If the corresponding key is not present, returns a
-    /// ``MissingOptionError``. If the key can't be parsed as a ``T`` returns a
-    /// ``UnparseableEnumOptionError``.
+    /// ``CheckOptions``. If the corresponding key is not present, return
+    /// ``None``.
+    ///
+    /// If the corresponding key can't be parsed as a ``T``, emit a
+    /// diagnostic and return ``None``.
     ///
     /// \ref clang::tidy::OptionEnumMapping must be specialized for ``T`` to
     /// supply the mapping required to convert between ``T`` and a string.
     template <typename T>
-    std::enable_if_t<std::is_enum<T>::value, llvm::Expected<T>>
+    std::enable_if_t<std::is_enum<T>::value, llvm::Optional<T>>
     get(StringRef LocalName, bool IgnoreCase = false) const {
-      if (llvm::Expected<int64_t> ValueOr =
+      if (llvm::Optional<int64_t> ValueOr =
               getEnumInt(LocalName, typeEraseMapping<T>(), false, IgnoreCase))
         return static_cast<T>(*ValueOr);
-      else
-        return std::move(ValueOr.takeError());
+      return None;
     }
 
     /// Read a named option from the ``Context`` and parse it as an
     /// enum type ``T``.
     ///
     /// Reads the option with the check-local name \p LocalName from the
-    /// ``CheckOptions``. If the corresponding key is not present or it can't be
-    /// parsed as a ``T``, returns \p Default.
+    /// ``CheckOptions``. If the corresponding key is not present, return
+    /// \p Default.
+    ///
+    /// If the corresponding key can't be parsed as a ``T``, emit a
+    /// diagnostic and return \p Default.
     ///
     /// \ref clang::tidy::OptionEnumMapping must be specialized for ``T`` to
     /// supply the mapping required to convert between ``T`` and a string.
     template <typename T>
     std::enable_if_t<std::is_enum<T>::value, T>
     get(StringRef LocalName, T Default, bool IgnoreCase = false) const {
-      if (auto ValueOr = get<T>(LocalName, IgnoreCase))
-        return *ValueOr;
-      else
-        reportOptionParsingError(ValueOr.takeError());
-      return Default;
+      return get<T>(LocalName, IgnoreCase).getValueOr(Default);
     }
 
     /// Read a named option from the ``Context`` and parse it as an
     /// enum type ``T``.
     ///
     /// Reads the option with the check-local name \p LocalName from local or
     /// global ``CheckOptions``. Gets local option first. If local is not
     /// present, falls back to get global option. If global option is not
-    /// present either, returns a ``MissingOptionError``. If the key can't be
-    /// parsed as a ``T`` returns a ``UnparseableEnumOptionError``.
+    /// present either, returns ``None``.
+    ///
+    /// If the corresponding key can't be parsed as a ``T``, emit a
+    /// diagnostic and return ``None``.
     ///
     /// \ref clang::tidy::OptionEnumMapping must be specialized for ``T`` to
     /// supply the mapping required to convert between ``T`` and a string.
     template <typename T>
-    std::enable_if_t<std::is_enum<T>::value, llvm::Expected<T>>
+    std::enable_if_t<std::is_enum<T>::value, llvm::Optional<T>>
     getLocalOrGlobal(StringRef LocalName, bool IgnoreCase = false) const {
-      if (llvm::Expected<int64_t> ValueOr =
+      if (llvm::Optional<int64_t> ValueOr =
               getEnumInt(LocalName, typeEraseMapping<T>(), true, IgnoreCase))
         return static_cast<T>(*ValueOr);
-      else
-        return std::move(ValueOr.takeError());
+      return None;
     }
 
     /// Read a named option from the ``Context`` and parse it as an
     /// enum type ``T``.
     ///
     /// Reads the option with the check-local name \p LocalName from local or
     /// global ``CheckOptions``. Gets local option first. If local is not
     /// present, falls back to get global option. If global option is not
-    /// present either or it can't be parsed as a ``T``, returns \p Default.
+    /// present either return \p Default.
+    ///
+    /// If the corresponding key can't be parsed as a ``T``, emit a
+    /// diagnostic and return \p Default.
     ///
     /// \ref clang::tidy::OptionEnumMapping must be specialized for ``T`` to
     /// supply the mapping required to convert between ``T`` and a string.
     template <typename T>
     std::enable_if_t<std::is_enum<T>::value, T>
     getLocalOrGlobal(StringRef LocalName, T Default,
                      bool IgnoreCase = false) const {
-      if (auto ValueOr = getLocalOrGlobal<T>(LocalName, IgnoreCase))
-        return *ValueOr;
-      else
-        reportOptionParsingError(ValueOr.takeError());
-      return Default;
-    }
-
-    /// Returns the value for the option \p LocalName represented as a ``T``.
-    /// If the option is missing returns None, if the option can't be parsed
-    /// as a ``T``, log that to stderr and return None.
-    template <typename T = std::string>
-    llvm::Optional<T> getOptional(StringRef LocalName) const {
-      if (auto ValueOr = get<T>(LocalName))
-        return *ValueOr;
-      else
-        reportOptionParsingError(ValueOr.takeError());
-      return llvm::None;
-    }
-
-    /// Returns the value for the local or global option \p LocalName
-    /// represented as a ``T``.
-    /// If the option is missing returns None, if the
-    /// option can't be parsed as a ``T``, log that to stderr and return None.
-    template <typename T = std::string>
-    llvm::Optional<T> getOptionalLocalOrGlobal(StringRef LocalName) const {
-      if (auto ValueOr = getLocalOrGlobal<T>(LocalName))
-        return *ValueOr;
-      else
-        reportOptionParsingError(ValueOr.takeError());
-      return llvm::None;
+      return getLocalOrGlobal<T>(LocalName, IgnoreCase).getValueOr(Default);
     }
 
     /// Stores an option with the check-local name \p LocalName with
     /// string value \p Value to \p Options.
     void store(ClangTidyOptions::OptionMap &Options, StringRef LocalName,
                StringRef Value) const;
 
     /// Stores an option with the check-local name \p LocalName with
store(ClangTidyOptions::OptionMap &Options, StringRef LocalName,
           });
       assert(Iter != Mapping.end() && "Unknown Case Value");
       store(Options, LocalName, Iter->second);
     }
 
   private:
     using NameAndValue = std::pair<int64_t, StringRef>;
 
-    llvm::Expected<int64_t> getEnumInt(StringRef LocalName,
+    llvm::Optional<int64_t> getEnumInt(StringRef LocalName,
                                        ArrayRef<NameAndValue> Mapping,
                                        bool CheckGlobal, bool IgnoreCase) const;
 
     template <typename T>
     std::enable_if_t<std::is_enum<T>::value, std::vector<NameAndValue>>
     typeEraseMapping() const {
       ArrayRef<std::pair<T, StringRef>> Mapping =
           OptionEnumMapping<T>::getEnumMapping();
       std::vector<NameAndValue> Result;
       Result.reserve(Mapping.size());
       for (auto &MappedItem : Mapping) {
         Result.emplace_back(static_cast<int64_t>(MappedItem.first),
                             MappedItem.second);
       }
       return Result;
     }
 
     void storeInt(ClangTidyOptions::OptionMap &Options, StringRef LocalName,
                   int64_t Value) const;
 
-    /// Emits a diagnostic if \p Err is not a MissingOptionError.
-    void reportOptionParsingError(llvm::Error &&Err) const;
 
     std::string NamePrefix;
     const ClangTidyOptions::OptionMap &CheckOptions;
     ClangTidyContext *Context;
   };
 
 private:
   void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
   StringRef getID() const override { return CheckName; }
   std::string CheckName;
   ClangTidyContext *Context;
 
 protected:
   OptionsView Options;
   /// Returns the main file name of the current translation unit.
   StringRef getCurrentMainFile() const { return Context->getCurrentFile(); }
   /// Returns the language options from the context.
   const LangOptions &getLangOpts() const { return Context->getLangOpts(); }
 };
 
 /// Read a named option from the ``Context`` and parse it as a bool.
 ///
 /// Reads the option with the check-local name \p LocalName from the
-/// ``CheckOptions``. If the corresponding key is not present, returns
-/// a ``MissingOptionError``. If the corresponding key can't be parsed as
-/// a bool, return an ``UnparseableIntegerOptionError``.
+/// ``CheckOptions``. If the corresponding key is not present, return
+/// ``None``.
+///
+/// If the corresponding key can't be parsed as a bool, emit a
+/// diagnostic and return ``None``.
 template <>
-llvm::Expected<bool>
+llvm::Optional<bool>
 ClangTidyCheck::OptionsView::get<bool>(StringRef LocalName) const;
 
 /// Read a named option from the ``Context`` and parse it as a bool.
 ///
 /// Reads the option with the check-local name \p LocalName from the
-/// ``CheckOptions``. If the corresponding key is not present or it can't be
-/// parsed as a bool, returns \p Default.
-template <>
-bool ClangTidyCheck::OptionsView::get<bool>(StringRef LocalName,
-                                            bool Default) const;
-
-/// Read a named option from the ``Context`` and parse it as a bool.
+/// ``CheckOptions``. If the corresponding key is not present, return
+/// \p Default.
 ///
-/// Reads the option with the check-local name \p LocalName from local or
-/// global ``CheckOptions``. Gets local option first. If local is not
-/// present, falls back to get global option. If global option is not
-/// present either, returns a ``MissingOptionError``. If the corresponding
-/// key can't be parsed as a bool, return an
-/// ``UnparseableIntegerOptionError``.
+/// If the corresponding key can't be parsed as a bool, emit a
+/// diagnostic and return \p Default.
 template <>
-llvm::Expected<bool>
+llvm::Optional<bool>
 ClangTidyCheck::OptionsView::getLocalOrGlobal<bool>(StringRef LocalName) const;
 
-/// Read a named option from the ``Context`` and parse it as a bool.
-///
-/// Reads the option with the check-local name \p LocalName from local or
-/// global ``CheckOptions``. Gets local option first. If local is not
-/// present, falls back to get global option. If global option is not
-/// present either or it can't be parsed as a bool, returns \p Default.
-template <>
-bool ClangTidyCheck::OptionsView::getLocalOrGlobal<bool>(StringRef LocalName,
-                                                         bool Default) const;
-
 /// Stores an option with the check-local name \p LocalName with
 /// bool value \p Value to \p Options.
 template <>
 void ClangTidyCheck::OptionsView::store<bool>(
     ClangTidyOptions::OptionMap &Options, StringRef LocalName,
     bool Value) const;
 
-/// Returns the value for the option \p LocalName.
-/// If the option is missing returns None.
-template <>
-Optional<std::string> ClangTidyCheck::OptionsView::getOptional<std::string>(
-    StringRef LocalName) const;
-
-/// Returns the value for the local or global option \p LocalName.
-/// If the option is missing returns None.
-template <>
-Optional<std::string>
-ClangTidyCheck::OptionsView::getOptionalLocalOrGlobal<std::string>(
-    StringRef LocalName) const;
 
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYCHECK_H

clang-tools-extra/clang-tidy/ClangTidyCheck.cpp

 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/YAMLParser.h"
 
 namespace clang {
 namespace tidy {
 
-char MissingOptionError::ID;
-char UnparseableEnumOptionError::ID;
-char UnparseableIntegerOptionError::ID;
-
-std::string MissingOptionError::message() const {
-  llvm::SmallString<128> Buffer({"option not found '", OptionName, "'"});
-  return std::string(Buffer);
-}
-
-std::string UnparseableEnumOptionError::message() const {
-  llvm::SmallString<256> Buffer({"invalid configuration value '", LookupValue,
-                                 "' for option '", LookupName, "'"});
-  if (SuggestedValue)
-    Buffer.append({"; did you mean '", *SuggestedValue, "'?"});
-  return std::string(Buffer);
-}
-
-std::string UnparseableIntegerOptionError::message() const {
-  llvm::SmallString<256> Buffer({"invalid configuration value '", LookupValue,
-                                 "' for option '", LookupName, "'; expected ",
-                                 (IsBoolean ? "a bool" : "an integer value")});
-  return std::string(Buffer);
-}
-
 ClangTidyCheck::ClangTidyCheck(StringRef CheckName, ClangTidyContext *Context)
     : CheckName(CheckName), Context(Context),
       Options(CheckName, Context->getOptions().CheckOptions, Context) {
   assert(Context != nullptr);
   assert(!CheckName.empty());
 }
 
 DiagnosticBuilder ClangTidyCheck::diag(SourceLocation Loc, StringRef Message,

 }
 
 ClangTidyCheck::OptionsView::OptionsView(
     StringRef CheckName, const ClangTidyOptions::OptionMap &CheckOptions,
     ClangTidyContext *Context)
     : NamePrefix(CheckName.str() + "."), CheckOptions(CheckOptions),
       Context(Context) {}
 
-llvm::Expected<std::string>
+llvm::Optional<std::string>
 ClangTidyCheck::OptionsView::get(StringRef LocalName) const {
   const auto &Iter = CheckOptions.find(NamePrefix + LocalName.str());
   if (Iter != CheckOptions.end())
     return Iter->getValue().Value;
-  return llvm::make_error<MissingOptionError>((NamePrefix + LocalName).str());
+  return None;
 }
 
 static ClangTidyOptions::OptionMap::const_iterator
 findPriorityOption(const ClangTidyOptions::OptionMap &Options, StringRef NamePrefix,
           StringRef LocalName) {
   auto IterLocal = Options.find((NamePrefix + LocalName).str());
   auto IterGlobal = Options.find(LocalName.str());
   if (IterLocal == Options.end())
     return IterGlobal;
   if (IterGlobal == Options.end())
     return IterLocal;
   if (IterLocal->getValue().Priority >= IterGlobal->getValue().Priority)
     return IterLocal;
   return IterGlobal;
 }
 
-llvm::Expected<std::string>
+llvm::Optional<std::string>
 ClangTidyCheck::OptionsView::getLocalOrGlobal(StringRef LocalName) const {
   auto Iter = findPriorityOption(CheckOptions, NamePrefix, LocalName);
   if (Iter != CheckOptions.end())
     return Iter->getValue().Value;
-  return llvm::make_error<MissingOptionError>((NamePrefix + LocalName).str());
+  return None;
 }
 
-static llvm::Expected<bool> getAsBool(StringRef Value,
-                                      const llvm::Twine &LookupName) {
+static Optional<bool> getAsBool(StringRef Value,
 
   if (llvm::Optional<bool> Parsed = llvm::yaml::parseBool(Value))
     return *Parsed;
   // To maintain backwards compatability, we support parsing numbers as
   // booleans, even though its not supported in YAML.
   long long Number;
   if (!Value.getAsInteger(10, Number))
     return Number != 0;
-  return llvm::make_error<UnparseableIntegerOptionError>(LookupName.str(),
-                                                         Value.str(), true);
+  return None;
 }
 
 template <>
-llvm::Expected<bool>
+llvm::Optional<bool>
 ClangTidyCheck::OptionsView::get<bool>(StringRef LocalName) const {
-  llvm::Expected<std::string> ValueOr = get(LocalName);
-  if (ValueOr)
-    return getAsBool(*ValueOr, NamePrefix + LocalName);
-  return ValueOr.takeError();
+  if (llvm::Optional<std::string> ValueOr = get(LocalName)) {
+    if (auto Result = getAsBool(*ValueOr, NamePrefix + LocalName))
+      return Result;
+    diagnoseBadBooleanOption(NamePrefix + LocalName, *ValueOr);
   }
-
-template <>
-bool ClangTidyCheck::OptionsView::get<bool>(StringRef LocalName,
-                                            bool Default) const {
-  llvm::Expected<bool> ValueOr = get<bool>(LocalName);
-  if (ValueOr)
-    return *ValueOr;
-  reportOptionParsingError(ValueOr.takeError());
-  return Default;
+  return None;
 }
 
 template <>
-llvm::Expected<bool>
+llvm::Optional<bool>
 ClangTidyCheck::OptionsView::getLocalOrGlobal<bool>(StringRef LocalName) const {
   auto Iter = findPriorityOption(CheckOptions, NamePrefix, LocalName);
-  if (Iter != CheckOptions.end())
-    return getAsBool(Iter->getValue().Value, Iter->getKey());
-  return llvm::make_error<MissingOptionError>((NamePrefix + LocalName).str());
+  if (Iter != CheckOptions.end()) {
+    if (auto Result = getAsBool(Iter->getValue().Value, Iter->getKey()))
+      return Result;
+    diagnoseBadBooleanOption(Iter->getKey(), Iter->getValue().Value);
   }
-
-template <>
-bool ClangTidyCheck::OptionsView::getLocalOrGlobal<bool>(StringRef LocalName,
-                                                         bool Default) const {
-  llvm::Expected<bool> ValueOr = getLocalOrGlobal<bool>(LocalName);
-  if (ValueOr)
-    return *ValueOr;
-  reportOptionParsingError(ValueOr.takeError());
-  return Default;
+  return None;
 }
 
 void ClangTidyCheck::OptionsView::store(ClangTidyOptions::OptionMap &Options,
                                         StringRef LocalName,
                                         StringRef Value) const {
   Options[NamePrefix + LocalName.str()] = Value;
 }
 
 void ClangTidyCheck::OptionsView::storeInt(ClangTidyOptions::OptionMap &Options,
                                            StringRef LocalName,
                                            int64_t Value) const {
   store(Options, LocalName, llvm::itostr(Value));
 }
 
 template <>
 void ClangTidyCheck::OptionsView::store<bool>(
     ClangTidyOptions::OptionMap &Options, StringRef LocalName,
     bool Value) const {
   store(Options, LocalName, Value ? StringRef("true") : StringRef("false"));
 }
 
-llvm::Expected<int64_t> ClangTidyCheck::OptionsView::getEnumInt(
+llvm::Optional<int64_t> ClangTidyCheck::OptionsView::getEnumInt(
     StringRef LocalName, ArrayRef<NameAndValue> Mapping, bool CheckGlobal,
     bool IgnoreCase) const {
   auto Iter = CheckGlobal
                   ? findPriorityOption(CheckOptions, NamePrefix, LocalName)
                   : CheckOptions.find((NamePrefix + LocalName).str());
   if (Iter == CheckOptions.end())
-    return llvm::make_error<MissingOptionError>((NamePrefix + LocalName).str());
+    return None;
 
   StringRef Value = Iter->getValue().Value;
   StringRef Closest;
   unsigned EditDistance = -1;
   for (const auto &NameAndEnum : Mapping) {
     if (IgnoreCase) {
       if (Value.equals_lower(NameAndEnum.second))
         return NameAndEnum.first;
     } else if (Value.equals(NameAndEnum.second)) {
       return NameAndEnum.first;
     } else if (Value.equals_lower(NameAndEnum.second)) {
       Closest = NameAndEnum.second;
       EditDistance = 0;
       continue;
     }
     unsigned Distance = Value.edit_distance(NameAndEnum.second);
     if (Distance < EditDistance) {
       EditDistance = Distance;
       Closest = NameAndEnum.second;
     }
   }
   if (EditDistance < 3)
-    return llvm::make_error<UnparseableEnumOptionError>(
-        Iter->getKey().str(), Iter->getValue().Value, Closest.str());
-  return llvm::make_error<UnparseableEnumOptionError>(Iter->getKey().str(),
-                                                      Iter->getValue().Value);
-}
-
-void ClangTidyCheck::OptionsView::reportOptionParsingError(
-    llvm::Error &&Err) const {
-  if (auto RemainingErrors =
-          llvm::handleErrors(std::move(Err), [](const MissingOptionError &) {}))
-    Context->configurationDiag(llvm::toString(std::move(RemainingErrors)));
-}
-
-template <>
-Optional<std::string> ClangTidyCheck::OptionsView::getOptional<std::string>(
-    StringRef LocalName) const {
-  if (auto ValueOr = get(LocalName))
-    return *ValueOr;
+    diagnoseBadEnumOption(Iter->getKey().str(), Iter->getValue().Value,
+                          Closest);
   else
-    consumeError(ValueOr.takeError());
-  return llvm::None;
+    diagnoseBadEnumOption(Iter->getKey().str(), Iter->getValue().Value);
+  return None;
 }
 
-template <>
-Optional<std::string>
-ClangTidyCheck::OptionsView::getOptionalLocalOrGlobal<std::string>(
-    StringRef LocalName) const {
-  if (auto ValueOr = getLocalOrGlobal(LocalName))
-    return *ValueOr;
+static constexpr llvm::StringLiteral ConfigWarning(
+    "invalid configuration value '%0' for option '%1'%select{|; expected a "
+    "bool|; expected an integer|; did you mean '%3'?}2");
+
+void ClangTidyCheck::OptionsView::diagnoseBadBooleanOption(
+    const Twine &Lookup, StringRef Unparsed) const {
+  SmallString<64> Buffer;
+  Context->configurationDiag(ConfigWarning)
+      << Unparsed << Lookup.toStringRef(Buffer) << 1;
+}
+
+void ClangTidyCheck::OptionsView::diagnoseBadIntegerOption(
+    const Twine &Lookup, StringRef Unparsed) const {
+  SmallString<64> Buffer;
+  Context->configurationDiag(ConfigWarning)
+      << Unparsed << Lookup.toStringRef(Buffer) << 2;
+}
+
+void ClangTidyCheck::OptionsView::diagnoseBadEnumOption(
+    const Twine &Lookup, StringRef Unparsed, StringRef Suggestion) const {
+  SmallString<64> Buffer;
+  auto Diag = Context->configurationDiag(ConfigWarning)
+              << Unparsed << Lookup.toStringRef(Buffer);
+  if (Suggestion.empty())
+    Diag << 0;
   else
-    consumeError(ValueOr.takeError());
-  return llvm::None;
+    Diag << 3 << Suggestion;
 }
 
+std::string ClangTidyCheck::OptionsView::get(StringRef LocalName,
+                                             StringRef Default) const {
+  if (llvm::Optional<std::string> Val = get(LocalName))
+    return std::move(*Val);
+  return Default.str();
+}
+std::string
+ClangTidyCheck::OptionsView::getLocalOrGlobal(StringRef LocalName,
+                                              StringRef Default) const {
+  if (llvm::Optional<std::string> Val = getLocalOrGlobal(LocalName))
+    return std::move(*Val);
+  return Default.str();
+}
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp

for (unsigned I = 0; I < SK_Count; ++I) {
     std::string Prefix(Options.get(StyleString, ""));
     // Fast replacement of [Pre]fix -> [Suf]fix.
     memcpy(&StyleString[StyleSize], "Suf", 3);
     std::string Postfix(Options.get(StyleString, ""));
     memcpy(&StyleString[StyleSize], "Case", 4);
     StyleString.pop_back();
     StyleString.pop_back();
     auto CaseOptional =
-        Options.getOptional<IdentifierNamingCheck::CaseType>(StyleString);
+        Options.get<IdentifierNamingCheck::CaseType>(StyleString);
 
     if (CaseOptional || !Prefix.empty() || !Postfix.empty() ||
         !IgnoredRegexpStr.empty())
       Styles[I].emplace(std::move(CaseOptional), std::move(Prefix),
                         std::move(Postfix), std::move(IgnoredRegexpStr));
   }
   bool IgnoreMainLike = Options.get("IgnoreMainLikeFunctions", false);
   return {std::move(Styles), IgnoreMainLike};

clang-tools-extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp

 MATCHER_P(DiagMessage, M, "") { return arg.Message == M; }
 MATCHER_P(DiagKind, K, "") { return arg.Kind == K; }
 MATCHER_P(DiagPos, P, "") { return arg.Pos == P; }
 MATCHER_P(DiagRange, P, "") { return arg.Range && *arg.Range == P; }
 } // namespace
 
 using ::testing::AllOf;
 using ::testing::ElementsAre;
+using ::testing::UnorderedElementsAre;
 
 TEST(ParseConfiguration, CollectDiags) {
   DiagCollecter Collector;
   auto ParseWithDiags = [&](llvm::StringRef Buffer) {
     return parseConfigurationWithDiags(llvm::MemoryBufferRef(Buffer, "Options"),
                                        Collector.getCallback());
   };
   llvm::Annotations Options(R"(
auto getIntLocal(Args &&... Arguments) {
     return Options.get<IntType>(std::forward<Args>(Arguments)...);
   }
 
   template <typename IntType = int, typename... Args>
   auto getIntGlobal(Args &&... Arguments) {
     return Options.getLocalOrGlobal<IntType>(std::forward<Args>(Arguments)...);
   }
 };
-} // namespace
 
 #define CHECK_VAL(Value, Expected)                                             \
   do {                                                                         \
     auto Item = Value;                                                         \
     ASSERT_TRUE(!!Item);                                                       \
     EXPECT_EQ(*Item, Expected);                                                \
   } while (false)
 
-#define CHECK_ERROR(Value, ErrorType, ExpectedMessage)                         \
-  do {                                                                         \
-    auto Item = Value;                                                         \
-    ASSERT_FALSE(Item);                                                        \
-    ASSERT_TRUE(Item.errorIsA<ErrorType>());                                   \
-    ASSERT_FALSE(llvm::handleErrors(                                           \
-        Item.takeError(), [&](const ErrorType &Err) -> llvm::Error {           \
-          EXPECT_EQ(Err.message(), ExpectedMessage);                           \
-          return llvm::Error::success();                                       \
-        }));                                                                   \
-  } while (false)
+MATCHER_P(ToolDiagMessage, M, "") { return arg.Message.Message == M; }
+MATCHER_P(ToolDiagLevel, L, "") { return arg.DiagLevel == L; }
+
+} // namespace
+
+} // namespace test
+
+static constexpr auto Warning = tooling::Diagnostic::Warning;
+static constexpr auto Error = tooling::Diagnostic::Error;
+
+static void PrintTo(const ClangTidyError &Err, ::std::ostream *OS) {
+  *OS << (Err.DiagLevel == Error ? "error: " : "warning: ")
+      << Err.Message.Message;
+}
+
+namespace test {
 
 TEST(CheckOptionsValidation, MissingOptions) {
   ClangTidyOptions Options;
   ClangTidyContext Context(std::make_unique<DefaultOptionsProvider>(
       ClangTidyGlobalOptions(), Options));
   ClangTidyDiagnosticConsumer DiagConsumer(Context);
   DiagnosticsEngine DE(new DiagnosticIDs(), new DiagnosticOptions,
                        &DiagConsumer, false);
   Context.setDiagnosticsEngine(&DE);
   TestCheck TestCheck(&Context);
-  CHECK_ERROR(TestCheck.getLocal("Opt"), MissingOptionError,
-              "option not found 'test.Opt'");
+  EXPECT_FALSE(TestCheck.getLocal("Opt").hasValue());
   EXPECT_EQ(TestCheck.getLocal("Opt", "Unknown"), "Unknown");
+  // Missing options aren't errors.
+  EXPECT_TRUE(DiagConsumer.take().empty());
 }
 
 TEST(CheckOptionsValidation, ValidIntOptions) {
   ClangTidyOptions Options;
   auto &CheckOptions = Options.CheckOptions;
-  CheckOptions["test.IntExpected1"] = "1";
-  CheckOptions["test.IntExpected2"] = "1WithMore";
-  CheckOptions["test.IntExpected3"] = "NoInt";
-  CheckOptions["GlobalIntExpected1"] = "1";
-  CheckOptions["GlobalIntExpected2"] = "NoInt";
-  CheckOptions["test.DefaultedIntInvalid"] = "NoInt";
+  CheckOptions["test.IntExpected"] = "1";
+  CheckOptions["test.IntInvalid1"] = "1WithMore";
+  CheckOptions["test.IntInvalid2"] = "NoInt";
+  CheckOptions["GlobalIntExpected"] = "1";
   CheckOptions["GlobalIntInvalid"] = "NoInt";
+  CheckOptions["test.DefaultedIntInvalid"] = "NoInt";
   CheckOptions["test.BoolITrueValue"] = "1";
   CheckOptions["test.BoolIFalseValue"] = "0";
   CheckOptions["test.BoolTrueValue"] = "true";
   CheckOptions["test.BoolFalseValue"] = "false";
   CheckOptions["test.BoolTrueShort"] = "Y";
   CheckOptions["test.BoolFalseShort"] = "N";
   CheckOptions["test.BoolUnparseable"] = "Nothing";
 
   ClangTidyContext Context(std::make_unique<DefaultOptionsProvider>(
       ClangTidyGlobalOptions(), Options));
   ClangTidyDiagnosticConsumer DiagConsumer(Context);
   DiagnosticsEngine DE(new DiagnosticIDs(), new DiagnosticOptions,
                        &DiagConsumer, false);
   Context.setDiagnosticsEngine(&DE);
   TestCheck TestCheck(&Context);
 
-#define CHECK_ERROR_INT(Name, Expected)                                        \
-  CHECK_ERROR(Name, UnparseableIntegerOptionError, Expected)
-
-  CHECK_VAL(TestCheck.getIntLocal("IntExpected1"), 1);
-  CHECK_VAL(TestCheck.getIntGlobal("GlobalIntExpected1"), 1);
-  CHECK_ERROR_INT(TestCheck.getIntLocal("IntExpected2"),
-                  "invalid configuration value '1WithMore' for option "
-                  "'test.IntExpected2'; expected an integer value");
-  CHECK_ERROR_INT(TestCheck.getIntLocal("IntExpected3"),
-                  "invalid configuration value 'NoInt' for option "
-                  "'test.IntExpected3'; expected an integer value");
-  CHECK_ERROR_INT(TestCheck.getIntGlobal("GlobalIntExpected2"),
-                  "invalid configuration value 'NoInt' for option "
-                  "'GlobalIntExpected2'; expected an integer value");
+  CHECK_VAL(TestCheck.getIntLocal("IntExpected"), 1);
+  CHECK_VAL(TestCheck.getIntGlobal("GlobalIntExpected"), 1);
+  EXPECT_FALSE(TestCheck.getIntLocal("IntInvalid1").hasValue());
+  EXPECT_FALSE(TestCheck.getIntLocal("IntInvalid2").hasValue());
+  EXPECT_FALSE(TestCheck.getIntGlobal("GlobalIntInvalid").hasValue());
   ASSERT_EQ(TestCheck.getIntLocal("DefaultedIntInvalid", 1), 1);
-  ASSERT_EQ(TestCheck.getIntGlobal("GlobalIntInvalid", 1), 1);
 
   CHECK_VAL(TestCheck.getIntLocal<bool>("BoolITrueValue"), true);
   CHECK_VAL(TestCheck.getIntLocal<bool>("BoolIFalseValue"), false);
   CHECK_VAL(TestCheck.getIntLocal<bool>("BoolTrueValue"), true);
   CHECK_VAL(TestCheck.getIntLocal<bool>("BoolFalseValue"), false);
   CHECK_VAL(TestCheck.getIntLocal<bool>("BoolTrueShort"), true);
   CHECK_VAL(TestCheck.getIntLocal<bool>("BoolFalseShort"), false);
-  CHECK_ERROR_INT(TestCheck.getIntLocal<bool>("BoolUnparseable"),
-                  "invalid configuration value 'Nothing' for option "
-                  "'test.BoolUnparseable'; expected a bool");
+  EXPECT_FALSE(TestCheck.getIntLocal<bool>("BoolUnparseable").hasValue());
 
-#undef CHECK_ERROR_INT
+  EXPECT_THAT(
+      DiagConsumer.take(),
+      UnorderedElementsAre(
+          AllOf(ToolDiagMessage(
+                    "invalid configuration value '1WithMore' for option "
+                    "'test.IntInvalid1'; expected an integer"),
+                ToolDiagLevel(Warning)),
+          AllOf(
+              ToolDiagMessage("invalid configuration value 'NoInt' for option "
+                              "'test.IntInvalid2'; expected an integer"),
+              ToolDiagLevel(Warning)),
+          AllOf(
+              ToolDiagMessage("invalid configuration value 'NoInt' for option "
+                              "'GlobalIntInvalid'; expected an integer"),
+              ToolDiagLevel(Warning)),
+          AllOf(ToolDiagMessage(
+                    "invalid configuration value 'NoInt' for option "
+                    "'test.DefaultedIntInvalid'; expected an integer"),
+                ToolDiagLevel(Warning)),
+          AllOf(ToolDiagMessage(
+                    "invalid configuration value 'Nothing' for option "
+                    "'test.BoolUnparseable'; expected a bool"),
+                ToolDiagLevel(Warning))));
 }
 
 TEST(ValidConfiguration, ValidEnumOptions) {
 
   ClangTidyOptions Options;
   auto &CheckOptions = Options.CheckOptions;
 
   CheckOptions["test.Valid"] = "Red";
   CheckOptions["test.Invalid"] = "Scarlet";
   CheckOptions["test.ValidWrongCase"] = "rED";
   CheckOptions["test.NearMiss"] = "Oragne";
   CheckOptions["GlobalValid"] = "Violet";
   CheckOptions["GlobalInvalid"] = "Purple";
   CheckOptions["GlobalValidWrongCase"] = "vIOLET";
   CheckOptions["GlobalNearMiss"] = "Yelow";
 
   ClangTidyContext Context(std::make_unique<DefaultOptionsProvider>(
       ClangTidyGlobalOptions(), Options));
+  ClangTidyDiagnosticConsumer DiagConsumer(Context);
+  DiagnosticsEngine DE(new DiagnosticIDs(), new DiagnosticOptions,
+                       &DiagConsumer, false);
+  Context.setDiagnosticsEngine(&DE);
   TestCheck TestCheck(&Context);
 
-#define CHECK_ERROR_ENUM(Name, Expected)                                       \
-  CHECK_ERROR(Name, UnparseableEnumOptionError, Expected)
-
   CHECK_VAL(TestCheck.getIntLocal<Colours>("Valid"), Colours::Red);
   CHECK_VAL(TestCheck.getIntGlobal<Colours>("GlobalValid"), Colours::Violet);
 
   CHECK_VAL(
       TestCheck.getIntLocal<Colours>("ValidWrongCase", /*IgnoreCase*/ true),
       Colours::Red);
   CHECK_VAL(TestCheck.getIntGlobal<Colours>("GlobalValidWrongCase",
                                             /*IgnoreCase*/ true),
             Colours::Violet);
-  CHECK_ERROR_ENUM(TestCheck.getIntLocal<Colours>("Invalid"),
-                   "invalid configuration value "
-                   "'Scarlet' for option 'test.Invalid'");
-  CHECK_ERROR_ENUM(TestCheck.getIntLocal<Colours>("ValidWrongCase"),
-                   "invalid configuration value 'rED' for option "
-                   "'test.ValidWrongCase'; did you mean 'Red'?");
-  CHECK_ERROR_ENUM(TestCheck.getIntLocal<Colours>("NearMiss"),
-                   "invalid configuration value 'Oragne' for option "
-                   "'test.NearMiss'; did you mean 'Orange'?");
-  CHECK_ERROR_ENUM(TestCheck.getIntGlobal<Colours>("GlobalInvalid"),
-                   "invalid configuration value "
-                   "'Purple' for option 'GlobalInvalid'");
-  CHECK_ERROR_ENUM(TestCheck.getIntGlobal<Colours>("GlobalValidWrongCase"),
-                   "invalid configuration value 'vIOLET' for option "
-                   "'GlobalValidWrongCase'; did you mean 'Violet'?");
-  CHECK_ERROR_ENUM(TestCheck.getIntGlobal<Colours>("GlobalNearMiss"),
-                   "invalid configuration value 'Yelow' for option "
-                   "'GlobalNearMiss'; did you mean 'Yellow'?");
 
-#undef CHECK_ERROR_ENUM
+  EXPECT_FALSE(TestCheck.getIntLocal<Colours>("ValidWrongCase").hasValue());
+  EXPECT_FALSE(TestCheck.getIntLocal<Colours>("NearMiss").hasValue());
+  EXPECT_FALSE(TestCheck.getIntGlobal<Colours>("GlobalInvalid").hasValue());
+  EXPECT_FALSE(
+      TestCheck.getIntGlobal<Colours>("GlobalValidWrongCase").hasValue());
+  EXPECT_FALSE(TestCheck.getIntGlobal<Colours>("GlobalNearMiss").hasValue());
+
+  EXPECT_FALSE(TestCheck.getIntLocal<Colours>("Invalid").hasValue());
+  EXPECT_THAT(
+      DiagConsumer.take(),
+      UnorderedElementsAre(
+          AllOf(ToolDiagMessage("invalid configuration value "
+                                "'Scarlet' for option 'test.Invalid'"),
+                ToolDiagLevel(Warning)),
+          AllOf(ToolDiagMessage("invalid configuration value 'rED' for option "
+                                "'test.ValidWrongCase'; did you mean 'Red'?"),
+                ToolDiagLevel(Warning)),
+          AllOf(
+              ToolDiagMessage("invalid configuration value 'Oragne' for option "
+                              "'test.NearMiss'; did you mean 'Orange'?"),
+              ToolDiagLevel(Warning)),
+          AllOf(ToolDiagMessage("invalid configuration value "
+                                "'Purple' for option 'GlobalInvalid'"),
+                ToolDiagLevel(Warning)),
+          AllOf(
+              ToolDiagMessage("invalid configuration value 'vIOLET' for option "
+                              "'GlobalValidWrongCase'; did you mean 'Violet'?"),
+              ToolDiagLevel(Warning)),
+          AllOf(
+              ToolDiagMessage("invalid configuration value 'Yelow' for option "
+                              "'GlobalNearMiss'; did you mean 'Yellow'?"),
+              ToolDiagLevel(Warning))));
 }
 
 #undef CHECK_VAL
-#undef CHECK_ERROR
 
 } // namespace test
 } // namespace tidy
 } // namespace clang