[Demangle][Rust] Parse char constants

[dblaikie]

Looks good - might need a test case for the error path if it's not already exercised by one of the other invalid tests (in which case does that invalid test changing to test this error path stop catching some error path that needs a new test instead?)

llvm/lib/Demangle/RustDemangle.cpp

469–472

Is this error path tested?

[tmiasko]

Add a test case for error code path

[tmiasko]

llvm/lib/Demangle/RustDemangle.cpp

469–472

I added a test case covering this, and used slightly tighter size bound on the number of digits.

llvm/include/llvm/Demangle/RustDemangle.h

 
 private:
   void demanglePath();
   void demangleGenericArg();
   void demangleType();
   void demangleConst();
   void demangleConstInt();
   void demangleConstBool();
+  void demangleConstChar();
 
   Identifier parseIdentifier();
   uint64_t parseOptionalBase62Number(char Tag);
   uint64_t parseBase62Number();
   uint64_t parseDecimalNumber();
   uint64_t parseHexNumber(StringView &HexDigits);
 
   void print(char C) {

llvm/lib/Demangle/RustDemangle.cpp

if (parseBasicType(consume(), Type)) {
     case BasicType::U64:
     case BasicType::U128:
     case BasicType::USize:
       demangleConstInt();
       break;
     case BasicType::Bool:
       demangleConstBool();
       break;
+    case BasicType::Char:
+      demangleConstChar();
+      break;
     case BasicType::Placeholder:
       print('_');
       break;
     default:
-      // FIXME demangle backreferences and char constants.
+      // FIXME demangle backreferences.
       Error = true;
       break;
     }
   } else {
     Error = true;
   }
 }
 
void Demangler::demangleConstBool() {
   if (HexDigits == "0")
     print("false");
   else if (HexDigits == "1")
     print("true");
   else
     Error = true;
 }
 
+/// Returns true if CodePoint represents a printable ASCII character.
+static bool isAsciiPrintable(uint64_t CodePoint) {
+  return 0x20 <= CodePoint && CodePoint <= 0x7e;
+}
+
+// <const-data> = <hex-number>
+void Demangler::demangleConstChar() {
+  StringView HexDigits;
+  uint64_t CodePoint = parseHexNumber(HexDigits);
+  if (Error || HexDigits.size() > 6) {
+    Error = true;
+    return;
+  }
+
+  print("'");
+  switch (CodePoint) {
+  case '\t':
+    print(R"(\t)");
+    break;
+  case '\r':
+    print(R"(\r)");
+    break;
+  case '\n':
+    print(R"(\n)");
+    break;
+  case '\\':
+    print(R"(\\)");
+    break;
+  case '"':
+    print(R"(")");
+    break;
+  case '\'':
+    print(R"(\')");
+    break;
+  default:
+    if (isAsciiPrintable(CodePoint)) {
+      char C = CodePoint;
+      print(C);
+    } else {
+      print(R"(\u{)");
+      print(HexDigits);
+      print('}');
+    }
+    break;
+  }
+  print('\'');
+}
+
 // <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

 ; Invalid bool constants
 
 CHECK: _RIC4boolKb2_E
        _RIC4boolKb2_E
 
 CHECK: _RIC4boolKbn0_E
        _RIC4boolKbn0_E
 
+; Char constants
+
+CHECK: char::<'a'>
+       _RIC4charKc61_E
+
+CHECK: char::<'"'>
+       _RIC4charKc22_E
+
+CHECK: char::<'\t'>
+       _RIC4charKc9_E
+
+CHECK: char::<'\r'>
+       _RIC4charKcd_E
+
+CHECK: char::<'\n'>
+       _RIC4charKca_E
+
+CHECK: char::<'\\'>
+       _RIC4charKc5c_E
+
+CHECK: char::<'\''>
+       _RIC4charKc27_E
+
+CHECK: char::<'\u{1f40d}'>
+       _RIC4charKc1f40d_E
+
+CHECK: char::<'\u{10ffff}'>
+       _RIC4charKc10ffff_E
+
+; Invalid char constants
+
+CHECK: _RIC4charKc1234567_E
+       _RIC4charKc1234567_E
+
 ; Invalid mangled characters
 
 CHECK: _RNvC2a.1c
        _RNvC2a.1c
 
 CHECK: _RNvC2a$1c
        _RNvC2a$1c