[Demangle] Add support for D native tuple types

[ljmf00]

Summary

This patch adds support for native tuple types as described by D ABI
specification.

Signed-off-by: Luís Ferreira <[e-mail]>

llvm/lib/Demangle/DLangDemangle.cpp

private:
   /// \param Decl output buffer to write the demangled name
   /// \param Mangled mangled symbol to be demangled
   ///
   /// \return the remaining string on success or nullptr on failure
   ///
   /// \see https://dlang.org/spec/abi.html#TypeModifiers
   const char *parseTypeModifiers(OutputString *Decl, const char *Mangled);
 
+  /// Extract and demangle a tuple value from a given mangled symbol append it
+  /// to the output string
+  ///
+  /// \param Decl output buffer to write the demangled name
+  /// \param Mangled mangled symbol to be demangled
+  ///
+  /// \return the remaining string on success or nullptr on failure
+  ///
+  /// \see https://dlang.org/spec/abi.html#TypeTuple
+  const char *parseTuple(OutputString *Decl, const char *Mangled);
+
   /// The string we are demangling.
   const char *Str;
   /// The index of the last back reference.
   int LastBackref;
 };
 
 } // namespace
 
const char *Demangler::parseType(OutputString *Decl, const char *Mangled) {
   case 'C': /* class T */
   case 'S': /* struct T */
   case 'E': /* enum T */
   case 'T': /* typedef T */
     Mangled++;
     return parseQualified(Decl, Mangled, false);
 
   // TODO: Parse delegate types
-  // TODO: Parse tuple types
+
+  case 'B': /* tuple T */
+    Mangled++;
+    return parseTuple(Decl, Mangled);
 
   // Basic types
   case 'n':
     Mangled++;
     Decl->append("typeof(null)");
     return Mangled;
 
   case 'v':
const char *Demangler::parseType(OutputString *Decl, const char *Mangled) {
   case 'Q':
     return parseTypeBackref(Decl, Mangled);
 
   default: // unhandled
     return nullptr;
   }
 }
 
+const char *Demangler::parseTuple(OutputString *Decl, const char *Mangled) {
+  unsigned long Elements;
+
+  Mangled = decodeNumber(Mangled, &Elements);
+  if (Mangled == nullptr)
+    return nullptr;
+
+  Decl->append("tuple(");
+
+  while (Elements--) {
+    Mangled = parseType(Decl, Mangled);
+    if (Mangled == nullptr)
+      return nullptr;
+
+    if (Elements != 0)
+      Decl->append(", ");
+  }
+
+  Decl->append(')');
+  return Mangled;
+}
+
 const char *Demangler::parseLName(OutputString *Decl, const char *Mangled,
                                   unsigned long Len) {
   switch (Len) {
   case 6:
     if (strncmp(Mangled, "__ctor", Len) == 0) {
       /* Constructor symbol for a class/struct.  */
       Decl->append("this");
       Mangled += Len;

llvm/unittests/Demangle/DLangDemangleTest.cpp

ExpectedVal ExpectedArray[] = {
       {"_D8demangle4testFNjaZv", "demangle.test(char)"},
       {"_D8demangle4testFNkaZv", "demangle.test(return char)"},
       {"_D8demangle4testFNlaZv", "demangle.test(char)"},
       {"_D8demangle4testFaXv", "demangle.test(char...)"},
       {"_D8demangle4testFaYv", "demangle.test(char, ...)"},
       {"_D8demangle4testFaaYv", "demangle.test(char, char, ...)"},
       {"_D8demangle4testFXv", "demangle.test(...)"},
       {"_D8demangle4testFYv", "demangle.test(, ...)"},
-      {"_D8demangle4testFaaZv", "demangle.test(char, char)"}
+      {"_D8demangle4testFaaZv", "demangle.test(char, char)"},
+      {"_D8demangle4testFB0Zv", "demangle.test(tuple())"},
+      {"_D8demangle4testFB1aZv", "demangle.test(tuple(char))"},
+      {"_D8demangle4testFB2aaZv", "demangle.test(tuple(char, char))"},
+      {"_D8demangle4testFB3aaaZv", "demangle.test(tuple(char, char, char))"},
+      {"_D8demangle4testFB2OaaZv", "demangle.test(tuple(shared(char), char))"}
   };
 
   for (ExpectedVal Val : ExpectedArray) {
     char *Demangled = llvm::dlangDemangle(Val.Mangled);
     EXPECT_STREQ(Demangled, Val.Expected);
     std::free(Demangled);
   }
 }