[YAML] Add basic support for class hierarchies

[anemet]

Summary

Looks like that with some minimal generalization of mapTag, we can
support inheritance in YAML I/O. In the new testcase I modified the
previous tagging example to actually store the underlying implementation
(decimal vs. fraction) in the YAML output.

I am thinking of using this pattern to produce the YAML output for
optimization remarks (see, https://reviews.llvm.org/D19678#419445). The
relevant part of the optimization remark hierarchy starts at
DiagnosticInfoOptimizationBase
(http://llvm.org/doxygen/classllvm_1_1DiagnosticInfoOptimizationBase.html)

[anemet]

Ping

[kledzik]

lib/Support/YAMLTraits.cpp

429

I don't this is correct. If then output case, if the lambda returns false, that means the object being outputted is not of this tag type, and therefore mapTag() should return false.

unittests/Support/YAMLIOTest.cpp

1608–1619

Without making any changes to mapTag(), you could implement this today as below. Basically, in the output case, you switch off the dynamic type. Of the input side, you switch off the tag.

static void mapping(IO &io, DoubleBase *&d) {

if (io.outputting()) {
  switch (d->kind) {
  case DoubleBase::decimal:
    if (io.mapTag("!decimal", true) 
        mappingDecimal(io, static_cast<DoubleDecimal *>(d));
    break;
 case DoubleBase:: fraction:
    if (io.mapTag("!fraction", true) 
        mappingDecimal(io, static_cast<DoubleFraction *>(d));
    break;
} else {
    if (io.mapTag("!decimal", true) {
      d = new DoubleDecimal;
      mappingDecimal(io, static_cast<DoubleDecimal *>(d));
    } else  if (io.mapTag("! fraction", true) {
      d = new DoubleFraction;
      mappingDecimal(io, static_cast<DoubleFraction *>(d));
  }

}

[anemet]

Talking to Nick in person a while ago, he was not fond of the use of lambda in this approach. I am abandoning this for now.

include/llvm/Support/YAMLTraits.h

public:
   virtual bool canElideEmptySequence() = 0;
 
   virtual unsigned beginFlowSequence() = 0;
   virtual bool preflightFlowElement(unsigned, void *&) = 0;
   virtual void postflightFlowElement(void*) = 0;
   virtual void endFlowSequence() = 0;
 
   virtual bool mapTag(StringRef Tag, bool Default=false) = 0;
+  /// Specify the type of the node.
+  ///
+  /// During output, the \p Tag is written if \p Use returns true.  A lambda is
+  /// used for lazy evaluation so that the underlying structure can be used.
+  /// During parsing, the structure may not be allocated at this point.
+  ///
+  /// During input, this returns whether \p Tag was encounter.  Also return true
+  /// if no tag was found but this is the default tag (i.e. \p Default is true).
+  virtual bool mapTag(StringRef Tag, std::function<bool()> Use,
+                      bool Default = false) = 0;
   virtual void beginMapping() = 0;
   virtual void endMapping() = 0;
   virtual bool preflightKey(const char*, bool, bool, bool &, void *&) = 0;
   virtual void postflightKey(void*) = 0;
 
   virtual void beginFlowMapping() = 0;
   virtual void endFlowMapping() = 0;
 
public:
   ~Input() override;
 
   // Check if there was an syntax or semantic error during parsing.
   std::error_code error();
 
 private:
   bool outputting() override;
   bool mapTag(StringRef, bool) override;
+  bool mapTag(StringRef, std::function<bool()> Use, bool Default) override;
   void beginMapping() override;
   void endMapping() override;
   bool preflightKey(const char *, bool, bool, bool &, void *&) override;
   void postflightKey(void *) override;
   void beginFlowMapping() override;
   void endFlowMapping() override;
   unsigned beginSequence() override;
   void endSequence() override;

 ///
 class Output : public IO {
 public:
   Output(llvm::raw_ostream &, void *Ctxt = nullptr, int WrapColumn = 70);
   ~Output() override;
 
   bool outputting() override;
   bool mapTag(StringRef, bool) override;
+  bool mapTag(StringRef, std::function<bool()> Use, bool Default) override;
   void beginMapping() override;
   void endMapping() override;
   bool preflightKey(const char *key, bool, bool, bool &, void *&) override;
   void postflightKey(void *) override;
   void beginFlowMapping() override;
   void endFlowMapping() override;
   unsigned beginSequence() override;
   void endSequence() override;

lib/Support/YAMLTraits.cpp

 bool Input::nextDocument() {
   return ++DocIterator != Strm->end();
 }
 
 const Node *Input::getCurrentNode() const {
   return CurrentNode ? CurrentNode->_node : nullptr;
 }
 
+bool Input::mapTag(StringRef Tag, std::function<bool()> Use, bool Default) {
+  return mapTag(Tag, Default);
+}
+
 bool Input::mapTag(StringRef Tag, bool Default) {
   std::string foundTag = CurrentNode->_node->getVerbatimTag();
   if (foundTag.empty()) {
     // If no tag found and 'Tag' is the default, say it was found.
     return Default;
   }
   // Return true iff found tag matches supplied tag.
   return Tag.equals(foundTag);
bool Output::outputting() {
   return true;
 }
 
 void Output::beginMapping() {
   StateStack.push_back(inMapFirstKey);
   NeedsNewLine = true;
 }
 
+bool Output::mapTag(StringRef Tag, std::function<bool()> Use, bool Default) {
+  return mapTag(Tag, Use());
+}
+
 bool Output::mapTag(StringRef Tag, bool Use) {
   if (Use) {
     // If this tag is being written inside a sequence we should write the start
     // of the sequence before writing the tag, otherwise the tag won't be
     // attached to the element in the sequence, but rather the sequence itself.
     bool SequenceElement =
         StateStack.size() > 1 && (StateStack[StateStack.size() - 2] == inSeq ||
           StateStack[StateStack.size() - 2] == inFlowSeq);

unittests/Support/YAMLIOTest.cpp

std::string intermediate;
 
     EXPECT_FALSE(yin.error());
     EXPECT_EQ(docList2.size(), 2UL);
     EXPECT_EQ(docList2[0].value, 10.25);
     EXPECT_EQ(docList2[1].value, -3.75);
   }
 }
 
+//===----------------------------------------------------------------------===//
+//  Test class hierarchy
+//===----------------------------------------------------------------------===//
+
+struct DoubleBase {
+  enum Kind { decimal, fraction };
+  Kind kind;
+  DoubleBase(Kind kind) : kind(kind) {}
+};
+
+struct DoubleDecimal : public DoubleBase {
+  double value;
+  DoubleDecimal() : DoubleBase(decimal) {}
+  DoubleDecimal(double value) : DoubleBase(decimal), value(value) {}
+};
+
+struct DoubleFraction : public DoubleBase {
+  int num, denom;
+  DoubleFraction() : DoubleBase(fraction) {}
+  DoubleFraction(int num, int denom)
+      : DoubleBase(fraction), num(num), denom(denom) {}
+};
+
+namespace llvm {
+namespace yaml {
+template <> struct ScalarEnumerationTraits<DoubleBase::Kind> {
+  static void enumeration(IO &io, DoubleBase::Kind &kind) {
+    io.enumCase(kind, "decimal", DoubleBase::decimal);
+    io.enumCase(kind, "fraction", DoubleBase::fraction);
+  }
+};
+
+template <> struct MappingTraits<DoubleBase *> {
+  static void mapping(IO &io, DoubleBase *&d) {
+    if (io.mapTag("!decimal", [&]() { return d->kind == DoubleBase::decimal; },
+                  true)) {
+      if (!io.outputting())
+        d = new DoubleDecimal;
+      mappingDecimal(io, static_cast<DoubleDecimal *>(d));
+    } else if (io.mapTag("!fraction",
+                         [&]() { return d->kind == DoubleBase::fraction; })) {
+      if (!io.outputting())
+        d = new DoubleFraction;
+      mappingFraction(io, static_cast<DoubleFraction *>(d));
+    }
+  }
+
+  static void mappingDecimal(IO &io, DoubleDecimal *dd) {
+    io.mapRequired("value", dd->value);
+  }
+  static void mappingFraction(IO &io, DoubleFraction *df) {
+    io.mapRequired("numerator", df->num);
+    io.mapRequired("denominator", df->denom);
+  }
+};
+}
+}
+
+LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(DoubleBase *)
+
+TEST(YAMLIO, TestClassHiearchy) {
+  std::vector<DoubleBase *> docList;
+  Input yin("--- !decimal\nvalue:  3.0\n"
+            "--- !fraction\nnumerator:  9\ndenominator:  2\n...\n");
+  yin >> docList;
+  EXPECT_FALSE(yin.error());
+  EXPECT_EQ(docList.size(), 2UL);
+
+  EXPECT_EQ(docList[0]->kind, DoubleBase::decimal);
+  auto *dd = static_cast<DoubleDecimal *>(docList[0]);
+  EXPECT_EQ(dd->value, 3.0);
+
+  EXPECT_EQ(docList[1]->kind, DoubleBase::fraction);
+  auto *df = static_cast<DoubleFraction *>(docList[1]);
+  EXPECT_EQ(df->num, 9);
+  EXPECT_EQ(df->denom, 2);
+}
+
+TEST(YAMLIO, TestClassHiearchyWriteAndRead) {
+  std::string intermediate;
+  {
+    DoubleFraction a(1025, 100);
+    DoubleDecimal b(-3.75);
+    std::vector<DoubleBase *> docList;
+    docList.push_back(&a);
+    docList.push_back(&b);
+
+    llvm::raw_string_ostream ostr(intermediate);
+    Output yout(ostr);
+    yout << docList;
+  }
+
+  {
+    Input yin(intermediate);
+    std::vector<DoubleBase *> docList2;
+    yin >> docList2;
+
+    EXPECT_FALSE(yin.error());
+    EXPECT_EQ(docList2.size(), 2UL);
+    EXPECT_EQ(docList2[0]->kind, DoubleBase::fraction);
+    auto *df = static_cast<DoubleFraction *>(docList2[0]);
+    EXPECT_EQ(df->num, 1025);
+    EXPECT_EQ(df->denom, 100);
+
+    EXPECT_EQ(docList2[1]->kind, DoubleBase::decimal);
+    EXPECT_EQ(static_cast<DoubleDecimal *>(docList2[1])->value, -3.75);
+  }
+}
 
 //===----------------------------------------------------------------------===//
 //  Test mapping validation
 //===----------------------------------------------------------------------===//
 
 struct MyValidation {
   double value;
 };