[clang-tidy] Recognize single character needles for absl::StrContains.

[ckennelly]

Summary

Commit fbdff6f3ae0b in the Abseil tree adds an overload for
absl::StrContains to accept a single character needle for optimized
lookups.

clang-tools-extra/clang-tidy/abseil/StringFindStrContainsCheck.cpp

 
 using ::clang::transformer::applyFirst;
 using ::clang::transformer::cat;
 using ::clang::transformer::change;
 using ::clang::transformer::makeRule;
 using ::clang::transformer::node;
 using ::clang::transformer::RewriteRule;
 
+AST_MATCHER(Type, isCharType) { return Node.isCharType(); }
+
 static const char DefaultStringLikeClasses[] = "::std::basic_string;"
                                                "::std::basic_string_view;"
                                                "::absl::string_view";
 static const char DefaultAbseilStringsMatchHeader[] = "absl/strings/match.h";
 
 static llvm::Optional<transformer::RewriteRule>
 MakeRule(const LangOptions &LangOpts,
          const ClangTidyCheck::OptionsView &Options) {
const std::string AbseilStringsMatchHeader =
       Options.get("AbseilStringsMatchHeader", DefaultAbseilStringsMatchHeader);
 
   auto StringLikeClass = cxxRecordDecl(hasAnyName(SmallVector<StringRef, 4>(
       StringLikeClassNames.begin(), StringLikeClassNames.end())));
   auto StringType =
       hasUnqualifiedDesugaredType(recordType(hasDeclaration(StringLikeClass)));
   auto CharStarType =
       hasUnqualifiedDesugaredType(pointerType(pointee(isAnyCharacter())));
+  auto CharType = hasUnqualifiedDesugaredType(isCharType());
   auto StringNpos = declRefExpr(
       to(varDecl(hasName("npos"), hasDeclContext(StringLikeClass))));
   auto StringFind = cxxMemberCallExpr(
       callee(cxxMethodDecl(
           hasName("find"),
-          hasParameter(0, parmVarDecl(anyOf(hasType(StringType),
-                                            hasType(CharStarType)))))),
+          hasParameter(
+              0, parmVarDecl(anyOf(hasType(StringType), hasType(CharStarType),
+                                   hasType(CharType)))))),
       on(hasType(StringType)), hasArgument(0, expr().bind("parameter_to_find")),
       anyOf(hasArgument(1, integerLiteral(equals(0))),
             hasArgument(1, cxxDefaultArgExpr())),
       onImplicitObjectArgument(expr().bind("string_being_searched")));
 
   RewriteRule rule = applyFirst(
       {makeRule(binaryOperator(hasOperatorName("=="),
                                hasOperands(ignoringParenImpCasts(StringNpos),

clang-tools-extra/test/clang-tidy/checkers/abseil-string-find-str-contains.cpp

void string_literal_and_char_ptr_tests() {
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
   // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, c);{{$}}
 
   asv.find(cc) == absl::string_view::npos;
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
   // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, cc);{{$}}
 }
 
-// Confirms that it does *not* match when the parameter to find() is a char,
-// because absl::StrContains is not implemented for char.
-void no_char_param_tests() {
+void char_param_tests() {
   std::string ss;
   ss.find('c') == std::string::npos;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
+  // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, 'c');{{$}}
 
   std::string_view ssv;
   ssv.find('c') == std::string_view::npos;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
+  // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ssv, 'c');{{$}}
 
   absl::string_view asv;
   asv.find('c') == absl::string_view::npos;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
+  // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, 'c');{{$}}
 }
 
 #define FOO(a, b, c, d) ((a).find(b) == std::string::npos ? (c) : (d))
 
 // Confirms that it does not match when a macro would be "torn" by the fix.
 void no_tearing_macros() {
   std::string h = "helo";
   FOO(h, "x", 5, 6);