kill demangle

9 files changed, 0 insertions, 7595 deletions

diff --git a/demangle/third_party/llvm/include/llvm/Demangle/Compiler.h b/demangle/third_party/llvm/include/llvm/Demangle/Compiler.h
deleted file mode 100644
index c17ff4ca..00000000
--- a/demangle/third_party/llvm/include/llvm/Demangle/Compiler.h
+++ /dev/null
@@ -1,549 +0,0 @@
-//===--- Compiler.h ---------------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//
-// This file contains a variety of feature test macros copied from
-// include/llvm/Support/Compiler.h so that LLVMDemangle does not need to take
-// a dependency on LLVMSupport.
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_DEMANGLE_COMPILER_H
-#define LLVM_DEMANGLE_COMPILER_H
-
-#ifdef __cplusplus
-#include <new>
-#endif
-#include <stddef.h>
-
-#if defined(_MSC_VER)
-#include <sal.h>
-#endif
-
-#ifndef __has_feature
-# define __has_feature(x) 0
-#endif
-
-#ifndef __has_extension
-# define __has_extension(x) 0
-#endif
-
-#ifndef __has_attribute
-# define __has_attribute(x) 0
-#endif
-
-#ifndef __has_builtin
-# define __has_builtin(x) 0
-#endif
-
-// Only use __has_cpp_attribute in C++ mode. GCC defines __has_cpp_attribute in
-// C mode, but the :: in __has_cpp_attribute(scoped::attribute) is invalid.
-#ifndef LLVM_HAS_CPP_ATTRIBUTE
-#if defined(__cplusplus) && defined(__has_cpp_attribute)
-# define LLVM_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
-#else
-# define LLVM_HAS_CPP_ATTRIBUTE(x) 0
-#endif
-#endif
-
-/// \macro LLVM_GNUC_PREREQ
-/// Extend the default __GNUC_PREREQ even if glibc's features.h isn't
-/// available.
-#ifndef LLVM_GNUC_PREREQ
-# if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
-#  define LLVM_GNUC_PREREQ(maj, min, patch) \
-    ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >= \
-     ((maj) << 20) + ((min) << 10) + (patch))
-# elif defined(__GNUC__) && defined(__GNUC_MINOR__)
-#  define LLVM_GNUC_PREREQ(maj, min, patch) \
-    ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10))
-# else
-#  define LLVM_GNUC_PREREQ(maj, min, patch) 0
-# endif
-#endif
-
-/// \macro LLVM_MSC_PREREQ
-/// Is the compiler MSVC of at least the specified version?
-/// The common \param version values to check for are:
-/// * 1910: VS2017, version 15.1 & 15.2
-/// * 1911: VS2017, version 15.3 & 15.4
-/// * 1912: VS2017, version 15.5
-/// * 1913: VS2017, version 15.6
-/// * 1914: VS2017, version 15.7
-/// * 1915: VS2017, version 15.8
-/// * 1916: VS2017, version 15.9
-/// * 1920: VS2019, version 16.0
-/// * 1921: VS2019, version 16.1
-#ifdef _MSC_VER
-#define LLVM_MSC_PREREQ(version) (_MSC_VER >= (version))
-
-// We require at least MSVC 2017.
-#if !LLVM_MSC_PREREQ(1910)
-#error LLVM requires at least MSVC 2017.
-#endif
-
-#else
-#define LLVM_MSC_PREREQ(version) 0
-#endif
-
-/// Does the compiler support ref-qualifiers for *this?
-///
-/// Sadly, this is separate from just rvalue reference support because GCC
-/// and MSVC implemented this later than everything else. This appears to be
-/// corrected in MSVC 2019 but not MSVC 2017.
-#if __has_feature(cxx_rvalue_references) || LLVM_GNUC_PREREQ(4, 8, 1) ||       \
-    LLVM_MSC_PREREQ(1920)
-#define LLVM_HAS_RVALUE_REFERENCE_THIS 1
-#else
-#define LLVM_HAS_RVALUE_REFERENCE_THIS 0
-#endif
-
-/// Expands to '&' if ref-qualifiers for *this are supported.
-///
-/// This can be used to provide lvalue/rvalue overrides of member functions.
-/// The rvalue override should be guarded by LLVM_HAS_RVALUE_REFERENCE_THIS
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
-#define LLVM_LVALUE_FUNCTION &
-#else
-#define LLVM_LVALUE_FUNCTION
-#endif
-
-/// LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked
-/// into a shared library, then the class should be private to the library and
-/// not accessible from outside it.  Can also be used to mark variables and
-/// functions, making them private to any shared library they are linked into.
-/// On PE/COFF targets, library visibility is the default, so this isn't needed.
-///
-/// LLVM_EXTERNAL_VISIBILITY - classes, functions, and variables marked with
-/// this attribute will be made public and visible outside of any shared library
-/// they are linked in to.
-#if (__has_attribute(visibility) || LLVM_GNUC_PREREQ(4, 0, 0)) &&              \
-    !defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(_WIN32)
-#define LLVM_LIBRARY_VISIBILITY __attribute__ ((visibility("hidden")))
-#define LLVM_EXTERNAL_VISIBILITY __attribute__ ((visibility("default")))
-#else
-#define LLVM_LIBRARY_VISIBILITY
-#define LLVM_EXTERNAL_VISIBILITY
-#endif
-
-#if defined(__GNUC__)
-#define LLVM_PREFETCH(addr, rw, locality) __builtin_prefetch(addr, rw, locality)
-#else
-#define LLVM_PREFETCH(addr, rw, locality)
-#endif
-
-#if __has_attribute(used) || LLVM_GNUC_PREREQ(3, 1, 0)
-#define LLVM_ATTRIBUTE_USED __attribute__((__used__))
-#else
-#define LLVM_ATTRIBUTE_USED
-#endif
-
-/// LLVM_NODISCARD - Warn if a type or return value is discarded.
-
-// Use the 'nodiscard' attribute in C++17 or newer mode.
-#if defined(__cplusplus) && __cplusplus > 201402L && LLVM_HAS_CPP_ATTRIBUTE(nodiscard)
-#define LLVM_NODISCARD [[nodiscard]]
-#elif LLVM_HAS_CPP_ATTRIBUTE(clang::warn_unused_result)
-#define LLVM_NODISCARD [[clang::warn_unused_result]]
-// Clang in C++14 mode claims that it has the 'nodiscard' attribute, but also
-// warns in the pedantic mode that 'nodiscard' is a C++17 extension (PR33518).
-// Use the 'nodiscard' attribute in C++14 mode only with GCC.
-// TODO: remove this workaround when PR33518 is resolved.
-#elif defined(__GNUC__) && LLVM_HAS_CPP_ATTRIBUTE(nodiscard)
-#define LLVM_NODISCARD [[nodiscard]]
-#else
-#define LLVM_NODISCARD
-#endif
-
-// Indicate that a non-static, non-const C++ member function reinitializes
-// the entire object to a known state, independent of the previous state of
-// the object.
-//
-// The clang-tidy check bugprone-use-after-move recognizes this attribute as a
-// marker that a moved-from object has left the indeterminate state and can be
-// reused.
-#if LLVM_HAS_CPP_ATTRIBUTE(clang::reinitializes)
-#define LLVM_ATTRIBUTE_REINITIALIZES [[clang::reinitializes]]
-#else
-#define LLVM_ATTRIBUTE_REINITIALIZES
-#endif
-
-// Some compilers warn about unused functions. When a function is sometimes
-// used or not depending on build settings (e.g. a function only called from
-// within "assert"), this attribute can be used to suppress such warnings.
-//
-// However, it shouldn't be used for unused *variables*, as those have a much
-// more portable solution:
-//   (void)unused_var_name;
-// Prefer cast-to-void wherever it is sufficient.
-#if __has_attribute(unused) || LLVM_GNUC_PREREQ(3, 1, 0)
-#define LLVM_ATTRIBUTE_UNUSED __attribute__((__unused__))
-#else
-#define LLVM_ATTRIBUTE_UNUSED
-#endif
-
-// FIXME: Provide this for PE/COFF targets.
-#if (__has_attribute(weak) || LLVM_GNUC_PREREQ(4, 0, 0)) &&                    \
-    (!defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(_WIN32))
-#define LLVM_ATTRIBUTE_WEAK __attribute__((__weak__))
-#else
-#define LLVM_ATTRIBUTE_WEAK
-#endif
-
-// Prior to clang 3.2, clang did not accept any spelling of
-// __has_attribute(const), so assume it is supported.
-#if defined(__clang__) || defined(__GNUC__)
-// aka 'CONST' but following LLVM Conventions.
-#define LLVM_READNONE __attribute__((__const__))
-#else
-#define LLVM_READNONE
-#endif
-
-#if __has_attribute(pure) || defined(__GNUC__)
-// aka 'PURE' but following LLVM Conventions.
-#define LLVM_READONLY __attribute__((__pure__))
-#else
-#define LLVM_READONLY
-#endif
-
-#if __has_builtin(__builtin_expect) || LLVM_GNUC_PREREQ(4, 0, 0)
-#define LLVM_LIKELY(EXPR) __builtin_expect((bool)(EXPR), true)
-#define LLVM_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false)
-#else
-#define LLVM_LIKELY(EXPR) (EXPR)
-#define LLVM_UNLIKELY(EXPR) (EXPR)
-#endif
-
-/// LLVM_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so,
-/// mark a method "not for inlining".
-#if __has_attribute(noinline) || LLVM_GNUC_PREREQ(3, 4, 0)
-#define LLVM_ATTRIBUTE_NOINLINE __attribute__((noinline))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_NOINLINE __declspec(noinline)
-#else
-#define LLVM_ATTRIBUTE_NOINLINE
-#endif
-
-/// LLVM_ATTRIBUTE_ALWAYS_INLINE - On compilers where we have a directive to do
-/// so, mark a method "always inline" because it is performance sensitive. GCC
-/// 3.4 supported this but is buggy in various cases and produces unimplemented
-/// errors, just use it in GCC 4.0 and later.
-#if __has_attribute(always_inline) || LLVM_GNUC_PREREQ(4, 0, 0)
-#define LLVM_ATTRIBUTE_ALWAYS_INLINE inline __attribute__((always_inline))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_ALWAYS_INLINE __forceinline
-#else
-#define LLVM_ATTRIBUTE_ALWAYS_INLINE inline
-#endif
-
-#ifdef __GNUC__
-#define LLVM_ATTRIBUTE_NORETURN __attribute__((noreturn))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_NORETURN __declspec(noreturn)
-#else
-#define LLVM_ATTRIBUTE_NORETURN
-#endif
-
-#if __has_attribute(returns_nonnull) || LLVM_GNUC_PREREQ(4, 9, 0)
-#define LLVM_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_RETURNS_NONNULL _Ret_notnull_
-#else
-#define LLVM_ATTRIBUTE_RETURNS_NONNULL
-#endif
-
-/// \macro LLVM_ATTRIBUTE_RETURNS_NOALIAS Used to mark a function as returning a
-/// pointer that does not alias any other valid pointer.
-#ifdef __GNUC__
-#define LLVM_ATTRIBUTE_RETURNS_NOALIAS __attribute__((__malloc__))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_RETURNS_NOALIAS __declspec(restrict)
-#else
-#define LLVM_ATTRIBUTE_RETURNS_NOALIAS
-#endif
-
-/// LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
-#if defined(__cplusplus) && __cplusplus > 201402L && LLVM_HAS_CPP_ATTRIBUTE(fallthrough)
-#define LLVM_FALLTHROUGH [[fallthrough]]
-#elif LLVM_HAS_CPP_ATTRIBUTE(gnu::fallthrough)
-#define LLVM_FALLTHROUGH [[gnu::fallthrough]]
-#elif __has_attribute(fallthrough)
-#define LLVM_FALLTHROUGH __attribute__((fallthrough))
-#elif LLVM_HAS_CPP_ATTRIBUTE(clang::fallthrough)
-#define LLVM_FALLTHROUGH [[clang::fallthrough]]
-#else
-#define LLVM_FALLTHROUGH
-#endif
-
-/// LLVM_REQUIRE_CONSTANT_INITIALIZATION - Apply this to globals to ensure that
-/// they are constant initialized.
-#if LLVM_HAS_CPP_ATTRIBUTE(clang::require_constant_initialization)
-#define LLVM_REQUIRE_CONSTANT_INITIALIZATION                                   \
-  [[clang::require_constant_initialization]]
-#else
-#define LLVM_REQUIRE_CONSTANT_INITIALIZATION
-#endif
-
-/// LLVM_GSL_OWNER - Apply this to owning classes like SmallVector to enable
-/// lifetime warnings.
-#if LLVM_HAS_CPP_ATTRIBUTE(gsl::Owner)
-#define LLVM_GSL_OWNER [[gsl::Owner]]
-#else
-#define LLVM_GSL_OWNER
-#endif
-
-/// LLVM_GSL_POINTER - Apply this to non-owning classes like
-/// StringRef to enable lifetime warnings.
-#if LLVM_HAS_CPP_ATTRIBUTE(gsl::Pointer)
-#define LLVM_GSL_POINTER [[gsl::Pointer]]
-#else
-#define LLVM_GSL_POINTER
-#endif
-
-/// LLVM_EXTENSION - Support compilers where we have a keyword to suppress
-/// pedantic diagnostics.
-#ifdef __GNUC__
-#define LLVM_EXTENSION __extension__
-#else
-#define LLVM_EXTENSION
-#endif
-
-// LLVM_ATTRIBUTE_DEPRECATED(decl, "message")
-// This macro will be removed.
-// Use C++14's attribute instead: [[deprecated("message")]]
-#define LLVM_ATTRIBUTE_DEPRECATED(decl, message) [[deprecated(message)]] decl
-
-/// LLVM_BUILTIN_UNREACHABLE - On compilers which support it, expands
-/// to an expression which states that it is undefined behavior for the
-/// compiler to reach this point.  Otherwise is not defined.
-#if __has_builtin(__builtin_unreachable) || LLVM_GNUC_PREREQ(4, 5, 0)
-# define LLVM_BUILTIN_UNREACHABLE __builtin_unreachable()
-#elif defined(_MSC_VER)
-# define LLVM_BUILTIN_UNREACHABLE __assume(false)
-#endif
-
-/// LLVM_BUILTIN_TRAP - On compilers which support it, expands to an expression
-/// which causes the program to exit abnormally.
-#if __has_builtin(__builtin_trap) || LLVM_GNUC_PREREQ(4, 3, 0)
-# define LLVM_BUILTIN_TRAP __builtin_trap()
-#elif defined(_MSC_VER)
-// The __debugbreak intrinsic is supported by MSVC, does not require forward
-// declarations involving platform-specific typedefs (unlike RaiseException),
-// results in a call to vectored exception handlers, and encodes to a short
-// instruction that still causes the trapping behavior we want.
-# define LLVM_BUILTIN_TRAP __debugbreak()
-#else
-# define LLVM_BUILTIN_TRAP *(volatile int*)0x11 = 0
-#endif
-
-/// LLVM_BUILTIN_DEBUGTRAP - On compilers which support it, expands to
-/// an expression which causes the program to break while running
-/// under a debugger.
-#if __has_builtin(__builtin_debugtrap)
-# define LLVM_BUILTIN_DEBUGTRAP __builtin_debugtrap()
-#elif defined(_MSC_VER)
-// The __debugbreak intrinsic is supported by MSVC and breaks while
-// running under the debugger, and also supports invoking a debugger
-// when the OS is configured appropriately.
-# define LLVM_BUILTIN_DEBUGTRAP __debugbreak()
-#else
-// Just continue execution when built with compilers that have no
-// support. This is a debugging aid and not intended to force the
-// program to abort if encountered.
-# define LLVM_BUILTIN_DEBUGTRAP
-#endif
-
-/// \macro LLVM_ASSUME_ALIGNED
-/// Returns a pointer with an assumed alignment.
-#if __has_builtin(__builtin_assume_aligned) || LLVM_GNUC_PREREQ(4, 7, 0)
-# define LLVM_ASSUME_ALIGNED(p, a) __builtin_assume_aligned(p, a)
-#elif defined(LLVM_BUILTIN_UNREACHABLE)
-# define LLVM_ASSUME_ALIGNED(p, a) \
-           (((uintptr_t(p) % (a)) == 0) ? (p) : (LLVM_BUILTIN_UNREACHABLE, (p)))
-#else
-# define LLVM_ASSUME_ALIGNED(p, a) (p)
-#endif
-
-/// \macro LLVM_PACKED
-/// Used to specify a packed structure.
-/// LLVM_PACKED(
-///    struct A {
-///      int i;
-///      int j;
-///      int k;
-///      long long l;
-///   });
-///
-/// LLVM_PACKED_START
-/// struct B {
-///   int i;
-///   int j;
-///   int k;
-///   long long l;
-/// };
-/// LLVM_PACKED_END
-#ifdef _MSC_VER
-# define LLVM_PACKED(d) __pragma(pack(push, 1)) d __pragma(pack(pop))
-# define LLVM_PACKED_START __pragma(pack(push, 1))
-# define LLVM_PACKED_END   __pragma(pack(pop))
-#else
-# define LLVM_PACKED(d) d __attribute__((packed))
-# define LLVM_PACKED_START _Pragma("pack(push, 1)")
-# define LLVM_PACKED_END   _Pragma("pack(pop)")
-#endif
-
-/// \macro LLVM_PTR_SIZE
-/// A constant integer equivalent to the value of sizeof(void*).
-/// Generally used in combination with alignas or when doing computation in the
-/// preprocessor.
-#ifdef __SIZEOF_POINTER__
-# define LLVM_PTR_SIZE __SIZEOF_POINTER__
-#elif defined(_WIN64)
-# define LLVM_PTR_SIZE 8
-#elif defined(_WIN32)
-# define LLVM_PTR_SIZE 4
-#elif defined(_MSC_VER)
-# error "could not determine LLVM_PTR_SIZE as a constant int for MSVC"
-#else
-# define LLVM_PTR_SIZE sizeof(void *)
-#endif
-
-/// \macro LLVM_MEMORY_SANITIZER_BUILD
-/// Whether LLVM itself is built with MemorySanitizer instrumentation.
-#if __has_feature(memory_sanitizer)
-# define LLVM_MEMORY_SANITIZER_BUILD 1
-# include <sanitizer/msan_interface.h>
-# define LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE __attribute__((no_sanitize_memory))
-#else
-# define LLVM_MEMORY_SANITIZER_BUILD 0
-# define __msan_allocated_memory(p, size)
-# define __msan_unpoison(p, size)
-# define LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE
-#endif
-
-/// \macro LLVM_ADDRESS_SANITIZER_BUILD
-/// Whether LLVM itself is built with AddressSanitizer instrumentation.
-#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
-# define LLVM_ADDRESS_SANITIZER_BUILD 1
-# include <sanitizer/asan_interface.h>
-#else
-# define LLVM_ADDRESS_SANITIZER_BUILD 0
-# define __asan_poison_memory_region(p, size)
-# define __asan_unpoison_memory_region(p, size)
-#endif
-
-/// \macro LLVM_THREAD_SANITIZER_BUILD
-/// Whether LLVM itself is built with ThreadSanitizer instrumentation.
-#if __has_feature(thread_sanitizer) || defined(__SANITIZE_THREAD__)
-# define LLVM_THREAD_SANITIZER_BUILD 1
-#else
-# define LLVM_THREAD_SANITIZER_BUILD 0
-#endif
-
-#if LLVM_THREAD_SANITIZER_BUILD
-// Thread Sanitizer is a tool that finds races in code.
-// See http://code.google.com/p/data-race-test/wiki/DynamicAnnotations .
-// tsan detects these exact functions by name.
-#ifdef __cplusplus
-extern "C" {
-#endif
-void AnnotateHappensAfter(const char *file, int line, const volatile void *cv);
-void AnnotateHappensBefore(const char *file, int line, const volatile void *cv);
-void AnnotateIgnoreWritesBegin(const char *file, int line);
-void AnnotateIgnoreWritesEnd(const char *file, int line);
-#ifdef __cplusplus
-}
-#endif
-
-// This marker is used to define a happens-before arc. The race detector will
-// infer an arc from the begin to the end when they share the same pointer
-// argument.
-# define TsanHappensBefore(cv) AnnotateHappensBefore(__FILE__, __LINE__, cv)
-
-// This marker defines the destination of a happens-before arc.
-# define TsanHappensAfter(cv) AnnotateHappensAfter(__FILE__, __LINE__, cv)
-
-// Ignore any races on writes between here and the next TsanIgnoreWritesEnd.
-# define TsanIgnoreWritesBegin() AnnotateIgnoreWritesBegin(__FILE__, __LINE__)
-
-// Resume checking for racy writes.
-# define TsanIgnoreWritesEnd() AnnotateIgnoreWritesEnd(__FILE__, __LINE__)
-#else
-# define TsanHappensBefore(cv)
-# define TsanHappensAfter(cv)
-# define TsanIgnoreWritesBegin()
-# define TsanIgnoreWritesEnd()
-#endif
-
-/// \macro LLVM_NO_SANITIZE
-/// Disable a particular sanitizer for a function.
-#if __has_attribute(no_sanitize)
-#define LLVM_NO_SANITIZE(KIND) __attribute__((no_sanitize(KIND)))
-#else
-#define LLVM_NO_SANITIZE(KIND)
-#endif
-
-/// Mark debug helper function definitions like dump() that should not be
-/// stripped from debug builds.
-/// Note that you should also surround dump() functions with
-/// `#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)` so they do always
-/// get stripped in release builds.
-// FIXME: Move this to a private config.h as it's not usable in public headers.
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE LLVM_ATTRIBUTE_USED
-#else
-#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE
-#endif
-
-/// \macro LLVM_PRETTY_FUNCTION
-/// Gets a user-friendly looking function signature for the current scope
-/// using the best available method on each platform.  The exact format of the
-/// resulting string is implementation specific and non-portable, so this should
-/// only be used, for example, for logging or diagnostics.
-#if defined(_MSC_VER)
-#define LLVM_PRETTY_FUNCTION __FUNCSIG__
-#elif defined(__GNUC__) || defined(__clang__)
-#define LLVM_PRETTY_FUNCTION __PRETTY_FUNCTION__
-#else
-#define LLVM_PRETTY_FUNCTION __func__
-#endif
-
-/// \macro LLVM_THREAD_LOCAL
-/// A thread-local storage specifier which can be used with globals,
-/// extern globals, and static globals.
-///
-/// This is essentially an extremely restricted analog to C++11's thread_local
-/// support. It uses thread_local if available, falling back on gcc __thread
-/// if not. __thread doesn't support many of the C++11 thread_local's
-/// features. You should only use this for PODs that you can statically
-/// initialize to some constant value. In almost all circumstances this is most
-/// appropriate for use with a pointer, integer, or small aggregation of
-/// pointers and integers.
-#if LLVM_ENABLE_THREADS
-#if __has_feature(cxx_thread_local) || defined(_MSC_VER)
-#define LLVM_THREAD_LOCAL thread_local
-#else
-// Clang, GCC, and other compatible compilers used __thread prior to C++11 and
-// we only need the restricted functionality that provides.
-#define LLVM_THREAD_LOCAL __thread
-#endif
-#else // !LLVM_ENABLE_THREADS
-// If threading is disabled entirely, this compiles to nothing and you get
-// a normal global variable.
-#define LLVM_THREAD_LOCAL
-#endif
-
-/// \macro LLVM_ENABLE_EXCEPTIONS
-/// Whether LLVM is built with exception support.
-#if __has_feature(cxx_exceptions)
-#define LLVM_ENABLE_EXCEPTIONS 1
-#elif defined(__GNUC__) && defined(__EXCEPTIONS)
-#define LLVM_ENABLE_EXCEPTIONS 1
-#elif defined(_MSC_VER) && defined(_CPPUNWIND)
-#define LLVM_ENABLE_EXCEPTIONS 1
-#endif
-
-#endif
diff --git a/demangle/third_party/llvm/include/llvm/Demangle/Demangle.h b/demangle/third_party/llvm/include/llvm/Demangle/Demangle.h
deleted file mode 100644
index 6133d0b9..00000000
--- a/demangle/third_party/llvm/include/llvm/Demangle/Demangle.h
+++ /dev/null
@@ -1,133 +0,0 @@
-//===--- Demangle.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_DEMANGLE_H
-#define LLVM_DEMANGLE_DEMANGLE_H
-
-#include <cstddef>
-#include <string>
-
-namespace llvm {
-/// This is a llvm local version of __cxa_demangle. Other than the name and
-/// being in the llvm namespace it is identical.
-///
-/// The mangled_name is demangled into buf and returned. If the buffer is not
-/// large enough, realloc is used to expand it.
-///
-/// The *status will be set to a value from the following enumeration
-enum : int {
-  demangle_unknown_error = -4,
-  demangle_invalid_args = -3,
-  demangle_invalid_mangled_name = -2,
-  demangle_memory_alloc_failure = -1,
-  demangle_success = 0,
-};
-
-char *itaniumDemangle(const char *mangled_name, char *buf, size_t *n,
-                      int *status);
-
-enum MSDemangleFlags {
-  MSDF_None = 0,
-  MSDF_DumpBackrefs = 1 << 0,
-  MSDF_NoAccessSpecifier = 1 << 1,
-  MSDF_NoCallingConvention = 1 << 2,
-  MSDF_NoReturnType = 1 << 3,
-  MSDF_NoMemberType = 1 << 4,
-  MSDF_NoVariableType = 1 << 5,
-};
-
-/// Demangles the Microsoft symbol pointed at by mangled_name and returns it.
-/// Returns a pointer to the start of a null-terminated demangled string on
-/// success, or nullptr on error.
-/// If n_read is non-null and demangling was successful, it receives how many
-/// bytes of the input string were consumed.
-/// buf can point to a *n_buf bytes large buffer where the demangled name is
-/// stored. If the buffer is too small, it is grown with realloc(). If buf is
-/// nullptr, then this malloc()s memory for the result.
-/// *n_buf stores the size of buf on input if buf is non-nullptr, and it
-/// receives the size of the demangled string on output if n_buf is not nullptr.
-/// status receives one of the demangle_ enum entries above if it's not nullptr.
-/// Flags controls various details of the demangled representation.
-char *microsoftDemangle(const char *mangled_name, size_t *n_read, char *buf,
-                        size_t *n_buf, int *status,
-                        MSDemangleFlags Flags = MSDF_None);
-
-// Demangles a Rust v0 mangled symbol.
-char *rustDemangle(const char *MangledName);
-
-// Demangles a D mangled symbol.
-char *dlangDemangle(const char *MangledName);
-
-/// Attempt to demangle a string using different demangling schemes.
-/// The function uses heuristics to determine which demangling scheme to use.
-/// \param MangledName - reference to string to demangle.
-/// \returns - the demangled string, or a copy of the input string if no
-/// demangling occurred.
-std::string demangle(const std::string &MangledName);
-
-bool nonMicrosoftDemangle(const char *MangledName, std::string &Result);
-
-/// "Partial" demangler. This supports demangling a string into an AST
-/// (typically an intermediate stage in itaniumDemangle) and querying certain
-/// properties or partially printing the demangled name.
-struct ItaniumPartialDemangler {
-  ItaniumPartialDemangler();
-
-  ItaniumPartialDemangler(ItaniumPartialDemangler &&Other);
-  ItaniumPartialDemangler &operator=(ItaniumPartialDemangler &&Other);
-
-  /// Demangle into an AST. Subsequent calls to the rest of the member functions
-  /// implicitly operate on the AST this produces.
-  /// \return true on error, false otherwise
-  bool partialDemangle(const char *MangledName);
-
-  /// Just print the entire mangled name into Buf. Buf and N behave like the
-  /// second and third parameters to itaniumDemangle.
-  char *finishDemangle(char *Buf, size_t *N) const;
-
-  /// Get the base name of a function. This doesn't include trailing template
-  /// arguments, ie for "a::b<int>" this function returns "b".
-  char *getFunctionBaseName(char *Buf, size_t *N) const;
-
-  /// Get the context name for a function. For "a::b::c", this function returns
-  /// "a::b".
-  char *getFunctionDeclContextName(char *Buf, size_t *N) const;
-
-  /// Get the entire name of this function.
-  char *getFunctionName(char *Buf, size_t *N) const;
-
-  /// Get the parameters for this function.
-  char *getFunctionParameters(char *Buf, size_t *N) const;
-  char *getFunctionReturnType(char *Buf, size_t *N) const;
-
-  /// If this function has any any cv or reference qualifiers. These imply that
-  /// the function is a non-static member function.
-  bool hasFunctionQualifiers() const;
-
-  /// If this symbol describes a constructor or destructor.
-  bool isCtorOrDtor() const;
-
-  /// If this symbol describes a function.
-  bool isFunction() const;
-
-  /// If this symbol describes a variable.
-  bool isData() const;
-
-  /// If this symbol is a <special-name>. These are generally implicitly
-  /// generated by the implementation, such as vtables and typeinfo names.
-  bool isSpecialName() const;
-
-  ~ItaniumPartialDemangler();
-
-private:
-  void *RootNode;
-  void *Context;
-};
-} // namespace llvm
-
-#endif
diff --git a/demangle/third_party/llvm/include/llvm/Demangle/DemangleConfig.h b/demangle/third_party/llvm/include/llvm/Demangle/DemangleConfig.h
deleted file mode 100644
index 2ff95dd8..00000000
--- a/demangle/third_party/llvm/include/llvm/Demangle/DemangleConfig.h
+++ /dev/null
@@ -1,92 +0,0 @@
-//===--- DemangleConfig.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 contains a variety of feature test macros copied from
-// include/llvm/Support/Compiler.h so that LLVMDemangle does not need to take
-// a dependency on LLVMSupport.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_DEMANGLE_DEMANGLECONFIG_H
-#define LLVM_DEMANGLE_DEMANGLECONFIG_H
-
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-
-#ifndef __has_cpp_attribute
-#define __has_cpp_attribute(x) 0
-#endif
-
-#ifndef __has_attribute
-#define __has_attribute(x) 0
-#endif
-
-#ifndef __has_builtin
-#define __has_builtin(x) 0
-#endif
-
-#ifndef DEMANGLE_GNUC_PREREQ
-#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
-#define DEMANGLE_GNUC_PREREQ(maj, min, patch)                           \
-  ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >=          \
-   ((maj) << 20) + ((min) << 10) + (patch))
-#elif defined(__GNUC__) && defined(__GNUC_MINOR__)
-#define DEMANGLE_GNUC_PREREQ(maj, min, patch)                           \
-  ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10))
-#else
-#define DEMANGLE_GNUC_PREREQ(maj, min, patch) 0
-#endif
-#endif
-
-#if __has_attribute(used) || DEMANGLE_GNUC_PREREQ(3, 1, 0)
-#define DEMANGLE_ATTRIBUTE_USED __attribute__((__used__))
-#else
-#define DEMANGLE_ATTRIBUTE_USED
-#endif
-
-#if __has_builtin(__builtin_unreachable) || DEMANGLE_GNUC_PREREQ(4, 5, 0)
-#define DEMANGLE_UNREACHABLE __builtin_unreachable()
-#elif defined(_MSC_VER)
-#define DEMANGLE_UNREACHABLE __assume(false)
-#else
-#define DEMANGLE_UNREACHABLE
-#endif
-
-#if __has_attribute(noinline) || DEMANGLE_GNUC_PREREQ(3, 4, 0)
-#define DEMANGLE_ATTRIBUTE_NOINLINE __attribute__((noinline))
-#elif defined(_MSC_VER)
-#define DEMANGLE_ATTRIBUTE_NOINLINE __declspec(noinline)
-#else
-#define DEMANGLE_ATTRIBUTE_NOINLINE
-#endif
-
-#if !defined(NDEBUG)
-#define DEMANGLE_DUMP_METHOD DEMANGLE_ATTRIBUTE_NOINLINE DEMANGLE_ATTRIBUTE_USED
-#else
-#define DEMANGLE_DUMP_METHOD DEMANGLE_ATTRIBUTE_NOINLINE
-#endif
-
-#if __cplusplus > 201402L && __has_cpp_attribute(fallthrough)
-#define DEMANGLE_FALLTHROUGH [[fallthrough]]
-#elif __has_cpp_attribute(gnu::fallthrough)
-#define DEMANGLE_FALLTHROUGH [[gnu::fallthrough]]
-#elif !__cplusplus
-// Workaround for llvm.org/PR23435, since clang 3.6 and below emit a spurious
-// error when __has_cpp_attribute is given a scoped attribute in C mode.
-#define DEMANGLE_FALLTHROUGH
-#elif __has_cpp_attribute(clang::fallthrough)
-#define DEMANGLE_FALLTHROUGH [[clang::fallthrough]]
-#else
-#define DEMANGLE_FALLTHROUGH
-#endif
-
-#define DEMANGLE_NAMESPACE_BEGIN namespace llvm { namespace itanium_demangle {
-#define DEMANGLE_NAMESPACE_END } }
-
-#endif
diff --git a/demangle/third_party/llvm/include/llvm/Demangle/ItaniumDemangle.h b/demangle/third_party/llvm/include/llvm/Demangle/ItaniumDemangle.h
deleted file mode 100644
index ea55f4a6..00000000
--- a/demangle/third_party/llvm/include/llvm/Demangle/ItaniumDemangle.h
+++ /dev/null
@@ -1,5500 +0,0 @@
-//===--- ItaniumDemangle.h -----------*- mode:c++;eval:(read-only-mode) -*-===//
-//       Do not edit! See README.txt.
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-// Generic itanium demangler library.
-// There are two copies of this file in the source tree.  The one under
-// 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 "Utility.h"
-#include <algorithm>
-#include <cassert>
-#include <cctype>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <limits>
-#include <new>
-#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");
-
-  T *First = nullptr;
-  T *Last = nullptr;
-  T *Cap = nullptr;
-  T Inline[N] = {0};
-
-  bool isInline() const { return First == Inline; }
-
-  void clearInline() {
-    First = Inline;
-    Last = Inline;
-    Cap = Inline + N;
-  }
-
-  void reserve(size_t NewCap) {
-    size_t S = size();
-    if (isInline()) {
-      auto *Tmp = static_cast<T *>(std::malloc(NewCap * sizeof(T)));
-      if (Tmp == nullptr)
-        std::terminate();
-      std::copy(First, Last, Tmp);
-      First = Tmp;
-    } else {
-      First = static_cast<T *>(std::realloc(First, NewCap * sizeof(T)));
-      if (First == nullptr)
-        std::terminate();
-    }
-    Last = First + S;
-    Cap = First + NewCap;
-  }
-
-public:
-  PODSmallVector() : First(Inline), Last(First), Cap(Inline + N) {}
-
-  PODSmallVector(const PODSmallVector &) = delete;
-  PODSmallVector &operator=(const PODSmallVector &) = delete;
-
-  PODSmallVector(PODSmallVector &&Other) : PODSmallVector() {
-    if (Other.isInline()) {
-      std::copy(Other.begin(), Other.end(), First);
-      Last = First + Other.size();
-      Other.clear();
-      return;
-    }
-
-    First = Other.First;
-    Last = Other.Last;
-    Cap = Other.Cap;
-    Other.clearInline();
-  }
-
-  PODSmallVector &operator=(PODSmallVector &&Other) {
-    if (Other.isInline()) {
-      if (!isInline()) {
-        std::free(First);
-        clearInline();
-      }
-      std::copy(Other.begin(), Other.end(), First);
-      Last = First + Other.size();
-      Other.clear();
-      return *this;
-    }
-
-    if (isInline()) {
-      First = Other.First;
-      Last = Other.Last;
-      Cap = Other.Cap;
-      Other.clearInline();
-      return *this;
-    }
-
-    std::swap(First, Other.First);
-    std::swap(Last, Other.Last);
-    std::swap(Cap, Other.Cap);
-    Other.clear();
-    return *this;
-  }
-
-  // NOLINTNEXTLINE(readability-identifier-naming)
-  void push_back(const T &Elem) {
-    if (Last == Cap)
-      reserve(size() * 2);
-    *Last++ = Elem;
-  }
-
-  // NOLINTNEXTLINE(readability-identifier-naming)
-  void pop_back() {
-    assert(Last != First && "Popping empty vector!");
-    --Last;
-  }
-
-  void dropBack(size_t Index) {
-    assert(Index <= size() && "dropBack() can't expand!");
-    Last = First + Index;
-  }
-
-  T *begin() { return First; }
-  T *end() { return Last; }
-
-  bool empty() const { return First == Last; }
-  size_t size() const { return static_cast<size_t>(Last - First); }
-  T &back() {
-    assert(Last != First && "Calling back() on empty vector!");
-    return *(Last - 1);
-  }
-  T &operator[](size_t Index) {
-    assert(Index < size() && "Invalid access!");
-    return *(begin() + Index);
-  }
-  void clear() { Last = First; }
-
-  ~PODSmallVector() {
-    if (!isInline())
-      std::free(First);
-  }
-};
-
-// Base class of all AST nodes. The AST is built by the parser, then is
-// traversed by the printLeft/Right functions to produce a demangled string.
-class Node {
-public:
-  enum Kind : unsigned char {
-#define NODE(NodeKind) K##NodeKind,
-#include "ItaniumNodes.def"
-  };
-
-  /// Three-way bool to track a cached value. Unknown is possible if this node
-  /// has an unexpanded parameter pack below it that may affect this cache.
-  enum class Cache : unsigned char { Yes, No, Unknown, };
-
-  /// Operator precedence for expression nodes. Used to determine required
-  /// parens in expression emission.
-  enum class Prec {
-    Primary,
-    Postfix,
-    Unary,
-    Cast,
-    PtrMem,
-    Multiplicative,
-    Additive,
-    Shift,
-    Spaceship,
-    Relational,
-    Equality,
-    And,
-    Xor,
-    Ior,
-    AndIf,
-    OrIf,
-    Conditional,
-    Assign,
-    Comma,
-    Default,
-  };
-
-private:
-  Kind K;
-
-  Prec Precedence : 6;
-
-  // FIXME: Make these protected.
-public:
-  /// Tracks if this node has a component on its right side, in which case we
-  /// need to call printRight.
-  Cache RHSComponentCache : 2;
-
-  /// Track if this node is a (possibly qualified) array type. This can affect
-  /// how we format the output string.
-  Cache ArrayCache : 2;
-
-  /// Track if this node is a (possibly qualified) function type. This can
-  /// affect how we format the output string.
-  Cache FunctionCache : 2;
-
-public:
-  Node(Kind K_, Prec Precedence_ = Prec::Primary,
-       Cache RHSComponentCache_ = Cache::No, Cache ArrayCache_ = Cache::No,
-       Cache FunctionCache_ = Cache::No)
-      : K(K_), Precedence(Precedence_), RHSComponentCache(RHSComponentCache_),
-        ArrayCache(ArrayCache_), FunctionCache(FunctionCache_) {}
-  Node(Kind K_, Cache RHSComponentCache_, Cache ArrayCache_ = Cache::No,
-       Cache FunctionCache_ = Cache::No)
-      : Node(K_, Prec::Primary, RHSComponentCache_, ArrayCache_,
-             FunctionCache_) {}
-
-  /// Visit the most-derived object corresponding to this object.
-  template<typename Fn> void visit(Fn F) const;
-
-  // The following function is provided by all derived classes:
-  //
-  // Call F with arguments that, when passed to the constructor of this node,
-  // would construct an equivalent node.
-  //template<typename Fn> void match(Fn F) const;
-
-  bool hasRHSComponent(OutputBuffer &OB) const {
-    if (RHSComponentCache != Cache::Unknown)
-      return RHSComponentCache == Cache::Yes;
-    return hasRHSComponentSlow(OB);
-  }
-
-  bool hasArray(OutputBuffer &OB) const {
-    if (ArrayCache != Cache::Unknown)
-      return ArrayCache == Cache::Yes;
-    return hasArraySlow(OB);
-  }
-
-  bool hasFunction(OutputBuffer &OB) const {
-    if (FunctionCache != Cache::Unknown)
-      return FunctionCache == Cache::Yes;
-    return hasFunctionSlow(OB);
-  }
-
-  Kind getKind() const { return K; }
-
-  Prec getPrecedence() const { return Precedence; }
-
-  virtual bool hasRHSComponentSlow(OutputBuffer &) const { return false; }
-  virtual bool hasArraySlow(OutputBuffer &) const { return false; }
-  virtual bool hasFunctionSlow(OutputBuffer &) const { return false; }
-
-  // Dig through "glue" nodes like ParameterPack and ForwardTemplateReference to
-  // get at a node that actually represents some concrete syntax.
-  virtual const Node *getSyntaxNode(OutputBuffer &) const { return this; }
-
-  // Print this node as an expression operand, surrounding it in parentheses if
-  // its precedence is [Strictly] weaker than P.
-  void printAsOperand(OutputBuffer &OB, Prec P = Prec::Default,
-                      bool StrictlyWorse = false) const {
-    bool Paren =
-        unsigned(getPrecedence()) >= unsigned(P) + unsigned(StrictlyWorse);
-    if (Paren)
-      OB.printOpen();
-    print(OB);
-    if (Paren)
-      OB.printClose();
-  }
-
-  void print(OutputBuffer &OB) const {
-    printLeft(OB);
-    if (RHSComponentCache != Cache::No)
-      printRight(OB);
-  }
-
-  // Print the "left" side of this Node into OutputBuffer.
-  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(); }
-
-  // Silence compiler warnings, this dtor will never be called.
-  virtual ~Node() = default;
-
-#ifndef NDEBUG
-  DEMANGLE_DUMP_METHOD void dump() const;
-#endif
-};
-
-class NodeArray {
-  Node **Elements;
-  size_t NumElements;
-
-public:
-  NodeArray() : Elements(nullptr), NumElements(0) {}
-  NodeArray(Node **Elements_, size_t NumElements_)
-      : Elements(Elements_), NumElements(NumElements_) {}
-
-  bool empty() const { return NumElements == 0; }
-  size_t size() const { return NumElements; }
-
-  Node **begin() const { return Elements; }
-  Node **end() const { return Elements + NumElements; }
-
-  Node *operator[](size_t Idx) const { return Elements[Idx]; }
-
-  void printWithComma(OutputBuffer &OB) const {
-    bool FirstElement = true;
-    for (size_t Idx = 0; Idx != NumElements; ++Idx) {
-      size_t BeforeComma = OB.getCurrentPosition();
-      if (!FirstElement)
-        OB += ", ";
-      size_t AfterComma = OB.getCurrentPosition();
-      Elements[Idx]->printAsOperand(OB, Node::Prec::Comma);
-
-      // Elements[Idx] is an empty parameter pack expansion, we should erase the
-      // comma we just printed.
-      if (AfterComma == OB.getCurrentPosition()) {
-        OB.setCurrentPosition(BeforeComma);
-        continue;
-      }
-
-      FirstElement = false;
-    }
-  }
-};
-
-struct NodeArrayNode : Node {
-  NodeArray Array;
-  NodeArrayNode(NodeArray Array_) : Node(KNodeArrayNode), Array(Array_) {}
-
-  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;
-
-public:
-  DotSuffix(const Node *Prefix_, StringView 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;
-  const Node *TA;
-
-public:
-  VendorExtQualType(const Node *Ty_, StringView Ext_, const Node *TA_)
-      : Node(KVendorExtQualType), Ty(Ty_), Ext(Ext_), TA(TA_) {}
-
-  const Node *getTy() const { return Ty; }
-  StringView 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;
-    if (TA != nullptr)
-      TA->print(OB);
-  }
-};
-
-enum FunctionRefQual : unsigned char {
-  FrefQualNone,
-  FrefQualLValue,
-  FrefQualRValue,
-};
-
-enum Qualifiers {
-  QualNone = 0,
-  QualConst = 0x1,
-  QualVolatile = 0x2,
-  QualRestrict = 0x4,
-};
-
-inline Qualifiers operator|=(Qualifiers &Q1, Qualifiers Q2) {
-  return Q1 = static_cast<Qualifiers>(Q1 | Q2);
-}
-
-class QualType final : public Node {
-protected:
-  const Qualifiers Quals;
-  const Node *Child;
-
-  void printQuals(OutputBuffer &OB) const {
-    if (Quals & QualConst)
-      OB += " const";
-    if (Quals & QualVolatile)
-      OB += " volatile";
-    if (Quals & QualRestrict)
-      OB += " restrict";
-  }
-
-public:
-  QualType(const Node *Child_, Qualifiers Quals_)
-      : Node(KQualType, Child_->RHSComponentCache,
-             Child_->ArrayCache, Child_->FunctionCache),
-        Quals(Quals_), Child(Child_) {}
-
-  Qualifiers getQuals() const { return Quals; }
-  const Node *getChild() const { return Child; }
-
-  template<typename Fn> void match(Fn F) const { F(Child, Quals); }
-
-  bool hasRHSComponentSlow(OutputBuffer &OB) const override {
-    return Child->hasRHSComponent(OB);
-  }
-  bool hasArraySlow(OutputBuffer &OB) const override {
-    return Child->hasArray(OB);
-  }
-  bool hasFunctionSlow(OutputBuffer &OB) const override {
-    return Child->hasFunction(OB);
-  }
-
-  void printLeft(OutputBuffer &OB) const override {
-    Child->printLeft(OB);
-    printQuals(OB);
-  }
-
-  void printRight(OutputBuffer &OB) const override { Child->printRight(OB); }
-};
-
-class ConversionOperatorType final : public Node {
-  const Node *Ty;
-
-public:
-  ConversionOperatorType(const Node *Ty_)
-      : Node(KConversionOperatorType), Ty(Ty_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Ty); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    OB += "operator ";
-    Ty->print(OB);
-  }
-};
-
-class PostfixQualifiedType final : public Node {
-  const Node *Ty;
-  const StringView Postfix;
-
-public:
-  PostfixQualifiedType(const Node *Ty_, StringView 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;
-
-public:
-  NameType(StringView 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; }
-
-  void printLeft(OutputBuffer &OB) const override { OB += Name; }
-};
-
-class BitIntType final : public Node {
-  const Node *Size;
-  bool Signed;
-
-public:
-  BitIntType(const Node *Size_, bool Signed_)
-      : Node(KBitIntType), Size(Size_), Signed(Signed_) {}
-
-  template <typename Fn> void match(Fn F) const { F(Size, Signed); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    if (!Signed)
-      OB += "unsigned ";
-    OB += "_BitInt";
-    OB.printOpen();
-    Size->printAsOperand(OB);
-    OB.printClose();
-  }
-};
-
-class ElaboratedTypeSpefType : public Node {
-  StringView Kind;
-  Node *Child;
-public:
-  ElaboratedTypeSpefType(StringView 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;
-
-  AbiTagAttr(Node* Base_, StringView Tag_)
-      : Node(KAbiTagAttr, Base_->RHSComponentCache,
-             Base_->ArrayCache, Base_->FunctionCache),
-        Base(Base_), Tag(Tag_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Base, Tag); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    Base->printLeft(OB);
-    OB += "[abi:";
-    OB += Tag;
-    OB += "]";
-  }
-};
-
-class EnableIfAttr : public Node {
-  NodeArray Conditions;
-public:
-  EnableIfAttr(NodeArray Conditions_)
-      : Node(KEnableIfAttr), Conditions(Conditions_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Conditions); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    OB += " [enable_if:";
-    Conditions.printWithComma(OB);
-    OB += ']';
-  }
-};
-
-class ObjCProtoName : public Node {
-  const Node *Ty;
-  StringView Protocol;
-
-  friend class PointerType;
-
-public:
-  ObjCProtoName(const Node *Ty_, StringView 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";
-  }
-
-  void printLeft(OutputBuffer &OB) const override {
-    Ty->print(OB);
-    OB += "<";
-    OB += Protocol;
-    OB += ">";
-  }
-};
-
-class PointerType final : public Node {
-  const Node *Pointee;
-
-public:
-  PointerType(const Node *Pointee_)
-      : Node(KPointerType, Pointee_->RHSComponentCache),
-        Pointee(Pointee_) {}
-
-  const Node *getPointee() const { return Pointee; }
-
-  template<typename Fn> void match(Fn F) const { F(Pointee); }
-
-  bool hasRHSComponentSlow(OutputBuffer &OB) const override {
-    return Pointee->hasRHSComponent(OB);
-  }
-
-  void printLeft(OutputBuffer &OB) const override {
-    // We rewrite objc_object<SomeProtocol>* into id<SomeProtocol>.
-    if (Pointee->getKind() != KObjCProtoName ||
-        !static_cast<const ObjCProtoName *>(Pointee)->isObjCObject()) {
-      Pointee->printLeft(OB);
-      if (Pointee->hasArray(OB))
-        OB += " ";
-      if (Pointee->hasArray(OB) || Pointee->hasFunction(OB))
-        OB += "(";
-      OB += "*";
-    } else {
-      const auto *objcProto = static_cast<const ObjCProtoName *>(Pointee);
-      OB += "id<";
-      OB += objcProto->Protocol;
-      OB += ">";
-    }
-  }
-
-  void printRight(OutputBuffer &OB) const override {
-    if (Pointee->getKind() != KObjCProtoName ||
-        !static_cast<const ObjCProtoName *>(Pointee)->isObjCObject()) {
-      if (Pointee->hasArray(OB) || Pointee->hasFunction(OB))
-        OB += ")";
-      Pointee->printRight(OB);
-    }
-  }
-};
-
-enum class ReferenceKind {
-  LValue,
-  RValue,
-};
-
-// Represents either a LValue or an RValue reference type.
-class ReferenceType : public Node {
-  const Node *Pointee;
-  ReferenceKind RK;
-
-  mutable bool Printing = false;
-
-  // Dig through any refs to refs, collapsing the ReferenceTypes as we go. The
-  // rule here is rvalue ref to rvalue ref collapses to a rvalue ref, and any
-  // other combination collapses to a lvalue ref.
-  //
-  // A combination of a TemplateForwardReference and a back-ref Substitution
-  // from an ill-formed string may have created a cycle; use cycle detection to
-  // avoid looping forever.
-  std::pair<ReferenceKind, const Node *> collapse(OutputBuffer &OB) const {
-    auto SoFar = std::make_pair(RK, Pointee);
-    // Track the chain of nodes for the Floyd's 'tortoise and hare'
-    // cycle-detection algorithm, since getSyntaxNode(S) is impure
-    PODSmallVector<const Node *, 8> Prev;
-    for (;;) {
-      const Node *SN = SoFar.second->getSyntaxNode(OB);
-      if (SN->getKind() != KReferenceType)
-        break;
-      auto *RT = static_cast<const ReferenceType *>(SN);
-      SoFar.second = RT->Pointee;
-      SoFar.first = std::min(SoFar.first, RT->RK);
-
-      // The middle of Prev is the 'slow' pointer moving at half speed
-      Prev.push_back(SoFar.second);
-      if (Prev.size() > 1 && SoFar.second == Prev[(Prev.size() - 1) / 2]) {
-        // Cycle detected
-        SoFar.second = nullptr;
-        break;
-      }
-    }
-    return SoFar;
-  }
-
-public:
-  ReferenceType(const Node *Pointee_, ReferenceKind RK_)
-      : Node(KReferenceType, Pointee_->RHSComponentCache),
-        Pointee(Pointee_), RK(RK_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Pointee, RK); }
-
-  bool hasRHSComponentSlow(OutputBuffer &OB) const override {
-    return Pointee->hasRHSComponent(OB);
-  }
-
-  void printLeft(OutputBuffer &OB) const override {
-    if (Printing)
-      return;
-    ScopedOverride<bool> SavePrinting(Printing, true);
-    std::pair<ReferenceKind, const Node *> Collapsed = collapse(OB);
-    if (!Collapsed.second)
-      return;
-    Collapsed.second->printLeft(OB);
-    if (Collapsed.second->hasArray(OB))
-      OB += " ";
-    if (Collapsed.second->hasArray(OB) || Collapsed.second->hasFunction(OB))
-      OB += "(";
-
-    OB += (Collapsed.first == ReferenceKind::LValue ? "&" : "&&");
-  }
-  void printRight(OutputBuffer &OB) const override {
-    if (Printing)
-      return;
-    ScopedOverride<bool> SavePrinting(Printing, true);
-    std::pair<ReferenceKind, const Node *> Collapsed = collapse(OB);
-    if (!Collapsed.second)
-      return;
-    if (Collapsed.second->hasArray(OB) || Collapsed.second->hasFunction(OB))
-      OB += ")";
-    Collapsed.second->printRight(OB);
-  }
-};
-
-class PointerToMemberType final : public Node {
-  const Node *ClassType;
-  const Node *MemberType;
-
-public:
-  PointerToMemberType(const Node *ClassType_, const Node *MemberType_)
-      : Node(KPointerToMemberType, MemberType_->RHSComponentCache),
-        ClassType(ClassType_), MemberType(MemberType_) {}
-
-  template<typename Fn> void match(Fn F) const { F(ClassType, MemberType); }
-
-  bool hasRHSComponentSlow(OutputBuffer &OB) const override {
-    return MemberType->hasRHSComponent(OB);
-  }
-
-  void printLeft(OutputBuffer &OB) const override {
-    MemberType->printLeft(OB);
-    if (MemberType->hasArray(OB) || MemberType->hasFunction(OB))
-      OB += "(";
-    else
-      OB += " ";
-    ClassType->print(OB);
-    OB += "::*";
-  }
-
-  void printRight(OutputBuffer &OB) const override {
-    if (MemberType->hasArray(OB) || MemberType->hasFunction(OB))
-      OB += ")";
-    MemberType->printRight(OB);
-  }
-};
-
-class ArrayType final : public Node {
-  const Node *Base;
-  Node *Dimension;
-
-public:
-  ArrayType(const Node *Base_, Node *Dimension_)
-      : Node(KArrayType,
-             /*RHSComponentCache=*/Cache::Yes,
-             /*ArrayCache=*/Cache::Yes),
-        Base(Base_), Dimension(Dimension_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Base, Dimension); }
-
-  bool hasRHSComponentSlow(OutputBuffer &) const override { return true; }
-  bool hasArraySlow(OutputBuffer &) const override { return true; }
-
-  void printLeft(OutputBuffer &OB) const override { Base->printLeft(OB); }
-
-  void printRight(OutputBuffer &OB) const override {
-    if (OB.back() != ']')
-      OB += " ";
-    OB += "[";
-    if (Dimension)
-      Dimension->print(OB);
-    OB += "]";
-    Base->printRight(OB);
-  }
-};
-
-class FunctionType final : public Node {
-  const Node *Ret;
-  NodeArray Params;
-  Qualifiers CVQuals;
-  FunctionRefQual RefQual;
-  const Node *ExceptionSpec;
-
-public:
-  FunctionType(const Node *Ret_, NodeArray Params_, Qualifiers CVQuals_,
-               FunctionRefQual RefQual_, const Node *ExceptionSpec_)
-      : Node(KFunctionType,
-             /*RHSComponentCache=*/Cache::Yes, /*ArrayCache=*/Cache::No,
-             /*FunctionCache=*/Cache::Yes),
-        Ret(Ret_), Params(Params_), CVQuals(CVQuals_), RefQual(RefQual_),
-        ExceptionSpec(ExceptionSpec_) {}
-
-  template<typename Fn> void match(Fn F) const {
-    F(Ret, Params, CVQuals, RefQual, ExceptionSpec);
-  }
-
-  bool hasRHSComponentSlow(OutputBuffer &) const override { return true; }
-  bool hasFunctionSlow(OutputBuffer &) const override { return true; }
-
-  // Handle C++'s ... quirky decl grammar by using the left & right
-  // distinction. Consider:
-  //   int (*f(float))(char) {}
-  // f is a function that takes a float and returns a pointer to a function
-  // that takes a char and returns an int. If we're trying to print f, start
-  // by printing out the return types's left, then print our parameters, then
-  // finally print right of the return type.
-  void printLeft(OutputBuffer &OB) const override {
-    Ret->printLeft(OB);
-    OB += " ";
-  }
-
-  void printRight(OutputBuffer &OB) const override {
-    OB.printOpen();
-    Params.printWithComma(OB);
-    OB.printClose();
-    Ret->printRight(OB);
-
-    if (CVQuals & QualConst)
-      OB += " const";
-    if (CVQuals & QualVolatile)
-      OB += " volatile";
-    if (CVQuals & QualRestrict)
-      OB += " restrict";
-
-    if (RefQual == FrefQualLValue)
-      OB += " &";
-    else if (RefQual == FrefQualRValue)
-      OB += " &&";
-
-    if (ExceptionSpec != nullptr) {
-      OB += ' ';
-      ExceptionSpec->print(OB);
-    }
-  }
-};
-
-class NoexceptSpec : public Node {
-  const Node *E;
-public:
-  NoexceptSpec(const Node *E_) : Node(KNoexceptSpec), E(E_) {}
-
-  template<typename Fn> void match(Fn F) const { F(E); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    OB += "noexcept";
-    OB.printOpen();
-    E->printAsOperand(OB);
-    OB.printClose();
-  }
-};
-
-class DynamicExceptionSpec : public Node {
-  NodeArray Types;
-public:
-  DynamicExceptionSpec(NodeArray Types_)
-      : Node(KDynamicExceptionSpec), Types(Types_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Types); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    OB += "throw";
-    OB.printOpen();
-    Types.printWithComma(OB);
-    OB.printClose();
-  }
-};
-
-class FunctionEncoding final : public Node {
-  const Node *Ret;
-  const Node *Name;
-  NodeArray Params;
-  const Node *Attrs;
-  Qualifiers CVQuals;
-  FunctionRefQual RefQual;
-
-public:
-  FunctionEncoding(const Node *Ret_, const Node *Name_, NodeArray Params_,
-                   const Node *Attrs_, Qualifiers CVQuals_,
-                   FunctionRefQual RefQual_)
-      : Node(KFunctionEncoding,
-             /*RHSComponentCache=*/Cache::Yes, /*ArrayCache=*/Cache::No,
-             /*FunctionCache=*/Cache::Yes),
-        Ret(Ret_), Name(Name_), Params(Params_), Attrs(Attrs_),
-        CVQuals(CVQuals_), RefQual(RefQual_) {}
-
-  template<typename Fn> void match(Fn F) const {
-    F(Ret, Name, Params, Attrs, CVQuals, RefQual);
-  }
-
-  Qualifiers getCVQuals() const { return CVQuals; }
-  FunctionRefQual getRefQual() const { return RefQual; }
-  NodeArray getParams() const { return Params; }
-  const Node *getReturnType() const { return Ret; }
-
-  bool hasRHSComponentSlow(OutputBuffer &) const override { return true; }
-  bool hasFunctionSlow(OutputBuffer &) const override { return true; }
-
-  const Node *getName() const { return Name; }
-
-  void printLeft(OutputBuffer &OB) const override {
-    if (Ret) {
-      Ret->printLeft(OB);
-      if (!Ret->hasRHSComponent(OB))
-        OB += " ";
-    }
-    Name->print(OB);
-  }
-
-  void printRight(OutputBuffer &OB) const override {
-    OB.printOpen();
-    Params.printWithComma(OB);
-    OB.printClose();
-    if (Ret)
-      Ret->printRight(OB);
-
-    if (CVQuals & QualConst)
-      OB += " const";
-    if (CVQuals & QualVolatile)
-      OB += " volatile";
-    if (CVQuals & QualRestrict)
-      OB += " restrict";
-
-    if (RefQual == FrefQualLValue)
-      OB += " &";
-    else if (RefQual == FrefQualRValue)
-      OB += " &&";
-
-    if (Attrs != nullptr)
-      Attrs->print(OB);
-  }
-};
-
-class LiteralOperator : public Node {
-  const Node *OpName;
-
-public:
-  LiteralOperator(const Node *OpName_)
-      : Node(KLiteralOperator), OpName(OpName_) {}
-
-  template<typename Fn> void match(Fn F) const { F(OpName); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    OB += "operator\"\" ";
-    OpName->print(OB);
-  }
-};
-
-class SpecialName final : public Node {
-  const StringView Special;
-  const Node *Child;
-
-public:
-  SpecialName(StringView 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);
-  }
-};
-
-class CtorVtableSpecialName final : public Node {
-  const Node *FirstType;
-  const Node *SecondType;
-
-public:
-  CtorVtableSpecialName(const Node *FirstType_, const Node *SecondType_)
-      : Node(KCtorVtableSpecialName),
-        FirstType(FirstType_), SecondType(SecondType_) {}
-
-  template<typename Fn> void match(Fn F) const { F(FirstType, SecondType); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    OB += "construction vtable for ";
-    FirstType->print(OB);
-    OB += "-in-";
-    SecondType->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(); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    Qual->print(OB);
-    OB += "::";
-    Name->print(OB);
-  }
-};
-
-struct ModuleName : Node {
-  ModuleName *Parent;
-  Node *Name;
-  bool IsPartition;
-
-  ModuleName(ModuleName *Parent_, Node *Name_, bool IsPartition_ = false)
-      : Node(KModuleName), Parent(Parent_), Name(Name_),
-        IsPartition(IsPartition_) {}
-
-  template <typename Fn> void match(Fn F) const {
-    F(Parent, Name, IsPartition);
-  }
-
-  void printLeft(OutputBuffer &OB) const override {
-    if (Parent)
-      Parent->print(OB);
-    if (Parent || IsPartition)
-      OB += IsPartition ? ':' : '.';
-    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(); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    Name->print(OB);
-    OB += '@';
-    Module->print(OB);
-  }
-};
-
-struct LocalName : Node {
-  Node *Encoding;
-  Node *Entity;
-
-  LocalName(Node *Encoding_, Node *Entity_)
-      : Node(KLocalName), Encoding(Encoding_), Entity(Entity_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Encoding, Entity); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    Encoding->print(OB);
-    OB += "::";
-    Entity->print(OB);
-  }
-};
-
-class QualifiedName final : public Node {
-  // qualifier::name
-  const Node *Qualifier;
-  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(); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    Qualifier->print(OB);
-    OB += "::";
-    Name->print(OB);
-  }
-};
-
-class VectorType final : public Node {
-  const Node *BaseType;
-  const Node *Dimension;
-
-public:
-  VectorType(const Node *BaseType_, const Node *Dimension_)
-      : Node(KVectorType), BaseType(BaseType_), Dimension(Dimension_) {}
-
-  const Node *getBaseType() const { return BaseType; }
-  const Node *getDimension() const { return Dimension; }
-
-  template<typename Fn> void match(Fn F) const { F(BaseType, Dimension); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    BaseType->print(OB);
-    OB += " vector[";
-    if (Dimension)
-      Dimension->print(OB);
-    OB += "]";
-  }
-};
-
-class PixelVectorType final : public Node {
-  const Node *Dimension;
-
-public:
-  PixelVectorType(const Node *Dimension_)
-      : Node(KPixelVectorType), Dimension(Dimension_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Dimension); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    // FIXME: This should demangle as "vector pixel".
-    OB += "pixel vector[";
-    Dimension->print(OB);
-    OB += "]";
-  }
-};
-
-class BinaryFPType final : public Node {
-  const Node *Dimension;
-
-public:
-  BinaryFPType(const Node *Dimension_)
-      : Node(KBinaryFPType), Dimension(Dimension_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Dimension); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    OB += "_Float";
-    Dimension->print(OB);
-  }
-};
-
-enum class TemplateParamKind { Type, NonType, Template };
-
-/// An invented name for a template parameter for which we don't have a
-/// corresponding template argument.
-///
-/// This node is created when parsing the <lambda-sig> for a lambda with
-/// explicit template arguments, which might be referenced in the parameter
-/// types appearing later in the <lambda-sig>.
-class SyntheticTemplateParamName final : public Node {
-  TemplateParamKind Kind;
-  unsigned Index;
-
-public:
-  SyntheticTemplateParamName(TemplateParamKind Kind_, unsigned Index_)
-      : Node(KSyntheticTemplateParamName), Kind(Kind_), Index(Index_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Kind, Index); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    switch (Kind) {
-    case TemplateParamKind::Type:
-      OB += "$T";
-      break;
-    case TemplateParamKind::NonType:
-      OB += "$N";
-      break;
-    case TemplateParamKind::Template:
-      OB += "$TT";
-      break;
-    }
-    if (Index > 0)
-      OB << Index - 1;
-  }
-};
-
-/// A template type parameter declaration, 'typename T'.
-class TypeTemplateParamDecl final : public Node {
-  Node *Name;
-
-public:
-  TypeTemplateParamDecl(Node *Name_)
-      : Node(KTypeTemplateParamDecl, Cache::Yes), Name(Name_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Name); }
-
-  void printLeft(OutputBuffer &OB) const override { OB += "typename "; }
-
-  void printRight(OutputBuffer &OB) const override { Name->print(OB); }
-};
-
-/// A non-type template parameter declaration, 'int N'.
-class NonTypeTemplateParamDecl final : public Node {
-  Node *Name;
-  Node *Type;
-
-public:
-  NonTypeTemplateParamDecl(Node *Name_, Node *Type_)
-      : Node(KNonTypeTemplateParamDecl, Cache::Yes), Name(Name_), Type(Type_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Name, Type); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    Type->printLeft(OB);
-    if (!Type->hasRHSComponent(OB))
-      OB += " ";
-  }
-
-  void printRight(OutputBuffer &OB) const override {
-    Name->print(OB);
-    Type->printRight(OB);
-  }
-};
-
-/// A template template parameter declaration,
-/// 'template<typename T> typename N'.
-class TemplateTemplateParamDecl final : public Node {
-  Node *Name;
-  NodeArray Params;
-
-public:
-  TemplateTemplateParamDecl(Node *Name_, NodeArray Params_)
-      : Node(KTemplateTemplateParamDecl, Cache::Yes), Name(Name_),
-        Params(Params_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Name, Params); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    ScopedOverride<unsigned> LT(OB.GtIsGt, 0);
-    OB += "template<";
-    Params.printWithComma(OB);
-    OB += "> typename ";
-  }
-
-  void printRight(OutputBuffer &OB) const override { Name->print(OB); }
-};
-
-/// A template parameter pack declaration, 'typename ...T'.
-class TemplateParamPackDecl final : public Node {
-  Node *Param;
-
-public:
-  TemplateParamPackDecl(Node *Param_)
-      : Node(KTemplateParamPackDecl, Cache::Yes), Param(Param_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Param); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    Param->printLeft(OB);
-    OB += "...";
-  }
-
-  void printRight(OutputBuffer &OB) const override { Param->printRight(OB); }
-};
-
-/// An unexpanded parameter pack (either in the expression or type context). If
-/// this AST is correct, this node will have a ParameterPackExpansion node above
-/// it.
-///
-/// This node is created when some <template-args> are found that apply to an
-/// <encoding>, and is stored in the TemplateParams table. In order for this to
-/// appear in the final AST, it has to referenced via a <template-param> (ie,
-/// T_).
-class ParameterPack final : public Node {
-  NodeArray Data;
-
-  // Setup OutputBuffer for a pack expansion, unless we're already expanding
-  // one.
-  void initializePackExpansion(OutputBuffer &OB) const {
-    if (OB.CurrentPackMax == std::numeric_limits<unsigned>::max()) {
-      OB.CurrentPackMax = static_cast<unsigned>(Data.size());
-      OB.CurrentPackIndex = 0;
-    }
-  }
-
-public:
-  ParameterPack(NodeArray Data_) : Node(KParameterPack), Data(Data_) {
-    ArrayCache = FunctionCache = RHSComponentCache = Cache::Unknown;
-    if (std::all_of(Data.begin(), Data.end(), [](Node* P) {
-          return P->ArrayCache == Cache::No;
-        }))
-      ArrayCache = Cache::No;
-    if (std::all_of(Data.begin(), Data.end(), [](Node* P) {
-          return P->FunctionCache == Cache::No;
-        }))
-      FunctionCache = Cache::No;
-    if (std::all_of(Data.begin(), Data.end(), [](Node* P) {
-          return P->RHSComponentCache == Cache::No;
-        }))
-      RHSComponentCache = Cache::No;
-  }
-
-  template<typename Fn> void match(Fn F) const { F(Data); }
-
-  bool hasRHSComponentSlow(OutputBuffer &OB) const override {
-    initializePackExpansion(OB);
-    size_t Idx = OB.CurrentPackIndex;
-    return Idx < Data.size() && Data[Idx]->hasRHSComponent(OB);
-  }
-  bool hasArraySlow(OutputBuffer &OB) const override {
-    initializePackExpansion(OB);
-    size_t Idx = OB.CurrentPackIndex;
-    return Idx < Data.size() && Data[Idx]->hasArray(OB);
-  }
-  bool hasFunctionSlow(OutputBuffer &OB) const override {
-    initializePackExpansion(OB);
-    size_t Idx = OB.CurrentPackIndex;
-    return Idx < Data.size() && Data[Idx]->hasFunction(OB);
-  }
-  const Node *getSyntaxNode(OutputBuffer &OB) const override {
-    initializePackExpansion(OB);
-    size_t Idx = OB.CurrentPackIndex;
-    return Idx < Data.size() ? Data[Idx]->getSyntaxNode(OB) : this;
-  }
-
-  void printLeft(OutputBuffer &OB) const override {
-    initializePackExpansion(OB);
-    size_t Idx = OB.CurrentPackIndex;
-    if (Idx < Data.size())
-      Data[Idx]->printLeft(OB);
-  }
-  void printRight(OutputBuffer &OB) const override {
-    initializePackExpansion(OB);
-    size_t Idx = OB.CurrentPackIndex;
-    if (Idx < Data.size())
-      Data[Idx]->printRight(OB);
-  }
-};
-
-/// A variadic template argument. This node represents an occurrence of
-/// J<something>E in some <template-args>. It isn't itself unexpanded, unless
-/// one of it's Elements is. The parser inserts a ParameterPack into the
-/// TemplateParams table if the <template-args> this pack belongs to apply to an
-/// <encoding>.
-class TemplateArgumentPack final : public Node {
-  NodeArray Elements;
-public:
-  TemplateArgumentPack(NodeArray Elements_)
-      : Node(KTemplateArgumentPack), Elements(Elements_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Elements); }
-
-  NodeArray getElements() const { return Elements; }
-
-  void printLeft(OutputBuffer &OB) const override {
-    Elements.printWithComma(OB);
-  }
-};
-
-/// A pack expansion. Below this node, there are some unexpanded ParameterPacks
-/// which each have Child->ParameterPackSize elements.
-class ParameterPackExpansion final : public Node {
-  const Node *Child;
-
-public:
-  ParameterPackExpansion(const Node *Child_)
-      : Node(KParameterPackExpansion), Child(Child_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Child); }
-
-  const Node *getChild() const { return Child; }
-
-  void printLeft(OutputBuffer &OB) const override {
-    constexpr unsigned Max = std::numeric_limits<unsigned>::max();
-    ScopedOverride<unsigned> SavePackIdx(OB.CurrentPackIndex, Max);
-    ScopedOverride<unsigned> SavePackMax(OB.CurrentPackMax, Max);
-    size_t StreamPos = OB.getCurrentPosition();
-
-    // Print the first element in the pack. If Child contains a ParameterPack,
-    // it will set up S.CurrentPackMax and print the first element.
-    Child->print(OB);
-
-    // No ParameterPack was found in Child. This can occur if we've found a pack
-    // expansion on a <function-param>.
-    if (OB.CurrentPackMax == Max) {
-      OB += "...";
-      return;
-    }
-
-    // We found a ParameterPack, but it has no elements. Erase whatever we may
-    // of printed.
-    if (OB.CurrentPackMax == 0) {
-      OB.setCurrentPosition(StreamPos);
-      return;
-    }
-
-    // Else, iterate through the rest of the elements in the pack.
-    for (unsigned I = 1, E = OB.CurrentPackMax; I < E; ++I) {
-      OB += ", ";
-      OB.CurrentPackIndex = I;
-      Child->print(OB);
-    }
-  }
-};
-
-class TemplateArgs final : public Node {
-  NodeArray Params;
-
-public:
-  TemplateArgs(NodeArray Params_) : Node(KTemplateArgs), Params(Params_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Params); }
-
-  NodeArray getParams() { return Params; }
-
-  void printLeft(OutputBuffer &OB) const override {
-    ScopedOverride<unsigned> LT(OB.GtIsGt, 0);
-    OB += "<";
-    Params.printWithComma(OB);
-    OB += ">";
-  }
-};
-
-/// A forward-reference to a template argument that was not known at the point
-/// where the template parameter name was parsed in a mangling.
-///
-/// This is created when demangling the name of a specialization of a
-/// conversion function template:
-///
-/// \code
-/// struct A {
-///   template<typename T> operator T*();
-/// };
-/// \endcode
-///
-/// When demangling a specialization of the conversion function template, we
-/// encounter the name of the template (including the \c T) before we reach
-/// the template argument list, so we cannot substitute the parameter name
-/// for the corresponding argument while parsing. Instead, we create a
-/// \c ForwardTemplateReference node that is resolved after we parse the
-/// template arguments.
-struct ForwardTemplateReference : Node {
-  size_t Index;
-  Node *Ref = nullptr;
-
-  // If we're currently printing this node. It is possible (though invalid) for
-  // a forward template reference to refer to itself via a substitution. This
-  // creates a cyclic AST, which will stack overflow printing. To fix this, bail
-  // out if more than one print* function is active.
-  mutable bool Printing = false;
-
-  ForwardTemplateReference(size_t Index_)
-      : Node(KForwardTemplateReference, Cache::Unknown, Cache::Unknown,
-             Cache::Unknown),
-        Index(Index_) {}
-
-  // We don't provide a matcher for these, because the value of the node is
-  // not determined by its construction parameters, and it generally needs
-  // special handling.
-  template<typename Fn> void match(Fn F) const = delete;
-
-  bool hasRHSComponentSlow(OutputBuffer &OB) const override {
-    if (Printing)
-      return false;
-    ScopedOverride<bool> SavePrinting(Printing, true);
-    return Ref->hasRHSComponent(OB);
-  }
-  bool hasArraySlow(OutputBuffer &OB) const override {
-    if (Printing)
-      return false;
-    ScopedOverride<bool> SavePrinting(Printing, true);
-    return Ref->hasArray(OB);
-  }
-  bool hasFunctionSlow(OutputBuffer &OB) const override {
-    if (Printing)
-      return false;
-    ScopedOverride<bool> SavePrinting(Printing, true);
-    return Ref->hasFunction(OB);
-  }
-  const Node *getSyntaxNode(OutputBuffer &OB) const override {
-    if (Printing)
-      return this;
-    ScopedOverride<bool> SavePrinting(Printing, true);
-    return Ref->getSyntaxNode(OB);
-  }
-
-  void printLeft(OutputBuffer &OB) const override {
-    if (Printing)
-      return;
-    ScopedOverride<bool> SavePrinting(Printing, true);
-    Ref->printLeft(OB);
-  }
-  void printRight(OutputBuffer &OB) const override {
-    if (Printing)
-      return;
-    ScopedOverride<bool> SavePrinting(Printing, true);
-    Ref->printRight(OB);
-  }
-};
-
-struct NameWithTemplateArgs : Node {
-  // name<template_args>
-  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(); }
-
-  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(); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    OB += "::";
-    Child->print(OB);
-  }
-};
-
-enum class SpecialSubKind {
-  allocator,
-  basic_string,
-  string,
-  istream,
-  ostream,
-  iostream,
-};
-
-class SpecialSubstitution;
-class ExpandedSpecialSubstitution : public Node {
-protected:
-  SpecialSubKind SSK;
-
-  ExpandedSpecialSubstitution(SpecialSubKind SSK_, Kind K_)
-      : Node(K_), SSK(SSK_) {}
-public:
-  ExpandedSpecialSubstitution(SpecialSubKind SSK_)
-      : ExpandedSpecialSubstitution(SSK_, KExpandedSpecialSubstitution) {}
-  inline ExpandedSpecialSubstitution(SpecialSubstitution const *);
-
-  template<typename Fn> void match(Fn F) const { F(SSK); }
-
-protected:
-  bool isInstantiation() const {
-    return unsigned(SSK) >= unsigned(SpecialSubKind::string);
-  }
-
-  StringView getBaseName() const override {
-    switch (SSK) {
-    case SpecialSubKind::allocator:
-      return StringView("allocator");
-    case SpecialSubKind::basic_string:
-      return StringView("basic_string");
-    case SpecialSubKind::string:
-      return StringView("basic_string");
-    case SpecialSubKind::istream:
-      return StringView("basic_istream");
-    case SpecialSubKind::ostream:
-      return StringView("basic_ostream");
-    case SpecialSubKind::iostream:
-      return StringView("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 ();
-    if (isInstantiation()) {
-      // The instantiations are typedefs that drop the "basic_" prefix.
-      assert(SV.startsWith("basic_"));
-      SV = SV.dropFront(sizeof("basic_") - 1);
-    }
-    return SV;
-  }
-
-  void printLeft(OutputBuffer &OB) const override {
-    OB << "std::" << getBaseName();
-  }
-};
-
-inline ExpandedSpecialSubstitution::ExpandedSpecialSubstitution(
-    SpecialSubstitution const *SS)
-    : ExpandedSpecialSubstitution(SS->SSK) {}
-
-class CtorDtorName final : public Node {
-  const Node *Basename;
-  const bool IsDtor;
-  const int Variant;
-
-public:
-  CtorDtorName(const Node *Basename_, bool IsDtor_, int Variant_)
-      : Node(KCtorDtorName), Basename(Basename_), IsDtor(IsDtor_),
-        Variant(Variant_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Basename, IsDtor, Variant); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    if (IsDtor)
-      OB += "~";
-    OB += Basename->getBaseName();
-  }
-};
-
-class DtorName : public Node {
-  const Node *Base;
-
-public:
-  DtorName(const Node *Base_) : Node(KDtorName), Base(Base_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Base); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    OB += "~";
-    Base->printLeft(OB);
-  }
-};
-
-class UnnamedTypeName : public Node {
-  const StringView Count;
-
-public:
-  UnnamedTypeName(StringView 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;
-
-public:
-  ClosureTypeName(NodeArray TemplateParams_, NodeArray Params_,
-                  StringView 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 {
-    if (!TemplateParams.empty()) {
-      ScopedOverride<unsigned> LT(OB.GtIsGt, 0);
-      OB += "<";
-      TemplateParams.printWithComma(OB);
-      OB += ">";
-    }
-    OB.printOpen();
-    Params.printWithComma(OB);
-    OB.printClose();
-  }
-
-  void printLeft(OutputBuffer &OB) const override {
-    OB += "\'lambda";
-    OB += Count;
-    OB += "\'";
-    printDeclarator(OB);
-  }
-};
-
-class StructuredBindingName : public Node {
-  NodeArray Bindings;
-public:
-  StructuredBindingName(NodeArray Bindings_)
-      : Node(KStructuredBindingName), Bindings(Bindings_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Bindings); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    OB.printOpen('[');
-    Bindings.printWithComma(OB);
-    OB.printClose(']');
-  }
-};
-
-// -- Expression Nodes --
-
-class BinaryExpr : public Node {
-  const Node *LHS;
-  const StringView InfixOperator;
-  const Node *RHS;
-
-public:
-  BinaryExpr(const Node *LHS_, StringView 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 {
-    bool ParenAll = OB.isGtInsideTemplateArgs() &&
-                    (InfixOperator == ">" || InfixOperator == ">>");
-    if (ParenAll)
-      OB.printOpen();
-    // Assignment is right associative, with special LHS precedence.
-    bool IsAssign = getPrecedence() == Prec::Assign;
-    LHS->printAsOperand(OB, IsAssign ? Prec::OrIf : getPrecedence(), !IsAssign);
-    // No space before comma operator
-    if (!(InfixOperator == ","))
-      OB += " ";
-    OB += InfixOperator;
-    OB += " ";
-    RHS->printAsOperand(OB, getPrecedence(), IsAssign);
-    if (ParenAll)
-      OB.printClose();
-  }
-};
-
-class ArraySubscriptExpr : public Node {
-  const Node *Op1;
-  const Node *Op2;
-
-public:
-  ArraySubscriptExpr(const Node *Op1_, const Node *Op2_, Prec Prec_)
-      : Node(KArraySubscriptExpr, Prec_), Op1(Op1_), Op2(Op2_) {}
-
-  template <typename Fn> void match(Fn F) const {
-    F(Op1, Op2, getPrecedence());
-  }
-
-  void printLeft(OutputBuffer &OB) const override {
-    Op1->printAsOperand(OB, getPrecedence());
-    OB.printOpen('[');
-    Op2->printAsOperand(OB);
-    OB.printClose(']');
-  }
-};
-
-class PostfixExpr : public Node {
-  const Node *Child;
-  const StringView Operator;
-
-public:
-  PostfixExpr(const Node *Child_, StringView 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);
-    OB += Operator;
-  }
-};
-
-class ConditionalExpr : public Node {
-  const Node *Cond;
-  const Node *Then;
-  const Node *Else;
-
-public:
-  ConditionalExpr(const Node *Cond_, const Node *Then_, const Node *Else_,
-                  Prec Prec_)
-      : Node(KConditionalExpr, Prec_), Cond(Cond_), Then(Then_), Else(Else_) {}
-
-  template <typename Fn> void match(Fn F) const {
-    F(Cond, Then, Else, getPrecedence());
-  }
-
-  void printLeft(OutputBuffer &OB) const override {
-    Cond->printAsOperand(OB, getPrecedence());
-    OB += " ? ";
-    Then->printAsOperand(OB);
-    OB += " : ";
-    Else->printAsOperand(OB, Prec::Assign, true);
-  }
-};
-
-class MemberExpr : public Node {
-  const Node *LHS;
-  const StringView Kind;
-  const Node *RHS;
-
-public:
-  MemberExpr(const Node *LHS_, StringView 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;
-  NodeArray UnionSelectors;
-  bool OnePastTheEnd;
-
-public:
-  SubobjectExpr(const Node *Type_, const Node *SubExpr_, StringView 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 {
-    SubExpr->print(OB);
-    OB += ".<";
-    Type->print(OB);
-    OB += " at offset ";
-    if (Offset.empty()) {
-      OB += "0";
-    } else if (Offset[0] == 'n') {
-      OB += "-";
-      OB += Offset.dropFront();
-    } else {
-      OB += Offset;
-    }
-    OB += ">";
-  }
-};
-
-class EnclosingExpr : public Node {
-  const StringView Prefix;
-  const Node *Infix;
-  const StringView Postfix;
-
-public:
-  EnclosingExpr(StringView 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 Node *To;
-  const Node *From;
-
-public:
-  CastExpr(StringView 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;
-    {
-      ScopedOverride<unsigned> LT(OB.GtIsGt, 0);
-      OB += "<";
-      To->printLeft(OB);
-      OB += ">";
-    }
-    OB.printOpen();
-    From->printAsOperand(OB);
-    OB.printClose();
-  }
-};
-
-class SizeofParamPackExpr : public Node {
-  const Node *Pack;
-
-public:
-  SizeofParamPackExpr(const Node *Pack_)
-      : Node(KSizeofParamPackExpr), Pack(Pack_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Pack); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    OB += "sizeof...";
-    OB.printOpen();
-    ParameterPackExpansion PPE(Pack);
-    PPE.printLeft(OB);
-    OB.printClose();
-  }
-};
-
-class CallExpr : public Node {
-  const Node *Callee;
-  NodeArray Args;
-
-public:
-  CallExpr(const Node *Callee_, NodeArray Args_, Prec Prec_)
-      : Node(KCallExpr, Prec_), Callee(Callee_), Args(Args_) {}
-
-  template <typename Fn> void match(Fn F) const {
-    F(Callee, Args, getPrecedence());
-  }
-
-  void printLeft(OutputBuffer &OB) const override {
-    Callee->print(OB);
-    OB.printOpen();
-    Args.printWithComma(OB);
-    OB.printClose();
-  }
-};
-
-class NewExpr : public Node {
-  // new (expr_list) type(init_list)
-  NodeArray ExprList;
-  Node *Type;
-  NodeArray InitList;
-  bool IsGlobal; // ::operator new ?
-  bool IsArray;  // new[] ?
-public:
-  NewExpr(NodeArray ExprList_, Node *Type_, NodeArray InitList_, bool IsGlobal_,
-          bool IsArray_, Prec Prec_)
-      : Node(KNewExpr, Prec_), ExprList(ExprList_), Type(Type_),
-        InitList(InitList_), IsGlobal(IsGlobal_), IsArray(IsArray_) {}
-
-  template<typename Fn> void match(Fn F) const {
-    F(ExprList, Type, InitList, IsGlobal, IsArray, getPrecedence());
-  }
-
-  void printLeft(OutputBuffer &OB) const override {
-    if (IsGlobal)
-      OB += "::";
-    OB += "new";
-    if (IsArray)
-      OB += "[]";
-    if (!ExprList.empty()) {
-      OB.printOpen();
-      ExprList.printWithComma(OB);
-      OB.printClose();
-    }
-    OB += " ";
-    Type->print(OB);
-    if (!InitList.empty()) {
-      OB.printOpen();
-      InitList.printWithComma(OB);
-      OB.printClose();
-    }
-  }
-};
-
-class DeleteExpr : public Node {
-  Node *Op;
-  bool IsGlobal;
-  bool IsArray;
-
-public:
-  DeleteExpr(Node *Op_, bool IsGlobal_, bool IsArray_, Prec Prec_)
-      : Node(KDeleteExpr, Prec_), Op(Op_), IsGlobal(IsGlobal_),
-        IsArray(IsArray_) {}
-
-  template <typename Fn> void match(Fn F) const {
-    F(Op, IsGlobal, IsArray, getPrecedence());
-  }
-
-  void printLeft(OutputBuffer &OB) const override {
-    if (IsGlobal)
-      OB += "::";
-    OB += "delete";
-    if (IsArray)
-      OB += "[]";
-    OB += ' ';
-    Op->print(OB);
-  }
-};
-
-class PrefixExpr : public Node {
-  StringView Prefix;
-  Node *Child;
-
-public:
-  PrefixExpr(StringView 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;
-
-public:
-  FunctionParam(StringView 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;
-  }
-};
-
-class ConversionExpr : public Node {
-  const Node *Type;
-  NodeArray Expressions;
-
-public:
-  ConversionExpr(const Node *Type_, NodeArray Expressions_, Prec Prec_)
-      : Node(KConversionExpr, Prec_), Type(Type_), Expressions(Expressions_) {}
-
-  template <typename Fn> void match(Fn F) const {
-    F(Type, Expressions, getPrecedence());
-  }
-
-  void printLeft(OutputBuffer &OB) const override {
-    OB.printOpen();
-    Type->print(OB);
-    OB.printClose();
-    OB.printOpen();
-    Expressions.printWithComma(OB);
-    OB.printClose();
-  }
-};
-
-class PointerToMemberConversionExpr : public Node {
-  const Node *Type;
-  const Node *SubExpr;
-  StringView Offset;
-
-public:
-  PointerToMemberConversionExpr(const Node *Type_, const Node *SubExpr_,
-                                StringView 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 {
-    OB.printOpen();
-    Type->print(OB);
-    OB.printClose();
-    OB.printOpen();
-    SubExpr->print(OB);
-    OB.printClose();
-  }
-};
-
-class InitListExpr : public Node {
-  const Node *Ty;
-  NodeArray Inits;
-public:
-  InitListExpr(const Node *Ty_, NodeArray Inits_)
-      : Node(KInitListExpr), Ty(Ty_), Inits(Inits_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Ty, Inits); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    if (Ty)
-      Ty->print(OB);
-    OB += '{';
-    Inits.printWithComma(OB);
-    OB += '}';
-  }
-};
-
-class BracedExpr : public Node {
-  const Node *Elem;
-  const Node *Init;
-  bool IsArray;
-public:
-  BracedExpr(const Node *Elem_, const Node *Init_, bool IsArray_)
-      : Node(KBracedExpr), Elem(Elem_), Init(Init_), IsArray(IsArray_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Elem, Init, IsArray); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    if (IsArray) {
-      OB += '[';
-      Elem->print(OB);
-      OB += ']';
-    } else {
-      OB += '.';
-      Elem->print(OB);
-    }
-    if (Init->getKind() != KBracedExpr && Init->getKind() != KBracedRangeExpr)
-      OB += " = ";
-    Init->print(OB);
-  }
-};
-
-class BracedRangeExpr : public Node {
-  const Node *First;
-  const Node *Last;
-  const Node *Init;
-public:
-  BracedRangeExpr(const Node *First_, const Node *Last_, const Node *Init_)
-      : Node(KBracedRangeExpr), First(First_), Last(Last_), Init(Init_) {}
-
-  template<typename Fn> void match(Fn F) const { F(First, Last, Init); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    OB += '[';
-    First->print(OB);
-    OB += " ... ";
-    Last->print(OB);
-    OB += ']';
-    if (Init->getKind() != KBracedExpr && Init->getKind() != KBracedRangeExpr)
-      OB += " = ";
-    Init->print(OB);
-  }
-};
-
-class FoldExpr : public Node {
-  const Node *Pack, *Init;
-  StringView OperatorName;
-  bool IsLeftFold;
-
-public:
-  FoldExpr(bool IsLeftFold_, StringView 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);
-  }
-
-  void printLeft(OutputBuffer &OB) const override {
-    auto PrintPack = [&] {
-      OB.printOpen();
-      ParameterPackExpansion(Pack).print(OB);
-      OB.printClose();
-    };
-
-    OB.printOpen();
-    // Either '[init op ]... op pack' or 'pack op ...[ op init]'
-    // Refactored to '[(init|pack) op ]...[ op (pack|init)]'
-    // Fold expr operands are cast-expressions
-    if (!IsLeftFold || Init != nullptr) {
-      // '(init|pack) op '
-      if (IsLeftFold)
-        Init->printAsOperand(OB, Prec::Cast, true);
-      else
-        PrintPack();
-      OB << " " << OperatorName << " ";
-    }
-    OB << "...";
-    if (IsLeftFold || Init != nullptr) {
-      // ' op (init|pack)'
-      OB << " " << OperatorName << " ";
-      if (IsLeftFold)
-        PrintPack();
-      else
-        Init->printAsOperand(OB, Prec::Cast, true);
-    }
-    OB.printClose();
-  }
-};
-
-class ThrowExpr : public Node {
-  const Node *Op;
-
-public:
-  ThrowExpr(const Node *Op_) : Node(KThrowExpr), Op(Op_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Op); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    OB += "throw ";
-    Op->print(OB);
-  }
-};
-
-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");
-  }
-};
-
-class StringLiteral : public Node {
-  const Node *Type;
-
-public:
-  StringLiteral(const Node *Type_) : Node(KStringLiteral), Type(Type_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Type); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    OB += "\"<";
-    Type->print(OB);
-    OB += ">\"";
-  }
-};
-
-class LambdaExpr : public Node {
-  const Node *Type;
-
-public:
-  LambdaExpr(const Node *Type_) : Node(KLambdaExpr), Type(Type_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Type); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    OB += "[]";
-    if (Type->getKind() == KClosureTypeName)
-      static_cast<const ClosureTypeName *>(Type)->printDeclarator(OB);
-    OB += "{...}";
-  }
-};
-
-class EnumLiteral : public Node {
-  // ty(integer)
-  const Node *Ty;
-  StringView Integer;
-
-public:
-  EnumLiteral(const Node *Ty_, StringView 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.dropFront(1);
-    else
-      OB << Integer;
-  }
-};
-
-class IntegerLiteral : public Node {
-  StringView Type;
-  StringView Value;
-
-public:
-  IntegerLiteral(StringView Type_, StringView Value_)
-      : Node(KIntegerLiteral), Type(Type_), Value(Value_) {}
-
-  template<typename Fn> void match(Fn F) const { F(Type, Value); }
-
-  void printLeft(OutputBuffer &OB) const override {
-    if (Type.size() > 3) {
-      OB.printOpen();
-      OB += Type;
-      OB.printClose();
-    }
-
-    if (Value[0] == 'n') {
-      OB += '-';
-      OB += Value.dropFront(1);
-    } else
-      OB += Value;
-
-    if (Type.size() <= 3)
-      OB += Type;
-  }
-};
-
-template <class Float> struct FloatData;
-
-namespace float_literal_impl {
-constexpr Node::Kind getFloatLiteralKind(float *) {
-  return Node::KFloatLiteral;
-}
-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;
-
-  static constexpr Kind KindForClass =
-      float_literal_impl::getFloatLiteralKind((Float *)nullptr);
-
-public:
-  FloatLiteralImpl(StringView 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 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, num + n);
-    }
-  }
-};
-
-using FloatLiteral = FloatLiteralImpl<float>;
-using DoubleLiteral = FloatLiteralImpl<double>;
-using LongDoubleLiteral = FloatLiteralImpl<long double>;
-
-/// Visit the node. Calls \c F(P), where \c P is the node cast to the
-/// appropriate derived class.
-template<typename Fn>
-void Node::visit(Fn F) const {
-  switch (K) {
-#define NODE(X)                                                                \
-  case K##X:                                                                   \
-    return F(static_cast<const X *>(this));
-#include "ItaniumNodes.def"
-  }
-  assert(0 && "unknown mangling node kind");
-}
-
-/// Determine the kind of a node from its type.
-template<typename NodeT> struct NodeKind;
-#define NODE(X)                                                                \
-  template <> struct NodeKind<X> {                                             \
-    static constexpr Node::Kind Kind = Node::K##X;                             \
-    static constexpr const char *name() { return #X; }                         \
-  };
-#include "ItaniumNodes.def"
-
-template <typename Derived, typename Alloc> struct AbstractManglingParser {
-  const char *First;
-  const char *Last;
-
-  // Name stack, this is used by the parser to hold temporary names that were
-  // parsed. The parser collapses multiple names into new nodes to construct
-  // the AST. Once the parser is finished, names.size() == 1.
-  PODSmallVector<Node *, 32> Names;
-
-  // Substitution table. Itanium supports name substitutions as a means of
-  // compression. The string "S42_" refers to the 44nd entry (base-36) in this
-  // table.
-  PODSmallVector<Node *, 32> Subs;
-
-  using TemplateParamList = PODSmallVector<Node *, 8>;
-
-  class ScopedTemplateParamList {
-    AbstractManglingParser *Parser;
-    size_t OldNumTemplateParamLists;
-    TemplateParamList Params;
-
-  public:
-    ScopedTemplateParamList(AbstractManglingParser *TheParser)
-        : Parser(TheParser),
-          OldNumTemplateParamLists(TheParser->TemplateParams.size()) {
-      Parser->TemplateParams.push_back(&Params);
-    }
-    ~ScopedTemplateParamList() {
-      assert(Parser->TemplateParams.size() >= OldNumTemplateParamLists);
-      Parser->TemplateParams.dropBack(OldNumTemplateParamLists);
-    }
-  };
-
-  // Template parameter table. Like the above, but referenced like "T42_".
-  // This has a smaller size compared to Subs and Names because it can be
-  // stored on the stack.
-  TemplateParamList OuterTemplateParams;
-
-  // Lists of template parameters indexed by template parameter depth,
-  // referenced like "TL2_4_". If nonempty, element 0 is always
-  // OuterTemplateParams; inner elements are always template parameter lists of
-  // lambda expressions. For a generic lambda with no explicit template
-  // parameter list, the corresponding parameter list pointer will be null.
-  PODSmallVector<TemplateParamList *, 4> TemplateParams;
-
-  // Set of unresolved forward <template-param> references. These can occur in a
-  // conversion operator's type, and are resolved in the enclosing <encoding>.
-  PODSmallVector<ForwardTemplateReference *, 4> ForwardTemplateRefs;
-
-  bool TryToParseTemplateArgs = true;
-  bool PermitForwardTemplateReferences = false;
-  size_t ParsingLambdaParamsAtLevel = (size_t)-1;
-
-  unsigned NumSyntheticTemplateParameters[3] = {};
-
-  Alloc ASTAllocator;
-
-  AbstractManglingParser(const char *First_, const char *Last_)
-      : First(First_), Last(Last_) {}
-
-  Derived &getDerived() { return static_cast<Derived &>(*this); }
-
-  void reset(const char *First_, const char *Last_) {
-    First = First_;
-    Last = Last_;
-    Names.clear();
-    Subs.clear();
-    TemplateParams.clear();
-    ParsingLambdaParamsAtLevel = (size_t)-1;
-    TryToParseTemplateArgs = true;
-    PermitForwardTemplateReferences = false;
-    for (int I = 0; I != 3; ++I)
-      NumSyntheticTemplateParameters[I] = 0;
-    ASTAllocator.reset();
-  }
-
-  template <class T, class... Args> Node *make(Args &&... args) {
-    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
-  }
-
-  template <class It> NodeArray makeNodeArray(It begin, It end) {
-    size_t sz = static_cast<size_t>(end - begin);
-    void *mem = ASTAllocator.allocateNodeArray(sz);
-    Node **data = new (mem) Node *[sz];
-    std::copy(begin, end, data);
-    return NodeArray(data, sz);
-  }
-
-  NodeArray popTrailingNodeArray(size_t FromPosition) {
-    assert(FromPosition <= Names.size());
-    NodeArray res =
-        makeNodeArray(Names.begin() + (long)FromPosition, Names.end());
-    Names.dropBack(FromPosition);
-    return res;
-  }
-
-  bool consumeIf(StringView S) {
-    if (StringView(First, Last).startsWith(S)) {
-      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);
-  Qualifiers parseCVQualifiers();
-  bool parsePositiveInteger(size_t *Out);
-  StringView 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 *parseExprPrimary();
-  template <class Float> Node *parseFloatingLiteral();
-  Node *parseFunctionParam();
-  Node *parseConversionExpr();
-  Node *parseBracedExpr();
-  Node *parseFoldExpr();
-  Node *parsePointerToMemberConversionExpr(Node::Prec Prec);
-  Node *parseSubobjectExpr();
-
-  /// Parse the <type> production.
-  Node *parseType();
-  Node *parseFunctionType();
-  Node *parseVectorType();
-  Node *parseDecltype();
-  Node *parseArrayType();
-  Node *parsePointerToMemberType();
-  Node *parseClassEnumType();
-  Node *parseQualifiedType();
-
-  Node *parseEncoding();
-  bool parseCallOffset();
-  Node *parseSpecialName();
-
-  /// Holds some extra information about a <name> that is being parsed. This
-  /// information is only pertinent if the <name> refers to an <encoding>.
-  struct NameState {
-    bool CtorDtorConversion = false;
-    bool EndsWithTemplateArgs = false;
-    Qualifiers CVQualifiers = QualNone;
-    FunctionRefQual ReferenceQualifier = FrefQualNone;
-    size_t ForwardTemplateRefsBegin;
-
-    NameState(AbstractManglingParser *Enclosing)
-        : ForwardTemplateRefsBegin(Enclosing->ForwardTemplateRefs.size()) {}
-  };
-
-  bool resolveForwardTemplateRefs(NameState &State) {
-    size_t I = State.ForwardTemplateRefsBegin;
-    size_t E = ForwardTemplateRefs.size();
-    for (; I < E; ++I) {
-      size_t Idx = ForwardTemplateRefs[I]->Index;
-      if (TemplateParams.empty() || !TemplateParams[0] ||
-          Idx >= TemplateParams[0]->size())
-        return true;
-      ForwardTemplateRefs[I]->Ref = (*TemplateParams[0])[Idx];
-    }
-    ForwardTemplateRefs.dropBack(State.ForwardTemplateRefsBegin);
-    return false;
-  }
-
-  /// Parse the <name> production>
-  Node *parseName(NameState *State = nullptr);
-  Node *parseLocalName(NameState *State);
-  Node *parseOperatorName(NameState *State);
-  bool parseModuleNameOpt(ModuleName *&Module);
-  Node *parseUnqualifiedName(NameState *State, Node *Scope, ModuleName *Module);
-  Node *parseUnnamedTypeName(NameState *State);
-  Node *parseSourceName(NameState *State);
-  Node *parseUnscopedName(NameState *State, bool *isSubstName);
-  Node *parseNestedName(NameState *State);
-  Node *parseCtorDtorName(Node *&SoFar, NameState *State);
-
-  Node *parseAbiTags(Node *N);
-
-  struct OperatorInfo {
-    enum OIKind : unsigned char {
-      Prefix,      // Prefix unary: @ expr
-      Postfix,     // Postfix unary: expr @
-      Binary,      // Binary: lhs @ rhs
-      Array,       // Array index:  lhs [ rhs ]
-      Member,      // Member access: lhs @ rhs
-      New,         // New
-      Del,         // Delete
-      Call,        // Function call: expr (expr*)
-      CCast,       // C cast: (type)expr
-      Conditional, // Conditional: expr ? expr : expr
-      NameOnly,    // Overload only, not allowed in expression.
-      // Below do not have operator names
-      NamedCast, // Named cast, @<type>(expr)
-      OfIdOp,    // alignof, sizeof, typeid
-
-      Unnameable = NamedCast,
-    };
-    char Enc[2];      // Encoding
-    OIKind Kind;      // Kind of operator
-    bool Flag : 1;    // Entry-specific flag
-    Node::Prec Prec : 7; // Precedence
-    const char *Name; // Spelling
-
-  public:
-    constexpr OperatorInfo(const char (&E)[3], OIKind K, bool F, Node::Prec P,
-                           const char *N)
-        : Enc{E[0], E[1]}, Kind{K}, Flag{F}, Prec{P}, Name{N} {}
-
-  public:
-    bool operator<(const OperatorInfo &Other) const {
-      return *this < Other.Enc;
-    }
-    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;
-      if (Kind < Unnameable) {
-        assert(Res.startsWith("operator") &&
-               "operator name does not start with 'operator'");
-        Res = Res.dropFront(sizeof("operator") - 1);
-        Res.consumeFront(' ');
-      }
-      return Res;
-    }
-    StringView getName() const { return Name; }
-    OIKind getKind() const { return Kind; }
-    bool getFlag() const { return Flag; }
-    Node::Prec getPrecedence() const { return Prec; }
-  };
-  static const OperatorInfo Ops[];
-  static const size_t NumOps;
-  const OperatorInfo *parseOperatorEncoding();
-
-  /// Parse the <unresolved-name> production.
-  Node *parseUnresolvedName(bool Global);
-  Node *parseSimpleId();
-  Node *parseBaseUnresolvedName();
-  Node *parseUnresolvedType();
-  Node *parseDestructorName();
-
-  /// Top-level entry point into the parser.
-  Node *parse();
-};
-
-const char* parse_discriminator(const char* first, const char* last);
-
-// <name> ::= <nested-name> // N
-//        ::= <local-name> # See Scope Encoding below  // Z
-//        ::= <unscoped-template-name> <template-args>
-//        ::= <unscoped-name>
-//
-// <unscoped-template-name> ::= <unscoped-name>
-//                          ::= <substitution>
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseName(NameState *State) {
-  if (look() == 'N')
-    return getDerived().parseNestedName(State);
-  if (look() == 'Z')
-    return getDerived().parseLocalName(State);
-
-  Node *Result = nullptr;
-  bool IsSubst = false;
-
-  Result = getDerived().parseUnscopedName(State, &IsSubst);
-  if (!Result)
-    return nullptr;
-
-  if (look() == 'I') {
-    //        ::= <unscoped-template-name> <template-args>
-    if (!IsSubst)
-      // An unscoped-template-name is substitutable.
-      Subs.push_back(Result);
-    Node *TA = getDerived().parseTemplateArgs(State != nullptr);
-    if (TA == nullptr)
-      return nullptr;
-    if (State)
-      State->EndsWithTemplateArgs = true;
-    Result = make<NameWithTemplateArgs>(Result, TA);
-  } else if (IsSubst) {
-    // The substitution case must be followed by <template-args>.
-    return nullptr;
-  }
-
-  return Result;
-}
-
-// <local-name> := Z <function encoding> E <entity name> [<discriminator>]
-//              := Z <function encoding> E s [<discriminator>]
-//              := Z <function encoding> Ed [ <parameter number> ] _ <entity name>
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseLocalName(NameState *State) {
-  if (!consumeIf('Z'))
-    return nullptr;
-  Node *Encoding = getDerived().parseEncoding();
-  if (Encoding == nullptr || !consumeIf('E'))
-    return nullptr;
-
-  if (consumeIf('s')) {
-    First = parse_discriminator(First, Last);
-    auto *StringLitName = make<NameType>("string literal");
-    if (!StringLitName)
-      return nullptr;
-    return make<LocalName>(Encoding, StringLitName);
-  }
-
-  if (consumeIf('d')) {
-    parseNumber(true);
-    if (!consumeIf('_'))
-      return nullptr;
-    Node *N = getDerived().parseName(State);
-    if (N == nullptr)
-      return nullptr;
-    return make<LocalName>(Encoding, N);
-  }
-
-  Node *Entity = getDerived().parseName(State);
-  if (Entity == nullptr)
-    return nullptr;
-  First = parse_discriminator(First, Last);
-  return make<LocalName>(Encoding, Entity);
-}
-
-// <unscoped-name> ::= <unqualified-name>
-//                 ::= St <unqualified-name>   # ::std::
-// [*] extension
-template <typename Derived, typename Alloc>
-Node *
-AbstractManglingParser<Derived, Alloc>::parseUnscopedName(NameState *State,
-                                                          bool *IsSubst) {
-
-  Node *Std = nullptr;
-  if (consumeIf("St")) {
-    Std = make<NameType>("std");
-    if (Std == nullptr)
-      return nullptr;
-  }
-
-  Node *Res = nullptr;
-  ModuleName *Module = nullptr;
-  if (look() == 'S') {
-    Node *S = getDerived().parseSubstitution();
-    if (!S)
-      return nullptr;
-    if (S->getKind() == Node::KModuleName)
-      Module = static_cast<ModuleName *>(S);
-    else if (IsSubst && Std == nullptr) {
-      Res = S;
-      *IsSubst = true;
-    } else {
-      return nullptr;
-    }
-  }
-
-  if (Res == nullptr || Std != nullptr) {
-    Res = getDerived().parseUnqualifiedName(State, Std, Module);
-  }
-
-  return Res;
-}
-
-// <unqualified-name> ::= [<module-name>] L? <operator-name> [<abi-tags>]
-//                    ::= [<module-name>] <ctor-dtor-name> [<abi-tags>]
-//                    ::= [<module-name>] L? <source-name> [<abi-tags>]
-//                    ::= [<module-name>] L? <unnamed-type-name> [<abi-tags>]
-//			# structured binding declaration
-//                    ::= [<module-name>] L? DC <source-name>+ E
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseUnqualifiedName(
-    NameState *State, Node *Scope, ModuleName *Module) {
-  if (getDerived().parseModuleNameOpt(Module))
-    return nullptr;
-
-  consumeIf('L');
-
-  Node *Result;
-  if (look() >= '1' && look() <= '9') {
-    Result = getDerived().parseSourceName(State);
-  } else if (look() == 'U') {
-    Result = getDerived().parseUnnamedTypeName(State);
-  } else if (consumeIf("DC")) {
-    // Structured binding
-    size_t BindingsBegin = Names.size();
-    do {
-      Node *Binding = getDerived().parseSourceName(State);
-      if (Binding == nullptr)
-        return nullptr;
-      Names.push_back(Binding);
-    } while (!consumeIf('E'));
-    Result = make<StructuredBindingName>(popTrailingNodeArray(BindingsBegin));
-  } else if (look() == 'C' || look() == 'D') {
-    // A <ctor-dtor-name>.
-    if (Scope == nullptr || Module != nullptr)
-      return nullptr;
-    Result = getDerived().parseCtorDtorName(Scope, State);
-  } else {
-    Result = getDerived().parseOperatorName(State);
-  }
-
-  if (Result != nullptr && Module != nullptr)
-    Result = make<ModuleEntity>(Module, Result);
-  if (Result != nullptr)
-    Result = getDerived().parseAbiTags(Result);
-  if (Result != nullptr && Scope != nullptr)
-    Result = make<NestedName>(Scope, Result);
-
-  return Result;
-}
-
-// <module-name> ::= <module-subname>
-// 	 	 ::= <module-name> <module-subname>
-//		 ::= <substitution>  # passed in by caller
-// <module-subname> ::= W <source-name>
-//		    ::= W P <source-name>
-template <typename Derived, typename Alloc>
-bool AbstractManglingParser<Derived, Alloc>::parseModuleNameOpt(
-    ModuleName *&Module) {
-  while (consumeIf('W')) {
-    bool IsPartition = consumeIf('P');
-    Node *Sub = getDerived().parseSourceName(nullptr);
-    if (!Sub)
-      return true;
-    Module =
-        static_cast<ModuleName *>(make<ModuleName>(Module, Sub, IsPartition));
-    Subs.push_back(Module);
-  }
-
-  return false;
-}
-
-// <unnamed-type-name> ::= Ut [<nonnegative number>] _
-//                     ::= <closure-type-name>
-//
-// <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
-//
-// <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda has no parameters
-template <typename Derived, typename Alloc>
-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();
-    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) {
-      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
-    // includes 'auto', we should remove LambdaTemplateParams from the
-    // TemplateParams list. Unfortunately, we don't find out whether there are
-    // any 'auto' parameters until too late in an example such as:
-    //
-    //   template<typename T> void f(
-    //       decltype([](decltype([]<typename T>(T v) {}),
-    //                   auto) {})) {}
-    //   template<typename T> void f(
-    //       decltype([](decltype([]<typename T>(T w) {}),
-    //                   int) {})) {}
-    //
-    // Here, the type of v is at level 2 but the type of w is at level 1. We
-    // don't find this out until we encounter the type of the next parameter.
-    //
-    // However, compilers can't actually cope with the former example in
-    // practice, and it's likely to be made ill-formed in future, so we don't
-    // need to support it here.
-    //
-    // If we encounter an 'auto' in the function parameter types, we will
-    // recreate a template parameter scope for it, but any intervening lambdas
-    // will be parsed in the 'wrong' template parameter depth.
-    if (TempParams.empty())
-      TemplateParams.pop_back();
-
-    if (!consumeIf("vE")) {
-      do {
-        Node *P = getDerived().parseType();
-        if (P == nullptr)
-          return nullptr;
-        Names.push_back(P);
-      } while (!consumeIf('E'));
-    }
-    NodeArray Params = popTrailingNodeArray(ParamsBegin);
-
-    StringView 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, First + Length);
-  First += Length;
-  if (Name.startsWith("_GLOBAL__N"))
-    return make<NameType>("(anonymous namespace)");
-  return make<NameType>(Name);
-}
-
-// Operator encodings
-template <typename Derived, typename Alloc>
-const typename AbstractManglingParser<
-    Derived, Alloc>::OperatorInfo AbstractManglingParser<Derived,
-                                                         Alloc>::Ops[] = {
-    // Keep ordered by encoding
-    {"aN", OperatorInfo::Binary, false, Node::Prec::Assign, "operator&="},
-    {"aS", OperatorInfo::Binary, false, Node::Prec::Assign, "operator="},
-    {"aa", OperatorInfo::Binary, false, Node::Prec::AndIf, "operator&&"},
-    {"ad", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator&"},
-    {"an", OperatorInfo::Binary, false, Node::Prec::And, "operator&"},
-    {"at", OperatorInfo::OfIdOp, /*Type*/ true, Node::Prec::Unary, "alignof "},
-    {"aw", OperatorInfo::NameOnly, false, Node::Prec::Primary,
-     "operator co_await"},
-    {"az", OperatorInfo::OfIdOp, /*Type*/ false, Node::Prec::Unary, "alignof "},
-    {"cc", OperatorInfo::NamedCast, false, Node::Prec::Postfix, "const_cast"},
-    {"cl", OperatorInfo::Call, false, Node::Prec::Postfix, "operator()"},
-    {"cm", OperatorInfo::Binary, false, Node::Prec::Comma, "operator,"},
-    {"co", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator~"},
-    {"cv", OperatorInfo::CCast, false, Node::Prec::Cast, "operator"}, // C Cast
-    {"dV", OperatorInfo::Binary, false, Node::Prec::Assign, "operator/="},
-    {"da", OperatorInfo::Del, /*Ary*/ true, Node::Prec::Unary,
-     "operator delete[]"},
-    {"dc", OperatorInfo::NamedCast, false, Node::Prec::Postfix, "dynamic_cast"},
-    {"de", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator*"},
-    {"dl", OperatorInfo::Del, /*Ary*/ false, Node::Prec::Unary,
-     "operator delete"},
-    {"ds", OperatorInfo::Member, /*Named*/ false, Node::Prec::PtrMem,
-     "operator.*"},
-    {"dt", OperatorInfo::Member, /*Named*/ false, Node::Prec::Postfix,
-     "operator."},
-    {"dv", OperatorInfo::Binary, false, Node::Prec::Assign, "operator/"},
-    {"eO", OperatorInfo::Binary, false, Node::Prec::Assign, "operator^="},
-    {"eo", OperatorInfo::Binary, false, Node::Prec::Xor, "operator^"},
-    {"eq", OperatorInfo::Binary, false, Node::Prec::Equality, "operator=="},
-    {"ge", OperatorInfo::Binary, false, Node::Prec::Relational, "operator>="},
-    {"gt", OperatorInfo::Binary, false, Node::Prec::Relational, "operator>"},
-    {"ix", OperatorInfo::Array, false, Node::Prec::Postfix, "operator[]"},
-    {"lS", OperatorInfo::Binary, false, Node::Prec::Assign, "operator<<="},
-    {"le", OperatorInfo::Binary, false, Node::Prec::Relational, "operator<="},
-    {"ls", OperatorInfo::Binary, false, Node::Prec::Shift, "operator<<"},
-    {"lt", OperatorInfo::Binary, false, Node::Prec::Relational, "operator<"},
-    {"mI", OperatorInfo::Binary, false, Node::Prec::Assign, "operator-="},
-    {"mL", OperatorInfo::Binary, false, Node::Prec::Assign, "operator*="},
-    {"mi", OperatorInfo::Binary, false, Node::Prec::Additive, "operator-"},
-    {"ml", OperatorInfo::Binary, false, Node::Prec::Multiplicative,
-     "operator*"},
-    {"mm", OperatorInfo::Postfix, false, Node::Prec::Postfix, "operator--"},
-    {"na", OperatorInfo::New, /*Ary*/ true, Node::Prec::Unary,
-     "operator new[]"},
-    {"ne", OperatorInfo::Binary, false, Node::Prec::Equality, "operator!="},
-    {"ng", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator-"},
-    {"nt", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator!"},
-    {"nw", OperatorInfo::New, /*Ary*/ false, Node::Prec::Unary, "operator new"},
-    {"oR", OperatorInfo::Binary, false, Node::Prec::Assign, "operator|="},
-    {"oo", OperatorInfo::Binary, false, Node::Prec::OrIf, "operator||"},
-    {"or", OperatorInfo::Binary, false, Node::Prec::Ior, "operator|"},
-    {"pL", OperatorInfo::Binary, false, Node::Prec::Assign, "operator+="},
-    {"pl", OperatorInfo::Binary, false, Node::Prec::Additive, "operator+"},
-    {"pm", OperatorInfo::Member, /*Named*/ false, Node::Prec::PtrMem,
-     "operator->*"},
-    {"pp", OperatorInfo::Postfix, false, Node::Prec::Postfix, "operator++"},
-    {"ps", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator+"},
-    {"pt", OperatorInfo::Member, /*Named*/ true, Node::Prec::Postfix,
-     "operator->"},
-    {"qu", OperatorInfo::Conditional, false, Node::Prec::Conditional,
-     "operator?"},
-    {"rM", OperatorInfo::Binary, false, Node::Prec::Assign, "operator%="},
-    {"rS", OperatorInfo::Binary, false, Node::Prec::Assign, "operator>>="},
-    {"rc", OperatorInfo::NamedCast, false, Node::Prec::Postfix,
-     "reinterpret_cast"},
-    {"rm", OperatorInfo::Binary, false, Node::Prec::Multiplicative,
-     "operator%"},
-    {"rs", OperatorInfo::Binary, false, Node::Prec::Shift, "operator>>"},
-    {"sc", OperatorInfo::NamedCast, false, Node::Prec::Postfix, "static_cast"},
-    {"ss", OperatorInfo::Binary, false, Node::Prec::Spaceship, "operator<=>"},
-    {"st", OperatorInfo::OfIdOp, /*Type*/ true, Node::Prec::Unary, "sizeof "},
-    {"sz", OperatorInfo::OfIdOp, /*Type*/ false, Node::Prec::Unary, "sizeof "},
-    {"te", OperatorInfo::OfIdOp, /*Type*/ false, Node::Prec::Postfix,
-     "typeid "},
-    {"ti", OperatorInfo::OfIdOp, /*Type*/ true, Node::Prec::Postfix, "typeid "},
-};
-template <typename Derived, typename Alloc>
-const size_t AbstractManglingParser<Derived, Alloc>::NumOps = sizeof(Ops) /
-                                                              sizeof(Ops[0]);
-
-// If the next 2 chars are an operator encoding, consume them and return their
-// OperatorInfo.  Otherwise return nullptr.
-template <typename Derived, typename Alloc>
-const typename AbstractManglingParser<Derived, Alloc>::OperatorInfo *
-AbstractManglingParser<Derived, Alloc>::parseOperatorEncoding() {
-  if (numLeft() < 2)
-    return nullptr;
-
-  // We can't use lower_bound as that can link to symbols in the C++ library,
-  // and this must remain independant of that.
-  size_t lower = 0u, upper = NumOps - 1; // Inclusive bounds.
-  while (upper != lower) {
-    size_t middle = (upper + lower) / 2;
-    if (Ops[middle] < First)
-      lower = middle + 1;
-    else
-      upper = middle;
-  }
-  if (Ops[lower] != First)
-    return nullptr;
-
-  First += 2;
-  return &Ops[lower];
-}
-
-//   <operator-name> ::= See parseOperatorEncoding()
-//                   ::= li <source-name>  # operator ""
-//                   ::= v <digit> <source-name>  # vendor extended operator
-template <typename Derived, typename Alloc>
-Node *
-AbstractManglingParser<Derived, Alloc>::parseOperatorName(NameState *State) {
-  if (const auto *Op = parseOperatorEncoding()) {
-    if (Op->getKind() == OperatorInfo::CCast) {
-      //              ::= cv <type>    # (cast)
-      ScopedOverride<bool> SaveTemplate(TryToParseTemplateArgs, false);
-      // If we're parsing an encoding, State != nullptr and the conversion
-      // operators' <type> could have a <template-param> that refers to some
-      // <template-arg>s further ahead in the mangled name.
-      ScopedOverride<bool> SavePermit(PermitForwardTemplateReferences,
-                                      PermitForwardTemplateReferences ||
-                                          State != nullptr);
-      Node *Ty = getDerived().parseType();
-      if (Ty == nullptr)
-        return nullptr;
-      if (State) State->CtorDtorConversion = true;
-      return make<ConversionOperatorType>(Ty);
-    }
-
-    if (Op->getKind() >= OperatorInfo::Unnameable)
-      /* Not a nameable operator.  */
-      return nullptr;
-    if (Op->getKind() == OperatorInfo::Member && !Op->getFlag())
-      /* Not a nameable MemberExpr */
-      return nullptr;
-
-    return make<NameType>(Op->getName());
-  }
-
-  if (consumeIf("li")) {
-    //                   ::= li <source-name>  # operator ""
-    Node *SN = getDerived().parseSourceName(State);
-    if (SN == nullptr)
-      return nullptr;
-    return make<LiteralOperator>(SN);
-  }
-
-  if (consumeIf('v')) {
-    // ::= v <digit> <source-name>        # vendor extended operator
-    if (look() >= '0' && look() <= '9') {
-      First++;
-      Node *SN = getDerived().parseSourceName(State);
-      if (SN == nullptr)
-        return nullptr;
-      return make<ConversionOperatorType>(SN);
-    }
-    return nullptr;
-  }
-
-  return nullptr;
-}
-
-// <ctor-dtor-name> ::= C1  # complete object constructor
-//                  ::= C2  # base object constructor
-//                  ::= C3  # complete object allocating constructor
-//   extension      ::= C4  # gcc old-style "[unified]" constructor
-//   extension      ::= C5  # the COMDAT used for ctors
-//                  ::= D0  # deleting destructor
-//                  ::= D1  # complete object destructor
-//                  ::= D2  # base object destructor
-//   extension      ::= D4  # gcc old-style "[unified]" destructor
-//   extension      ::= D5  # the COMDAT used for dtors
-template <typename Derived, typename Alloc>
-Node *
-AbstractManglingParser<Derived, Alloc>::parseCtorDtorName(Node *&SoFar,
-                                                          NameState *State) {
-  if (SoFar->getKind() == Node::KSpecialSubstitution) {
-    // Expand the special substitution.
-    SoFar = make<ExpandedSpecialSubstitution>(
-        static_cast<SpecialSubstitution *>(SoFar));
-    if (!SoFar)
-      return nullptr;
-  }
-
-  if (consumeIf('C')) {
-    bool IsInherited = consumeIf('I');
-    if (look() != '1' && look() != '2' && look() != '3' && look() != '4' &&
-        look() != '5')
-      return nullptr;
-    int Variant = look() - '0';
-    ++First;
-    if (State) State->CtorDtorConversion = true;
-    if (IsInherited) {
-      if (getDerived().parseName(State) == nullptr)
-        return nullptr;
-    }
-    return make<CtorDtorName>(SoFar, /*IsDtor=*/false, Variant);
-  }
-
-  if (look() == 'D' && (look(1) == '0' || look(1) == '1' || look(1) == '2' ||
-                        look(1) == '4' || look(1) == '5')) {
-    int Variant = look(1) - '0';
-    First += 2;
-    if (State) State->CtorDtorConversion = true;
-    return make<CtorDtorName>(SoFar, /*IsDtor=*/true, Variant);
-  }
-
-  return nullptr;
-}
-
-// <nested-name> ::= N [<CV-Qualifiers>] [<ref-qualifier>] <prefix>
-// 			<unqualified-name> E
-//               ::= N [<CV-Qualifiers>] [<ref-qualifier>] <template-prefix>
-//               	<template-args> E
-//
-// <prefix> ::= <prefix> <unqualified-name>
-//          ::= <template-prefix> <template-args>
-//          ::= <template-param>
-//          ::= <decltype>
-//          ::= # empty
-//          ::= <substitution>
-//          ::= <prefix> <data-member-prefix>
-// [*] extension
-//
-// <data-member-prefix> := <member source-name> [<template-args>] M
-//
-// <template-prefix> ::= <prefix> <template unqualified-name>
-//                   ::= <template-param>
-//                   ::= <substitution>
-template <typename Derived, typename Alloc>
-Node *
-AbstractManglingParser<Derived, Alloc>::parseNestedName(NameState *State) {
-  if (!consumeIf('N'))
-    return nullptr;
-
-  Qualifiers CVTmp = parseCVQualifiers();
-  if (State) State->CVQualifiers = CVTmp;
-
-  if (consumeIf('O')) {
-    if (State) State->ReferenceQualifier = FrefQualRValue;
-  } else if (consumeIf('R')) {
-    if (State) State->ReferenceQualifier = FrefQualLValue;
-  } else {
-    if (State) State->ReferenceQualifier = FrefQualNone;
-  }
-
-  Node *SoFar = nullptr;
-  while (!consumeIf('E')) {
-    if (State)
-      // Only set end-with-template on the case that does that.
-      State->EndsWithTemplateArgs = false;
-
-    if (look() == 'T') {
-      //          ::= <template-param>
-      if (SoFar != nullptr)
-        return nullptr; // Cannot have a prefix.
-      SoFar = getDerived().parseTemplateParam();
-    } else if (look() == 'I') {
-      //          ::= <template-prefix> <template-args>
-      if (SoFar == nullptr)
-        return nullptr; // Must have a prefix.
-      Node *TA = getDerived().parseTemplateArgs(State != nullptr);
-      if (TA == nullptr)
-        return nullptr;
-      if (SoFar->getKind() == Node::KNameWithTemplateArgs)
-        // Semantically <template-args> <template-args> cannot be generated by a
-        // C++ entity.  There will always be [something like] a name between
-        // them.
-        return nullptr;
-      if (State)
-        State->EndsWithTemplateArgs = true;
-      SoFar = make<NameWithTemplateArgs>(SoFar, TA);
-    } else if (look() == 'D' && (look(1) == 't' || look(1) == 'T')) {
-      //          ::= <decltype>
-      if (SoFar != nullptr)
-        return nullptr; // Cannot have a prefix.
-      SoFar = getDerived().parseDecltype();
-    } else {
-      ModuleName *Module = nullptr;
-
-      if (look() == 'S') {
-        //          ::= <substitution>
-        Node *S = nullptr;
-        if (look(1) == 't') {
-          First += 2;
-          S = make<NameType>("std");
-        } else {
-          S = getDerived().parseSubstitution();
-        }
-        if (!S)
-          return nullptr;
-        if (S->getKind() == Node::KModuleName) {
-          Module = static_cast<ModuleName *>(S);
-        } else if (SoFar != nullptr) {
-          return nullptr; // Cannot have a prefix.
-        } else {
-          SoFar = S;
-          continue; // Do not push a new substitution.
-        }
-      }
-
-      //          ::= [<prefix>] <unqualified-name>
-      SoFar = getDerived().parseUnqualifiedName(State, SoFar, Module);
-    }
-
-    if (SoFar == nullptr)
-      return nullptr;
-    Subs.push_back(SoFar);
-
-    // No longer used.
-    // <data-member-prefix> := <member source-name> [<template-args>] M
-    consumeIf('M');
-  }
-
-  if (SoFar == nullptr || Subs.empty())
-    return nullptr;
-
-  Subs.pop_back();
-  return SoFar;
-}
-
-// <simple-id> ::= <source-name> [ <template-args> ]
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseSimpleId() {
-  Node *SN = getDerived().parseSourceName(/*NameState=*/nullptr);
-  if (SN == nullptr)
-    return nullptr;
-  if (look() == 'I') {
-    Node *TA = getDerived().parseTemplateArgs();
-    if (TA == nullptr)
-      return nullptr;
-    return make<NameWithTemplateArgs>(SN, TA);
-  }
-  return SN;
-}
-
-// <destructor-name> ::= <unresolved-type>  # e.g., ~T or ~decltype(f())
-//                   ::= <simple-id>        # e.g., ~A<2*N>
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseDestructorName() {
-  Node *Result;
-  if (std::isdigit(look()))
-    Result = getDerived().parseSimpleId();
-  else
-    Result = getDerived().parseUnresolvedType();
-  if (Result == nullptr)
-    return nullptr;
-  return make<DtorName>(Result);
-}
-
-// <unresolved-type> ::= <template-param>
-//                   ::= <decltype>
-//                   ::= <substitution>
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseUnresolvedType() {
-  if (look() == 'T') {
-    Node *TP = getDerived().parseTemplateParam();
-    if (TP == nullptr)
-      return nullptr;
-    Subs.push_back(TP);
-    return TP;
-  }
-  if (look() == 'D') {
-    Node *DT = getDerived().parseDecltype();
-    if (DT == nullptr)
-      return nullptr;
-    Subs.push_back(DT);
-    return DT;
-  }
-  return getDerived().parseSubstitution();
-}
-
-// <base-unresolved-name> ::= <simple-id>                                # unresolved name
-//          extension     ::= <operator-name>                            # unresolved operator-function-id
-//          extension     ::= <operator-name> <template-args>            # unresolved operator template-id
-//                        ::= on <operator-name>                         # unresolved operator-function-id
-//                        ::= on <operator-name> <template-args>         # unresolved operator template-id
-//                        ::= dn <destructor-name>                       # destructor or pseudo-destructor;
-//                                                                         # e.g. ~X or ~X<N-1>
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseBaseUnresolvedName() {
-  if (std::isdigit(look()))
-    return getDerived().parseSimpleId();
-
-  if (consumeIf("dn"))
-    return getDerived().parseDestructorName();
-
-  consumeIf("on");
-
-  Node *Oper = getDerived().parseOperatorName(/*NameState=*/nullptr);
-  if (Oper == nullptr)
-    return nullptr;
-  if (look() == 'I') {
-    Node *TA = getDerived().parseTemplateArgs();
-    if (TA == nullptr)
-      return nullptr;
-    return make<NameWithTemplateArgs>(Oper, TA);
-  }
-  return Oper;
-}
-
-// <unresolved-name>
-//  extension        ::= srN <unresolved-type> [<template-args>] <unresolved-qualifier-level>* E <base-unresolved-name>
-//                   ::= [gs] <base-unresolved-name>                     # x or (with "gs") ::x
-//                   ::= [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name>
-//                                                                       # A::x, N::y, A<T>::z; "gs" means leading "::"
-// [gs] has been parsed by caller.
-//                   ::= sr <unresolved-type> <base-unresolved-name>     # T::x / decltype(p)::x
-//  extension        ::= sr <unresolved-type> <template-args> <base-unresolved-name>
-//                                                                       # T::N::x /decltype(p)::N::x
-//  (ignored)        ::= srN <unresolved-type>  <unresolved-qualifier-level>+ E <base-unresolved-name>
-//
-// <unresolved-qualifier-level> ::= <simple-id>
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseUnresolvedName(bool Global) {
-  Node *SoFar = nullptr;
-
-  // srN <unresolved-type> [<template-args>] <unresolved-qualifier-level>* E <base-unresolved-name>
-  // srN <unresolved-type>                   <unresolved-qualifier-level>+ E <base-unresolved-name>
-  if (consumeIf("srN")) {
-    SoFar = getDerived().parseUnresolvedType();
-    if (SoFar == nullptr)
-      return nullptr;
-
-    if (look() == 'I') {
-      Node *TA = getDerived().parseTemplateArgs();
-      if (TA == nullptr)
-        return nullptr;
-      SoFar = make<NameWithTemplateArgs>(SoFar, TA);
-      if (!SoFar)
-        return nullptr;
-    }
-
-    while (!consumeIf('E')) {
-      Node *Qual = getDerived().parseSimpleId();
-      if (Qual == nullptr)
-        return nullptr;
-      SoFar = make<QualifiedName>(SoFar, Qual);
-      if (!SoFar)
-        return nullptr;
-    }
-
-    Node *Base = getDerived().parseBaseUnresolvedName();
-    if (Base == nullptr)
-      return nullptr;
-    return make<QualifiedName>(SoFar, Base);
-  }
-
-  // [gs] <base-unresolved-name>                     # x or (with "gs") ::x
-  if (!consumeIf("sr")) {
-    SoFar = getDerived().parseBaseUnresolvedName();
-    if (SoFar == nullptr)
-      return nullptr;
-    if (Global)
-      SoFar = make<GlobalQualifiedName>(SoFar);
-    return SoFar;
-  }
-
-  // [gs] sr <unresolved-qualifier-level>+ E   <base-unresolved-name>
-  if (std::isdigit(look())) {
-    do {
-      Node *Qual = getDerived().parseSimpleId();
-      if (Qual == nullptr)
-        return nullptr;
-      if (SoFar)
-        SoFar = make<QualifiedName>(SoFar, Qual);
-      else if (Global)
-        SoFar = make<GlobalQualifiedName>(Qual);
-      else
-        SoFar = Qual;
-      if (!SoFar)
-        return nullptr;
-    } while (!consumeIf('E'));
-  }
-  //      sr <unresolved-type>                 <base-unresolved-name>
-  //      sr <unresolved-type> <template-args> <base-unresolved-name>
-  else {
-    SoFar = getDerived().parseUnresolvedType();
-    if (SoFar == nullptr)
-      return nullptr;
-
-    if (look() == 'I') {
-      Node *TA = getDerived().parseTemplateArgs();
-      if (TA == nullptr)
-        return nullptr;
-      SoFar = make<NameWithTemplateArgs>(SoFar, TA);
-      if (!SoFar)
-        return nullptr;
-    }
-  }
-
-  assert(SoFar != nullptr);
-
-  Node *Base = getDerived().parseBaseUnresolvedName();
-  if (Base == nullptr)
-    return nullptr;
-  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();
-    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
-AbstractManglingParser<Alloc, Derived>::parseNumber(bool AllowNegative) {
-  const char *Tmp = First;
-  if (AllowNegative)
-    consumeIf('n');
-  if (numLeft() == 0 || !std::isdigit(*First))
-    return StringView();
-  while (numLeft() != 0 && std::isdigit(*First))
-    ++First;
-  return StringView(Tmp, First);
-}
-
-// <positive length number> ::= [0-9]*
-template <typename Alloc, typename Derived>
-bool AbstractManglingParser<Alloc, Derived>::parsePositiveInteger(size_t *Out) {
-  *Out = 0;
-  if (look() < '0' || look() > '9')
-    return true;
-  while (look() >= '0' && look() <= '9') {
-    *Out *= 10;
-    *Out += static_cast<size_t>(consume() - '0');
-  }
-  return false;
-}
-
-template <typename Alloc, typename Derived>
-StringView AbstractManglingParser<Alloc, Derived>::parseBareSourceName() {
-  size_t Int = 0;
-  if (parsePositiveInteger(&Int) || numLeft() < Int)
-    return StringView();
-  StringView R(First, First + Int);
-  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
-//                  ::= Dw <type>+ E      # dynamic exception specification with instantiation-dependent types
-//
-// <ref-qualifier> ::= R                   # & ref-qualifier
-// <ref-qualifier> ::= O                   # && ref-qualifier
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseFunctionType() {
-  Qualifiers CVQuals = parseCVQualifiers();
-
-  Node *ExceptionSpec = nullptr;
-  if (consumeIf("Do")) {
-    ExceptionSpec = make<NameType>("noexcept");
-    if (!ExceptionSpec)
-      return nullptr;
-  } else if (consumeIf("DO")) {
-    Node *E = getDerived().parseExpr();
-    if (E == nullptr || !consumeIf('E'))
-      return nullptr;
-    ExceptionSpec = make<NoexceptSpec>(E);
-    if (!ExceptionSpec)
-      return nullptr;
-  } else if (consumeIf("Dw")) {
-    size_t SpecsBegin = Names.size();
-    while (!consumeIf('E')) {
-      Node *T = getDerived().parseType();
-      if (T == nullptr)
-        return nullptr;
-      Names.push_back(T);
-    }
-    ExceptionSpec =
-      make<DynamicExceptionSpec>(popTrailingNodeArray(SpecsBegin));
-    if (!ExceptionSpec)
-      return nullptr;
-  }
-
-  consumeIf("Dx"); // transaction safe
-
-  if (!consumeIf('F'))
-    return nullptr;
-  consumeIf('Y'); // extern "C"
-  Node *ReturnType = getDerived().parseType();
-  if (ReturnType == nullptr)
-    return nullptr;
-
-  FunctionRefQual ReferenceQualifier = FrefQualNone;
-  size_t ParamsBegin = Names.size();
-  while (true) {
-    if (consumeIf('E'))
-      break;
-    if (consumeIf('v'))
-      continue;
-    if (consumeIf("RE")) {
-      ReferenceQualifier = FrefQualLValue;
-      break;
-    }
-    if (consumeIf("OE")) {
-      ReferenceQualifier = FrefQualRValue;
-      break;
-    }
-    Node *T = getDerived().parseType();
-    if (T == nullptr)
-      return nullptr;
-    Names.push_back(T);
-  }
-
-  NodeArray Params = popTrailingNodeArray(ParamsBegin);
-  return make<FunctionType>(ReturnType, Params, CVQuals,
-                            ReferenceQualifier, ExceptionSpec);
-}
-
-// extension:
-// <vector-type>           ::= Dv <positive dimension number> _ <extended element type>
-//                         ::= Dv [<dimension expression>] _ <element type>
-// <extended element type> ::= <element type>
-//                         ::= p # AltiVec vector pixel
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseVectorType() {
-  if (!consumeIf("Dv"))
-    return nullptr;
-  if (look() >= '1' && look() <= '9') {
-    Node *DimensionNumber = make<NameType>(parseNumber());
-    if (!DimensionNumber)
-      return nullptr;
-    if (!consumeIf('_'))
-      return nullptr;
-    if (consumeIf('p'))
-      return make<PixelVectorType>(DimensionNumber);
-    Node *ElemType = getDerived().parseType();
-    if (ElemType == nullptr)
-      return nullptr;
-    return make<VectorType>(ElemType, DimensionNumber);
-  }
-
-  if (!consumeIf('_')) {
-    Node *DimExpr = getDerived().parseExpr();
-    if (!DimExpr)
-      return nullptr;
-    if (!consumeIf('_'))
-      return nullptr;
-    Node *ElemType = getDerived().parseType();
-    if (!ElemType)
-      return nullptr;
-    return make<VectorType>(ElemType, DimExpr);
-  }
-  Node *ElemType = getDerived().parseType();
-  if (!ElemType)
-    return nullptr;
-  return make<VectorType>(ElemType, /*Dimension=*/nullptr);
-}
-
-// <decltype>  ::= Dt <expression> E  # decltype of an id-expression or class member access (C++0x)
-//             ::= DT <expression> E  # decltype of an expression (C++0x)
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseDecltype() {
-  if (!consumeIf('D'))
-    return nullptr;
-  if (!consumeIf('t') && !consumeIf('T'))
-    return nullptr;
-  Node *E = getDerived().parseExpr();
-  if (E == nullptr)
-    return nullptr;
-  if (!consumeIf('E'))
-    return nullptr;
-  return make<EnclosingExpr>("decltype", E);
-}
-
-// <array-type> ::= A <positive dimension number> _ <element type>
-//              ::= A [<dimension expression>] _ <element type>
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseArrayType() {
-  if (!consumeIf('A'))
-    return nullptr;
-
-  Node *Dimension = nullptr;
-
-  if (std::isdigit(look())) {
-    Dimension = make<NameType>(parseNumber());
-    if (!Dimension)
-      return nullptr;
-    if (!consumeIf('_'))
-      return nullptr;
-  } else if (!consumeIf('_')) {
-    Node *DimExpr = getDerived().parseExpr();
-    if (DimExpr == nullptr)
-      return nullptr;
-    if (!consumeIf('_'))
-      return nullptr;
-    Dimension = DimExpr;
-  }
-
-  Node *Ty = getDerived().parseType();
-  if (Ty == nullptr)
-    return nullptr;
-  return make<ArrayType>(Ty, Dimension);
-}
-
-// <pointer-to-member-type> ::= M <class type> <member type>
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parsePointerToMemberType() {
-  if (!consumeIf('M'))
-    return nullptr;
-  Node *ClassType = getDerived().parseType();
-  if (ClassType == nullptr)
-    return nullptr;
-  Node *MemberType = getDerived().parseType();
-  if (MemberType == nullptr)
-    return nullptr;
-  return make<PointerToMemberType>(ClassType, MemberType);
-}
-
-// <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;
-  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();
-    if (Qual.empty())
-      return nullptr;
-
-    // extension            ::= U <objc-name> <objc-type>  # objc-type<identifier>
-    if (Qual.startsWith("objcproto")) {
-      StringView ProtoSourceName = Qual.dropFront(std::strlen("objcproto"));
-      StringView Proto;
-      {
-        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 *TA = nullptr;
-    if (look() == 'I') {
-      TA = getDerived().parseTemplateArgs();
-      if (TA == nullptr)
-        return nullptr;
-    }
-
-    Node *Child = getDerived().parseQualifiedType();
-    if (Child == nullptr)
-      return nullptr;
-    return make<VendorExtQualType>(Child, Qual, TA);
-  }
-
-  Qualifiers Quals = parseCVQualifiers();
-  Node *Ty = getDerived().parseType();
-  if (Ty == nullptr)
-    return nullptr;
-  if (Quals != QualNone)
-    Ty = make<QualType>(Ty, Quals);
-  return Ty;
-}
-
-// <type>      ::= <builtin-type>
-//             ::= <qualified-type>
-//             ::= <function-type>
-//             ::= <class-enum-type>
-//             ::= <array-type>
-//             ::= <pointer-to-member-type>
-//             ::= <template-param>
-//             ::= <template-template-param> <template-args>
-//             ::= <decltype>
-//             ::= P <type>        # pointer
-//             ::= R <type>        # l-value reference
-//             ::= O <type>        # r-value reference (C++11)
-//             ::= C <type>        # complex pair (C99)
-//             ::= G <type>        # imaginary (C99)
-//             ::= <substitution>  # See Compression below
-// extension   ::= U <objc-name> <objc-type>  # objc-type<identifier>
-// extension   ::= <vector-type> # <vector-type> starts with Dv
-//
-// <objc-name> ::= <k0 number> objcproto <k1 number> <identifier>  # k0 = 9 + <number of digits in k1> + k1
-// <objc-type> ::= <source-name>  # PU<11+>objcproto 11objc_object<source-name> 11objc_object -> id<source-name>
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseType() {
-  Node *Result = nullptr;
-
-  switch (look()) {
-  //             ::= <qualified-type>
-  case 'r':
-  case 'V':
-  case 'K': {
-    unsigned AfterQuals = 0;
-    if (look(AfterQuals) == 'r') ++AfterQuals;
-    if (look(AfterQuals) == 'V') ++AfterQuals;
-    if (look(AfterQuals) == 'K') ++AfterQuals;
-
-    if (look(AfterQuals) == 'F' ||
-        (look(AfterQuals) == 'D' &&
-         (look(AfterQuals + 1) == 'o' || look(AfterQuals + 1) == 'O' ||
-          look(AfterQuals + 1) == 'w' || look(AfterQuals + 1) == 'x'))) {
-      Result = getDerived().parseFunctionType();
-      break;
-    }
-    DEMANGLE_FALLTHROUGH;
-  }
-  case 'U': {
-    Result = getDerived().parseQualifiedType();
-    break;
-  }
-  // <builtin-type> ::= v    # void
-  case 'v':
-    ++First;
-    return make<NameType>("void");
-  //                ::= w    # wchar_t
-  case 'w':
-    ++First;
-    return make<NameType>("wchar_t");
-  //                ::= b    # bool
-  case 'b':
-    ++First;
-    return make<NameType>("bool");
-  //                ::= c    # char
-  case 'c':
-    ++First;
-    return make<NameType>("char");
-  //                ::= a    # signed char
-  case 'a':
-    ++First;
-    return make<NameType>("signed char");
-  //                ::= h    # unsigned char
-  case 'h':
-    ++First;
-    return make<NameType>("unsigned char");
-  //                ::= s    # short
-  case 's':
-    ++First;
-    return make<NameType>("short");
-  //                ::= t    # unsigned short
-  case 't':
-    ++First;
-    return make<NameType>("unsigned short");
-  //                ::= i    # int
-  case 'i':
-    ++First;
-    return make<NameType>("int");
-  //                ::= j    # unsigned int
-  case 'j':
-    ++First;
-    return make<NameType>("unsigned int");
-  //                ::= l    # long
-  case 'l':
-    ++First;
-    return make<NameType>("long");
-  //                ::= m    # unsigned long
-  case 'm':
-    ++First;
-    return make<NameType>("unsigned long");
-  //                ::= x    # long long, __int64
-  case 'x':
-    ++First;
-    return make<NameType>("long long");
-  //                ::= y    # unsigned long long, __int64
-  case 'y':
-    ++First;
-    return make<NameType>("unsigned long long");
-  //                ::= n    # __int128
-  case 'n':
-    ++First;
-    return make<NameType>("__int128");
-  //                ::= o    # unsigned __int128
-  case 'o':
-    ++First;
-    return make<NameType>("unsigned __int128");
-  //                ::= f    # float
-  case 'f':
-    ++First;
-    return make<NameType>("float");
-  //                ::= d    # double
-  case 'd':
-    ++First;
-    return make<NameType>("double");
-  //                ::= e    # long double, __float80
-  case 'e':
-    ++First;
-    return make<NameType>("long double");
-  //                ::= g    # __float128
-  case 'g':
-    ++First;
-    return make<NameType>("__float128");
-  //                ::= z    # ellipsis
-  case 'z':
-    ++First;
-    return make<NameType>("...");
-
-  // <builtin-type> ::= u <source-name>    # vendor extended type
-  case 'u': {
-    ++First;
-    StringView 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;
-  }
-  case 'D':
-    switch (look(1)) {
-    //                ::= Dd   # IEEE 754r decimal floating point (64 bits)
-    case 'd':
-      First += 2;
-      return make<NameType>("decimal64");
-    //                ::= De   # IEEE 754r decimal floating point (128 bits)
-    case 'e':
-      First += 2;
-      return make<NameType>("decimal128");
-    //                ::= Df   # IEEE 754r decimal floating point (32 bits)
-    case 'f':
-      First += 2;
-      return make<NameType>("decimal32");
-    //                ::= Dh   # IEEE 754r half-precision floating point (16 bits)
-    case 'h':
-      First += 2;
-      return make<NameType>("half");
-    //                ::= DF <number> _ # ISO/IEC TS 18661 binary floating point (N bits)
-    case 'F': {
-      First += 2;
-      Node *DimensionNumber = make<NameType>(parseNumber());
-      if (!DimensionNumber)
-        return nullptr;
-      if (!consumeIf('_'))
-        return nullptr;
-      return make<BinaryFPType>(DimensionNumber);
-    }
-    //                ::= DB <number> _                             # C23 signed _BitInt(N)
-    //                ::= DB <instantiation-dependent expression> _ # C23 signed _BitInt(N)
-    //                ::= DU <number> _                             # C23 unsigned _BitInt(N)
-    //                ::= DU <instantiation-dependent expression> _ # C23 unsigned _BitInt(N)
-    case 'B':
-    case 'U': {
-      bool Signed = look(1) == 'B';
-      First += 2;
-      Node *Size = std::isdigit(look()) ? make<NameType>(parseNumber())
-                                        : getDerived().parseExpr();
-      if (!Size)
-        return nullptr;
-      if (!consumeIf('_'))
-        return nullptr;
-      return make<BitIntType>(Size, Signed);
-    }
-    //                ::= Di   # char32_t
-    case 'i':
-      First += 2;
-      return make<NameType>("char32_t");
-    //                ::= Ds   # char16_t
-    case 's':
-      First += 2;
-      return make<NameType>("char16_t");
-    //                ::= Du   # char8_t (C++2a, not yet in the Itanium spec)
-    case 'u':
-      First += 2;
-      return make<NameType>("char8_t");
-    //                ::= Da   # auto (in dependent new-expressions)
-    case 'a':
-      First += 2;
-      return make<NameType>("auto");
-    //                ::= Dc   # decltype(auto)
-    case 'c':
-      First += 2;
-      return make<NameType>("decltype(auto)");
-    //                ::= Dn   # std::nullptr_t (i.e., decltype(nullptr))
-    case 'n':
-      First += 2;
-      return make<NameType>("std::nullptr_t");
-
-    //             ::= <decltype>
-    case 't':
-    case 'T': {
-      Result = getDerived().parseDecltype();
-      break;
-    }
-    // extension   ::= <vector-type> # <vector-type> starts with Dv
-    case 'v': {
-      Result = getDerived().parseVectorType();
-      break;
-    }
-    //           ::= Dp <type>       # pack expansion (C++0x)
-    case 'p': {
-      First += 2;
-      Node *Child = getDerived().parseType();
-      if (!Child)
-        return nullptr;
-      Result = make<ParameterPackExpansion>(Child);
-      break;
-    }
-    // Exception specifier on a function type.
-    case 'o':
-    case 'O':
-    case 'w':
-    // Transaction safe function type.
-    case 'x':
-      Result = getDerived().parseFunctionType();
-      break;
-    }
-    break;
-  //             ::= <function-type>
-  case 'F': {
-    Result = getDerived().parseFunctionType();
-    break;
-  }
-  //             ::= <array-type>
-  case 'A': {
-    Result = getDerived().parseArrayType();
-    break;
-  }
-  //             ::= <pointer-to-member-type>
-  case 'M': {
-    Result = getDerived().parsePointerToMemberType();
-    break;
-  }
-  //             ::= <template-param>
-  case 'T': {
-    // This could be an elaborate type specifier on a <class-enum-type>.
-    if (look(1) == 's' || look(1) == 'u' || look(1) == 'e') {
-      Result = getDerived().parseClassEnumType();
-      break;
-    }
-
-    Result = getDerived().parseTemplateParam();
-    if (Result == nullptr)
-      return nullptr;
-
-    // Result could be either of:
-    //   <type>        ::= <template-param>
-    //   <type>        ::= <template-template-param> <template-args>
-    //
-    //   <template-template-param> ::= <template-param>
-    //                             ::= <substitution>
-    //
-    // If this is followed by some <template-args>, and we're permitted to
-    // parse them, take the second production.
-
-    if (TryToParseTemplateArgs && look() == 'I') {
-      Node *TA = getDerived().parseTemplateArgs();
-      if (TA == nullptr)
-        return nullptr;
-      Result = make<NameWithTemplateArgs>(Result, TA);
-    }
-    break;
-  }
-  //             ::= P <type>        # pointer
-  case 'P': {
-    ++First;
-    Node *Ptr = getDerived().parseType();
-    if (Ptr == nullptr)
-      return nullptr;
-    Result = make<PointerType>(Ptr);
-    break;
-  }
-  //             ::= R <type>        # l-value reference
-  case 'R': {
-    ++First;
-    Node *Ref = getDerived().parseType();
-    if (Ref == nullptr)
-      return nullptr;
-    Result = make<ReferenceType>(Ref, ReferenceKind::LValue);
-    break;
-  }
-  //             ::= O <type>        # r-value reference (C++11)
-  case 'O': {
-    ++First;
-    Node *Ref = getDerived().parseType();
-    if (Ref == nullptr)
-      return nullptr;
-    Result = make<ReferenceType>(Ref, ReferenceKind::RValue);
-    break;
-  }
-  //             ::= C <type>        # complex pair (C99)
-  case 'C': {
-    ++First;
-    Node *P = getDerived().parseType();
-    if (P == nullptr)
-      return nullptr;
-    Result = make<PostfixQualifiedType>(P, " complex");
-    break;
-  }
-  //             ::= G <type>        # imaginary (C99)
-  case 'G': {
-    ++First;
-    Node *P = getDerived().parseType();
-    if (P == nullptr)
-      return P;
-    Result = make<PostfixQualifiedType>(P, " imaginary");
-    break;
-  }
-  //             ::= <substitution>  # See Compression below
-  case 'S': {
-    if (look(1) != 't') {
-      bool IsSubst = false;
-      Result = getDerived().parseUnscopedName(nullptr, &IsSubst);
-      if (!Result)
-        return nullptr;
-
-      // Sub could be either of:
-      //   <type>        ::= <substitution>
-      //   <type>        ::= <template-template-param> <template-args>
-      //
-      //   <template-template-param> ::= <template-param>
-      //                             ::= <substitution>
-      //
-      // If this is followed by some <template-args>, and we're permitted to
-      // parse them, take the second production.
-
-      if (look() == 'I' && (!IsSubst || TryToParseTemplateArgs)) {
-        if (!IsSubst)
-          Subs.push_back(Result);
-        Node *TA = getDerived().parseTemplateArgs();
-        if (TA == nullptr)
-          return nullptr;
-        Result = make<NameWithTemplateArgs>(Result, TA);
-      } else if (IsSubst) {
-        // If all we parsed was a substitution, don't re-insert into the
-        // substitution table.
-        return Result;
-      }
-      break;
-    }
-    DEMANGLE_FALLTHROUGH;
-  }
-  //        ::= <class-enum-type>
-  default: {
-    Result = getDerived().parseClassEnumType();
-    break;
-  }
-  }
-
-  // If we parsed a type, insert it into the substitution table. Note that all
-  // <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 *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 *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);
-  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() {
-  Qualifiers CVR = QualNone;
-  if (consumeIf('r'))
-    CVR |= QualRestrict;
-  if (consumeIf('V'))
-    CVR |= QualVolatile;
-  if (consumeIf('K'))
-    CVR |= QualConst;
-  return CVR;
-}
-
-// <function-param> ::= fp <top-level CV-Qualifiers> _                                     # L == 0, first parameter
-//                  ::= fp <top-level CV-Qualifiers> <parameter-2 non-negative number> _   # L == 0, second and later parameters
-//                  ::= fL <L-1 non-negative number> p <top-level CV-Qualifiers> _         # L > 0, first parameter
-//                  ::= 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();
-    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();
-    if (!consumeIf('_'))
-      return nullptr;
-    return make<FunctionParam>(Num);
-  }
-  return nullptr;
-}
-
-// cv <type> <expression>                               # conversion with one argument
-// cv <type> _ <expression>* E                          # conversion with a different number of arguments
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseConversionExpr() {
-  if (!consumeIf("cv"))
-    return nullptr;
-  Node *Ty;
-  {
-    ScopedOverride<bool> SaveTemp(TryToParseTemplateArgs, false);
-    Ty = getDerived().parseType();
-  }
-
-  if (Ty == nullptr)
-    return nullptr;
-
-  if (consumeIf('_')) {
-    size_t ExprsBegin = Names.size();
-    while (!consumeIf('E')) {
-      Node *E = getDerived().parseExpr();
-      if (E == nullptr)
-        return E;
-      Names.push_back(E);
-    }
-    NodeArray Exprs = popTrailingNodeArray(ExprsBegin);
-    return make<ConversionExpr>(Ty, Exprs);
-  }
-
-  Node *E[1] = {getDerived().parseExpr()};
-  if (E[0] == nullptr)
-    return nullptr;
-  return make<ConversionExpr>(Ty, makeNodeArray(E, E + 1));
-}
-
-// <expr-primary> ::= L <type> <value number> E                          # integer literal
-//                ::= L <type> <value float> E                           # floating literal
-//                ::= L <string type> E                                  # string literal
-//                ::= L <nullptr type> E                                 # nullptr literal (i.e., "LDnE")
-//                ::= L <lambda type> E                                  # lambda expression
-// FIXME:         ::= L <type> <real-part float> _ <imag-part float> E   # complex floating point literal (C 2000)
-//                ::= L <mangled-name> E                                 # external name
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseExprPrimary() {
-  if (!consumeIf('L'))
-    return nullptr;
-  switch (look()) {
-  case 'w':
-    ++First;
-    return getDerived().parseIntegerLiteral("wchar_t");
-  case 'b':
-    if (consumeIf("b0E"))
-      return make<BoolExpr>(0);
-    if (consumeIf("b1E"))
-      return make<BoolExpr>(1);
-    return nullptr;
-  case 'c':
-    ++First;
-    return getDerived().parseIntegerLiteral("char");
-  case 'a':
-    ++First;
-    return getDerived().parseIntegerLiteral("signed char");
-  case 'h':
-    ++First;
-    return getDerived().parseIntegerLiteral("unsigned char");
-  case 's':
-    ++First;
-    return getDerived().parseIntegerLiteral("short");
-  case 't':
-    ++First;
-    return getDerived().parseIntegerLiteral("unsigned short");
-  case 'i':
-    ++First;
-    return getDerived().parseIntegerLiteral("");
-  case 'j':
-    ++First;
-    return getDerived().parseIntegerLiteral("u");
-  case 'l':
-    ++First;
-    return getDerived().parseIntegerLiteral("l");
-  case 'm':
-    ++First;
-    return getDerived().parseIntegerLiteral("ul");
-  case 'x':
-    ++First;
-    return getDerived().parseIntegerLiteral("ll");
-  case 'y':
-    ++First;
-    return getDerived().parseIntegerLiteral("ull");
-  case 'n':
-    ++First;
-    return getDerived().parseIntegerLiteral("__int128");
-  case 'o':
-    ++First;
-    return getDerived().parseIntegerLiteral("unsigned __int128");
-  case 'f':
-    ++First;
-    return getDerived().template parseFloatingLiteral<float>();
-  case 'd':
-    ++First;
-    return getDerived().template parseFloatingLiteral<double>();
-  case 'e':
-    ++First;
-#if defined(__powerpc__) || defined(__s390__)
-    // Handle cases where long doubles encoded with e have the same size
-    // and representation as doubles.
-    return getDerived().template parseFloatingLiteral<double>();
-#else
-    return getDerived().template parseFloatingLiteral<long double>();
-#endif
-  case '_':
-    if (consumeIf("_Z")) {
-      Node *R = getDerived().parseEncoding();
-      if (R != nullptr && consumeIf('E'))
-        return R;
-    }
-    return nullptr;
-  case 'A': {
-    Node *T = getDerived().parseType();
-    if (T == nullptr)
-      return nullptr;
-    // FIXME: We need to include the string contents in the mangling.
-    if (consumeIf('E'))
-      return make<StringLiteral>(T);
-    return nullptr;
-  }
-  case 'D':
-    if (consumeIf("Dn") && (consumeIf('0'), consumeIf('E')))
-      return make<NameType>("nullptr");
-    return nullptr;
-  case 'T':
-    // Invalid mangled name per
-    //   http://sourcerytools.com/pipermail/cxx-abi-dev/2011-August/002422.html
-    return nullptr;
-  case 'U': {
-    // FIXME: Should we support LUb... for block literals?
-    if (look(1) != 'l')
-      return nullptr;
-    Node *T = parseUnnamedTypeName(nullptr);
-    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);
-    if (N.empty())
-      return nullptr;
-    if (!consumeIf('E'))
-      return nullptr;
-    return make<EnumLiteral>(T, N);
-  }
-  }
-}
-
-// <braced-expression> ::= <expression>
-//                     ::= di <field source-name> <braced-expression>    # .name = expr
-//                     ::= dx <index expression> <braced-expression>     # [expr] = expr
-//                     ::= dX <range begin expression> <range end expression> <braced-expression>
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseBracedExpr() {
-  if (look() == 'd') {
-    switch (look(1)) {
-    case 'i': {
-      First += 2;
-      Node *Field = getDerived().parseSourceName(/*NameState=*/nullptr);
-      if (Field == nullptr)
-        return nullptr;
-      Node *Init = getDerived().parseBracedExpr();
-      if (Init == nullptr)
-        return nullptr;
-      return make<BracedExpr>(Field, Init, /*isArray=*/false);
-    }
-    case 'x': {
-      First += 2;
-      Node *Index = getDerived().parseExpr();
-      if (Index == nullptr)
-        return nullptr;
-      Node *Init = getDerived().parseBracedExpr();
-      if (Init == nullptr)
-        return nullptr;
-      return make<BracedExpr>(Index, Init, /*isArray=*/true);
-    }
-    case 'X': {
-      First += 2;
-      Node *RangeBegin = getDerived().parseExpr();
-      if (RangeBegin == nullptr)
-        return nullptr;
-      Node *RangeEnd = getDerived().parseExpr();
-      if (RangeEnd == nullptr)
-        return nullptr;
-      Node *Init = getDerived().parseBracedExpr();
-      if (Init == nullptr)
-        return nullptr;
-      return make<BracedRangeExpr>(RangeBegin, RangeEnd, Init);
-    }
-    }
-  }
-  return getDerived().parseExpr();
-}
-
-// (not yet in the spec)
-// <fold-expr> ::= fL <binary-operator-name> <expression> <expression>
-//             ::= fR <binary-operator-name> <expression> <expression>
-//             ::= fl <binary-operator-name> <expression>
-//             ::= fr <binary-operator-name> <expression>
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseFoldExpr() {
-  if (!consumeIf('f'))
-    return nullptr;
-
-  bool IsLeftFold = false, HasInitializer = false;
-  switch (look()) {
-  default:
-    return nullptr;
-  case 'L':
-    IsLeftFold = true;
-    HasInitializer = true;
-    break;
-  case 'R':
-    HasInitializer = true;
-    break;
-  case 'l':
-    IsLeftFold = true;
-    break;
-  case 'r':
-    break;
-  }
-  ++First;
-
-  const auto *Op = parseOperatorEncoding();
-  if (!Op)
-    return nullptr;
-  if (!(Op->getKind() == OperatorInfo::Binary
-        || (Op->getKind() == OperatorInfo::Member
-            && Op->getName().back() == '*')))
-    return nullptr;
-
-  Node *Pack = getDerived().parseExpr();
-  if (Pack == nullptr)
-    return nullptr;
-
-  Node *Init = nullptr;
-  if (HasInitializer) {
-    Init = getDerived().parseExpr();
-    if (Init == nullptr)
-      return nullptr;
-  }
-
-  if (IsLeftFold && Init)
-    std::swap(Pack, Init);
-
-  return make<FoldExpr>(IsLeftFold, Op->getSymbol(), Pack, Init);
-}
-
-// <expression> ::= mc <parameter type> <expr> [<offset number>] E
-//
-// Not yet in the spec: https://github.com/itanium-cxx-abi/cxx-abi/issues/47
-template <typename Derived, typename Alloc>
-Node *
-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);
-  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);
-  size_t SelectorsBegin = Names.size();
-  while (consumeIf('_')) {
-    Node *Selector = make<NameType>(parseNumber());
-    if (!Selector)
-      return nullptr;
-    Names.push_back(Selector);
-  }
-  bool OnePastTheEnd = consumeIf('p');
-  if (!consumeIf('E'))
-    return nullptr;
-  return make<SubobjectExpr>(
-      Ty, Expr, Offset, popTrailingNodeArray(SelectorsBegin), OnePastTheEnd);
-}
-
-// <expression> ::= <unary operator-name> <expression>
-//              ::= <binary operator-name> <expression> <expression>
-//              ::= <ternary operator-name> <expression> <expression> <expression>
-//              ::= cl <expression>+ E                                   # call
-//              ::= cv <type> <expression>                               # conversion with one argument
-//              ::= cv <type> _ <expression>* E                          # conversion with a different number of arguments
-//              ::= [gs] nw <expression>* _ <type> E                     # new (expr-list) type
-//              ::= [gs] nw <expression>* _ <type> <initializer>         # new (expr-list) type (init)
-//              ::= [gs] na <expression>* _ <type> E                     # new[] (expr-list) type
-//              ::= [gs] na <expression>* _ <type> <initializer>         # new[] (expr-list) type (init)
-//              ::= [gs] dl <expression>                                 # delete expression
-//              ::= [gs] da <expression>                                 # delete[] expression
-//              ::= pp_ <expression>                                     # prefix ++
-//              ::= mm_ <expression>                                     # prefix --
-//              ::= ti <type>                                            # typeid (type)
-//              ::= te <expression>                                      # typeid (expression)
-//              ::= dc <type> <expression>                               # dynamic_cast<type> (expression)
-//              ::= sc <type> <expression>                               # static_cast<type> (expression)
-//              ::= cc <type> <expression>                               # const_cast<type> (expression)
-//              ::= rc <type> <expression>                               # reinterpret_cast<type> (expression)
-//              ::= st <type>                                            # sizeof (a type)
-//              ::= sz <expression>                                      # sizeof (an expression)
-//              ::= at <type>                                            # alignof (a type)
-//              ::= az <expression>                                      # alignof (an expression)
-//              ::= nx <expression>                                      # noexcept (expression)
-//              ::= <template-param>
-//              ::= <function-param>
-//              ::= dt <expression> <unresolved-name>                    # expr.name
-//              ::= pt <expression> <unresolved-name>                    # expr->name
-//              ::= ds <expression> <expression>                         # expr.*expr
-//              ::= sZ <template-param>                                  # size of a parameter pack
-//              ::= sZ <function-param>                                  # size of a function parameter pack
-//              ::= sP <template-arg>* E                                 # sizeof...(T), size of a captured template parameter pack from an alias template
-//              ::= sp <expression>                                      # pack expansion
-//              ::= tw <expression>                                      # throw expression
-//              ::= tr                                                   # throw with no operand (rethrow)
-//              ::= <unresolved-name>                                    # f(p), N::f(p), ::f(p),
-//                                                                       # freestanding dependent name (e.g., T::x),
-//                                                                       # objectless nonstatic member reference
-//              ::= fL <binary-operator-name> <expression> <expression>
-//              ::= fR <binary-operator-name> <expression> <expression>
-//              ::= fl <binary-operator-name> <expression>
-//              ::= fr <binary-operator-name> <expression>
-//              ::= <expr-primary>
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseExpr() {
-  bool Global = consumeIf("gs");
-
-  const auto *Op = parseOperatorEncoding();
-  if (Op) {
-    auto Sym = Op->getSymbol();
-    switch (Op->getKind()) {
-    case OperatorInfo::Binary:
-      // Binary operator: lhs @ rhs
-      return getDerived().parseBinaryExpr(Sym, Op->getPrecedence());
-    case OperatorInfo::Prefix:
-      // Prefix unary operator: @ expr
-      return getDerived().parsePrefixExpr(Sym, Op->getPrecedence());
-    case OperatorInfo::Postfix: {
-      // Postfix unary operator: expr @
-      if (consumeIf('_'))
-        return getDerived().parsePrefixExpr(Sym, Op->getPrecedence());
-      Node *Ex = getDerived().parseExpr();
-      if (Ex == nullptr)
-        return nullptr;
-      return make<PostfixExpr>(Ex, Sym, Op->getPrecedence());
-    }
-    case OperatorInfo::Array: {
-      // Array Index:  lhs [ rhs ]
-      Node *Base = getDerived().parseExpr();
-      if (Base == nullptr)
-        return nullptr;
-      Node *Index = getDerived().parseExpr();
-      if (Index == nullptr)
-        return nullptr;
-      return make<ArraySubscriptExpr>(Base, Index, Op->getPrecedence());
-    }
-    case OperatorInfo::Member: {
-      // Member access lhs @ rhs
-      Node *LHS = getDerived().parseExpr();
-      if (LHS == nullptr)
-        return nullptr;
-      Node *RHS = getDerived().parseExpr();
-      if (RHS == nullptr)
-        return nullptr;
-      return make<MemberExpr>(LHS, Sym, RHS, Op->getPrecedence());
-    }
-    case OperatorInfo::New: {
-      // New
-      // # new (expr-list) type [(init)]
-      // [gs] nw <expression>* _ <type> [pi <expression>*] E
-      // # new[] (expr-list) type [(init)]
-      // [gs] na <expression>* _ <type> [pi <expression>*] E
-      size_t Exprs = Names.size();
-      while (!consumeIf('_')) {
-        Node *Ex = getDerived().parseExpr();
-        if (Ex == nullptr)
-          return nullptr;
-        Names.push_back(Ex);
-      }
-      NodeArray ExprList = popTrailingNodeArray(Exprs);
-      Node *Ty = getDerived().parseType();
-      if (Ty == nullptr)
-        return nullptr;
-      bool HaveInits = consumeIf("pi");
-      size_t InitsBegin = Names.size();
-      while (!consumeIf('E')) {
-        if (!HaveInits)
-          return nullptr;
-        Node *Init = getDerived().parseExpr();
-        if (Init == nullptr)
-          return Init;
-        Names.push_back(Init);
-      }
-      NodeArray Inits = popTrailingNodeArray(InitsBegin);
-      return make<NewExpr>(ExprList, Ty, Inits, Global,
-                           /*IsArray=*/Op->getFlag(), Op->getPrecedence());
-    }
-    case OperatorInfo::Del: {
-      // Delete
-      Node *Ex = getDerived().parseExpr();
-      if (Ex == nullptr)
-        return nullptr;
-      return make<DeleteExpr>(Ex, Global, /*IsArray=*/Op->getFlag(),
-                              Op->getPrecedence());
-    }
-    case OperatorInfo::Call: {
-      // Function Call
-      Node *Callee = getDerived().parseExpr();
-      if (Callee == nullptr)
-        return nullptr;
-      size_t ExprsBegin = Names.size();
-      while (!consumeIf('E')) {
-        Node *E = getDerived().parseExpr();
-        if (E == nullptr)
-          return nullptr;
-        Names.push_back(E);
-      }
-      return make<CallExpr>(Callee, popTrailingNodeArray(ExprsBegin),
-                            Op->getPrecedence());
-    }
-    case OperatorInfo::CCast: {
-      // C Cast: (type)expr
-      Node *Ty;
-      {
-        ScopedOverride<bool> SaveTemp(TryToParseTemplateArgs, false);
-        Ty = getDerived().parseType();
-      }
-      if (Ty == nullptr)
-        return nullptr;
-
-      size_t ExprsBegin = Names.size();
-      bool IsMany = consumeIf('_');
-      while (!consumeIf('E')) {
-        Node *E = getDerived().parseExpr();
-        if (E == nullptr)
-          return E;
-        Names.push_back(E);
-        if (!IsMany)
-          break;
-      }
-      NodeArray Exprs = popTrailingNodeArray(ExprsBegin);
-      if (!IsMany && Exprs.size() != 1)
-        return nullptr;
-      return make<ConversionExpr>(Ty, Exprs, Op->getPrecedence());
-    }
-    case OperatorInfo::Conditional: {
-      // Conditional operator: expr ? expr : expr
-      Node *Cond = getDerived().parseExpr();
-      if (Cond == nullptr)
-        return nullptr;
-      Node *LHS = getDerived().parseExpr();
-      if (LHS == nullptr)
-        return nullptr;
-      Node *RHS = getDerived().parseExpr();
-      if (RHS == nullptr)
-        return nullptr;
-      return make<ConditionalExpr>(Cond, LHS, RHS, Op->getPrecedence());
-    }
-    case OperatorInfo::NamedCast: {
-      // Named cast operation, @<type>(expr)
-      Node *Ty = getDerived().parseType();
-      if (Ty == nullptr)
-        return nullptr;
-      Node *Ex = getDerived().parseExpr();
-      if (Ex == nullptr)
-        return nullptr;
-      return make<CastExpr>(Sym, Ty, Ex, Op->getPrecedence());
-    }
-    case OperatorInfo::OfIdOp: {
-      // [sizeof/alignof/typeid] ( <type>|<expr> )
-      Node *Arg =
-          Op->getFlag() ? getDerived().parseType() : getDerived().parseExpr();
-      if (!Arg)
-        return nullptr;
-      return make<EnclosingExpr>(Sym, Arg, Op->getPrecedence());
-    }
-    case OperatorInfo::NameOnly: {
-      // Not valid as an expression operand.
-      return nullptr;
-    }
-    }
-    DEMANGLE_UNREACHABLE;
-  }
-
-  if (numLeft() < 2)
-    return nullptr;
-
-  if (look() == 'L')
-    return getDerived().parseExprPrimary();
-  if (look() == 'T')
-    return getDerived().parseTemplateParam();
-  if (look() == 'f') {
-    // Disambiguate a fold expression from a <function-param>.
-    if (look(1) == 'p' || (look(1) == 'L' && std::isdigit(look(2))))
-      return getDerived().parseFunctionParam();
-    return getDerived().parseFoldExpr();
-  }
-  if (consumeIf("il")) {
-    size_t InitsBegin = Names.size();
-    while (!consumeIf('E')) {
-      Node *E = getDerived().parseBracedExpr();
-      if (E == nullptr)
-        return nullptr;
-      Names.push_back(E);
-    }
-    return make<InitListExpr>(nullptr, popTrailingNodeArray(InitsBegin));
-  }
-  if (consumeIf("mc"))
-    return parsePointerToMemberConversionExpr(Node::Prec::Unary);
-  if (consumeIf("nx")) {
-    Node *Ex = getDerived().parseExpr();
-    if (Ex == nullptr)
-      return Ex;
-    return make<EnclosingExpr>("noexcept ", Ex, Node::Prec::Unary);
-  }
-  if (consumeIf("so"))
-    return parseSubobjectExpr();
-  if (consumeIf("sp")) {
-    Node *Child = getDerived().parseExpr();
-    if (Child == nullptr)
-      return nullptr;
-    return make<ParameterPackExpansion>(Child);
-  }
-  if (consumeIf("sZ")) {
-    if (look() == 'T') {
-      Node *R = getDerived().parseTemplateParam();
-      if (R == nullptr)
-        return nullptr;
-      return make<SizeofParamPackExpr>(R);
-    }
-    Node *FP = getDerived().parseFunctionParam();
-    if (FP == nullptr)
-      return nullptr;
-    return make<EnclosingExpr>("sizeof... ", FP);
-  }
-  if (consumeIf("sP")) {
-    size_t ArgsBegin = Names.size();
-    while (!consumeIf('E')) {
-      Node *Arg = getDerived().parseTemplateArg();
-      if (Arg == nullptr)
-        return nullptr;
-      Names.push_back(Arg);
-    }
-    auto *Pack = make<NodeArrayNode>(popTrailingNodeArray(ArgsBegin));
-    if (!Pack)
-      return nullptr;
-    return make<EnclosingExpr>("sizeof... ", Pack);
-  }
-  if (consumeIf("tl")) {
-    Node *Ty = getDerived().parseType();
-    if (Ty == nullptr)
-      return nullptr;
-    size_t InitsBegin = Names.size();
-    while (!consumeIf('E')) {
-      Node *E = getDerived().parseBracedExpr();
-      if (E == nullptr)
-        return nullptr;
-      Names.push_back(E);
-    }
-    return make<InitListExpr>(Ty, popTrailingNodeArray(InitsBegin));
-  }
-  if (consumeIf("tr"))
-    return make<NameType>("throw");
-  if (consumeIf("tw")) {
-    Node *Ex = getDerived().parseExpr();
-    if (Ex == nullptr)
-      return nullptr;
-    return make<ThrowExpr>(Ex);
-  }
-  if (consumeIf('u')) {
-    Node *Name = getDerived().parseSourceName(/*NameState=*/nullptr);
-    if (!Name)
-      return nullptr;
-    // Special case legacy __uuidof mangling. The 't' and 'z' appear where the
-    // standard encoding expects a <template-arg>, and would be otherwise be
-    // interpreted as <type> node 'short' or 'ellipsis'. However, neither
-    // __uuidof(short) nor __uuidof(...) can actually appear, so there is no
-    // actual conflict here.
-    bool IsUUID = false;
-    Node *UUID = nullptr;
-    if (Name->getBaseName() == "__uuidof") {
-      if (consumeIf('t')) {
-        UUID = getDerived().parseType();
-        IsUUID = true;
-      } else if (consumeIf('z')) {
-        UUID = getDerived().parseExpr();
-        IsUUID = true;
-      }
-    }
-    size_t ExprsBegin = Names.size();
-    if (IsUUID) {
-      if (UUID == nullptr)
-        return nullptr;
-      Names.push_back(UUID);
-    } else {
-      while (!consumeIf('E')) {
-        Node *E = getDerived().parseTemplateArg();
-        if (E == nullptr)
-          return E;
-        Names.push_back(E);
-      }
-    }
-    return make<CallExpr>(Name, popTrailingNodeArray(ExprsBegin),
-                          Node::Prec::Postfix);
-  }
-
-  // Only unresolved names remain.
-  return getDerived().parseUnresolvedName(Global);
-}
-
-// <call-offset> ::= h <nv-offset> _
-//               ::= v <v-offset> _
-//
-// <nv-offset> ::= <offset number>
-//               # non-virtual base override
-//
-// <v-offset>  ::= <offset number> _ <virtual offset number>
-//               # virtual base override, with vcall offset
-template <typename Alloc, typename Derived>
-bool AbstractManglingParser<Alloc, Derived>::parseCallOffset() {
-  // Just scan through the call offset, we never add this information into the
-  // output.
-  if (consumeIf('h'))
-    return parseNumber(true).empty() || !consumeIf('_');
-  if (consumeIf('v'))
-    return parseNumber(true).empty() || !consumeIf('_') ||
-           parseNumber(true).empty() || !consumeIf('_');
-  return true;
-}
-
-// <special-name> ::= TV <type>    # virtual table
-//                ::= TT <type>    # VTT structure (construction vtable index)
-//                ::= TI <type>    # typeinfo structure
-//                ::= TS <type>    # typeinfo name (null-terminated byte string)
-//                ::= Tc <call-offset> <call-offset> <base encoding>
-//                    # base is the nominal target function of thunk
-//                    # first call-offset is 'this' adjustment
-//                    # second call-offset is result adjustment
-//                ::= T <call-offset> <base encoding>
-//                    # base is the nominal target function of thunk
-//                # Guard variable for one-time initialization
-//                ::= GV <object name>
-//                                     # No <type>
-//                ::= TW <object name> # Thread-local wrapper
-//                ::= TH <object name> # Thread-local initialization
-//                ::= GR <object name> _             # First temporary
-//                ::= GR <object name> <seq-id> _    # Subsequent temporaries
-//                # construction vtable for second-in-first
-//      extension ::= TC <first type> <number> _ <second type>
-//      extension ::= GR <object name> # reference temporary for object
-//      extension ::= GI <module name> # module global initializer
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseSpecialName() {
-  switch (look()) {
-  case 'T':
-    switch (look(1)) {
-    // TA <template-arg>    # template parameter object
-    //
-    // Not yet in the spec: https://github.com/itanium-cxx-abi/cxx-abi/issues/63
-    case 'A': {
-      First += 2;
-      Node *Arg = getDerived().parseTemplateArg();
-      if (Arg == nullptr)
-        return nullptr;
-      return make<SpecialName>("template parameter object for ", Arg);
-    }
-    // TV <type>    # virtual table
-    case 'V': {
-      First += 2;
-      Node *Ty = getDerived().parseType();
-      if (Ty == nullptr)
-        return nullptr;
-      return make<SpecialName>("vtable for ", Ty);
-    }
-    // TT <type>    # VTT structure (construction vtable index)
-    case 'T': {
-      First += 2;
-      Node *Ty = getDerived().parseType();
-      if (Ty == nullptr)
-        return nullptr;
-      return make<SpecialName>("VTT for ", Ty);
-    }
-    // TI <type>    # typeinfo structure
-    case 'I': {
-      First += 2;
-      Node *Ty = getDerived().parseType();
-      if (Ty == nullptr)
-        return nullptr;
-      return make<SpecialName>("typeinfo for ", Ty);
-    }
-    // TS <type>    # typeinfo name (null-terminated byte string)
-    case 'S': {
-      First += 2;
-      Node *Ty = getDerived().parseType();
-      if (Ty == nullptr)
-        return nullptr;
-      return make<SpecialName>("typeinfo name for ", Ty);
-    }
-    // Tc <call-offset> <call-offset> <base encoding>
-    case 'c': {
-      First += 2;
-      if (parseCallOffset() || parseCallOffset())
-        return nullptr;
-      Node *Encoding = getDerived().parseEncoding();
-      if (Encoding == nullptr)
-        return nullptr;
-      return make<SpecialName>("covariant return thunk to ", Encoding);
-    }
-    // extension ::= TC <first type> <number> _ <second type>
-    //               # construction vtable for second-in-first
-    case 'C': {
-      First += 2;
-      Node *FirstType = getDerived().parseType();
-      if (FirstType == nullptr)
-        return nullptr;
-      if (parseNumber(true).empty() || !consumeIf('_'))
-        return nullptr;
-      Node *SecondType = getDerived().parseType();
-      if (SecondType == nullptr)
-        return nullptr;
-      return make<CtorVtableSpecialName>(SecondType, FirstType);
-    }
-    // TW <object name> # Thread-local wrapper
-    case 'W': {
-      First += 2;
-      Node *Name = getDerived().parseName();
-      if (Name == nullptr)
-        return nullptr;
-      return make<SpecialName>("thread-local wrapper routine for ", Name);
-    }
-    // TH <object name> # Thread-local initialization
-    case 'H': {
-      First += 2;
-      Node *Name = getDerived().parseName();
-      if (Name == nullptr)
-        return nullptr;
-      return make<SpecialName>("thread-local initialization routine for ", Name);
-    }
-    // T <call-offset> <base encoding>
-    default: {
-      ++First;
-      bool IsVirt = look() == 'v';
-      if (parseCallOffset())
-        return nullptr;
-      Node *BaseEncoding = getDerived().parseEncoding();
-      if (BaseEncoding == nullptr)
-        return nullptr;
-      if (IsVirt)
-        return make<SpecialName>("virtual thunk to ", BaseEncoding);
-      else
-        return make<SpecialName>("non-virtual thunk to ", BaseEncoding);
-    }
-    }
-  case 'G':
-    switch (look(1)) {
-    // GV <object name> # Guard variable for one-time initialization
-    case 'V': {
-      First += 2;
-      Node *Name = getDerived().parseName();
-      if (Name == nullptr)
-        return nullptr;
-      return make<SpecialName>("guard variable for ", Name);
-    }
-    // GR <object name> # reference temporary for object
-    // GR <object name> _             # First temporary
-    // GR <object name> <seq-id> _    # Subsequent temporaries
-    case 'R': {
-      First += 2;
-      Node *Name = getDerived().parseName();
-      if (Name == nullptr)
-        return nullptr;
-      size_t Count;
-      bool ParsedSeqId = !parseSeqId(&Count);
-      if (!consumeIf('_') && ParsedSeqId)
-        return nullptr;
-      return make<SpecialName>("reference temporary for ", Name);
-    }
-    // GI <module-name> v
-    case 'I': {
-      First += 2;
-      ModuleName *Module = nullptr;
-      if (getDerived().parseModuleNameOpt(Module))
-        return nullptr;
-      if (Module == nullptr)
-        return nullptr;
-      return make<SpecialName>("initializer for module ", Module);
-    }
-    }
-  }
-  return nullptr;
-}
-
-// <encoding> ::= <function name> <bare-function-type>
-//            ::= <data name>
-//            ::= <special-name>
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseEncoding() {
-  // The template parameters of an encoding are unrelated to those of the
-  // enclosing context.
-  class SaveTemplateParams {
-    AbstractManglingParser *Parser;
-    decltype(TemplateParams) OldParams;
-    decltype(OuterTemplateParams) OldOuterParams;
-
-  public:
-    SaveTemplateParams(AbstractManglingParser *TheParser) : Parser(TheParser) {
-      OldParams = std::move(Parser->TemplateParams);
-      OldOuterParams = std::move(Parser->OuterTemplateParams);
-      Parser->TemplateParams.clear();
-      Parser->OuterTemplateParams.clear();
-    }
-    ~SaveTemplateParams() {
-      Parser->TemplateParams = std::move(OldParams);
-      Parser->OuterTemplateParams = std::move(OldOuterParams);
-    }
-  } SaveTemplateParams(this);
-
-  if (look() == 'G' || look() == 'T')
-    return getDerived().parseSpecialName();
-
-  auto IsEndOfEncoding = [&] {
-    // The set of chars that can potentially follow an <encoding> (none of which
-    // can start a <type>). Enumerating these allows us to avoid speculative
-    // parsing.
-    return numLeft() == 0 || look() == 'E' || look() == '.' || look() == '_';
-  };
-
-  NameState NameInfo(this);
-  Node *Name = getDerived().parseName(&NameInfo);
-  if (Name == nullptr)
-    return nullptr;
-
-  if (resolveForwardTemplateRefs(NameInfo))
-    return nullptr;
-
-  if (IsEndOfEncoding())
-    return Name;
-
-  Node *Attrs = nullptr;
-  if (consumeIf("Ua9enable_ifI")) {
-    size_t BeforeArgs = Names.size();
-    while (!consumeIf('E')) {
-      Node *Arg = getDerived().parseTemplateArg();
-      if (Arg == nullptr)
-        return nullptr;
-      Names.push_back(Arg);
-    }
-    Attrs = make<EnableIfAttr>(popTrailingNodeArray(BeforeArgs));
-    if (!Attrs)
-      return nullptr;
-  }
-
-  Node *ReturnType = nullptr;
-  if (!NameInfo.CtorDtorConversion && NameInfo.EndsWithTemplateArgs) {
-    ReturnType = getDerived().parseType();
-    if (ReturnType == nullptr)
-      return nullptr;
-  }
-
-  if (consumeIf('v'))
-    return make<FunctionEncoding>(ReturnType, Name, NodeArray(),
-                                  Attrs, NameInfo.CVQualifiers,
-                                  NameInfo.ReferenceQualifier);
-
-  size_t ParamsBegin = Names.size();
-  do {
-    Node *Ty = getDerived().parseType();
-    if (Ty == nullptr)
-      return nullptr;
-    Names.push_back(Ty);
-  } while (!IsEndOfEncoding());
-
-  return make<FunctionEncoding>(ReturnType, Name,
-                                popTrailingNodeArray(ParamsBegin),
-                                Attrs, NameInfo.CVQualifiers,
-                                NameInfo.ReferenceQualifier);
-}
-
-template <class Float>
-struct FloatData;
-
-template <>
-struct FloatData<float>
-{
-    static const size_t mangled_size = 8;
-    static const size_t max_demangled_size = 24;
-    static constexpr const char* spec = "%af";
-};
-
-template <>
-struct FloatData<double>
-{
-    static const size_t mangled_size = 16;
-    static const size_t max_demangled_size = 32;
-    static constexpr const char* spec = "%a";
-};
-
-template <>
-struct FloatData<long double>
-{
-#if defined(__mips__) && defined(__mips_n64) || defined(__aarch64__) || \
-    defined(__wasm__) || defined(__riscv)
-    static const size_t mangled_size = 32;
-#elif defined(__arm__) || defined(__mips__) || defined(__hexagon__)
-    static const size_t mangled_size = 16;
-#else
-    static const size_t mangled_size = 20;  // May need to be adjusted to 16 or 24 on other platforms
-#endif
-    // `-0x1.ffffffffffffffffffffffffffffp+16383` + 'L' + '\0' == 42 bytes.
-    // 28 'f's * 4 bits == 112 bits, which is the number of mantissa bits.
-    // Negatives are one character longer than positives.
-    // `0x1.` and `p` are constant, and exponents `+16383` and `-16382` are the
-    // same length. 1 sign bit, 112 mantissa bits, and 15 exponent bits == 128.
-    static const size_t max_demangled_size = 42;
-    static constexpr const char *spec = "%LaL";
-};
-
-template <typename Alloc, typename Derived>
-template <class Float>
-Node *AbstractManglingParser<Alloc, Derived>::parseFloatingLiteral() {
-  const size_t N = FloatData<Float>::mangled_size;
-  if (numLeft() <= N)
-    return nullptr;
-  StringView Data(First, First + N);
-  for (char C : Data)
-    if (!std::isxdigit(C))
-      return nullptr;
-  First += N;
-  if (!consumeIf('E'))
-    return nullptr;
-  return make<FloatLiteralImpl<Float>>(Data);
-}
-
-// <seq-id> ::= <0-9A-Z>+
-template <typename Alloc, typename Derived>
-bool AbstractManglingParser<Alloc, Derived>::parseSeqId(size_t *Out) {
-  if (!(look() >= '0' && look() <= '9') &&
-      !(look() >= 'A' && look() <= 'Z'))
-    return true;
-
-  size_t Id = 0;
-  while (true) {
-    if (look() >= '0' && look() <= '9') {
-      Id *= 36;
-      Id += static_cast<size_t>(look() - '0');
-    } else if (look() >= 'A' && look() <= 'Z') {
-      Id *= 36;
-      Id += static_cast<size_t>(look() - 'A') + 10;
-    } else {
-      *Out = Id;
-      return false;
-    }
-    ++First;
-  }
-}
-
-// <substitution> ::= S <seq-id> _
-//                ::= S_
-// <substitution> ::= Sa # ::std::allocator
-// <substitution> ::= Sb # ::std::basic_string
-// <substitution> ::= Ss # ::std::basic_string < char,
-//                                               ::std::char_traits<char>,
-//                                               ::std::allocator<char> >
-// <substitution> ::= Si # ::std::basic_istream<char,  std::char_traits<char> >
-// <substitution> ::= So # ::std::basic_ostream<char,  std::char_traits<char> >
-// <substitution> ::= Sd # ::std::basic_iostream<char, std::char_traits<char> >
-// The St case is handled specially in parseNestedName.
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseSubstitution() {
-  if (!consumeIf('S'))
-    return nullptr;
-
-  if (look() >= 'a' && look() <= 'z') {
-    SpecialSubKind Kind;
-    switch (look()) {
-    case 'a':
-      Kind = SpecialSubKind::allocator;
-      break;
-    case 'b':
-      Kind = SpecialSubKind::basic_string;
-      break;
-    case 'd':
-      Kind = SpecialSubKind::iostream;
-      break;
-    case 'i':
-      Kind = SpecialSubKind::istream;
-      break;
-    case 'o':
-      Kind = SpecialSubKind::ostream;
-      break;
-    case 's':
-      Kind = SpecialSubKind::string;
-      break;
-    default:
-      return nullptr;
-    }
-    ++First;
-    auto *SpecialSub = make<SpecialSubstitution>(Kind);
-    if (!SpecialSub)
-      return nullptr;
-
-    // Itanium C++ ABI 5.1.2: If a name that would use a built-in <substitution>
-    // has ABI tags, the tags are appended to the substitution; the result is a
-    // substitutable component.
-    Node *WithTags = getDerived().parseAbiTags(SpecialSub);
-    if (WithTags != SpecialSub) {
-      Subs.push_back(WithTags);
-      SpecialSub = WithTags;
-    }
-    return SpecialSub;
-  }
-
-  //                ::= S_
-  if (consumeIf('_')) {
-    if (Subs.empty())
-      return nullptr;
-    return Subs[0];
-  }
-
-  //                ::= S <seq-id> _
-  size_t Index = 0;
-  if (parseSeqId(&Index))
-    return nullptr;
-  ++Index;
-  if (!consumeIf('_') || Index >= Subs.size())
-    return nullptr;
-  return Subs[Index];
-}
-
-// <template-param> ::= T_    # first template parameter
-//                  ::= T <parameter-2 non-negative number> _
-//                  ::= TL <level-1> __
-//                  ::= TL <level-1> _ <parameter-2 non-negative number> _
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseTemplateParam() {
-  if (!consumeIf('T'))
-    return nullptr;
-
-  size_t Level = 0;
-  if (consumeIf('L')) {
-    if (parsePositiveInteger(&Level))
-      return nullptr;
-    ++Level;
-    if (!consumeIf('_'))
-      return nullptr;
-  }
-
-  size_t Index = 0;
-  if (!consumeIf('_')) {
-    if (parsePositiveInteger(&Index))
-      return nullptr;
-    ++Index;
-    if (!consumeIf('_'))
-      return nullptr;
-  }
-
-  // If we're in a context where this <template-param> refers to a
-  // <template-arg> further ahead in the mangled name (currently just conversion
-  // operator types), then we should only look it up in the right context.
-  // This can only happen at the outermost level.
-  if (PermitForwardTemplateReferences && Level == 0) {
-    Node *ForwardRef = make<ForwardTemplateReference>(Index);
-    if (!ForwardRef)
-      return nullptr;
-    assert(ForwardRef->getKind() == Node::KForwardTemplateReference);
-    ForwardTemplateRefs.push_back(
-        static_cast<ForwardTemplateReference *>(ForwardRef));
-    return ForwardRef;
-  }
-
-  if (Level >= TemplateParams.size() || !TemplateParams[Level] ||
-      Index >= TemplateParams[Level]->size()) {
-    // Itanium ABI 5.1.8: In a generic lambda, uses of auto in the parameter
-    // list are mangled as the corresponding artificial template type parameter.
-    if (ParsingLambdaParamsAtLevel == Level && Level <= TemplateParams.size()) {
-      // This will be popped by the ScopedTemplateParamList in
-      // parseUnnamedTypeName.
-      if (Level == TemplateParams.size())
-        TemplateParams.push_back(nullptr);
-      return make<NameType>("auto");
-    }
-
-    return nullptr;
-  }
-
-  return (*TemplateParams[Level])[Index];
-}
-
-// <template-param-decl> ::= Ty                          # type parameter
-//                       ::= Tn <type>                   # non-type parameter
-//                       ::= Tt <template-param-decl>* E # template parameter
-//                       ::= Tp <template-param-decl>    # parameter pack
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseTemplateParamDecl() {
-  auto InventTemplateParamName = [&](TemplateParamKind Kind) {
-    unsigned Index = NumSyntheticTemplateParameters[(int)Kind]++;
-    Node *N = make<SyntheticTemplateParamName>(Kind, Index);
-    if (N) TemplateParams.back()->push_back(N);
-    return N;
-  };
-
-  if (consumeIf("Ty")) {
-    Node *Name = InventTemplateParamName(TemplateParamKind::Type);
-    if (!Name)
-      return nullptr;
-    return make<TypeTemplateParamDecl>(Name);
-  }
-
-  if (consumeIf("Tn")) {
-    Node *Name = InventTemplateParamName(TemplateParamKind::NonType);
-    if (!Name)
-      return nullptr;
-    Node *Type = parseType();
-    if (!Type)
-      return nullptr;
-    return make<NonTypeTemplateParamDecl>(Name, Type);
-  }
-
-  if (consumeIf("Tt")) {
-    Node *Name = InventTemplateParamName(TemplateParamKind::Template);
-    if (!Name)
-      return nullptr;
-    size_t ParamsBegin = Names.size();
-    ScopedTemplateParamList TemplateTemplateParamParams(this);
-    while (!consumeIf("E")) {
-      Node *P = parseTemplateParamDecl();
-      if (!P)
-        return nullptr;
-      Names.push_back(P);
-    }
-    NodeArray Params = popTrailingNodeArray(ParamsBegin);
-    return make<TemplateTemplateParamDecl>(Name, Params);
-  }
-
-  if (consumeIf("Tp")) {
-    Node *P = parseTemplateParamDecl();
-    if (!P)
-      return nullptr;
-    return make<TemplateParamPackDecl>(P);
-  }
-
-  return nullptr;
-}
-
-// <template-arg> ::= <type>                    # type or template
-//                ::= X <expression> E          # expression
-//                ::= <expr-primary>            # simple expressions
-//                ::= J <template-arg>* E       # argument pack
-//                ::= LZ <encoding> E           # extension
-template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseTemplateArg() {
-  switch (look()) {
-  case 'X': {
-    ++First;
-    Node *Arg = getDerived().parseExpr();
-    if (Arg == nullptr || !consumeIf('E'))
-      return nullptr;
-    return Arg;
-  }
-  case 'J': {
-    ++First;
-    size_t ArgsBegin = Names.size();
-    while (!consumeIf('E')) {
-      Node *Arg = getDerived().parseTemplateArg();
-      if (Arg == nullptr)
-        return nullptr;
-      Names.push_back(Arg);
-    }
-    NodeArray Args = popTrailingNodeArray(ArgsBegin);
-    return make<TemplateArgumentPack>(Args);
-  }
-  case 'L': {
-    //                ::= LZ <encoding> E           # extension
-    if (look(1) == 'Z') {
-      First += 2;
-      Node *Arg = getDerived().parseEncoding();
-      if (Arg == nullptr || !consumeIf('E'))
-        return nullptr;
-      return Arg;
-    }
-    //                ::= <expr-primary>            # simple expressions
-    return getDerived().parseExprPrimary();
-  }
-  default:
-    return getDerived().parseType();
-  }
-}
-
-// <template-args> ::= I <template-arg>* E
-//     extension, the abi says <template-arg>+
-template <typename Derived, typename Alloc>
-Node *
-AbstractManglingParser<Derived, Alloc>::parseTemplateArgs(bool TagTemplates) {
-  if (!consumeIf('I'))
-    return nullptr;
-
-  // <template-params> refer to the innermost <template-args>. Clear out any
-  // outer args that we may have inserted into TemplateParams.
-  if (TagTemplates) {
-    TemplateParams.clear();
-    TemplateParams.push_back(&OuterTemplateParams);
-    OuterTemplateParams.clear();
-  }
-
-  size_t ArgsBegin = Names.size();
-  while (!consumeIf('E')) {
-    if (TagTemplates) {
-      auto OldParams = std::move(TemplateParams);
-      Node *Arg = getDerived().parseTemplateArg();
-      TemplateParams = std::move(OldParams);
-      if (Arg == nullptr)
-        return nullptr;
-      Names.push_back(Arg);
-      Node *TableEntry = Arg;
-      if (Arg->getKind() == Node::KTemplateArgumentPack) {
-        TableEntry = make<ParameterPack>(
-            static_cast<TemplateArgumentPack*>(TableEntry)->getElements());
-        if (!TableEntry)
-          return nullptr;
-      }
-      TemplateParams.back()->push_back(TableEntry);
-    } else {
-      Node *Arg = getDerived().parseTemplateArg();
-      if (Arg == nullptr)
-        return nullptr;
-      Names.push_back(Arg);
-    }
-  }
-  return make<TemplateArgs>(popTrailingNodeArray(ArgsBegin));
-}
-
-// <mangled-name> ::= _Z <encoding>
-//                ::= <type>
-// extension      ::= ___Z <encoding> _block_invoke
-// extension      ::= ___Z <encoding> _block_invoke<decimal-digit>+
-// 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 = Last;
-    }
-    if (numLeft() != 0)
-      return nullptr;
-    return Encoding;
-  }
-
-  if (consumeIf("___Z") || consumeIf("____Z")) {
-    Node *Encoding = getDerived().parseEncoding();
-    if (Encoding == nullptr || !consumeIf("_block_invoke"))
-      return nullptr;
-    bool RequireNumber = consumeIf('_');
-    if (parseNumber().empty() && RequireNumber)
-      return nullptr;
-    if (look() == '.')
-      First = Last;
-    if (numLeft() != 0)
-      return nullptr;
-    return make<SpecialName>("invocation function for block in ", Encoding);
-  }
-
-  Node *Ty = getDerived().parseType();
-  if (numLeft() != 0)
-    return nullptr;
-  return Ty;
-}
-
-template <typename Alloc>
-struct ManglingParser : AbstractManglingParser<ManglingParser<Alloc>, Alloc> {
-  using AbstractManglingParser<ManglingParser<Alloc>,
-                               Alloc>::AbstractManglingParser;
-};
-
-DEMANGLE_NAMESPACE_END
-
-#endif // DEMANGLE_ITANIUMDEMANGLE_H
diff --git a/demangle/third_party/llvm/include/llvm/Demangle/ItaniumNodes.def b/demangle/third_party/llvm/include/llvm/Demangle/ItaniumNodes.def
deleted file mode 100644
index c0e277d5..00000000
--- a/demangle/third_party/llvm/include/llvm/Demangle/ItaniumNodes.def
+++ /dev/null
@@ -1,95 +0,0 @@
-//===--- ItaniumNodes.def ------------*- mode:c++;eval:(read-only-mode) -*-===//
-//       Do not edit! See README.txt.
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-// Define the demangler's node names
-
-#ifndef NODE
-#error Define NODE to handle nodes
-#endif
-
-NODE(NodeArrayNode)
-NODE(DotSuffix)
-NODE(VendorExtQualType)
-NODE(QualType)
-NODE(ConversionOperatorType)
-NODE(PostfixQualifiedType)
-NODE(ElaboratedTypeSpefType)
-NODE(NameType)
-NODE(AbiTagAttr)
-NODE(EnableIfAttr)
-NODE(ObjCProtoName)
-NODE(PointerType)
-NODE(ReferenceType)
-NODE(PointerToMemberType)
-NODE(ArrayType)
-NODE(FunctionType)
-NODE(NoexceptSpec)
-NODE(DynamicExceptionSpec)
-NODE(FunctionEncoding)
-NODE(LiteralOperator)
-NODE(SpecialName)
-NODE(CtorVtableSpecialName)
-NODE(QualifiedName)
-NODE(NestedName)
-NODE(LocalName)
-NODE(ModuleName)
-NODE(ModuleEntity)
-NODE(VectorType)
-NODE(PixelVectorType)
-NODE(BinaryFPType)
-NODE(BitIntType)
-NODE(SyntheticTemplateParamName)
-NODE(TypeTemplateParamDecl)
-NODE(NonTypeTemplateParamDecl)
-NODE(TemplateTemplateParamDecl)
-NODE(TemplateParamPackDecl)
-NODE(ParameterPack)
-NODE(TemplateArgumentPack)
-NODE(ParameterPackExpansion)
-NODE(TemplateArgs)
-NODE(ForwardTemplateReference)
-NODE(NameWithTemplateArgs)
-NODE(GlobalQualifiedName)
-NODE(ExpandedSpecialSubstitution)
-NODE(SpecialSubstitution)
-NODE(CtorDtorName)
-NODE(DtorName)
-NODE(UnnamedTypeName)
-NODE(ClosureTypeName)
-NODE(StructuredBindingName)
-NODE(BinaryExpr)
-NODE(ArraySubscriptExpr)
-NODE(PostfixExpr)
-NODE(ConditionalExpr)
-NODE(MemberExpr)
-NODE(SubobjectExpr)
-NODE(EnclosingExpr)
-NODE(CastExpr)
-NODE(SizeofParamPackExpr)
-NODE(CallExpr)
-NODE(NewExpr)
-NODE(DeleteExpr)
-NODE(PrefixExpr)
-NODE(FunctionParam)
-NODE(ConversionExpr)
-NODE(PointerToMemberConversionExpr)
-NODE(InitListExpr)
-NODE(FoldExpr)
-NODE(ThrowExpr)
-NODE(BoolExpr)
-NODE(StringLiteral)
-NODE(LambdaExpr)
-NODE(EnumLiteral)
-NODE(IntegerLiteral)
-NODE(FloatLiteral)
-NODE(DoubleLiteral)
-NODE(LongDoubleLiteral)
-NODE(BracedExpr)
-NODE(BracedRangeExpr)
-
-#undef NODE
diff --git a/demangle/third_party/llvm/include/llvm/Demangle/MicrosoftDemangle.h b/demangle/third_party/llvm/include/llvm/Demangle/MicrosoftDemangle.h
deleted file mode 100644
index f1a5e1b6..00000000
--- a/demangle/third_party/llvm/include/llvm/Demangle/MicrosoftDemangle.h
+++ /dev/null
@@ -1,276 +0,0 @@
-//===------------------------- 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 <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
-// STL containers.
-constexpr size_t AllocUnit = 4096;
-
-class ArenaAllocator {
-  struct AllocatorNode {
-    uint8_t *Buf = nullptr;
-    size_t Used = 0;
-    size_t Capacity = 0;
-    AllocatorNode *Next = nullptr;
-  };
-
-  void addNode(size_t Capacity) {
-    AllocatorNode *NewHead = new AllocatorNode;
-    NewHead->Buf = new uint8_t[Capacity];
-    NewHead->Next = Head;
-    NewHead->Capacity = Capacity;
-    Head = NewHead;
-    NewHead->Used = 0;
-  }
-
-public:
-  ArenaAllocator() { addNode(AllocUnit); }
-
-  ~ArenaAllocator() {
-    while (Head) {
-      assert(Head->Buf);
-      delete[] Head->Buf;
-      AllocatorNode *Next = Head->Next;
-      delete Head;
-      Head = Next;
-    }
-  }
-
-  char *allocUnalignedBuffer(size_t Size) {
-    assert(Head && Head->Buf);
-
-    uint8_t *P = Head->Buf + Head->Used;
-
-    Head->Used += Size;
-    if (Head->Used <= Head->Capacity)
-      return reinterpret_cast<char *>(P);
-
-    addNode(std::max(AllocUnit, Size));
-    Head->Used = Size;
-    return reinterpret_cast<char *>(Head->Buf);
-  }
-
-  template <typename T, typename... Args> T *allocArray(size_t Count) {
-    size_t Size = Count * sizeof(T);
-    assert(Head && Head->Buf);
-
-    size_t P = (size_t)Head->Buf + Head->Used;
-    uintptr_t AlignedP =
-        (((size_t)P + alignof(T) - 1) & ~(size_t)(alignof(T) - 1));
-    uint8_t *PP = (uint8_t *)AlignedP;
-    size_t Adjustment = AlignedP - P;
-
-    Head->Used += Size + Adjustment;
-    if (Head->Used <= Head->Capacity)
-      return new (PP) T[Count]();
-
-    addNode(std::max(AllocUnit, Size));
-    Head->Used = Size;
-    return new (Head->Buf) T[Count]();
-  }
-
-  template <typename T, typename... Args> T *alloc(Args &&... ConstructorArgs) {
-    constexpr size_t Size = sizeof(T);
-    assert(Head && Head->Buf);
-
-    size_t P = (size_t)Head->Buf + Head->Used;
-    uintptr_t AlignedP =
-        (((size_t)P + alignof(T) - 1) & ~(size_t)(alignof(T) - 1));
-    uint8_t *PP = (uint8_t *)AlignedP;
-    size_t Adjustment = AlignedP - P;
-
-    Head->Used += Size + Adjustment;
-    if (Head->Used <= Head->Capacity)
-      return new (PP) T(std::forward<Args>(ConstructorArgs)...);
-
-    static_assert(Size < AllocUnit);
-    addNode(AllocUnit);
-    Head->Used = Size;
-    return new (Head->Buf) T(std::forward<Args>(ConstructorArgs)...);
-  }
-
-private:
-  AllocatorNode *Head = nullptr;
-};
-
-struct BackrefContext {
-  static constexpr size_t Max = 10;
-
-  TypeNode *FunctionParams[Max];
-  size_t FunctionParamCount = 0;
-
-  // The first 10 BackReferences in a mangled name can be back-referenced by
-  // special name @[0-9]. This is a storage for the first 10 BackReferences.
-  NamedIdentifierNode *Names[Max];
-  size_t NamesCount = 0;
-};
-
-enum class QualifierMangleMode { Drop, Mangle, Result };
-
-enum NameBackrefBehavior : uint8_t {
-  NBB_None = 0,          // don't save any names as backrefs.
-  NBB_Template = 1 << 0, // save template instanations.
-  NBB_Simple = 1 << 1,   // save simple names.
-};
-
-enum class FunctionIdentifierCodeGroup { Basic, Under, DoubleUnder };
-
-// Demangler class takes the main role in demangling symbols.
-// It has a set of functions to parse mangled symbols into Type instances.
-// 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);
-
-  TagTypeNode *parseTagUniqueName(StringView &MangledName);
-
-  // True if an error occurred.
-  bool Error = false;
-
-  void dumpBackReferences();
-
-private:
-  SymbolNode *demangleEncodedSymbol(StringView &MangledName,
-                                    QualifiedNameNode *QN);
-  SymbolNode *demangleDeclarator(StringView &MangledName);
-  SymbolNode *demangleMD5Name(StringView &MangledName);
-  SymbolNode *demangleTypeinfoName(StringView &MangledName);
-
-  VariableSymbolNode *demangleVariableEncoding(StringView &MangledName,
-                                               StorageClass SC);
-  FunctionSymbolNode *demangleFunctionEncoding(StringView &MangledName);
-
-  Qualifiers demanglePointerExtQualifiers(StringView &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,
-                                              bool HasThisQuals);
-
-  ArrayTypeNode *demangleArrayType(StringView &MangledName);
-
-  NodeArrayNode *demangleFunctionParameterList(StringView &MangledName,
-                                               bool &IsVariadic);
-  NodeArrayNode *demangleTemplateParameterList(StringView &MangledName);
-
-  std::pair<uint64_t, bool> demangleNumber(StringView &MangledName);
-  uint64_t demangleUnsigned(StringView &MangledName);
-  int64_t demangleSigned(StringView &MangledName);
-
-  void memorizeString(StringView s);
-  void memorizeIdentifier(IdentifierNode *Identifier);
-
-  /// Allocate a copy of \p Borrowed into memory that we own.
-  StringView copyString(StringView Borrowed);
-
-  QualifiedNameNode *demangleFullyQualifiedTypeName(StringView &MangledName);
-  QualifiedNameNode *demangleFullyQualifiedSymbolName(StringView &MangledName);
-
-  IdentifierNode *demangleUnqualifiedTypeName(StringView &MangledName,
-                                              bool Memorize);
-  IdentifierNode *demangleUnqualifiedSymbolName(StringView &MangledName,
-                                                NameBackrefBehavior NBB);
-
-  QualifiedNameNode *demangleNameScopeChain(StringView &MangledName,
-                                            IdentifierNode *UnqualifiedName);
-  IdentifierNode *demangleNameScopePiece(StringView &MangledName);
-
-  NamedIdentifierNode *demangleBackRefName(StringView &MangledName);
-  IdentifierNode *demangleTemplateInstantiationName(StringView &MangledName,
-                                                    NameBackrefBehavior NBB);
-  IntrinsicFunctionKind
-  translateIntrinsicFunctionCode(char CH, FunctionIdentifierCodeGroup Group);
-  IdentifierNode *demangleFunctionIdentifierCode(StringView &MangledName);
-  IdentifierNode *
-  demangleFunctionIdentifierCode(StringView &MangledName,
-                                 FunctionIdentifierCodeGroup Group);
-  StructorIdentifierNode *demangleStructorIdentifier(StringView &MangledName,
-                                                     bool IsDestructor);
-  ConversionOperatorIdentifierNode *
-  demangleConversionOperatorIdentifier(StringView &MangledName);
-  LiteralOperatorIdentifierNode *
-  demangleLiteralOperatorIdentifier(StringView &MangledName);
-
-  SymbolNode *demangleSpecialIntrinsic(StringView &MangledName);
-  SpecialTableSymbolNode *
-  demangleSpecialTableSymbolNode(StringView &MangledName,
-                                 SpecialIntrinsicKind SIK);
-  LocalStaticGuardVariableNode *
-  demangleLocalStaticGuard(StringView &MangledName, bool IsThread);
-  VariableSymbolNode *demangleUntypedVariable(ArenaAllocator &Arena,
-                                              StringView &MangledName,
-                                              StringView VariableName);
-  VariableSymbolNode *
-  demangleRttiBaseClassDescriptorNode(ArenaAllocator &Arena,
-                                      StringView &MangledName);
-  FunctionSymbolNode *demangleInitFiniStub(StringView &MangledName,
-                                           bool IsDestructor);
-
-  NamedIdentifierNode *demangleSimpleName(StringView &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);
-
-  std::pair<Qualifiers, bool> demangleQualifiers(StringView &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.
-  //  void foo(int *, int*);
-  //
-  //  // Second int* is not a back-ref to first (first is not a function param).
-  //  int* foo(int*);
-  //
-  //  // Second int* is a back-ref to first (ALL function types share the same
-  //  // back-ref map.
-  //  using F = void(*)(int*);
-  //  F G(int *);
-  BackrefContext Backrefs;
-};
-
-} // namespace ms_demangle
-} // namespace llvm
-
-#endif // LLVM_DEMANGLE_MICROSOFTDEMANGLE_H
diff --git a/demangle/third_party/llvm/include/llvm/Demangle/MicrosoftDemangleNodes.h b/demangle/third_party/llvm/include/llvm/Demangle/MicrosoftDemangleNodes.h
deleted file mode 100644
index 8ad24723..00000000
--- a/demangle/third_party/llvm/include/llvm/Demangle/MicrosoftDemangleNodes.h
+++ /dev/null
@@ -1,629 +0,0 @@
-//===- 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>
-
-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,
-  Q_Volatile = 1 << 1,
-  Q_Far = 1 << 2,
-  Q_Huge = 1 << 3,
-  Q_Unaligned = 1 << 4,
-  Q_Restrict = 1 << 5,
-  Q_Pointer64 = 1 << 6
-};
-
-enum class StorageClass : uint8_t {
-  None,
-  PrivateStatic,
-  ProtectedStatic,
-  PublicStatic,
-  Global,
-  FunctionLocalStatic,
-};
-
-enum class PointerAffinity { None, Pointer, Reference, RValueReference };
-enum class FunctionRefQualifier { None, Reference, RValueReference };
-
-// Calling conventions
-enum class CallingConv : uint8_t {
-  None,
-  Cdecl,
-  Pascal,
-  Thiscall,
-  Stdcall,
-  Fastcall,
-  Clrcall,
-  Eabi,
-  Vectorcall,
-  Regcall,
-  Swift,      // Clang-only
-  SwiftAsync, // Clang-only
-};
-
-enum class ReferenceKind : uint8_t { None, LValueRef, RValueRef };
-
-enum OutputFlags {
-  OF_Default = 0,
-  OF_NoCallingConvention = 1,
-  OF_NoTagSpecifier = 2,
-  OF_NoAccessSpecifier = 4,
-  OF_NoMemberType = 8,
-  OF_NoReturnType = 16,
-  OF_NoVariableType = 32,
-};
-
-// Types
-enum class PrimitiveKind {
-  Void,
-  Bool,
-  Char,
-  Schar,
-  Uchar,
-  Char8,
-  Char16,
-  Char32,
-  Short,
-  Ushort,
-  Int,
-  Uint,
-  Long,
-  Ulong,
-  Int64,
-  Uint64,
-  Wchar,
-  Float,
-  Double,
-  Ldouble,
-  Nullptr,
-};
-
-enum class CharKind {
-  Char,
-  Char16,
-  Char32,
-  Wchar,
-};
-
-enum class IntrinsicFunctionKind : uint8_t {
-  None,
-  New,                        // ?2 # operator new
-  Delete,                     // ?3 # operator delete
-  Assign,                     // ?4 # operator=
-  RightShift,                 // ?5 # operator>>
-  LeftShift,                  // ?6 # operator<<
-  LogicalNot,                 // ?7 # operator!
-  Equals,                     // ?8 # operator==
-  NotEquals,                  // ?9 # operator!=
-  ArraySubscript,             // ?A # operator[]
-  Pointer,                    // ?C # operator->
-  Dereference,                // ?D # operator*
-  Increment,                  // ?E # operator++
-  Decrement,                  // ?F # operator--
-  Minus,                      // ?G # operator-
-  Plus,                       // ?H # operator+
-  BitwiseAnd,                 // ?I # operator&
-  MemberPointer,              // ?J # operator->*
-  Divide,                     // ?K # operator/
-  Modulus,                    // ?L # operator%
-  LessThan,                   // ?M operator<
-  LessThanEqual,              // ?N operator<=
-  GreaterThan,                // ?O operator>
-  GreaterThanEqual,           // ?P operator>=
-  Comma,                      // ?Q operator,
-  Parens,                     // ?R operator()
-  BitwiseNot,                 // ?S operator~
-  BitwiseXor,                 // ?T operator^
-  BitwiseOr,                  // ?U operator|
-  LogicalAnd,                 // ?V operator&&
-  LogicalOr,                  // ?W operator||
-  TimesEqual,                 // ?X operator*=
-  PlusEqual,                  // ?Y operator+=
-  MinusEqual,                 // ?Z operator-=
-  DivEqual,                   // ?_0 operator/=
-  ModEqual,                   // ?_1 operator%=
-  RshEqual,                   // ?_2 operator>>=
-  LshEqual,                   // ?_3 operator<<=
-  BitwiseAndEqual,            // ?_4 operator&=
-  BitwiseOrEqual,             // ?_5 operator|=
-  BitwiseXorEqual,            // ?_6 operator^=
-  VbaseDtor,                  // ?_D # vbase destructor
-  VecDelDtor,                 // ?_E # vector deleting destructor
-  DefaultCtorClosure,         // ?_F # default constructor closure
-  ScalarDelDtor,              // ?_G # scalar deleting destructor
-  VecCtorIter,                // ?_H # vector constructor iterator
-  VecDtorIter,                // ?_I # vector destructor iterator
-  VecVbaseCtorIter,           // ?_J # vector vbase constructor iterator
-  VdispMap,                   // ?_K # virtual displacement map
-  EHVecCtorIter,              // ?_L # eh vector constructor iterator
-  EHVecDtorIter,              // ?_M # eh vector destructor iterator
-  EHVecVbaseCtorIter,         // ?_N # eh vector vbase constructor iterator
-  CopyCtorClosure,            // ?_O # copy constructor closure
-  LocalVftableCtorClosure,    // ?_T # local vftable constructor closure
-  ArrayNew,                   // ?_U operator new[]
-  ArrayDelete,                // ?_V operator delete[]
-  ManVectorCtorIter,          // ?__A managed vector ctor iterator
-  ManVectorDtorIter,          // ?__B managed vector dtor iterator
-  EHVectorCopyCtorIter,       // ?__C EH vector copy ctor iterator
-  EHVectorVbaseCopyCtorIter,  // ?__D EH vector vbase copy ctor iterator
-  VectorCopyCtorIter,         // ?__G vector copy constructor iterator
-  VectorVbaseCopyCtorIter,    // ?__H vector vbase copy constructor iterator
-  ManVectorVbaseCopyCtorIter, // ?__I managed vector vbase copy constructor
-  CoAwait,                    // ?__L operator co_await
-  Spaceship,                  // ?__M operator<=>
-  MaxIntrinsic
-};
-
-enum class SpecialIntrinsicKind {
-  None,
-  Vftable,
-  Vbtable,
-  Typeof,
-  VcallThunk,
-  LocalStaticGuard,
-  StringLiteralSymbol,
-  UdtReturning,
-  Unknown,
-  DynamicInitializer,
-  DynamicAtexitDestructor,
-  RttiTypeDescriptor,
-  RttiBaseClassDescriptor,
-  RttiBaseClassArray,
-  RttiClassHierarchyDescriptor,
-  RttiCompleteObjLocator,
-  LocalVftable,
-  LocalStaticThreadGuard,
-};
-
-// Function classes
-enum FuncClass : uint16_t {
-  FC_None = 0,
-  FC_Public = 1 << 0,
-  FC_Protected = 1 << 1,
-  FC_Private = 1 << 2,
-  FC_Global = 1 << 3,
-  FC_Static = 1 << 4,
-  FC_Virtual = 1 << 5,
-  FC_Far = 1 << 6,
-  FC_ExternC = 1 << 7,
-  FC_NoParameterList = 1 << 8,
-  FC_VirtualThisAdjust = 1 << 9,
-  FC_VirtualThisAdjustEx = 1 << 10,
-  FC_StaticThisAdjust = 1 << 11,
-};
-
-enum class TagKind { Class, Struct, Union, Enum };
-
-enum class NodeKind {
-  Unknown,
-  Md5Symbol,
-  PrimitiveType,
-  FunctionSignature,
-  Identifier,
-  NamedIdentifier,
-  VcallThunkIdentifier,
-  LocalStaticGuardIdentifier,
-  IntrinsicFunctionIdentifier,
-  ConversionOperatorIdentifier,
-  DynamicStructorIdentifier,
-  StructorIdentifier,
-  LiteralOperatorIdentifier,
-  ThunkSignature,
-  PointerType,
-  TagType,
-  ArrayType,
-  Custom,
-  IntrinsicType,
-  NodeArray,
-  QualifiedName,
-  TemplateParameterReference,
-  EncodedStringLiteral,
-  IntegerLiteral,
-  RttiBaseClassDescriptor,
-  LocalStaticGuardVariable,
-  FunctionSymbol,
-  VariableSymbol,
-  SpecialTableSymbol
-};
-
-struct Node {
-  explicit Node(NodeKind K) : Kind(K) {}
-  virtual ~Node() = default;
-
-  NodeKind kind() const { return Kind; }
-
-  virtual void output(OutputBuffer &OB, OutputFlags Flags) const = 0;
-
-  std::string toString(OutputFlags Flags = OF_Default) const;
-
-private:
-  NodeKind Kind;
-};
-
-struct TypeNode;
-struct PrimitiveTypeNode;
-struct FunctionSignatureNode;
-struct IdentifierNode;
-struct NamedIdentifierNode;
-struct VcallThunkIdentifierNode;
-struct IntrinsicFunctionIdentifierNode;
-struct LiteralOperatorIdentifierNode;
-struct ConversionOperatorIdentifierNode;
-struct StructorIdentifierNode;
-struct ThunkSignatureNode;
-struct PointerTypeNode;
-struct ArrayTypeNode;
-struct TagTypeNode;
-struct NodeArrayNode;
-struct QualifiedNameNode;
-struct TemplateParameterReferenceNode;
-struct EncodedStringLiteralNode;
-struct IntegerLiteralNode;
-struct RttiBaseClassDescriptorNode;
-struct LocalStaticGuardVariableNode;
-struct SymbolNode;
-struct FunctionSymbolNode;
-struct VariableSymbolNode;
-struct SpecialTableSymbolNode;
-
-struct TypeNode : public Node {
-  explicit TypeNode(NodeKind K) : Node(K) {}
-
-  virtual void outputPre(OutputBuffer &OB, OutputFlags Flags) const = 0;
-  virtual void outputPost(OutputBuffer &OB, OutputFlags Flags) const = 0;
-
-  void output(OutputBuffer &OB, OutputFlags Flags) const override {
-    outputPre(OB, Flags);
-    outputPost(OB, Flags);
-  }
-
-  Qualifiers Quals = Q_None;
-};
-
-struct PrimitiveTypeNode : public TypeNode {
-  explicit PrimitiveTypeNode(PrimitiveKind K)
-      : TypeNode(NodeKind::PrimitiveType), PrimKind(K) {}
-
-  void outputPre(OutputBuffer &OB, OutputFlags Flags) const override;
-  void outputPost(OutputBuffer &OB, OutputFlags Flags) const override {}
-
-  PrimitiveKind PrimKind;
-};
-
-struct FunctionSignatureNode : public TypeNode {
-  explicit FunctionSignatureNode(NodeKind K) : TypeNode(K) {}
-  FunctionSignatureNode() : TypeNode(NodeKind::FunctionSignature) {}
-
-  void outputPre(OutputBuffer &OB, OutputFlags Flags) const override;
-  void outputPost(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  // Valid if this FunctionTypeNode is the Pointee of a PointerType or
-  // MemberPointerType.
-  PointerAffinity Affinity = PointerAffinity::None;
-
-  // The function's calling convention.
-  CallingConv CallConvention = CallingConv::None;
-
-  // Function flags (gloabl, public, etc)
-  FuncClass FunctionClass = FC_Global;
-
-  FunctionRefQualifier RefQualifier = FunctionRefQualifier::None;
-
-  // The return type of the function.
-  TypeNode *ReturnType = nullptr;
-
-  // True if this is a C-style ... varargs function.
-  bool IsVariadic = false;
-
-  // Function parameters
-  NodeArrayNode *Params = nullptr;
-
-  // True if the function type is noexcept.
-  bool IsNoexcept = false;
-};
-
-struct IdentifierNode : public Node {
-  explicit IdentifierNode(NodeKind K) : Node(K) {}
-
-  NodeArrayNode *TemplateParams = nullptr;
-
-protected:
-  void outputTemplateParameters(OutputBuffer &OB, OutputFlags Flags) const;
-};
-
-struct VcallThunkIdentifierNode : public IdentifierNode {
-  VcallThunkIdentifierNode() : IdentifierNode(NodeKind::VcallThunkIdentifier) {}
-
-  void output(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  uint64_t OffsetInVTable = 0;
-};
-
-struct DynamicStructorIdentifierNode : public IdentifierNode {
-  DynamicStructorIdentifierNode()
-      : IdentifierNode(NodeKind::DynamicStructorIdentifier) {}
-
-  void output(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  VariableSymbolNode *Variable = nullptr;
-  QualifiedNameNode *Name = nullptr;
-  bool IsDestructor = false;
-};
-
-struct NamedIdentifierNode : public IdentifierNode {
-  NamedIdentifierNode() : IdentifierNode(NodeKind::NamedIdentifier) {}
-
-  void output(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  StringView 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;
-};
-
-struct LocalStaticGuardIdentifierNode : public IdentifierNode {
-  LocalStaticGuardIdentifierNode()
-      : IdentifierNode(NodeKind::LocalStaticGuardIdentifier) {}
-
-  void output(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  bool IsThread = false;
-  uint32_t ScopeIndex = 0;
-};
-
-struct ConversionOperatorIdentifierNode : public IdentifierNode {
-  ConversionOperatorIdentifierNode()
-      : IdentifierNode(NodeKind::ConversionOperatorIdentifier) {}
-
-  void output(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  // The type that this operator converts too.
-  TypeNode *TargetType = nullptr;
-};
-
-struct StructorIdentifierNode : public IdentifierNode {
-  StructorIdentifierNode() : IdentifierNode(NodeKind::StructorIdentifier) {}
-  explicit StructorIdentifierNode(bool IsDestructor)
-      : IdentifierNode(NodeKind::StructorIdentifier),
-        IsDestructor(IsDestructor) {}
-
-  void output(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  // The name of the class that this is a structor of.
-  IdentifierNode *Class = nullptr;
-  bool IsDestructor = false;
-};
-
-struct ThunkSignatureNode : public FunctionSignatureNode {
-  ThunkSignatureNode() : FunctionSignatureNode(NodeKind::ThunkSignature) {}
-
-  void outputPre(OutputBuffer &OB, OutputFlags Flags) const override;
-  void outputPost(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  struct ThisAdjustor {
-    uint32_t StaticOffset = 0;
-    int32_t VBPtrOffset = 0;
-    int32_t VBOffsetOffset = 0;
-    int32_t VtordispOffset = 0;
-  };
-
-  ThisAdjustor ThisAdjust;
-};
-
-struct PointerTypeNode : public TypeNode {
-  PointerTypeNode() : TypeNode(NodeKind::PointerType) {}
-  void outputPre(OutputBuffer &OB, OutputFlags Flags) const override;
-  void outputPost(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  // Is this a pointer, reference, or rvalue-reference?
-  PointerAffinity Affinity = PointerAffinity::None;
-
-  // If this is a member pointer, this is the class that the member is in.
-  QualifiedNameNode *ClassParent = nullptr;
-
-  // Represents a type X in "a pointer to X", "a reference to X", or
-  // "rvalue-reference to X"
-  TypeNode *Pointee = nullptr;
-};
-
-struct TagTypeNode : public TypeNode {
-  explicit TagTypeNode(TagKind Tag) : TypeNode(NodeKind::TagType), Tag(Tag) {}
-
-  void outputPre(OutputBuffer &OB, OutputFlags Flags) const override;
-  void outputPost(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  QualifiedNameNode *QualifiedName = nullptr;
-  TagKind Tag;
-};
-
-struct ArrayTypeNode : public TypeNode {
-  ArrayTypeNode() : TypeNode(NodeKind::ArrayType) {}
-
-  void outputPre(OutputBuffer &OB, OutputFlags Flags) const override;
-  void outputPost(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  void outputDimensionsImpl(OutputBuffer &OB, OutputFlags Flags) const;
-  void outputOneDimension(OutputBuffer &OB, OutputFlags Flags, Node *N) const;
-
-  // A list of array dimensions.  e.g. [3,4,5] in `int Foo[3][4][5]`
-  NodeArrayNode *Dimensions = nullptr;
-
-  // The type of array element.
-  TypeNode *ElementType = nullptr;
-};
-
-struct IntrinsicNode : public TypeNode {
-  IntrinsicNode() : TypeNode(NodeKind::IntrinsicType) {}
-  void output(OutputBuffer &OB, OutputFlags Flags) const override {}
-};
-
-struct CustomTypeNode : public TypeNode {
-  CustomTypeNode() : TypeNode(NodeKind::Custom) {}
-
-  void outputPre(OutputBuffer &OB, OutputFlags Flags) const override;
-  void outputPost(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  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;
-
-  Node **Nodes = nullptr;
-  size_t Count = 0;
-};
-
-struct QualifiedNameNode : public Node {
-  QualifiedNameNode() : Node(NodeKind::QualifiedName) {}
-
-  void output(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  NodeArrayNode *Components = nullptr;
-
-  IdentifierNode *getUnqualifiedIdentifier() {
-    Node *LastComponent = Components->Nodes[Components->Count - 1];
-    return static_cast<IdentifierNode *>(LastComponent);
-  }
-};
-
-struct TemplateParameterReferenceNode : public Node {
-  TemplateParameterReferenceNode()
-      : Node(NodeKind::TemplateParameterReference) {}
-
-  void output(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  SymbolNode *Symbol = nullptr;
-
-  int ThunkOffsetCount = 0;
-  std::array<int64_t, 3> ThunkOffsets;
-  PointerAffinity Affinity = PointerAffinity::None;
-  bool IsMemberPointer = false;
-};
-
-struct IntegerLiteralNode : public Node {
-  IntegerLiteralNode() : Node(NodeKind::IntegerLiteral) {}
-  IntegerLiteralNode(uint64_t Value, bool IsNegative)
-      : Node(NodeKind::IntegerLiteral), Value(Value), IsNegative(IsNegative) {}
-
-  void output(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  uint64_t Value = 0;
-  bool IsNegative = false;
-};
-
-struct RttiBaseClassDescriptorNode : public IdentifierNode {
-  RttiBaseClassDescriptorNode()
-      : IdentifierNode(NodeKind::RttiBaseClassDescriptor) {}
-
-  void output(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  uint32_t NVOffset = 0;
-  int32_t VBPtrOffset = 0;
-  uint32_t VBTableOffset = 0;
-  uint32_t Flags = 0;
-};
-
-struct SymbolNode : public Node {
-  explicit SymbolNode(NodeKind K) : Node(K) {}
-  void output(OutputBuffer &OB, OutputFlags Flags) const override;
-  QualifiedNameNode *Name = nullptr;
-};
-
-struct SpecialTableSymbolNode : public SymbolNode {
-  explicit SpecialTableSymbolNode()
-      : SymbolNode(NodeKind::SpecialTableSymbol) {}
-
-  void output(OutputBuffer &OB, OutputFlags Flags) const override;
-  QualifiedNameNode *TargetName = nullptr;
-  Qualifiers Quals = Qualifiers::Q_None;
-};
-
-struct LocalStaticGuardVariableNode : public SymbolNode {
-  LocalStaticGuardVariableNode()
-      : SymbolNode(NodeKind::LocalStaticGuardVariable) {}
-
-  void output(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  bool IsVisible = false;
-};
-
-struct EncodedStringLiteralNode : public SymbolNode {
-  EncodedStringLiteralNode() : SymbolNode(NodeKind::EncodedStringLiteral) {}
-
-  void output(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  StringView DecodedString;
-  bool IsTruncated = false;
-  CharKind Char = CharKind::Char;
-};
-
-struct VariableSymbolNode : public SymbolNode {
-  VariableSymbolNode() : SymbolNode(NodeKind::VariableSymbol) {}
-
-  void output(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  StorageClass SC = StorageClass::None;
-  TypeNode *Type = nullptr;
-};
-
-struct FunctionSymbolNode : public SymbolNode {
-  FunctionSymbolNode() : SymbolNode(NodeKind::FunctionSymbol) {}
-
-  void output(OutputBuffer &OB, OutputFlags Flags) const override;
-
-  FunctionSignatureNode *Signature = nullptr;
-};
-
-} // namespace ms_demangle
-} // namespace llvm
-
-#endif
diff --git a/demangle/third_party/llvm/include/llvm/Demangle/StringView.h b/demangle/third_party/llvm/include/llvm/Demangle/StringView.h
deleted file mode 100644
index 6bbb8837..00000000
--- a/demangle/third_party/llvm/include/llvm/Demangle/StringView.h
+++ /dev/null
@@ -1,122 +0,0 @@
-//===--- StringView.h ----------------*- mode:c++;eval:(read-only-mode) -*-===//
-//       Do not edit! See README.txt.
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-// FIXME: Use std::string_view instead when we support C++17.
-// There are two copies of this file in the source tree.  The one under
-// 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_STRINGVIEW_H
-#define DEMANGLE_STRINGVIEW_H
-
-#include "DemangleConfig.h"
-#include <cassert>
-#include <cstring>
-
-DEMANGLE_NAMESPACE_BEGIN
-
-class StringView {
-  const char *First;
-  const char *Last;
-
-public:
-  static const size_t npos = ~size_t(0);
-
-  template <size_t N>
-  StringView(const char (&Str)[N]) : First(Str), Last(Str + N - 1) {}
-  StringView(const char *First_, const char *Last_)
-      : First(First_), Last(Last_) {}
-  StringView(const char *First_, size_t Len)
-      : First(First_), Last(First_ + Len) {}
-  StringView(const char *Str) : First(Str), Last(Str + std::strlen(Str)) {}
-  StringView() : First(nullptr), Last(nullptr) {}
-
-  StringView substr(size_t Pos, size_t Len = npos) const {
-    assert(Pos <= size());
-    if (Len > size() - Pos)
-      Len = size() - Pos;
-    return StringView(begin() + Pos, Len);
-  }
-
-  size_t find(char C, size_t From = 0) const {
-    // Avoid calling memchr with nullptr.
-    if (From < size()) {
-      // Just forward to memchr, which is faster than a hand-rolled loop.
-      if (const void *P = ::memchr(First + From, C, size() - From))
-        return size_t(static_cast<const char *>(P) - First);
-    }
-    return npos;
-  }
-
-  StringView dropFront(size_t N = 1) const {
-    if (N >= size())
-      N = size();
-    return StringView(First + N, Last);
-  }
-
-  StringView dropBack(size_t N = 1) const {
-    if (N >= size())
-      N = size();
-    return StringView(First, Last - N);
-  }
-
-  char front() const {
-    assert(!empty());
-    return *begin();
-  }
-
-  char back() const {
-    assert(!empty());
-    return *(end() - 1);
-  }
-
-  char popFront() {
-    assert(!empty());
-    return *First++;
-  }
-
-  bool consumeFront(char C) {
-    if (!startsWith(C))
-      return false;
-    *this = dropFront(1);
-    return true;
-  }
-
-  bool consumeFront(StringView S) {
-    if (!startsWith(S))
-      return false;
-    *this = dropFront(S.size());
-    return true;
-  }
-
-  bool startsWith(char C) const { return !empty() && *begin() == C; }
-
-  bool startsWith(StringView Str) const {
-    if (Str.size() > size())
-      return false;
-    return std::strncmp(Str.begin(), begin(), Str.size()) == 0;
-  }
-
-  const char &operator[](size_t Idx) const { return *(begin() + Idx); }
-
-  const char *begin() const { return First; }
-  const char *end() const { return Last; }
-  size_t size() const { return static_cast<size_t>(Last - First); }
-  bool empty() const { return First == Last; }
-};
-
-inline bool operator==(const StringView &LHS, const StringView &RHS) {
-  return LHS.size() == RHS.size() &&
-         std::strncmp(LHS.begin(), RHS.begin(), LHS.size()) == 0;
-}
-
-DEMANGLE_NAMESPACE_END
-
-#endif
diff --git a/demangle/third_party/llvm/include/llvm/Demangle/Utility.h b/demangle/third_party/llvm/include/llvm/Demangle/Utility.h
deleted file mode 100644
index 855c56e9..00000000
--- a/demangle/third_party/llvm/include/llvm/Demangle/Utility.h
+++ /dev/null
@@ -1,199 +0,0 @@
-//===--- Utility.h -------------------*- mode:c++;eval:(read-only-mode) -*-===//
-//       Do not edit! See README.txt.
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-// Provide some utility classes for use in the demangler.
-// There are two copies of this file in the source tree.  The one in libcxxabi
-// 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 <array>
-#include <cstdint>
-#include <cstdlib>
-#include <cstring>
-#include <exception>
-#include <limits>
-
-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;
-  size_t BufferCapacity = 0;
-
-  // Ensure there are at least N more positions in the buffer.
-  void grow(size_t N) {
-    size_t Need = N + CurrentPosition;
-    if (Need > BufferCapacity) {
-      // Reduce the number of reallocations, with a bit of hysteresis. The
-      // number here is chosen so the first allocation will more-than-likely not
-      // allocate more than 1K.
-      Need += 1024 - 32;
-      BufferCapacity *= 2;
-      if (BufferCapacity < Need)
-        BufferCapacity = Need;
-      Buffer = static_cast<char *>(std::realloc(Buffer, BufferCapacity));
-      if (Buffer == nullptr)
-        std::terminate();
-    }
-  }
-
-  OutputBuffer &writeUnsigned(uint64_t N, bool isNeg = false) {
-    std::array<char, 21> Temp;
-    char *TempPtr = Temp.data() + Temp.size();
-
-    // Output at least one character.
-    do {
-      *--TempPtr = char('0' + N % 10);
-      N /= 10;
-    } while (N);
-
-    // Add negative sign.
-    if (isNeg)
-      *--TempPtr = '-';
-
-    return operator+=(StringView(TempPtr, Temp.data() + Temp.size()));
-  }
-
-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); }
-
-  /// 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) {
-    if (size_t Size = R.size()) {
-      grow(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) {
-    size_t Size = R.size();
-
-    grow(Size);
-    std::memmove(Buffer + Size, Buffer, CurrentPosition);
-    std::memcpy(Buffer, R.begin(), Size);
-    CurrentPosition += Size;
-
-    return *this;
-  }
-
-  OutputBuffer &operator<<(StringView 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) {
-    return writeUnsigned(N, false);
-  }
-
-  OutputBuffer &operator<<(long N) {
-    return this->operator<<(static_cast<long long>(N));
-  }
-
-  OutputBuffer &operator<<(unsigned long N) {
-    return this->operator<<(static_cast<unsigned long long>(N));
-  }
-
-  OutputBuffer &operator<<(int N) {
-    return this->operator<<(static_cast<long long>(N));
-  }
-
-  OutputBuffer &operator<<(unsigned int N) {
-    return this->operator<<(static_cast<unsigned long long>(N));
-  }
-
-  void insert(size_t Pos, const char *S, size_t N) {
-    assert(Pos <= CurrentPosition);
-    if (N == 0)
-      return;
-    grow(N);
-    std::memmove(Buffer + Pos + N, Buffer + Pos, CurrentPosition - Pos);
-    std::memcpy(Buffer + Pos, S, N);
-    CurrentPosition += N;
-  }
-
-  size_t getCurrentPosition() const { return CurrentPosition; }
-  void setCurrentPosition(size_t NewPos) { CurrentPosition = NewPos; }
-
-  char back() const {
-    assert(CurrentPosition);
-    return Buffer[CurrentPosition - 1];
-  }
-
-  bool empty() const { return CurrentPosition == 0; }
-
-  char *getBuffer() { return Buffer; }
-  char *getBufferEnd() { return Buffer + CurrentPosition - 1; }
-  size_t getBufferCapacity() const { return BufferCapacity; }
-};
-
-template <class T> class ScopedOverride {
-  T &Loc;
-  T Original;
-
-public:
-  ScopedOverride(T &Loc_) : ScopedOverride(Loc_, Loc_) {}
-
-  ScopedOverride(T &Loc_, T NewVal) : Loc(Loc_), Original(Loc_) {
-    Loc_ = std::move(NewVal);
-  }
-  ~ScopedOverride() { Loc = std::move(Original); }
-
-  ScopedOverride(const ScopedOverride &) = delete;
-  ScopedOverride &operator=(const ScopedOverride &) = delete;
-};
-
-DEMANGLE_NAMESPACE_END
-
-#endif