[StringView] remove consumeFront

[nickdesaulniers]

Summary

Towards converting our use of llvm::StringView to std::string_view,
remove a method that std::string_view doesn't have.

This could be moved to the nascent llvm/ADT/StringViewExtras.h, but the
use is highly localized to one TU. Move this to be a static function
there.

llvm/include/llvm/Demangle/ItaniumDemangle.h

template <typename Derived, typename Alloc> struct AbstractManglingParser {
 
   public:
     StringView getSymbol() const {
       StringView Res = Name;
       if (Kind < Unnameable) {
         assert(Res.startsWith("operator") &&
                "operator name does not start with 'operator'");
         Res.remove_prefix(sizeof("operator") - 1);
-        Res.consumeFront(' ');
+        if (Res.startsWith(' '))
+          Res.remove_prefix(1);
       }
       return Res;
     }
     StringView getName() const { return Name; }
     OIKind getKind() const { return Kind; }
     bool getFlag() const { return Flag; }
     Node::Prec getPrecedence() const { return Prec; }
   };

llvm/include/llvm/Demangle/StringView.h

char front() const {
     return *begin();
   }
 
   char back() const {
     assert(!empty());
     return *(end() - 1);
   }
 
-  bool consumeFront(char C) {
-    if (!startsWith(C))
-      return false;
-    remove_prefix(1);
-    return true;
-  }
-
-  bool consumeFront(StringView S) {
-    if (!startsWith(S))
-      return false;
-    remove_prefix(S.size());
-    return true;
-  }
-
   bool startsWith(char C) const { return !empty() && *begin() == C; }
 
   bool startsWith(StringView Str) const {
     if (Str.size() > size())
       return false;
     return std::strncmp(Str.begin(), begin(), Str.size()) == 0;
   }
 

llvm/lib/Demangle/MicrosoftDemangle.cpp

 }
 
 
 struct NodeList {
   Node *N = nullptr;
   NodeList *Next = nullptr;
 };
 
+static bool consumeFront(StringView &S, char C) {
+  if (!S.startsWith(C))
+    return false;
+  S.remove_prefix(1);
+  return true;
+}
+
+static bool consumeFront(StringView &S, StringView C) {
+  if (!S.startsWith(C))
+    return false;
+  S.remove_prefix(C.size());
+  return true;
+}
+
 static bool isMemberPointer(StringView MangledName, bool &Error) {
   Error = false;
   const char F = MangledName.front();
   MangledName.remove_prefix(1);
   switch (F) {
   case '$':
     // This is probably an rvalue reference (e.g. $$Q), and you cannot have an
     // rvalue reference to a member.
if (MangledName[0] != '6' && MangledName[0] != '8') {
       Error = true;
       return false;
     }
     return (MangledName[0] == '8');
   }
 
   // Remove ext qualifiers since those can appear on either type and are
   // therefore not indicative.
-  MangledName.consumeFront('E'); // 64-bit
-  MangledName.consumeFront('I'); // restrict
-  MangledName.consumeFront('F'); // unaligned
+  consumeFront(MangledName, 'E'); // 64-bit
+  consumeFront(MangledName, 'I'); // restrict
+  consumeFront(MangledName, 'F'); // unaligned
 
   if (MangledName.empty()) {
     Error = true;
     return false;
   }
 
   // The next value should be either ABCD (non-member) or QRST (member).
   switch (MangledName.front()) {
static bool isMemberPointer(StringView MangledName, bool &Error) {
   default:
     Error = true;
     return false;
   }
 }
 
 static SpecialIntrinsicKind
 consumeSpecialIntrinsicKind(StringView &MangledName) {
-  if (MangledName.consumeFront("?_7"))
+  if (consumeFront(MangledName, "?_7"))
     return SpecialIntrinsicKind::Vftable;
-  if (MangledName.consumeFront("?_8"))
+  if (consumeFront(MangledName, "?_8"))
     return SpecialIntrinsicKind::Vbtable;
-  if (MangledName.consumeFront("?_9"))
+  if (consumeFront(MangledName, "?_9"))
     return SpecialIntrinsicKind::VcallThunk;
-  if (MangledName.consumeFront("?_A"))
+  if (consumeFront(MangledName, "?_A"))
     return SpecialIntrinsicKind::Typeof;
-  if (MangledName.consumeFront("?_B"))
+  if (consumeFront(MangledName, "?_B"))
     return SpecialIntrinsicKind::LocalStaticGuard;
-  if (MangledName.consumeFront("?_C"))
+  if (consumeFront(MangledName, "?_C"))
     return SpecialIntrinsicKind::StringLiteralSymbol;
-  if (MangledName.consumeFront("?_P"))
+  if (consumeFront(MangledName, "?_P"))
     return SpecialIntrinsicKind::UdtReturning;
-  if (MangledName.consumeFront("?_R0"))
+  if (consumeFront(MangledName, "?_R0"))
     return SpecialIntrinsicKind::RttiTypeDescriptor;
-  if (MangledName.consumeFront("?_R1"))
+  if (consumeFront(MangledName, "?_R1"))
     return SpecialIntrinsicKind::RttiBaseClassDescriptor;
-  if (MangledName.consumeFront("?_R2"))
+  if (consumeFront(MangledName, "?_R2"))
     return SpecialIntrinsicKind::RttiBaseClassArray;
-  if (MangledName.consumeFront("?_R3"))
+  if (consumeFront(MangledName, "?_R3"))
     return SpecialIntrinsicKind::RttiClassHierarchyDescriptor;
-  if (MangledName.consumeFront("?_R4"))
+  if (consumeFront(MangledName, "?_R4"))
     return SpecialIntrinsicKind::RttiCompleteObjLocator;
-  if (MangledName.consumeFront("?_S"))
+  if (consumeFront(MangledName, "?_S"))
     return SpecialIntrinsicKind::LocalVftable;
-  if (MangledName.consumeFront("?__E"))
+  if (consumeFront(MangledName, "?__E"))
     return SpecialIntrinsicKind::DynamicInitializer;
-  if (MangledName.consumeFront("?__F"))
+  if (consumeFront(MangledName, "?__F"))
     return SpecialIntrinsicKind::DynamicAtexitDestructor;
-  if (MangledName.consumeFront("?__J"))
+  if (consumeFront(MangledName, "?__J"))
     return SpecialIntrinsicKind::LocalStaticThreadGuard;
   return SpecialIntrinsicKind::None;
 }
 
 static bool startsWithLocalScopePattern(StringView S) {
-  if (!S.consumeFront('?'))
+  if (!consumeFront(S, '?'))
     return false;
 
   size_t End = S.find('?');
   if (End == StringView::npos)
     return false;
   StringView Candidate = S.substr(0, End);
   if (Candidate.empty())
     return false;

 static bool isArrayType(StringView S) { return S[0] == 'Y'; }
 
 static bool isFunctionType(StringView S) {
   return S.startsWith("$$A8@@") || S.startsWith("$$A6");
 }
 
 static FunctionRefQualifier
 demangleFunctionRefQualifier(StringView &MangledName) {
-  if (MangledName.consumeFront('G'))
+  if (consumeFront(MangledName, 'G'))
     return FunctionRefQualifier::Reference;
-  else if (MangledName.consumeFront('H'))
+  else if (consumeFront(MangledName, 'H'))
     return FunctionRefQualifier::RValueReference;
   return FunctionRefQualifier::None;
 }
 
 static std::pair<Qualifiers, PointerAffinity>
 demanglePointerCVQualifiers(StringView &MangledName) {
-  if (MangledName.consumeFront("$$Q"))
+  if (consumeFront(MangledName, "$$Q"))
     return std::make_pair(Q_None, PointerAffinity::RValueReference);
 
   const char F = MangledName.front();
   MangledName.remove_prefix(1);
   switch (F) {
   case 'A':
     return std::make_pair(Q_None, PointerAffinity::Reference);
   case 'P':
Demangler::demangleSpecialTableSymbolNode(StringView &MangledName,
   char Front = MangledName.front();
   MangledName.remove_prefix(1);
   if (Front != '6' && Front != '7') {
     Error = true;
     return nullptr;
   }
 
   std::tie(STSN->Quals, IsMember) = demangleQualifiers(MangledName);
-  if (!MangledName.consumeFront('@'))
+  if (!consumeFront(MangledName, '@'))
     STSN->TargetName = demangleFullyQualifiedTypeName(MangledName);
   return STSN;
 }
 
 LocalStaticGuardVariableNode *
 Demangler::demangleLocalStaticGuard(StringView &MangledName, bool IsThread) {
   LocalStaticGuardIdentifierNode *LSGI =
       Arena.alloc<LocalStaticGuardIdentifierNode>();
   LSGI->IsThread = IsThread;
   QualifiedNameNode *QN = demangleNameScopeChain(MangledName, LSGI);
   LocalStaticGuardVariableNode *LSGVN =
       Arena.alloc<LocalStaticGuardVariableNode>();
   LSGVN->Name = QN;
 
-  if (MangledName.consumeFront("4IA"))
+  if (consumeFront(MangledName, "4IA"))
     LSGVN->IsVisible = false;
-  else if (MangledName.consumeFront("5"))
+  else if (consumeFront(MangledName, "5"))
     LSGVN->IsVisible = true;
   else {
     Error = true;
     return nullptr;
   }
 
   if (!MangledName.empty())
     LSGI->ScopeIndex = demangleUnsigned(MangledName);

 }
 
 VariableSymbolNode *Demangler::demangleUntypedVariable(
     ArenaAllocator &Arena, StringView &MangledName, StringView VariableName) {
   NamedIdentifierNode *NI = synthesizeNamedIdentifier(Arena, VariableName);
   QualifiedNameNode *QN = demangleNameScopeChain(MangledName, NI);
   VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>();
   VSN->Name = QN;
-  if (MangledName.consumeFront("8"))
+  if (consumeFront(MangledName, "8"))
     return VSN;
 
   Error = true;
   return nullptr;
 }
 
 VariableSymbolNode *
 Demangler::demangleRttiBaseClassDescriptorNode(ArenaAllocator &Arena,
                                                StringView &MangledName) {
   RttiBaseClassDescriptorNode *RBCDN =
       Arena.alloc<RttiBaseClassDescriptorNode>();
   RBCDN->NVOffset = demangleUnsigned(MangledName);
   RBCDN->VBPtrOffset = demangleSigned(MangledName);
   RBCDN->VBTableOffset = demangleUnsigned(MangledName);
   RBCDN->Flags = demangleUnsigned(MangledName);
   if (Error)
     return nullptr;
 
   VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>();
   VSN->Name = demangleNameScopeChain(MangledName, RBCDN);
-  MangledName.consumeFront('8');
+  consumeFront(MangledName, '8');
   return VSN;
 }
 
 FunctionSymbolNode *Demangler::demangleInitFiniStub(StringView &MangledName,
                                                     bool IsDestructor) {
   DynamicStructorIdentifierNode *DSIN =
       Arena.alloc<DynamicStructorIdentifierNode>();
   DSIN->IsDestructor = IsDestructor;
 
   bool IsKnownStaticDataMember = false;
-  if (MangledName.consumeFront('?'))
+  if (consumeFront(MangledName, '?'))
     IsKnownStaticDataMember = true;
 
   SymbolNode *Symbol = demangleDeclarator(MangledName);
   if (Error)
     return nullptr;
 
   FunctionSymbolNode *FSN = nullptr;
 
   if (Symbol->kind() == NodeKind::VariableSymbol) {
     DSIN->Variable = static_cast<VariableSymbolNode *>(Symbol);
 
     // Older versions of clang mangled this type of symbol incorrectly.  They
     // would omit the leading ? and they would only emit a single @ at the end.
     // The correct mangling is a leading ? and 2 trailing @ signs.  Handle
     // both cases.
     int AtCount = IsKnownStaticDataMember ? 2 : 1;
     for (int I = 0; I < AtCount; ++I) {
-      if (MangledName.consumeFront('@'))
+      if (consumeFront(MangledName, '@'))
         continue;
       Error = true;
       return nullptr;
     }
 
     FSN = demangleFunctionEncoding(MangledName);
     if (FSN)
       FSN->Name = synthesizeQualifiedName(Arena, DSIN);
SymbolNode *Demangler::demangleSpecialIntrinsic(StringView &MangledName) {
   case SpecialIntrinsicKind::LocalStaticGuard:
     return demangleLocalStaticGuard(MangledName, /*IsThread=*/false);
   case SpecialIntrinsicKind::LocalStaticThreadGuard:
     return demangleLocalStaticGuard(MangledName, /*IsThread=*/true);
   case SpecialIntrinsicKind::RttiTypeDescriptor: {
     TypeNode *T = demangleType(MangledName, QualifierMangleMode::Result);
     if (Error)
       break;
-    if (!MangledName.consumeFront("@8"))
+    if (!consumeFront(MangledName, "@8"))
       break;
     if (!MangledName.empty())
       break;
     return synthesizeVariable(Arena, T, "`RTTI Type Descriptor'");
   }
   case SpecialIntrinsicKind::RttiBaseClassArray:
     return demangleUntypedVariable(Arena, MangledName,
                                    "`RTTI Base Class Array'");

 Demangler::demangleFunctionIdentifierCode(StringView &MangledName) {
   assert(MangledName.startsWith('?'));
   MangledName.remove_prefix(1);
   if (MangledName.empty()) {
     Error = true;
     return nullptr;
   }
 
-  if (MangledName.consumeFront("__"))
+  if (consumeFront(MangledName, "__"))
     return demangleFunctionIdentifierCode(
         MangledName, FunctionIdentifierCodeGroup::DoubleUnder);
-  if (MangledName.consumeFront("_"))
+  if (consumeFront(MangledName, "_"))
     return demangleFunctionIdentifierCode(MangledName,
                                           FunctionIdentifierCodeGroup::Under);
   return demangleFunctionIdentifierCode(MangledName,
                                         FunctionIdentifierCodeGroup::Basic);
 }
 
 StructorIdentifierNode *
 Demangler::demangleStructorIdentifier(StringView &MangledName,
SymbolNode *Demangler::demangleMD5Name(StringView &MangledName) {
   //    for the object to have an MD5 name, the complete object locator is
   //    called ??@...@??_R4@ (with a trailing "??_R4@" instead of the usual
   //    leading "??_R4". This is handled here.
   // 2. For catchable types, in versions of MSVC before 2015 (<1900) or after
   //    2017.2 (>= 1914), the catchable type mangling is _CT??@...@??@...@8
   //    instead of_CT??@...@8 with just one MD5 name. Since we don't yet
   //    demangle catchable types anywhere, this isn't handled for MD5 names
   //    either.
-  MangledName.consumeFront("??_R4@");
+  consumeFront(MangledName, "??_R4@");
 
   StringView MD5(Start, MangledName.begin() - Start);
   SymbolNode *S = Arena.alloc<SymbolNode>(NodeKind::Md5Symbol);
   S->Name = synthesizeQualifiedName(Arena, MD5);
 
   return S;
 }
 
 SymbolNode *Demangler::demangleTypeinfoName(StringView &MangledName) {
   assert(MangledName.startsWith('.'));
-  MangledName.consumeFront('.');
+  consumeFront(MangledName, '.');
 
   TypeNode *T = demangleType(MangledName, QualifierMangleMode::Result);
   if (Error || !MangledName.empty()) {
     Error = true;
     return nullptr;
   }
   return synthesizeVariable(Arena, T, "`RTTI Type Descriptor Name'");
 }
if (MangledName.startsWith("??@"))
     return demangleMD5Name(MangledName);
 
   // MSVC-style mangled symbols must start with '?'.
   if (!MangledName.startsWith('?')) {
     Error = true;
     return nullptr;
   }
 
-  MangledName.consumeFront('?');
+  consumeFront(MangledName, '?');
 
   // ?$ is a template instantiation, but all other names that start with ? are
   // operators / special names.
   if (SymbolNode *SI = demangleSpecialIntrinsic(MangledName))
     return SI;
 
   return demangleDeclarator(MangledName);
 }
 
 TagTypeNode *Demangler::parseTagUniqueName(StringView &MangledName) {
-  if (!MangledName.consumeFront(".?A")) {
+  if (!consumeFront(MangledName, ".?A")) {
     Error = true;
     return nullptr;
   }
-  MangledName.consumeFront(".?A");
+  consumeFront(MangledName, ".?A");
   if (MangledName.empty()) {
     Error = true;
     return nullptr;
   }
 
   return demangleClassType(MangledName);
 }
 

 //
 // <number>               ::= [?] <non-negative integer>
 //
 // <non-negative integer> ::= <decimal digit> # when 1 <= Number <= 10
 //                        ::= <hex digit>+ @  # when Number == 0 or >= 10
 //
 // <hex-digit>            ::= [A-P]           # A = 0, B = 1, ...
 std::pair<uint64_t, bool> Demangler::demangleNumber(StringView &MangledName) {
-  bool IsNegative = MangledName.consumeFront('?');
+  bool IsNegative = consumeFront(MangledName, '?');
 
   if (startsWithDigit(MangledName)) {
     uint64_t Ret = MangledName[0] - '0' + 1;
     MangledName.remove_prefix(1);
     return {Ret, IsNegative};
   }
 
   uint64_t Ret = 0;
void Demangler::memorizeIdentifier(IdentifierNode *Identifier) {
   memorizeString(Owned);
   std::free(OB.getBuffer());
 }
 
 IdentifierNode *
 Demangler::demangleTemplateInstantiationName(StringView &MangledName,
                                              NameBackrefBehavior NBB) {
   assert(MangledName.startsWith("?$"));
-  MangledName.consumeFront("?$");
+  consumeFront(MangledName, "?$");
 
   BackrefContext OuterContext;
   std::swap(OuterContext, Backrefs);
 
   IdentifierNode *Identifier =
       demangleUnqualifiedSymbolName(MangledName, NBB_Simple);
   if (!Error)
     Identifier->TemplateParams = demangleTemplateParameterList(MangledName);
if (!MangledName.startsWith('?')) {
     MangledName.remove_prefix(1);
     return F;
   }
 
   MangledName.remove_prefix(1);
   if (MangledName.empty())
     goto CharLiteralError;
 
-  if (MangledName.consumeFront('$')) {
+  if (consumeFront(MangledName, '$')) {
     // Two hex digits
     if (MangledName.size() < 2)
       goto CharLiteralError;
     StringView Nibbles = MangledName.substr(0, 2);
     if (!isRebasedHexDigit(Nibbles[0]) || !isRebasedHexDigit(Nibbles[1]))
       goto CharLiteralError;
     // Don't append the null terminator.
     uint8_t C1 = rebasedHexDigitToNumber(Nibbles[0]);

 FunctionSymbolNode *Demangler::demangleVcallThunkNode(StringView &MangledName) {
   FunctionSymbolNode *FSN = Arena.alloc<FunctionSymbolNode>();
   VcallThunkIdentifierNode *VTIN = Arena.alloc<VcallThunkIdentifierNode>();
   FSN->Signature = Arena.alloc<ThunkSignatureNode>();
   FSN->Signature->FunctionClass = FC_NoParameterList;
 
   FSN->Name = demangleNameScopeChain(MangledName, VTIN);
   if (!Error)
-    Error = !MangledName.consumeFront("$B");
+    Error = !consumeFront(MangledName, "$B");
   if (!Error)
     VTIN->OffsetInVTable = demangleUnsigned(MangledName);
   if (!Error)
-    Error = !MangledName.consumeFront('A');
+    Error = !consumeFront(MangledName, 'A');
   if (!Error)
     FSN->Signature->CallConvention = demangleCallingConvention(MangledName);
   return (Error) ? nullptr : FSN;
 }
 
 EncodedStringLiteralNode *
 Demangler::demangleStringLiteral(StringView &MangledName) {
   // This function uses goto, so declare all variables up front.
   OutputBuffer OB;
   StringView CRC;
   uint64_t StringByteSize;
   bool IsWcharT = false;
   bool IsNegative = false;
   size_t CrcEndPos = 0;
   char F;
 
   EncodedStringLiteralNode *Result = Arena.alloc<EncodedStringLiteralNode>();
 
   // Prefix indicating the beginning of a string literal
-  if (!MangledName.consumeFront("@_"))
+  if (!consumeFront(MangledName, "@_"))
     goto StringLiteralError;
   if (MangledName.empty())
     goto StringLiteralError;
 
   // Char Type (regular or wchar_t)
   F = MangledName.front();
   MangledName.remove_prefix(1);
   switch (F) {
Demangler::demangleStringLiteral(StringView &MangledName) {
   if (MangledName.empty())
     goto StringLiteralError;
 
   if (IsWcharT) {
     Result->Char = CharKind::Wchar;
     if (StringByteSize > 64)
       Result->IsTruncated = true;
 
-    while (!MangledName.consumeFront('@')) {
+    while (!consumeFront(MangledName, '@')) {
       if (MangledName.size() < 2)
         goto StringLiteralError;
       wchar_t W = demangleWcharLiteral(MangledName);
       if (StringByteSize != 2 || Result->IsTruncated)
         outputEscapedChar(OB, W);
       StringByteSize -= 2;
       if (Error)
         goto StringLiteralError;
     }
   } else {
     // The max byte length is actually 32, but some compilers mangled strings
     // incorrectly, so we have to assume it can go higher.
     constexpr unsigned MaxStringByteLength = 32 * 4;
     uint8_t StringBytes[MaxStringByteLength];
 
     unsigned BytesDecoded = 0;
-    while (!MangledName.consumeFront('@')) {
+    while (!consumeFront(MangledName, '@')) {
       if (MangledName.size() < 1 || BytesDecoded >= MaxStringByteLength)
         goto StringLiteralError;
       StringBytes[BytesDecoded++] = demangleCharLiteral(MangledName);
     }
 
     if (StringByteSize > BytesDecoded)
       Result->IsTruncated = true;
 
StringView Demangler::demangleSimpleString(StringView &MangledName,
 
   Error = true;
   return {};
 }
 
 NamedIdentifierNode *
 Demangler::demangleAnonymousNamespaceName(StringView &MangledName) {
   assert(MangledName.startsWith("?A"));
-  MangledName.consumeFront("?A");
+  consumeFront(MangledName, "?A");
 
   NamedIdentifierNode *Node = Arena.alloc<NamedIdentifierNode>();
   Node->Name = "`anonymous namespace'";
   size_t EndPos = MangledName.find('@');
   if (EndPos == StringView::npos) {
     Error = true;
     return nullptr;
   }
   StringView NamespaceKey = MangledName.substr(0, EndPos);
   memorizeString(NamespaceKey);
   MangledName = MangledName.substr(EndPos + 1);
   return Node;
 }
 
 NamedIdentifierNode *
 Demangler::demangleLocallyScopedNamePiece(StringView &MangledName) {
   assert(startsWithLocalScopePattern(MangledName));
 
   NamedIdentifierNode *Identifier = Arena.alloc<NamedIdentifierNode>();
-  MangledName.consumeFront('?');
+  consumeFront(MangledName, '?');
   uint64_t Number = 0;
   bool IsNegative = false;
   std::tie(Number, IsNegative) = demangleNumber(MangledName);
   assert(!IsNegative);
 
   // One ? to terminate the number
-  MangledName.consumeFront('?');
+  consumeFront(MangledName, '?');
 
   assert(!Error);
   Node *Scope = parse(MangledName);
   if (Error)
     return nullptr;
 
   // Render the parent symbol's name into a buffer.
   OutputBuffer OB;

 QualifiedNameNode *
 Demangler::demangleNameScopeChain(StringView &MangledName,
                                   IdentifierNode *UnqualifiedName) {
   NodeList *Head = Arena.alloc<NodeList>();
 
   Head->N = UnqualifiedName;
 
   size_t Count = 1;
-  while (!MangledName.consumeFront("@")) {
+  while (!consumeFront(MangledName, "@")) {
     ++Count;
     NodeList *NewHead = Arena.alloc<NodeList>();
     NewHead->Next = Head;
     Head = NewHead;
 
     if (MangledName.empty()) {
       Error = true;
       return nullptr;
FuncClass Demangler::demangleFunctionClass(StringView &MangledName) {
   case 'X':
     return FuncClass(FC_Public | FC_Virtual | FC_StaticThisAdjust | FC_Far);
   case 'Y':
     return FuncClass(FC_Global);
   case 'Z':
     return FuncClass(FC_Global | FC_Far);
   case '$': {
     FuncClass VFlag = FC_VirtualThisAdjust;
-    if (MangledName.consumeFront('R'))
+    if (consumeFront(MangledName, 'R'))
       VFlag = FuncClass(VFlag | FC_VirtualThisAdjustEx);
     if (MangledName.empty())
       break;
     const char F = MangledName.front();
     MangledName.remove_prefix(1);
     switch (F) {
     case '0':
       return FuncClass(FC_Private | FC_Virtual | VFlag);

 //                 ::= <type> <pointee-cvr-qualifiers> # pointers, references
 TypeNode *Demangler::demangleType(StringView &MangledName,
                                   QualifierMangleMode QMM) {
   Qualifiers Quals = Q_None;
   bool IsMember = false;
   if (QMM == QualifierMangleMode::Mangle) {
     std::tie(Quals, IsMember) = demangleQualifiers(MangledName);
   } else if (QMM == QualifierMangleMode::Result) {
-    if (MangledName.consumeFront('?'))
+    if (consumeFront(MangledName, '?'))
       std::tie(Quals, IsMember) = demangleQualifiers(MangledName);
   }
 
   if (MangledName.empty()) {
     Error = true;
     return nullptr;
   }
 
   TypeNode *Ty = nullptr;
   if (isTagType(MangledName))
     Ty = demangleClassType(MangledName);
   else if (isPointerType(MangledName)) {
     if (isMemberPointer(MangledName, Error))
       Ty = demangleMemberPointerType(MangledName);
     else if (!Error)
       Ty = demanglePointerType(MangledName);
     else
       return nullptr;
   } else if (isArrayType(MangledName))
     Ty = demangleArrayType(MangledName);
   else if (isFunctionType(MangledName)) {
-    if (MangledName.consumeFront("$$A8@@"))
+    if (consumeFront(MangledName, "$$A8@@"))
       Ty = demangleFunctionType(MangledName, true);
     else {
       assert(MangledName.startsWith("$$A6"));
-      MangledName.consumeFront("$$A6");
+      consumeFront(MangledName, "$$A6");
       Ty = demangleFunctionType(MangledName, false);
     }
   } else if (isCustomType(MangledName)) {
     Ty = demangleCustomType(MangledName);
   } else {
     Ty = demanglePrimitiveType(MangledName);
   }
 
   if (!Ty || Error)
     return Ty;
   Ty->Quals = Qualifiers(Ty->Quals | Quals);
   return Ty;
 }
 
 bool Demangler::demangleThrowSpecification(StringView &MangledName) {
-  if (MangledName.consumeFront("_E"))
+  if (consumeFront(MangledName, "_E"))
     return true;
-  if (MangledName.consumeFront('Z'))
+  if (consumeFront(MangledName, 'Z'))
     return false;
 
   Error = true;
   return false;
 }
 
 FunctionSignatureNode *Demangler::demangleFunctionType(StringView &MangledName,
                                                        bool HasThisQuals) {
   FunctionSignatureNode *FTy = Arena.alloc<FunctionSignatureNode>();
 
   if (HasThisQuals) {
     FTy->Quals = demanglePointerExtQualifiers(MangledName);
     FTy->RefQualifier = demangleFunctionRefQualifier(MangledName);
     FTy->Quals = Qualifiers(FTy->Quals | demangleQualifiers(MangledName).first);
   }
 
   // Fields that appear on both member and non-member functions.
   FTy->CallConvention = demangleCallingConvention(MangledName);
 
   // <return-type> ::= <type>
   //               ::= @ # structors (they have no declared return type)
-  bool IsStructor = MangledName.consumeFront('@');
+  bool IsStructor = consumeFront(MangledName, '@');
   if (!IsStructor)
     FTy->ReturnType = demangleType(MangledName, QualifierMangleMode::Result);
 
   FTy->Params = demangleFunctionParameterList(MangledName, FTy->IsVariadic);
 
   FTy->IsNoexcept = demangleThrowSpecification(MangledName);
 
   return FTy;
 }
 
 FunctionSymbolNode *
 Demangler::demangleFunctionEncoding(StringView &MangledName) {
   FuncClass ExtraFlags = FC_None;
-  if (MangledName.consumeFront("$$J0"))
+  if (consumeFront(MangledName, "$$J0"))
     ExtraFlags = FC_ExternC;
 
   if (MangledName.empty()) {
     Error = true;
     return nullptr;
   }
 
   FuncClass FC = demangleFunctionClass(MangledName);

 }
 
 CustomTypeNode *Demangler::demangleCustomType(StringView &MangledName) {
   assert(MangledName.startsWith('?'));
   MangledName.remove_prefix(1);
 
   CustomTypeNode *CTN = Arena.alloc<CustomTypeNode>();
   CTN->Identifier = demangleUnqualifiedTypeName(MangledName, /*Memorize=*/true);
-  if (!MangledName.consumeFront('@'))
+  if (!consumeFront(MangledName, '@'))
     Error = true;
   if (Error)
     return nullptr;
   return CTN;
 }
 
 // Reads a primitive type.
 PrimitiveTypeNode *Demangler::demanglePrimitiveType(StringView &MangledName) {
-  if (MangledName.consumeFront("$$T"))
+  if (consumeFront(MangledName, "$$T"))
     return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Nullptr);
 
   const char F = MangledName.front();
   MangledName.remove_prefix(1);
   switch (F) {
   case 'X':
     return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Void);
   case 'D':
case 'T':
     break;
   case 'U':
     TT = Arena.alloc<TagTypeNode>(TagKind::Struct);
     break;
   case 'V':
     TT = Arena.alloc<TagTypeNode>(TagKind::Class);
     break;
   case 'W':
-    if (!MangledName.consumeFront('4')) {
+    if (!consumeFront(MangledName, '4')) {
       Error = true;
       return nullptr;
     }
     TT = Arena.alloc<TagTypeNode>(TagKind::Enum);
     break;
   default:
     assert(false);
   }
 
   TT->QualifiedName = demangleFullyQualifiedTypeName(MangledName);
   return TT;
 }
 
 // <pointer-type> ::= E? <pointer-cvr-qualifiers> <ext-qualifiers> <type>
 //                       # the E is required for 64-bit non-static pointers
 PointerTypeNode *Demangler::demanglePointerType(StringView &MangledName) {
   PointerTypeNode *Pointer = Arena.alloc<PointerTypeNode>();
 
   std::tie(Pointer->Quals, Pointer->Affinity) =
       demanglePointerCVQualifiers(MangledName);
 
-  if (MangledName.consumeFront("6")) {
+  if (consumeFront(MangledName, "6")) {
     Pointer->Pointee = demangleFunctionType(MangledName, false);
     return Pointer;
   }
 
   Qualifiers ExtQuals = demanglePointerExtQualifiers(MangledName);
   Pointer->Quals = Qualifiers(Pointer->Quals | ExtQuals);
 
   Pointer->Pointee = demangleType(MangledName, QualifierMangleMode::Mangle);
   return Pointer;
 }
 
 PointerTypeNode *Demangler::demangleMemberPointerType(StringView &MangledName) {
   PointerTypeNode *Pointer = Arena.alloc<PointerTypeNode>();
 
   std::tie(Pointer->Quals, Pointer->Affinity) =
       demanglePointerCVQualifiers(MangledName);
   assert(Pointer->Affinity == PointerAffinity::Pointer);
 
   Qualifiers ExtQuals = demanglePointerExtQualifiers(MangledName);
   Pointer->Quals = Qualifiers(Pointer->Quals | ExtQuals);
 
   // isMemberPointer() only returns true if there is at least one character
   // after the qualifiers.
-  if (MangledName.consumeFront("8")) {
+  if (consumeFront(MangledName, "8")) {
     Pointer->ClassParent = demangleFullyQualifiedTypeName(MangledName);
     Pointer->Pointee = demangleFunctionType(MangledName, true);
   } else {
     Qualifiers PointeeQuals = Q_None;
     bool IsMember = false;
     std::tie(PointeeQuals, IsMember) = demangleQualifiers(MangledName);
     assert(IsMember || Error);
     Pointer->ClassParent = demangleFullyQualifiedTypeName(MangledName);
 
     Pointer->Pointee = demangleType(MangledName, QualifierMangleMode::Drop);
     if (Pointer->Pointee)
       Pointer->Pointee->Quals = PointeeQuals;
   }
 
   return Pointer;
 }
 
 Qualifiers Demangler::demanglePointerExtQualifiers(StringView &MangledName) {
   Qualifiers Quals = Q_None;
-  if (MangledName.consumeFront('E'))
+  if (consumeFront(MangledName, 'E'))
     Quals = Qualifiers(Quals | Q_Pointer64);
-  if (MangledName.consumeFront('I'))
+  if (consumeFront(MangledName, 'I'))
     Quals = Qualifiers(Quals | Q_Restrict);
-  if (MangledName.consumeFront('F'))
+  if (consumeFront(MangledName, 'F'))
     Quals = Qualifiers(Quals | Q_Unaligned);
 
   return Quals;
 }
 
 ArrayTypeNode *Demangler::demangleArrayType(StringView &MangledName) {
   assert(MangledName.front() == 'Y');
   MangledName.remove_prefix(1);
for (uint64_t I = 0; I < Rank; ++I) {
     Tail->N = Arena.alloc<IntegerLiteralNode>(D, IsNegative);
     if (I + 1 < Rank) {
       Tail->Next = Arena.alloc<NodeList>();
       Tail = Tail->Next;
     }
   }
   ATy->Dimensions = nodeListToNodeArray(Arena, Head, Rank);
 
-  if (MangledName.consumeFront("$$C")) {
+  if (consumeFront(MangledName, "$$C")) {
     bool IsMember = false;
     std::tie(ATy->Quals, IsMember) = demangleQualifiers(MangledName);
     if (IsMember) {
       Error = true;
       return nullptr;
     }
   }
 
   ATy->ElementType = demangleType(MangledName, QualifierMangleMode::Drop);
   return ATy;
 }
 
 // Reads a function's parameters.
 NodeArrayNode *Demangler::demangleFunctionParameterList(StringView &MangledName,
                                                         bool &IsVariadic) {
   // Empty parameter list.
-  if (MangledName.consumeFront('X'))
+  if (consumeFront(MangledName, 'X'))
     return nullptr;
 
   NodeList *Head = Arena.alloc<NodeList>();
   NodeList **Current = &Head;
   size_t Count = 0;
   while (!Error && !MangledName.startsWith('@') &&
          !MangledName.startsWith('Z')) {
     ++Count;
NodeArrayNode *Demangler::demangleFunctionParameterList(StringView &MangledName,
 
   if (Error)
     return nullptr;
 
   NodeArrayNode *NA = nodeListToNodeArray(Arena, Head, Count);
   // A non-empty parameter list is terminated by either 'Z' (variadic) parameter
   // list or '@' (non variadic).  Careful not to consume "@Z", as in that case
   // the following Z could be a throw specifier.
-  if (MangledName.consumeFront('@'))
+  if (consumeFront(MangledName, '@'))
     return NA;
 
-  if (MangledName.consumeFront('Z')) {
+  if (consumeFront(MangledName, 'Z')) {
     IsVariadic = true;
     return NA;
   }
 
   DEMANGLE_UNREACHABLE;
 }
 
 NodeArrayNode *
 Demangler::demangleTemplateParameterList(StringView &MangledName) {
   NodeList *Head = nullptr;
   NodeList **Current = &Head;
   size_t Count = 0;
 
   while (!MangledName.startsWith('@')) {
-    if (MangledName.consumeFront("$S") || MangledName.consumeFront("$$V") ||
-        MangledName.consumeFront("$$$V") || MangledName.consumeFront("$$Z")) {
+    if (consumeFront(MangledName, "$S") || consumeFront(MangledName, "$$V") ||
+        consumeFront(MangledName, "$$$V") || consumeFront(MangledName, "$$Z")) {
       // parameter pack separator
       continue;
     }
 
     ++Count;
 
     // Template parameter lists don't participate in back-referencing.
     *Current = Arena.alloc<NodeList>();
 
     NodeList &TP = **Current;
 
     TemplateParameterReferenceNode *TPRN = nullptr;
-    if (MangledName.consumeFront("$$Y")) {
+    if (consumeFront(MangledName, "$$Y")) {
       // Template alias
       TP.N = demangleFullyQualifiedTypeName(MangledName);
-    } else if (MangledName.consumeFront("$$B")) {
+    } else if (consumeFront(MangledName, "$$B")) {
       // Array
       TP.N = demangleType(MangledName, QualifierMangleMode::Drop);
-    } else if (MangledName.consumeFront("$$C")) {
+    } else if (consumeFront(MangledName, "$$C")) {
       // Type has qualifiers.
       TP.N = demangleType(MangledName, QualifierMangleMode::Mangle);
     } else if (MangledName.startsWith("$1") || MangledName.startsWith("$H") ||
                MangledName.startsWith("$I") || MangledName.startsWith("$J")) {
       // Pointer to member
       TP.N = TPRN = Arena.alloc<TemplateParameterReferenceNode>();
       TPRN->IsMemberPointer = true;
 
if (consumeFront(MangledName, "$$Y")) {
       case '1':
         break;
       default:
         DEMANGLE_UNREACHABLE;
       }
       TPRN->Affinity = PointerAffinity::Pointer;
       TPRN->Symbol = S;
     } else if (MangledName.startsWith("$E?")) {
-      MangledName.consumeFront("$E");
+      consumeFront(MangledName, "$E");
       // Reference to symbol
       TP.N = TPRN = Arena.alloc<TemplateParameterReferenceNode>();
       TPRN->Symbol = parse(MangledName);
       TPRN->Affinity = PointerAffinity::Reference;
     } else if (MangledName.startsWith("$F") || MangledName.startsWith("$G")) {
       TP.N = TPRN = Arena.alloc<TemplateParameterReferenceNode>();
 
       // Data member pointer.
if (consumeFront(MangledName, "$$Y")) {
         TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] =
             demangleSigned(MangledName);
         break;
       default:
         DEMANGLE_UNREACHABLE;
       }
       TPRN->IsMemberPointer = true;
 
-    } else if (MangledName.consumeFront("$0")) {
+    } else if (consumeFront(MangledName, "$0")) {
       // Integral non-type template parameter
       bool IsNegative = false;
       uint64_t Value = 0;
       std::tie(Value, IsNegative) = demangleNumber(MangledName);
 
       TP.N = Arena.alloc<IntegerLiteralNode>(Value, IsNegative);
     } else {
       TP.N = demangleType(MangledName, QualifierMangleMode::Drop);
     }
     if (Error)
       return nullptr;
 
     Current = &TP.Next;
   }
 
   // The loop above returns nullptr on Error.
   assert(!Error);
 
   // Template parameter lists cannot be variadic, so it can only be terminated
   // by @ (as opposed to 'Z' in the function parameter case).
   assert(MangledName.startsWith('@')); // The above loop exits only on '@'.
-  MangledName.consumeFront('@');
+  consumeFront(MangledName, '@');
   return nodeListToNodeArray(Arena, Head, Count);
 }
 
 void Demangler::dumpBackReferences() {
   std::printf("%d function parameter backreferences\n",
               (int)Backrefs.FunctionParamCount);
 
   // Create an output stream so we can render each type.

llvm/lib/Demangle/RustDemangle.cpp

 // <symbol-name> = "_R" <path> [<instantiating-crate>]
 bool Demangler::demangle(StringView Mangled) {
   Position = 0;
   Error = false;
   Print = true;
   RecursionLevel = 0;
   BoundLifetimes = 0;
 
-  if (!Mangled.consumeFront("_R")) {
+  if (!Mangled.startsWith("_R")) {
     Error = true;
     return false;
   }
+  Mangled.remove_prefix(2);
   size_t Dot = Mangled.find('.');
   Input = Dot == StringView::npos ? Mangled : Mangled.substr(0, Dot);
 
   demanglePath(IsInType::No);
 
   if (Position != Input.size()) {
     ScopedOverride<bool> SavePrint(Print, false);
     demanglePath(IsInType::No);