[YAML I/O] Fix bug in emission of empty sequence

[JDevlieghere]

Summary

Don't emit an output dash for an empty sequence.

Take emitting a vector of strings for example:

std::vector<std::string> Strings = {"foo", "bar"};
LLVM_YAML_IS_SEQUENCE_VECTOR(std::string)
yout << Strings;

This emits the following YAML document.

---
- foo
- bar
...

However, when the vector is empty, the result is valid YAML, but is now a sequence with one element consisting of an empty list.

---
- []
...

If we were to try to read this into a vector of strings again, it would fail.

YAML:2:4: error: not a mapping
- []

The problem is the output dash before the empty list. The correct output would be:

---
[]
...

This patch fixes that. I'm not too familiar with the YAML I/O implementation beyond the traits themselves, so I'm open to suggestions if you know a better way to fix this.

[thegameg]

LGTM. Not sure if there's a cleaner way.

llvm/include/llvm/Support/YAMLTraits.h

public:
   void beginDocuments();
   bool preflightDocument(unsigned);
   void postflightDocument();
   void endDocuments();
 
 private:
   void output(StringRef s);
   void outputUpToEndOfLine(StringRef s);
-  void newLineCheck();
+  void newLineCheck(bool EmptySequence = false);
   void outputNewLine();
   void paddedKey(StringRef key);
   void flowKey(StringRef Key);
 
   enum InState {
     inSeqFirstElement,
     inSeqOtherElement,
     inFlowSeqFirstElement,

llvm/lib/Support/YAMLTraits.cpp

unsigned Output::beginSequence() {
   Padding = "\n";
   return 0;
 }
 
 void Output::endSequence() {
   // If we did not emit anything, we should explicitly emit an empty sequence
   if (StateStack.back() == inSeqFirstElement) {
     Padding = PaddingBeforeContainer;
-    newLineCheck();
+    newLineCheck(/*EmptySequence=*/true);
     output("[]");
     Padding = "\n";
   }
   StateStack.pop_back();
 }
 
 bool Output::preflightElement(unsigned, void *&) {
   return true;
void Output::outputNewLine() {
   Out << "\n";
   Column = 0;
 }
 
 // if seq at top, indent as if map, then add "- "
 // if seq in middle, use "- " if firstKey, else use "  "
 //
 
-void Output::newLineCheck() {
+void Output::newLineCheck(bool EmptySequence) {
   if (Padding != "\n") {
     output(Padding);
     Padding = {};
     return;
   }
   outputNewLine();
   Padding = {};
 
-  if (StateStack.size() == 0)
+  if (StateStack.size() == 0 || EmptySequence)
     return;
 
   unsigned Indent = StateStack.size() - 1;
   bool OutputDash = false;
 
   if (StateStack.back() == inSeqFirstElement ||
       StateStack.back() == inSeqOtherElement) {
     OutputDash = true;
   } else if ((StateStack.size() > 1) &&
              ((StateStack.back() == inMapFirstKey) ||
               inFlowSeqAnyElement(StateStack.back()) ||
               (StateStack.back() == inFlowMapFirstKey)) &&
              inSeqAnyElement(StateStack[StateStack.size() - 2])) {
     --Indent;
     OutputDash = true;
   }
 
   for (unsigned i = 0; i < Indent; ++i) {
     output("  ");
   }
   if (OutputDash) {
     output("- ");
   }
-
 }
 
 void Output::paddedKey(StringRef key) {
   output(key);
   output(":");
   const char *spaces = "                ";
   if (key.size() < strlen(spaces))
     Padding = &spaces[key.size()];

llvm/unittests/Support/YAMLIOTest.cpp

TEST(YAMLIO, TestEmptyMapWrite) {
   std::string str;
   llvm::raw_string_ostream OS(str);
   Output yout(OS);
   yout << cont;
   EXPECT_EQ(OS.str(), "---\nfbm:             {}\n...\n");
 }
 
 TEST(YAMLIO, TestEmptySequenceWrite) {
+  {
     FooBarContainer cont;
     std::string str;
     llvm::raw_string_ostream OS(str);
     Output yout(OS);
     yout << cont;
     EXPECT_EQ(OS.str(), "---\nfbs:             []\n...\n");
   }
 
+  {
+    FooBarSequence seq;
+    std::string str;
+    llvm::raw_string_ostream OS(str);
+    Output yout(OS);
+    yout << seq;
+    EXPECT_EQ(OS.str(), "---\n[]\n...\n");
+  }
+}
+
 static void TestEscaped(llvm::StringRef Input, llvm::StringRef Expected) {
   std::string out;
   llvm::raw_string_ostream ostr(out);
   Output xout(ostr, nullptr, 0);
 
   llvm::yaml::EmptyContext Ctx;
   yamlize(xout, Input, true, Ctx);