[clang-tidy] Simplify readability checks to not need ignoring* matchers

[njames93]

Please address the format issues.

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

41–42

This allOf matcher only contains 1 sub matcher so is breaking the build.

[steveire]

Update

[njames93]

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

31 ↗

(On Diff #331130)

Please rebase, this check has since been removed from clang-tidy.

[steveire]

Rebase

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

 
 private:
   bool checkStmt(const ast_matchers::MatchFinder::MatchResult &Result,
                  const Stmt *S, SourceLocation StartLoc,
                  SourceLocation EndLocHint = SourceLocation());
   template <typename IfOrWhileStmt>
   SourceLocation findRParenLoc(const IfOrWhileStmt *S, const SourceManager &SM,
                                const ASTContext *Context);
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 
 private:
   std::set<const Stmt *> ForceBracesStmts;
   const unsigned ShortStatementLines;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_BRACESAROUNDSTATEMENTSCHECK_H

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

: ClangTidyCheck(Name, Context),
       ShortStatementLines(Options.get("ShortStatementLines", 0U)) {}
 
 void BracesAroundStatementsCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "ShortStatementLines", ShortStatementLines);
 }
 
 void BracesAroundStatementsCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(
-      ifStmt(unless(allOf(isConstexpr(), isInTemplateInstantiation())))
-          .bind("if"),
-      this);
+  Finder->addMatcher(ifStmt().bind("if"), this);
   Finder->addMatcher(whileStmt().bind("while"), this);
   Finder->addMatcher(doStmt().bind("do"), this);
   Finder->addMatcher(forStmt().bind("for"), this);
   Finder->addMatcher(cxxForRangeStmt().bind("for-range"), this);
 }
 
 void BracesAroundStatementsCheck::check(
     const MatchFinder::MatchResult &Result) {

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

 public:
   ElseAfterReturnCheck(StringRef Name, ClangTidyContext *Context);
 
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) 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;
+  }
 
   using ConditionalBranchMap =
       llvm::DenseMap<FileID, SmallVector<SourceRange, 1>>;
 
 private:
   const bool WarnOnUnfixable;
   const bool WarnOnConditionVariables;
   ConditionalBranchMap PPConditionals;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_ELSEAFTERRETURNCHECK_H

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

void ElseAfterReturnCheck::registerPPCallbacks(const SourceManager &SM,
                                                Preprocessor *ModuleExpanderPP) {
   PP->addPPCallbacks(
       std::make_unique<PPConditionalCollector>(this->PPConditionals, SM));
 }
 
 void ElseAfterReturnCheck::registerMatchers(MatchFinder *Finder) {
   const auto InterruptsControlFlow = stmt(anyOf(
       returnStmt().bind(InterruptingStr), continueStmt().bind(InterruptingStr),
-      breakStmt().bind(InterruptingStr),
-      expr(ignoringImplicit(cxxThrowExpr().bind(InterruptingStr)))));
+      breakStmt().bind(InterruptingStr), cxxThrowExpr().bind(InterruptingStr)));
   Finder->addMatcher(
       compoundStmt(
           forEach(ifStmt(unless(isConstexpr()),
                          hasThen(stmt(
                              anyOf(InterruptsControlFlow,
                                    compoundStmt(has(InterruptsControlFlow))))),
                          hasElse(stmt().bind("else")))
                       .bind("if")))

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

InconsistentDeclarationParameterNameCheck(StringRef Name,
                                             ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context),
         IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)),
         Strict(Options.getLocalOrGlobal("Strict", false)) {}
 
   void storeOptions(ClangTidyOptions::OptionMap &Opts) 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:
   void markRedeclarationsAsVisited(const FunctionDecl *FunctionDeclaration);
 
   llvm::DenseSet<const FunctionDecl *> VisitedDeclarations;
   const bool IgnoreMacros;
   const bool Strict;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_INCONSISTENT_DECLARATION_PARAMETER_NAME_H

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

 void InconsistentDeclarationParameterNameCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "IgnoreMacros", IgnoreMacros);
   Options.store(Opts, "Strict", Strict);
 }
 
 void InconsistentDeclarationParameterNameCheck::registerMatchers(
     MatchFinder *Finder) {
-  Finder->addMatcher(functionDecl(unless(isImplicit()), hasOtherDeclarations())
-                         .bind("functionDecl"),
+  Finder->addMatcher(functionDecl(hasOtherDeclarations()).bind("functionDecl"),
                      this);
 }
 
 void InconsistentDeclarationParameterNameCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *OriginalDeclaration =
       Result.Nodes.getNodeAs<FunctionDecl>("functionDecl");
 

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

 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/readability-misleading-indentation.html
 class MisleadingIndentationCheck : public ClangTidyCheck {
 public:
   MisleadingIndentationCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   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:
   void danglingElseCheck(const SourceManager &SM, ASTContext *Context,
                          const IfStmt *If);
   void missingBracesCheck(const SourceManager &SM, const CompoundStmt *CStmt);
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_MISLEADING_INDENTATION_H

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

if (SM.getExpansionColumnNumber(InnerLoc) ==
       diag(OuterLoc, "did you mean this line to be inside this '%0'",
            DiagnosticIDs::Note)
           << StmtNames[StmtKind];
     }
   }
 }
 
 void MisleadingIndentationCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(
-      ifStmt(allOf(hasElse(stmt()),
-                   unless(allOf(isConstexpr(), isInTemplateInstantiation()))))
-          .bind("if"),
-      this);
+  Finder->addMatcher(ifStmt(hasElse(stmt())).bind("if"), this);
   Finder->addMatcher(
       compoundStmt(has(stmt(anyOf(ifStmt(), forStmt(), whileStmt()))))
           .bind("compound"),
       this);
 }
 
 void MisleadingIndentationCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *If = Result.Nodes.getNodeAs<IfStmt>("if"))

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

 ///
 /// Corresponding cpplint.py check name: 'readability/function'.
 class NamedParameterCheck : public ClangTidyCheck {
 public:
   NamedParameterCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   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;
+  }
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_NAMEDPARAMETERCHECK_H

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

 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
 void NamedParameterCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
-  Finder->addMatcher(functionDecl(unless(isInstantiated())).bind("decl"), this);
+  Finder->addMatcher(functionDecl().bind("decl"), this);
 }
 
 void NamedParameterCheck::check(const MatchFinder::MatchResult &Result) {
   const SourceManager &SM = *Result.SourceManager;
   const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("decl");
   SmallVector<std::pair<const FunctionDecl *, unsigned>, 4> UnnamedParams;
 
-  // Ignore implicitly generated members.
-  if (Function->isImplicit())
-    return;
-
   // Ignore declarations without a definition if we're not dealing with an
   // overriden method.
   const FunctionDecl *Definition = nullptr;
   if ((!Function->isDefined(Definition) || Function->isDefaulted() ||
        Function->isDeleted()) &&
       (!isa<CXXMethodDecl>(Function) ||
        cast<CXXMethodDecl>(Function)->size_overridden_methods() == 0))
     return;

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

 /// http://clang.llvm.org/extra/clang-tidy/checks/readability-non-const-parameter.html
 class NonConstParameterCheck : public ClangTidyCheck {
 public:
   NonConstParameterCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void onEndOfTranslationUnit() override;
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 
 private:
   /// Parameter info.
   struct ParmInfo {
     /// Is function parameter referenced?
     bool IsReferenced;
 
     /// Can function parameter be const?

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

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
 void NonConstParameterCheck::registerMatchers(MatchFinder *Finder) {
   // Add parameters to Parameters.
-  Finder->addMatcher(parmVarDecl(unless(isInstantiated())).bind("Parm"), this);
+  Finder->addMatcher(parmVarDecl().bind("Parm"), this);
 
   // C++ constructor.
   Finder->addMatcher(cxxConstructorDecl().bind("Ctor"), this);
 
   // Track unused parameters, there is Wunused-parameter about unused
   // parameters.
   Finder->addMatcher(declRefExpr().bind("Ref"), this);
 
   // Analyse parameter usage in function.
-  Finder->addMatcher(
-      traverse(TK_AsIs,
-               stmt(anyOf(unaryOperator(hasAnyOperatorName("++", "--")),
+  Finder->addMatcher(stmt(anyOf(unaryOperator(hasAnyOperatorName("++", "--")),
                                 binaryOperator(), callExpr(), returnStmt(),
                                 cxxConstructExpr()))
-                   .bind("Mark")),
+                         .bind("Mark"),
                      this);
   Finder->addMatcher(varDecl(hasInitializer(anything())).bind("Mark"), this);
 }
 
 void NonConstParameterCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *Parm = Result.Nodes.getNodeAs<ParmVarDecl>("Parm")) {
     if (const DeclContext *D = Parm->getParentFunctionOrMethod()) {
       if (const auto *M = dyn_cast<CXXMethodDecl>(D)) {
         if (M->isVirtual() || M->size_overridden_methods() != 0)

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

 /// http://clang.llvm.org/extra/clang-tidy/checks/readability-redundant-control-flow.html
 class RedundantControlFlowCheck : public ClangTidyCheck {
 public:
   RedundantControlFlowCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   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:
   void
   checkRedundantReturn(const ast_matchers::MatchFinder::MatchResult &Result,
                        const CompoundStmt *Block);
 
   void
   checkRedundantContinue(const ast_matchers::MatchFinder::MatchResult &Result,
                          const CompoundStmt *Block);

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

 bool isLocationInMacroExpansion(const SourceManager &SM, SourceLocation Loc) {
   return SM.isMacroBodyExpansion(Loc) || SM.isMacroArgExpansion(Loc);
 }
 
 } // namespace
 
 void RedundantControlFlowCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
-      functionDecl(
-          isDefinition(), returns(voidType()),
-          has(compoundStmt(hasAnySubstatement(returnStmt(unless(has(expr())))))
+      functionDecl(isDefinition(), returns(voidType()),
+                   hasBody(compoundStmt(hasAnySubstatement(
+                                            returnStmt(unless(has(expr())))))
                                .bind("return"))),
       this);
   Finder->addMatcher(
       mapAnyOf(forStmt, cxxForRangeStmt, whileStmt, doStmt)
           .with(hasBody(compoundStmt(hasAnySubstatement(continueStmt()))
                             .bind("continue"))),
       this);
 }
 

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

 public:
   SimplifySubscriptExprCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap& Opts) override;
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 
 private:
   const std::vector<std::string> Types;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_SIMPLIFYSUBSCRIPTEXPRCHECK_H

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

 }
 
 void SimplifySubscriptExprCheck::registerMatchers(MatchFinder *Finder) {
   const auto TypesMatcher = hasUnqualifiedDesugaredType(
       recordType(hasDeclaration(cxxRecordDecl(hasAnyName(
           llvm::SmallVector<StringRef, 8>(Types.begin(), Types.end()))))));
 
   Finder->addMatcher(
-      arraySubscriptExpr(hasBase(ignoringParenImpCasts(
+      arraySubscriptExpr(hasBase(
           cxxMemberCallExpr(
               has(memberExpr().bind("member")),
               on(hasType(qualType(
                   unless(anyOf(substTemplateTypeParmType(),
                                hasDescendant(substTemplateTypeParmType()))),
                   anyOf(TypesMatcher, pointerType(pointee(TypesMatcher)))))),
               callee(namedDecl(hasName("data"))))
-              .bind("call")))),
+              .bind("call"))),
       this);
 }
 
 void SimplifySubscriptExprCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Call = Result.Nodes.getNodeAs<CXXMemberCallExpr>("call");
   if (Result.Context->getSourceManager().isMacroBodyExpansion(
           Call->getExprLoc()))
     return;

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

public:
   StaticAccessedThroughInstanceCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context),
         NameSpecifierNestingThreshold(
             Options.get("NameSpecifierNestingThreshold", 3U)) {}
 
   void storeOptions(ClangTidyOptions::OptionMap &Opts) 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:
   const unsigned NameSpecifierNestingThreshold;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_STATIC_ACCESSED_THROUGH_INSTANCE_H

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

void StaticAccessedThroughInstanceCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "NameSpecifierNestingThreshold",
                 NameSpecifierNestingThreshold);
 }
 
 void StaticAccessedThroughInstanceCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       memberExpr(hasDeclaration(anyOf(cxxMethodDecl(isStaticStorageClass()),
-                                      varDecl(hasStaticStorageDuration()))),
-                 unless(isInTemplateInstantiation()))
+                                      varDecl(hasStaticStorageDuration()))))
           .bind("memberExpression"),
       this);
 }
 
 void StaticAccessedThroughInstanceCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *MemberExpression =
       Result.Nodes.getNodeAs<MemberExpr>("memberExpression");

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

 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/readability-uniqueptr-delete-release.html
 class UniqueptrDeleteReleaseCheck : public ClangTidyCheck {
 public:
   UniqueptrDeleteReleaseCheck(StringRef Name, ClangTidyContext *Context);
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 
 private:
   const bool PreferResetCall;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_UNIQUEPTR_DELETE_RELEASE_H

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

void UniqueptrDeleteReleaseCheck::registerMatchers(MatchFinder *Finder) {
 
   auto UniquePtrWithDefaultDelete = classTemplateSpecializationDecl(
       hasName("::std::unique_ptr"),
       hasTemplateArgument(1, refersToType(hasDeclaration(cxxRecordDecl(
                                  hasName("::std::default_delete"))))));
 
   Finder->addMatcher(
       cxxDeleteExpr(
           unless(isInTemplateInstantiation()),
-          has(expr(ignoringParenImpCasts(
-              cxxMemberCallExpr(
-                  callee(
-                      memberExpr(hasObjectExpression(allOf(
-                                     unless(isTypeDependent()),
-                                     anyOf(hasType(UniquePtrWithDefaultDelete),
-                                           hasType(pointsTo(
-                                               UniquePtrWithDefaultDelete))))),
+          has(cxxMemberCallExpr(
+                  callee(memberExpr(hasObjectExpression(anyOf(
+                                        hasType(UniquePtrWithDefaultDelete),
+                                            UniquePtrWithDefaultDelete)))),
                                     member(cxxMethodDecl(hasName("release"))))
                              .bind("release_expr")))
-                  .bind("release_call")))))
+                  .bind("release_call")))
           .bind("delete"),
       this);
 }
 
 void UniqueptrDeleteReleaseCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *DeleteExpr = Result.Nodes.getNodeAs<CXXDeleteExpr>("delete");
   const auto *ReleaseExpr = Result.Nodes.getNodeAs<MemberExpr>("release_expr");

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

 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/readability-uppercase-literal-suffix.html
 class UppercaseLiteralSuffixCheck : public ClangTidyCheck {
 public:
   UppercaseLiteralSuffixCheck(StringRef Name, ClangTidyContext *Context);
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 
 private:
   template <typename LiteralType>
   bool checkBoundMatch(const ast_matchers::MatchFinder::MatchResult &Result);
 
   const std::vector<std::string> NewSuffixes;
   const bool IgnoreMacros;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_UPPERCASELITERALSUFFIXCHECK_H

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

Options.store(Opts, "NewSuffixes",
                 utils::options::serializeStringList(NewSuffixes));
   Options.store(Opts, "IgnoreMacros", IgnoreMacros);
 }
 
 void UppercaseLiteralSuffixCheck::registerMatchers(MatchFinder *Finder) {
   // Sadly, we can't check whether the literal has suffix or not.
   // E.g. i32 suffix still results in 'BuiltinType::Kind::Int'.
   // And such an info is not stored in the *Literal itself.
-  Finder->addMatcher(traverse(TK_AsIs,
+  Finder->addMatcher(
       stmt(eachOf(integerLiteral().bind(IntegerLiteralCheck::Name),
                   floatLiteral().bind(FloatingLiteralCheck::Name)),
            unless(anyOf(hasParent(userDefinedLiteral()),
-                        hasAncestor(isImplicit()),
-                        hasAncestor(substNonTypeTemplateParmExpr()))))),
+                        hasAncestor(substNonTypeTemplateParmExpr())))),
       this);
 }
 
 template <typename LiteralType>
 bool UppercaseLiteralSuffixCheck::checkBoundMatch(
     const MatchFinder::MatchResult &Result) {
   const auto *Literal =
       Result.Nodes.getNodeAs<typename LiteralType::type>(LiteralType::Name);