[Demangle][Rust] Parse dyn-trait-assoc-binding

[tmiasko]

Summary

Depends on D103361

[dblaikie]

Looks good - couple of optional things.

llvm/lib/Demangle/RustDemangle.cpp

227

Might be simpler to early return true here - skip the IsOpen variable - since this is the one place that can return true? (and return false at the end of the function)

566–579

Could use another enum here for "LeaveOpen" to avoid the need to comment call sites?

[tmiasko]

• Remove IsOpen variable.
• Use an enum for LeaveOpen.

llvm/include/llvm/Demangle/RustDemangle.h

enum class BasicType {
   Never,
 };
 
 enum class InType {
   No,
   Yes,
 };
 
+enum class LeaveOpen {
+  No,
+  Yes,
+};
+
 class Demangler {
   // Maximum recursion level. Used to avoid stack overflow.
   size_t MaxRecursionLevel;
   // Current recursion level.
   size_t RecursionLevel;
   size_t BoundLifetimes;
   // 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(InType InType);
+  bool demanglePath(InType InType, LeaveOpen LeaveOpen = LeaveOpen::No);
   void demangleImplPath(InType InType);
   void demangleGenericArg();
   void demangleType();
   void demangleFnSig();
   void demangleDynBounds();
   void demangleDynTrait();
   void demangleOptionalBinder();
   void demangleConst();

llvm/lib/Demangle/RustDemangle.cpp

bool Demangler::demangle(StringView Mangled) {
   // 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.
+// Demangles a path. InType indicates whether a path is inside a type. When
+// LeaveOpen is true, a closing `>` after generic arguments is omitted from the
+// output. Return value indicates whether generics arguments have been left
+// open.
 //
 // <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(InType InType) {
+bool Demangler::demanglePath(InType InType, LeaveOpen LeaveOpen) {
   if (Error || RecursionLevel >= MaxRecursionLevel) {
     Error = true;
-    return;
+    return false;
   }
   SwapAndRestore<size_t> SaveRecursionLevel(RecursionLevel, RecursionLevel + 1);
 
   switch (consume()) {
   case 'C': {
     parseOptionalBase62Number('s');
     Identifier Ident = parseIdentifier();
     print(Ident.Name);
case 'I': {
     if (InType == rust_demangle::InType::No)
       print("::");
     print("<");
     for (size_t I = 0; !Error && !consumeIf('E'); ++I) {
       if (I > 0)
         print(", ");
       demangleGenericArg();
     }
+    if (LeaveOpen == rust_demangle::LeaveOpen::Yes)
+      return true;
+    else
       print(">");
     break;
   }
   default:
     // FIXME parse remaining productions.
     Error = true;
     break;
   }
+
+  return false;
 }
 
 // <impl-path> = [<disambiguator>] <path>
 // <disambiguator> = "s" <base-62-number>
 void Demangler::demangleImplPath(InType InType) {
   SwapAndRestore<bool> SavePrint(Print, false);
   parseOptionalBase62Number('s');
   demanglePath(InType);
if (I > 0)
       print(" + ");
     demangleDynTrait();
   }
 }
 
 // <dyn-trait> = <path> {<dyn-trait-assoc-binding>}
 // <dyn-trait-assoc-binding> = "p" <undisambiguated-identifier> <type>
 void Demangler::demangleDynTrait() {
-  demanglePath(InType::Yes);
-  // FIXME demangle {<dyn-trait-assoc-binding>}
+  bool IsOpen = demanglePath(InType::Yes, LeaveOpen::Yes);
+  while (!Error && consumeIf('p')) {
+    if (!IsOpen) {
+      IsOpen = true;
+      print('<');
+    } else {
+      print(", ");
+    }
+    print(parseIdentifier().Name);
+    print(" = ");
+    demangleType();
+  }
+  if (IsOpen)
+    print(">");
 }
 
 // Demangles optional binder and updates the number of bound lifetimes.
 //
 // <binder> = "G" <base-62-number>
 void Demangler::demangleOptionalBinder() {
   uint64_t Binder = parseOptionalBase62Number('G');
   if (Error || Binder == 0)

llvm/test/Demangle/rust.test

CHECK: trait::<dyn Display>
        _RIC5traitDC7DisplayEL_E
 
 CHECK: trait::<dyn Display + Send + Sync>
        _RIC5traitDC7DisplayC4SendC4SyncEL_E
 
 CHECK: trait::<dyn for<'a> Display>
        _RIC5traitDG_C7DisplayEL_E
 
+CHECK: trait::<dyn IntoIterator<_, Item = _>>
+       _RIC5traitDIC12IntoIteratorpEp4ItempEL_E
+
+CHECK: trait::<dyn IntoIterator<Item = _>>
+       _RIC5traitDC12IntoIteratorp4ItempEL_E
+
+CHECK: trait::<dyn IntoIterator<Item = _, IntoIter = _>>
+       _RIC5traitDC12IntoIteratorp4Itempp8IntoIterpEL_E
+
 ; Invalid trait object, missing lifetime.
 
 CHECK: _RIC5traitDEE
        _RIC5traitDEE
 
 ; Binders
 
 CHECK: binders::<for<'a> fn(&'a _)>