Reland: [Demangle] replace use of llvm::StringView w/ std::string_view

[nickdesaulniers]

Summary

This reverts commit d81cdb49d74064e88843733e7da92db865943509.

This refactoring was waiting on converting LLVM to C++17.

Leave StringView.h and cleanup around for subsequent cleanup.

Additional fixes for missing std::string_view conversions for MSVC.

[nickdesaulniers]

llvm/include/llvm/Demangle/ItaniumDemangle.h

19

I'll probably revert https://reviews.llvm.org/D148367 for now then rebase this on top.

[nickdesaulniers]

• rebase

[DavidSpickett]

I am confused why startswith is in the itanium demangle namespace but I could be confusing a specialised function with the generic one that works for any string view. Otherwise looks fine at a glance.

llvm/include/llvm/Demangle/ItaniumDemangle.h

1586

Is this right? Not sure itanium_demangle makes sense here.

2486

Same here, namespace doesn't sound right.

llvm/include/llvm/Demangle/MicrosoftDemangle.h

14

Needed because llvm's stringview included assert?

llvm/include/llvm/Demangle/Utility.h

19–20

Why does this change?

[nickdesaulniers]

In D148546#4276926, @DavidSpickett wrote:

I am confused why startswith is in the itanium demangle namespace but I could be confusing a specialised function with the generic one that works for any string view. Otherwise looks fine at a glance.

Hey David! Thanks for the review! See the two parent commits for more context:

1. https://reviews.llvm.org/D148547
2. https://reviews.llvm.org/D148556

The second in particular could use review still ;) The first has landed. This patch is part of a stack that could use review if you have the cycles for it.

llvm/include/llvm/Demangle/MicrosoftDemangle.h

14

yep, used below on L49.

llvm/include/llvm/Demangle/Utility.h

19–20

The definition of DEMANGLE_NAMESPACE_BEGIN used below on L30 comes from this header, which was being included indirectly by StringView.h before this change.

[DavidSpickett]

I don't know enough to review the other patches but I understand the layering issue. So assuming the other patches are ok, this one LGTM.

llvm/include/llvm/Demangle/ItaniumDemangle.h

1586

Answered.

2486

Answered.

[ayzhao]

This still fails to build on Windows with MSVC's cl.exe compiler:

C:\src\llvm-project\build-ninja>ninja all
[49/4908] Building CXX object lib\Demangle\CMakeFiles\LLVMDemangle.dir\ItaniumDemangle.cpp.obj
FAILED: lib/Demangle/CMakeFiles/LLVMDemangle.dir/ItaniumDemangle.cpp.obj
C:\PROGRA~1\MICROS~2\2022\PROFES~1\VC\Tools\MSVC\1435~1.322\bin\Hostx86\x86\cl.exe  /nologo /TP -DGTEST_HAS_RTTI=0 -DUNICODE -D_CRT_NONSTDC_NO_DEPRECATE -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS -D_FILE_OFFSET_BITS=64 -D_GLIBCXX_ASSERTIONS -D_HAS_EXCEPTIONS=0 -D_LARGEFILE_SOURCE -D_LIBCPP_ENABLE_ASSERTIONS -D_SCL_SECURE_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS -D_UNICODE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -IC:\src\llvm-project\build-ninja\lib\Demangle -IC:\src\llvm-project\llvm\lib\Demangle -IC:\src\llvm-project\build-ninja\include -IC:\src\llvm-project\llvm\include /DWIN32 /D_WINDOWS   /Zc:inline /Zc:preprocessor /Zc:__cplusplus /Oi /bigobj /permissive- /W4 -wd4141 -wd4146 -wd4244 -wd4267 -wd4291 -wd4351 -wd4456 -wd4457 -wd4458 -wd4459 -wd4503 -wd4624 -wd4722 -wd4100 -wd4127 -wd4512 -wd4505 -wd4610 -wd4510 -wd4702 -wd4245 -wd4706 -wd4310 -wd4701 -wd4703 -wd4389 -wd4611 -wd4805 -wd4204 -wd4577 -wd4091 -wd4592 -wd4319 -wd4709 -wd5105 -wd4324 -w14062 -we4238 /Gw /MD /O2 /Ob2  /EHs-c- /GR- -UNDEBUG -std:c++17 /showIncludes /Folib\Demangle\CMakeFiles\LLVMDemangle.dir\ItaniumDemangle.cpp.obj /Fdlib\Demangle\CMakeFiles\LLVMDemangle.dir\LLVMDemangle.pdb /FS -c C:\src\llvm-project\llvm\lib\Demangle\ItaniumDemangle.cpp
C:\src\llvm-project\llvm\include\llvm/Demangle/ItaniumDemangle.h(3718): error C2665: 'llvm::itanium_demangle::ScopedOverride<const char *>::ScopedOverride': no overloaded function could convert all the argument types
C:\src\llvm-project\llvm\include\llvm\Demangle\Utility.h(194): note: could be 'llvm::itanium_demangle::ScopedOverride<const char *>::ScopedOverride(T &,T)'
        with
        [
            T=const char *
        ]
C:\src\llvm-project\llvm\include\llvm/Demangle/ItaniumDemangle.h(3718): note: 'llvm::itanium_demangle::ScopedOverride<const char *>::ScopedOverride(T &,T)': cannot convert argument 2 from 'std::_String_view_iterator<_Traits>' to 'T'
        with
        [
            T=const char *
        ]
        and
        [
            _Traits=std::char_traits<char>
        ]
        and
        [
            T=const char *
        ]
C:\src\llvm-project\llvm\include\llvm/Demangle/ItaniumDemangle.h(3718): note: No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called
C:\src\llvm-project\llvm\include\llvm/Demangle/ItaniumDemangle.h(3718): note: while trying to match the argument list '(const char *, std::_String_view_iterator<_Traits>)'
        with
        [
            _Traits=std::char_traits<char>
        ]
C:\src\llvm-project\llvm\include\llvm/Demangle/ItaniumDemangle.h(3707): note: while compiling class template member function 'llvm::itanium_demangle::Node *llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<`anonymous-namespace'::DefaultAllocator>,Alloc>::parseQualifiedType(void)'
        with
        [
            Alloc=`anonymous-namespace'::DefaultAllocator
        ]
C:\src\llvm-project\llvm\include\llvm/Demangle/ItaniumDemangle.h(3796): note: see reference to function template instantiation 'llvm::itanium_demangle::Node *llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<`anonymous-namespace'::DefaultAllocator>,Alloc>::parseQualifiedType(void)' being compiled
        with
        [
            Alloc=`anonymous-namespace'::DefaultAllocator
        ]
C:\src\llvm-project\llvm\include\llvm/Demangle/ItaniumDemangle.h(3472): note: while compiling class template member function 'std::string_view llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<`anonymous-namespace'::DefaultAllocator>,Alloc>::parseNumber(bool)'
        with
        [
            Alloc=`anonymous-namespace'::DefaultAllocator
        ]
C:\src\llvm-project\llvm\include\llvm/Demangle/ItaniumDemangle.h(5489): note: see reference to function template instantiation 'std::string_view llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<`anonymous-namespace'::DefaultAllocator>,Alloc>::parseNumber(bool)' being compiled
        with
        [
            Alloc=`anonymous-namespace'::DefaultAllocator
        ]
C:\src\llvm-project\llvm\include\llvm/Demangle/ItaniumDemangle.h(5469): note: while compiling class template member function 'llvm::itanium_demangle::Node *llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<`anonymous-namespace'::DefaultAllocator>,Alloc>::parse(void)'
        with
        [
            Alloc=`anonymous-namespace'::DefaultAllocator
        ]
C:\src\llvm-project\llvm\lib\Demangle\ItaniumDemangle.cpp(378): note: see reference to function template instantiation 'llvm::itanium_demangle::Node *llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<`anonymous-namespace'::DefaultAllocator>,Alloc>::parse(void)' being compiled
        with
        [
            Alloc=`anonymous-namespace'::DefaultAllocator
        ]
C:\src\llvm-project\llvm\include\llvm/Demangle/ItaniumDemangle.h(5505): note: see reference to class template instantiation 'llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<`anonymous-namespace'::DefaultAllocator>,Alloc>' being compiled
        with
        [
            Alloc=`anonymous-namespace'::DefaultAllocator
        ]
C:\src\llvm-project\llvm\lib\Demangle\ItaniumDemangle.cpp(377): note: see reference to class template instantiation 'llvm::itanium_demangle::ManglingParser<`anonymous-namespace'::DefaultAllocator>' being compiled
C:\src\llvm-project\llvm\include\llvm/Demangle/ItaniumDemangle.h(3719): error C2665: 'llvm::itanium_demangle::ScopedOverride<const char *>::ScopedOverride': no overloaded function could convert all the argument types
C:\src\llvm-project\llvm\include\llvm\Demangle\Utility.h(194): note: could be 'llvm::itanium_demangle::ScopedOverride<const char *>::ScopedOverride(T &,T)'
        with
        [
            T=const char *
        ]
C:\src\llvm-project\llvm\include\llvm/Demangle/ItaniumDemangle.h(3719): note: 'llvm::itanium_demangle::ScopedOverride<const char *>::ScopedOverride(T &,T)': cannot convert argument 2 from 'std::_String_view_iterator<_Traits>' to 'T'
        with
        [
            T=const char *
        ]
        and
        [
            _Traits=std::char_traits<char>
        ]
        and
        [
            T=const char *
        ]
C:\src\llvm-project\llvm\include\llvm/Demangle/ItaniumDemangle.h(3719): note: No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called
C:\src\llvm-project\llvm\include\llvm/Demangle/ItaniumDemangle.h(3719): note: while trying to match the argument list '(const char *, std::_String_view_iterator<_Traits>)'
        with
        [
            _Traits=std::char_traits<char>
        ]
[97/4908] Building CXX object tools\clang\utils\TableGen\CMakeFiles\clang-tblgen.dir\ClangAttrEmitter.cpp.obj
ninja: build stopped: subcommand failed.

[nickdesaulniers]

• git clang-format HEAD~, fix 2 more conversion issues

[ayzhao]

A new conversion issue popped up:

C:\src\llvm-project\build-ninja>ninja all
[376/3206] Building CXX object lib\ProfileData\CMakeFiles\LLVMProfileData.dir\ItaniumManglingCanonicalizer.cpp.obj
FAILED: lib/ProfileData/CMakeFiles/LLVMProfileData.dir/ItaniumManglingCanonicalizer.cpp.obj
C:\PROGRA~1\MICROS~2\2022\PROFES~1\VC\Tools\MSVC\1435~1.322\bin\Hostx86\x86\cl.exe  /nologo /TP -DGTEST_HAS_RTTI=0 -DUNICODE -D_CRT_NONSTDC_NO_DEPRECATE -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS -D_FILE_OFFSET_BITS=64 -D_GLIBCXX_ASSERTIONS -D_HAS_EXCEPTIONS=0 -D_LARGEFILE_SOURCE -D_LIBCPP_ENABLE_ASSERTIONS -D_SCL_SECURE_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS -D_UNICODE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -IC:\src\llvm-project\build-ninja\lib\ProfileData -IC:\src\llvm-project\llvm\lib\ProfileData -IC:\src\llvm-project\build-ninja\include -IC:\src\llvm-project\llvm\include /DWIN32 /D_WINDOWS   /Zc:inline /Zc:preprocessor /Zc:__cplusplus /Oi /bigobj /permissive- /W4 -wd4141 -wd4146 -wd4244 -wd4267 -wd4291 -wd4351 -wd4456 -wd4457 -wd4458 -wd4459 -wd4503 -wd4624 -wd4722 -wd4100 -wd4127 -wd4512 -wd4505 -wd4610 -wd4510 -wd4702 -wd4245 -wd4706 -wd4310 -wd4701 -wd4703 -wd4389 -wd4611 -wd4805 -wd4204 -wd4577 -wd4091 -wd4592 -wd4319 -wd4709 -wd5105 -wd4324 -w14062 -we4238 /Gw /MD /O2 /Ob2  /EHs-c- /GR- -UNDEBUG -std:c++17 /showIncludes /Folib\ProfileData\CMakeFiles\LLVMProfileData.dir\ItaniumManglingCanonicalizer.cpp.obj /Fdlib\ProfileData\CMakeFiles\LLVMProfileData.dir\LLVMProfileData.pdb /FS -c C:\src\llvm-project\llvm\lib\ProfileData\ItaniumManglingCanonicalizer.cpp
C:\src\llvm-project\llvm\lib\ProfileData\ItaniumManglingCanonicalizer.cpp(26): error C2440: '<function-style-cast>': cannot convert from 'initializer list' to 'llvm::StringRef'
C:\src\llvm-project\llvm\lib\ProfileData\ItaniumManglingCanonicalizer.cpp(26): note: No constructor could take the source type, or constructor overload resolution was ambiguous
[490/3022] Building CXX object tools\clang\lib\CodeGen\CMakeFiles\obj.clangCodeGen.dir\CGExpr.cpp.obj
C:\src\llvm-project\clang\lib\CodeGen\CGExpr.cpp(3583): warning C4018: '<=': signed/unsigned mismatch
[505/2927] Building CXX object tools\clang\lib\ASTMatchers\Dynamic\CMakeFiles\obj.clangDynamicASTMatchers.dir\Registry.cpp.obj
ninja: build stopped: subcommand failed.

[nickdesaulniers]

• fix another conversion issue for msvc

[ayzhao]

LGTM, looks like this builds on Windows now:

C:\src\llvm-project\build-ninja>ninja all
[3498/6597] Building CXX object tools\clang\lib\AST\CMakeFiles\obj.clangAST.dir\AttrDocTable.cpp.obj
C:\src\llvm-project\clang\lib\AST\AttrDocTable.cpp(24): warning C4018: '<': signed/unsigned mismatch
[3846/6597] Building CXX object tools\clang\lib\CodeGen\CMakeFiles\obj.clangCodeGen.dir\CGExpr.cpp.obj
C:\src\llvm-project\clang\lib\CodeGen\CGExpr.cpp(3583): warning C4018: '<=': signed/unsigned mismatch
[4655/6597] Building CXX object tools\lld\COFF\CMakeFiles\lldCOFF.dir\PDB.cpp.obj
C:\src\llvm-project\lld\COFF\PDB.cpp(839): warning C4018: '>=': signed/unsigned mismatch
[4919/6597] Building CXX object tools\lldb\source\Core\CMakeFiles\lldbCore.dir\ModuleList.cpp.obj
C:\src\llvm-project\lldb\source\Core\ModuleList.cpp(336): warning C4996: 'std::shared_ptr<lldb_private::Module>::unique': warning STL4016: std::shared_ptr::unique() is deprecated in C++17. You can define _SILENCE_CXX17_SHARED_PTR_UNIQUE_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.
C:\src\llvm-project\lldb\source\Core\ModuleList.cpp(367): warning C4996: 'std::shared_ptr<lldb_private::Module>::unique': warning STL4016: std::shared_ptr::unique() is deprecated in C++17. You can define _SILENCE_CXX17_SHARED_PTR_UNIQUE_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.
[5175/6597] Building CXX object tools\lldb\source\Plugins\Process\Utility\CMakeFiles\lldbPluginProcessUtility.dir\NativeRegisterContextDBReg_x86.cpp.obj
C:\src\llvm-project\lldb\source\Plugins\Process\Utility\NativeRegisterContextDBReg_x86.h(23): warning C4589: Constructor of abstract class 'lldb_private::NativeRegisterContextDBReg_x86' ignores initializer for virtual base class 'lldb_private::NativeRegisterContextRegisterInfo'
C:\src\llvm-project\lldb\source\Plugins\Process\Utility\NativeRegisterContextDBReg_x86.h(23): note: virtual base classes are only initialized by the most-derived type
[5205/6597] Building CXX object tools\lldb\source\Plugins\LanguageRuntime\ObjC\AppleObjCRuntime\CMakeFiles\lldbPluginAppleObjCRuntime.dir\AppleObjCRuntimeV2.cpp.obj
C:\src\llvm-project\lldb\source\Plugins\LanguageRuntime\ObjC\AppleObjCRuntime\AppleObjCRuntimeV2.cpp(1744): warning C5030: attribute 'clang::fallthrough' is not recognized
[5263/6597] Building CXX object tools\lldb\source\Plugins\Process\Utility\CMakeFiles\lldbPluginProcessUtility.dir\RegisterContextPOSIX_mips64.cpp.obj
C:\src\llvm-project\lldb\source\Plugins\Process\Utility\RegisterContextPOSIX_mips64.cpp(109): warning C4065: switch statement contains 'default' but no 'case' labels
C:\src\llvm-project\lldb\source\Plugins\Process\Utility\RegisterContextPOSIX_mips64.cpp(120): warning C4065: switch statement contains 'default' but no 'case' labels
[5593/6597] Building CXX object tools\lldb\source\API\CMakeFiles\liblldb.dir\SBTypeFilter.cpp.obj
C:\src\llvm-project\lldb\source\API\SBTypeFilter.cpp(169): warning C4996: 'std::shared_ptr<lldb_private::TypeFilterImpl>::unique': warning STL4016: std::shared_ptr::unique() is deprecated in C++17. You can define _SILENCE_CXX17_SHARED_PTR_UNIQUE_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.
[5652/6597] Building CXX object tools\lldb\source\API\CMakeFiles\liblldb.dir\SBTypeFormat.cpp.obj
C:\src\llvm-project\lldb\source\API\SBTypeFormat.cpp(160): warning C4996: 'std::shared_ptr<lldb_private::TypeFormatImpl>::unique': warning STL4016: std::shared_ptr::unique() is deprecated in C++17. You can define _SILENCE_CXX17_SHARED_PTR_UNIQUE_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.
[5665/6597] Building CXX object tools\lldb\source\API\CMakeFiles\liblldb.dir\SBTypeSynthetic.cpp.obj
C:\src\llvm-project\lldb\source\API\SBTypeSynthetic.cpp(187): warning C4996: 'std::shared_ptr<lldb_private::ScriptedSyntheticChildren>::unique': warning STL4016: std::shared_ptr::unique() is deprecated in C++17. You can define _SILENCE_CXX17_SHARED_PTR_UNIQUE_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.
[5675/6597] Building CXX object tools\lldb\source\API\CMakeFiles\liblldb.dir\SBTypeSummary.cpp.obj
C:\src\llvm-project\lldb\source\API\SBTypeSummary.cpp(384): warning C4996: 'std::shared_ptr<lldb_private::TypeSummaryImpl>::unique': warning STL4016: std::shared_ptr::unique() is deprecated in C++17. You can define _SILENCE_CXX17_SHARED_PTR_UNIQUE_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.
[6585/6597] Building CXX object tools\clang\tools\extra\clangd\CMakeFiles\obj.clangDaemon.dir\InlayHints.cpp.obj
C:\src\llvm-project\clang-tools-extra\clangd\InlayHints.cpp(594): warning C4018: '<': signed/unsigned mismatch
[6597/6597] Linking CXX executable bin\clangd.exe

[nickdesaulniers]

Thanks for the help testing on Windows @ayzhao . Those warnings look potentially interesting to follow up; none appear to be introduced from this diff. Landing.

[nickdesaulniers]

llvm/test/Demangle/ms-cxx14.test is now crashing on windows, working on a fix forward for llvm::microsoftDemangle which I think is missing a nullptr check.

lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp

 #include "PdbAstBuilder.h"
 
 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
 #include "llvm/DebugInfo/CodeView/RecordName.h"
 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecordHelpers.h"
 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
 #include "llvm/DebugInfo/PDB/Native/PublicsStream.h"
 #include "llvm/DebugInfo/PDB/Native/SymbolStream.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
 #include "llvm/Demangle/MicrosoftDemangle.h"
 
+#include "PdbUtil.h"
 #include "Plugins/ExpressionParser/Clang/ClangASTMetadata.h"
 #include "Plugins/ExpressionParser/Clang/ClangUtil.h"
 #include "Plugins/Language/CPlusPlus/MSVCUndecoratedNameParser.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
+#include "SymbolFileNativePDB.h"
+#include "UdtRecordCompleter.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/LLDBAssert.h"
-#include "PdbUtil.h"
-#include "UdtRecordCompleter.h"
-#include "SymbolFileNativePDB.h"
 #include <optional>
+#include <string_view>
 
 using namespace lldb_private;
 using namespace lldb_private::npdb;
 using namespace llvm::codeview;
 using namespace llvm::pdb;
 
 namespace {
 struct CreateMethodDecl : public TypeVisitorCallbacks {

 PdbAstBuilder::CreateDeclInfoForType(const TagRecord &record, TypeIndex ti) {
   SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
       m_clang.GetSymbolFile()->GetBackingSymbolFile());
   // FIXME: Move this to GetDeclContextContainingUID.
   if (!record.hasUniqueName())
     return CreateDeclInfoForUndecoratedName(record.Name);
 
   llvm::ms_demangle::Demangler demangler;
-  StringView sv(record.UniqueName.begin(), record.UniqueName.size());
+  std::string_view sv(record.UniqueName.begin(), record.UniqueName.size());
   llvm::ms_demangle::TagTypeNode *ttn = demangler.parseTagUniqueName(sv);
   if (demangler.Error)
     return {m_clang.GetTranslationUnitDecl(), std::string(record.UniqueName)};
 
   llvm::ms_demangle::IdentifierNode *idn =
       ttn->QualifiedName->getUnqualifiedIdentifier();
   std::string uname = idn->toString(llvm::ms_demangle::OF_NoTagSpecifier);
 

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 #include "DWARFLocationExpression.h"
 #include "PdbSymUid.h"
 #include "PdbUtil.h"
 #include "UdtRecordCompleter.h"
 #include <optional>
+#include <string_view>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace npdb;
 using namespace llvm::codeview;
 using namespace llvm::pdb;
 
 char SymbolFileNativePDB::ID;
static std::string GetUnqualifiedTypeName(const TagRecord &record) {
   if (!record.hasUniqueName()) {
     MSVCUndecoratedNameParser parser(record.Name);
     llvm::ArrayRef<MSVCUndecoratedNameSpecifier> specs = parser.GetSpecifiers();
 
     return std::string(specs.back().GetBaseName());
   }
 
   llvm::ms_demangle::Demangler demangler;
-  StringView sv(record.UniqueName.begin(), record.UniqueName.size());
+  std::string_view sv(record.UniqueName.begin(), record.UniqueName.size());
   llvm::ms_demangle::TagTypeNode *ttn = demangler.parseTagUniqueName(sv);
   if (demangler.Error)
     return std::string(record.Name);
 
   llvm::ms_demangle::IdentifierNode *idn =
       ttn->QualifiedName->getUnqualifiedIdentifier();
   return idn->toString();
 }

llvm/include/llvm/Demangle/ItaniumDemangle.h

 // libcxxabi is the original and the one under llvm is the copy.  Use
 // cp-to-llvm.sh to update the copy.  See README.txt for more details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef DEMANGLE_ITANIUMDEMANGLE_H
 #define DEMANGLE_ITANIUMDEMANGLE_H
 
 #include "DemangleConfig.h"
-#include "StringView.h"
+#include "StringViewExtras.h"
 #include "Utility.h"
 #include <algorithm>
 #include <cassert>
 #include <cctype>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <limits>
 #include <new>
+#include <string_view>
 #include <type_traits>
 #include <utility>
 
 DEMANGLE_NAMESPACE_BEGIN
 
 template <class T, size_t N> class PODSmallVector {
   static_assert(std::is_pod<T>::value,
                 "T is required to be a plain old data type");
public:
   virtual void printLeft(OutputBuffer &) const = 0;
 
   // Print the "right". This distinction is necessary to represent C++ types
   // that appear on the RHS of their subtype, such as arrays or functions.
   // Since most types don't have such a component, provide a default
   // implementation.
   virtual void printRight(OutputBuffer &) const {}
 
-  virtual StringView getBaseName() const { return StringView(); }
+  virtual std::string_view getBaseName() const { return {}; }
 
   // Silence compiler warnings, this dtor will never be called.
   virtual ~Node() = default;
 
 #ifndef NDEBUG
   DEMANGLE_DUMP_METHOD void dump() const;
 #endif
 };
struct NodeArrayNode : Node {
 
   template<typename Fn> void match(Fn F) const { F(Array); }
 
   void printLeft(OutputBuffer &OB) const override { Array.printWithComma(OB); }
 };
 
 class DotSuffix final : public Node {
   const Node *Prefix;
-  const StringView Suffix;
+  const std::string_view Suffix;
 
 public:
-  DotSuffix(const Node *Prefix_, StringView Suffix_)
+  DotSuffix(const Node *Prefix_, std::string_view Suffix_)
       : Node(KDotSuffix), Prefix(Prefix_), Suffix(Suffix_) {}
 
   template<typename Fn> void match(Fn F) const { F(Prefix, Suffix); }
 
   void printLeft(OutputBuffer &OB) const override {
     Prefix->print(OB);
     OB += " (";
     OB += Suffix;
     OB += ")";
   }
 };
 
 class VendorExtQualType final : public Node {
   const Node *Ty;
-  StringView Ext;
+  std::string_view Ext;
   const Node *TA;
 
 public:
-  VendorExtQualType(const Node *Ty_, StringView Ext_, const Node *TA_)
+  VendorExtQualType(const Node *Ty_, std::string_view Ext_, const Node *TA_)
       : Node(KVendorExtQualType), Ty(Ty_), Ext(Ext_), TA(TA_) {}
 
   const Node *getTy() const { return Ty; }
-  StringView getExt() const { return Ext; }
+  std::string_view getExt() const { return Ext; }
   const Node *getTA() const { return TA; }
 
   template <typename Fn> void match(Fn F) const { F(Ty, Ext, TA); }
 
   void printLeft(OutputBuffer &OB) const override {
     Ty->print(OB);
     OB += " ";
     OB += Ext;
public:
   void printLeft(OutputBuffer &OB) const override {
     OB += "operator ";
     Ty->print(OB);
   }
 };
 
 class PostfixQualifiedType final : public Node {
   const Node *Ty;
-  const StringView Postfix;
+  const std::string_view Postfix;
 
 public:
-  PostfixQualifiedType(const Node *Ty_, StringView Postfix_)
+  PostfixQualifiedType(const Node *Ty_, std::string_view Postfix_)
       : Node(KPostfixQualifiedType), Ty(Ty_), Postfix(Postfix_) {}
 
   template<typename Fn> void match(Fn F) const { F(Ty, Postfix); }
 
   void printLeft(OutputBuffer &OB) const override {
     Ty->printLeft(OB);
     OB += Postfix;
   }
 };
 
 class NameType final : public Node {
-  const StringView Name;
+  const std::string_view Name;
 
 public:
-  NameType(StringView Name_) : Node(KNameType), Name(Name_) {}
+  NameType(std::string_view Name_) : Node(KNameType), Name(Name_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name); }
 
-  StringView getName() const { return Name; }
-  StringView getBaseName() const override { return Name; }
+  std::string_view getName() const { return Name; }
+  std::string_view getBaseName() const override { return Name; }
 
   void printLeft(OutputBuffer &OB) const override { OB += Name; }
 };
 
 class BitIntType final : public Node {
   const Node *Size;
   bool Signed;
 
void printLeft(OutputBuffer &OB) const override {
     OB += "_BitInt";
     OB.printOpen();
     Size->printAsOperand(OB);
     OB.printClose();
   }
 };
 
 class ElaboratedTypeSpefType : public Node {
-  StringView Kind;
+  std::string_view Kind;
   Node *Child;
 public:
-  ElaboratedTypeSpefType(StringView Kind_, Node *Child_)
+  ElaboratedTypeSpefType(std::string_view Kind_, Node *Child_)
       : Node(KElaboratedTypeSpefType), Kind(Kind_), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Kind, Child); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += Kind;
     OB += ' ';
     Child->print(OB);
   }
 };
 
 struct AbiTagAttr : Node {
   Node *Base;
-  StringView Tag;
+  std::string_view Tag;
 
-  AbiTagAttr(Node *Base_, StringView Tag_)
+  AbiTagAttr(Node *Base_, std::string_view Tag_)
       : Node(KAbiTagAttr, Base_->RHSComponentCache, Base_->ArrayCache,
              Base_->FunctionCache),
         Base(Base_), Tag(Tag_) {}
 
   template<typename Fn> void match(Fn F) const { F(Base, Tag); }
 
-  StringView getBaseName() const override { return Base->getBaseName(); }
+  std::string_view getBaseName() const override { return Base->getBaseName(); }
 
   void printLeft(OutputBuffer &OB) const override {
     Base->printLeft(OB);
     OB += "[abi:";
     OB += Tag;
     OB += "]";
   }
 };
void printLeft(OutputBuffer &OB) const override {
     OB += " [enable_if:";
     Conditions.printWithComma(OB);
     OB += ']';
   }
 };
 
 class ObjCProtoName : public Node {
   const Node *Ty;
-  StringView Protocol;
+  std::string_view Protocol;
 
   friend class PointerType;
 
 public:
-  ObjCProtoName(const Node *Ty_, StringView Protocol_)
+  ObjCProtoName(const Node *Ty_, std::string_view Protocol_)
       : Node(KObjCProtoName), Ty(Ty_), Protocol(Protocol_) {}
 
   template<typename Fn> void match(Fn F) const { F(Ty, Protocol); }
 
   bool isObjCObject() const {
     return Ty->getKind() == KNameType &&
            static_cast<const NameType *>(Ty)->getName() == "objc_object";
   }
public:
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "operator\"\" ";
     OpName->print(OB);
   }
 };
 
 class SpecialName final : public Node {
-  const StringView Special;
+  const std::string_view Special;
   const Node *Child;
 
 public:
-  SpecialName(StringView Special_, const Node *Child_)
+  SpecialName(std::string_view Special_, const Node *Child_)
       : Node(KSpecialName), Special(Special_), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Special, Child); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += Special;
     Child->print(OB);
   }
struct NestedName : Node {
   Node *Qual;
   Node *Name;
 
   NestedName(Node *Qual_, Node *Name_)
       : Node(KNestedName), Qual(Qual_), Name(Name_) {}
 
   template<typename Fn> void match(Fn F) const { F(Qual, Name); }
 
-  StringView getBaseName() const override { return Name->getBaseName(); }
+  std::string_view getBaseName() const override { return Name->getBaseName(); }
 
   void printLeft(OutputBuffer &OB) const override {
     Qual->print(OB);
     OB += "::";
     Name->print(OB);
   }
 };
 
struct ModuleEntity : Node {
   ModuleName *Module;
   Node *Name;
 
   ModuleEntity(ModuleName *Module_, Node *Name_)
       : Node(KModuleEntity), Module(Module_), Name(Name_) {}
 
   template <typename Fn> void match(Fn F) const { F(Module, Name); }
 
-  StringView getBaseName() const override { return Name->getBaseName(); }
+  std::string_view getBaseName() const override { return Name->getBaseName(); }
 
   void printLeft(OutputBuffer &OB) const override {
     Name->print(OB);
     OB += '@';
     Module->print(OB);
   }
 };
 
class QualifiedName final : public Node {
   const Node *Name;
 
 public:
   QualifiedName(const Node *Qualifier_, const Node *Name_)
       : Node(KQualifiedName), Qualifier(Qualifier_), Name(Name_) {}
 
   template<typename Fn> void match(Fn F) const { F(Qualifier, Name); }
 
-  StringView getBaseName() const override { return Name->getBaseName(); }
+  std::string_view getBaseName() const override { return Name->getBaseName(); }
 
   void printLeft(OutputBuffer &OB) const override {
     Qualifier->print(OB);
     OB += "::";
     Name->print(OB);
   }
 };
 
struct NameWithTemplateArgs : Node {
   Node *Name;
   Node *TemplateArgs;
 
   NameWithTemplateArgs(Node *Name_, Node *TemplateArgs_)
       : Node(KNameWithTemplateArgs), Name(Name_), TemplateArgs(TemplateArgs_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name, TemplateArgs); }
 
-  StringView getBaseName() const override { return Name->getBaseName(); }
+  std::string_view getBaseName() const override { return Name->getBaseName(); }
 
   void printLeft(OutputBuffer &OB) const override {
     Name->print(OB);
     TemplateArgs->print(OB);
   }
 };
 
 class GlobalQualifiedName final : public Node {
   Node *Child;
 
 public:
   GlobalQualifiedName(Node* Child_)
       : Node(KGlobalQualifiedName), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Child); }
 
-  StringView getBaseName() const override { return Child->getBaseName(); }
+  std::string_view getBaseName() const override { return Child->getBaseName(); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "::";
     Child->print(OB);
   }
 };
 
 enum class SpecialSubKind {
public:
 
   template<typename Fn> void match(Fn F) const { F(SSK); }
 
 protected:
   bool isInstantiation() const {
     return unsigned(SSK) >= unsigned(SpecialSubKind::string);
   }
 
-  StringView getBaseName() const override {
+  std::string_view getBaseName() const override {
     switch (SSK) {
     case SpecialSubKind::allocator:
-      return StringView("allocator");
+      return {"allocator"};
     case SpecialSubKind::basic_string:
-      return StringView("basic_string");
+      return {"basic_string"};
     case SpecialSubKind::string:
-      return StringView("basic_string");
+      return {"basic_string"};
     case SpecialSubKind::istream:
-      return StringView("basic_istream");
+      return {"basic_istream"};
     case SpecialSubKind::ostream:
-      return StringView("basic_ostream");
+      return {"basic_ostream"};
     case SpecialSubKind::iostream:
-      return StringView("basic_iostream");
+      return {"basic_iostream"};
     }
     DEMANGLE_UNREACHABLE;
   }
 
 private:
   void printLeft(OutputBuffer &OB) const override {
     OB << "std::" << getBaseName();
     if (isInstantiation()) {
       OB << "<char, std::char_traits<char>";
       if (SSK == SpecialSubKind::string)
         OB << ", std::allocator<char>";
       OB << ">";
     }
   }
 };
 
 class SpecialSubstitution final : public ExpandedSpecialSubstitution {
 public:
   SpecialSubstitution(SpecialSubKind SSK_)
       : ExpandedSpecialSubstitution(SSK_, KSpecialSubstitution) {}
 
   template<typename Fn> void match(Fn F) const { F(SSK); }
 
-  StringView getBaseName() const override {
-    auto SV = ExpandedSpecialSubstitution::getBaseName();
+  std::string_view getBaseName() const override {
+    std::string_view SV = ExpandedSpecialSubstitution::getBaseName();
     if (isInstantiation()) {
       // The instantiations are typedefs that drop the "basic_" prefix.
-      assert(SV.startsWith("basic_"));
+      assert(llvm::itanium_demangle::starts_with(SV, "basic_"));
       SV.remove_prefix(sizeof("basic_") - 1);
     }
     return SV;
   }
 
   void printLeft(OutputBuffer &OB) const override {
     OB << "std::" << getBaseName();
   }
public:
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "~";
     Base->printLeft(OB);
   }
 };
 
 class UnnamedTypeName : public Node {
-  const StringView Count;
+  const std::string_view Count;
 
 public:
-  UnnamedTypeName(StringView Count_) : Node(KUnnamedTypeName), Count(Count_) {}
+  UnnamedTypeName(std::string_view Count_)
+      : Node(KUnnamedTypeName), Count(Count_) {}
 
   template<typename Fn> void match(Fn F) const { F(Count); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "'unnamed";
     OB += Count;
     OB += "\'";
   }
 };
 
 class ClosureTypeName : public Node {
   NodeArray TemplateParams;
   NodeArray Params;
-  StringView Count;
+  std::string_view Count;
 
 public:
   ClosureTypeName(NodeArray TemplateParams_, NodeArray Params_,
-                  StringView Count_)
+                  std::string_view Count_)
       : Node(KClosureTypeName), TemplateParams(TemplateParams_),
         Params(Params_), Count(Count_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(TemplateParams, Params, Count);
   }
 
   void printDeclarator(OutputBuffer &OB) const {
void printLeft(OutputBuffer &OB) const override {
     OB.printClose(']');
   }
 };
 
 // -- Expression Nodes --
 
 class BinaryExpr : public Node {
   const Node *LHS;
-  const StringView InfixOperator;
+  const std::string_view InfixOperator;
   const Node *RHS;
 
 public:
-  BinaryExpr(const Node *LHS_, StringView InfixOperator_, const Node *RHS_,
-             Prec Prec_)
+  BinaryExpr(const Node *LHS_, std::string_view InfixOperator_,
+             const Node *RHS_, Prec Prec_)
       : Node(KBinaryExpr, Prec_), LHS(LHS_), InfixOperator(InfixOperator_),
         RHS(RHS_) {}
 
   template <typename Fn> void match(Fn F) const {
     F(LHS, InfixOperator, RHS, getPrecedence());
   }
 
   void printLeft(OutputBuffer &OB) const override {
void printLeft(OutputBuffer &OB) const override {
     OB.printOpen('[');
     Op2->printAsOperand(OB);
     OB.printClose(']');
   }
 };
 
 class PostfixExpr : public Node {
   const Node *Child;
-  const StringView Operator;
+  const std::string_view Operator;
 
 public:
-  PostfixExpr(const Node *Child_, StringView Operator_, Prec Prec_)
+  PostfixExpr(const Node *Child_, std::string_view Operator_, Prec Prec_)
       : Node(KPostfixExpr, Prec_), Child(Child_), Operator(Operator_) {}
 
   template <typename Fn> void match(Fn F) const {
     F(Child, Operator, getPrecedence());
   }
 
   void printLeft(OutputBuffer &OB) const override {
     Child->printAsOperand(OB, getPrecedence(), true);
void printLeft(OutputBuffer &OB) const override {
     Then->printAsOperand(OB);
     OB += " : ";
     Else->printAsOperand(OB, Prec::Assign, true);
   }
 };
 
 class MemberExpr : public Node {
   const Node *LHS;
-  const StringView Kind;
+  const std::string_view Kind;
   const Node *RHS;
 
 public:
-  MemberExpr(const Node *LHS_, StringView Kind_, const Node *RHS_, Prec Prec_)
+  MemberExpr(const Node *LHS_, std::string_view Kind_, const Node *RHS_,
+             Prec Prec_)
       : Node(KMemberExpr, Prec_), LHS(LHS_), Kind(Kind_), RHS(RHS_) {}
 
   template <typename Fn> void match(Fn F) const {
     F(LHS, Kind, RHS, getPrecedence());
   }
 
   void printLeft(OutputBuffer &OB) const override {
     LHS->printAsOperand(OB, getPrecedence(), true);
     OB += Kind;
     RHS->printAsOperand(OB, getPrecedence(), false);
   }
 };
 
 class SubobjectExpr : public Node {
   const Node *Type;
   const Node *SubExpr;
-  StringView Offset;
+  std::string_view Offset;
   NodeArray UnionSelectors;
   bool OnePastTheEnd;
 
 public:
-  SubobjectExpr(const Node *Type_, const Node *SubExpr_, StringView Offset_,
-                NodeArray UnionSelectors_, bool OnePastTheEnd_)
+  SubobjectExpr(const Node *Type_, const Node *SubExpr_,
+                std::string_view Offset_, NodeArray UnionSelectors_,
+                bool OnePastTheEnd_)
       : Node(KSubobjectExpr), Type(Type_), SubExpr(SubExpr_), Offset(Offset_),
         UnionSelectors(UnionSelectors_), OnePastTheEnd(OnePastTheEnd_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(Type, SubExpr, Offset, UnionSelectors, OnePastTheEnd);
   }
 
   void printLeft(OutputBuffer &OB) const override {
void printLeft(OutputBuffer &OB) const override {
     } else {
       OB += Offset;
     }
     OB += ">";
   }
 };
 
 class EnclosingExpr : public Node {
-  const StringView Prefix;
+  const std::string_view Prefix;
   const Node *Infix;
-  const StringView Postfix;
+  const std::string_view Postfix;
 
 public:
-  EnclosingExpr(StringView Prefix_, const Node *Infix_,
+  EnclosingExpr(std::string_view Prefix_, const Node *Infix_,
                 Prec Prec_ = Prec::Primary)
       : Node(KEnclosingExpr, Prec_), Prefix(Prefix_), Infix(Infix_) {}
 
   template <typename Fn> void match(Fn F) const {
     F(Prefix, Infix, getPrecedence());
   }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += Prefix;
     OB.printOpen();
     Infix->print(OB);
     OB.printClose();
     OB += Postfix;
   }
 };
 
 class CastExpr : public Node {
   // cast_kind<to>(from)
-  const StringView CastKind;
+  const std::string_view CastKind;
   const Node *To;
   const Node *From;
 
 public:
-  CastExpr(StringView CastKind_, const Node *To_, const Node *From_, Prec Prec_)
+  CastExpr(std::string_view CastKind_, const Node *To_, const Node *From_,
+           Prec Prec_)
       : Node(KCastExpr, Prec_), CastKind(CastKind_), To(To_), From(From_) {}
 
   template <typename Fn> void match(Fn F) const {
     F(CastKind, To, From, getPrecedence());
   }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += CastKind;
void printLeft(OutputBuffer &OB) const override {
     if (IsArray)
       OB += "[]";
     OB += ' ';
     Op->print(OB);
   }
 };
 
 class PrefixExpr : public Node {
-  StringView Prefix;
+  std::string_view Prefix;
   Node *Child;
 
 public:
-  PrefixExpr(StringView Prefix_, Node *Child_, Prec Prec_)
+  PrefixExpr(std::string_view Prefix_, Node *Child_, Prec Prec_)
       : Node(KPrefixExpr, Prec_), Prefix(Prefix_), Child(Child_) {}
 
   template <typename Fn> void match(Fn F) const {
     F(Prefix, Child, getPrecedence());
   }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += Prefix;
     Child->printAsOperand(OB, getPrecedence());
   }
 };
 
 class FunctionParam : public Node {
-  StringView Number;
+  std::string_view Number;
 
 public:
-  FunctionParam(StringView Number_) : Node(KFunctionParam), Number(Number_) {}
+  FunctionParam(std::string_view Number_)
+      : Node(KFunctionParam), Number(Number_) {}
 
   template<typename Fn> void match(Fn F) const { F(Number); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "fp";
     OB += Number;
   }
 };
void printLeft(OutputBuffer &OB) const override {
     Expressions.printWithComma(OB);
     OB.printClose();
   }
 };
 
 class PointerToMemberConversionExpr : public Node {
   const Node *Type;
   const Node *SubExpr;
-  StringView Offset;
+  std::string_view Offset;
 
 public:
   PointerToMemberConversionExpr(const Node *Type_, const Node *SubExpr_,
-                                StringView Offset_, Prec Prec_)
+                                std::string_view Offset_, Prec Prec_)
       : Node(KPointerToMemberConversionExpr, Prec_), Type(Type_),
         SubExpr(SubExpr_), Offset(Offset_) {}
 
   template <typename Fn> void match(Fn F) const {
     F(Type, SubExpr, Offset, getPrecedence());
   }
 
   void printLeft(OutputBuffer &OB) const override {
void printLeft(OutputBuffer &OB) const override {
     if (Init->getKind() != KBracedExpr && Init->getKind() != KBracedRangeExpr)
       OB += " = ";
     Init->print(OB);
   }
 };
 
 class FoldExpr : public Node {
   const Node *Pack, *Init;
-  StringView OperatorName;
+  std::string_view OperatorName;
   bool IsLeftFold;
 
 public:
-  FoldExpr(bool IsLeftFold_, StringView OperatorName_, const Node *Pack_,
+  FoldExpr(bool IsLeftFold_, std::string_view OperatorName_, const Node *Pack_,
            const Node *Init_)
       : Node(KFoldExpr), Pack(Pack_), Init(Init_), OperatorName(OperatorName_),
         IsLeftFold(IsLeftFold_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(IsLeftFold, OperatorName, Pack, Init);
   }
 
class BoolExpr : public Node {
   bool Value;
 
 public:
   BoolExpr(bool Value_) : Node(KBoolExpr), Value(Value_) {}
 
   template<typename Fn> void match(Fn F) const { F(Value); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB += Value ? StringView("true") : StringView("false");
+    OB += Value ? std::string_view("true") : std::string_view("false");
   }
 };
 
 class StringLiteral : public Node {
   const Node *Type;
 
 public:
   StringLiteral(const Node *Type_) : Node(KStringLiteral), Type(Type_) {}
if (Type->getKind() == KClosureTypeName)
       static_cast<const ClosureTypeName *>(Type)->printDeclarator(OB);
     OB += "{...}";
   }
 };
 
 class EnumLiteral : public Node {
   // ty(integer)
   const Node *Ty;
-  StringView Integer;
+  std::string_view Integer;
 
 public:
-  EnumLiteral(const Node *Ty_, StringView Integer_)
+  EnumLiteral(const Node *Ty_, std::string_view Integer_)
       : Node(KEnumLiteral), Ty(Ty_), Integer(Integer_) {}
 
   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.substr(1);
     else
       OB << Integer;
   }
 };
 
 class IntegerLiteral : public Node {
-  StringView Type;
-  StringView Value;
+  std::string_view Type;
+  std::string_view Value;
 
 public:
-  IntegerLiteral(StringView Type_, StringView Value_)
+  IntegerLiteral(std::string_view Type_, std::string_view 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;
constexpr Node::Kind getFloatLiteralKind(double *) {
   return Node::KDoubleLiteral;
 }
 constexpr Node::Kind getFloatLiteralKind(long double *) {
   return Node::KLongDoubleLiteral;
 }
 }
 
 template <class Float> class FloatLiteralImpl : public Node {
-  const StringView Contents;
+  const std::string_view Contents;
 
   static constexpr Kind KindForClass =
       float_literal_impl::getFloatLiteralKind((Float *)nullptr);
 
 public:
-  FloatLiteralImpl(StringView Contents_)
+  FloatLiteralImpl(std::string_view Contents_)
       : Node(KindForClass), Contents(Contents_) {}
 
   template<typename Fn> void match(Fn F) const { F(Contents); }
 
   void printLeft(OutputBuffer &OB) const override {
-    const char *first = Contents.begin();
-    const char *last = Contents.end() + 1;
+    const char *first = &*Contents.begin();
+    const char *last = &*Contents.end() + 1;
 
     const size_t N = FloatData<Float>::mangled_size;
     if (static_cast<std::size_t>(last - first) > N) {
       last = first + N;
       union {
         Float value;
         char buf[sizeof(Float)];
       };
       const char *t = first;
       char *e = buf;
       for (; t != last; ++t, ++e) {
         unsigned d1 = isdigit(*t) ? static_cast<unsigned>(*t - '0')
                                   : static_cast<unsigned>(*t - 'a' + 10);
         ++t;
         unsigned d0 = isdigit(*t) ? static_cast<unsigned>(*t - '0')
                                   : 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, n);
+      OB += std::string_view(num, n);
     }
   }
 };
 
 using FloatLiteral = FloatLiteralImpl<float>;
 using DoubleLiteral = FloatLiteralImpl<double>;
 using LongDoubleLiteral = FloatLiteralImpl<long double>;
 
template <typename Derived, typename Alloc> struct AbstractManglingParser {
   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 - First).startsWith(S)) {
+  bool consumeIf(std::string_view S) {
+    if (llvm::itanium_demangle::starts_with(
+            std::string_view(First, Last - First), S)) {
       First += S.size();
       return true;
     }
     return false;
   }
 
   bool consumeIf(char C) {
     if (First != Last && *First == C) {
       ++First;
       return true;
     }
     return false;
   }
 
   char consume() { return First != Last ? *First++ : '\0'; }
 
   char look(unsigned Lookahead = 0) const {
     if (static_cast<size_t>(Last - First) <= Lookahead)
       return '\0';
     return First[Lookahead];
   }
 
   size_t numLeft() const { return static_cast<size_t>(Last - First); }
 
-  StringView parseNumber(bool AllowNegative = false);
+  std::string_view parseNumber(bool AllowNegative = false);
   Qualifiers parseCVQualifiers();
   bool parsePositiveInteger(size_t *Out);
-  StringView parseBareSourceName();
+  std::string_view parseBareSourceName();
 
   bool parseSeqId(size_t *Out);
   Node *parseSubstitution();
   Node *parseTemplateParam();
   Node *parseTemplateParamDecl();
   Node *parseTemplateArgs(bool TagTemplates = false);
   Node *parseTemplateArg();
 
   /// Parse the <expr> production.
   Node *parseExpr();
-  Node *parsePrefixExpr(StringView Kind, Node::Prec Prec);
-  Node *parseBinaryExpr(StringView Kind, Node::Prec Prec);
-  Node *parseIntegerLiteral(StringView Lit);
+  Node *parsePrefixExpr(std::string_view Kind, Node::Prec Prec);
+  Node *parseBinaryExpr(std::string_view Kind, Node::Prec Prec);
+  Node *parseIntegerLiteral(std::string_view Lit);
   Node *parseExprPrimary();
   template <class Float> Node *parseFloatingLiteral();
   Node *parseFunctionParam();
   Node *parseConversionExpr();
   Node *parseBracedExpr();
   Node *parseFoldExpr();
   Node *parsePointerToMemberConversionExpr(Node::Prec Prec);
   Node *parseSubobjectExpr();
bool operator<(const char *Peek) const {
       return Enc[0] < Peek[0] || (Enc[0] == Peek[0] && Enc[1] < Peek[1]);
     }
     bool operator==(const char *Peek) const {
       return Enc[0] == Peek[0] && Enc[1] == Peek[1];
     }
     bool operator!=(const char *Peek) const { return !this->operator==(Peek); }
 
   public:
-    StringView getSymbol() const {
-      StringView Res = Name;
+    std::string_view getSymbol() const {
+      std::string_view Res = Name;
       if (Kind < Unnameable) {
-        assert(Res.startsWith("operator") &&
+        assert(llvm::itanium_demangle::starts_with(Res, "operator") &&
                "operator name does not start with 'operator'");
         Res.remove_prefix(sizeof("operator") - 1);
-        if (Res.startsWith(' '))
+        if (llvm::itanium_demangle::starts_with(Res, ' '))
           Res.remove_prefix(1);
       }
       return Res;
     }
-    StringView getName() const { return Name; }
+    std::string_view getName() const { return Name; }
     OIKind getKind() const { return Kind; }
     bool getFlag() const { return Flag; }
     Node::Prec getPrecedence() const { return Prec; }
   };
   static const OperatorInfo Ops[];
   static const size_t NumOps;
   const OperatorInfo *parseOperatorEncoding();
 

 Node *
 AbstractManglingParser<Derived, Alloc>::parseUnnamedTypeName(NameState *State) {
   // <template-params> refer to the innermost <template-args>. Clear out any
   // outer args that we may have inserted into TemplateParams.
   if (State != nullptr)
     TemplateParams.clear();
 
   if (consumeIf("Ut")) {
-    StringView Count = parseNumber();
+    std::string_view Count = parseNumber();
     if (!consumeIf('_'))
       return nullptr;
     return make<UnnamedTypeName>(Count);
   }
   if (consumeIf("Ul")) {
     ScopedOverride<size_t> SwapParams(ParsingLambdaParamsAtLevel,
                                       TemplateParams.size());
     ScopedTemplateParamList LambdaTemplateParams(this);
 
     size_t ParamsBegin = Names.size();
     while (look() == 'T' &&
-           StringView("yptn").find(look(1)) != StringView::npos) {
+           std::string_view("yptn").find(look(1)) != std::string_view::npos) {
       Node *T = parseTemplateParamDecl();
       if (!T)
         return nullptr;
       Names.push_back(T);
     }
     NodeArray TempParams = popTrailingNodeArray(ParamsBegin);
 
     // FIXME: If TempParams is empty and none of the function parameters
if (!consumeIf("vE")) {
         Node *P = getDerived().parseType();
         if (P == nullptr)
           return nullptr;
         Names.push_back(P);
       } while (!consumeIf('E'));
     }
     NodeArray Params = popTrailingNodeArray(ParamsBegin);
 
-    StringView Count = parseNumber();
+    std::string_view Count = parseNumber();
     if (!consumeIf('_'))
       return nullptr;
     return make<ClosureTypeName>(TempParams, Params, Count);
   }
   if (consumeIf("Ub")) {
     (void)parseNumber();
     if (!consumeIf('_'))
       return nullptr;
     return make<NameType>("'block-literal'");
   }
   return nullptr;
 }
 
 // <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, Length);
+  std::string_view Name(First, Length);
   First += Length;
-  if (Name.startsWith("_GLOBAL__N"))
+  if (llvm::itanium_demangle::starts_with(Name, "_GLOBAL__N"))
     return make<NameType>("(anonymous namespace)");
   return make<NameType>(Name);
 }
 
 // Operator encodings
 template <typename Derived, typename Alloc>
 const typename AbstractManglingParser<
     Derived, Alloc>::OperatorInfo AbstractManglingParser<Derived,
Node *AbstractManglingParser<Derived, Alloc>::parseUnresolvedName(bool Global) {
   return make<QualifiedName>(SoFar, Base);
 }
 
 // <abi-tags> ::= <abi-tag> [<abi-tags>]
 // <abi-tag> ::= B <source-name>
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseAbiTags(Node *N) {
   while (consumeIf('B')) {
-    StringView SN = parseBareSourceName();
+    std::string_view SN = parseBareSourceName();
     if (SN.empty())
       return nullptr;
     N = make<AbiTagAttr>(N, SN);
     if (!N)
       return nullptr;
   }
   return N;
 }
 
 // <number> ::= [n] <non-negative decimal integer>
 template <typename Alloc, typename Derived>
-StringView
+std::string_view
 AbstractManglingParser<Alloc, Derived>::parseNumber(bool AllowNegative) {
   const char *Tmp = First;
   if (AllowNegative)
     consumeIf('n');
   if (numLeft() == 0 || !std::isdigit(*First))
-    return StringView();
+    return std::string_view();
   while (numLeft() != 0 && std::isdigit(*First))
     ++First;
-  return StringView(Tmp, First - Tmp);
+  return std::string_view(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() {
+std::string_view AbstractManglingParser<Alloc, Derived>::parseBareSourceName() {
   size_t Int = 0;
   if (parsePositiveInteger(&Int) || numLeft() < Int)
-    return StringView();
-  StringView R(First, Int);
+    return {};
+  std::string_view 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

 }
 
 // <class-enum-type> ::= <name>     # non-dependent type name, dependent type name, or dependent typename-specifier
 //                   ::= Ts <name>  # dependent elaborated type specifier using 'struct' or 'class'
 //                   ::= Tu <name>  # dependent elaborated type specifier using 'union'
 //                   ::= Te <name>  # dependent elaborated type specifier using 'enum'
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseClassEnumType() {
-  StringView ElabSpef;
+  std::string_view ElabSpef;
   if (consumeIf("Ts"))
     ElabSpef = "struct";
   else if (consumeIf("Tu"))
     ElabSpef = "union";
   else if (consumeIf("Te"))
     ElabSpef = "enum";
 
   Node *Name = getDerived().parseName();
   if (Name == nullptr)
     return nullptr;
 
   if (!ElabSpef.empty())
     return make<ElaboratedTypeSpefType>(ElabSpef, Name);
 
   return Name;
 }
 
 // <qualified-type>     ::= <qualifiers> <type>
 // <qualifiers> ::= <extended-qualifier>* <CV-qualifiers>
 // <extended-qualifier> ::= U <source-name> [<template-args>] # vendor extended type qualifier
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseQualifiedType() {
   if (consumeIf('U')) {
-    StringView Qual = parseBareSourceName();
+    std::string_view Qual = parseBareSourceName();
     if (Qual.empty())
       return nullptr;
 
     // extension            ::= U <objc-name> <objc-type>  # objc-type<identifier>
-    if (Qual.startsWith("objcproto")) {
-      StringView ProtoSourceName = Qual.substr(std::strlen("objcproto"));
-      StringView Proto;
+    if (llvm::itanium_demangle::starts_with(Qual, "objcproto")) {
+      std::string_view ProtoSourceName = Qual.substr(std::strlen("objcproto"));
+      std::string_view Proto;
       {
-        ScopedOverride<const char *> SaveFirst(First, ProtoSourceName.begin()),
-            SaveLast(Last, ProtoSourceName.end());
+        ScopedOverride<const char *> SaveFirst(First, &*ProtoSourceName.begin()),
+            SaveLast(Last, &*ProtoSourceName.end());
         Proto = parseBareSourceName();
       }
       if (Proto.empty())
         return nullptr;
       Node *Child = getDerived().parseQualifiedType();
       if (Child == nullptr)
         return nullptr;
       return make<ObjCProtoName>(Child, Proto);
Node *AbstractManglingParser<Derived, Alloc>::parseType() {
   //                ::= z    # ellipsis
   case 'z':
     ++First;
     return make<NameType>("...");
 
   // <builtin-type> ::= u <source-name>    # vendor extended type
   case 'u': {
     ++First;
-    StringView Res = parseBareSourceName();
+    std::string_view Res = parseBareSourceName();
     if (Res.empty())
       return nullptr;
     // Typically, <builtin-type>s are not considered substitution candidates,
     // but the exception to that exception is vendor extended types (Itanium C++
     // ABI 5.9.1).
     Result = make<NameType>(Res);
     break;
   }
Node *AbstractManglingParser<Derived, Alloc>::parseType() {
   // <builtin-type>s and <substitution>s have already bailed out, because they
   // don't get substitutions.
   if (Result != nullptr)
     Subs.push_back(Result);
   return Result;
 }
 
 template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parsePrefixExpr(StringView Kind,
-                                                              Node::Prec Prec) {
+Node *
+AbstractManglingParser<Derived, Alloc>::parsePrefixExpr(std::string_view Kind,
   Node *E = getDerived().parseExpr();
   if (E == nullptr)
     return nullptr;
   return make<PrefixExpr>(Kind, E, Prec);
 }
 
 template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseBinaryExpr(StringView Kind,
-                                                              Node::Prec Prec) {
+Node *
+AbstractManglingParser<Derived, Alloc>::parseBinaryExpr(std::string_view Kind,
   Node *LHS = getDerived().parseExpr();
   if (LHS == nullptr)
     return nullptr;
   Node *RHS = getDerived().parseExpr();
   if (RHS == nullptr)
     return nullptr;
   return make<BinaryExpr>(LHS, Kind, RHS, Prec);
 }
 
 template <typename Derived, typename Alloc>
-Node *
-AbstractManglingParser<Derived, Alloc>::parseIntegerLiteral(StringView Lit) {
-  StringView Tmp = parseNumber(true);
+Node *AbstractManglingParser<Derived, Alloc>::parseIntegerLiteral(
+    std::string_view Lit) {
+  std::string_view Tmp = parseNumber(true);
   if (!Tmp.empty() && consumeIf('E'))
     return make<IntegerLiteral>(Lit, Tmp);
   return nullptr;
 }
 
 // <CV-Qualifiers> ::= [r] [V] [K]
 template <typename Alloc, typename Derived>
 Qualifiers AbstractManglingParser<Alloc, Derived>::parseCVQualifiers() {

 //                  ::= fL <L-1 non-negative number> p <top-level CV-Qualifiers> <parameter-2 non-negative number> _   # L > 0, second and later parameters
 //                  ::= fpT      # 'this' expression (not part of standard?)
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseFunctionParam() {
   if (consumeIf("fpT"))
     return make<NameType>("this");
   if (consumeIf("fp")) {
     parseCVQualifiers();
-    StringView Num = parseNumber();
+    std::string_view Num = parseNumber();
     if (!consumeIf('_'))
       return nullptr;
     return make<FunctionParam>(Num);
   }
   if (consumeIf("fL")) {
     if (parseNumber().empty())
       return nullptr;
     if (!consumeIf('p'))
       return nullptr;
     parseCVQualifiers();
-    StringView Num = parseNumber();
+    std::string_view Num = parseNumber();
     if (!consumeIf('_'))
       return nullptr;
     return make<FunctionParam>(Num);
   }
   return nullptr;
 }
 
 // cv <type> <expression>                               # conversion with one argument
if (!T || !consumeIf('E'))
       return nullptr;
     return make<LambdaExpr>(T);
   }
   default: {
     // might be named type
     Node *T = getDerived().parseType();
     if (T == nullptr)
       return nullptr;
-    StringView N = parseNumber(/*AllowNegative=*/true);
+    std::string_view N = parseNumber(/*AllowNegative=*/true);
     if (N.empty())
       return nullptr;
     if (!consumeIf('E'))
       return nullptr;
     return make<EnumLiteral>(T, N);
   }
   }
 }

 AbstractManglingParser<Derived, Alloc>::parsePointerToMemberConversionExpr(
     Node::Prec Prec) {
   Node *Ty = getDerived().parseType();
   if (!Ty)
     return nullptr;
   Node *Expr = getDerived().parseExpr();
   if (!Expr)
     return nullptr;
-  StringView Offset = getDerived().parseNumber(true);
+  std::string_view Offset = getDerived().parseNumber(true);
   if (!consumeIf('E'))
     return nullptr;
   return make<PointerToMemberConversionExpr>(Ty, Expr, Offset, Prec);
 }
 
 // <expression> ::= so <referent type> <expr> [<offset number>] <union-selector>* [p] E
 // <union-selector> ::= _ [<number>]
 //
 // Not yet in the spec: https://github.com/itanium-cxx-abi/cxx-abi/issues/47
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseSubobjectExpr() {
   Node *Ty = getDerived().parseType();
   if (!Ty)
     return nullptr;
   Node *Expr = getDerived().parseExpr();
   if (!Expr)
     return nullptr;
-  StringView Offset = getDerived().parseNumber(true);
+  std::string_view Offset = getDerived().parseNumber(true);
   size_t SelectorsBegin = Names.size();
   while (consumeIf('_')) {
     Node *Selector = make<NameType>(parseNumber());
     if (!Selector)
       return nullptr;
     Names.push_back(Selector);
   }
   bool OnePastTheEnd = consumeIf('p');

 };
 
 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, N);
+  std::string_view 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 - First));
+      Encoding =
+          make<DotSuffix>(Encoding, std::string_view(First, Last - First));
       First = Last;
     }
     if (numLeft() != 0)
       return nullptr;
     return Encoding;
   }
 
   if (consumeIf("___Z") || consumeIf("____Z")) {

llvm/include/llvm/Demangle/MicrosoftDemangle.h

 //===------------------------- MicrosoftDemangle.h --------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEMANGLE_MICROSOFTDEMANGLE_H
 #define LLVM_DEMANGLE_MICROSOFTDEMANGLE_H
 
 #include "llvm/Demangle/MicrosoftDemangleNodes.h"
-#include "llvm/Demangle/StringView.h"
 
+#include <cassert>
+#include <string_view>
 #include <utility>
 
 namespace llvm {
 namespace ms_demangle {
 // This memory allocator is extremely fast, but it doesn't call dtors
 // for allocated objects. That means you can't use STL containers
 // (such as std::vector) with this allocator. But it pays off --
 // the demangler is 3x faster with this allocator compared to one with

 // It also has a set of functions to convert Type instances to strings.
 class Demangler {
 public:
   Demangler() = default;
   virtual ~Demangler() = default;
 
   // You are supposed to call parse() first and then check if error is true.  If
   // it is false, call output() to write the formatted name to the given stream.
-  SymbolNode *parse(StringView &MangledName);
+  SymbolNode *parse(std::string_view &MangledName);
 
-  TagTypeNode *parseTagUniqueName(StringView &MangledName);
+  TagTypeNode *parseTagUniqueName(std::string_view &MangledName);
 
   // True if an error occurred.
   bool Error = false;
 
   void dumpBackReferences();
 
 private:
-  SymbolNode *demangleEncodedSymbol(StringView &MangledName,
+  SymbolNode *demangleEncodedSymbol(std::string_view &MangledName,
                                     QualifiedNameNode *QN);
-  SymbolNode *demangleDeclarator(StringView &MangledName);
-  SymbolNode *demangleMD5Name(StringView &MangledName);
-  SymbolNode *demangleTypeinfoName(StringView &MangledName);
+  SymbolNode *demangleDeclarator(std::string_view &MangledName);
+  SymbolNode *demangleMD5Name(std::string_view &MangledName);
+  SymbolNode *demangleTypeinfoName(std::string_view &MangledName);
 
-  VariableSymbolNode *demangleVariableEncoding(StringView &MangledName,
+  VariableSymbolNode *demangleVariableEncoding(std::string_view &MangledName,
                                                StorageClass SC);
-  FunctionSymbolNode *demangleFunctionEncoding(StringView &MangledName);
+  FunctionSymbolNode *demangleFunctionEncoding(std::string_view &MangledName);
 
-  Qualifiers demanglePointerExtQualifiers(StringView &MangledName);
+  Qualifiers demanglePointerExtQualifiers(std::string_view &MangledName);
 
   // Parser functions. This is a recursive-descent parser.
-  TypeNode *demangleType(StringView &MangledName, QualifierMangleMode QMM);
-  PrimitiveTypeNode *demanglePrimitiveType(StringView &MangledName);
-  CustomTypeNode *demangleCustomType(StringView &MangledName);
-  TagTypeNode *demangleClassType(StringView &MangledName);
-  PointerTypeNode *demanglePointerType(StringView &MangledName);
-  PointerTypeNode *demangleMemberPointerType(StringView &MangledName);
-  FunctionSignatureNode *demangleFunctionType(StringView &MangledName,
+  TypeNode *demangleType(std::string_view &MangledName,
+                         QualifierMangleMode QMM);
+  PrimitiveTypeNode *demanglePrimitiveType(std::string_view &MangledName);
+  CustomTypeNode *demangleCustomType(std::string_view &MangledName);
+  TagTypeNode *demangleClassType(std::string_view &MangledName);
+  PointerTypeNode *demanglePointerType(std::string_view &MangledName);
+  PointerTypeNode *demangleMemberPointerType(std::string_view &MangledName);
+  FunctionSignatureNode *demangleFunctionType(std::string_view &MangledName,
                                               bool HasThisQuals);
 
-  ArrayTypeNode *demangleArrayType(StringView &MangledName);
+  ArrayTypeNode *demangleArrayType(std::string_view &MangledName);
 
-  NodeArrayNode *demangleFunctionParameterList(StringView &MangledName,
+  NodeArrayNode *demangleFunctionParameterList(std::string_view &MangledName,
                                                bool &IsVariadic);
-  NodeArrayNode *demangleTemplateParameterList(StringView &MangledName);
+  NodeArrayNode *demangleTemplateParameterList(std::string_view &MangledName);
 
-  std::pair<uint64_t, bool> demangleNumber(StringView &MangledName);
-  uint64_t demangleUnsigned(StringView &MangledName);
-  int64_t demangleSigned(StringView &MangledName);
+  std::pair<uint64_t, bool> demangleNumber(std::string_view &MangledName);
+  uint64_t demangleUnsigned(std::string_view &MangledName);
+  int64_t demangleSigned(std::string_view &MangledName);
 
-  void memorizeString(StringView s);
+  void memorizeString(std::string_view s);
   void memorizeIdentifier(IdentifierNode *Identifier);
 
   /// Allocate a copy of \p Borrowed into memory that we own.
-  StringView copyString(StringView Borrowed);
+  std::string_view copyString(std::string_view Borrowed);
 
-  QualifiedNameNode *demangleFullyQualifiedTypeName(StringView &MangledName);
-  QualifiedNameNode *demangleFullyQualifiedSymbolName(StringView &MangledName);
+  QualifiedNameNode *
+  demangleFullyQualifiedTypeName(std::string_view &MangledName);
+  QualifiedNameNode *
+  demangleFullyQualifiedSymbolName(std::string_view &MangledName);
 
-  IdentifierNode *demangleUnqualifiedTypeName(StringView &MangledName,
+  IdentifierNode *demangleUnqualifiedTypeName(std::string_view &MangledName,
                                               bool Memorize);
-  IdentifierNode *demangleUnqualifiedSymbolName(StringView &MangledName,
+  IdentifierNode *demangleUnqualifiedSymbolName(std::string_view &MangledName,
                                                 NameBackrefBehavior NBB);
 
-  QualifiedNameNode *demangleNameScopeChain(StringView &MangledName,
+  QualifiedNameNode *demangleNameScopeChain(std::string_view &MangledName,
                                             IdentifierNode *UnqualifiedName);
-  IdentifierNode *demangleNameScopePiece(StringView &MangledName);
+  IdentifierNode *demangleNameScopePiece(std::string_view &MangledName);
 
-  NamedIdentifierNode *demangleBackRefName(StringView &MangledName);
-  IdentifierNode *demangleTemplateInstantiationName(StringView &MangledName,
-                                                    NameBackrefBehavior NBB);
+  NamedIdentifierNode *demangleBackRefName(std::string_view &MangledName);
+  IdentifierNode *
+  demangleTemplateInstantiationName(std::string_view &MangledName,
   IntrinsicFunctionKind
   translateIntrinsicFunctionCode(char CH, FunctionIdentifierCodeGroup Group);
-  IdentifierNode *demangleFunctionIdentifierCode(StringView &MangledName);
+  IdentifierNode *demangleFunctionIdentifierCode(std::string_view &MangledName);
   IdentifierNode *
-  demangleFunctionIdentifierCode(StringView &MangledName,
+  demangleFunctionIdentifierCode(std::string_view &MangledName,
                                  FunctionIdentifierCodeGroup Group);
-  StructorIdentifierNode *demangleStructorIdentifier(StringView &MangledName,
-                                                     bool IsDestructor);
+  StructorIdentifierNode *
+  demangleStructorIdentifier(std::string_view &MangledName, bool IsDestructor);
   ConversionOperatorIdentifierNode *
-  demangleConversionOperatorIdentifier(StringView &MangledName);
+  demangleConversionOperatorIdentifier(std::string_view &MangledName);
   LiteralOperatorIdentifierNode *
-  demangleLiteralOperatorIdentifier(StringView &MangledName);
+  demangleLiteralOperatorIdentifier(std::string_view &MangledName);
 
-  SymbolNode *demangleSpecialIntrinsic(StringView &MangledName);
+  SymbolNode *demangleSpecialIntrinsic(std::string_view &MangledName);
   SpecialTableSymbolNode *
-  demangleSpecialTableSymbolNode(StringView &MangledName,
+  demangleSpecialTableSymbolNode(std::string_view &MangledName,
                                  SpecialIntrinsicKind SIK);
   LocalStaticGuardVariableNode *
-  demangleLocalStaticGuard(StringView &MangledName, bool IsThread);
+  demangleLocalStaticGuard(std::string_view &MangledName, bool IsThread);
   VariableSymbolNode *demangleUntypedVariable(ArenaAllocator &Arena,
-                                              StringView &MangledName,
-                                              StringView VariableName);
+                                              std::string_view &MangledName,
+                                              std::string_view VariableName);
   VariableSymbolNode *
   demangleRttiBaseClassDescriptorNode(ArenaAllocator &Arena,
-                                      StringView &MangledName);
-  FunctionSymbolNode *demangleInitFiniStub(StringView &MangledName,
+                                      std::string_view &MangledName);
+  FunctionSymbolNode *demangleInitFiniStub(std::string_view &MangledName,
                                            bool IsDestructor);
 
-  NamedIdentifierNode *demangleSimpleName(StringView &MangledName,
+  NamedIdentifierNode *demangleSimpleName(std::string_view &MangledName,
                                           bool Memorize);
-  NamedIdentifierNode *demangleAnonymousNamespaceName(StringView &MangledName);
-  NamedIdentifierNode *demangleLocallyScopedNamePiece(StringView &MangledName);
-  EncodedStringLiteralNode *demangleStringLiteral(StringView &MangledName);
-  FunctionSymbolNode *demangleVcallThunkNode(StringView &MangledName);
-
-  StringView demangleSimpleString(StringView &MangledName, bool Memorize);
-
-  FuncClass demangleFunctionClass(StringView &MangledName);
-  CallingConv demangleCallingConvention(StringView &MangledName);
-  StorageClass demangleVariableStorageClass(StringView &MangledName);
-  bool demangleThrowSpecification(StringView &MangledName);
-  wchar_t demangleWcharLiteral(StringView &MangledName);
-  uint8_t demangleCharLiteral(StringView &MangledName);
+  NamedIdentifierNode *
+  demangleAnonymousNamespaceName(std::string_view &MangledName);
+  NamedIdentifierNode *
+  demangleLocallyScopedNamePiece(std::string_view &MangledName);
+  EncodedStringLiteralNode *
+  demangleStringLiteral(std::string_view &MangledName);
+  FunctionSymbolNode *demangleVcallThunkNode(std::string_view &MangledName);
+
+  std::string_view demangleSimpleString(std::string_view &MangledName,
+                                        bool Memorize);
+
+  FuncClass demangleFunctionClass(std::string_view &MangledName);
+  CallingConv demangleCallingConvention(std::string_view &MangledName);
+  StorageClass demangleVariableStorageClass(std::string_view &MangledName);
+  bool demangleThrowSpecification(std::string_view &MangledName);
+  wchar_t demangleWcharLiteral(std::string_view &MangledName);
+  uint8_t demangleCharLiteral(std::string_view &MangledName);
 
-  std::pair<Qualifiers, bool> demangleQualifiers(StringView &MangledName);
+  std::pair<Qualifiers, bool> demangleQualifiers(std::string_view &MangledName);
 
   // Memory allocator.
   ArenaAllocator Arena;
 
   // A single type uses one global back-ref table for all function params.
   // This means back-refs can even go "into" other types.  Examples:
   //
   //  // Second int* is a back-ref to first.

llvm/include/llvm/Demangle/MicrosoftDemangleNodes.h

 //===- MicrosoftDemangleNodes.h ---------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the AST nodes used in the MSVC demangler.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEMANGLE_MICROSOFTDEMANGLENODES_H
 #define LLVM_DEMANGLE_MICROSOFTDEMANGLENODES_H
 
-#include "llvm/Demangle/StringView.h"
 #include <array>
 #include <cstdint>
 #include <string>
+#include <string_view>
 
 namespace llvm {
 namespace itanium_demangle {
 class OutputBuffer;
 }
 }
 
 using llvm::itanium_demangle::OutputBuffer;
-using llvm::itanium_demangle::StringView;
 
 namespace llvm {
 namespace ms_demangle {
 
 // Storage classes
 enum Qualifiers : uint8_t {
   Q_None = 0,
   Q_Const = 1 << 0,
struct DynamicStructorIdentifierNode : public IdentifierNode {
   bool IsDestructor = false;
 };
 
 struct NamedIdentifierNode : public IdentifierNode {
   NamedIdentifierNode() : IdentifierNode(NodeKind::NamedIdentifier) {}
 
   void output(OutputBuffer &OB, OutputFlags Flags) const override;
 
-  StringView Name;
+  std::string_view Name;
 };
 
 struct IntrinsicFunctionIdentifierNode : public IdentifierNode {
   explicit IntrinsicFunctionIdentifierNode(IntrinsicFunctionKind Operator)
       : IdentifierNode(NodeKind::IntrinsicFunctionIdentifier),
         Operator(Operator) {}
 
   void output(OutputBuffer &OB, OutputFlags Flags) const override;
 
   IntrinsicFunctionKind Operator;
 };
 
 struct LiteralOperatorIdentifierNode : public IdentifierNode {
   LiteralOperatorIdentifierNode()
       : IdentifierNode(NodeKind::LiteralOperatorIdentifier) {}
 
   void output(OutputBuffer &OB, OutputFlags Flags) const override;
 
-  StringView Name;
+  std::string_view Name;
 };
 
 struct LocalStaticGuardIdentifierNode : public IdentifierNode {
   LocalStaticGuardIdentifierNode()
       : IdentifierNode(NodeKind::LocalStaticGuardIdentifier) {}
 
   void output(OutputBuffer &OB, OutputFlags Flags) const override;
 
struct CustomTypeNode : public TypeNode {
   IdentifierNode *Identifier = nullptr;
 };
 
 struct NodeArrayNode : public Node {
   NodeArrayNode() : Node(NodeKind::NodeArray) {}
 
   void output(OutputBuffer &OB, OutputFlags Flags) const override;
 
-  void output(OutputBuffer &OB, OutputFlags Flags, StringView Separator) const;
+  void output(OutputBuffer &OB, OutputFlags Flags,
+              std::string_view Separator) const;
 
   Node **Nodes = nullptr;
   size_t Count = 0;
 };
 
 struct QualifiedNameNode : public Node {
   QualifiedNameNode() : Node(NodeKind::QualifiedName) {}
 
struct LocalStaticGuardVariableNode : public SymbolNode {
   bool IsVisible = false;
 };
 
 struct EncodedStringLiteralNode : public SymbolNode {
   EncodedStringLiteralNode() : SymbolNode(NodeKind::EncodedStringLiteral) {}
 
   void output(OutputBuffer &OB, OutputFlags Flags) const override;
 
-  StringView DecodedString;
+  std::string_view DecodedString;
   bool IsTruncated = false;
   CharKind Char = CharKind::Char;
 };
 
 struct VariableSymbolNode : public SymbolNode {
   VariableSymbolNode() : SymbolNode(NodeKind::VariableSymbol) {}
 
   void output(OutputBuffer &OB, OutputFlags Flags) const override;

llvm/include/llvm/Demangle/Utility.h

 // is the original and the one in llvm is the copy.  Use cp-to-llvm.sh to update
 // the copy.  See README.txt for more details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef DEMANGLE_UTILITY_H
 #define DEMANGLE_UTILITY_H
 
-#include "StringView.h"
+#include "DemangleConfig.h"
+
 #include <array>
+#include <cassert>
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
 #include <exception>
 #include <limits>
+#include <string_view>
 
 DEMANGLE_NAMESPACE_BEGIN
 
 // Stream that AST nodes write their string representation into after the AST
 // has been parsed.
 class OutputBuffer {
   char *Buffer = nullptr;
   size_t CurrentPosition = 0;
do {
       *--TempPtr = char('0' + N % 10);
       N /= 10;
     } while (N);
 
     // Add negative sign.
     if (isNeg)
       *--TempPtr = '-';
 
-    return operator+=(StringView(TempPtr, Temp.data() + Temp.size() - TempPtr));
+    return operator+=(
+        std::string_view(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;
   // Non-copyable
   OutputBuffer(const OutputBuffer &) = delete;
   OutputBuffer &operator=(const OutputBuffer &) = delete;
 
-  operator StringView() const { return StringView(Buffer, CurrentPosition); }
+  operator std::string_view() const {
+    return std::string_view(Buffer, CurrentPosition);
+  }
 
   /// If a ParameterPackExpansion (or similar type) is encountered, the offset
   /// into the pack that we're currently printing.
   unsigned CurrentPackIndex = std::numeric_limits<unsigned>::max();
   unsigned CurrentPackMax = std::numeric_limits<unsigned>::max();
 
   /// When zero, we're printing template args and '>' needs to be parenthesized.
   /// Use a counter so we can simply increment inside parentheses.
   unsigned GtIsGt = 1;
 
   bool isGtInsideTemplateArgs() const { return GtIsGt == 0; }
 
   void printOpen(char Open = '(') {
     GtIsGt++;
     *this += Open;
   }
   void printClose(char Close = ')') {
     GtIsGt--;
     *this += Close;
   }
 
-  OutputBuffer &operator+=(StringView R) {
+  OutputBuffer &operator+=(std::string_view R) {
     if (size_t Size = R.size()) {
       grow(Size);
-      std::memcpy(Buffer + CurrentPosition, R.begin(), Size);
+      std::memcpy(Buffer + CurrentPosition, &*R.begin(), Size);
       CurrentPosition += Size;
     }
     return *this;
   }
 
   OutputBuffer &operator+=(char C) {
     grow(1);
     Buffer[CurrentPosition++] = C;
     return *this;
   }
 
-  OutputBuffer &prepend(StringView R) {
+  OutputBuffer &prepend(std::string_view R) {
     size_t Size = R.size();
 
     grow(Size);
     std::memmove(Buffer + Size, Buffer, CurrentPosition);
-    std::memcpy(Buffer, R.begin(), Size);
+    std::memcpy(Buffer, &*R.begin(), Size);
     CurrentPosition += Size;
 
     return *this;
   }
 
-  OutputBuffer &operator<<(StringView R) { return (*this += R); }
+  OutputBuffer &operator<<(std::string_view R) { return (*this += R); }
 
   OutputBuffer &operator<<(char C) { return (*this += C); }
 
   OutputBuffer &operator<<(long long N) {
     return writeUnsigned(static_cast<unsigned long long>(std::abs(N)), N < 0);
   }
 
   OutputBuffer &operator<<(unsigned long long N) {

llvm/lib/Demangle/DLangDemangle.cpp

 //===--- DLangDemangle.cpp ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file defines a demangler for the D programming language as specified
 /// in the ABI specification, available at:
 /// https://dlang.org/spec/abi.html#name_mangling
 ///
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Demangle/Demangle.h"
-#include "llvm/Demangle/StringView.h"
 #include "llvm/Demangle/Utility.h"
 
 #include <cctype>
 #include <cstring>
 #include <limits>
 
 using namespace llvm;
 using llvm::itanium_demangle::OutputBuffer;
-using llvm::itanium_demangle::StringView;
 
 namespace {
 
 /// Demangle information structure.
 struct Demangler {
   /// Initialize the information structure we use to pass around information.
   ///
   /// \param Mangled String to demangle.
if (strncmp(Mangled, "__ModuleInfoZ", Len + 1) == 0) {
       Demangled->prepend("ModuleInfo for ");
       Demangled->setCurrentPosition(Demangled->getCurrentPosition() - 1);
       Mangled += Len;
       return Mangled;
     }
     break;
   }
 
-  *Demangled << StringView(Mangled, Len);
+  *Demangled << std::string_view(Mangled, Len);
   Mangled += Len;
 
   return Mangled;
 }
 
 Demangler::Demangler(const char *Mangled)
     : Str(Mangled), LastBackref(strlen(Mangled)) {}
 

llvm/lib/Demangle/ItaniumDemangle.cpp

struct DumpVisitor {
   template<typename ...Ts> static bool anyWantNewline(Ts ...Vs) {
     for (bool B : {wantsNewline(Vs)...})
       if (B)
         return true;
     return false;
   }
 
   void printStr(const char *S) { fprintf(stderr, "%s", S); }
-  void print(StringView SV) {
-    fprintf(stderr, "\"%.*s\"", (int)SV.size(), SV.begin());
+  void print(std::string_view SV) {
+    fprintf(stderr, "\"%.*s\"", (int)SV.size(), &*SV.begin());
   }
   void print(const Node *N) {
     if (N)
       N->visit(std::ref(*this));
     else
       printStr("<null>");
   }
   void print(NodeArray A) {

llvm/lib/Demangle/MicrosoftDemangle.cpp

 //===- MicrosoftDemangle.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a demangler for MSVC-style mangled symbols.
 //
 // This file has no dependencies on the rest of LLVM so that it can be
 // easily reused in other programs such as libcxxabi.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Demangle/MicrosoftDemangle.h"
-#include "llvm/Demangle/Demangle.h"
-#include "llvm/Demangle/MicrosoftDemangleNodes.h"
 
+#include "llvm/Demangle/Demangle.h"
 #include "llvm/Demangle/DemangleConfig.h"
-#include "llvm/Demangle/StringView.h"
+#include "llvm/Demangle/MicrosoftDemangleNodes.h"
+#include "llvm/Demangle/StringViewExtras.h"
 #include "llvm/Demangle/Utility.h"
 
 #include <array>
 #include <cctype>
 #include <cstdio>
+#include <string_view>
 #include <tuple>
 
 using namespace llvm;
 using namespace ms_demangle;
 
-static bool startsWithDigit(StringView S) {
+static bool startsWithDigit(std::string_view S) {
   return !S.empty() && std::isdigit(S.front());
 }
 
 struct NodeList {
   Node *N = nullptr;
   NodeList *Next = nullptr;
 };
 
-static bool consumeFront(StringView &S, char C) {
-  if (!S.startsWith(C))
+static bool consumeFront(std::string_view &S, char C) {
+  if (!llvm::itanium_demangle::starts_with(S, C))
     return false;
   S.remove_prefix(1);
   return true;
 }
 
-static bool consumeFront(StringView &S, StringView C) {
-  if (!S.startsWith(C))
+static bool consumeFront(std::string_view &S, std::string_view C) {
+  if (!llvm::itanium_demangle::starts_with(S, C))
     return false;
   S.remove_prefix(C.size());
   return true;
 }
 
-static bool isMemberPointer(StringView MangledName, bool &Error) {
+static bool isMemberPointer(std::string_view 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.
     return false;
case 'T':
     return true;
   default:
     Error = true;
     return false;
   }
 }
 
 static SpecialIntrinsicKind
-consumeSpecialIntrinsicKind(StringView &MangledName) {
+consumeSpecialIntrinsicKind(std::string_view &MangledName) {
   if (consumeFront(MangledName, "?_7"))
     return SpecialIntrinsicKind::Vftable;
   if (consumeFront(MangledName, "?_8"))
     return SpecialIntrinsicKind::Vbtable;
   if (consumeFront(MangledName, "?_9"))
     return SpecialIntrinsicKind::VcallThunk;
   if (consumeFront(MangledName, "?_A"))
     return SpecialIntrinsicKind::Typeof;
if (consumeFront(MangledName, "?__E"))
     return SpecialIntrinsicKind::DynamicInitializer;
   if (consumeFront(MangledName, "?__F"))
     return SpecialIntrinsicKind::DynamicAtexitDestructor;
   if (consumeFront(MangledName, "?__J"))
     return SpecialIntrinsicKind::LocalStaticThreadGuard;
   return SpecialIntrinsicKind::None;
 }
 
-static bool startsWithLocalScopePattern(StringView S) {
+static bool startsWithLocalScopePattern(std::string_view S) {
   if (!consumeFront(S, '?'))
     return false;
 
   size_t End = S.find('?');
-  if (End == StringView::npos)
+  if (End == std::string_view::npos)
     return false;
-  StringView Candidate = S.substr(0, End);
+  std::string_view Candidate = S.substr(0, End);
   if (Candidate.empty())
     return false;
 
   // \?[0-9]\?
   // ?@? is the discriminator 0.
   if (Candidate.size() == 1)
     return Candidate[0] == '@' || (Candidate[0] >= '0' && Candidate[0] <= '9');
 
while (!Candidate.empty()) {
     if (Candidate[0] < 'A' || Candidate[0] > 'P')
       return false;
     Candidate.remove_prefix(1);
   }
 
   return true;
 }
 
-static bool isTagType(StringView S) {
+static bool isTagType(std::string_view S) {
   switch (S.front()) {
   case 'T': // union
   case 'U': // struct
   case 'V': // class
   case 'W': // enum
     return true;
   }
   return false;
 }
 
-static bool isCustomType(StringView S) { return S[0] == '?'; }
+static bool isCustomType(std::string_view S) { return S[0] == '?'; }
 
-static bool isPointerType(StringView S) {
-  if (S.startsWith("$$Q")) // foo &&
+static bool isPointerType(std::string_view S) {
+  if (llvm::itanium_demangle::starts_with(S, "$$Q")) // foo &&
     return true;
 
   switch (S.front()) {
   case 'A': // foo &
   case 'P': // foo *
   case 'Q': // foo *const
   case 'R': // foo *volatile
   case 'S': // foo *const volatile
     return true;
   }
   return false;
 }
 
-static bool isArrayType(StringView S) { return S[0] == 'Y'; }
+static bool isArrayType(std::string_view S) { return S[0] == 'Y'; }
 
-static bool isFunctionType(StringView S) {
-  return S.startsWith("$$A8@@") || S.startsWith("$$A6");
+static bool isFunctionType(std::string_view S) {
+  return llvm::itanium_demangle::starts_with(S, "$$A8@@") ||
+         llvm::itanium_demangle::starts_with(S, "$$A6");
 }
 
 static FunctionRefQualifier
-demangleFunctionRefQualifier(StringView &MangledName) {
+demangleFunctionRefQualifier(std::string_view &MangledName) {
   if (consumeFront(MangledName, 'G'))
     return FunctionRefQualifier::Reference;
   else if (consumeFront(MangledName, 'H'))
     return FunctionRefQualifier::RValueReference;
   return FunctionRefQualifier::None;
 }
 
 static std::pair<Qualifiers, PointerAffinity>
-demanglePointerCVQualifiers(StringView &MangledName) {
+demanglePointerCVQualifiers(std::string_view &MangledName) {
   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':
     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);
   case 'S':
     return std::make_pair(Qualifiers(Q_Const | Q_Volatile),
                           PointerAffinity::Pointer);
   }
   // This function is only called if isPointerType() returns true,
   // and it only returns true for the six cases listed above.
   DEMANGLE_UNREACHABLE;
 }
 
-StringView Demangler::copyString(StringView Borrowed) {
+std::string_view Demangler::copyString(std::string_view Borrowed) {
   char *Stable = Arena.allocUnalignedBuffer(Borrowed.size());
   // This is not a micro-optimization, it avoids UB, should Borrowed be an null
   // buffer.
   if (Borrowed.size())
-    std::memcpy(Stable, Borrowed.begin(), Borrowed.size());
+    std::memcpy(Stable, &*Borrowed.begin(), Borrowed.size());
 
   return {Stable, Borrowed.size()};
 }
 
 SpecialTableSymbolNode *
-Demangler::demangleSpecialTableSymbolNode(StringView &MangledName,
+Demangler::demangleSpecialTableSymbolNode(std::string_view &MangledName,
                                           SpecialIntrinsicKind K) {
   NamedIdentifierNode *NI = Arena.alloc<NamedIdentifierNode>();
   switch (K) {
   case SpecialIntrinsicKind::Vftable:
     NI->Name = "`vftable'";
     break;
   case SpecialIntrinsicKind::Vbtable:
     NI->Name = "`vbtable'";
Demangler::demangleSpecialTableSymbolNode(std::string_view &MangledName,
 
   std::tie(STSN->Quals, IsMember) = demangleQualifiers(MangledName);
   if (!consumeFront(MangledName, '@'))
     STSN->TargetName = demangleFullyQualifiedTypeName(MangledName);
   return STSN;
 }
 
 LocalStaticGuardVariableNode *
-Demangler::demangleLocalStaticGuard(StringView &MangledName, bool IsThread) {
+Demangler::demangleLocalStaticGuard(std::string_view &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 (consumeFront(MangledName, "4IA"))
     LSGVN->IsVisible = false;
   else if (consumeFront(MangledName, "5"))
     LSGVN->IsVisible = true;
   else {
     Error = true;
     return nullptr;
   }
 
   if (!MangledName.empty())
     LSGI->ScopeIndex = demangleUnsigned(MangledName);
   return LSGVN;
 }
 
 static NamedIdentifierNode *synthesizeNamedIdentifier(ArenaAllocator &Arena,
-                                                      StringView Name) {
+                                                      std::string_view Name) {
   NamedIdentifierNode *Id = Arena.alloc<NamedIdentifierNode>();
   Id->Name = Name;
   return Id;
 }
 
 static QualifiedNameNode *synthesizeQualifiedName(ArenaAllocator &Arena,
                                                   IdentifierNode *Identifier) {
   QualifiedNameNode *QN = Arena.alloc<QualifiedNameNode>();
   QN->Components = Arena.alloc<NodeArrayNode>();
   QN->Components->Count = 1;
   QN->Components->Nodes = Arena.allocArray<Node *>(1);
   QN->Components->Nodes[0] = Identifier;
   return QN;
 }
 
 static QualifiedNameNode *synthesizeQualifiedName(ArenaAllocator &Arena,
-                                                  StringView Name) {
+                                                  std::string_view Name) {
   NamedIdentifierNode *Id = synthesizeNamedIdentifier(Arena, Name);
   return synthesizeQualifiedName(Arena, Id);
 }
 
 static VariableSymbolNode *synthesizeVariable(ArenaAllocator &Arena,
                                               TypeNode *Type,
-                                              StringView VariableName) {
+                                              std::string_view VariableName) {
   VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>();
   VSN->Type = Type;
   VSN->Name = synthesizeQualifiedName(Arena, VariableName);
   return VSN;
 }
 
-VariableSymbolNode *Demangler::demangleUntypedVariable(
-    ArenaAllocator &Arena, StringView &MangledName, StringView VariableName) {
+VariableSymbolNode *
+Demangler::demangleUntypedVariable(ArenaAllocator &Arena,
+                                   std::string_view &MangledName,
+                                   std::string_view VariableName) {
   NamedIdentifierNode *NI = synthesizeNamedIdentifier(Arena, VariableName);
   QualifiedNameNode *QN = demangleNameScopeChain(MangledName, NI);
   VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>();
   VSN->Name = QN;
   if (consumeFront(MangledName, "8"))
     return VSN;
 
   Error = true;
   return nullptr;
 }
 
 VariableSymbolNode *
 Demangler::demangleRttiBaseClassDescriptorNode(ArenaAllocator &Arena,
-                                               StringView &MangledName) {
+                                               std::string_view &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);
   consumeFront(MangledName, '8');
   return VSN;
 }
 
-FunctionSymbolNode *Demangler::demangleInitFiniStub(StringView &MangledName,
-                                                    bool IsDestructor) {
+FunctionSymbolNode *
+Demangler::demangleInitFiniStub(std::string_view &MangledName,
   DynamicStructorIdentifierNode *DSIN =
       Arena.alloc<DynamicStructorIdentifierNode>();
   DSIN->IsDestructor = IsDestructor;
 
   bool IsKnownStaticDataMember = false;
   if (consumeFront(MangledName, '?'))
     IsKnownStaticDataMember = true;
 
if (Symbol->kind() == NodeKind::VariableSymbol) {
     FSN = static_cast<FunctionSymbolNode *>(Symbol);
     DSIN->Name = Symbol->Name;
     FSN->Name = synthesizeQualifiedName(Arena, DSIN);
   }
 
   return FSN;
 }
 
-SymbolNode *Demangler::demangleSpecialIntrinsic(StringView &MangledName) {
+SymbolNode *Demangler::demangleSpecialIntrinsic(std::string_view &MangledName) {
   SpecialIntrinsicKind SIK = consumeSpecialIntrinsicKind(MangledName);
 
   switch (SIK) {
   case SpecialIntrinsicKind::None:
     return nullptr;
   case SpecialIntrinsicKind::StringLiteralSymbol:
     return demangleStringLiteral(MangledName);
   case SpecialIntrinsicKind::Vftable:
SymbolNode *Demangler::demangleSpecialIntrinsic(std::string_view &MangledName) {
   case SpecialIntrinsicKind::Unknown:
     DEMANGLE_UNREACHABLE; // Never returned by consumeSpecialIntrinsicKind.
   }
   Error = true;
   return nullptr;
 }
 
 IdentifierNode *
-Demangler::demangleFunctionIdentifierCode(StringView &MangledName) {
-  assert(MangledName.startsWith('?'));
+Demangler::demangleFunctionIdentifierCode(std::string_view &MangledName) {
+  assert(llvm::itanium_demangle::starts_with(MangledName, '?'));
   MangledName.remove_prefix(1);
   if (MangledName.empty()) {
     Error = true;
     return nullptr;
   }
 
   if (consumeFront(MangledName, "__"))
     return demangleFunctionIdentifierCode(
         MangledName, FunctionIdentifierCodeGroup::DoubleUnder);
   if (consumeFront(MangledName, "_"))
     return demangleFunctionIdentifierCode(MangledName,
                                           FunctionIdentifierCodeGroup::Under);
   return demangleFunctionIdentifierCode(MangledName,
                                         FunctionIdentifierCodeGroup::Basic);
 }
 
 StructorIdentifierNode *
-Demangler::demangleStructorIdentifier(StringView &MangledName,
+Demangler::demangleStructorIdentifier(std::string_view &MangledName,
                                       bool IsDestructor) {
   StructorIdentifierNode *N = Arena.alloc<StructorIdentifierNode>();
   N->IsDestructor = IsDestructor;
   return N;
 }
 
 ConversionOperatorIdentifierNode *
-Demangler::demangleConversionOperatorIdentifier(StringView &MangledName) {
+Demangler::demangleConversionOperatorIdentifier(std::string_view &MangledName) {
   ConversionOperatorIdentifierNode *N =
       Arena.alloc<ConversionOperatorIdentifierNode>();
   return N;
 }
 
 LiteralOperatorIdentifierNode *
-Demangler::demangleLiteralOperatorIdentifier(StringView &MangledName) {
+Demangler::demangleLiteralOperatorIdentifier(std::string_view &MangledName) {
   LiteralOperatorIdentifierNode *N =
       Arena.alloc<LiteralOperatorIdentifierNode>();
   N->Name = demangleSimpleString(MangledName, /*Memorize=*/false);
   return N;
 }
 
 IntrinsicFunctionKind
 Demangler::translateIntrinsicFunctionCode(char CH,
case FunctionIdentifierCodeGroup::Under:
     return Under[Index];
   case FunctionIdentifierCodeGroup::DoubleUnder:
     return DoubleUnder[Index];
   }
   DEMANGLE_UNREACHABLE;
 }
 
 IdentifierNode *
-Demangler::demangleFunctionIdentifierCode(StringView &MangledName,
+Demangler::demangleFunctionIdentifierCode(std::string_view &MangledName,
                                           FunctionIdentifierCodeGroup Group) {
   if (MangledName.empty()) {
     Error = true;
     return nullptr;
   }
   const char CH = MangledName.front();
   switch (Group) {
   case FunctionIdentifierCodeGroup::Basic:
default:
       return Arena.alloc<IntrinsicFunctionIdentifierNode>(
           translateIntrinsicFunctionCode(CH, Group));
     }
   }
 
   DEMANGLE_UNREACHABLE;
 }
 
-SymbolNode *Demangler::demangleEncodedSymbol(StringView &MangledName,
+SymbolNode *Demangler::demangleEncodedSymbol(std::string_view &MangledName,
                                              QualifiedNameNode *Name) {
   if (MangledName.empty()) {
     Error = true;
     return nullptr;
   }
 
   // Read a variable.
   switch (MangledName.front()) {
if (UQN->kind() == NodeKind::ConversionOperatorIdentifier) {
     ConversionOperatorIdentifierNode *COIN =
         static_cast<ConversionOperatorIdentifierNode *>(UQN);
     if (FSN)
       COIN->TargetType = FSN->Signature->ReturnType;
   }
   return FSN;
 }
 
-SymbolNode *Demangler::demangleDeclarator(StringView &MangledName) {
+SymbolNode *Demangler::demangleDeclarator(std::string_view &MangledName) {
   // What follows is a main symbol name. This may include namespaces or class
   // back references.
   QualifiedNameNode *QN = demangleFullyQualifiedSymbolName(MangledName);
   if (Error)
     return nullptr;
 
   SymbolNode *Symbol = demangleEncodedSymbol(MangledName, QN);
   if (Error)
     return nullptr;
   Symbol->Name = QN;
 
   IdentifierNode *UQN = QN->getUnqualifiedIdentifier();
   if (UQN->kind() == NodeKind::ConversionOperatorIdentifier) {
     ConversionOperatorIdentifierNode *COIN =
         static_cast<ConversionOperatorIdentifierNode *>(UQN);
     if (!COIN->TargetType) {
       Error = true;
       return nullptr;
     }
   }
   return Symbol;
 }
 
-SymbolNode *Demangler::demangleMD5Name(StringView &MangledName) {
-  assert(MangledName.startsWith("??@"));
+SymbolNode *Demangler::demangleMD5Name(std::string_view &MangledName) {
+  assert(llvm::itanium_demangle::starts_with(MangledName, "??@"));
   // This is an MD5 mangled name.  We can't demangle it, just return the
   // mangled name.
   // An MD5 mangled name is ??@ followed by 32 characters and a terminating @.
   size_t MD5Last = MangledName.find('@', strlen("??@"));
-  if (MD5Last == StringView::npos) {
+  if (MD5Last == std::string_view::npos) {
     Error = true;
     return nullptr;
   }
-  const char *Start = MangledName.begin();
+  const char *Start = &*MangledName.begin();
   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
   //    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.
   consumeFront(MangledName, "??_R4@");
 
-  StringView MD5(Start, MangledName.begin() - Start);
+  std::string_view 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('.'));
+SymbolNode *Demangler::demangleTypeinfoName(std::string_view &MangledName) {
+  assert(llvm::itanium_demangle::starts_with(MangledName, '.'));
   consumeFront(MangledName, '.');
 
   TypeNode *T = demangleType(MangledName, QualifierMangleMode::Result);
   if (Error || !MangledName.empty()) {
     Error = true;
     return nullptr;
   }
   return synthesizeVariable(Arena, T, "`RTTI Type Descriptor Name'");
 }
 
 // Parser entry point.
-SymbolNode *Demangler::parse(StringView &MangledName) {
+SymbolNode *Demangler::parse(std::string_view &MangledName) {
   // Typeinfo names are strings stored in RTTI data. They're not symbol names.
   // It's still useful to demangle them. They're the only demangled entity
   // that doesn't start with a "?" but a ".".
-  if (MangledName.startsWith('.'))
+  if (llvm::itanium_demangle::starts_with(MangledName, '.'))
     return demangleTypeinfoName(MangledName);
 
-  if (MangledName.startsWith("??@"))
+  if (llvm::itanium_demangle::starts_with(MangledName, "??@"))
     return demangleMD5Name(MangledName);
 
   // MSVC-style mangled symbols must start with '?'.
-  if (!MangledName.startsWith('?')) {
+  if (!llvm::itanium_demangle::starts_with(MangledName, '?')) {
     Error = true;
     return nullptr;
   }
 
   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) {
+TagTypeNode *Demangler::parseTagUniqueName(std::string_view &MangledName) {
   if (!consumeFront(MangledName, ".?A")) {
     Error = true;
     return nullptr;
   }
   consumeFront(MangledName, ".?A");
   if (MangledName.empty()) {
     Error = true;
     return nullptr;
   }
 
   return demangleClassType(MangledName);
 }
 
 // <type-encoding> ::= <storage-class> <variable-type>
 // <storage-class> ::= 0  # private static member
 //                 ::= 1  # protected static member
 //                 ::= 2  # public static member
 //                 ::= 3  # global
 //                 ::= 4  # static local
 
-VariableSymbolNode *Demangler::demangleVariableEncoding(StringView &MangledName,
-                                                        StorageClass SC) {
+VariableSymbolNode *
+Demangler::demangleVariableEncoding(std::string_view &MangledName,
   VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>();
 
   VSN->Type = demangleType(MangledName, QualifierMangleMode::Drop);
   VSN->SC = SC;
 
   if (Error)
     return nullptr;
 

 // This function parses it.
 //
 // <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) {
+std::pair<uint64_t, bool>
+Demangler::demangleNumber(std::string_view &MangledName) {
   bool IsNegative = consumeFront(MangledName, '?');
 
   if (startsWithDigit(MangledName)) {
     uint64_t Ret = MangledName[0] - '0' + 1;
     MangledName.remove_prefix(1);
     return {Ret, IsNegative};
   }
 
for (size_t i = 0; i < MangledName.size(); ++i) {
     }
     break;
   }
 
   Error = true;
   return {0ULL, false};
 }
 
-uint64_t Demangler::demangleUnsigned(StringView &MangledName) {
+uint64_t Demangler::demangleUnsigned(std::string_view &MangledName) {
   bool IsNegative = false;
   uint64_t Number = 0;
   std::tie(Number, IsNegative) = demangleNumber(MangledName);
   if (IsNegative)
     Error = true;
   return Number;
 }
 
-int64_t Demangler::demangleSigned(StringView &MangledName) {
+int64_t Demangler::demangleSigned(std::string_view &MangledName) {
   bool IsNegative = false;
   uint64_t Number = 0;
   std::tie(Number, IsNegative) = demangleNumber(MangledName);
   if (Number > INT64_MAX)
     Error = true;
   int64_t I = static_cast<int64_t>(Number);
   return IsNegative ? -I : I;
 }
 
 // First 10 strings can be referenced by special BackReferences ?0, ?1, ..., ?9.
 // Memorize it.
-void Demangler::memorizeString(StringView S) {
+void Demangler::memorizeString(std::string_view S) {
   if (Backrefs.NamesCount >= BackrefContext::Max)
     return;
   for (size_t i = 0; i < Backrefs.NamesCount; ++i)
     if (S == Backrefs.Names[i]->Name)
       return;
   NamedIdentifierNode *N = Arena.alloc<NamedIdentifierNode>();
   N->Name = S;
   Backrefs.Names[Backrefs.NamesCount++] = N;
 }
 
-NamedIdentifierNode *Demangler::demangleBackRefName(StringView &MangledName) {
+NamedIdentifierNode *
+Demangler::demangleBackRefName(std::string_view &MangledName) {
   assert(startsWithDigit(MangledName));
 
   size_t I = MangledName[0] - '0';
   if (I >= Backrefs.NamesCount) {
     Error = true;
     return nullptr;
   }
 
   MangledName.remove_prefix(1);
   return Backrefs.Names[I];
 }
 
 void Demangler::memorizeIdentifier(IdentifierNode *Identifier) {
   // Render this class template name into a string buffer so that we can
   // memorize it for the purpose of back-referencing.
   OutputBuffer OB;
   Identifier->output(OB, OF_Default);
-  StringView Owned = copyString(OB);
+  std::string_view Owned = copyString(OB);
   memorizeString(Owned);
   std::free(OB.getBuffer());
 }
 
 IdentifierNode *
-Demangler::demangleTemplateInstantiationName(StringView &MangledName,
+Demangler::demangleTemplateInstantiationName(std::string_view &MangledName,
                                              NameBackrefBehavior NBB) {
-  assert(MangledName.startsWith("?$"));
+  assert(llvm::itanium_demangle::starts_with(MangledName, "?$"));
   consumeFront(MangledName, "?$");
 
   BackrefContext OuterContext;
   std::swap(OuterContext, Backrefs);
 
   IdentifierNode *Identifier =
       demangleUnqualifiedSymbolName(MangledName, NBB_Simple);
   if (!Error)
if (NBB & NBB_Template) {
     }
 
     memorizeIdentifier(Identifier);
   }
 
   return Identifier;
 }
 
-NamedIdentifierNode *Demangler::demangleSimpleName(StringView &MangledName,
-                                                   bool Memorize) {
-  StringView S = demangleSimpleString(MangledName, Memorize);
+NamedIdentifierNode *
+Demangler::demangleSimpleName(std::string_view &MangledName, bool Memorize) {
+  std::string_view S = demangleSimpleString(MangledName, Memorize);
   if (Error)
     return nullptr;
 
   NamedIdentifierNode *Name = Arena.alloc<NamedIdentifierNode>();
   Name->Name = S;
   return Name;
 }
 
 static bool isRebasedHexDigit(char C) { return (C >= 'A' && C <= 'P'); }
 
 static uint8_t rebasedHexDigitToNumber(char C) {
   assert(isRebasedHexDigit(C));
   return (C <= 'J') ? (C - 'A') : (10 + C - 'K');
 }
 
-uint8_t Demangler::demangleCharLiteral(StringView &MangledName) {
+uint8_t Demangler::demangleCharLiteral(std::string_view &MangledName) {
   assert(!MangledName.empty());
-  if (!MangledName.startsWith('?')) {
+  if (!llvm::itanium_demangle::starts_with(MangledName, '?')) {
     const uint8_t F = MangledName.front();
     MangledName.remove_prefix(1);
     return F;
   }
 
   MangledName.remove_prefix(1);
   if (MangledName.empty())
     goto CharLiteralError;
 
   if (consumeFront(MangledName, '$')) {
     // Two hex digits
     if (MangledName.size() < 2)
       goto CharLiteralError;
-    StringView Nibbles = MangledName.substr(0, 2);
+    std::string_view 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.remove_prefix(2);
     return (C1 << 4) | C2;
   }
if (MangledName[0] >= 'A' && MangledName[0] <= 'Z') {
     return C;
   }
 
 CharLiteralError:
   Error = true;
   return '\0';
 }
 
-wchar_t Demangler::demangleWcharLiteral(StringView &MangledName) {
+wchar_t Demangler::demangleWcharLiteral(std::string_view &MangledName) {
   uint8_t C1, C2;
 
   C1 = demangleCharLiteral(MangledName);
   if (Error || MangledName.empty())
     goto WCharLiteralError;
   C2 = demangleCharLiteral(MangledName);
   if (Error)
     goto WCharLiteralError;
while (C != 0) {
     for (int I = 0; I < 2; ++I) {
       writeHexDigit(&TempBuffer[Pos--], C % 16);
       C /= 16;
     }
   }
   TempBuffer[Pos--] = 'x';
   assert(Pos >= 0);
   TempBuffer[Pos--] = '\\';
-  OB << StringView(&TempBuffer[Pos + 1]);
+  OB << std::string_view(&TempBuffer[Pos + 1]);
 }
 
 static void outputEscapedChar(OutputBuffer &OB, unsigned C) {
   switch (C) {
   case '\0': // nul
     OB << "\\0";
     return;
   case '\'': // single quote
static unsigned decodeMultiByteChar(const uint8_t *StringBytes,
   StringBytes = StringBytes + Offset;
   for (unsigned I = 0; I < CharBytes; ++I) {
     unsigned C = static_cast<unsigned>(StringBytes[I]);
     Result |= C << (8 * I);
   }
   return Result;
 }
 
-FunctionSymbolNode *Demangler::demangleVcallThunkNode(StringView &MangledName) {
+FunctionSymbolNode *
+Demangler::demangleVcallThunkNode(std::string_view &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 = !consumeFront(MangledName, "$B");
   if (!Error)
     VTIN->OffsetInVTable = demangleUnsigned(MangledName);
   if (!Error)
     Error = !consumeFront(MangledName, 'A');
   if (!Error)
     FSN->Signature->CallConvention = demangleCallingConvention(MangledName);
   return (Error) ? nullptr : FSN;
 }
 
 EncodedStringLiteralNode *
-Demangler::demangleStringLiteral(StringView &MangledName) {
+Demangler::demangleStringLiteral(std::string_view &MangledName) {
   // This function uses goto, so declare all variables up front.
   OutputBuffer OB;
-  StringView CRC;
+  std::string_view CRC;
   uint64_t StringByteSize;
   bool IsWcharT = false;
   bool IsNegative = false;
   size_t CrcEndPos = 0;
   char F;
 
   EncodedStringLiteralNode *Result = Arena.alloc<EncodedStringLiteralNode>();
 
Demangler::demangleStringLiteral(std::string_view &MangledName) {
 
   // Encoded Length
   std::tie(StringByteSize, IsNegative) = demangleNumber(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)
+  if (CrcEndPos == std::string_view::npos)
     goto StringLiteralError;
   CRC = MangledName.substr(0, CrcEndPos);
   MangledName.remove_prefix(CrcEndPos + 1);
   if (MangledName.empty())
     goto StringLiteralError;
 
   if (IsWcharT) {
     Result->Char = CharKind::Wchar;

 StringLiteralError:
   Error = true;
   std::free(OB.getBuffer());
   return nullptr;
 }
 
 // Returns MangledName's prefix before the first '@', or an error if
 // MangledName contains no '@' or the prefix has length 0.
-StringView Demangler::demangleSimpleString(StringView &MangledName,
+std::string_view Demangler::demangleSimpleString(std::string_view &MangledName,
                                                  bool Memorize) {
-  StringView S;
+  std::string_view S;
   for (size_t i = 0; i < MangledName.size(); ++i) {
     if (MangledName[i] != '@')
       continue;
     if (i == 0)
       break;
     S = MangledName.substr(0, i);
     MangledName.remove_prefix(i + 1);
 
     if (Memorize)
       memorizeString(S);
     return S;
   }
 
   Error = true;
   return {};
 }
 
 NamedIdentifierNode *
-Demangler::demangleAnonymousNamespaceName(StringView &MangledName) {
-  assert(MangledName.startsWith("?A"));
+Demangler::demangleAnonymousNamespaceName(std::string_view &MangledName) {
+  assert(llvm::itanium_demangle::starts_with(MangledName, "?A"));
   consumeFront(MangledName, "?A");
 
   NamedIdentifierNode *Node = Arena.alloc<NamedIdentifierNode>();
   Node->Name = "`anonymous namespace'";
   size_t EndPos = MangledName.find('@');
-  if (EndPos == StringView::npos) {
+  if (EndPos == std::string_view::npos) {
     Error = true;
     return nullptr;
   }
-  StringView NamespaceKey = MangledName.substr(0, EndPos);
+  std::string_view NamespaceKey = MangledName.substr(0, EndPos);
   memorizeString(NamespaceKey);
   MangledName = MangledName.substr(EndPos + 1);
   return Node;
 }
 
 NamedIdentifierNode *
-Demangler::demangleLocallyScopedNamePiece(StringView &MangledName) {
+Demangler::demangleLocallyScopedNamePiece(std::string_view &MangledName) {
   assert(startsWithLocalScopePattern(MangledName));
 
   NamedIdentifierNode *Identifier = Arena.alloc<NamedIdentifierNode>();
   consumeFront(MangledName, '?');
   uint64_t Number = 0;
   bool IsNegative = false;
   std::tie(Number, IsNegative) = demangleNumber(MangledName);
   assert(!IsNegative);
Demangler::demangleLocallyScopedNamePiece(std::string_view &MangledName) {
 
   Identifier->Name = copyString(OB);
   std::free(OB.getBuffer());
   return Identifier;
 }
 
 // Parses a type name in the form of A@B@C@@ which represents C::B::A.
 QualifiedNameNode *
-Demangler::demangleFullyQualifiedTypeName(StringView &MangledName) {
+Demangler::demangleFullyQualifiedTypeName(std::string_view &MangledName) {
   IdentifierNode *Identifier =
       demangleUnqualifiedTypeName(MangledName, /*Memorize=*/true);
   if (Error)
     return nullptr;
   assert(Identifier);
 
   QualifiedNameNode *QN = demangleNameScopeChain(MangledName, Identifier);
   if (Error)
     return nullptr;
   assert(QN);
   return QN;
 }
 
 // Parses a symbol name in the form of A@B@C@@ which represents C::B::A.
 // Symbol names have slightly different rules regarding what can appear
 // so we separate out the implementations for flexibility.
 QualifiedNameNode *
-Demangler::demangleFullyQualifiedSymbolName(StringView &MangledName) {
+Demangler::demangleFullyQualifiedSymbolName(std::string_view &MangledName) {
   // This is the final component of a symbol name (i.e. the leftmost component
   // of a mangled name.  Since the only possible template instantiation that
   // can appear in this context is a function template, and since those are
   // not saved for the purposes of name backreferences, only backref simple
   // names.
   IdentifierNode *Identifier =
       demangleUnqualifiedSymbolName(MangledName, NBB_Simple);
   if (Error)
StructorIdentifierNode *SIN =
         static_cast<StructorIdentifierNode *>(Identifier);
     Node *ClassNode = QN->Components->Nodes[QN->Components->Count - 2];
     SIN->Class = static_cast<IdentifierNode *>(ClassNode);
   }
   assert(QN);
   return QN;
 }
 
-IdentifierNode *Demangler::demangleUnqualifiedTypeName(StringView &MangledName,
-                                                       bool Memorize) {
+IdentifierNode *
+Demangler::demangleUnqualifiedTypeName(std::string_view &MangledName,
   // An inner-most name can be a back-reference, because a fully-qualified name
   // (e.g. Scope + Inner) can contain other fully qualified names inside of
   // them (for example template parameters), and these nested parameters can
   // refer to previously mangled types.
   if (startsWithDigit(MangledName))
     return demangleBackRefName(MangledName);
 
-  if (MangledName.startsWith("?$"))
+  if (llvm::itanium_demangle::starts_with(MangledName, "?$"))
     return demangleTemplateInstantiationName(MangledName, NBB_Template);
 
   return demangleSimpleName(MangledName, Memorize);
 }
 
 IdentifierNode *
-Demangler::demangleUnqualifiedSymbolName(StringView &MangledName,
+Demangler::demangleUnqualifiedSymbolName(std::string_view &MangledName,
                                          NameBackrefBehavior NBB) {
   if (startsWithDigit(MangledName))
     return demangleBackRefName(MangledName);
-  if (MangledName.startsWith("?$"))
+  if (llvm::itanium_demangle::starts_with(MangledName, "?$"))
     return demangleTemplateInstantiationName(MangledName, NBB);
-  if (MangledName.startsWith('?'))
+  if (llvm::itanium_demangle::starts_with(MangledName, '?'))
     return demangleFunctionIdentifierCode(MangledName);
   return demangleSimpleName(MangledName, /*Memorize=*/(NBB & NBB_Simple) != 0);
 }
 
-IdentifierNode *Demangler::demangleNameScopePiece(StringView &MangledName) {
+IdentifierNode *
+Demangler::demangleNameScopePiece(std::string_view &MangledName) {
   if (startsWithDigit(MangledName))
     return demangleBackRefName(MangledName);
 
-  if (MangledName.startsWith("?$"))
+  if (llvm::itanium_demangle::starts_with(MangledName, "?$"))
     return demangleTemplateInstantiationName(MangledName, NBB_Template);
 
-  if (MangledName.startsWith("?A"))
+  if (llvm::itanium_demangle::starts_with(MangledName, "?A"))
     return demangleAnonymousNamespaceName(MangledName);
 
   if (startsWithLocalScopePattern(MangledName))
     return demangleLocallyScopedNamePiece(MangledName);
 
   return demangleSimpleName(MangledName, /*Memorize=*/true);
 }
 
 static NodeArrayNode *nodeListToNodeArray(ArenaAllocator &Arena, NodeList *Head,
                                           size_t Count) {
   NodeArrayNode *N = Arena.alloc<NodeArrayNode>();
   N->Count = Count;
   N->Nodes = Arena.allocArray<Node *>(Count);
   for (size_t I = 0; I < Count; ++I) {
     N->Nodes[I] = Head->N;
     Head = Head->Next;
   }
   return N;
 }
 
 QualifiedNameNode *
-Demangler::demangleNameScopeChain(StringView &MangledName,
+Demangler::demangleNameScopeChain(std::string_view &MangledName,
                                   IdentifierNode *UnqualifiedName) {
   NodeList *Head = Arena.alloc<NodeList>();
 
   Head->N = UnqualifiedName;
 
   size_t Count = 1;
   while (!consumeFront(MangledName, "@")) {
     ++Count;
while (!consumeFront(MangledName, "@")) {
     Head->N = Elem;
   }
 
   QualifiedNameNode *QN = Arena.alloc<QualifiedNameNode>();
   QN->Components = nodeListToNodeArray(Arena, Head, Count);
   return QN;
 }
 
-FuncClass Demangler::demangleFunctionClass(StringView &MangledName) {
+FuncClass Demangler::demangleFunctionClass(std::string_view &MangledName) {
   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':
case '$': {
     }
   }
   }
 
   Error = true;
   return FC_Public;
 }
 
-CallingConv Demangler::demangleCallingConvention(StringView &MangledName) {
+CallingConv
+Demangler::demangleCallingConvention(std::string_view &MangledName) {
   if (MangledName.empty()) {
     Error = true;
     return CallingConv::None;
   }
 
   const char F = MangledName.front();
   MangledName.remove_prefix(1);
   switch (F) {
case 'S':
     return CallingConv::Swift;
   case 'W':
     return CallingConv::SwiftAsync;
   }
 
   return CallingConv::None;
 }
 
-StorageClass Demangler::demangleVariableStorageClass(StringView &MangledName) {
+StorageClass
+Demangler::demangleVariableStorageClass(std::string_view &MangledName) {
   assert(MangledName.front() >= '0' && MangledName.front() <= '4');
 
   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) {
+Demangler::demangleQualifiers(std::string_view &MangledName) {
   if (MangledName.empty()) {
     Error = true;
     return std::make_pair(Q_None, false);
   }
 
   const char F = MangledName.front();
   MangledName.remove_prefix(1);
   switch (F) {
case 'D':
     return std::make_pair(Qualifiers(Q_Const | Q_Volatile), false);
   }
   Error = true;
   return std::make_pair(Q_None, false);
 }
 
 // <variable-type> ::= <type> <cvr-qualifiers>
 //                 ::= <type> <pointee-cvr-qualifiers> # pointers, references
-TypeNode *Demangler::demangleType(StringView &MangledName,
+TypeNode *Demangler::demangleType(std::string_view &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 (consumeFront(MangledName, '?'))
       std::tie(Quals, IsMember) = demangleQualifiers(MangledName);
else if (isPointerType(MangledName)) {
     else
       return nullptr;
   } else if (isArrayType(MangledName))
     Ty = demangleArrayType(MangledName);
   else if (isFunctionType(MangledName)) {
     if (consumeFront(MangledName, "$$A8@@"))
       Ty = demangleFunctionType(MangledName, true);
     else {
-      assert(MangledName.startsWith("$$A6"));
+      assert(llvm::itanium_demangle::starts_with(MangledName, "$$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) {
+bool Demangler::demangleThrowSpecification(std::string_view &MangledName) {
   if (consumeFront(MangledName, "_E"))
     return true;
   if (consumeFront(MangledName, 'Z'))
     return false;
 
   Error = true;
   return false;
 }
 
-FunctionSignatureNode *Demangler::demangleFunctionType(StringView &MangledName,
-                                                       bool HasThisQuals) {
+FunctionSignatureNode *
+Demangler::demangleFunctionType(std::string_view &MangledName,
   FunctionSignatureNode *FTy = Arena.alloc<FunctionSignatureNode>();
 
   if (HasThisQuals) {
     FTy->Quals = demanglePointerExtQualifiers(MangledName);
     FTy->RefQualifier = demangleFunctionRefQualifier(MangledName);
     FTy->Quals = Qualifiers(FTy->Quals | demangleQualifiers(MangledName).first);
   }
 
Demangler::demangleFunctionType(std::string_view &MangledName,
   FTy->Params = demangleFunctionParameterList(MangledName, FTy->IsVariadic);
 
   FTy->IsNoexcept = demangleThrowSpecification(MangledName);
 
   return FTy;
 }
 
 FunctionSymbolNode *
-Demangler::demangleFunctionEncoding(StringView &MangledName) {
+Demangler::demangleFunctionEncoding(std::string_view &MangledName) {
   FuncClass ExtraFlags = FC_None;
   if (consumeFront(MangledName, "$$J0"))
     ExtraFlags = FC_ExternC;
 
   if (MangledName.empty()) {
     Error = true;
     return nullptr;
   }
Demangler::demangleFunctionEncoding(std::string_view &MangledName) {
   }
   FSN->FunctionClass = FC;
 
   FunctionSymbolNode *Symbol = Arena.alloc<FunctionSymbolNode>();
   Symbol->Signature = FSN;
   return Symbol;
 }
 
-CustomTypeNode *Demangler::demangleCustomType(StringView &MangledName) {
-  assert(MangledName.startsWith('?'));
+CustomTypeNode *Demangler::demangleCustomType(std::string_view &MangledName) {
+  assert(llvm::itanium_demangle::starts_with(MangledName, '?'));
   MangledName.remove_prefix(1);
 
   CustomTypeNode *CTN = Arena.alloc<CustomTypeNode>();
   CTN->Identifier = demangleUnqualifiedTypeName(MangledName, /*Memorize=*/true);
   if (!consumeFront(MangledName, '@'))
     Error = true;
   if (Error)
     return nullptr;
   return CTN;
 }
 
 // Reads a primitive type.
-PrimitiveTypeNode *Demangler::demanglePrimitiveType(StringView &MangledName) {
+PrimitiveTypeNode *
+Demangler::demanglePrimitiveType(std::string_view &MangledName) {
   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 '_': {
     }
     break;
   }
   }
   Error = true;
   return nullptr;
 }
 
-TagTypeNode *Demangler::demangleClassType(StringView &MangledName) {
+TagTypeNode *Demangler::demangleClassType(std::string_view &MangledName) {
   TagTypeNode *TT = nullptr;
 
   const char F = MangledName.front();
   MangledName.remove_prefix(1);
   switch (F) {
   case 'T':
     TT = Arena.alloc<TagTypeNode>(TagKind::Union);
     break;
TagTypeNode *Demangler::demangleClassType(std::string_view &MangledName) {
   }
 
   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 *Demangler::demanglePointerType(std::string_view &MangledName) {
   PointerTypeNode *Pointer = Arena.alloc<PointerTypeNode>();
 
   std::tie(Pointer->Quals, Pointer->Affinity) =
       demanglePointerCVQualifiers(MangledName);
 
   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 *
+Demangler::demangleMemberPointerType(std::string_view &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);
if (consumeFront(MangledName, "8")) {
     Pointer->Pointee = demangleType(MangledName, QualifierMangleMode::Drop);
     if (Pointer->Pointee)
       Pointer->Pointee->Quals = PointeeQuals;
   }
 
   return Pointer;
 }
 
-Qualifiers Demangler::demanglePointerExtQualifiers(StringView &MangledName) {
+Qualifiers
+Demangler::demanglePointerExtQualifiers(std::string_view &MangledName) {
   Qualifiers Quals = Q_None;
   if (consumeFront(MangledName, 'E'))
     Quals = Qualifiers(Quals | Q_Pointer64);
   if (consumeFront(MangledName, 'I'))
     Quals = Qualifiers(Quals | Q_Restrict);
   if (consumeFront(MangledName, 'F'))
     Quals = Qualifiers(Quals | Q_Unaligned);
 
   return Quals;
 }
 
-ArrayTypeNode *Demangler::demangleArrayType(StringView &MangledName) {
+ArrayTypeNode *Demangler::demangleArrayType(std::string_view &MangledName) {
   assert(MangledName.front() == 'Y');
   MangledName.remove_prefix(1);
 
   uint64_t Rank = 0;
   bool IsNegative = false;
   std::tie(Rank, IsNegative) = demangleNumber(MangledName);
   if (IsNegative || Rank == 0) {
     Error = true;
if (consumeFront(MangledName, "$$C")) {
     }
   }
 
   ATy->ElementType = demangleType(MangledName, QualifierMangleMode::Drop);
   return ATy;
 }
 
 // Reads a function's parameters.
-NodeArrayNode *Demangler::demangleFunctionParameterList(StringView &MangledName,
-                                                        bool &IsVariadic) {
+NodeArrayNode *
+Demangler::demangleFunctionParameterList(std::string_view &MangledName,
   // Empty parameter list.
   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')) {
+  while (!Error && !llvm::itanium_demangle::starts_with(MangledName, '@') &&
+         !llvm::itanium_demangle::starts_with(MangledName, 'Z')) {
     ++Count;
 
     if (startsWithDigit(MangledName)) {
       size_t N = MangledName[0] - '0';
       if (N >= Backrefs.FunctionParamCount) {
         Error = true;
         return nullptr;
       }
if (consumeFront(MangledName, 'Z')) {
     IsVariadic = true;
     return NA;
   }
 
   DEMANGLE_UNREACHABLE;
 }
 
 NodeArrayNode *
-Demangler::demangleTemplateParameterList(StringView &MangledName) {
+Demangler::demangleTemplateParameterList(std::string_view &MangledName) {
   NodeList *Head = nullptr;
   NodeList **Current = &Head;
   size_t Count = 0;
 
-  while (!MangledName.startsWith('@')) {
+  while (!llvm::itanium_demangle::starts_with(MangledName, '@')) {
     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 (consumeFront(MangledName, "$$Y")) {
       // Template alias
       TP.N = demangleFullyQualifiedTypeName(MangledName);
     } else if (consumeFront(MangledName, "$$B")) {
       // Array
       TP.N = demangleType(MangledName, QualifierMangleMode::Drop);
     } 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")) {
+    } else if (llvm::itanium_demangle::starts_with(MangledName, "$1") ||
+               llvm::itanium_demangle::starts_with(MangledName, "$H") ||
+               llvm::itanium_demangle::starts_with(MangledName, "$I") ||
+               llvm::itanium_demangle::starts_with(MangledName, "$J")) {
       // Pointer to member
       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.front();
       MangledName.remove_prefix(1);
       SymbolNode *S = nullptr;
-      if (MangledName.startsWith('?')) {
+      if (llvm::itanium_demangle::starts_with(MangledName, '?')) {
         S = parse(MangledName);
         if (Error || !S->Name) {
           Error = true;
           return nullptr;
         }
         memorizeIdentifier(S->Name->getUnqualifiedIdentifier());
       }
 
if (consumeFront(MangledName, "$$Y")) {
         DEMANGLE_FALLTHROUGH;
       case '1':
         break;
       default:
         DEMANGLE_UNREACHABLE;
       }
       TPRN->Affinity = PointerAffinity::Pointer;
       TPRN->Symbol = S;
-    } else if (MangledName.startsWith("$E?")) {
+    } else if (llvm::itanium_demangle::starts_with(MangledName, "$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")) {
+    } else if (llvm::itanium_demangle::starts_with(MangledName, "$F") ||
+               llvm::itanium_demangle::starts_with(MangledName, "$G")) {
       TP.N = TPRN = Arena.alloc<TemplateParameterReferenceNode>();
 
       // Data member pointer.
       MangledName.remove_prefix(1);
       char InheritanceSpecifier = MangledName.front();
       MangledName.remove_prefix(1);
 
       switch (InheritanceSpecifier) {
while (!llvm::itanium_demangle::starts_with(MangledName, '@')) {
     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 '@'.
+  assert(llvm::itanium_demangle::starts_with(
+      MangledName, '@')); // The above loop exits only on '@'.
   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.
   OutputBuffer OB;
   for (size_t I = 0; I < Backrefs.FunctionParamCount; ++I) {
     OB.setCurrentPosition(0);
 
     TypeNode *T = Backrefs.FunctionParams[I];
     T->output(OB, OF_Default);
 
-    StringView B = OB;
-    std::printf("  [%d] - %.*s\n", (int)I, (int)B.size(), B.begin());
+    std::string_view B = OB;
+    std::printf("  [%d] - %.*s\n", (int)I, (int)B.size(), &*B.begin());
   }
   std::free(OB.getBuffer());
 
   if (Backrefs.FunctionParamCount > 0)
     std::printf("\n");
   std::printf("%d name backreferences\n", (int)Backrefs.NamesCount);
   for (size_t I = 0; I < Backrefs.NamesCount; ++I) {
     std::printf("  [%d] - %.*s\n", (int)I, (int)Backrefs.Names[I]->Name.size(),
-                Backrefs.Names[I]->Name.begin());
+                &*Backrefs.Names[I]->Name.begin());
   }
   if (Backrefs.NamesCount > 0)
     std::printf("\n");
 }
 
 char *llvm::microsoftDemangle(const char *MangledName, size_t *NMangled,
                               char *Buf, size_t *N,
                               int *Status, MSDemangleFlags Flags) {
   Demangler D;
 
-  StringView Name{MangledName};
+  std::string_view Name{MangledName};
   SymbolNode *AST = D.parse(Name);
   if (!D.Error && NMangled)
-    *NMangled = Name.begin() - MangledName;
+    *NMangled = &*Name.begin() - MangledName;
 
   if (Flags & MSDF_DumpBackrefs)
     D.dumpBackReferences();
 
   OutputFlags OF = OF_Default;
   if (Flags & MSDF_NoCallingConvention)
     OF = OutputFlags(OF | OF_NoCallingConvention);
   if (Flags & MSDF_NoAccessSpecifier)

llvm/lib/Demangle/MicrosoftDemangleNodes.cpp

static void outputCallingConvention(OutputBuffer &OB, CallingConv CC) {
   default:
     break;
   }
 }
 
 std::string Node::toString(OutputFlags Flags) const {
   OutputBuffer OB;
   this->output(OB, Flags);
-  StringView SV = OB;
+  std::string_view SV = OB;
   std::string Owned(SV.begin(), SV.end());
   std::free(OB.getBuffer());
   return Owned;
 }
 
 void PrimitiveTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
   switch (PrimKind) {
     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Void, "void");
void PrimitiveTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
   outputQualifiers(OB, Quals, true, false);
 }
 
 void NodeArrayNode::output(OutputBuffer &OB, OutputFlags Flags) const {
   output(OB, Flags, ", ");
 }
 
 void NodeArrayNode::output(OutputBuffer &OB, OutputFlags Flags,
-                           StringView Separator) const {
+                           std::string_view Separator) const {
   if (Count == 0)
     return;
   if (Nodes[0])
     Nodes[0]->output(OB, Flags);
   for (size_t I = 1; I < Count; ++I) {
     OB << Separator;
     Nodes[I]->output(OB, Flags);
   }

llvm/lib/Demangle/RustDemangle.cpp

 //===--- RustDemangle.cpp ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a demangler for Rust v0 mangled symbols as specified in
 // https://rust-lang.github.io/rfcs/2603-rust-symbol-name-mangling-v0.html
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Demangle/Demangle.h"
-#include "llvm/Demangle/StringView.h"
+#include "llvm/Demangle/StringViewExtras.h"
 #include "llvm/Demangle/Utility.h"
 
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <cstring>
 #include <limits>
 
 using namespace llvm;
 
 using llvm::itanium_demangle::OutputBuffer;
 using llvm::itanium_demangle::ScopedOverride;
-using llvm::itanium_demangle::StringView;
 
 namespace {
 
 struct Identifier {
-  StringView Name;
+  std::string_view Name;
   bool Punycode;
 
   bool empty() const { return Name.empty(); }
 };
 
 enum class BasicType {
   Bool,
   Char,

 
 class Demangler {
   // Maximum recursion level. Used to avoid stack overflow.
   size_t MaxRecursionLevel;
   // Current recursion level.
   size_t RecursionLevel;
   size_t BoundLifetimes;
   // Input string that is being demangled with "_R" prefix removed.
-  StringView Input;
+  std::string_view Input;
   // Position in the input string.
   size_t Position;
   // When true, print methods append the output to the stream.
   // When false, the output is suppressed.
   bool Print;
   // True if an error occurred.
   bool Error;
 
 public:
   // Demangled output.
   OutputBuffer Output;
 
   Demangler(size_t MaxRecursionLevel = 500);
 
-  bool demangle(StringView MangledName);
+  bool demangle(std::string_view MangledName);
 
 private:
   bool demanglePath(IsInType Type,
                     LeaveGenericsOpen LeaveOpen = LeaveGenericsOpen::No);
   void demangleImplPath(IsInType InType);
   void demangleGenericArg();
   void demangleType();
   void demangleFnSig();
template <typename Callable> void demangleBackref(Callable Demangler) {
     Position = Backref;
     Demangler();
   }
 
   Identifier parseIdentifier();
   uint64_t parseOptionalBase62Number(char Tag);
   uint64_t parseBase62Number();
   uint64_t parseDecimalNumber();
-  uint64_t parseHexNumber(StringView &HexDigits);
+  uint64_t parseHexNumber(std::string_view &HexDigits);
 
   void print(char C);
-  void print(StringView S);
+  void print(std::string_view S);
   void printDecimalNumber(uint64_t N);
   void printBasicType(BasicType);
   void printLifetime(uint64_t Index);
   void printIdentifier(Identifier Ident);
 
   char look() const;
   char consume();
   bool consumeIf(char Prefix);
 
   bool addAssign(uint64_t &A, uint64_t B);
   bool mulAssign(uint64_t &A, uint64_t B);
 };
 
 } // namespace
 
 char *llvm::rustDemangle(const char *MangledName) {
   if (MangledName == nullptr)
     return nullptr;
 
   // Return early if mangled name doesn't look like a Rust symbol.
-  StringView Mangled(MangledName);
-  if (!Mangled.startsWith("_R"))
+  std::string_view Mangled(MangledName);
+  if (!llvm::itanium_demangle::starts_with(Mangled, "_R"))
     return nullptr;
 
   Demangler D;
   if (!D.demangle(Mangled)) {
     std::free(D.Output.getBuffer());
     return nullptr;
   }
 
static inline bool isValid(const char C) {
   return isDigit(C) || isLower(C) || isUpper(C) || C == '_';
 }
 
 // Demangles Rust v0 mangled symbol. Returns true when successful, and false
 // otherwise. The demangled symbol is stored in Output field. It is
 // responsibility of the caller to free the memory behind the output stream.
 //
 // <symbol-name> = "_R" <path> [<instantiating-crate>]
-bool Demangler::demangle(StringView Mangled) {
+bool Demangler::demangle(std::string_view Mangled) {
   Position = 0;
   Error = false;
   Print = true;
   RecursionLevel = 0;
   BoundLifetimes = 0;
 
-  if (!Mangled.startsWith("_R")) {
+  if (!llvm::itanium_demangle::starts_with(Mangled, "_R")) {
     Error = true;
     return false;
   }
   Mangled.remove_prefix(2);
   size_t Dot = Mangled.find('.');
-  Input = Dot == StringView::npos ? Mangled : Mangled.substr(0, Dot);
+  Input = Dot == std::string_view::npos ? Mangled : Mangled.substr(0, Dot);
 
   demanglePath(IsInType::No);
 
   if (Position != Input.size()) {
     ScopedOverride<bool> SavePrint(Print, false);
     demanglePath(IsInType::No);
   }
 
   if (Position != Input.size())
     Error = true;
 
-  if (Dot != StringView::npos) {
+  if (Dot != std::string_view::npos) {
     print(" (");
     print(Mangled.substr(Dot));
     print(")");
   }
 
   return !Error;
 }
 
void Demangler::demangleConst() {
   }
 }
 
 // <const-data> = ["n"] <hex-number>
 void Demangler::demangleConstInt() {
   if (consumeIf('n'))
     print('-');
 
-  StringView HexDigits;
+  std::string_view HexDigits;
   uint64_t Value = parseHexNumber(HexDigits);
   if (HexDigits.size() <= 16) {
     printDecimalNumber(Value);
   } else {
     print("0x");
     print(HexDigits);
   }
 }
 
 // <const-data> = "0_" // false
 //              | "1_" // true
 void Demangler::demangleConstBool() {
-  StringView HexDigits;
+  std::string_view HexDigits;
   parseHexNumber(HexDigits);
   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;
+  std::string_view HexDigits;
   uint64_t CodePoint = parseHexNumber(HexDigits);
   if (Error || HexDigits.size() > 6) {
     Error = true;
     return;
   }
 
   print("'");
   switch (CodePoint) {
Identifier Demangler::parseIdentifier() {
   // Underscore resolves the ambiguity when identifier starts with a decimal
   // digit or another underscore.
   consumeIf('_');
 
   if (Error || Bytes > Input.size() - Position) {
     Error = true;
     return {};
   }
-  StringView S = Input.substr(Position, Bytes);
+  std::string_view S = Input.substr(Position, Bytes);
   Position += Bytes;
 
   if (!std::all_of(S.begin(), S.end(), isValid)) {
     Error = true;
     return {};
   }
 
   return {S, Punycode};

 }
 
 // Parses a hexadecimal number with <0-9a-f> as a digits. Returns the parsed
 // value and stores hex digits in HexDigits. The return value is unspecified if
 // HexDigits.size() > 16.
 //
 // <hex-number> = "0_"
 //              | <1-9a-f> {<0-9a-f>} "_"
-uint64_t Demangler::parseHexNumber(StringView &HexDigits) {
+uint64_t Demangler::parseHexNumber(std::string_view &HexDigits) {
   size_t Start = Position;
   uint64_t Value = 0;
 
   if (!isHexDigit(look()))
     Error = true;
 
   if (consumeIf('0')) {
     if (!consumeIf('_'))
       Error = true;
   } else {
     while (!Error && !consumeIf('_')) {
       char C = consume();
       Value *= 16;
       if (isDigit(C))
         Value += C - '0';
       else if ('a' <= C && C <= 'f')
         Value += 10 + (C - 'a');
       else
         Error = true;
     }
   }
 
   if (Error) {
-    HexDigits = StringView();
+    HexDigits = std::string_view();
     return 0;
   }
 
   size_t End = Position - 1;
   assert(Start < End);
   HexDigits = Input.substr(Start, End - Start);
   return Value;
 }
 
 void Demangler::print(char C) {
   if (Error || !Print)
     return;
 
   Output += C;
 }
 
-void Demangler::print(StringView S) {
+void Demangler::print(std::string_view S) {
   if (Error || !Print)
     return;
 
   Output += S;
 }
 
 void Demangler::printDecimalNumber(uint64_t N) {
   if (Error || !Print)
if (CodePoint <= 0x10FFFF) {
     return true;
   }
 
   return false;
 }
 
 // Decodes string encoded using punycode and appends results to Output.
 // Returns true if decoding was successful.
-static bool decodePunycode(StringView Input, OutputBuffer &Output) {
+static bool decodePunycode(std::string_view Input, OutputBuffer &Output) {
   size_t OutputSize = Output.getCurrentPosition();
   size_t InputIdx = 0;
 
   // Rust uses an underscore as a delimiter.
-  size_t DelimiterPos = StringView::npos;
+  size_t DelimiterPos = std::string_view::npos;
   for (size_t I = 0; I != Input.size(); ++I)
     if (Input[I] == '_')
       DelimiterPos = I;
 
-  if (DelimiterPos != StringView::npos) {
+  if (DelimiterPos != std::string_view::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, 4);
+      Output += std::string_view(UTF8, 4);
     }
     // Skip over the delimiter.
     ++InputIdx;
   }
 
   size_t Base = 36;
   size_t Skew = 38;
   size_t Bias = 72;

llvm/lib/ProfileData/ItaniumManglingCanonicalizer.cpp

 #include "llvm/ADT/StringRef.h"
 #include "llvm/Demangle/ItaniumDemangle.h"
 #include "llvm/Support/Allocator.h"
 
 using namespace llvm;
 using llvm::itanium_demangle::ForwardTemplateReference;
 using llvm::itanium_demangle::Node;
 using llvm::itanium_demangle::NodeKind;
-using llvm::itanium_demangle::StringView;
 
 namespace {
 struct FoldingSetNodeIDBuilder {
   llvm::FoldingSetNodeID &ID;
   void operator()(const Node *P) { ID.AddPointer(P); }
-  void operator()(StringView Str) {
-    ID.AddString(llvm::StringRef(Str.begin(), Str.size()));
+  void operator()(std::string_view Str) {
+    ID.AddString(llvm::StringRef(&*Str.begin(), Str.size()));
   }
   template <typename T>
   std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>> operator()(T V) {
     ID.AddInteger((unsigned long long)V);
   }
   void operator()(itanium_demangle::NodeArray A) {
     ID.AddInteger(A.size());
     for (const Node *N : A)
parseMaybeMangledName(CanonicalizingDemangler &Demangler, StringRef Mangling,
   //   encoding 6memcpy 7memmove
   // consistent with how they are encoded as local-names inside a C++ mangling.
   Node *N;
   if (Mangling.startswith("_Z") || Mangling.startswith("__Z") ||
       Mangling.startswith("___Z") || Mangling.startswith("____Z"))
     N = Demangler.parse();
   else
     N = Demangler.make<itanium_demangle::NameType>(
-        StringView(Mangling.data(), Mangling.size()));
+        std::string_view(Mangling.data(), Mangling.size()));
   return reinterpret_cast<ItaniumManglingCanonicalizer::Key>(N);
 }
 
 ItaniumManglingCanonicalizer::Key
 ItaniumManglingCanonicalizer::canonicalize(StringRef Mangling) {
   return parseMaybeMangledName(P->Demangler, Mangling, true);
 }
 
 ItaniumManglingCanonicalizer::Key
 ItaniumManglingCanonicalizer::lookup(StringRef Mangling) {
   return parseMaybeMangledName(P->Demangler, Mangling, false);
 }

llvm/unittests/Demangle/ItaniumDemangleTest.cpp

 //===------------------ ItaniumDemangleTest.cpp ---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Demangle/ItaniumDemangle.h"
 #include "llvm/Support/Allocator.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cstdlib>
+#include <string_view>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::itanium_demangle;
 
 namespace {
 class TestAllocator {
   BumpPtrAllocator Alloc;
TEST(ItaniumDemangle, MethodOverride) {
   };
 
   TestParser Parser("_Z1fIiEjl");
   ASSERT_NE(nullptr, Parser.parse());
   EXPECT_THAT(Parser.Types, testing::ElementsAre('i', 'j', 'l'));
 }
 
 static std::string toString(OutputBuffer &OB) {
-  StringView SV = OB;
+  std::string_view SV = OB;
   return {SV.begin(), SV.end()};
 }
 
 TEST(ItaniumDemangle, HalfType) {
   struct TestParser : AbstractManglingParser<TestParser, TestAllocator> {
     std::vector<std::string> Types;
 
     TestParser(const char *Str)
         : AbstractManglingParser(Str, Str + strlen(Str)) {}
 
     Node *parseType() {
       OutputBuffer OB;
       Node *N = AbstractManglingParser<TestParser, TestAllocator>::parseType();
       N->printLeft(OB);
-      StringView Name = N->getBaseName();
+      std::string_view Name = N->getBaseName();
       if (!Name.empty())
         Types.push_back(std::string(Name.begin(), Name.end()));
       else
         Types.push_back(toString(OB));
       std::free(OB.getBuffer());
       return N;
     }
   };
 
   // void f(A<_Float16>, _Float16);
   TestParser Parser("_Z1f1AIDF16_EDF16_");
   ASSERT_NE(nullptr, Parser.parse());
   EXPECT_THAT(Parser.Types, testing::ElementsAre("_Float16", "A", "_Float16"));
 }

llvm/unittests/Demangle/OutputBufferTest.cpp

 //===- llvm/unittest/OutputBufferTest.cpp - OutputStream unit tests -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Demangle/MicrosoftDemangleNodes.h"
 #include "llvm/Demangle/Utility.h"
 #include "gtest/gtest.h"
 #include <string>
+#include <string_view>
 
 using namespace llvm;
 using llvm::itanium_demangle::OutputBuffer;
 
 static std::string toString(OutputBuffer &OB) {
-  StringView SV = OB;
+  std::string_view SV = OB;
   return {SV.begin(), SV.end()};
 }
 
 template <typename T> static std::string printToString(const T &Value) {
   OutputBuffer OB;
   OB << Value;
   std::string s = toString(OB);
   std::free(OB.getBuffer());