[clang-tidy]: string_view of temporary string

[jbcoe]

Summary

Find instances where a string_view is constructed from a temporary string and replace the string_view with a string.

[dblaikie]

Any way to/would it be worth broadening this with an annotation or some
such (or just a lost for now) of types that maintain references to their
ctor params? (Eg: llvm arrayref, etc)

[alexfh]

As David noted, there are other similar classes like llvm::StringRef, llvm::ArraryRef, gsl::span, StringPiece (in various Google projects, e.g. https://github.com/google/re2/blob/master/re2/stringpiece.h) and numerous other in different code bases. I think, we should make the check sufficiently configurable to be able to support other similar classes.

clang-tidy/misc/MiscTidyModule.cpp

36

Please include the full context in the diff (see http://llvm.org/docs/Phabricator.html).

89

Please use CamelCase for class names: StringViewOfTemporaryCheck.

90

Please only use dashes as delimiters in the check name: misc-string-view-of-temporary.

[jbcoe]

rendered obsolete by http://reviews.llvm.org/D17811

clang-tidy/misc/CMakeLists.txt

   SizeofContainerCheck.cpp
   StaticAssertCheck.cpp
   StringIntegerAssignmentCheck.cpp
+  StringViewOfTemporaryCheck.cpp
   SuspiciousSemicolonCheck.cpp
   SwappedArgumentsCheck.cpp
   ThrowByValueCatchByReferenceCheck.cpp

clang-tidy/misc/MiscTidyModule.cpp

 #include "SizeofContainerCheck.h"
 #include "StaticAssertCheck.h"
 #include "StringIntegerAssignmentCheck.h"
+#include "StringViewOfTemporaryCheck.h"
 #include "SuspiciousSemicolonCheck.h"
 #include "SwappedArgumentsCheck.h"
 #include "ThrowByValueCatchByReferenceCheck.h"

         "misc-static-assert");
     CheckFactories.registerCheck<StringIntegerAssignmentCheck>(
         "misc-string-integer-assignment");
+    CheckFactories.registerCheck<String_viewOfTemporaryCheck>(
+        "misc-string_view-of-temporary");
     CheckFactories.registerCheck<SuspiciousSemicolonCheck>(
         "misc-suspicious-semicolon");
     CheckFactories.registerCheck<SwappedArgumentsCheck>(

clang-tidy/misc/StringViewOfTemporaryCheck.h

+//===--- String_viewOfTemporaryCheck.h - clang-tidy--------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STRING_VIEW_OF_TEMPORARY_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STRING_VIEW_OF_TEMPORARY_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace misc {
+
+/// Find non-temporary string_views constructed from temporary strings.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/misc-string_view-of-temporary.html
+class String_viewOfTemporaryCheck : public ClangTidyCheck {
+public:
+  String_viewOfTemporaryCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace misc
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STRING_VIEW_OF_TEMPORARY_H

clang-tidy/misc/StringViewOfTemporaryCheck.cpp

+//===--- StringViewOfTemporaryCheck.cpp - clang-tidy----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "StringViewOfTemporaryCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace misc {
+
+namespace {
+
+AST_MATCHER(RecordDecl, isStdString) {
+  return Node.isInStdNamespace() && (Node.getName() == "string");
+}
+
+AST_MATCHER(RecordDecl, isStdStringView) {
+  return Node.isInStdNamespace() && (Node.getName() == "string_view");
+}
+
+} // end namespace
+
+void String_viewOfTemporaryCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(
+      varDecl(has(cxxConstructExpr(hasDescendant(materializeTemporaryExpr(
+                  hasType(recordDecl(isStdString())))))),
+              hasType(recordDecl(isStdStringView())))
+          .bind("sv-temp"),
+      this);
+}
+
+void String_viewOfTemporaryCheck::check(
+    const MatchFinder::MatchResult &Result) {
+  const auto *MatchedDecl = Result.Nodes.getNodeAs<VarDecl>("sv-temp");
+
+  const auto TypeLoc =
+      MatchedDecl->getTypeSourceInfo()->getTypeLoc().getSourceRange();
+
+  diag(MatchedDecl->getLocation(),
+       "string_view %0 is constructed from a temporary string")
+      << MatchedDecl << FixItHint::CreateReplacement(TypeLoc, "std::string");
+}
+
+} // namespace misc
+} // namespace tidy
+} // namespace clang

docs/clang-tidy/checks/list.rst

    misc-sizeof-container
    misc-static-assert
    misc-string-integer-assignment
+   misc-string_view-of-temporary
    misc-suspicious-semicolon
    misc-swapped-arguments
    misc-throw-by-value-catch-by-reference

docs/clang-tidy/checks/misc-string_view-of-temporary.rst

+.. title:: clang-tidy - misc-string_view-of-temporary
+
+misc-string_view-of-temporary
+=============================
+
+Find non-temporary ``string_view``s constructed from temporary strings and
+replace them with ``std::string``s.
+
+The following construction of a ``string_view`` constructs a view of a
+temporary object: 
+
+.. code:: c++
+
+  std::string f();
+
+  std::string_view s(f());
+
+The fix replaces the ``std::string_view`` with an ``std::string``:
+
+.. code:: c++
+
+  std::string f();
+
+  std::string s(f());
+

test/clang-tidy/misc-string_view-of-temporary.cpp

+// RUN: %check_clang_tidy %s misc-string_view-of-temporary %t
+
+namespace std {
+inline namespace implementation {
+class string {
+public:
+  string(const char *);
+};
+
+class string_view {
+public:
+  string_view(const string &);
+  string_view(const char*);
+};
+}
+}
+
+using std::string;
+using std::string_view;
+
+string f();
+void g(string_view);
+void h()
+{
+  string_view sv(f());
+// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: string_view 'sv' is constructed from a temporary string [misc-string_view-of-temporary]
+// CHECK-FIXES: std::string sv(f());
+  g(f());
+  auto s = f();
+  string_view sv2(s);
+  string_view sv3("char[] construction");
+}
+