[StringView] remove dropFront

[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::dropFront is semantically similar to
std::string_view::substr but with the input clamped to the size. No code
was relying on clamping other than the rust demangler, which I fixed in
https://reviews.llvm.org/D148272. Removing this method makes it easier
to switch over code later.

[nickdesaulniers]

llvm/include/llvm/Demangle/ItaniumDemangle.h

1587

anywhere we assign the result back to the string view object we should probably use StringView::remove_prefix instead.

[nickdesaulniers]

llvm/include/llvm/Demangle/ItaniumDemangle.h

1587

Nevermind; there is no StringView::remove_prefix. These can be changed to std::string_view::remove_prefix after conversion.

[MaskRay]

llvm/include/llvm/Demangle/ItaniumDemangle.h

1586

The second assert is made redundant by assert(SV.startsWith("basic_"));

2269

The assert is unnecessary. Integer[0] expresses the intention.

2289–2290

The assert is unnecessary. Value[0] expresses the intention.

[nickdesaulniers]

• remove redundant asserts

[erichkeane]

So I think most of your asserts are actually unnecessary. I only made it about 1/2 way down, but dont see any that are obviously necessary.

llvm/include/llvm/Demangle/ItaniumDemangle.h

1841

I think this assert is actually ALSO unnecessary, we already know that we're not in Offset.empty, line 1837 (and even if we weren't, line 1839 would probably be UB?).

2634

See above assert that checks startsWith, so also probably unnecessary.

3708

This assert is also redundant.

llvm/lib/Demangle/MicrosoftDemangle.cpp

172

index of zero above these makes this assert 'too late', since it would already be UB.

489

startswith above this.

[nickdesaulniers]

• remove all asserts, as per @erichkeane

[nickdesaulniers]

llvm/include/llvm/Demangle/StringView.h

66–70

needs a rebase on 3ece37b3fa2c14157ad02967b867570c6a0c08e8

[nickdesaulniers]

llvm/include/llvm/Demangle/ItaniumDemangle.h

1587

ah @MaskRay added that in 3ece37b3fa2c14157ad02967b867570c6a0c08e8

[nickdesaulniers]

• rebase on 3ece37b3fa2c14157ad02967b867570c6a0c08e8, use more StringView::remove_prefix

[MaskRay]

Thanks!

llvm/include/llvm/Demangle/ItaniumDemangle.h

public:
 
   template<typename Fn> void match(Fn F) const { F(SSK); }
 
   StringView getBaseName() const override {
     auto SV = ExpandedSpecialSubstitution::getBaseName ();
     if (isInstantiation()) {
       // The instantiations are typedefs that drop the "basic_" prefix.
       assert(SV.startsWith("basic_"));
-      SV = SV.dropFront(sizeof("basic_") - 1);
+      SV.remove_prefix(sizeof("basic_") - 1);
     }
     return SV;
   }
 
   void printLeft(OutputBuffer &OB) const override {
     OB << "std::" << getBaseName();
   }
 };
 
void printLeft(OutputBuffer &OB) const override {
     SubExpr->print(OB);
     OB += ".<";
     Type->print(OB);
     OB += " at offset ";
     if (Offset.empty()) {
       OB += "0";
     } else if (Offset[0] == 'n') {
       OB += "-";
-      OB += Offset.dropFront();
+      OB += Offset.substr(1);
     } else {
       OB += Offset;
     }
     OB += ">";
   }
 };
 
 class EnclosingExpr : public Node {
public:
   template<typename Fn> void match(Fn F) const { F(Ty, Integer); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB.printOpen();
     Ty->print(OB);
     OB.printClose();
 
     if (Integer[0] == 'n')
-      OB << "-" << Integer.dropFront(1);
+      OB << '-' << Integer.substr(1);
     else
       OB << Integer;
   }
 };
 
 class IntegerLiteral : public Node {
   StringView Type;
   StringView Value;
 
 public:
   IntegerLiteral(StringView Type_, StringView Value_)
       : Node(KIntegerLiteral), Type(Type_), Value(Value_) {}
 
   template<typename Fn> void match(Fn F) const { F(Type, Value); }
 
   void printLeft(OutputBuffer &OB) const override {
     if (Type.size() > 3) {
       OB.printOpen();
       OB += Type;
       OB.printClose();
     }
 
-    if (Value[0] == 'n') {
-      OB += '-';
-      OB += Value.dropFront(1);
-    } else
+    if (Value[0] == 'n')
+      OB << '-' << Value.substr(1);
+    else
       OB += Value;
 
     if (Type.size() <= 3)
       OB += Type;
   }
 };
 
 template <class Float> struct FloatData;
public:
     bool operator!=(const char *Peek) const { return !this->operator==(Peek); }
 
   public:
     StringView getSymbol() const {
       StringView Res = Name;
       if (Kind < Unnameable) {
         assert(Res.startsWith("operator") &&
                "operator name does not start with 'operator'");
-        Res = Res.dropFront(sizeof("operator") - 1);
+        Res.remove_prefix(sizeof("operator") - 1);
         Res.consumeFront(' ');
       }
       return Res;
     }
     StringView getName() const { return Name; }
     OIKind getKind() const { return Kind; }
     bool getFlag() const { return Flag; }
     Node::Prec getPrecedence() const { return Prec; }

 Node *AbstractManglingParser<Derived, Alloc>::parseQualifiedType() {
   if (consumeIf('U')) {
     StringView Qual = parseBareSourceName();
     if (Qual.empty())
       return nullptr;
 
     // extension            ::= U <objc-name> <objc-type>  # objc-type<identifier>
     if (Qual.startsWith("objcproto")) {
-      StringView ProtoSourceName = Qual.dropFront(std::strlen("objcproto"));
+      StringView ProtoSourceName = Qual.substr(std::strlen("objcproto"));
       StringView Proto;
       {
         ScopedOverride<const char *> SaveFirst(First, ProtoSourceName.begin()),
             SaveLast(Last, ProtoSourceName.end());
         Proto = parseBareSourceName();
       }
       if (Proto.empty())
         return nullptr;

llvm/include/llvm/Demangle/StringView.h

size_t find(char C, size_t From = 0) const {
     if (From < size()) {
       // Just forward to memchr, which is faster than a hand-rolled loop.
       if (const void *P = ::memchr(First + From, C, size() - From))
         return size_t(static_cast<const char *>(P) - First);
     }
     return npos;
   }
 
-  StringView dropFront(size_t N = 1) const {
-    if (N >= size())
-      N = size();
-    return StringView(First + N, Last);
-  }
-
   void remove_prefix(size_t N) {
     assert(size() >= N);
     First += N;
   }
   void remove_suffix(size_t N) {
     assert(size() >= N);
     Last -= N;
   }
 
   char front() const {
     assert(!empty());
     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;
-    *this = dropFront(1);
+    remove_prefix(1);
     return true;
   }
 
   bool consumeFront(StringView S) {
     if (!startsWith(S))
       return false;
-    *this = dropFront(S.size());
+    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;

llvm/lib/Demangle/MicrosoftDemangle.cpp

static bool startsWithLocalScopePattern(StringView S) {
   // Note that the reason the first digit cannot be A is two fold.  First, it
   // would create an ambiguity with ?A which delimits the beginning of an
   // anonymous namespace.  Second, A represents 0, and you don't start a multi
   // digit number with a leading 0.  Presumably the anonymous namespace
   // ambiguity is also why single digit encoded numbers use 0-9 rather than A-J.
   if (Candidate[0] < 'B' || Candidate[0] > 'P')
     return false;
   Candidate.remove_prefix(1);
   while (!Candidate.empty()) {
     if (Candidate[0] < 'A' || Candidate[0] > 'P')
       return false;
     Candidate.remove_prefix(1);
   }
 
   return true;
 }
 
SymbolNode *Demangler::demangleSpecialIntrinsic(StringView &MangledName) {
   }
   Error = true;
   return nullptr;
 }
 
 IdentifierNode *
 Demangler::demangleFunctionIdentifierCode(StringView &MangledName) {
   assert(MangledName.startsWith('?'));
   MangledName.remove_prefix(1);
   if (MangledName.empty()) {
     Error = true;
     return nullptr;
   }
 
   if (MangledName.consumeFront("__"))
     return demangleFunctionIdentifierCode(
         MangledName, FunctionIdentifierCodeGroup::DoubleUnder);
SymbolNode *Demangler::demangleMD5Name(StringView &MangledName) {
   // mangled name.
   // An MD5 mangled name is ??@ followed by 32 characters and a terminating @.
   size_t MD5Last = MangledName.find('@', strlen("??@"));
   if (MD5Last == StringView::npos) {
     Error = true;
     return nullptr;
   }
   const char *Start = MangledName.begin();
-  MangledName = MangledName.dropFront(MD5Last + 1);
+  MangledName.remove_prefix(MD5Last + 1);
 
   // There are two additional special cases for MD5 names:
   // 1. For complete object locators where the object name is long enough
   //    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

 //                        ::= <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('?');
 
   if (startsWithDigit(MangledName)) {
     uint64_t Ret = MangledName[0] - '0' + 1;
-    MangledName = MangledName.dropFront(1);
+    MangledName.remove_prefix(1);
     return {Ret, IsNegative};
   }
 
   uint64_t Ret = 0;
   for (size_t i = 0; i < MangledName.size(); ++i) {
     char C = MangledName[i];
     if (C == '@') {
-      MangledName = MangledName.dropFront(i + 1);
+      MangledName.remove_prefix(i + 1);
       return {Ret, IsNegative};
     }
     if ('A' <= C && C <= 'P') {
       Ret = (Ret << 4) + (C - 'A');
       continue;
     }
     break;
   }
if (MangledName.consumeFront('$')) {
     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]);
     uint8_t C2 = rebasedHexDigitToNumber(Nibbles[1]);
-    MangledName = MangledName.dropFront(2);
+    MangledName.remove_prefix(2);
     return (C1 << 4) | C2;
   }
 
   if (startsWithDigit(MangledName)) {
     const char *Lookup = ",/\\:. \n\t'-";
     char C = Lookup[MangledName[0] - '0'];
     MangledName.remove_prefix(1);
     return C;
Demangler::demangleStringLiteral(StringView &MangledName) {
   if (Error || IsNegative || StringByteSize < (IsWcharT ? 2 : 1))
     goto StringLiteralError;
 
   // CRC 32 (always 8 characters plus a terminator)
   CrcEndPos = MangledName.find('@');
   if (CrcEndPos == StringView::npos)
     goto StringLiteralError;
   CRC = MangledName.substr(0, CrcEndPos);
-  MangledName = MangledName.dropFront(CrcEndPos + 1);
+  MangledName.remove_prefix(CrcEndPos + 1);
   if (MangledName.empty())
     goto StringLiteralError;
 
   if (IsWcharT) {
     Result->Char = CharKind::Wchar;
     if (StringByteSize > 64)
       Result->IsTruncated = true;
 
StringView Demangler::demangleSimpleString(StringView &MangledName,
                                            bool Memorize) {
   StringView S;
   for (size_t i = 0; i < MangledName.size(); ++i) {
     if (MangledName[i] != '@')
       continue;
     if (i == 0)
       break;
     S = MangledName.substr(0, i);
-    MangledName = MangledName.dropFront(i + 1);
+    MangledName.remove_prefix(i + 1);
 
     if (Memorize)
       memorizeString(S);
     return S;
   }
 
   Error = true;
   return {};