[Demangle] Add support for D delegate types

[ljmf00]

Summary

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

llvm/lib/Demangle/DLangDemangle.cpp

private:
   /// \see https://dlang.org/spec/abi.html#IdentifierBackRef
   const char *parseSymbolBackref(OutputString *Decl, const char *Mangled);
 
   /// Extract and demangle backreferenced type from a given mangled symbol
   /// and append it to the output string
   ///
   /// \param Decl output buffer to write the demangled name
   /// \param Mangled mangled symbol to be demangled
+  /// \param IsFunction whether the backreferenced type is expected to be a
+  ///                   function
   ///
   /// \return the remaining string on success or nullptr on failure
   ///
   /// \see https://dlang.org/spec/abi.html#back_ref
   /// \see https://dlang.org/spec/abi.html#TypeBackRef
-  const char *parseTypeBackref(OutputString *Decl, const char *Mangled);
+  const char *parseTypeBackref(OutputString *Decl, const char *Mangled,
+                               bool IsFunction);
 
   /// Check whether it is a function calling convention
   ///
   /// \param Mangled string to extract the function calling convention
   ///
   /// \return true on success, false otherwise
   ///
   /// \see https://dlang.org/spec/abi.html#CallConvention
const char *Demangler::parseSymbolBackref(OutputString *Decl,
 
   Backref = parseLName(Decl, Backref, Len);
   if (Backref == nullptr)
     return nullptr;
 
   return Mangled;
 }
 
-const char *Demangler::parseTypeBackref(OutputString *Decl, const char *Mangled) {
+const char *Demangler::parseTypeBackref(OutputString *Decl, const char *Mangled,
+                                        bool IsFunction) {
   /* A type back reference always points to a letter.
         TypeBackRef:
             Q NumberBackRef
             ^
    */
   const char *Backref;
 
   /* If we appear to be moving backwards through the mangle string, then
      bail as this may be a recursive back reference */
   if (Mangled - Str >= LastBackref)
     return nullptr;
 
   int SaveRefPos = LastBackref;
   LastBackref = Mangled - Str;
 
   // Get position of the back reference
   Mangled = decodeBackref(Mangled, &Backref);
 
-  // TODO: Add support for function type back references
+  // Must point to a type
+  if (IsFunction)
+    Backref = parseFunctionType(Decl, Backref);
+  else
     Backref = parseType(Decl, Backref);
 
   LastBackref = SaveRefPos;
 
   if (Backref == nullptr)
     return nullptr;
 
   return Mangled;
 }
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
+  case 'D': /* delegate T */
+  {
+    OutputString Mods = OutputString();
+    size_t Szmods;
+    Mangled++;
+
+    Mangled = parseTypeModifiers(&Mods, Mangled);
+    Szmods = Mods.getLength();
+
+    // Back referenced function type
+    if (Mangled && *Mangled == 'Q')
+      Mangled = parseTypeBackref(Decl, Mangled, true);
+    else
+      Mangled = parseFunctionType(Decl, Mangled);
+
+    Decl->append("delegate");
+    Decl->append(Mods.Buffer, Szmods);
+
+    Mods.free();
+    return Mangled;
+  }
 
   case 'B': /* tuple T */
     Mangled++;
     return parseTuple(Decl, Mangled);
 
   // Basic types
   case 'n':
     Mangled++;
case 'k':
       Mangled++;
       Decl->append("ucent");
       return Mangled;
     }
     return nullptr;
 
   // Back referenced type
   case 'Q':
-    return parseTypeBackref(Decl, Mangled);
+    return parseTypeBackref(Decl, Mangled, false);
 
   default: // unhandled
     return nullptr;
   }
 }
 
 const char *Demangler::parseTuple(OutputString *Decl, const char *Mangled) {
   unsigned long Elements;

llvm/unittests/Demangle/DLangDemangleTest.cpp

ExpectedVal ExpectedArray[] = {
       {"_D8demangle4testFaaYv", "demangle.test(char, char, ...)"},
       {"_D8demangle4testFXv", "demangle.test(...)"},
       {"_D8demangle4testFYv", "demangle.test(, ...)"},
       {"_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))"}
+      {"_D8demangle4testFB2OaaZv", "demangle.test(tuple(shared(char), char))"},
+      {"_D8demangle4testFB3aDFZaaZv",
+       "demangle.test(tuple(char, char() delegate, char))"},
+      {"_D8demangle4testFDFZaZv", "demangle.test(char() delegate)"},
+      {"_D8demangle4testFDUZaZv", "demangle.test(extern(C) char() delegate)"},
+      {"_D8demangle4testFDWZaZv",
+       "demangle.test(extern(Windows) char() delegate)"},
+      {"_D8demangle4testFDVZaZv",
+       "demangle.test(extern(Pascal) char() delegate)"},
+      {"_D8demangle4testFDRZaZv", "demangle.test(extern(C++) char() delegate)"},
+      {"_D8demangle4testFDYZaZv",
+       "demangle.test(extern(Objective-C) char() delegate)"},
+      {"_D8demangle4testFPFZaZv", "demangle.test(char() function)"},
+      {"_D8demangle4testFPUZaZv", "demangle.test(extern(C) char() function)"},
+      {"_D8demangle4testFPWZaZv",
+       "demangle.test(extern(Windows) char() function)"},
+      {"_D8demangle4testFPVZaZv",
+       "demangle.test(extern(Pascal) char() function)"},
+      {"_D8demangle4testFPRZaZv", "demangle.test(extern(C++) char() function)"},
+      {"_D8demangle4testFPYZaZv",
+       "demangle.test(extern(Objective-C) char() function)"},
+      {"_D8demangle4testFDFNaZaZv", "demangle.test(char() pure delegate)"},
+      {"_D8demangle4testFDFNbZaZv", "demangle.test(char() nothrow delegate)"},
+      {"_D8demangle4testFDFNcZaZv", "demangle.test(char() ref delegate)"},
+      {"_D8demangle4testFDFNdZaZv", "demangle.test(char() @property delegate)"},
+      {"_D8demangle4testFDFNeZaZv", "demangle.test(char() @trusted delegate)"},
+      {"_D8demangle4testFDFNfZaZv", "demangle.test(char() @safe delegate)"},
+      {"_D8demangle4testFDFNiZaZv", "demangle.test(char() @nogc delegate)"},
+      {"_D8demangle4testFDFNmZaZv", "demangle.test(char() @live delegate)"},
+      {"_D8demangle4testFDFNaNbZaZv",
+       "demangle.test(char() pure nothrow delegate)"},
+      {"_D8demangle4testFDFNbNaZaZv",
+       "demangle.test(char() nothrow pure delegate)"},
+      {"_D8demangle4testFDFNdNfNaZaZv",
+       "demangle.test(char() @property @safe pure delegate)"},
+      {"_D8demangle4testFNjDFZaZv", "demangle.test(char() delegate)"},
+      {"_D8demangle4testFNkDFZaZv", "demangle.test(return char() delegate)"},
+      {"_D8demangle4testFDFNjZaZv", "demangle.test(char() return delegate)"},
+      {"_D8demangle4testFNjNkDFNjZaZv",
+       "demangle.test(return char() return delegate)"},
+      {"_D8demangle4testFNlDFZaZv", "demangle.test(char() delegate)"},
+      {"_D8demangle4testFMDFZaZv", "demangle.test(scope char() delegate)"},
+      {"_D8demangle4testFDFNlZaZv", "demangle.test(char() scope delegate)"},
+      {"_D8demangle4testFMDFNlZaZv",
+       "demangle.test(scope char() scope delegate)"},
+      {"_D8demangle4testFNlMDFNlZaZv",
+       "demangle.test(scope char() scope delegate)"},
+      {"_D8demangle4testFPFNaZaZv", "demangle.test(char() pure function)"},
+      {"_D8demangle4testFPFNbZaZv", "demangle.test(char() nothrow function)"},
+      {"_D8demangle4testFPFNcZaZv", "demangle.test(char() ref function)"},
+      {"_D8demangle4testFPFNdZaZv", "demangle.test(char() @property function)"},
+      {"_D8demangle4testFPFNeZaZv", "demangle.test(char() @trusted function)"},
+      {"_D8demangle4testFPFNfZaZv", "demangle.test(char() @safe function)"},
+      {"_D8demangle4testFPFNiZaZv", "demangle.test(char() @nogc function)"},
+      {"_D8demangle4testFPFNmZaZv", "demangle.test(char() @live function)"},
+      {"_D8demangle4testFPFNaNbZaZv",
+       "demangle.test(char() pure nothrow function)"},
+      {"_D8demangle4testFPFNbNaZaZv",
+       "demangle.test(char() nothrow pure function)"},
+      {"_D8demangle4testFPFNdNfNaZaZv",
+       "demangle.test(char() @property @safe pure function)"},
+      {"_D8demangle4testFNjPFZaZv", "demangle.test(char() function)"},
+      {"_D8demangle4testFNkPFZaZv", "demangle.test(return char() function)"},
+      {"_D8demangle4testFPFNjZaZv", "demangle.test(char() return function)"},
+      {"_D8demangle4testFNjNkPFNjZaZv",
+       "demangle.test(return char() return function)"},
+      {"_D8demangle4testFNlPFZaZv", "demangle.test(char() function)"},
+      {"_D8demangle4testFMPFZaZv", "demangle.test(scope char() function)"},
+      {"_D8demangle4testFPFNlZaZv", "demangle.test(char() scope function)"},
+      {"_D8demangle4testFMPFNlZaZv",
+       "demangle.test(scope char() scope function)"},
+      {"_D8demangle4testFNlMPFNlZaZv",
+       "demangle.test(scope char() scope function)"},
+      {"_D8demangle4test6__ctorMFZv", "demangle.test.this()"},
+      {"_D8demangle4test6__dtorMFZv", "demangle.test.~this()"},
+      {"_D8demangle4test10__postblitMFZv", "demangle.test.this(this)"},
+      {"_D8demangle4testFHAbaZv", "demangle.test(char[bool[]])"},
+      {"_D8demangle4testFHG42caZv", "demangle.test(char[creal[42]])"},
+      {"_D8demangle4testFAiXv", "demangle.test(int[]...)"},
+      {"_D8demangle4testFLAiXv", "demangle.test(lazy int[]...)"},
+      {"_D8demangle4testFAiYv", "demangle.test(int[], ...)"},
+      {"_D8demangle4testFLAiYv", "demangle.test(lazy int[], ...)"},
+      {"_D8demangle4testFLilZv", "demangle.test(lazy int, long)"},
+      {"_D8demangle4testFLliZv", "demangle.test(lazy long, int)"},
+      {"_D8demangle4testFLC6ObjectLDFLiZiZi",
+       "demangle.test(lazy Object, lazy int(lazy int) delegate)"},
+      {"_D8demangle4testMxFZv", "demangle.test() const"},
+      {"_D8demangle4testMyFZv", "demangle.test() immutable"},
+      {"_D8demangle4testMNgFZv", "demangle.test() inout"},
+      {"_D8demangle4testMNgxFZv", "demangle.test() inout const"},
+      {"_D8demangle4testMOFZv", "demangle.test() shared"},
+      {"_D8demangle4testMOxFZv", "demangle.test() shared const"},
+      {"_D8demangle4testMONgFZv", "demangle.test() shared inout"},
+      {"_D8demangle4testMONgxFZv", "demangle.test() shared inout const"},
+      {"_D8demangle4testFDxFZaZv", "demangle.test(char() delegate const)"},
+      {"_D8demangle4testFDyFZaZv", "demangle.test(char() delegate immutable)"},
+      {"_D8demangle4testFDNgFZaZv", "demangle.test(char() delegate inout)"},
+      {"_D8demangle4testFDNgxFZaZv",
+       "demangle.test(char() delegate inout const)"},
+      {"_D8demangle4testFDOFZaZv", "demangle.test(char() delegate shared)"},
+      {"_D8demangle4testFDOxFZaZv",
+       "demangle.test(char() delegate shared const)"},
+      {"_D8demangle4testFDONgFZaZv",
+       "demangle.test(char() delegate shared inout)"},
+      {"_D8demangle4testFDONgxFZaZv",
+       "demangle.test(char() delegate shared inout const)"},
+      {"_D8demangle004testFaZv", "demangle.test(char)"},
+      {"_D8demangle000000004testFaZv", "demangle.test(char)"}
   };
 
   for (ExpectedVal Val : ExpectedArray) {
     char *Demangled = llvm::dlangDemangle(Val.Mangled);
     EXPECT_STREQ(Demangled, Val.Expected);
     std::free(Demangled);
   }
 }