[Demangle] Add support for D struct literals

[ljmf00]

Summary

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

llvm/lib/Demangle/DLangDemangle.cpp

private:
   /// \param Type mangled type character in which the type should be
   ///             represented as
   ///
   /// \return the remaining string on success or nullptr on failure
   ///
   /// \see https://dlang.org/spec/abi.html#Value
   const char *parseInteger(OutputString *Decl, const char *Mangled, char Type);
 
+  /// Extract and demangle an struct literal 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
+  /// \param Name demangled symbol name of the struct literal
+  ///
+  /// \return the remaining string on success or nullptr on failure
+  ///
+  /// \see https://dlang.org/spec/abi.html#Value
+  const char *parseStructLiteral(OutputString *Decl, const char *Mangled,
+                                 const char *Name);
+
   /// Extract and demangle an array literal 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
   ///
private:
   /// \see https://dlang.org/spec/abi.html#Value
   const char *parseReal(OutputString *Decl, const char *Mangled);
 
   /// Extract and demangle any 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
+  /// \param Name demangled symbol name of the type, if needed
   /// \param Type mangled type character in which the type should be
   ///             represented as, if needed
   ///
   /// \return the remaining string on success or nullptr on failure
   ///
   /// \see https://dlang.org/spec/abi.html#Value
-  const char *parseValue(OutputString *Decl, const char *Mangled, char Type);
+  const char *parseValue(OutputString *Decl, const char *Mangled,
+                         const char *Name, char Type);
 
   /// The string we are demangling.
   const char *Str;
   /// The index of the last back reference.
   int LastBackref;
 };
 
 } // namespace
case 'V': /* Value parameter. */
 
       /* In the few instances where the type is actually desired in
          the output, it should precede the value from dlang_value.  */
       Name = OutputString();
       Mangled = parseType(&Name, Mangled);
       Name.append('\0');
       Name.Ptr--;
 
-      Mangled = parseValue(Decl, Mangled, Type);
+      Mangled = parseValue(Decl, Mangled, Name.Buffer, Type);
       Name.free();
       break;
     }
 
     case 'X': /* Externally mangled parameter.  */
     {
       unsigned long Len;
       const char *EndPtr;
const char *Demangler::parseTemplate(OutputString *Decl, const char *Mangled,
   /* Check for template name length mismatch.  */
   if (Len != -1UL && Mangled && (unsigned long)(Mangled - Start) != Len)
     return nullptr;
 
   return Mangled;
 }
 
 const char *Demangler::parseValue(OutputString *Decl, const char *Mangled,
-                                  char Type) {
+                                  const char *Name, char Type) {
   if (Mangled == nullptr || *Mangled == '\0')
     return nullptr;
 
   switch (*Mangled) {
   // Integral values
   case 'N':
     Mangled++;
     Decl->append('-');
const char *Demangler::parseValue(OutputString *Decl, const char *Mangled,
   case 'A':
     Mangled++;
     if (Type == 'H')
       Mangled = parseAssocArray(Decl, Mangled);
     else
       Mangled = parseArrayLiteral(Decl, Mangled);
     break;
 
+  // Struct values
+  case 'S':
+    Mangled++;
+    Mangled = parseStructLiteral(Decl, Mangled, Name);
+    break;
+
   default:
     return nullptr;
   }
 
   return Mangled;
 }
 
+const char *Demangler::parseStructLiteral(OutputString *Decl,
+                                          const char *Mangled,
+                                          const char *Name) {
+  unsigned long Args;
+
+  Mangled = decodeNumber(Mangled, &Args);
+  if (Mangled == nullptr)
+    return nullptr;
+
+  if (Name != nullptr)
+    Decl->append(Name);
+
+  Decl->append('(');
+  while (Args--) {
+    Mangled = parseValue(Decl, Mangled, nullptr, '\0');
+    if (Mangled == nullptr)
+      return nullptr;
+
+    if (Args != 0)
+      Decl->append(", ");
+  }
+
+  Decl->append(')');
+  return Mangled;
+}
+
 const char *Demangler::parseString(OutputString *Decl, const char *Mangled) {
   char Type = *Mangled;
   unsigned long Len;
 
   Mangled++;
   Mangled = decodeNumber(Mangled, &Len);
   if (Mangled == nullptr || *Mangled != '_')
     return nullptr;
const char *Demangler::parseArrayLiteral(OutputString *Decl,
   unsigned long Elements;
 
   Mangled = decodeNumber(Mangled, &Elements);
   if (Mangled == nullptr)
     return nullptr;
 
   Decl->append('[');
   while (Elements--) {
-    Mangled = parseValue(Decl, Mangled, '\0');
+    Mangled = parseValue(Decl, Mangled, nullptr, '\0');
     if (Mangled == nullptr)
       return nullptr;
 
     if (Elements != 0)
       Decl->append(", ");
   }
 
   Decl->append(']');
   return Mangled;
 }
 
 const char *Demangler::parseAssocArray(OutputString *Decl,
                                        const char *Mangled) {
   unsigned long Elements;
 
   Mangled = decodeNumber(Mangled, &Elements);
   if (Mangled == nullptr)
     return nullptr;
 
   Decl->append('[');
   while (Elements--) {
-    Mangled = parseValue(Decl, Mangled, '\0');
+    Mangled = parseValue(Decl, Mangled, nullptr, '\0');
     if (Mangled == nullptr)
       return nullptr;
 
     Decl->append(':');
-    Mangled = parseValue(Decl, Mangled, '\0');
+    Mangled = parseValue(Decl, Mangled, nullptr, '\0');
     if (Mangled == nullptr)
       return nullptr;
 
     if (Elements != 0)
       Decl->append(", ");
   }
 
   Decl->append(']');

llvm/unittests/Demangle/DLangDemangleTest.cpp

ExpectedVal ExpectedArray[] = {
       {"_D8demangle16__T4testVAyaa0_Zv", "demangle.test!(\"\")"},
       {"_D8demangle32__T4testVAyaa8_20090a0d0c0b00ffZv",
        "demangle.test!(\" \\t\\n\\r\\f\\v\\x00\\xff\")"},
       {"_D8demangle22__T4testVAiA4i1i2i3i4Zv", "demangle.test!([1, 2, 3, 4])"},
       {"_D8demangle25__T4testVAdA2e08P1eN08P1Zv",
        "demangle.test!([0x0.8p1, -0x0.8p1])"},
       {"_D8demangle23__T4testVHiiA2i1i2i3i4Zv", "demangle.test!([1:2, 3:4])"},
       {"_D8demangle39__T4testVHAxaiA2a3_616263i1a3_646566i2Zv",
-       "demangle.test!([\"abc\":1, \"def\":2])"}
+       "demangle.test!([\"abc\":1, \"def\":2])"},
+      {"_D8demangle28__T4testVS8demangle1SS2i1i2Zv",
+       "demangle.test!(demangle.S(1, 2))"},
+      {"_D8demangle35__T4testVS8demangle1SS2i1a3_616263Zv",
+       "demangle.test!(demangle.S(1, \"abc\"))"}
   };
 
   for (ExpectedVal Val : ExpectedArray) {
     char *Demangled = llvm::dlangDemangle(Val.Mangled);
     EXPECT_STREQ(Demangled, Val.Expected);
     std::free(Demangled);
   }
 }