[Demangle][Rust] Parse named types

[dblaikie]

llvm/include/llvm/Demangle/RustDemangle.h

82

Could use a custom enum parameter here to avoid having to add a comment at every call site.

llvm/lib/Demangle/RustDemangle.cpp

424–437

Perhaps it'd be more appropriate to use look() here, then consume() in the if block below?

429–435

Rather than special casing a bunch of things here - especially if the consume->look change makes sense - could this code here use demanglePath unconditionally and let errors fall out of that naturally? (it'd match the grammar more closely, I think - avoid needing the implementation of <path> mixed up in the implementation of <type>)

I guess maybe that's not feasible - if some invalid basic type could then be interpreted as a path, even though it should be an invalid basic type instead?

llvm/test/Demangle/rust.test

141

These tests for <type> are using inherited impl whereas I think previous tests for <type> were using generic args. It'd be nice if they were consistent, I think? (so as not to raise questions/confusion about whether the context in which the type appears is significant to the testing of the type rule) (I don't mind which way they are consistent - if you'd rather change the previous tests over to use inherited impl so they're consistent with the new tests, or chan these new ones to use generic args - or both to some third thing (changing existing tests should be done in a preliminary/separate commit, though))

[tmiasko]

• Fall back to the path production without special casing.
• Use an enum for InType.
• Use generic arguments in tests instead of an inherent impl.

llvm/lib/Demangle/RustDemangle.cpp

424–437

In context of this changes using look() instead of consume() seems like an improvement, and I changed it accordingly.

Admittedly I will return to the previous approach when introducing additional type productions since each would have to consume the initial character otherwise.

llvm/test/Demangle/rust.test

141

Replaced with generic arguments for consistency. As additional benefit it emphasizes the distinction between demangling of generic arguments outside types where :: is included, and in types where it is omitted.

[dblaikie]

Looks good, thanks!

llvm/include/llvm/Demangle/RustDemangle.h

public:
   // Demangled output.
   OutputStream Output;
 
   Demangler(size_t MaxRecursionLevel = 500);
 
   bool demangle(StringView MangledName);
 
 private:
-  void demanglePath();
+  void demanglePath(bool InType);
   void demangleImplPath();
   void demangleGenericArg();
   void demangleType();
   void demangleConst();
   void demangleConstInt();
   void demangleConstBool();
   void demangleConstChar();
 

llvm/lib/Demangle/RustDemangle.cpp

bool Demangler::demangle(StringView Mangled) {
   RecursionLevel = 0;
 
   if (!Mangled.consumeFront("_R")) {
     Error = true;
     return false;
   }
   Input = Mangled;
 
-  demanglePath();
+  demanglePath(false /* InType */);
 
   // FIXME parse optional <instantiating-crate>.
 
   if (Position != Input.size())
     Error = true;
 
   return !Error;
 }
 
+// Demangles a path. InType indicates whether a path is inside a type.
+//
 // <path> = "C" <identifier>               // crate root
 //        | "M" <impl-path> <type>         // <T> (inherent impl)
 //        | "X" <impl-path> <type> <path>  // <T as Trait> (trait impl)
 //        | "Y" <type> <path>              // <T as Trait> (trait definition)
 //        | "N" <ns> <path> <identifier>   // ...::ident (nested path)
 //        | "I" <path> {<generic-arg>} "E" // ...<T, U> (generic args)
 //        | <backref>
 // <identifier> = [<disambiguator>] <undisambiguated-identifier>
 // <ns> = "C"      // closure
 //      | "S"      // shim
 //      | <A-Z>    // other special namespaces
 //      | <a-z>    // internal namespaces
-void Demangler::demanglePath() {
+void Demangler::demanglePath(bool InType) {
   if (Error || RecursionLevel >= MaxRecursionLevel) {
     Error = true;
     return;
   }
   SwapAndRestore<size_t> SaveRecursionLevel(RecursionLevel, RecursionLevel + 1);
 
   switch (consume()) {
   case 'C': {
case 'M': {
     print(">");
     break;
   }
   case 'X': {
     demangleImplPath();
     print("<");
     demangleType();
     print(" as ");
-    demanglePath();
+    demanglePath(true /* InType */);
     print(">");
     break;
   }
   case 'Y': {
     print("<");
     demangleType();
     print(" as ");
-    demanglePath();
+    demanglePath(true /* InType */);
     print(">");
     break;
   }
   case 'N': {
     char NS = consume();
     if (!isLower(NS) && !isUpper(NS)) {
       Error = true;
       break;
     }
-    demanglePath();
+    demanglePath(InType);
 
     uint64_t Disambiguator = parseOptionalBase62Number('s');
     Identifier Ident = parseIdentifier();
 
     if (isUpper(NS)) {
       // Special namespaces
       print("::{");
       if (NS == 'C')
if (isUpper(NS)) {
       if (!Ident.empty()) {
         print("::");
         print(Ident.Name);
       }
     }
     break;
   }
   case 'I': {
-    demanglePath();
-    print("::<");
+    demanglePath(InType);
+    // Omit "::" in type paths where "<" opening generic arguments is optional.
+    if (!InType)
+      print("::");
+    print("<");
     for (size_t I = 0; !Error && !consumeIf('E'); ++I) {
       if (I > 0)
         print(", ");
       demangleGenericArg();
     }
     print(">");
     break;
   }
   default:
     // FIXME parse remaining productions.
     Error = true;
     break;
   }
 }
 
 // <impl-path> = [<disambiguator>] <path>
 // <disambiguator> = "s" <base-62-number>
 void Demangler::demangleImplPath() {
   SwapAndRestore<bool> SavePrint(Print, false);
   parseOptionalBase62Number('s');
-  demanglePath();
+  demanglePath(false /* InType */);
 }
 
 // <generic-arg> = <lifetime>
 //               | <type>
 //               | "K" <const>
 // <lifetime> = "L" <base-62-number>
 void Demangler::demangleGenericArg() {
   if (consumeIf('K'))

 //          | "R" [<lifetime>] <type>     // &T
 //          | "Q" [<lifetime>] <type>     // &mut T
 //          | "P" <type>                  // *const T
 //          | "O" <type>                  // *mut T
 //          | "F" <fn-sig>                // fn(...) -> ...
 //          | "D" <dyn-bounds> <lifetime> // dyn Trait<Assoc = X> + Send + 'a
 //          | <backref>                   // backref
 void Demangler::demangleType() {
+  char C = consume();
   BasicType Type;
-  if (parseBasicType(consume(), Type))
-    printBasicType(Type);
-  else
-    Error = true; // FIXME parse remaining productions.
+  if (parseBasicType(C, Type))
+    return printBasicType(Type);
+
+  switch (C) {
+  case 'C':
+  case 'M':
+  case 'X':
+  case 'Y':
+  case 'N':
+  case 'I':
+    Position -= 1;
+    demanglePath(true /* InType */);
+    break;
+  default:
+    Error = true;
+    break;
+  }
 }
 
 // <const> = <basic-type> <const-data>
 //         | "p"                          // placeholder
 //         | <backref>
 void Demangler::demangleConst() {
   BasicType Type;
   if (parseBasicType(consume(), Type)) {

llvm/test/Demangle/rust.test

CHECK: basic::<i64>
        _RIC5basicxE
 
 CHECK: basic::<u64>
        _RIC5basicyE
 
 CHECK: basic::<!>
        _RIC5basiczE
 
+; Named types. Test possible paths productions.
+
+CHECK: <name>
+       _RMC5crateC4name
+
+CHECK: <<_>>
+       _RMC5crateMC5cratep
+
+CHECK: <<_ as Name>>
+       _RMC5crateXC5cratepC4Name
+
+CHECK: <<_ as Name>>
+       _RMC5crateYpC4Name
+
+CHECK: <name::Name>
+       _RMC5crateNvC4name4Name
+
+CHECK: <Name<>>
+       _RMC5crateIC4NameE
+
 ; Integer constants. Test value demangling.
 
 CHECK: integer::<0>
        _RIC7integerKi0_E
 
 CHECK: integer::<1>
        _RIC7integerKi1_E