[clang-tidy] Support all YAML supported spellings for bools in CheckOptions.

[njames93]

Summary

Depends on D92755

[aaron.ballman]

Is there a way to add test coverage for this to demonstrate that we handle what YAML considers a Boolean and that we don't allow oddities?

[njames93]

Refactored based on changes to parent.

[njames93]

Fix test failures and added some to demonstrate this behaviour. Haven't added exhaustive cases as they are present in the YAML parser tests.

[aaron.ballman]

LGTM!

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

 //===--- ClangTidyCheck.cpp - 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangTidyCheck.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/WithColor.h"
+#include "llvm/Support/YAMLParser.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace clang {
 namespace tidy {
 
 char MissingOptionError::ID;
 char UnparseableEnumOptionError::ID;
 char UnparseableIntegerOptionError::ID;
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());
 }
 
 static llvm::Expected<bool> getAsBool(StringRef Value,
                                       const llvm::Twine &LookupName) {
-  if (Value == "true")
-    return true;
-  if (Value == "false")
-    return false;
-  bool Result;
-  if (!Value.getAsInteger(10, Result))
-    return Result;
+
+  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);
 }
 
 template <>
 llvm::Expected<bool>
 ClangTidyCheck::OptionsView::get<bool>(StringRef LocalName) const {
   llvm::Expected<std::string> ValueOr = get(LocalName);

clang-tools-extra/docs/ReleaseNotes.rst

 --------------------------
 
 - Checks that allow configuring names of headers to include now support wrapping
   the include in angle brackets to create a system include. For example,
   :doc:`cppcoreguidelines-init-variables
   <clang-tidy/checks/cppcoreguidelines-init-variables>` and
   :doc:`modernize-make-unique <clang-tidy/checks/modernize-make-unique>`.
 
+- CheckOptions that take boolean values now support all spellings supported in 
+  the `YAML format <https://yaml.org/type/bool.html>`_.
+
 New modules
 ^^^^^^^^^^^
 
 - New ``altera`` module.
 
   Includes checks related to OpenCL for FPGA coding guidelines, based on the
   `Altera SDK for OpenCL: Best Practices Guide
   <https://www.altera.com/en_US/pdfs/literature/hb/opencl-sdk/aocl_optimization_guide.pdf>`_.

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

TEST(CheckOptionsValidation, ValidIntOptions) {
   CheckOptions["GlobalIntExpected1"] = "1";
   CheckOptions["GlobalIntExpected2"] = "NoInt";
   CheckOptions["test.DefaultedIntInvalid"] = "NoInt";
   CheckOptions["GlobalIntInvalid"] = "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";
-  CheckOptions["test.BoolCaseMismatch"] = "True";
 
   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_INT(TestCheck.getIntGlobal("GlobalIntExpected2"),
                   "'GlobalIntExpected2'; expected an integer value");
   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");
-  CHECK_ERROR_INT(TestCheck.getIntLocal<bool>("BoolCaseMismatch"),
-                  "invalid configuration value 'True' for option "
-                  "'test.BoolCaseMismatch'; expected a bool");
 
 #undef CHECK_ERROR_INT
 }
 
 TEST(ValidConfiguration, ValidEnumOptions) {
 
   ClangTidyOptions Options;
   auto &CheckOptions = Options.CheckOptions;