abseil-string-find-str-contains should not propose an edit for the three-parameter version of find().

[tdl-g]

Summary

std::string, std::string_view, and absl::string_view all have a three-parameter version of find()
which has a "count" (or "n") paremeter limiting the size of the substring to search. We don't want
to propose changing to absl::StrContains in those cases. This change fixes that and adds unit tests
to confirm.

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

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"),
+          hasName("find"), parameterCountIs(2),
           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")));
 

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

 class basic_string {
 public:
   basic_string();
   basic_string(const basic_string &);
   basic_string(const C *);
   ~basic_string();
   int find(basic_string s, int pos = 0);
   int find(const C *s, int pos = 0);
+  int find(const C *s, int pos, int n);
   int find(char c, int pos = 0);
   static constexpr size_t npos = -1;
 };
 typedef basic_string<char> string;
 
 // Lightweight standin for std::string_view.
 template <typename C>
 class basic_string_view {
 public:
   basic_string_view();
   basic_string_view(const basic_string_view &);
   basic_string_view(const C *);
   ~basic_string_view();
   int find(basic_string_view s, int pos = 0);
   int find(const C *s, int pos = 0);
+  int find(const C *s, int pos, int n);
   int find(char c, int pos = 0);
   static constexpr size_t npos = -1;
 };
 typedef basic_string_view<char> string_view;
 
 } // namespace std
 
 namespace absl {
 
 // Lightweight standin for absl::string_view.
 class string_view {
 public:
   string_view();
   string_view(const string_view &);
   string_view(const char *);
   ~string_view();
   int find(string_view s, int pos = 0);
   int find(const char *s, int pos = 0);
+  int find(const char *s, int pos, int n);
   int find(char c, int pos = 0);
   static constexpr size_t npos = -1;
 };
 
 } // namespace absl
 
 // Functions that take and return our various string-like types.
 std::string foo_ss(std::string);
void no_nonzero_pos() {
 
   std::string_view ssv;
   ssv.find("a", 2) == std::string_view::npos;
 
   absl::string_view asv;
   asv.find("a", 3) == std::string_view::npos;
 }
 
+// Confirms that it does not match when the count parameter is present.
+void no_count() {
+  std::string ss;
+  ss.find("a", 0, 1) == std::string::npos;
+
+  std::string_view ssv;
+  ssv.find("a", 0, 1) == std::string_view::npos;
+
+  absl::string_view asv;
+  asv.find("a", 0, 1) == std::string_view::npos;
+}
+
 // Confirms that it does not match when it's compared to something other than
 // npos, even if the value is the same as npos.
 void no_non_npos() {
   std::string ss;
   ss.find("a") == 0;
   ss.find("a") == 1;
   ss.find("a") == -1;