[clang-tidy] Simplify inaccurate erase check

[steveire]

Summary

The normalization of matchers means that this now works in all language
modes.

[njames93]

LG with nit.

clang-tools-extra/clang-tidy/bugprone/InaccurateEraseCheck.cpp

25–27

This seems like a use case for the optionally matcher.

clang-tools-extra/clang-tidy/bugprone/InaccurateEraseCheck.h

 public:
   InaccurateEraseCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, 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;
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 };
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_INACCURATEERASECHECK_H

clang-tools-extra/clang-tidy/bugprone/InaccurateEraseCheck.cpp

 namespace tidy {
 namespace bugprone {
 
 void InaccurateEraseCheck::registerMatchers(MatchFinder *Finder) {
   const auto EndCall =
       callExpr(
           callee(functionDecl(hasAnyName("remove", "remove_if", "unique"))),
           hasArgument(
-              1,
-              anyOf(cxxConstructExpr(has(ignoringImplicit(
-                        cxxMemberCallExpr(callee(cxxMethodDecl(hasName("end"))))
-                            .bind("end")))),
+              1, anyOf(cxxMemberCallExpr(callee(cxxMethodDecl(hasName("end"))))
+                           .bind("end"),
                        anything())))
           .bind("alg");
 
   const auto DeclInStd = type(hasUnqualifiedDesugaredType(
       tagType(hasDeclaration(decl(isInStdNamespace())))));
   Finder->addMatcher(
-      traverse(
-          TK_AsIs,
-          cxxMemberCallExpr(
-              on(anyOf(hasType(DeclInStd), hasType(pointsTo(DeclInStd)))),
-              callee(cxxMethodDecl(hasName("erase"))), argumentCountIs(1),
-              hasArgument(0, has(ignoringImplicit(anyOf(
-                                 EndCall, has(ignoringImplicit(EndCall)))))),
-              unless(isInTemplateInstantiation()))
-              .bind("erase")),
+          hasArgument(0, EndCall))
+          .bind("erase"),
       this);
 }
 
 void InaccurateEraseCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MemberCall =
       Result.Nodes.getNodeAs<CXXMemberCallExpr>("erase");
   const auto *EndExpr =
       Result.Nodes.getNodeAs<CXXMemberCallExpr>("end");

clang-tools-extra/test/clang-tidy/checkers/bugprone-inaccurate-erase.cpp

-// RUN: %check_clang_tidy -std=c++11,c++14 %s bugprone-inaccurate-erase %t
-// FIXME: Fix the checker to work in C++17 mode.
+// RUN: %check_clang_tidy %s bugprone-inaccurate-erase %t
 
 namespace std {
 template <typename T> struct vec_iterator {
   T ptr;
   vec_iterator operator++(int);
 
   template <typename X>
   vec_iterator(const vec_iterator<X> &); // Omit enable_if<...>.