YAMLIO: Fix serialization of strings with embedded nuls

[labath]

Summary

A bug/typo in Output::scalarString caused us to round-trip a StringRef
through a const char *. This meant that any strings with embedded nuls
were unintentionally cut short at the first such character. (It also
could have caused accidental buffer overruns, but it seems that all
StringRefs coming into this functions were formed from null-terminated
strings.)

This patch fixes the bug and adds an appropriate test.

[sammccall]

Ouch, thanks!

lib/Support/YAMLTraits.cpp

if (S.empty()) {
     return;
   }
   if (MustQuote == QuotingType::None) {
     // Only quote if we must.
     outputUpToEndOfLine(S);
     return;
   }
 
-  unsigned i = 0;
-  unsigned j = 0;
-  unsigned End = S.size();
-  const char *Base = S.data();
-
   const char *const Quote = MustQuote == QuotingType::Single ? "'" : "\"";
   output(Quote); // Starting quote.
 
   // When using double-quoted strings (and only in that case), non-printable characters may be
   // present, and will be escaped using a variety of unicode-scalar and special short-form
   // escapes. This is handled in yaml::escape.
   if (MustQuote == QuotingType::Double) {
-    output(yaml::escape(Base, /* EscapePrintable= */ false));
+    output(yaml::escape(S, /* EscapePrintable= */ false));
     outputUpToEndOfLine(Quote);
     return;
   }
 
+  unsigned i = 0;
+  unsigned j = 0;
+  unsigned End = S.size();
+  const char *Base = S.data();
+
   // When using single-quoted strings, any single quote ' must be doubled to be escaped.
   while (j < End) {
     if (S[j] == '\'') {                    // Escape quotes.
       output(StringRef(&Base[i], j - i));  // "flush".
       output(StringLiteral("''"));         // Print it as ''
       i = j + 1;
     }
     ++j;

unittests/Support/YAMLIOTest.cpp

struct StringTypes {
   std::string stdstr5;
   std::string stdstr6;
   std::string stdstr7;
   std::string stdstr8;
   std::string stdstr9;
   std::string stdstr10;
   std::string stdstr11;
   std::string stdstr12;
+  std::string stdstr13;
 };
 
 namespace llvm {
 namespace yaml {
   template <>
   struct MappingTraits<StringTypes> {
     static void mapping(IO &io, StringTypes& st) {
       io.mapRequired("str1",      st.str1);
static void mapping(IO &io, StringTypes& st) {
       io.mapRequired("stdstr5",   st.stdstr5);
       io.mapRequired("stdstr6",   st.stdstr6);
       io.mapRequired("stdstr7",   st.stdstr7);
       io.mapRequired("stdstr8",   st.stdstr8);
       io.mapRequired("stdstr9",   st.stdstr9);
       io.mapRequired("stdstr10",  st.stdstr10);
       io.mapRequired("stdstr11",  st.stdstr11);
       io.mapRequired("stdstr12",  st.stdstr12);
+      io.mapRequired("stdstr13",  st.stdstr13);
     }
   };
 }
 }
 
 TEST(YAMLIO, TestReadWriteStringTypes) {
   std::string intermediate;
   {
std::string intermediate;
     map.stdstr5 = "";
     map.stdstr6 = "0000000004000000";
     map.stdstr7 = "true";
     map.stdstr8 = "FALSE";
     map.stdstr9 = "~";
     map.stdstr10 = "0.2e20";
     map.stdstr11 = "0x30";
     map.stdstr12 = "- match";
+    map.stdstr13.assign("\0a\0b\0", 5);
 
     llvm::raw_string_ostream ostr(intermediate);
     Output yout(ostr);
     yout << map;
   }
 
   llvm::StringRef flowOut(intermediate);
   EXPECT_NE(llvm::StringRef::npos, flowOut.find("'''aaa"));
TEST(YAMLIO, TestReadWriteStringTypes) {
   EXPECT_NE(llvm::StringRef::npos, flowOut.find("'0x30'\n"));
   EXPECT_NE(llvm::StringRef::npos, flowOut.find("'- match'\n"));
   EXPECT_NE(std::string::npos, flowOut.find("'''eee"));
   EXPECT_NE(std::string::npos, flowOut.find("'\"fff'"));
   EXPECT_NE(std::string::npos, flowOut.find("'`ggg'"));
   EXPECT_NE(std::string::npos, flowOut.find("'@hhh'"));
   EXPECT_NE(std::string::npos, flowOut.find("''\n"));
   EXPECT_NE(std::string::npos, flowOut.find("'0000000004000000'\n"));
+  EXPECT_NE(std::string::npos, flowOut.find("\"\\0a\\0b\\0\""));
 
   {
     Input yin(intermediate);
     StringTypes map;
     yin >> map;
 
     EXPECT_FALSE(yin.error());
     EXPECT_TRUE(map.str1.equals("'aaa"));
     EXPECT_TRUE(map.str2.equals("\"bbb"));
     EXPECT_TRUE(map.str3.equals("`ccc"));
     EXPECT_TRUE(map.str4.equals("@ddd"));
     EXPECT_TRUE(map.str5.equals(""));
     EXPECT_TRUE(map.str6.equals("0000000004000000"));
     EXPECT_TRUE(map.stdstr1 == "'eee");
     EXPECT_TRUE(map.stdstr2 == "\"fff");
     EXPECT_TRUE(map.stdstr3 == "`ggg");
     EXPECT_TRUE(map.stdstr4 == "@hhh");
     EXPECT_TRUE(map.stdstr5 == "");
     EXPECT_TRUE(map.stdstr6 == "0000000004000000");
+    EXPECT_EQ(std::string("\0a\0b\0", 5), map.stdstr13);
   }
 }
 
 //===----------------------------------------------------------------------===//
 //  Test ScalarEnumerationTraits
 //===----------------------------------------------------------------------===//
 
 enum Colors {