[clang-tidy] Extend SimplifyBooleanExpr demorgan support.

[njames93]

Summary

Adds an option SimplifyDemorganRelaxed which, when enabled, will transform negated conjunctions or disjunctions when neither operand is a negation.
Default value is false.

[LegalizeAdulthood]

LGTM

[njames93]

Add note to docs that this new option has no effect if SimplifyDeMorgan is false.

clang-tools-extra/clang-tidy/readability/SimplifyBooleanExprCheck.h

private:
 
   void issueDiag(const ASTContext &Result, SourceLocation Loc,
                  StringRef Description, SourceRange ReplacementRange,
                  StringRef Replacement);
 
   const bool ChainedConditionalReturn;
   const bool ChainedConditionalAssignment;
   const bool SimplifyDeMorgan;
+  const bool SimplifyDeMorganRelaxed;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_SIMPLIFY_BOOLEAN_EXPR_H

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

bool TraverseUnaryOperator(UnaryOperator *Op) {
     auto *Parens = dyn_cast<ParenExpr>(SubImp);
     auto *BinaryOp =
         Parens
             ? dyn_cast<BinaryOperator>(Parens->getSubExpr()->IgnoreImplicit())
             : dyn_cast<BinaryOperator>(SubImp);
     if (!BinaryOp || !BinaryOp->isLogicalOp() ||
         !BinaryOp->getType()->isBooleanType())
       return Base::TraverseUnaryOperator(Op);
-    if (checkEitherSide(BinaryOp, isUnaryLNot) ||
+    if (Check->SimplifyDeMorganRelaxed ||
+        checkEitherSide(BinaryOp, isUnaryLNot) ||
         checkEitherSide(BinaryOp,
                         [](const Expr *E) { return nestedDemorgan(E, 1); })) {
       if (Check->reportDeMorgan(Context, Op, BinaryOp, !IsProcessing, parent(),
                                 Parens) &&
           !Check->areDiagsSelfContained()) {
         llvm::SaveAndRestore<bool> RAII(IsProcessing, true);
         return Base::TraverseUnaryOperator(Op);
       }

 };
 
 SimplifyBooleanExprCheck::SimplifyBooleanExprCheck(StringRef Name,
                                                    ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       ChainedConditionalReturn(Options.get("ChainedConditionalReturn", false)),
       ChainedConditionalAssignment(
           Options.get("ChainedConditionalAssignment", false)),
-      SimplifyDeMorgan(Options.get("SimplifyDeMorgan", true)) {}
+      SimplifyDeMorgan(Options.get("SimplifyDeMorgan", true)),
+      SimplifyDeMorganRelaxed(Options.get("SimplifyDeMorganRelaxed", false)) {
+  if (SimplifyDeMorganRelaxed && !SimplifyDeMorgan)
+    configurationDiag("%0: 'SimplifyDeMorganRelaxed' cannot be enabled "
+                      "without 'SimplifyDeMorgan' enabled")
+        << Name;
+}
 
 static bool containsBoolLiteral(const Expr *E) {
   if (!E)
     return false;
   E = E->IgnoreParenImpCasts();
   if (isa<CXXBoolLiteralExpr>(E))
     return true;
   if (const auto *BinOp = dyn_cast<BinaryOperator>(E))
void SimplifyBooleanExprCheck::reportBinOp(const ASTContext &Context,
   }
 }
 
 void SimplifyBooleanExprCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "ChainedConditionalReturn", ChainedConditionalReturn);
   Options.store(Opts, "ChainedConditionalAssignment",
                 ChainedConditionalAssignment);
   Options.store(Opts, "SimplifyDeMorgan", SimplifyDeMorgan);
+  Options.store(Opts, "SimplifyDeMorganRelaxed", SimplifyDeMorganRelaxed);
 }
 
 void SimplifyBooleanExprCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(translationUnitDecl(), this);
 }
 
 void SimplifyBooleanExprCheck::check(const MatchFinder::MatchResult &Result) {
   Visitor(this, *Result.Context).traverse();

clang-tools-extra/docs/clang-tidy/checks/readability-simplify-boolean-expr.rst

.. option:: ChainedConditionalAssignment
 
    If `true`, conditional boolean assignments at the end of an ``if/else
    if`` chain will be transformed. Default is `false`.
 
 .. option:: SimplifyDeMorgan
 
    If `true`, DeMorgan's Theorem will be applied to simplify negated
    conjunctions and disjunctions.  Default is `true`.
+
+.. option:: SimplifyDeMorganRelaxed
+
+   If `true`, :option:`SimplifyDeMorgan` will also transform negated 
+   conjunctions and disjunctions where there is no negation on either operand. 
+   Default is `false`.
+
+   When Enabled:
+
+   .. code-block::
+
+      bool X = !(A && B)
+      bool Y = !(A || B)
+
+   Would be transformed to:
+
+   .. code-block::
+
+      bool X = !A || !B
+      bool Y = !A && !B

clang-tools-extra/test/clang-tidy/checkers/readability-simplify-bool-expr-demorgan.cpp

 // RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t
 
+// Check when we can convert !(A Op B) -> !A InvOp !B.
+// RUN: %check_clang_tidy -check-suffixes=",RELAXED" %s \
+// RUN: readability-simplify-boolean-expr %t -- -config="{CheckOptions: [{ \
+// RUN: key: "readability-simplify-boolean-expr.SimplifyDeMorganRelaxed", value: true}]}" --
+
+// Verify warning issued when invalid options are specified.
+// RUN: clang-tidy %s -checks=-*,readability-simplify-boolean-expr -config="{CheckOptions: [ \
+// RUN:   {key: readability-simplify-boolean-expr.SimplifyDeMorgan, value: false}, \
+// RUN:   {key: readability-simplify-boolean-expr.SimplifyDeMorganRelaxed, value: true}]}" \
+// RUN: -- 2>&1 | FileCheck %s -check-prefix=CHECK-BAD-CONFIG \
+// RUN:       -implicit-check-not="{{warning|error}}:"
+
+// CHECK-BAD-CONFIG: warning: readability-simplify-boolean-expr: 'SimplifyDeMorganRelaxed' cannot be enabled without 'SimplifyDeMorgan' enabled
 void eat(bool);
 
 void foo(bool A1, bool A2, bool A3, bool A4) {
   bool X;
+
+  X = !(A1 && A2);
+  X = !(A1 || A2);
+  // CHECK-MESSAGES-RELAXED: :[[@LINE-2]]:7: warning: boolean expression can be simplified by DeMorgan's theorem
+  // CHECK-MESSAGES-RELAXED: :[[@LINE-2]]:7: warning: boolean expression can be simplified by DeMorgan's theorem
+  // CHECK-FIXES-RELAXED: X = !A1 || !A2;
+  // CHECK-FIXES-NEXT-RELAXED: X = !A1 && !A2;
+
   X = !(!A1 || A2);
   X = !(A1 || !A2);
   X = !(!A1 || !A2);
   // CHECK-MESSAGES: :[[@LINE-3]]:7: warning: boolean expression can be simplified by DeMorgan's theorem
   // CHECK-MESSAGES: :[[@LINE-3]]:7: warning: boolean expression can be simplified by DeMorgan's theorem
   // CHECK-MESSAGES: :[[@LINE-3]]:7: warning: boolean expression can be simplified by DeMorgan's theorem
   // CHECK-FIXES: X = A1 && !A2;
   // CHECK-FIXES-NEXT: X = !A1 && A2;