[Demangle][Rust] Parse named types

[dblaikie]

llvm/include/llvm/Demangle/RustDemangle.h

86–87

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

enum class BasicType {
   F64,
   Str,
   Placeholder,
   Unit,
   Variadic,
   Never,
 };
 
+enum class InType {
+  No,
+  Yes,
+};
+
 class Demangler {
   // Maximum recursion level. Used to avoid stack overflow.
   size_t MaxRecursionLevel;
   // Current recursion level.
   size_t RecursionLevel;
 
   // Input string that is being demangled with "_R" prefix removed.
   StringView Input;

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

llvm/lib/Demangle/RustDemangle.cpp

bool Demangler::demangle(StringView Mangled) {
   RecursionLevel = 0;
 
   if (!Mangled.consumeFront("_R")) {
     Error = true;
     return false;
   }
   Input = Mangled;
 
-  demanglePath();
+  demanglePath(InType::No);
 
   // 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(InType InType) {
   if (Error || RecursionLevel >= MaxRecursionLevel) {
     Error = true;
     return;
   }
   SwapAndRestore<size_t> SaveRecursionLevel(RecursionLevel, RecursionLevel + 1);
 
   switch (consume()) {
   case 'C': {
     parseOptionalBase62Number('s');
     Identifier Ident = parseIdentifier();
     print(Ident.Name);
     break;
   }
   case 'M': {
-    demangleImplPath();
+    demangleImplPath(InType);
     print("<");
     demangleType();
     print(">");
     break;
   }
   case 'X': {
-    demangleImplPath();
+    demangleImplPath(InType);
     print("<");
     demangleType();
     print(" as ");
-    demanglePath();
+    demanglePath(InType::Yes);
     print(">");
     break;
   }
   case 'Y': {
     print("<");
     demangleType();
     print(" as ");
-    demanglePath();
+    demanglePath(InType::Yes);
     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 "::" when in a type, where it is optional.
+    if (InType == InType::No)
+      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() {
+void Demangler::demangleImplPath(InType InType) {
   SwapAndRestore<bool> SavePrint(Print, false);
   parseOptionalBase62Number('s');
-  demanglePath();
+  demanglePath(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 = look();
   BasicType Type;
-  if (parseBasicType(consume(), Type))
-    printBasicType(Type);
-  else
-    Error = true; // FIXME parse remaining productions.
+  if (parseBasicType(C, Type)) {
+    consume();
+    return printBasicType(Type);
+  }
+
+  demanglePath(InType::Yes);
 }
 
 // <const> = <basic-type> <const-data>
 //         | "p"                          // placeholder
 //         | <backref>
 void Demangler::demangleConst() {
   BasicType Type;
   if (parseBasicType(consume(), Type)) {
     switch (Type) {
     case BasicType::I8:
     case BasicType::I16:
     case BasicType::I32:
     case BasicType::I64:
     case BasicType::I128:

llvm/test/Demangle/rust.test

CHECK: basic::<i64>
        _RIC5basicxE
 
 CHECK: basic::<u64>
        _RIC5basicyE
 
 CHECK: basic::<!>
        _RIC5basiczE
 
+; Named types. Test possible paths productions.
+
+CHECK: named::<name>
+       _RIC5namedC4nameE
+
+CHECK: named::<<_>>
+       _RIC5namedMC5cratepE
+
+CHECK: named::<<_ as Name>>
+       _RIC5namedXC5cratepC4NameE
+
+CHECK: named::<<_ as Name>>
+       _RIC5namedYpC4NameE
+
+CHECK: named::<name::Name>
+       _RIC5namedNvC4name4NameE
+
+CHECK: named::<Name<>>
+       _RIC5namedIC4NameEE
+
 ; Integer constants. Test value demangling.
 
 CHECK: integer::<0>
        _RIC7integerKi0_E
 
 CHECK: integer::<1>
        _RIC7integerKi1_E