Disallow StringRef assignment from temporary std::strings.

[jordan_rose]

Summary

Similar to D25446, this prevents accidentally referring to temporary storage that goes out of scope by the end of the statement:

someStringRef = getStringByValue();
someStringRef = (Twine("-") + otherString).str();

Note that once again the constructor still has this problem:

StringRef someStringRef = getStringByValue();

because once again we occasionally rely on this in calls:

takesStringRef(getStringByValue());
takesStringRef(Twine("-") + otherString);

Still, it's a step, and it caught one real problem in Clang and one in Swift.

Depends on D26317

[jordan_rose]

Approved by Duncan via email.

[jordan_rose]

Committed in r286139, accidentally omitting the tests. Tests added in r286141.

include/llvm/ADT/StringRef.h

public:
     /// @name Operator Overloads
     /// @{
 
     char operator[](size_t Index) const {
       assert(Index < Length && "Invalid index!");
       return Data[Index];
     }
 
+    /// Disallow accidental assignment from a temporary std::string.
+    ///
+    /// The declaration here is extra complicated so that `stringRef = {}`
+    /// and `stringRef = "abc"` continue to select the move assignment operator.
+    template <typename T>
+    typename std::enable_if<std::is_same<T, std::string>::value,
+                            StringRef>::type &
+    operator=(T &&Str) = delete;
+
     /// @}
     /// @name Type Conversions
     /// @{
 
     operator std::string() const {
       return str();
     }
 

unittests/ADT/StringRefTest.cpp

 std::ostream &operator<<(std::ostream &OS,
                          const std::pair<StringRef, StringRef> &P) {
   OS << "(" << P.first << ", " << P.second << ")";
   return OS;
 }
 
 }
 
+// Check that we can't accidentally assign a temporary std::string to a
+// StringRef. (Unfortunately we can't make use of the same thing with
+// constructors.)
+//
+// Disable this check under MSVC; even MSVC 2015 isn't consistent between
+// std::is_assignable and actually writing such an assignment.
+#if !defined(_MSC_VER)
+static_assert(
+    !std::is_assignable<StringRef, std::string>::value,
+    "Assigning from prvalue std::string");
+static_assert(
+    !std::is_assignable<StringRef, std::string &&>::value,
+    "Assigning from xvalue std::string");
+static_assert(
+    std::is_assignable<StringRef, std::string &>::value,
+    "Assigning from lvalue std::string");
+static_assert(
+    std::is_assignable<StringRef, const char *>::value,
+    "Assigning from prvalue C string");
+static_assert(
+    std::is_assignable<StringRef, const char * &&>::value,
+    "Assigning from xvalue C string");
+static_assert(
+    std::is_assignable<StringRef, const char * &>::value,
+    "Assigning from lvalue C string");
+#endif
+
+
 namespace {
 TEST(StringRefTest, Construction) {
   EXPECT_EQ("", StringRef());
   EXPECT_EQ("hello", StringRef("hello"));
   EXPECT_EQ("hello", StringRef("hello world", 5));
   EXPECT_EQ("hello", StringRef(std::string("hello")));
 }
 
+TEST(StringRefTest, EmptyInitializerList) {
+  StringRef S = {};
+  EXPECT_TRUE(S.empty());
+
+  S = {};
+  EXPECT_TRUE(S.empty());
+}
+
 TEST(StringRefTest, Iteration) {
   StringRef S("hello");
   const char *p = "hello";
   for (const char *it = S.begin(), *ie = S.end(); it != ie; ++it, ++p)
     EXPECT_EQ(*it, *p);
 }
 
 TEST(StringRefTest, StringOps) {