[clang-tidy] Simplify boolean expr check

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

 /// http://clang.llvm.org/extra/clang-tidy/checks/readability-simplify-boolean-expr.html
 class SimplifyBooleanExprCheck : public ClangTidyCheck {
 public:
   SimplifyBooleanExprCheck(StringRef Name, ClangTidyContext *Context);
 
   void storeOptions(ClangTidyOptions::OptionMap &Options) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 
 private:
   class Visitor;
 
   void reportBinOp(const ast_matchers::MatchFinder::MatchResult &Result,
                    const BinaryOperator *Op);
 
   void matchBoolCondition(ast_matchers::MatchFinder *Finder, bool Value,

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

if (const auto *Negated = Result.Nodes.getNodeAs<UnaryOperator>(Id)) {
     if (Negated->getOpcode() == UO_LNot &&
         isa<CXXBoolLiteralExpr>(Negated->getSubExpr()))
       return Negated->getBeginLoc().isMacroID() ? nullptr : Negated;
   }
   return nullptr;
 }
 
 internal::BindableMatcher<Stmt> literalOrNegatedBool(bool Value) {
-  return expr(anyOf(cxxBoolLiteral(equals(Value)),
-                    unaryOperator(hasUnaryOperand(ignoringParenImpCasts(
-                                      cxxBoolLiteral(equals(!Value)))),
-                                  hasOperatorName("!"))));
+  return expr(
+      anyOf(cxxBoolLiteral(equals(Value)),
+            unaryOperator(hasUnaryOperand(cxxBoolLiteral(equals(!Value))),
 }
 
 internal::Matcher<Stmt> returnsBool(bool Value, StringRef Id = "ignored") {
   auto SimpleReturnsBool = returnStmt(has(literalOrNegatedBool(Value).bind(Id)))
                                .bind("returns-bool");
   return anyOf(SimpleReturnsBool,
                compoundStmt(statementCountIs(1), has(SimpleReturnsBool)));
 }
default:
       break;
   }
 }
 
 void SimplifyBooleanExprCheck::matchBoolCondition(MatchFinder *Finder,
                                                   bool Value,
                                                   StringRef BooleanId) {
   Finder->addMatcher(
-      ifStmt(unless(isInTemplateInstantiation()),
-             hasCondition(literalOrNegatedBool(Value).bind(BooleanId)))
+      ifStmt(hasCondition(literalOrNegatedBool(Value).bind(BooleanId)))
           .bind(IfStmtId),
       this);
 }
 
 void SimplifyBooleanExprCheck::matchTernaryResult(MatchFinder *Finder,
                                                   bool Value,
                                                   StringRef TernaryId) {
   Finder->addMatcher(
-      conditionalOperator(unless(isInTemplateInstantiation()),
-                          hasTrueExpression(literalOrNegatedBool(Value)),
+      conditionalOperator(hasTrueExpression(literalOrNegatedBool(Value)),
                           hasFalseExpression(literalOrNegatedBool(!Value)))
           .bind(TernaryId),
       this);
 }
 
 void SimplifyBooleanExprCheck::matchIfReturnsBool(MatchFinder *Finder,
                                                   bool Value, StringRef Id) {
   if (ChainedConditionalReturn)
-    Finder->addMatcher(ifStmt(unless(isInTemplateInstantiation()),
-                              hasThen(returnsBool(Value, ThenLiteralId)),
+    Finder->addMatcher(ifStmt(hasThen(returnsBool(Value, ThenLiteralId)),
                               hasElse(returnsBool(!Value)))
                            .bind(Id),
                        this);
   else
-    Finder->addMatcher(ifStmt(unless(isInTemplateInstantiation()),
-                              unless(hasParent(ifStmt())),
+    Finder->addMatcher(ifStmt(unless(hasParent(ifStmt())),
                               hasThen(returnsBool(Value, ThenLiteralId)),
                               hasElse(returnsBool(!Value)))
                            .bind(Id),
                        this);
 }
 
 void SimplifyBooleanExprCheck::matchIfAssignsBool(MatchFinder *Finder,
                                                   bool Value, StringRef Id) {
   auto VarAssign = declRefExpr(hasDeclaration(decl().bind(IfAssignVarId)));
   auto VarRef = declRefExpr(hasDeclaration(equalsBoundNode(IfAssignVarId)));
   auto MemAssign = memberExpr(hasDeclaration(decl().bind(IfAssignVarId)));
   auto MemRef = memberExpr(hasDeclaration(equalsBoundNode(IfAssignVarId)));
   auto SimpleThen =
       binaryOperator(hasOperatorName("="), hasLHS(anyOf(VarAssign, MemAssign)),
                      hasLHS(expr().bind(IfAssignVariableId)),
                      hasRHS(literalOrNegatedBool(Value).bind(IfAssignLocId)));
   auto Then = anyOf(SimpleThen, compoundStmt(statementCountIs(1),
                                              hasAnySubstatement(SimpleThen)));
   auto SimpleElse =
       binaryOperator(hasOperatorName("="), hasLHS(anyOf(VarRef, MemRef)),
                      hasRHS(literalOrNegatedBool(!Value)));
   auto Else = anyOf(SimpleElse, compoundStmt(statementCountIs(1),
                                              hasAnySubstatement(SimpleElse)));
   if (ChainedConditionalAssignment)
-    Finder->addMatcher(ifStmt(unless(isInTemplateInstantiation()),
-                              hasThen(Then), hasElse(Else))
-                           .bind(Id),
-                       this);
+    Finder->addMatcher(ifStmt(hasThen(Then), hasElse(Else)).bind(Id), this);
   else
-    Finder->addMatcher(ifStmt(unless(isInTemplateInstantiation()),
-                              unless(hasParent(ifStmt())), hasThen(Then),
-                              hasElse(Else))
-                           .bind(Id),
-                       this);
+    Finder->addMatcher(
+        ifStmt(unless(hasParent(ifStmt())), hasThen(Then), hasElse(Else))
 }
 
 void SimplifyBooleanExprCheck::matchCompoundIfReturnsBool(MatchFinder *Finder,
                                                           bool Value,
                                                           StringRef Id) {
   Finder->addMatcher(
       compoundStmt(
-          unless(isInTemplateInstantiation()),
           hasAnySubstatement(
               ifStmt(hasThen(returnsBool(Value)), unless(hasElse(stmt())))),
-          hasAnySubstatement(returnStmt(has(ignoringParenImpCasts(
-                                            literalOrNegatedBool(!Value))))
+          hasAnySubstatement(returnStmt(has(literalOrNegatedBool(!Value)))
                                  .bind(CompoundReturnId)))
           .bind(Id),
       this);
 }
 
 void SimplifyBooleanExprCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "ChainedConditionalReturn", ChainedConditionalReturn);
   Options.store(Opts, "ChainedConditionalAssignment",