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

[tmiasko]

Summary

Depends on D103361

[dblaikie]

Looks good - couple of optional things.

llvm/lib/Demangle/RustDemangle.cpp

228

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)

567

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

public:
   // Demangled output.
   OutputStream Output;
 
   Demangler(size_t MaxRecursionLevel = 500);
 
   bool demangle(StringView MangledName);
 
 private:
-  void demanglePath(InType InType);
+  bool demanglePath(InType InType, bool LeaveOpen = false);
   void demangleImplPath(InType InType);
   void demangleGenericArg();
   void demangleType();
   void demangleFnSig();
   void demangleDynBounds();
   void demangleDynTrait();
   void demangleBinder();
   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, bool LeaveOpen) {
   if (Error || RecursionLevel >= MaxRecursionLevel) {
     Error = true;
-    return;
+    return false;
   }
   SwapAndRestore<size_t> SaveRecursionLevel(RecursionLevel, RecursionLevel + 1);
+  bool IsOpen = false;
 
   switch (consume()) {
   case 'C': {
     parseOptionalBase62Number('s');
     Identifier Ident = parseIdentifier();
     print(Ident.Name);
     break;
   }
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)
+      IsOpen = true;
+    else
       print(">");
     break;
   }
   default:
     // FIXME parse remaining productions.
     Error = true;
     break;
   }
+
+  return IsOpen;
 }
 
 // <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, true /* LeaveOpen */);
+  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::demangleBinder() {
   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 _)>