[StringView] remove ctor incompatible with std::string_view

[nickdesaulniers]

Summary

Towards replacing llvm::StringView with std::string_view, remove ctor
that std::string_view doesn't have an analog for.

[nickdesaulniers]

llvm/include/llvm/Demangle/StringView.h

55–56

Nevermind this change and the addition of iterator. I'll remove that once I rebase on top of D148348.

[erichkeane]

I think this is the right direction.

[MaskRay]

llvm/include/llvm/Demangle/ItaniumDemangle.h

2481

size_t n = std::distance(First, Last); can be removed.

3474

[nickdesaulniers]

• rebase on D148348

[nickdesaulniers]

hmm...a few tests are failing with this diff. Will take a look.

[nickdesaulniers]

llvm/include/llvm/Demangle/Utility.h

67

This is the change that's breaking the tests...

[nickdesaulniers]

llvm/include/llvm/Demangle/Utility.h

67

probably should be Temp.data() + Temp.size() - TempPtr

[erichkeane]

llvm/include/llvm/Demangle/Utility.h

67

TempPtr is not necessarily the Temp.data location, it looks like it is modified a h andful of times on line 59 and 65.

So this is meant to be a 'rest' kinda thing, but the code you changed it to is using the whole 'size'. I think you need to make Temp.size() be Temp.size() - std::distance(Temp.data(), TempPtr); (check for off-by-1 please :D).

[nickdesaulniers]

• remove std::distance, fix test failures

[nickdesaulniers]

llvm/include/llvm/Demangle/Utility.h

67

(check for off-by-1 please :D).

was there some additional check you wanted me to add here?

[erichkeane]

llvm/include/llvm/Demangle/Utility.h

67

Ah, no, just check for an off-by-1 error in my suggestion (don't just use it).

[nickdesaulniers]

llvm/include/llvm/Demangle/Utility.h

67

LGTM

llvm/include/llvm/Demangle/ItaniumDemangle.h

if (static_cast<std::size_t>(last - first) > N) {
                                   : static_cast<unsigned>(*t - 'a' + 10);
         *e = static_cast<char>((d1 << 4) + d0);
       }
 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
       std::reverse(buf, e);
 #endif
       char num[FloatData<Float>::max_demangled_size] = {0};
       int n = snprintf(num, sizeof(num), FloatData<Float>::spec, value);
-      OB += StringView(num, num + n);
+      OB += StringView(num, n);
     }
   }
 };
 
 using FloatLiteral = FloatLiteralImpl<float>;
 using DoubleLiteral = FloatLiteralImpl<double>;
 using LongDoubleLiteral = FloatLiteralImpl<long double>;
 
NodeArray popTrailingNodeArray(size_t FromPosition) {
     assert(FromPosition <= Names.size());
     NodeArray res =
         makeNodeArray(Names.begin() + (long)FromPosition, Names.end());
     Names.dropBack(FromPosition);
     return res;
   }
 
   bool consumeIf(StringView S) {
-    if (StringView(First, Last).startsWith(S)) {
+    if (StringView(First, Last - First).startsWith(S)) {
       First += S.size();
       return true;
     }
     return false;
   }
 
   bool consumeIf(char C) {
     if (First != Last && *First == C) {
       ++First;

 // <source-name> ::= <positive length number> <identifier>
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseSourceName(NameState *) {
   size_t Length = 0;
   if (parsePositiveInteger(&Length))
     return nullptr;
   if (numLeft() < Length || Length == 0)
     return nullptr;
-  StringView Name(First, First + Length);
+  StringView Name(First, Length);
   First += Length;
   if (Name.startsWith("_GLOBAL__N"))
     return make<NameType>("(anonymous namespace)");
   return make<NameType>(Name);
 }
 
 // Operator encodings
 template <typename Derived, typename Alloc>

 AbstractManglingParser<Alloc, Derived>::parseNumber(bool AllowNegative) {
   const char *Tmp = First;
   if (AllowNegative)
     consumeIf('n');
   if (numLeft() == 0 || !std::isdigit(*First))
     return StringView();
   while (numLeft() != 0 && std::isdigit(*First))
     ++First;
-  return StringView(Tmp, First);
+  return StringView(Tmp, First - Tmp);
 }
 
 // <positive length number> ::= [0-9]*
 template <typename Alloc, typename Derived>
 bool AbstractManglingParser<Alloc, Derived>::parsePositiveInteger(size_t *Out) {
   *Out = 0;
   if (look() < '0' || look() > '9')
     return true;
   while (look() >= '0' && look() <= '9') {
     *Out *= 10;
     *Out += static_cast<size_t>(consume() - '0');
   }
   return false;
 }
 
 template <typename Alloc, typename Derived>
 StringView AbstractManglingParser<Alloc, Derived>::parseBareSourceName() {
   size_t Int = 0;
   if (parsePositiveInteger(&Int) || numLeft() < Int)
     return StringView();
-  StringView R(First, First + Int);
+  StringView R(First, Int);
   First += Int;
   return R;
 }
 
 // <function-type> ::= [<CV-qualifiers>] [<exception-spec>] [Dx] F [Y] <bare-function-type> [<ref-qualifier>] E
 //
 // <exception-spec> ::= Do                # non-throwing exception-specification (e.g., noexcept, throw())
 //                  ::= DO <expression> E # computed (instantiation-dependent) noexcept

 };
 
 template <typename Alloc, typename Derived>
 template <class Float>
 Node *AbstractManglingParser<Alloc, Derived>::parseFloatingLiteral() {
   const size_t N = FloatData<Float>::mangled_size;
   if (numLeft() <= N)
     return nullptr;
-  StringView Data(First, First + N);
+  StringView Data(First, N);
   for (char C : Data)
     if (!std::isxdigit(C))
       return nullptr;
   First += N;
   if (!consumeIf('E'))
     return nullptr;
   return make<FloatLiteralImpl<Float>>(Data);
 }

 // extension      ::= ___Z <encoding> _block_invoke_<decimal-digit>+
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parse() {
   if (consumeIf("_Z") || consumeIf("__Z")) {
     Node *Encoding = getDerived().parseEncoding();
     if (Encoding == nullptr)
       return nullptr;
     if (look() == '.') {
-      Encoding = make<DotSuffix>(Encoding, StringView(First, Last));
+      Encoding = make<DotSuffix>(Encoding, StringView(First, Last - First));
       First = Last;
     }
     if (numLeft() != 0)
       return nullptr;
     return Encoding;
   }
 
   if (consumeIf("___Z") || consumeIf("____Z")) {

llvm/include/llvm/Demangle/StringView.h

class StringView {
   const char *First;
   const char *Last;
 
 public:
   static const size_t npos = ~size_t(0);
 
   template <size_t N>
   StringView(const char (&Str)[N]) : First(Str), Last(Str + N - 1) {}
-  StringView(const char *First_, const char *Last_)
-      : First(First_), Last(Last_) {}
   StringView(const char *First_, size_t Len)
       : First(First_), Last(First_ + Len) {}
   StringView(const char *Str) : First(Str), Last(Str + std::strlen(Str)) {}
   StringView() : First(nullptr), Last(nullptr) {}
 
   StringView substr(size_t Pos, size_t Len = npos) const {
     assert(Pos <= size());
     if (Len > size() - Pos)
       Len = size() - Pos;
     return StringView(begin() + Pos, Len);
   }
 
   size_t find(char C, size_t From = 0) const {
     // Avoid calling memchr with nullptr.
     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;
   }
 
   void remove_prefix(size_t N) {
     assert(size() >= N);
     First += N;
   }
   void remove_suffix(size_t N) {
     assert(size() >= N);
     Last -= N;
   }
 

llvm/include/llvm/Demangle/Utility.h

do {
       *--TempPtr = char('0' + N % 10);
       N /= 10;
     } while (N);
 
     // Add negative sign.
     if (isNeg)
       *--TempPtr = '-';
 
-    return operator+=(StringView(TempPtr, Temp.data() + Temp.size()));
+    return operator+=(StringView(TempPtr, Temp.data() + Temp.size() - TempPtr));
   }
 
 public:
   OutputBuffer(char *StartBuf, size_t Size)
       : Buffer(StartBuf), BufferCapacity(Size) {}
   OutputBuffer(char *StartBuf, size_t *SizePtr)
       : OutputBuffer(StartBuf, StartBuf ? *SizePtr : 0) {}
   OutputBuffer() = default;

llvm/lib/Demangle/MicrosoftDemangle.cpp

SymbolNode *Demangler::demangleMD5Name(StringView &MangledName) {
   //    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@");
 
-  StringView MD5(Start, MangledName.begin());
+  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('.'));

llvm/lib/Demangle/RustDemangle.cpp

static bool decodePunycode(StringView Input, OutputBuffer &Output) {
   if (DelimiterPos != StringView::npos) {
     // Copy basic code points before the last delimiter to the output.
     for (; InputIdx != DelimiterPos; ++InputIdx) {
       char C = Input[InputIdx];
       if (!isValid(C))
         return false;
       // Code points are padded with zeros while decoding is in progress.
       char UTF8[4] = {C};
-      Output += StringView(UTF8, UTF8 + 4);
+      Output += StringView(UTF8, 4);
     }
     // Skip over the delimiter.
     ++InputIdx;
   }
 
   size_t Base = 36;
   size_t Skew = 38;
   size_t Bias = 72;