[Demangle][Rust] Parse basic types

[dblaikie]

Looks good - maybe some patch reordering, maybe the generic rule is as good as the "M" or "Y" rule to test <type> - your call.

llvm/lib/Demangle/RustDemangle.cpp

119

Maybe it'd be more direct to implement/test type here (or with "Y" below) (or is there some even more direct production/reference to types?) rather than as parameters to generic types?

Then the generic type testing can include one simple nested type without using generic types as the means to test all the basic types?

236

Spec comment for <basic-type> (I realize it's not much more than the table of implementation - but when looking around for the <basic-type> rule, it'd be nice if it were written somewhere/here)

239–240

Skip the else after return ( https://llvm.org/docs/CodingStandards.html#don-t-use-else-after-a-return )

[tmiasko]

Address review comments

• Add description of <basic-type> production from the specification.
• Don't use else after a return.

The other rules seems equally good for testing <type> as <generic-arg> is, so I left this as is.

Could you commit this for me? Thanks.

llvm/include/llvm/Demangle/RustDemangle.h

public:
   OutputStream Output;
 
   Demangler(size_t MaxRecursionLevel = 500);
 
   bool demangle(StringView MangledName);
 
 private:
   void demanglePath();
+  void demangleGenericArg();
+  void demangleType();
 
   Identifier parseIdentifier();
   uint64_t parseOptionalBase62Number(char Tag);
   uint64_t parseBase62Number();
   uint64_t parseDecimalNumber();
 
   void print(char C) {
     if (Error)

llvm/lib/Demangle/RustDemangle.cpp

bool Demangler::demangle(StringView Mangled) {
 
   if (Position != Input.size())
     Error = true;
 
   return !Error;
 }
 
 // <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
if (isUpper(NS)) {
       // Implementation internal namespaces.
       if (!Ident.empty()) {
         print("::");
         print(Ident.Name);
       }
     }
     break;
   }
+  case 'I': {
+    demanglePath();
+    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;
   }
 }
 
+// <generic-arg> = <lifetime>
+//               | <type>
+//               | "K" <const>
+// <lifetime> = "L" <base-62-number>
+void Demangler::demangleGenericArg() {
+  // FIXME parse remaining productions
+  demangleType();
+}
+
+static const char *const BasicTypes[] = {
+    "i8",    // a
+    "bool",  // b
+    "char",  // c
+    "f64",   // d
+    "str",   // e
+    "f32",   // f
+    nullptr, // g
+    "u8",    // h
+    "isize", // i
+    "usize", // j
+    nullptr, // k
+    "i32",   // l
+    "u32",   // m
+    "i128",  // n
+    "u128",  // o
+    "_",     // p
+    nullptr, // q
+    nullptr, // r
+    "i16",   // s
+    "u16",   // t
+    "()",    // u
+    "...",   // v
+    nullptr, // w
+    "i64",   // x
+    "u64",   // y
+    "!",     // z
+};
+
+// <basic-type> = "a"      // i8
+//              | "b"      // bool
+//              | "c"      // char
+//              | "d"      // f64
+//              | "e"      // str
+//              | "f"      // f32
+//              | "h"      // u8
+//              | "i"      // isize
+//              | "j"      // usize
+//              | "l"      // i32
+//              | "m"      // u32
+//              | "n"      // i128
+//              | "o"      // u128
+//              | "s"      // i16
+//              | "t"      // u16
+//              | "u"      // ()
+//              | "v"      // ...
+//              | "x"      // i64
+//              | "y"      // u64
+//              | "z"      // !
+//              | "p"      // placeholder (e.g. for generic params), shown as _
+static const char *parseBasicType(char C) {
+  if (isLower(C))
+    return BasicTypes[C - 'a'];
+  return nullptr;
+}
+
+// <type> = | <basic-type>
+//          | <path>                      // named type
+//          | "A" <type> <const>          // [T; N]
+//          | "S" <type>                  // [T]
+//          | "T" {<type>} "E"            // (T1, T2, T3, ...)
+//          | "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() {
+  if (const char *BasicType = parseBasicType(consume())) {
+    print(BasicType);
+  } else {
+    // FIXME parse remaining productions.
+    Error = true;
+  }
+}
+
 // <undisambiguated-identifier> = ["u"] <decimal-number> ["_"] <bytes>
 Identifier Demangler::parseIdentifier() {
   bool Punycode = consumeIf('u');
   uint64_t Bytes = parseDecimalNumber();
 
   // Underscore resolves the ambiguity when identifier starts with a decimal
   // digit or another underscore.
   consumeIf('_');

llvm/test/Demangle/rust.test

 CHECK: crate::{shim:reify#0}
        _RNSC5crate5reify
 
 ; Unrecognized special namespace
 
 CHECK: crate::{Z:ident#10}
        _RNZC5crates8_5ident
 
+; Generic type arguments
+
+CHECK: generic::<_>
+       _RIC7genericpE
+
+CHECK: generic::<_, _>
+       _RIC7genericppE
+
+CHECK: generic::<_, _, _>
+       _RIC7genericpppE
+
+; Basic types
+
+CHECK: basic::<i8>
+       _RIC5basicaE
+
+CHECK: basic::<bool>
+       _RIC5basicbE
+
+CHECK: basic::<char>
+       _RIC5basiccE
+
+CHECK: basic::<f64>
+       _RIC5basicdE
+
+CHECK: basic::<str>
+       _RIC5basiceE
+
+CHECK: basic::<f32>
+       _RIC5basicfE
+
+CHECK: basic::<u8>
+       _RIC5basichE
+
+CHECK: basic::<isize>
+       _RIC5basiciE
+
+CHECK: basic::<usize>
+       _RIC5basicjE
+
+CHECK: basic::<i32>
+       _RIC5basiclE
+
+CHECK: basic::<u32>
+       _RIC5basicmE
+
+CHECK: basic::<i128>
+       _RIC5basicnE
+
+CHECK: basic::<u128>
+       _RIC5basicoE
+
+CHECK: basic::<_>
+       _RIC5basicpE
+
+CHECK: basic::<i16>
+       _RIC5basicsE
+
+CHECK: basic::<u16>
+       _RIC5basictE
+
+CHECK: basic::<()>
+       _RIC5basicuE
+
+CHECK: basic::<...>
+       _RIC5basicvE
+
+CHECK: basic::<i64>
+       _RIC5basicxE
+
+CHECK: basic::<u64>
+       _RIC5basicyE
+
+CHECK: basic::<!>
+       _RIC5basiczE
+
 ; Invalid mangled characters
 
 CHECK: _RNvC2a.1c
        _RNvC2a.1c
 
 CHECK: _RNvC2a$1c
        _RNvC2a$1c