[Demangle][Rust] Parse array type

[dblaikie]

llvm/test/Demangle/rust.test

160–165

Is it worth having two tests here? The parser seems fairly orthogonally designed and generic args ('p') don't seem more likely to be buggy/weird than any other argument type, such as the u8/0 in the second case? Might be inclined towards only having the second test, unless there's some interesting interaction with the generic args I'm missing.

[tmiasko]

• Remove redundant test case.

[tmiasko]

llvm/test/Demangle/rust.test

160–165

I left only the second test case (I wanted to test that code is parsing a <type> and a <const>, which is unclear with placeholders accepted by both).

llvm/lib/Demangle/RustDemangle.cpp

 //        | "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) {
   if (Error || RecursionLevel >= MaxRecursionLevel) {
     Error = true;
     return;
   }
   SwapAndRestore<size_t> SaveRecursionLevel(RecursionLevel, RecursionLevel + 1);
 
   switch (consume()) {
   case 'C': {

 //          | "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();
+  size_t Start = Position;
+
+  char C = consume();
   BasicType Type;
-  if (parseBasicType(C, Type)) {
-    consume();
+  if (parseBasicType(C, Type))
     return printBasicType(Type);
-  }
 
+  switch (C) {
+  case 'A':
+    print("[");
+    demangleType();
+    print("; ");
+    demangleConst();
+    print("]");
+    break;
+  default:
+    Position = Start;
     demanglePath(InType::Yes);
+    break;
+  }
 }
 
 // <const> = <basic-type> <const-data>
 //         | "p"                          // placeholder
 //         | <backref>
 void Demangler::demangleConst() {
   BasicType Type;
   if (parseBasicType(consume(), Type)) {

llvm/test/Demangle/rust.test

CHECK: named::<<_ as Name>>
        _RIC5namedYpC4NameE
 
 CHECK: named::<name::Name>
        _RIC5namedNvC4name4NameE
 
 CHECK: named::<Name<>>
        _RIC5namedIC4NameEE
 
+; Types
+
+CHECK: types::<[u8; 0]>
+       _RIC5typesAhj0_E
+
 ; Integer constants. Test value demangling.
 
 CHECK: integer::<0>
        _RIC7integerKi0_E
 
 CHECK: integer::<1>
        _RIC7integerKi1_E
 
 CHECK: integer::<-1>
        _RIC7integerKin1_E