[StringView] remove popFront

[nickdesaulniers]

Summary

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

llvm::StringView::popFront is similar to std::string_view::remove_prefix
but with a reference to std::string_view::front taken first.

llvm/include/llvm/Demangle/StringView.h

char front() const {
     return *begin();
   }
 
   char back() const {
     assert(!empty());
     return *(end() - 1);
   }
 
-  char popFront() {
-    assert(!empty());
-    return *First++;
-  }
-
   bool consumeFront(char C) {
     if (!startsWith(C))
       return false;
     remove_prefix(1);
     return true;
   }
 
   bool consumeFront(StringView S) {

llvm/lib/Demangle/MicrosoftDemangle.cpp

 
 struct NodeList {
   Node *N = nullptr;
   NodeList *Next = nullptr;
 };
 
 static bool isMemberPointer(StringView MangledName, bool &Error) {
   Error = false;
-  switch (MangledName.popFront()) {
+  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.
     return false;
   case 'A':
     // 'A' indicates a reference, and you cannot have a reference to a member
     // function or member.
     return false;
demangleFunctionRefQualifier(StringView &MangledName) {
   return FunctionRefQualifier::None;
 }
 
 static std::pair<Qualifiers, PointerAffinity>
 demanglePointerCVQualifiers(StringView &MangledName) {
   if (MangledName.consumeFront("$$Q"))
     return std::make_pair(Q_None, PointerAffinity::RValueReference);
 
-  switch (MangledName.popFront()) {
+  const char F = MangledName.front();
+  MangledName.remove_prefix(1);
+  switch (F) {
   case 'A':
     return std::make_pair(Q_None, PointerAffinity::Reference);
   case 'P':
     return std::make_pair(Q_None, PointerAffinity::Pointer);
   case 'Q':
     return std::make_pair(Q_Const, PointerAffinity::Pointer);
   case 'R':
     return std::make_pair(Q_Volatile, PointerAffinity::Pointer);
Demangler::demangleSpecialTableSymbolNode(StringView &MangledName,
   QualifiedNameNode *QN = demangleNameScopeChain(MangledName, NI);
   SpecialTableSymbolNode *STSN = Arena.alloc<SpecialTableSymbolNode>();
   STSN->Name = QN;
   bool IsMember = false;
   if (MangledName.empty()) {
     Error = true;
     return nullptr;
   }
-  char Front = MangledName.popFront();
+  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('@'))
     STSN->TargetName = demangleFullyQualifiedTypeName(MangledName);

 
 IdentifierNode *
 Demangler::demangleFunctionIdentifierCode(StringView &MangledName,
                                           FunctionIdentifierCodeGroup Group) {
   if (MangledName.empty()) {
     Error = true;
     return nullptr;
   }
+  const char CH = MangledName.front();
   switch (Group) {
   case FunctionIdentifierCodeGroup::Basic:
-    switch (char CH = MangledName.popFront()) {
+    MangledName.remove_prefix(1);
+    switch (CH) {
     case '0':
     case '1':
       return demangleStructorIdentifier(MangledName, CH == '1');
     case 'B':
       return demangleConversionOperatorIdentifier(MangledName);
     default:
       return Arena.alloc<IntrinsicFunctionIdentifierNode>(
           translateIntrinsicFunctionCode(CH, Group));
     }
   case FunctionIdentifierCodeGroup::Under:
+    MangledName.remove_prefix(1);
     return Arena.alloc<IntrinsicFunctionIdentifierNode>(
-        translateIntrinsicFunctionCode(MangledName.popFront(), Group));
+        translateIntrinsicFunctionCode(CH, Group));
   case FunctionIdentifierCodeGroup::DoubleUnder:
-    switch (char CH = MangledName.popFront()) {
+    MangledName.remove_prefix(1);
+    switch (CH) {
     case 'K':
       return demangleLiteralOperatorIdentifier(MangledName);
     default:
       return Arena.alloc<IntrinsicFunctionIdentifierNode>(
           translateIntrinsicFunctionCode(CH, Group));
     }
   }
 

 
 static uint8_t rebasedHexDigitToNumber(char C) {
   assert(isRebasedHexDigit(C));
   return (C <= 'J') ? (C - 'A') : (10 + C - 'K');
 }
 
 uint8_t Demangler::demangleCharLiteral(StringView &MangledName) {
   assert(!MangledName.empty());
-  if (!MangledName.startsWith('?'))
-    return MangledName.popFront();
+  if (!MangledName.startsWith('?')) {
+    const uint8_t F = MangledName.front();
+    MangledName.remove_prefix(1);
+    return F;
+  }
 
   MangledName.remove_prefix(1);
   if (MangledName.empty())
     goto CharLiteralError;
 
   if (MangledName.consumeFront('$')) {
     // Two hex digits
     if (MangledName.size() < 2)

 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("@_"))
     goto StringLiteralError;
   if (MangledName.empty())
     goto StringLiteralError;
 
   // Char Type (regular or wchar_t)
-  switch (MangledName.popFront()) {
+  F = MangledName.front();
+  MangledName.remove_prefix(1);
+  switch (F) {
   case '1':
     IsWcharT = true;
     DEMANGLE_FALLTHROUGH;
   case '0':
     break;
   default:
     goto StringLiteralError;
   }
Demangler::demangleNameScopeChain(StringView &MangledName,
   }
 
   QualifiedNameNode *QN = Arena.alloc<QualifiedNameNode>();
   QN->Components = nodeListToNodeArray(Arena, Head, Count);
   return QN;
 }
 
 FuncClass Demangler::demangleFunctionClass(StringView &MangledName) {
-  switch (MangledName.popFront()) {
+  const char F = MangledName.front();
+  MangledName.remove_prefix(1);
+  switch (F) {
   case '9':
     return FuncClass(FC_ExternC | FC_NoParameterList);
   case 'A':
     return FC_Private;
   case 'B':
     return FuncClass(FC_Private | FC_Far);
   case 'C':
     return FuncClass(FC_Private | FC_Static);
FuncClass Demangler::demangleFunctionClass(StringView &MangledName) {
   case 'Z':
     return FuncClass(FC_Global | FC_Far);
   case '$': {
     FuncClass VFlag = FC_VirtualThisAdjust;
     if (MangledName.consumeFront('R'))
       VFlag = FuncClass(VFlag | FC_VirtualThisAdjustEx);
     if (MangledName.empty())
       break;
-    switch (MangledName.popFront()) {
+    const char F = MangledName.front();
+    MangledName.remove_prefix(1);
+    switch (F) {
     case '0':
       return FuncClass(FC_Private | FC_Virtual | VFlag);
     case '1':
       return FuncClass(FC_Private | FC_Virtual | VFlag | FC_Far);
     case '2':
       return FuncClass(FC_Protected | FC_Virtual | VFlag);
     case '3':
       return FuncClass(FC_Protected | FC_Virtual | VFlag | FC_Far);

 }
 
 CallingConv Demangler::demangleCallingConvention(StringView &MangledName) {
   if (MangledName.empty()) {
     Error = true;
     return CallingConv::None;
   }
 
-  switch (MangledName.popFront()) {
+  const char F = MangledName.front();
+  MangledName.remove_prefix(1);
+  switch (F) {
   case 'A':
   case 'B':
     return CallingConv::Cdecl;
   case 'C':
   case 'D':
     return CallingConv::Pascal;
   case 'E':
   case 'F':
CallingConv Demangler::demangleCallingConvention(StringView &MangledName) {
   }
 
   return CallingConv::None;
 }
 
 StorageClass Demangler::demangleVariableStorageClass(StringView &MangledName) {
   assert(MangledName.front() >= '0' && MangledName.front() <= '4');
 
-  switch (MangledName.popFront()) {
+  const char F = MangledName.front();
+  MangledName.remove_prefix(1);
+  switch (F) {
   case '0':
     return StorageClass::PrivateStatic;
   case '1':
     return StorageClass::ProtectedStatic;
   case '2':
     return StorageClass::PublicStatic;
   case '3':
     return StorageClass::Global;
   case '4':
     return StorageClass::FunctionLocalStatic;
   }
   DEMANGLE_UNREACHABLE;
 }
 
 std::pair<Qualifiers, bool>
 Demangler::demangleQualifiers(StringView &MangledName) {
   if (MangledName.empty()) {
     Error = true;
     return std::make_pair(Q_None, false);
   }
 
-  switch (MangledName.popFront()) {
+  const char F = MangledName.front();
+  MangledName.remove_prefix(1);
+  switch (F) {
   // Member qualifiers
   case 'Q':
     return std::make_pair(Q_None, true);
   case 'R':
     return std::make_pair(Q_Const, true);
   case 'S':
     return std::make_pair(Q_Volatile, true);
   case 'T':
Demangler::demangleFunctionEncoding(StringView &MangledName) {
 
   FunctionSymbolNode *Symbol = Arena.alloc<FunctionSymbolNode>();
   Symbol->Signature = FSN;
   return Symbol;
 }
 
 CustomTypeNode *Demangler::demangleCustomType(StringView &MangledName) {
   assert(MangledName.startsWith('?'));
-  MangledName.popFront();
+  MangledName.remove_prefix(1);
 
   CustomTypeNode *CTN = Arena.alloc<CustomTypeNode>();
   CTN->Identifier = demangleUnqualifiedTypeName(MangledName, /*Memorize=*/true);
   if (!MangledName.consumeFront('@'))
     Error = true;
   if (Error)
     return nullptr;
   return CTN;
 }
 
 // Reads a primitive type.
 PrimitiveTypeNode *Demangler::demanglePrimitiveType(StringView &MangledName) {
   if (MangledName.consumeFront("$$T"))
     return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Nullptr);
 
-  switch (MangledName.popFront()) {
+  const char F = MangledName.front();
+  MangledName.remove_prefix(1);
+  switch (F) {
   case 'X':
     return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Void);
   case 'D':
     return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Char);
   case 'C':
     return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Schar);
   case 'E':
     return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Uchar);
case 'N':
     return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Double);
   case 'O':
     return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Ldouble);
   case '_': {
     if (MangledName.empty()) {
       Error = true;
       return nullptr;
     }
-    switch (MangledName.popFront()) {
+    const char F = MangledName.front();
+    MangledName.remove_prefix(1);
+    switch (F) {
     case 'N':
       return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Bool);
     case 'J':
       return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Int64);
     case 'K':
       return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Uint64);
     case 'W':
       return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Wchar);
PrimitiveTypeNode *Demangler::demanglePrimitiveType(StringView &MangledName) {
   }
   Error = true;
   return nullptr;
 }
 
 TagTypeNode *Demangler::demangleClassType(StringView &MangledName) {
   TagTypeNode *TT = nullptr;
 
-  switch (MangledName.popFront()) {
+  const char F = MangledName.front();
+  MangledName.remove_prefix(1);
+  switch (F) {
   case 'T':
     TT = Arena.alloc<TagTypeNode>(TagKind::Union);
     break;
   case 'U':
     TT = Arena.alloc<TagTypeNode>(TagKind::Struct);
     break;
   case 'V':
     TT = Arena.alloc<TagTypeNode>(TagKind::Class);
Qualifiers Demangler::demanglePointerExtQualifiers(StringView &MangledName) {
   if (MangledName.consumeFront('F'))
     Quals = Qualifiers(Quals | Q_Unaligned);
 
   return Quals;
 }
 
 ArrayTypeNode *Demangler::demangleArrayType(StringView &MangledName) {
   assert(MangledName.front() == 'Y');
-  MangledName.popFront();
+  MangledName.remove_prefix(1);
 
   uint64_t Rank = 0;
   bool IsNegative = false;
   std::tie(Rank, IsNegative) = demangleNumber(MangledName);
   if (IsNegative || Rank == 0) {
     Error = true;
     return nullptr;
   }
if (MangledName.consumeFront("$$Y")) {
       TP.N = TPRN = Arena.alloc<TemplateParameterReferenceNode>();
       TPRN->IsMemberPointer = true;
 
       MangledName.remove_prefix(1);
       // 1 - single inheritance       <name>
       // H - multiple inheritance     <name> <number>
       // I - virtual inheritance      <name> <number> <number>
       // J - unspecified inheritance  <name> <number> <number> <number>
-      char InheritanceSpecifier = MangledName.popFront();
+      char InheritanceSpecifier = MangledName.front();
+      MangledName.remove_prefix(1);
       SymbolNode *S = nullptr;
       if (MangledName.startsWith('?')) {
         S = parse(MangledName);
         if (Error || !S->Name) {
           Error = true;
           return nullptr;
         }
         memorizeIdentifier(S->Name->getUnqualifiedIdentifier());
if (MangledName.consumeFront("$$Y")) {
       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.
       MangledName.remove_prefix(1);
-      char InheritanceSpecifier = MangledName.popFront();
+      char InheritanceSpecifier = MangledName.front();
+      MangledName.remove_prefix(1);
 
       switch (InheritanceSpecifier) {
       case 'G':
         TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] =
             demangleSigned(MangledName);
         DEMANGLE_FALLTHROUGH;
       case 'F':
         TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] =