[clang-tidy] performance-faster-string-find string-view

[njames93]

Summary

Extend the default string like classes to include std::basic_string_view.

[aaron.ballman]

clang-tools-extra/docs/clang-tidy/checks/performance-faster-string-find.rst

27

I'm not certain how to read that last sentence (I read it as: the list of methods is considered fixed and cannot be extended, which seems like a bad interpretation). Maybe it's talking about fix-its instead?

Regardless, the typo consired -> consider should be fixed.

[njames93]

clang-tools-extra/docs/clang-tidy/checks/performance-faster-string-find.rst

27

That typo was here before I got here, but I think it means The list of methods inside the classes to consider are fixed. In other words you can't make the check detect calls to ::MyStringClass::MyFind().

Does The list of methods inside the classes to consider are fixed. sound like a good replacement for the it?

[aaron.ballman]

clang-tools-extra/docs/clang-tidy/checks/performance-faster-string-find.rst

27

Oh, I understand now, thank you! The "fixed" keeps throwing me though, so I wonder if this is better still: The check will only consider member functions named "find", "rfind", "find_first_of", "find_first_not_of", "find_last_of", or "find_last_not_of" within these classes. or something?

[njames93]

Update docs

[aaron.ballman]

LGTM!

clang-tools-extra/clang-tidy/performance/FasterStringFindCheck.cpp

 }
 
 } // namespace
 
 FasterStringFindCheck::FasterStringFindCheck(StringRef Name,
                                              ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       StringLikeClasses(utils::options::parseStringList(
-          Options.get("StringLikeClasses", "std::basic_string"))) {}
+          Options.get("StringLikeClasses",
+                      "::std::basic_string;::std::basic_string_view"))) {}
 
 void FasterStringFindCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "StringLikeClasses",
                 utils::options::serializeStringList(StringLikeClasses));
 }
 
 void FasterStringFindCheck::registerMatchers(MatchFinder *Finder) {
   const auto SingleChar =

clang-tools-extra/docs/ReleaseNotes.rst

 - New alias :doc:`cert-str34-c
   <clang-tidy/checks/cert-str34-c>` to
   :doc:`bugprone-signed-char-misuse
   <clang-tidy/checks/bugprone-signed-char-misuse>` was added.
 
 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+- Improved :doc:`performance-faster-string-find
+  <clang-tidy/checks/performance-faster-string-find>` check.
+
+  Now checks ``std::basic_string_view`` by default.
+
 - Improved :doc:`readability-identifier-naming
   <clang-tidy/checks/readability-identifier-naming>` check.
 
   Now able to rename member references in class template definitions with 
   explicit access.
 
 - Improved :doc:`readability-qualified-auto
   <clang-tidy/checks/readability-qualified-auto>` check now supports a

clang-tools-extra/docs/clang-tidy/checks/performance-faster-string-find.rst

.. code-block:: c++
   str.find('A');
 
 Options
 -------
 
 .. option:: StringLikeClasses
 
    Semicolon-separated list of names of string-like classes. By default only
-   ``std::basic_string`` is considered. The list of methods to consired is
-   fixed.
+   ``::std::basic_string`` and ``::std::basic_string_view`` are considered. 
+   The check will only consider member functions named ``find``, ``rfind``, 
+   ``find_first_of``, ``find_first_not_of``, ``find_last_of``, or 
+   ``find_last_not_of`` within these classes.
 

clang-tools-extra/test/clang-tidy/checkers/performance-faster-string-find.cpp

-// RUN: %check_clang_tidy %s performance-faster-string-find %t -- \
+// RUN: %check_clang_tidy %s performance-faster-string-find %t
+// RUN: %check_clang_tidy -check-suffix=CUSTOM %s performance-faster-string-find %t -- \
 // RUN:   -config="{CheckOptions: \
 // RUN:             [{key: performance-faster-string-find.StringLikeClasses, \
-// RUN:               value: 'std::basic_string; ::llvm::StringRef;'}]}" --
+// RUN:               value: '::llvm::StringRef;'}]}"
 
 namespace std {
 template <typename Char>
 struct basic_string {
   int find(const Char *, int = 0) const;
   int find(const Char *, int, int) const;
   int rfind(const Char *) const;
   int find_first_of(const Char *) const;
   int find_first_not_of(const Char *) const;
   int find_last_of(const Char *) const;
   int find_last_not_of(const Char *) const;
 };
 
 typedef basic_string<char> string;
 typedef basic_string<wchar_t> wstring;
+
+template <typename Char>
+struct basic_string_view {
+  int find(const Char *, int = 0) const;
+  int find(const Char *, int, int) const;
+  int rfind(const Char *) const;
+  int find_first_of(const Char *) const;
+  int find_first_not_of(const Char *) const;
+  int find_last_of(const Char *) const;
+  int find_last_not_of(const Char *) const;
+};
+
+typedef basic_string_view<char> string_view;
+typedef basic_string_view<wchar_t> wstring_view;
 }  // namespace std
 
 namespace llvm {
 struct StringRef {
   int find(const char *) const;
 };
 }  // namespace llvm
 
void StringFind() {
   WStr.find(L"n");
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: 'find' called with a string literal
   // CHECK-FIXES: Str.find(L'n');
   // Even with unicode that fits in one wide char.
   WStr.find(L"\x3A9");
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: 'find' called with a string literal
   // CHECK-FIXES: Str.find(L'\x3A9');
 
+  // std::string_view and std::wstring_view should work.
+  std::string_view StrView;
+  StrView.find("n");
+  // CHECK-MESSAGES: [[@LINE-1]]:16: warning: 'find' called with a string literal
+  // CHECK-FIXES: StrView.find('n');
+  std::wstring_view WStrView;
+
+  WStrView.find(L"n");
+  // CHECK-MESSAGES: [[@LINE-1]]:17: warning: 'find' called with a string literal
+  // CHECK-FIXES: WStrView.find(L'n');
+  WStrView.find(L"\x3A9");
+  // CHECK-MESSAGES: [[@LINE-1]]:17: warning: 'find' called with a string literal
+  // CHECK-FIXES: WStrView.find(L'\x3A9');
+
   // Also with other types, but only if it was specified in the options.
   llvm::StringRef sr;
   sr.find("x");
-  // CHECK-MESSAGES: [[@LINE-1]]:11: warning: 'find' called with a string literal
-  // CHECK-FIXES: sr.find('x');
+  // CHECK-MESSAGES-CUSTOM: [[@LINE-1]]:11: warning: 'find' called with a string literal
+  // CHECK-FIXES-CUSTOM: sr.find('x');
   NotStringRef nsr;
   nsr.find("x");
 }
 
 
 template <typename T>
 int FindTemplateDependant(T value) {
   return value.find("A");