[VERY-WIP] [ItaniumDemangle] Add ability to re-serialize the parsed AST

[labath]

Summary

This is kind of an alternative to D50586. Instead of modifying the parsed string in the middle of parsing, we "remangle" the (possibly modified name" into a new string.

This isn't complete yet (I've needed to modify some parts of the AST construction to preserve enough information for remangling, but I haven't done this for all nodes), and it needs a lot of cleaning up. In particular, it does not yet expose any way to actually modify the parsed AST.

However, I am putting it out here, to show a possibly cleaner (and definitely more powerful) alternative to the mentioned patch.

[erik.pilkington]

This is really cool, thanks for putting this together! In order to properly recreate the mangled name, we would have to track a far amount more information in the AST, looks like you have a pretty good start. I think that the set of transformations that we could support here would be pretty limited. For instance, substituting int for int* in a mangled name is probably a non-starter because we would have to add a substitution, which means that we would have to track substitutions from the AST (in order to tell when int* already appeared in the mangled name and should be remangled as a substitution), and adjust future substitutions numbers, which sounds like it would be hard to get right. Just replacing one <builtin-type> for another should be fine though (since those can't be substitutions), as should the constructor thing you mentioned.

Given that, I'm skeptical that this is the right way forward here. Maybe adding some way for clients to hijack the parser would be a better approach, i.e. we could make the parser a CRTP base, and LLDB could override parseType() or parseCtorDtor() as needed. Thats would kinda be a generalization of https://reviews.llvm.org/D50586. Any thoughts?

[labath]

In D50599#1197282, @erik.pilkington wrote:

This is really cool, thanks for putting this together! In order to properly recreate the mangled name, we would have to track a far amount more information in the AST, looks like you have a pretty good start. I think that the set of transformations that we could support here would be pretty limited. For instance, substituting int for int* in a mangled name is probably a non-starter because we would have to add a substitution, which means that we would have to track substitutions from the AST (in order to tell when int* already appeared in the mangled name and should be remangled as a substitution), and adjust future substitutions numbers, which sounds like it would be hard to get right. Just replacing one <builtin-type> for another should be fine though (since those can't be substitutions), as should the constructor thing you mentioned.

That's a good point. I was aware that substitutions will be a tricky, but I thought this would only be a problem when actually updating the substitution nodes themselves (because of the duplicated information between the "index" and "node" members). It did not occur to me that adding/removing any non-trivial (substitutable) node would invalidate these substitution nodes. That could be fixed, but it would require a bit more effort -- e.g., making sure all substitution accesses go through the central vector of substitutable node (and substitution nodes just store the index into the vector), then after every (notrivial) modification going through all substitution nodes and updating their indices. However, that could be overkill given that I don't anticipate needing any complex transformations like this.

Given that, I'm skeptical that this is the right way forward here. Maybe adding some way for clients to hijack the parser would be a better approach, i.e. we could make the parser a CRTP base, and LLDB could override parseType() or parseCtorDtor() as needed. Thats would kinda be a generalization of https://reviews.llvm.org/D50586. Any thoughts?

That's an interesting idea. The slight hickup I see is that for my use case, I only need to update C1->C2 for the top-level function (and not, e.g. for the C1 instances nested inside local names). This kind of thing is easy to do on the AST, but not from within the parseCtorDtor() function. I suspect that may be true for other transformations as well (I'm not sure if there is a good spec of what should exactly be substituted by D50586, but I think this could be an issue there too). I suppose that could be made to work by overriding parseLocalName (and anything else that may embed a function encoding), but it won't be ideal, because we would need to duplicate some of the parsing logic:

disableC1substitution();
Node *Encoding = parseEncoding();
enableC1substitution();
if (consumeIf('s'))
  // do stuff

if (consumeIf('d'))
  // do other stuff

Node *Entity = parseName(State);
...

Or we could just not support substitution in local names (I think LLDB has bigger problems when working with local objects than missing constructors).

However, I also think that just allowing the AST transformations that we can guarantee don't run into the substitution problems you mentioned (E.g. by making only the "kind" field of the BuiltinType node and the "flavor" field of the CtorDtor node mutable), would be fine too. Then, if anyone wants to do another modification, he can just mark the extra field mutable (provide a setter), and implement any fixups needed. With any luck, all fixups will be trivial, and we will never run into the case of needing a substitution-invalidating transformation.

[erik.pilkington]

In D50599#1197781, @labath wrote:

That's an interesting idea. The slight hickup I see is that for my use case, I only need to update C1->C2 for the top-level function (and not, e.g. for the C1 instances nested inside local names). This kind of thing is easy to do on the AST, but not from within the parseCtorDtor() function. I suspect that may be true for other transformations as well (I'm not sure if there is a good spec of what should exactly be substituted by D50586, but I think this could be an issue there too). I suppose that could be made to work by overriding parseLocalName (and anything else that may embed a function encoding), but it won't be ideal, because we would need to duplicate some of the parsing logic:

disableC1substitution();
Node *Encoding = parseEncoding();
enableC1substitution();
if (consumeIf('s'))
  // do stuff

if (consumeIf('d'))
  // do other stuff

Node *Entity = parseName(State);
...

Or we could just not support substitution in local names (I think LLDB has bigger problems when working with local objects than missing constructors).

Couldn't you just track the <encoding> depth by overriding parseEncoding, and only do the analysis in parseCtorDtor for top-level encodings?

However, I also think that just allowing the AST transformations that we can guarantee don't run into the substitution problems you mentioned (E.g. by making only the "kind" field of the BuiltinType node and the "flavor" field of the CtorDtor node mutable), would be fine too. Then, if anyone wants to do another modification, he can just mark the extra field mutable (provide a setter), and implement any fixups needed. With any luck, all fixups will be trivial, and we will never run into the case of needing a substitution-invalidating transformation.

I'm not opposed to this if you put the time into getting it right, but just for the record my concerns are:

1. This will be a fairly intrusive change to the demangler
2. Adding extra info to the AST, and the indirection required to track substitution and template-param numbers will have a perf cost, which may be a dealbreaker depending on the numbers (<5% is probably fine, say)
3. This is a really hard to get right/heavyweight way of solving this specific problem.
4. Not broadly useful because the amount of changes you can make without breaking substitutions is limited.

[labath]

In D50599#1197819, @erik.pilkington wrote:

In D50599#1197781, @labath wrote:

That's an interesting idea. The slight hickup I see is that for my use case, I only need to update C1->C2 for the top-level function (and not, e.g. for the C1 instances nested inside local names). This kind of thing is easy to do on the AST, but not from within the parseCtorDtor() function. I suspect that may be true for other transformations as well (I'm not sure if there is a good spec of what should exactly be substituted by D50586, but I think this could be an issue there too). I suppose that could be made to work by overriding parseLocalName (and anything else that may embed a function encoding), but it won't be ideal, because we would need to duplicate some of the parsing logic:

disableC1substitution();
Node *Encoding = parseEncoding();
enableC1substitution();
if (consumeIf('s'))
  // do stuff

if (consumeIf('d'))
  // do other stuff

Node *Entity = parseName(State);
...

Or we could just not support substitution in local names (I think LLDB has bigger problems when working with local objects than missing constructors).

Couldn't you just track the <encoding> depth by overriding parseEncoding, and only do the analysis in parseCtorDtor for top-level encodings?

You're right again. That does sound like it could work. I guess I should have given this idea more thought. Now I feel silly.

Given this, I think I'm convinced that going the CRTP route is a much better option. I'll shelve this and try to make that work instead.

I have one process question though. What's the current workflow for merging changes between the demangler copies in libc++abi and llvm? Right now they're mostly identical except for a few macros, but CRTP will require putting a lot of stuff into the header (and into a namespace), so they will diverge more. Do you think it would make sense to factor the common bits into a separate (.inc ?) file which can be kept identical? Then cxa_demangle.cpp could just #include that file into an anonymous namespace and llvm could include that into the llvm namespace (from a header file).

[erik.pilkington]

In D50599#1199289, @labath wrote:

Given this, I think I'm convinced that going the CRTP route is a much better option. I'll shelve this and try to make that work instead.

Okay, great! Glad we're on the same page. This was a neat idea, thanks for taking the time to investigate it.

I have one process question though. What's the current workflow for merging changes between the demangler copies in libc++abi and llvm? Right now they're mostly identical except for a few macros, but CRTP will require putting a lot of stuff into the header (and into a namespace), so they will diverge more. Do you think it would make sense to factor the common bits into a separate (.inc ?) file which can be kept identical? Then cxa_demangle.cpp could just #include that file into an anonymous namespace and llvm could include that into the llvm namespace (from a header file).

I have an ugly perl script that I use to patch changes from libcxxabi to llvm (see the end of this message). The basic idea for compatibility in libcxxabi is ItaniumDemangle.cpp maps to libcxxabi/src/cxa_demangle, and the other headers in llvm/lib/Demangle/* map to their equivalents in libcxxabi/src/demangle/*. I would like to keep them identical to keep patching easy, so any changes to the file structure in llvm should also be done in libcxxabi.
I think that we should move the Node hierarchy into it's own file ItaniumNode.h, and the CRTP parser into one, ItaniumParser.h which would include ItaniumNode.h, and put all the declarations in the namespace llvm::itanium_demangler (or an anon namespace in libcxxabi). That would allow us to implement ItaniumPartialDemangler in a separate file (which wouldn't map to anything in libcxxabi), which would be nice. ItaniumDemangle.cpp could just be a #include "ItaniumParser.h" and the implementation of itaniumDemangle(), or __cxa_demangle in libcxxabi. Does that sounds reasonable? CCing @rsmith, who expressed some interest in moving the AST/parser to a header, and @dexonsmith, who's had some thoughts on this before.

#!/usr/bin/env perl

use warnings;
use strict;

my $diff = `git show $ARGV[0] libcxxabi/src`;

$diff =~ s/libcxxabi\/src\/cxa_demangle.cpp/llvm\/lib\/Demangle\/ItaniumDemangle.cpp/g;
$diff =~ s/libcxxabi\/src\/demangle\/Utility.h/llvm\/lib\/Demangle\/Utility.h/g;
$diff =~ s/libcxxabi\/src\/demangle\/Compiler.h/llvm\/lib\/Demangle\/Compiler.h/g;
$diff =~ s/libcxxabi\/src\/demangle\/StringView.h/llvm\/lib\/Demangle\/StringView.h/g;
$diff =~ s/_LIBCPP_UNREACHABLE\(\)/LLVM_BUILTIN_UNREACHABLE/g;
$diff =~ s/_LIBCPP_FALLTHROUGH\(\)/LLVM_FALLTHROUGH/g;
$diff =~ s/DUMP_METHOD/LLVM_DUMP_METHOD/g;
$diff =~ s/__cxxabiv1/llvm/g;
$diff =~ s/_LIBCXXABI_FUNC_VIS//g;
$diff =~ s/__cxa_demangle/itaniumDemangle/g;

open OUTPUT, "| patch -p1";
local $SIG{PIPE} = sub { die "pipe broken" };
print OUTPUT $diff;

[dexonsmith]

In D50599#1199411, @erik.pilkington wrote:

In D50599#1199289, @labath wrote:

I have one process question though. What's the current workflow for merging changes between the demangler copies in libc++abi and llvm? Right now they're mostly identical except for a few macros, but CRTP will require putting a lot of stuff into the header (and into a namespace), so they will diverge more. Do you think it would make sense to factor the common bits into a separate (.inc ?) file which can be kept identical? Then cxa_demangle.cpp could just #include that file into an anonymous namespace and llvm could include that into the llvm namespace (from a header file).

I have an ugly perl script that I use to patch changes from libcxxabi to llvm (see the end of this message). The basic idea for compatibility in libcxxabi is ItaniumDemangle.cpp maps to libcxxabi/src/cxa_demangle, and the other headers in llvm/lib/Demangle/* map to their equivalents in libcxxabi/src/demangle/*. I would like to keep them identical to keep patching easy, so any changes to the file structure in llvm should also be done in libcxxabi.
I think that we should move the Node hierarchy into it's own file ItaniumNode.h, and the CRTP parser into one, ItaniumParser.h which would include ItaniumNode.h, and put all the declarations in the namespace llvm::itanium_demangler (or an anon namespace in libcxxabi). That would allow us to implement ItaniumPartialDemangler in a separate file (which wouldn't map to anything in libcxxabi), which would be nice. ItaniumDemangle.cpp could just be a #include "ItaniumParser.h" and the implementation of itaniumDemangle(), or __cxa_demangle in libcxxabi. Does that sounds reasonable? CCing @rsmith, who expressed some interest in moving the AST/parser to a header, and @dexonsmith, who's had some thoughts on this before.

I don't have a strong opinion on how to keep the two versions of the demangler in sync, but I do think it's really important that they do not diverge. Perhaps we should add a test that the two versions are in sync, check the perl script in somewhere, and document the patching process?

Longer term, I suspect we'll want to pull the demangler guts out into a separate project that LLVM and libcxxabi both depend on (and expose in different ways)... but having LLVM depend on another project would be chaotic when we don't have a monorepo.

include/llvm/Demangle/Demangle.h

struct ItaniumPartialDemangler {
 
   /// 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;
 
+  char *mangle(char *Buf, size_t *N) const;
+
   ~ItaniumPartialDemangler();
 private:
   void *RootNode;
   void *Context;
 };
 } // namespace llvm
 
 #endif

lib/Demangle/ItaniumDemangle.cpp

 #include <cassert>
 #include <cctype>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <numeric>
 #include <utility>
 #include <vector>
+#include <array>
 
 namespace {
 // 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 {
-    KNodeArrayNode,
     KDotSuffix,
     KVendorExtQualType,
     KQualType,
     KConversionOperatorType,
     KPostfixQualifiedType,
     KElaboratedTypeSpefType,
     KNameType,
+    KOperatorName,
+    KBuiltinType,
     KAbiTagAttr,
+    KDefaultArg,
     KEnableIfAttr,
     KObjCProtoName,
     KPointerType,
     KReferenceType,
     KPointerToMemberType,
     KArrayType,
     KFunctionType,
     KNoexceptSpec,
     KDynamicExceptionSpec,
     KFunctionEncoding,
     KLiteralOperator,
     KSpecialName,
+    KSpecialNameX,
     KCtorVtableSpecialName,
     KQualifiedName,
     KNestedName,
+    KFullNestedName,
     KLocalName,
     KVectorType,
     KParameterPack,
     KTemplateArgumentPack,
     KParameterPackExpansion,
     KTemplateArgs,
+    KTemplateExpression,
     KForwardTemplateReference,
     KNameWithTemplateArgs,
     KGlobalQualifiedName,
     KStdQualifiedName,
+    KStdName,
+    KSubstitution,
     KExpandedSpecialSubstitution,
     KSpecialSubstitution,
     KCtorDtorName,
     KDtorName,
     KUnnamedTypeName,
     KClosureTypeName,
     KStructuredBindingName,
     KExpr,
+    KBinaryExpr,
     KBracedExpr,
     KBracedRangeExpr,
+    KEnclosingExprX,
+    KFunctionParam,
+    KIntegerExpr,
+    KSizeofAliasParamPackExpr,
+    KSizeofParamPackExpr,
   };
 
   Kind K;
 
   /// 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, };
 
for (size_t Idx = 0; Idx != NumElements; ++Idx) {
         continue;
       }
 
       FirstElement = false;
     }
   }
 };
 
-struct NodeArrayNode : Node {
-  NodeArray Array;
-  NodeArrayNode(NodeArray Array_) : Node(KNodeArrayNode), Array(Array_) {}
-  void printLeft(OutputStream &S) const override {
-    Array.printWithComma(S);
-  }
-};
-
 class DotSuffix final : public Node {
+public:
   const Node *Prefix;
   const StringView Suffix;
 
-public:
   DotSuffix(Node *Prefix_, StringView Suffix_)
       : Node(KDotSuffix), Prefix(Prefix_), Suffix(Suffix_) {}
 
   void printLeft(OutputStream &s) const override {
     Prefix->print(s);
     s += " (";
     s += Suffix;
     s += ")";
   }
 };
 
 class VendorExtQualType final : public Node {
+public:
   const Node *Ty;
   StringView Ext;
 
-public:
   VendorExtQualType(Node *Ty_, StringView Ext_)
       : Node(KVendorExtQualType), Ty(Ty_), Ext(Ext_) {}
 
   void printLeft(OutputStream &S) const override {
     Ty->print(S);
     S += " ";
     S += Ext;
   }

 };
 
 void addQualifiers(Qualifiers &Q1, Qualifiers Q2) {
   Q1 = static_cast<Qualifiers>(Q1 | Q2);
 }
 
 class QualType : public Node {
 protected:
-  const Qualifiers Quals;
-  const Node *Child;
-
   void printQuals(OutputStream &S) const {
     if (Quals & QualConst)
       S += " const";
     if (Quals & QualVolatile)
       S += " volatile";
     if (Quals & QualRestrict)
       S += " restrict";
   }
 
 public:
+  const Qualifiers Quals;
+  const Node *Child;
+
   QualType(Node *Child_, Qualifiers Quals_)
       : Node(KQualType, Child_->RHSComponentCache,
              Child_->ArrayCache, Child_->FunctionCache),
         Quals(Quals_), Child(Child_) {}
 
   bool hasRHSComponentSlow(OutputStream &S) const override {
     return Child->hasRHSComponent(S);
   }
   bool hasArraySlow(OutputStream &S) const override {
     return Child->hasArray(S);
   }
   bool hasFunctionSlow(OutputStream &S) const override {
     return Child->hasFunction(S);
   }
 
   void printLeft(OutputStream &S) const override {
     Child->printLeft(S);
     printQuals(S);
   }
 
   void printRight(OutputStream &S) const override { Child->printRight(S); }
 };
 
 class ConversionOperatorType final : public Node {
+public:
   const Node *Ty;
 
-public:
   ConversionOperatorType(Node *Ty_)
       : Node(KConversionOperatorType), Ty(Ty_) {}
 
   void printLeft(OutputStream &S) const override {
     S += "operator ";
     Ty->print(S);
   }
 };
 
 class PostfixQualifiedType final : public Node {
+public:
+  enum Kind { KComplex, KImaginary };
+
   const Node *Ty;
-  const StringView Postfix;
+  const Kind K;
 
-public:
-  PostfixQualifiedType(Node *Ty_, StringView Postfix_)
-      : Node(KPostfixQualifiedType), Ty(Ty_), Postfix(Postfix_) {}
+  PostfixQualifiedType(Node *Ty_, Kind K_)
+      : Node(KPostfixQualifiedType), Ty(Ty_), K(K_) {}
 
   void printLeft(OutputStream &s) const override {
+    static constexpr const char *Postfix[] = {" complex", " imaginary"};
     Ty->printLeft(s);
-    s += Postfix;
+    s += Postfix[K];
   }
 };
 
 class NameType final : public Node {
+public:
   const StringView Name;
 
-public:
   NameType(StringView Name_) : Node(KNameType), Name(Name_) {}
 
   StringView getName() const { return Name; }
   StringView getBaseName() const override { return Name; }
 
   void printLeft(OutputStream &s) const override { s += Name; }
 };
 
+class OperatorName final : public Node {
+public:
+  enum Kind {
+    Oamp_amp,
+    Oamp1,
+    Oamp,
+    Oamp_eq,
+    Oeq,
+    Ocall,
+    Ocomma,
+    Otilde,
+    Odel_arr,
+    Oderef,
+    Odel,
+    Oslash,
+    Oslash_eq,
+    Ocaret,
+    Ocaret_eq,
+    Oeq_eq,
+    Ogt_eq,
+    Ogt,
+    Oindex,
+    Olt_eq,
+    Olt_lt,
+    Olt_lt_eq,
+    Olt,
+    Osub,
+    Osub_eq,
+    Omul,
+    Omul_eq,
+    Osub_sub,
+    Onew_arr,
+    Onot_eq,
+    Oneg,
+    Onot,
+    Onew,
+    Oor_or,
+    Oor,
+    Oor_eq,
+    Oarrow_mul,
+    Oplus,
+    Oplus_eq,
+    Oplus_plus,
+    Oplus1,
+    Oarrow,
+    Oternary,
+    Omod,
+    Omod_eq,
+    Ogt_gt,
+    Ogt_gt_eq,
+    Olt_eq_gt,
+  };
+  
+  Kind K;
+
+public:
+  OperatorName(Kind K_) : Node(KOperatorName), K(K_) {}
+
+  StringView getName() const {
+    static constexpr const char *OpStr[] = {
+        "operator&&",        "operator&",   "operator&",       "operator&=",
+        "operator=",         "operator()",  "operator,",       "operator~",
+        "operator delete[]", "operator*",   "operator delete", "operator/",
+        "operator/=",        "operator^",   "operator^=",      "operator==",
+        "operator>=",        "operator>",   "operator[]",      "operator<=",
+        "operator<<",        "operator<<=", "operator<",       "operator-",
+        "operator-=",        "operator*",   "operator*=",      "operator--",
+        "operator new[]",    "operator!=",  "operator-",       "operator!",
+        "operator new",      "operator||",  "operator|",       "operator|=",
+        "operator->*",       "operator+",   "operator+=",      "operator++",
+        "operator+",         "operator->",  "operator?",       "operator%",
+        "operator%=",        "operator>>",  "operator>>=",     "operator<=>",
+    };
+    return OpStr[K];
+  }
+  StringView getBaseName() const override { return getName(); }
+  void printLeft(OutputStream &S) const override { S += getName(); }
+};
+
+class BuiltinType final : public Node {
+public:
+  enum Kind {
+    Kvoid,
+    Kwchar_t,
+    Kbool,
+    Kchar,
+    Ksigned_char,
+    Kunsigned_char,
+    Kshort,
+    Kunsigned_short,
+    Kint,
+    Kunsigned_int,
+    Klong,
+    Kunsigned_long,
+    Klong_long,
+    Kunsigned_long_long,
+    K__int128,
+    Kunsigned__int128,
+    Kfloat,
+    Kdouble,
+    Klong_double,
+    K__float128,
+    Kellipsis,
+    Kdecimal64,
+    Kdecimal128,
+    Kdecimal32,
+    Kdecimal16,
+    Kchar32_t,
+    Kchar16_t,
+    Kauto,
+    Kdecltype_auto,
+    Knullptr_t,
+  };
+
+  const Kind K;
+
+  BuiltinType(Kind K_) : Node(KBuiltinType), K(K_) {}
+
+  void printLeft(OutputStream &S) const override {
+    switch (K) {
+    case Kvoid:
+      S += "void";
+      return;
+    case Kwchar_t:
+      S += "wchar_t";
+      return;
+    case Kbool:
+      S += "bool";
+      return;
+    case Kchar:
+      S += "char";
+      return;
+    case Ksigned_char:
+      S += "signed char";
+      return;
+    case Kunsigned_char:
+      S += "unsigned char";
+      return;
+    case Kshort:
+      S += "short";
+      return;
+    case Kunsigned_short:
+      S += "unsigned short";
+      return;
+    case Kint:
+      S += "int";
+      return;
+    case Kunsigned_int:
+      S += "unsigned int";
+      return;
+    case Klong:
+      S += "long";
+      return;
+    case Kunsigned_long:
+      S += "unsigned long";
+      return;
+    case Klong_long:
+      S += "long long";
+      return;
+    case Kunsigned_long_long:
+      S += "unsigned long long";
+      return;
+    case K__int128:
+      S += "__int128";
+      return;
+    case Kunsigned__int128:
+      S += "unsigned __int128";
+      return;
+    case Kfloat:
+      S += "float";
+      return;
+    case Kdouble:
+      S += "double";
+      return;
+    case Klong_double:
+      S += "long double";
+      return;
+    case K__float128:
+      S += "__float128";
+      return;
+    case Kellipsis:
+      S += "...";
+      return;
+    case Kdecimal64:
+      S += "decimal64";
+      return;
+    case Kdecimal128:
+      S += "decimal128";
+      return;
+    case Kdecimal32:
+      S += "decimal32";
+      return;
+    case Kdecimal16:
+      S += "decimal16";
+      return;
+    case Kchar32_t:
+      S += "char32_t";
+      return;
+    case Kchar16_t:
+      S += "char16_t";
+      return;
+    case Kauto:
+      S += "auto";
+      return;
+    case Kdecltype_auto:
+      S += "decltype(auto)";
+      return;
+    case Knullptr_t:
+      S += "std::nullptr_t";
+      return;
+    }
+  }
+};
+
 class ElaboratedTypeSpefType : public Node {
-  StringView Kind;
-  Node *Child;
 public:
-  ElaboratedTypeSpefType(StringView Kind_, Node *Child_)
-      : Node(KElaboratedTypeSpefType), Kind(Kind_), Child(Child_) {}
+  enum Kind { Kstruct, Kunion, Kenum };
+
+  Kind K;
+  Node *Child;
+
+  ElaboratedTypeSpefType(Kind K_, Node *Child_)
+      : Node(KElaboratedTypeSpefType), K(K_), Child(Child_) {}
 
   void printLeft(OutputStream &S) const override {
-    S += Kind;
-    S += ' ';
+    static constexpr const char *Elaborate[] = {"struct ", "union ", "enum "};
+    S += Elaborate[K];
     Child->print(S);
   }
 };
 
 struct AbiTagAttr : Node {
   Node *Base;
   StringView Tag;
 
   AbiTagAttr(Node* Base_, StringView Tag_)
       : Node(KAbiTagAttr, Base_->RHSComponentCache,
              Base_->ArrayCache, Base_->FunctionCache),
         Base(Base_), Tag(Tag_) {}
 
   void printLeft(OutputStream &S) const override {
     Base->printLeft(S);
     S += "[abi:";
     S += Tag;
     S += "]";
   }
 };
 
+struct DefaultArg final : Node {
+  size_t Number;
+  Node *Name;
+
+  DefaultArg(size_t Number_, Node *Name_)
+      : Node(KDefaultArg), Number(Number_), Name(Name_) {}
+
+  void printLeft(OutputStream &S) const override { Name->printLeft(S); }
+};
+
 class EnableIfAttr : public Node {
-  NodeArray Conditions;
 public:
+  NodeArray Conditions;
+
   EnableIfAttr(NodeArray Conditions_)
       : Node(KEnableIfAttr), Conditions(Conditions_) {}
 
   void printLeft(OutputStream &S) const override {
     S += " [enable_if:";
     Conditions.printWithComma(S);
     S += ']';
   }
 };
 
 class ObjCProtoName : public Node {
+public:
   Node *Ty;
   StringView Protocol;
 
   friend class PointerType;
 
-public:
   ObjCProtoName(Node *Ty_, StringView Protocol_)
       : Node(KObjCProtoName), Ty(Ty_), Protocol(Protocol_) {}
 
   bool isObjCObject() const {
     return Ty->getKind() == KNameType &&
            static_cast<NameType *>(Ty)->getName() == "objc_object";
   }
 
   void printLeft(OutputStream &S) const override {
     Ty->print(S);
     S += "<";
     S += Protocol;
     S += ">";
   }
 };
 
 class PointerType final : public Node {
+public:
   const Node *Pointee;
 
-public:
   PointerType(Node *Pointee_)
       : Node(KPointerType, Pointee_->RHSComponentCache),
         Pointee(Pointee_) {}
 
   bool hasRHSComponentSlow(OutputStream &S) const override {
     return Pointee->hasRHSComponent(S);
   }
 

 
 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.
   std::pair<ReferenceKind, const Node *> collapse(OutputStream &S) const {
     auto SoFar = std::make_pair(RK, Pointee);
     for (;;) {
       const Node *SN = SoFar.second->getSyntaxNode(S);
       if (SN->getKind() != KReferenceType)
         break;
       auto *RT = static_cast<const ReferenceType *>(SN);
       SoFar.second = RT->Pointee;
       SoFar.first = std::min(SoFar.first, RT->RK);
     }
     return SoFar;
   }
 
 public:
+  const Node *Pointee;
+  ReferenceKind RK;
+
   ReferenceType(Node *Pointee_, ReferenceKind RK_)
       : Node(KReferenceType, Pointee_->RHSComponentCache),
         Pointee(Pointee_), RK(RK_) {}
 
   bool hasRHSComponentSlow(OutputStream &S) const override {
     return Pointee->hasRHSComponent(S);
   }
 
void printRight(OutputStream &s) const override {
     std::pair<ReferenceKind, const Node *> Collapsed = collapse(s);
     if (Collapsed.second->hasArray(s) || Collapsed.second->hasFunction(s))
       s += ")";
     Collapsed.second->printRight(s);
   }
 };
 
 class PointerToMemberType final : public Node {
+public:
   const Node *ClassType;
   const Node *MemberType;
 
-public:
   PointerToMemberType(Node *ClassType_, Node *MemberType_)
       : Node(KPointerToMemberType, MemberType_->RHSComponentCache),
         ClassType(ClassType_), MemberType(MemberType_) {}
 
   bool hasRHSComponentSlow(OutputStream &S) const override {
     return MemberType->hasRHSComponent(S);
   }
 
public:
 
   const Node *asNode() const {
     assert(isNode());
     return static_cast<const Node *>(First);
   }
 };
 
 class ArrayType final : public Node {
+public:
   Node *Base;
   NodeOrString Dimension;
 
-public:
   ArrayType(Node *Base_, NodeOrString Dimension_)
       : Node(KArrayType,
              /*RHSComponentCache=*/Cache::Yes,
              /*ArrayCache=*/Cache::Yes),
         Base(Base_), Dimension(Dimension_) {}
 
   // Incomplete array type.
   ArrayType(Node *Base_)
void printRight(OutputStream &S) const override {
     else if (Dimension.isNode())
       Dimension.asNode()->print(S);
     S += "]";
     Base->printRight(S);
   }
 };
 
 class FunctionType final : public Node {
+public:
   Node *Ret;
   NodeArray Params;
   Qualifiers CVQuals;
   FunctionRefQual RefQual;
   Node *ExceptionSpec;
 
-public:
   FunctionType(Node *Ret_, NodeArray Params_, Qualifiers CVQuals_,
                FunctionRefQual RefQual_, Node *ExceptionSpec_)
       : Node(KFunctionType,
              /*RHSComponentCache=*/Cache::Yes, /*ArrayCache=*/Cache::No,
              /*FunctionCache=*/Cache::Yes),
         Ret(Ret_), Params(Params_), CVQuals(CVQuals_), RefQual(RefQual_),
         ExceptionSpec(ExceptionSpec_) {}
 
void printRight(OutputStream &S) const override {
     if (ExceptionSpec != nullptr) {
       S += ' ';
       ExceptionSpec->print(S);
     }
   }
 };
 
 class NoexceptSpec : public Node {
-  Node *E;
 public:
+  Node *E;
+
   NoexceptSpec(Node *E_) : Node(KNoexceptSpec), E(E_) {}
 
   void printLeft(OutputStream &S) const override {
-    S += "noexcept(";
+    S += "noexcept";
+    if (E) {
+      S += "(";
       E->print(S);
       S += ")";
     }
+  }
 };
 
 class DynamicExceptionSpec : public Node {
-  NodeArray Types;
 public:
+  NodeArray Types;
+
   DynamicExceptionSpec(NodeArray Types_)
       : Node(KDynamicExceptionSpec), Types(Types_) {}
 
   void printLeft(OutputStream &S) const override {
     S += "throw(";
     Types.printWithComma(S);
     S += ')';
   }
 };
 
 class FunctionEncoding final : public Node {
+public:
   Node *Ret;
   Node *Name;
   NodeArray Params;
   Node *Attrs;
   Qualifiers CVQuals;
   FunctionRefQual RefQual;
 
-public:
   FunctionEncoding(Node *Ret_, Node *Name_, NodeArray Params_,
                    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_) {}
 
else if (RefQual == FrefQualRValue)
       S += " &&";
 
     if (Attrs != nullptr)
       Attrs->print(S);
   }
 };
 
 class LiteralOperator : public Node {
+public:
   const Node *OpName;
 
-public:
   LiteralOperator(Node *OpName_) : Node(KLiteralOperator), OpName(OpName_) {}
 
   void printLeft(OutputStream &S) const override {
     S += "operator\"\" ";
     OpName->print(S);
   }
 };
 
 class SpecialName final : public Node {
   const StringView Special;
   const Node *Child;
 
 public:
   SpecialName(StringView Special_, Node* Child_)
       : Node(KSpecialName), Special(Special_), Child(Child_) {}
 
   void printLeft(OutputStream &S) const override {
     S += Special;
     Child->print(S);
   }
 };
 
+class SpecialNameX final : public Node {
+public:
+  enum Kind {
+    KVTable,
+    KVTT,
+    KTypeinfo,
+    KTypename,
+    KThreadWrapper,
+    KThreadInit,
+    KGuardVar,
+  };
+  const Kind K;
+  const Node *Child;
+
+  SpecialNameX(Kind K_, Node* Child_)
+      : Node(KSpecialNameX), K(K_), Child(Child_) {}
+
+  void printLeft(OutputStream &S) const override {
+    static constexpr const char *Special[] = {
+        "vtable for ",
+        "VTT for ",
+        "typeinfo for ",
+        "typeinfo name for ",
+        "thread-local wrapper routine for ",
+        "thread-local initialization routine for ",
+        "guard variable for ",
+    };
+    S += Special[K];
+    Child->print(S);
+  }
+};
+
 class CtorVtableSpecialName final : public Node {
   const Node *FirstType;
   const Node *SecondType;
 
 public:
   CtorVtableSpecialName(Node *FirstType_, Node *SecondType_)
       : Node(KCtorVtableSpecialName),
         FirstType(FirstType_), SecondType(SecondType_) {}
struct NestedName : Node {
 
   void printLeft(OutputStream &S) const override {
     Qual->print(S);
     S += "::";
     Name->print(S);
   }
 };
 
+class FullNestedName final : public Node {
+public:
+  Node *Name;
+
+  FullNestedName(Node *Name_) : Node(KFullNestedName), Name(Name_) {}
+
+  StringView getBaseName() const override { return Name->getBaseName(); }
+
+  void printLeft(OutputStream &S) const override { Name->printLeft(S); }
+};
+
 struct LocalName : Node {
   Node *Encoding;
   Node *Entity;
 
   LocalName(Node *Encoding_, Node *Entity_)
       : Node(KLocalName), Encoding(Encoding_), Entity(Entity_) {}
 
   void printLeft(OutputStream &S) const override {
for (unsigned I = 1, E = S.CurrentPackMax; I < E; ++I) {
       S += ", ";
       S.CurrentPackIndex = I;
       Child->print(S);
     }
   }
 };
 
 class TemplateArgs final : public Node {
+public:
   NodeArray Params;
 
-public:
   TemplateArgs(NodeArray Params_) : Node(KTemplateArgs), Params(Params_) {}
 
   NodeArray getParams() { return Params; }
 
   void printLeft(OutputStream &S) const override {
     S += "<";
     Params.printWithComma(S);
     if (S.back() == '>')
struct ForwardTemplateReference : Node {
   // 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_) {}
 
+  ForwardTemplateReference(size_t Index_, Node *Ref_)
+      : Node(KForwardTemplateReference, Cache::Unknown, Cache::Unknown,
+             Cache::Unknown),
+        Index(Index_), Ref(Ref_) {}
+
   bool hasRHSComponentSlow(OutputStream &S) const override {
     if (Printing)
       return false;
     SwapAndRestore<bool> SavePrinting(Printing, true);
     return Ref->hasRHSComponent(S);
   }
   bool hasArraySlow(OutputStream &S) const override {
     if (Printing)

 };
 
 struct NameWithTemplateArgs : Node {
   // name<template_args>
   Node *Name;
   Node *TemplateArgs;
 
   NameWithTemplateArgs(Node *Name_, Node *TemplateArgs_)
-      : Node(KNameWithTemplateArgs), Name(Name_), TemplateArgs(TemplateArgs_) {}
+      : Node(KNameWithTemplateArgs), Name(Name_),
+        TemplateArgs(TemplateArgs_) {}
 
   StringView getBaseName() const override { return Name->getBaseName(); }
 
   void printLeft(OutputStream &S) const override {
     Name->print(S);
     TemplateArgs->print(S);
   }
 };
public:
   void printLeft(OutputStream &S) const override {
     S += "::";
     Child->print(S);
   }
 };
 
 struct StdQualifiedName : Node {
   Node *Child;
+  bool Local;
 
-  StdQualifiedName(Node *Child_) : Node(KStdQualifiedName), Child(Child_) {}
+  StdQualifiedName(Node *Child_, bool Local_)
+      : Node(KStdQualifiedName), Child(Child_), Local(Local_) {}
 
   StringView getBaseName() const override { return Child->getBaseName(); }
 
   void printLeft(OutputStream &S) const override {
     S += "std::";
     Child->print(S);
   }
 };
 
+struct StdName: Node {
+  StdName() : Node(KStdName) {}
+  void printLeft(OutputStream &S) const override { S += "std"; }
+};
+
+struct Substitution: Node {
+  size_t Index;
+  Node *Ref;
+
+  Substitution(size_t Index_, Node *Ref_)
+      : Node(KSubstitution), Index(Index_), Ref(Ref_) {}
+
+  bool hasRHSComponentSlow(OutputStream &S) const override {
+    return Ref->hasRHSComponent(S);
+  }
+  bool hasArraySlow(OutputStream &S) const override { return Ref->hasArray(S); }
+  bool hasFunctionSlow(OutputStream &S) const override {
+    return Ref->hasFunction(S);
+  }
+  const Node *getSyntaxNode(OutputStream &S) const override {
+    return Ref->getSyntaxNode(S);
+  }
+
+  void printLeft(OutputStream &S) const override { Ref->printLeft(S); }
+  void printRight(OutputStream &S) const override { Ref->printRight(S); }
+};
+
 enum class SpecialSubKind {
   allocator,
   basic_string,
   string,
   istream,
   ostream,
   iostream,
 };
case SpecialSubKind::iostream:
       S += "std::iostream";
       break;
     }
   }
 };
 
 class CtorDtorName final : public Node {
   const Node *Basename;
-  const bool IsDtor;
 
 public:
-  CtorDtorName(Node *Basename_, bool IsDtor_)
-      : Node(KCtorDtorName), Basename(Basename_), IsDtor(IsDtor_) {}
+  const bool IsDtor;
+  const uint8_t Flavor;
+
+  CtorDtorName(Node *Basename_, bool IsDtor_, uint8_t Flavor_)
+      : Node(KCtorDtorName), Basename(Basename_), IsDtor(IsDtor_),
+        Flavor(Flavor_) {}
 
   void printLeft(OutputStream &S) const override {
     if (IsDtor)
       S += "~";
     S += Basename->getBaseName();
   }
 };
 
public:
   void printLeft(OutputStream &S) const override {
     S += "'unnamed";
     S += Count;
     S += "\'";
   }
 };
 
 class ClosureTypeName : public Node {
+public:
   NodeArray Params;
   StringView Count;
 
-public:
   ClosureTypeName(NodeArray Params_, StringView Count_)
       : Node(KClosureTypeName), Params(Params_), Count(Count_) {}
 
   void printLeft(OutputStream &S) const override {
     S += "\'lambda";
     S += Count;
     S += "\'(";
     Params.printWithComma(S);
public:
 
   void printLeft(OutputStream &S) const override {
     S += '[';
     Bindings.printWithComma(S);
     S += ']';
   }
 };
 
+class TemplateExpression : public Node {
+public:
+  Node *Expr;
+
+  TemplateExpression(Node *Expr_) : Node(KTemplateExpression), Expr(Expr_) {}
+
+  bool hasRHSComponentSlow(OutputStream &S) const override {
+    return Expr->hasRHSComponent(S);
+  }
+  bool hasArraySlow(OutputStream &S) const override {
+    return Expr->hasArray(S);
+  }
+  bool hasFunctionSlow(OutputStream &S) const override {
+    return Expr->hasFunction(S);
+  }
+
+  void printLeft(OutputStream &S) const override { Expr->printLeft(S); }
+  void printRight(OutputStream &S) const override { Expr->printRight(S); }
+};
+
 // -- Expression Nodes --
 
 struct Expr : public Node {
   Expr(Kind K = KExpr) : Node(K) {}
 };
 
 class BinaryExpr : public Expr {
+public:
+  enum Operator {
+    Oamp_amp,
+    Oamp,
+    Oamp_eq,
+    Oeq,
+    Ocomma,
+    Oslash,
+    Oslash_eq,
+    Ocaret,
+    Ocaret_eq,
+    Oeq_eq,
+    Ogt_eq,
+    Ogt,
+    Olt_eq,
+    Olt_lt,
+    Olt_lt_eq,
+    Olt,
+    Osub,
+    Osub_eq,
+    Omul,
+    Omul_eq,
+    Onot_eq,
+    Oor_or,
+    Oor,
+    Oor_eq,
+    Oarrow_mul,
+    Oplus,
+    Oplus_eq,
+    Omod,
+    Omod_eq,
+    Ogt_gt,
+    Ogt_gt_eq,
+  };
+
+private:
+  static constexpr const char *const OpStr[] = {
+      "&&", "&",  "&=",  "=",   ",",  "/", "/=", "^",  "^=",  "==", ">=",
+      ">",  "<=", "<<",  "<<=", "<",  "-", "-=", "*",  "*=",  "!=", "||",
+      "|",  "|=", "->*", "+",   "+=", "%", "%=", ">>", ">>=",
+  };
+
+public:
   const Node *LHS;
-  const StringView InfixOperator;
+  const Operator InfixOperator;
   const Node *RHS;
 
-public:
-  BinaryExpr(Node *LHS_, StringView InfixOperator_, Node *RHS_)
-      : LHS(LHS_), InfixOperator(InfixOperator_), RHS(RHS_) {}
+  BinaryExpr(Node *LHS_, Operator InfixOperator_, Node *RHS_)
+      : Expr(KBinaryExpr), LHS(LHS_), InfixOperator(InfixOperator_), RHS(RHS_) {
+  }
 
   void printLeft(OutputStream &S) const override {
     // might be a template argument expression, then we need to disambiguate
     // with parens.
-    if (InfixOperator == ">")
+    if (InfixOperator == Ogt)
       S += "(";
 
     S += "(";
     LHS->print(S);
     S += ") ";
-    S += InfixOperator;
+    S += OpStr[InfixOperator];
     S += " (";
     RHS->print(S);
     S += ")";
 
-    if (InfixOperator == ">")
+    if (InfixOperator == Ogt)
       S += ")";
   }
 };
+const char *const BinaryExpr::OpStr[];
 
 class ArraySubscriptExpr : public Expr {
   const Node *Op1;
   const Node *Op2;
 
 public:
   ArraySubscriptExpr(Node *Op1_, Node *Op2_) : Op1(Op1_), Op2(Op2_) {}
 
public:
 
   void printLeft(OutputStream &S) const override {
     S += Prefix;
     Infix->print(S);
     S += Postfix;
   }
 };
 
+class EnclosingExprX : public Expr {
+public:
+  enum Kind {
+    Ksizeof,
+    KdecltypeId,
+    Kdecltype,
+  };
+
+  const Kind K;
+  const Node *Infix;
+
+private:
+  static constexpr const char *Prefix[] = {
+      "sizeof (",
+      "decltype (",
+      "decltype (",
+  };
+  static constexpr const char *Postfix[] = {
+      ")",
+      ")",
+      ")",
+  };
+
+public:
+  EnclosingExprX(Kind K_, Node *Infix_)
+      : Expr(KEnclosingExprX), K(K_), Infix(Infix_) {}
+
+  void printLeft(OutputStream &S) const override {
+    S += Prefix[K];
+    Infix->print(S);
+    S += Postfix[K];
+  }
+};
+const char *const EnclosingExprX::Prefix[];
+const char *const EnclosingExprX::Postfix[];
+
 class CastExpr : public Expr {
   // cast_kind<to>(from)
   const StringView CastKind;
   const Node *To;
   const Node *From;
 
 public:
   CastExpr(StringView CastKind_, Node *To_, Node *From_)
       : CastKind(CastKind_), To(To_), From(From_) {}
 
   void printLeft(OutputStream &S) const override {
     S += CastKind;
     S += "<";
     To->printLeft(S);
     S += ">(";
     From->printLeft(S);
     S += ")";
   }
 };
 
+class SizeofAliasParamPackExpr : public Expr {
+public:
+  NodeArray Pack;
+
+  SizeofAliasParamPackExpr(NodeArray Pack_) : Expr(KSizeofAliasParamPackExpr), Pack(Pack_) {}
+
+  void printLeft(OutputStream &S) const override {
+    S += "sizeof... (";
+    Pack.printWithComma(S);
+    S += ")";
+  }
+};
+
 class SizeofParamPackExpr : public Expr {
+public:
   Node *Pack;
 
-public:
-  SizeofParamPackExpr(Node *Pack_) : Pack(Pack_) {}
+  SizeofParamPackExpr(Node *Pack_) : Expr(KSizeofParamPackExpr), Pack(Pack_) {}
 
   void printLeft(OutputStream &S) const override {
     S += "sizeof...(";
     ParameterPackExpansion PPE(Pack);
     PPE.printLeft(S);
     S += ")";
   }
 };
void printLeft(OutputStream &S) const override {
     S += Prefix;
     S += "(";
     Child->print(S);
     S += ")";
   }
 };
 
 class FunctionParam : public Expr {
-  StringView Number;
-
 public:
-  FunctionParam(StringView Number_) : Number(Number_) {}
+  Qualifiers CVR;
+  size_t Level;
+  size_t Number;
+
+  FunctionParam(Qualifiers CVR_, size_t Level_, size_t Number_)
+      : Expr(KFunctionParam), CVR(CVR_), Level(Level_), Number(Number_) {}
 
   void printLeft(OutputStream &S) const override {
     S += "fp";
-    S += Number;
+    S << Number;
   }
 };
 
 class ConversionExpr : public Expr {
   const Node *Type;
   NodeArray Expressions;
 
 public:
void printLeft(OutputStream &S) const override {
     S += "(";
     Ty->print(S);
     S += ")";
     S += Integer;
   }
 };
 
 class IntegerExpr : public Expr {
-  StringView Type;
+public:
+  BuiltinType::Kind Type;
   StringView Value;
 
-public:
-  IntegerExpr(StringView Type_, StringView Value_) : Type(Type_), Value(Value_) {}
+  IntegerExpr(BuiltinType::Kind Type_, StringView Value_)
+      : Expr(KIntegerExpr), Type(Type_), Value(Value_) {}
 
   void printLeft(OutputStream &S) const override {
-    if (Type.size() > 3) {
+    switch (Type) {
+    case BuiltinType::Kwchar_t:
+    case BuiltinType::Kchar:
+    case BuiltinType::Ksigned_char:
+    case BuiltinType::Kunsigned_char:
+    case BuiltinType::Kshort:
+    case BuiltinType::Kunsigned_short:
+    case BuiltinType::K__int128:
+    case BuiltinType::Kunsigned__int128:
       S += "(";
-      S += Type;
+      BuiltinType(Type).printLeft(S);
       S += ")";
+      break;
+    default:
+      break;
     }
 
     if (Value[0] == 'n') {
       S += "-";
       S += Value.dropFront(1);
     } else
       S += Value;
 
-    if (Type.size() <= 3)
-      S += Type;
+    switch (Type) {
+    case BuiltinType::Kint:
+      break;
+    case BuiltinType::Kunsigned_int:
+      S += "u";
+      break;
+    case BuiltinType::Klong:
+      S += "l";
+      break;
+    case BuiltinType::Kunsigned_long:
+      S += "ul";
+      break;
+    case BuiltinType::Klong_long:
+      S += "ll";
+      break;
+    case BuiltinType::Kunsigned_long_long:
+      S += "ull";
+      break;
+    default:
+      break;
+    }
   }
 };
 
 template <class Float> struct FloatData;
 
 template <class Float> class FloatExpr : public Expr {
   const StringView Contents;
 
struct Db {
   Node *parseSubstitution();
   Node *parseTemplateParam();
   Node *parseTemplateArgs(bool TagTemplates = false);
   Node *parseTemplateArg();
 
   /// Parse the <expr> production.
   Node *parseExpr();
   Node *parsePrefixExpr(StringView Kind);
-  Node *parseBinaryExpr(StringView Kind);
-  Node *parseIntegerLiteral(StringView Lit);
+  Node *parseBinaryExpr(BinaryExpr::Operator);
+  Node *parseIntegerLiteral(BuiltinType::Kind);
   Node *parseExprPrimary();
   template <class Float> Node *parseFloatingLiteral();
   Node *parseFunctionParam();
   Node *parseNewExpr();
   Node *parseConversionExpr();
   Node *parseBracedExpr();
   Node *parseFoldExpr();
 
if (Encoding == nullptr || !consumeIf('E'))
     return nullptr;
 
   if (consumeIf('s')) {
     First = parse_discriminator(First, Last);
     return make<LocalName>(Encoding, make<NameType>("string literal"));
   }
 
   if (consumeIf('d')) {
-    parseNumber(true);
+    size_t Num;
+    if (parsePositiveInteger(&Num))
+      Num = 0;
+    else
+      Num += 1;
     if (!consumeIf('_'))
       return nullptr;
     Node *N = parseName(State);
     if (N == nullptr)
       return nullptr;
+    N = make<DefaultArg>(Num, N);
+    if (N == nullptr)
+      return nullptr;
     return make<LocalName>(Encoding, N);
   }
 
   Node *Entity = 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       ::= StL<unqualified-name>
 Node *Db::parseUnscopedName(NameState *State) {
- if (consumeIf("StL") || consumeIf("St")) {
+ if (consumeIf("St")) {
+   bool Local = consumeIf('L');
    Node *R = parseUnqualifiedName(State);
    if (R == nullptr)
      return nullptr;
-   return make<StdQualifiedName>(R);
+   return make<StdQualifiedName>(R, Local);
  }
  return parseUnqualifiedName(State);
 }
 
 // <unqualified-name> ::= <operator-name> [abi-tags]
 //                    ::= <ctor-dtor-name>
 //                    ::= <source-name>
 //                    ::= <unnamed-type-name>

 //                   ::= ss    # <=> C++2a
 //                   ::= v <digit> <source-name>        # vendor extended operator
 Node *Db::parseOperatorName(NameState *State) {
   switch (look()) {
   case 'a':
     switch (look(1)) {
     case 'a':
       First += 2;
-      return make<NameType>("operator&&");
+      return make<OperatorName>(OperatorName::Oamp_amp);
     case 'd':
+      First += 2;
+      return make<OperatorName>(OperatorName::Oamp1);
     case 'n':
       First += 2;
-      return make<NameType>("operator&");
+      return make<OperatorName>(OperatorName::Oamp);
     case 'N':
       First += 2;
-      return make<NameType>("operator&=");
+      return make<OperatorName>(OperatorName::Oamp_eq);
     case 'S':
       First += 2;
-      return make<NameType>("operator=");
+      return make<OperatorName>(OperatorName::Oeq);
     }
     return nullptr;
   case 'c':
     switch (look(1)) {
     case 'l':
       First += 2;
-      return make<NameType>("operator()");
+      return make<OperatorName>(OperatorName::Ocall);
     case 'm':
       First += 2;
-      return make<NameType>("operator,");
+      return make<OperatorName>(OperatorName::Ocomma);
     case 'o':
       First += 2;
-      return make<NameType>("operator~");
+      return make<OperatorName>(OperatorName::Otilde);
     //                   ::= cv <type>    # (cast)
     case 'v': {
       First += 2;
       SwapAndRestore<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.
       SwapAndRestore<bool> SavePermit(PermitForwardTemplateReferences,
                                       PermitForwardTemplateReferences ||
                                           State != nullptr);
       Node* Ty = parseType();
       if (Ty == nullptr)
         return nullptr;
       if (State) State->CtorDtorConversion = true;
       return make<ConversionOperatorType>(Ty);
     }
     }
     return nullptr;
   case 'd':
     switch (look(1)) {
     case 'a':
       First += 2;
-      return make<NameType>("operator delete[]");
+      return make<OperatorName>(OperatorName::Odel_arr);
     case 'e':
       First += 2;
-      return make<NameType>("operator*");
+      return make<OperatorName>(OperatorName::Oderef);
     case 'l':
       First += 2;
-      return make<NameType>("operator delete");
+      return make<OperatorName>(OperatorName::Odel);
     case 'v':
       First += 2;
-      return make<NameType>("operator/");
+      return make<OperatorName>(OperatorName::Oslash);
     case 'V':
       First += 2;
-      return make<NameType>("operator/=");
+      return make<OperatorName>(OperatorName::Oslash_eq);
     }
     return nullptr;
   case 'e':
     switch (look(1)) {
     case 'o':
       First += 2;
-      return make<NameType>("operator^");
+      return make<OperatorName>(OperatorName::Ocaret);
     case 'O':
       First += 2;
-      return make<NameType>("operator^=");
+      return make<OperatorName>(OperatorName::Ocaret_eq);
     case 'q':
       First += 2;
-      return make<NameType>("operator==");
+      return make<OperatorName>(OperatorName::Oeq_eq);
     }
     return nullptr;
   case 'g':
     switch (look(1)) {
     case 'e':
       First += 2;
-      return make<NameType>("operator>=");
+      return make<OperatorName>(OperatorName::Ogt_eq);
     case 't':
       First += 2;
-      return make<NameType>("operator>");
+      return make<OperatorName>(OperatorName::Ogt);
     }
     return nullptr;
   case 'i':
     if (look(1) == 'x') {
       First += 2;
-      return make<NameType>("operator[]");
+      return make<OperatorName>(OperatorName::Oindex);
     }
     return nullptr;
   case 'l':
     switch (look(1)) {
     case 'e':
       First += 2;
-      return make<NameType>("operator<=");
+      return make<OperatorName>(OperatorName::Olt_eq);
     //                   ::= li <source-name>  # operator ""
     case 'i': {
       First += 2;
       Node *SN = parseSourceName(State);
       if (SN == nullptr)
         return nullptr;
       return make<LiteralOperator>(SN);
     }
     case 's':
       First += 2;
-      return make<NameType>("operator<<");
+      return make<OperatorName>(OperatorName::Olt_lt);
     case 'S':
       First += 2;
-      return make<NameType>("operator<<=");
+      return make<OperatorName>(OperatorName::Olt_lt_eq);
     case 't':
       First += 2;
-      return make<NameType>("operator<");
+      return make<OperatorName>(OperatorName::Olt);
     }
     return nullptr;
   case 'm':
     switch (look(1)) {
     case 'i':
       First += 2;
-      return make<NameType>("operator-");
+      return make<OperatorName>(OperatorName::Osub);
     case 'I':
       First += 2;
-      return make<NameType>("operator-=");
+      return make<OperatorName>(OperatorName::Osub_eq);
     case 'l':
       First += 2;
-      return make<NameType>("operator*");
+      return make<OperatorName>(OperatorName::Omul);
     case 'L':
       First += 2;
-      return make<NameType>("operator*=");
+      return make<OperatorName>(OperatorName::Omul_eq);
     case 'm':
       First += 2;
-      return make<NameType>("operator--");
+      return make<OperatorName>(OperatorName::Osub_sub);
     }
     return nullptr;
   case 'n':
     switch (look(1)) {
     case 'a':
       First += 2;
-      return make<NameType>("operator new[]");
+      return make<OperatorName>(OperatorName::Onew_arr);
     case 'e':
       First += 2;
-      return make<NameType>("operator!=");
+      return make<OperatorName>(OperatorName::Onot_eq);
     case 'g':
       First += 2;
-      return make<NameType>("operator-");
+      return make<OperatorName>(OperatorName::Oneg);
     case 't':
       First += 2;
-      return make<NameType>("operator!");
+      return make<OperatorName>(OperatorName::Onot);
     case 'w':
       First += 2;
-      return make<NameType>("operator new");
+      return make<OperatorName>(OperatorName::Onew);
     }
     return nullptr;
   case 'o':
     switch (look(1)) {
     case 'o':
       First += 2;
-      return make<NameType>("operator||");
+      return make<OperatorName>(OperatorName::Oor_or);
     case 'r':
       First += 2;
-      return make<NameType>("operator|");
+      return make<OperatorName>(OperatorName::Oor);
     case 'R':
       First += 2;
-      return make<NameType>("operator|=");
+      return make<OperatorName>(OperatorName::Oor_eq);
     }
     return nullptr;
   case 'p':
     switch (look(1)) {
     case 'm':
       First += 2;
-      return make<NameType>("operator->*");
+      return make<OperatorName>(OperatorName::Oarrow_mul);
     case 'l':
       First += 2;
-      return make<NameType>("operator+");
+      return make<OperatorName>(OperatorName::Oplus);
     case 'L':
       First += 2;
-      return make<NameType>("operator+=");
+      return make<OperatorName>(OperatorName::Oplus_eq);
     case 'p':
       First += 2;
-      return make<NameType>("operator++");
+      return make<OperatorName>(OperatorName::Oplus_plus);
     case 's':
       First += 2;
-      return make<NameType>("operator+");
+      return make<OperatorName>(OperatorName::Oplus1);
     case 't':
       First += 2;
-      return make<NameType>("operator->");
+      return make<OperatorName>(OperatorName::Oarrow);
     }
     return nullptr;
   case 'q':
     if (look(1) == 'u') {
       First += 2;
-      return make<NameType>("operator?");
+      return make<OperatorName>(OperatorName::Oternary);
     }
     return nullptr;
   case 'r':
     switch (look(1)) {
     case 'm':
       First += 2;
-      return make<NameType>("operator%");
+      return make<OperatorName>(OperatorName::Omod);
     case 'M':
       First += 2;
-      return make<NameType>("operator%=");
+      return make<OperatorName>(OperatorName::Omod_eq);
     case 's':
       First += 2;
-      return make<NameType>("operator>>");
+      return make<OperatorName>(OperatorName::Ogt_gt);
     case 'S':
       First += 2;
-      return make<NameType>("operator>>=");
+      return make<OperatorName>(OperatorName::Ogt_gt_eq);
     }
     return nullptr;
   case 's':
     if (look(1) == 's') {
       First += 2;
-      return make<NameType>("operator<=>");
+      return make<OperatorName>(OperatorName::Olt_eq_gt);
     }
     return nullptr;
   // ::= v <digit> <source-name>        # vendor extended operator
   case 'v':
     if (std::isdigit(look(1))) {
       First += 2;
       Node *SN = parseSourceName(State);
       if (SN == nullptr)
default:
       break;
     }
   }
 
   if (consumeIf('C')) {
     bool IsInherited = consumeIf('I');
     if (look() != '1' && look() != '2' && look() != '3' && look() != '5')
       return nullptr;
+    uint8_t Flavor = look()-'0';
     ++First;
     if (State) State->CtorDtorConversion = true;
     if (IsInherited) {
       if (parseName(State) == nullptr)
         return nullptr;
     }
-    return make<CtorDtorName>(SoFar, false);
+    return make<CtorDtorName>(SoFar, false, Flavor);
   }
 
   if (look() == 'D' &&
       (look(1) == '0' || look(1) == '1' || look(1) == '2' || look(1) == '5')) {
+    uint8_t Flavor = look(1) - '0';
     First += 2;
     if (State) State->CtorDtorConversion = true;
-    return make<CtorDtorName>(SoFar, true);
+    return make<CtorDtorName>(SoFar, true, Flavor);
   }
 
   return nullptr;
 }
 
 // <nested-name> ::= N [<CV-Qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
 //               ::= N [<CV-Qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
 //
Node *Db::parseNestedName(NameState *State) {
   Node *SoFar = nullptr;
   auto PushComponent = [&](Node *Comp) {
     if (SoFar) SoFar = make<NestedName>(SoFar, Comp);
     else       SoFar = Comp;
     if (State) State->EndsWithTemplateArgs = false;
   };
 
   if (consumeIf("St"))
-    SoFar = make<NameType>("std");
+    SoFar = make<StdName>();
 
   while (!consumeIf('E')) {
     consumeIf('L'); // extension
 
     // <data-member-prefix> := <member source-name> [<template-args>] M
     if (consumeIf('M')) {
       if (SoFar == nullptr)
         return nullptr;
while (!consumeIf('E')) {
     PushComponent(N);
     Subs.push_back(SoFar);
   }
 
   if (SoFar == nullptr || Subs.empty())
     return nullptr;
 
   Subs.pop_back();
-  return SoFar;
+  return make<FullNestedName>(SoFar);
 }
 
 // <simple-id> ::= <source-name> [ <template-args> ]
 Node *Db::parseSimpleId() {
   Node *SN = parseSourceName(/*NameState=*/nullptr);
   if (SN == nullptr)
     return nullptr;
   if (look() == 'I') {

 //
 // <ref-qualifier> ::= R                   # & ref-qualifier
 // <ref-qualifier> ::= O                   # && ref-qualifier
 Node *Db::parseFunctionType() {
   Qualifiers CVQuals = parseCVQualifiers();
 
   Node *ExceptionSpec = nullptr;
   if (consumeIf("Do")) {
-    ExceptionSpec = make<NameType>("noexcept");
+    ExceptionSpec = make<NoexceptSpec>(nullptr);
   } else if (consumeIf("DO")) {
     Node *E = parseExpr();
     if (E == nullptr || !consumeIf('E'))
       return nullptr;
     ExceptionSpec = make<NoexceptSpec>(E);
   } else if (consumeIf("Dw")) {
     size_t SpecsBegin = Names.size();
     while (!consumeIf('E')) {
Node *Db::parseVectorType() {
   return make<VectorType>(ElemType, StringView());
 }
 
 // <decltype>  ::= Dt <expression> E  # decltype of an id-expression or class member access (C++0x)
 //             ::= DT <expression> E  # decltype of an expression (C++0x)
 Node *Db::parseDecltype() {
   if (!consumeIf('D'))
     return nullptr;
-  if (!consumeIf('t') && !consumeIf('T'))
+  EnclosingExprX::Kind K;
+  if (consumeIf('t'))
+    K = EnclosingExprX::KdecltypeId;
+  else if(consumeIf('T'))
+    K = EnclosingExprX::Kdecltype;
+  else
     return nullptr;
   Node *E = parseExpr();
   if (E == nullptr)
     return nullptr;
   if (!consumeIf('E'))
     return nullptr;
-  return make<EnclosingExpr>("decltype(", E, ")");
+  return make<EnclosingExprX>(K, E);
 }
 
 // <array-type> ::= A <positive dimension number> _ <element type>
 //              ::= A [<dimension expression>] _ <element type>
 Node *Db::parseArrayType() {
   if (!consumeIf('A'))
     return nullptr;
 
Node *Db::parsePointerToMemberType() {
   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'
 Node *Db::parseClassEnumType() {
-  StringView ElabSpef;
+  bool ElaborationFound = true;
+  ElaboratedTypeSpefType::Kind ElabSpef;
   if (consumeIf("Ts"))
-    ElabSpef = "struct";
+    ElabSpef = ElaboratedTypeSpefType::Kstruct;
   else if (consumeIf("Tu"))
-    ElabSpef = "union";
+    ElabSpef = ElaboratedTypeSpefType::Kunion;
   else if (consumeIf("Te"))
-    ElabSpef = "enum";
+    ElabSpef = ElaboratedTypeSpefType::Kenum;
+  else
+    ElaborationFound = false;
 
   Node *Name = parseName();
   if (Name == nullptr)
     return nullptr;
 
-  if (!ElabSpef.empty())
+  if (ElaborationFound)
     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
Node *Db::parseType() {
   }
   case 'U': {
     Result = parseQualifiedType();
     break;
   }
   // <builtin-type> ::= v    # void
   case 'v':
     ++First;
-    return make<NameType>("void");
+    return make<BuiltinType>(BuiltinType::Kvoid);
   //                ::= w    # wchar_t
   case 'w':
     ++First;
-    return make<NameType>("wchar_t");
+    return make<BuiltinType>(BuiltinType::Kwchar_t);
   //                ::= b    # bool
   case 'b':
     ++First;
-    return make<NameType>("bool");
+    return make<BuiltinType>(BuiltinType::Kbool);
   //                ::= c    # char
   case 'c':
     ++First;
-    return make<NameType>("char");
+    return make<BuiltinType>(BuiltinType::Kchar);
   //                ::= a    # signed char
   case 'a':
     ++First;
-    return make<NameType>("signed char");
+    return make<BuiltinType>(BuiltinType::Ksigned_char);
   //                ::= h    # unsigned char
   case 'h':
     ++First;
-    return make<NameType>("unsigned char");
+    return make<BuiltinType>(BuiltinType::Kunsigned_char);
   //                ::= s    # short
   case 's':
     ++First;
-    return make<NameType>("short");
+    return make<BuiltinType>(BuiltinType::Kshort);
   //                ::= t    # unsigned short
   case 't':
     ++First;
-    return make<NameType>("unsigned short");
+    return make<BuiltinType>(BuiltinType::Kunsigned_short);
   //                ::= i    # int
   case 'i':
     ++First;
-    return make<NameType>("int");
+    return make<BuiltinType>(BuiltinType::Kint);
   //                ::= j    # unsigned int
   case 'j':
     ++First;
-    return make<NameType>("unsigned int");
+    return make<BuiltinType>(BuiltinType::Kunsigned_int);
   //                ::= l    # long
   case 'l':
     ++First;
-    return make<NameType>("long");
+    return make<BuiltinType>(BuiltinType::Klong);
   //                ::= m    # unsigned long
   case 'm':
     ++First;
-    return make<NameType>("unsigned long");
+    return make<BuiltinType>(BuiltinType::Kunsigned_long);
   //                ::= x    # long long, __int64
   case 'x':
     ++First;
-    return make<NameType>("long long");
+    return make<BuiltinType>(BuiltinType::Klong_long);
   //                ::= y    # unsigned long long, __int64
   case 'y':
     ++First;
-    return make<NameType>("unsigned long long");
+    return make<BuiltinType>(BuiltinType::Kunsigned_long_long);
   //                ::= n    # __int128
   case 'n':
     ++First;
-    return make<NameType>("__int128");
+    return make<BuiltinType>(BuiltinType::K__int128);
   //                ::= o    # unsigned __int128
   case 'o':
     ++First;
-    return make<NameType>("unsigned __int128");
+    return make<BuiltinType>(BuiltinType::Kunsigned__int128);
   //                ::= f    # float
   case 'f':
     ++First;
-    return make<NameType>("float");
+    return make<BuiltinType>(BuiltinType::Kfloat);
   //                ::= d    # double
   case 'd':
     ++First;
-    return make<NameType>("double");
+    return make<BuiltinType>(BuiltinType::Kdouble);
   //                ::= e    # long double, __float80
   case 'e':
     ++First;
-    return make<NameType>("long double");
+    return make<BuiltinType>(BuiltinType::Klong_double);
   //                ::= g    # __float128
   case 'g':
     ++First;
-    return make<NameType>("__float128");
+    return make<BuiltinType>(BuiltinType::K__float128);
   //                ::= z    # ellipsis
   case 'z':
     ++First;
-    return make<NameType>("...");
+    return make<BuiltinType>(BuiltinType::Kellipsis);
 
   // <builtin-type> ::= u <source-name>    # vendor extended type
   case 'u': {
     ++First;
     StringView Res = parseBareSourceName();
     if (Res.empty())
       return nullptr;
     return make<NameType>(Res);
case 'O': {
     break;
   }
   //             ::= C <type>        # complex pair (C99)
   case 'C': {
     ++First;
     Node *P = parseType();
     if (P == nullptr)
       return nullptr;
-    Result = make<PostfixQualifiedType>(P, " complex");
+    Result = make<PostfixQualifiedType>(P, PostfixQualifiedType::KComplex);
     break;
   }
   //             ::= G <type>        # imaginary (C99)
   case 'G': {
     ++First;
     Node *P = parseType();
     if (P == nullptr)
       return P;
-    Result = make<PostfixQualifiedType>(P, " imaginary");
+    Result = make<PostfixQualifiedType>(P, PostfixQualifiedType::KImaginary);
     break;
   }
   //             ::= <substitution>  # See Compression below
   case 'S': {
     if (look(1) && look(1) != 't') {
       Node *Sub = parseSubstitution();
       if (Sub == nullptr)
         return nullptr;

 
 Node *Db::parsePrefixExpr(StringView Kind) {
   Node *E = parseExpr();
   if (E == nullptr)
     return nullptr;
   return make<PrefixExpr>(Kind, E);
 }
 
-Node *Db::parseBinaryExpr(StringView Kind) {
+Node *Db::parseBinaryExpr(BinaryExpr::Operator Op) {
   Node *LHS = parseExpr();
   if (LHS == nullptr)
     return nullptr;
   Node *RHS = parseExpr();
   if (RHS == nullptr)
     return nullptr;
-  return make<BinaryExpr>(LHS, Kind, RHS);
+  return make<BinaryExpr>(LHS, Op, RHS);
 }
 
-Node *Db::parseIntegerLiteral(StringView Lit) {
+Node *Db::parseIntegerLiteral(BuiltinType::Kind K) {
   StringView Tmp = parseNumber(true);
   if (!Tmp.empty() && consumeIf('E'))
-    return make<IntegerExpr>(Lit, Tmp);
+    return make<IntegerExpr>(K, Tmp);
   return nullptr;
 }
 
 // <CV-Qualifiers> ::= [r] [V] [K]
 Qualifiers Db::parseCVQualifiers() {
   Qualifiers CVR = QualNone;
   if (consumeIf('r'))
     addQualifiers(CVR, QualRestrict);
   if (consumeIf('V'))
     addQualifiers(CVR, QualVolatile);
   if (consumeIf('K'))
     addQualifiers(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
 Node *Db::parseFunctionParam() {
-  if (consumeIf("fp")) {
-    parseCVQualifiers();
-    StringView Num = parseNumber();
-    if (!consumeIf('_'))
-      return nullptr;
-    return make<FunctionParam>(Num);
-  }
-  if (consumeIf("fL")) {
-    if (parseNumber().empty())
+  if (!consumeIf('f'))
+  size_t Level = 0;
+  if (consumeIf("L")) {
+    if (parsePositiveInteger(&Level))
       return nullptr;
-    if (!consumeIf('p'))
-      return nullptr;
-    parseCVQualifiers();
-    StringView Num = parseNumber();
+    ++Level;
+  }
+  Qualifiers CVR = parseCVQualifiers();
+  size_t Num = 0;
+  if (!consumeIf('_')) {
+    if (parsePositiveInteger(&Num))
+      return nullptr;
+    ++Num;
     if (!consumeIf('_'))
       return nullptr;
-    return make<FunctionParam>(Num);
   }
-  return nullptr;
+  return make<FunctionParam>(CVR, Level, Num);
 }
 
 // [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)
 // <initializer> ::= pi <expression>* E                 # parenthesized initialization
 Node *Db::parseNewExpr() {

 // FIXME:         ::= L <type> <real-part float> _ <imag-part float> E   # complex floating point literal (C 2000)
 //                ::= L <mangled-name> E                                 # external name
 Node *Db::parseExprPrimary() {
   if (!consumeIf('L'))
     return nullptr;
   switch (look()) {
   case 'w':
     ++First;
-    return parseIntegerLiteral("wchar_t");
+    return parseIntegerLiteral(BuiltinType::Kwchar_t);
   case 'b':
     if (consumeIf("b0E"))
       return make<BoolExpr>(0);
     if (consumeIf("b1E"))
       return make<BoolExpr>(1);
     return nullptr;
   case 'c':
     ++First;
-    return parseIntegerLiteral("char");
+    return parseIntegerLiteral(BuiltinType::Kchar);
   case 'a':
     ++First;
-    return parseIntegerLiteral("signed char");
+    return parseIntegerLiteral(BuiltinType::Ksigned_char);
   case 'h':
     ++First;
-    return parseIntegerLiteral("unsigned char");
+    return parseIntegerLiteral(BuiltinType::Kunsigned_char);
   case 's':
     ++First;
-    return parseIntegerLiteral("short");
+    return parseIntegerLiteral(BuiltinType::Kshort);
   case 't':
     ++First;
-    return parseIntegerLiteral("unsigned short");
+    return parseIntegerLiteral(BuiltinType::Kunsigned_short);
   case 'i':
     ++First;
-    return parseIntegerLiteral("");
+    return parseIntegerLiteral(BuiltinType::Kint);
   case 'j':
     ++First;
-    return parseIntegerLiteral("u");
+    return parseIntegerLiteral(BuiltinType::Kunsigned_int);
   case 'l':
     ++First;
-    return parseIntegerLiteral("l");
+    return parseIntegerLiteral(BuiltinType::Klong);
   case 'm':
     ++First;
-    return parseIntegerLiteral("ul");
+    return parseIntegerLiteral(BuiltinType::Kunsigned_long);
   case 'x':
     ++First;
-    return parseIntegerLiteral("ll");
+    return parseIntegerLiteral(BuiltinType::Klong_long);
   case 'y':
     ++First;
-    return parseIntegerLiteral("ull");
+    return parseIntegerLiteral(BuiltinType::Kunsigned_long_long);
   case 'n':
     ++First;
-    return parseIntegerLiteral("__int128");
+    return parseIntegerLiteral(BuiltinType::K__int128);
   case 'o':
     ++First;
-    return parseIntegerLiteral("unsigned __int128");
+    return parseIntegerLiteral(BuiltinType::Kunsigned__int128);
   case 'f':
     ++First;
     return parseFloatingLiteral<float>();
   case 'd':
     ++First;
     return parseFloatingLiteral<double>();
   case 'e':
     ++First;
case 'f': {
     if (look(1) == 'p' || (look(1) == 'L' && std::isdigit(look(2))))
       return parseFunctionParam();
     return parseFoldExpr();
   }
   case 'a':
     switch (First[1]) {
     case 'a':
       First += 2;
-      return parseBinaryExpr("&&");
+      return parseBinaryExpr(BinaryExpr::Oamp_amp);
     case 'd':
       First += 2;
       return parsePrefixExpr("&");
     case 'n':
       First += 2;
-      return parseBinaryExpr("&");
+      return parseBinaryExpr(BinaryExpr::Oamp);
     case 'N':
       First += 2;
-      return parseBinaryExpr("&=");
+      return parseBinaryExpr(BinaryExpr::Oamp_eq);
     case 'S':
       First += 2;
-      return parseBinaryExpr("=");
+      return parseBinaryExpr(BinaryExpr::Oeq);
     case 't': {
       First += 2;
       Node *Ty = parseType();
       if (Ty == nullptr)
         return nullptr;
       return make<EnclosingExpr>("alignof (", Ty, ")");
     }
     case 'z': {
case 'l': {
         if (E == nullptr)
           return E;
         Names.push_back(E);
       }
       return make<CallExpr>(Callee, popTrailingNodeArray(ExprsBegin));
     }
     case 'm':
       First += 2;
-      return parseBinaryExpr(",");
+      return parseBinaryExpr(BinaryExpr::Ocomma);
     case 'o':
       First += 2;
       return parsePrefixExpr("~");
     case 'v':
       return parseConversionExpr();
     }
     return nullptr;
   case 'd':
case 't': {
         return LHS;
       Node *RHS = parseExpr();
       if (RHS == nullptr)
         return nullptr;
       return make<MemberExpr>(LHS, ".", RHS);
     }
     case 'v':
       First += 2;
-      return parseBinaryExpr("/");
+      return parseBinaryExpr(BinaryExpr::Oslash);
     case 'V':
       First += 2;
-      return parseBinaryExpr("/=");
+      return parseBinaryExpr(BinaryExpr::Oslash_eq);
     }
     return nullptr;
   case 'e':
     switch (First[1]) {
     case 'o':
       First += 2;
-      return parseBinaryExpr("^");
+      return parseBinaryExpr(BinaryExpr::Ocaret);
     case 'O':
       First += 2;
-      return parseBinaryExpr("^=");
+      return parseBinaryExpr(BinaryExpr::Ocaret_eq);
     case 'q':
       First += 2;
-      return parseBinaryExpr("==");
+      return parseBinaryExpr(BinaryExpr::Oeq_eq);
     }
     return nullptr;
   case 'g':
     switch (First[1]) {
     case 'e':
       First += 2;
-      return parseBinaryExpr(">=");
+      return parseBinaryExpr(BinaryExpr::Ogt_eq);
     case 't':
       First += 2;
-      return parseBinaryExpr(">");
+      return parseBinaryExpr(BinaryExpr::Ogt);
     }
     return nullptr;
   case 'i':
     switch (First[1]) {
     case 'x': {
       First += 2;
       Node *Base = parseExpr();
       if (Base == nullptr)
case 'l': {
       return make<InitListExpr>(nullptr, popTrailingNodeArray(InitsBegin));
     }
     }
     return nullptr;
   case 'l':
     switch (First[1]) {
     case 'e':
       First += 2;
-      return parseBinaryExpr("<=");
+      return parseBinaryExpr(BinaryExpr::Olt_eq);
     case 's':
       First += 2;
-      return parseBinaryExpr("<<");
+      return parseBinaryExpr(BinaryExpr::Olt_lt);
     case 'S':
       First += 2;
-      return parseBinaryExpr("<<=");
+      return parseBinaryExpr(BinaryExpr::Olt_lt_eq);
     case 't':
       First += 2;
-      return parseBinaryExpr("<");
+      return parseBinaryExpr(BinaryExpr::Olt);
     }
     return nullptr;
   case 'm':
     switch (First[1]) {
     case 'i':
       First += 2;
-      return parseBinaryExpr("-");
+      return parseBinaryExpr(BinaryExpr::Osub);
     case 'I':
       First += 2;
-      return parseBinaryExpr("-=");
+      return parseBinaryExpr(BinaryExpr::Osub_eq);
     case 'l':
       First += 2;
-      return parseBinaryExpr("*");
+      return parseBinaryExpr(BinaryExpr::Omul);
     case 'L':
       First += 2;
-      return parseBinaryExpr("*=");
+      return parseBinaryExpr(BinaryExpr::Omul_eq);
     case 'm':
       First += 2;
       if (consumeIf('_'))
         return parsePrefixExpr("--");
       Node *Ex = parseExpr();
       if (Ex == nullptr)
         return nullptr;
       return make<PostfixExpr>(Ex, "--");
     }
     return nullptr;
   case 'n':
     switch (First[1]) {
     case 'a':
     case 'w':
       return parseNewExpr();
     case 'e':
       First += 2;
-      return parseBinaryExpr("!=");
+      return parseBinaryExpr(BinaryExpr::Onot_eq);
     case 'g':
       First += 2;
       return parsePrefixExpr("-");
     case 't':
       First += 2;
       return parsePrefixExpr("!");
     case 'x':
       First += 2;
       Node *Ex = parseExpr();
       if (Ex == nullptr)
         return Ex;
       return make<EnclosingExpr>("noexcept (", Ex, ")");
     }
     return nullptr;
   case 'o':
     switch (First[1]) {
     case 'n':
       return parseUnresolvedName();
     case 'o':
       First += 2;
-      return parseBinaryExpr("||");
+      return parseBinaryExpr(BinaryExpr::Oor_or);
     case 'r':
       First += 2;
-      return parseBinaryExpr("|");
+      return parseBinaryExpr(BinaryExpr::Oor);
     case 'R':
       First += 2;
-      return parseBinaryExpr("|=");
+      return parseBinaryExpr(BinaryExpr::Oor_eq);
     }
     return nullptr;
   case 'p':
     switch (First[1]) {
     case 'm':
       First += 2;
-      return parseBinaryExpr("->*");
+      return parseBinaryExpr(BinaryExpr::Oarrow_mul);
     case 'l':
       First += 2;
-      return parseBinaryExpr("+");
+      return parseBinaryExpr(BinaryExpr::Oplus);
     case 'L':
       First += 2;
-      return parseBinaryExpr("+=");
+      return parseBinaryExpr(BinaryExpr::Oplus_eq);
     case 'p': {
       First += 2;
       if (consumeIf('_'))
         return parsePrefixExpr("++");
       Node *Ex = parseExpr();
       if (Ex == nullptr)
         return Ex;
       return make<PostfixExpr>(Ex, "++");
case 'c': {
         return T;
       Node *Ex = parseExpr();
       if (Ex == nullptr)
         return Ex;
       return make<CastExpr>("reinterpret_cast", T, Ex);
     }
     case 'm':
       First += 2;
-      return parseBinaryExpr("%");
+      return parseBinaryExpr(BinaryExpr::Omod);
     case 'M':
       First += 2;
-      return parseBinaryExpr("%=");
+      return parseBinaryExpr(BinaryExpr::Omod_eq);
     case 's':
       First += 2;
-      return parseBinaryExpr(">>");
+      return parseBinaryExpr(BinaryExpr::Ogt_gt);
     case 'S':
       First += 2;
-      return parseBinaryExpr(">>=");
+      return parseBinaryExpr(BinaryExpr::Ogt_gt_eq);
     }
     return nullptr;
   case 's':
     switch (First[1]) {
     case 'c': {
       First += 2;
       Node *T = parseType();
       if (T == nullptr)
case 's':
     }
     case 'r':
       return parseUnresolvedName();
     case 't': {
       First += 2;
       Node *Ty = parseType();
       if (Ty == nullptr)
         return Ty;
-      return make<EnclosingExpr>("sizeof (", Ty, ")");
+      return make<EnclosingExprX>(EnclosingExprX::Ksizeof, Ty);
     }
     case 'z': {
       First += 2;
       Node *Ex = parseExpr();
       if (Ex == nullptr)
         return Ex;
       return make<EnclosingExpr>("sizeof (", Ex, ")");
     }
case 'P': {
       First += 2;
       size_t ArgsBegin = Names.size();
       while (!consumeIf('E')) {
         Node *Arg = parseTemplateArg();
         if (Arg == nullptr)
           return nullptr;
         Names.push_back(Arg);
       }
-      return make<EnclosingExpr>(
-          "sizeof... (", make<NodeArrayNode>(popTrailingNodeArray(ArgsBegin)),
-          ")");
+      return make<SizeofAliasParamPackExpr>(popTrailingNodeArray(ArgsBegin));
     }
     }
     return nullptr;
   case 't':
     switch (First[1]) {
     case 'e': {
       First += 2;
       Node *Ex = parseExpr();
Node *Db::parseSpecialName() {
   case 'T':
     switch (look(1)) {
     // TV <type>    # virtual table
     case 'V': {
       First += 2;
       Node *Ty = parseType();
       if (Ty == nullptr)
         return nullptr;
-      return make<SpecialName>("vtable for ", Ty);
+      return make<SpecialNameX>(SpecialNameX::KVTable, Ty);
     }
     // TT <type>    # VTT structure (construction vtable index)
     case 'T': {
       First += 2;
       Node *Ty = parseType();
       if (Ty == nullptr)
         return nullptr;
-      return make<SpecialName>("VTT for ", Ty);
+      return make<SpecialNameX>(SpecialNameX::KVTT, Ty);
     }
     // TI <type>    # typeinfo structure
     case 'I': {
       First += 2;
       Node *Ty = parseType();
       if (Ty == nullptr)
         return nullptr;
-      return make<SpecialName>("typeinfo for ", Ty);
+      return make<SpecialNameX>(SpecialNameX::KTypeinfo, Ty);
     }
     // TS <type>    # typeinfo name (null-terminated byte string)
     case 'S': {
       First += 2;
       Node *Ty = parseType();
       if (Ty == nullptr)
         return nullptr;
-      return make<SpecialName>("typeinfo name for ", Ty);
+      return make<SpecialNameX>(SpecialNameX::KTypename, Ty);
     }
     // Tc <call-offset> <call-offset> <base encoding>
     case 'c': {
       First += 2;
       if (parseCallOffset() || parseCallOffset())
         return nullptr;
       Node *Encoding = parseEncoding();
       if (Encoding == nullptr)
case 'C': {
       return make<CtorVtableSpecialName>(SecondType, FirstType);
     }
     // TW <object name> # Thread-local wrapper
     case 'W': {
       First += 2;
       Node *Name = parseName();
       if (Name == nullptr)
         return nullptr;
-      return make<SpecialName>("thread-local wrapper routine for ", Name);
+      return make<SpecialNameX>(SpecialNameX::KThreadWrapper, Name);
     }
     // TH <object name> # Thread-local initialization
     case 'H': {
       First += 2;
       Node *Name = parseName();
       if (Name == nullptr)
         return nullptr;
-      return make<SpecialName>("thread-local initialization routine for ", Name);
+      return make<SpecialNameX>(SpecialNameX::KThreadInit, Name);
     }
     // T <call-offset> <base encoding>
     default: {
       ++First;
       bool IsVirt = look() == 'v';
       if (parseCallOffset())
         return nullptr;
       Node *BaseEncoding = 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 = parseName();
       if (Name == nullptr)
         return nullptr;
-      return make<SpecialName>("guard variable for ", Name);
+      return make<SpecialNameX>(SpecialNameX::KGuardVar, 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 = parseName();
       if (Name == nullptr)
Node *Db::parseSubstitution() {
 
   //                ::= S <seq-id> _
   size_t Index = 0;
   if (parseSeqId(&Index))
     return nullptr;
   ++Index;
   if (!consumeIf('_') || Index >= Subs.size())
     return nullptr;
+  return make<Substitution>(Index, Subs[Index]);
   return Subs[Index];
 }
 
 // <template-param> ::= T_    # first template parameter
 //                  ::= T <parameter-2 non-negative number> _
 Node *Db::parseTemplateParam() {
   if (!consumeIf('T'))
     return nullptr;
Node *Db::parseTemplateParam() {
   // operator types), then we should only look it up in the right context.
   if (PermitForwardTemplateReferences) {
     ForwardTemplateRefs.push_back(make<ForwardTemplateReference>(Index));
     return ForwardTemplateRefs.back();
   }
 
   if (Index >= TemplateParams.size())
     return nullptr;
-  return TemplateParams[Index];
+  return make<ForwardTemplateReference>(Index, TemplateParams[Index]);
 }
 
 // <template-arg> ::= <type>                    # type or template
 //                ::= X <expression> E          # expression
 //                ::= <expr-primary>            # simple expressions
 //                ::= J <template-arg>* E       # argument pack
 //                ::= LZ <encoding> E           # extension
 Node *Db::parseTemplateArg() {
   switch (look()) {
   case 'X': {
     ++First;
     Node *Arg = parseExpr();
     if (Arg == nullptr || !consumeIf('E'))
       return nullptr;
-    return Arg;
+    return make<TemplateExpression>(Arg);
   }
   case 'J': {
     ++First;
     size_t ArgsBegin = Names.size();
     while (!consumeIf('E')) {
       Node *Arg = parseTemplateArg();
       if (Arg == nullptr)
         return nullptr;
if (Buf == nullptr) {
     BufferSize = InitSize;
   } else
     BufferSize = *N;
 
   S.reset(Buf, BufferSize);
   return false;
 }
 
+class Mangler {
+  OutputStream &S;
+
+  void mangle(const NodeArray &A, bool EmptyIsVoid) const {
+    if (A.empty() && EmptyIsVoid) {
+      S += "v";
+      return;
+    }
+    for (Node *P : A)
+      visit(*P);
+  }
+
+  void mangle(StringView Tag) const {
+    S << Tag.size();
+    S += Tag;
+  }
+
+  void mangle(Qualifiers CVQuals) const {
+    if (CVQuals & QualRestrict)
+      S += "r";
+    if (CVQuals & QualVolatile)
+      S += "V";
+    if (CVQuals & QualConst)
+      S += "K";
+  }
+
+  void mangle(BinaryExpr::Operator O) const {
+    static constexpr const char *const Mangle[] = {
+        "aa", "an", "aN", "aS", "cm", "dv", "dV", "eo", "eO", "eq", "ge",
+        "gt", "le", "ls", "lS", "lt", "mi", "mI", "ml", "mL", "ne", "oo",
+        "or", "oR", "pm", "pl", "pL", "rm", "rM", "rs", "rS",
+    };
+    S += Mangle[O];
+  }
+
+  void mangle(EnclosingExprX::Kind K) const {
+    static constexpr const char *Mangle[] = {
+        "st",
+        "Dt",
+        "DT",
+    };
+    S += Mangle[K];
+  }
+
+  void visitDotSuffix(const DotSuffix &N, const Qualifiers *) const {
+    visit(*N.Prefix);
+    S += N.Suffix;
+  }
+  void visitVendorExtQualType(const VendorExtQualType &N,
+                              const Qualifiers *) const {
+    S += "U";
+    S << N.Ext.size();
+    S += N.Ext;
+    visit(*N.Ty);
+  }
+  void visitQualType(const QualType &N, const Qualifiers *) const {
+    mangle(N.Quals);
+    visit(*N.Child);
+  }
+  void visitConversionOperatorType(const ConversionOperatorType &N,
+                                   const Qualifiers *CVQuals) const {
+    S += "cv";
+    visit(*N.Ty);
+  }
+  void visitPostfixQualifiedType(const PostfixQualifiedType &N,
+                                 const Qualifiers *) const {
+    static constexpr char Mangle[] = {'C', 'G'};
+    S += Mangle[N.K];
+    visit(*N.Ty);
+  }
+  void visitElaboratedTypeSpefType(const ElaboratedTypeSpefType &N,
+                                   const Qualifiers *) const {
+    static constexpr const char *Mangle[] = {"Ts", "Tu", "Te"};
+    S += Mangle[N.K];
+    visit(*N.Child);
+  }
+  void visitNameType(const NameType &N, const Qualifiers *) const {
+    mangle(N.Name);
+  }
+  void visitOperatorName(const OperatorName &N, const Qualifiers *) const {
+    static constexpr const char *Mangle[] = {
+        "aa", "ad", "an", "aN", "aS", "cl", "cm", "co", "da", "de", "dl", "dv",
+        "dV", "eo", "eO", "eq", "ge", "gt", "ix", "le", "ls", "lS", "lt", "mi",
+        "mI", "ml", "mL", "mm", "na", "ne", "ng", "nt", "nw", "oo", "or", "oR",
+        "pm", "pl", "pL", "pp", "ps", "pt", "qu", "rm", "rM", "rs", "rS", "ss",
+    };
+    S += Mangle[N.K];
+  }
+  void visitBuiltinType(const BuiltinType &N, const Qualifiers *CVQuals) const {
+    static constexpr const char *Mangle[] = {
+        "v", "w",  "b",  "c",  "a",  "h",  "s",  "t",  "i",  "j",
+        "l", "m",  "x",  "y",  "n",  "o",  "f",  "d",  "e",  "g",
+        "e", "Dd", "De", "Df", "Dh", "Di", "Ds", "Da", "Dc", "Dn",
+    };
+    S += Mangle[N.K];
+  }
+  void visitAbiTagAttr(const AbiTagAttr &N, const Qualifiers *) const {
+    visit(*N.Base);
+    S += "B";
+    mangle(N.Tag);
+  }
+  void visitDefaultArg(const DefaultArg &N, const Qualifiers *CVQuals) const {
+    S += "d";
+    if (N.Number)
+      S << N.Number;
+    S += "_";
+    visit(*N.Name, CVQuals);
+  }
+  void visitEnableIfAttr(const EnableIfAttr &N,
+                         const Qualifiers *CVQuals) const {
+    S += "Ua9enable_ifI";
+    mangle(N.Conditions, false);
+    S += "E";
+  }
+  void visitObjCProtoName(const ObjCProtoName &N,
+                          const Qualifiers *) const {
+    char Buffer[20];
+    OutputStream S1(Buffer, sizeof(Buffer));
+    S1 << N.Protocol.size();
+
+    S += "U";
+    S << 9 + S1.getCurrentPosition() + N.Protocol.size();
+    S += "objcproto";
+    S += StringView(S1.getBuffer(), S1.getCurrentPosition());
+    S += N.Protocol;
+    visit(*N.Ty);
+  }
+  void visitPointerType(const PointerType &N, const Qualifiers *CVQuals) const {
+    S += "P";
+    visit(*N.Pointee);
+  }
+  void visitReferenceType(const ReferenceType &N,
+                          const Qualifiers *CVQuals) const {
+    switch (N.RK) {
+    case ReferenceKind::LValue:
+      S += "R";
+      break;
+    case ReferenceKind::RValue:
+      S += "O";
+      break;
+    }
+    visit(*N.Pointee);
+  }
+  void visitPointerToMemberType(const PointerToMemberType &N,
+                                const Qualifiers *CVQuals) const {
+    S += "M";
+    visit(*N.ClassType);
+    visit(*N.MemberType);
+  }
+  void visitArrayType(const ArrayType &N, const Qualifiers *CVQuals) const {
+    S += "A";
+    if (N.Dimension.isString())
+      S += N.Dimension.asString();
+    else if (N.Dimension.isNode())
+      visit(*N.Dimension.asNode());
+    S += "_";
+    visit(*N.Base);
+  }
+  void visitFunctionType(const FunctionType &N,
+                         const Qualifiers *CVQuals) const {
+    mangle(N.CVQuals);
+    if (N.ExceptionSpec)
+      visit(*N.ExceptionSpec);
+    S += "F";
+    visit(*N.Ret);
+    mangle(N.Params, true);
+
+    if (N.RefQual == FrefQualLValue)
+      S += "R";
+    else if (N.RefQual == FrefQualRValue)
+      S += "O";
+    S += "E";
+  }
+  void visitNoexceptSpec(const NoexceptSpec &N,
+                         const Qualifiers *CVQuals) const {
+    if (!N.E) {
+      S += "Do";
+      return;
+    }
+    S += "DO";
+    visit(*N.E);
+    S += "E";
+  }
+  void visitDynamicExceptionSpec(const DynamicExceptionSpec &N,
+                                 const Qualifiers *CVQuals) const {
+    S += "Dw";
+    mangle(N.Types, false);
+    S += "E";
+  }
+  void visitFunctionEncoding(const FunctionEncoding &N,
+                             const Qualifiers *CVQuals) const {
+    visit(*N.Name, &N.CVQuals);
+    if (N.Attrs)
+      visit(*N.Attrs);
+    if (N.Ret)
+      visit(*N.Ret);
+    mangle(N.Params, true);
+  }
+  void visitLiteralOperator(const LiteralOperator &N,
+                            const Qualifiers *) const {
+    S += "li";
+    visit(*N.OpName);
+  }
+  void visitSpecialName(const SpecialName &N, const Qualifiers *CVQuals) const {
+  }
+  void visitSpecialNameX(const SpecialNameX &N, const Qualifiers *) const {
+    static constexpr const char *Mangle[] = {"TV", "TT", "TI", "TS",
+                                             "TW", "TH", "GV"};
+    S += Mangle[N.K];
+    visit(*N.Child);
+  }
+  void visitCtorVtableSpecialName(const CtorVtableSpecialName &N,
+                                  const Qualifiers *CVQuals) const {}
+  void visitQualifiedName(const QualifiedName &N,
+                          const Qualifiers *CVQuals) const {}
+  void visitNestedName(const NestedName &N, const Qualifiers *CVQuals) const {
+    visit(*N.Qual);
+    visit(*N.Name);
+  }
+  void visitFullNestedName(const FullNestedName &N,
+                           const Qualifiers *CVQuals) const {
+    S += "N";
+    if (CVQuals)
+      mangle(*CVQuals);
+    visit(*N.Name);
+    S += "E";
+  }
+  void visitLocalName(const LocalName &N, const Qualifiers *CVQuals) const {
+    S += "Z";
+    visit(*N.Encoding);
+    S += "E";
+    visit(*N.Entity, CVQuals);
+  }
+  void visitVectorType(const VectorType &N, const Qualifiers *CVQuals) const {}
+  void visitParameterPack(const ParameterPack &N,
+                          const Qualifiers *CVQuals) const {}
+  void visitTemplateArgumentPack(const TemplateArgumentPack &N,
+                                 const Qualifiers *) const {
+    S += "J";
+    mangle(N.getElements(), false);
+    S += "E";
+  }
+  void visitParameterPackExpansion(const ParameterPackExpansion &N,
+                                   const Qualifiers *) const {
+    S += "Dp";
+    visit(*N.getChild());
+  }
+  void visitTemplateArgs(const TemplateArgs &N,
+                         const Qualifiers *CVQuals) const {
+    S += "I";
+    for (Node *P : N.Params)
+      visit(*P);
+    S += "E";
+  }
+  void visitTemplateExpression(const TemplateExpression &N,
+                               const Qualifiers *CVQuals) const {
+    S += "X";
+    visit(*N.Expr);
+    S += "E";
+  }
+  void visitForwardTemplateReference(const ForwardTemplateReference &N,
+                                     const Qualifiers *CVQuals) const {
+    S += "T";
+    if (N.Index)
+      S << N.Index - 1;
+    S += "_";
+  }
+  void visitNameWithTemplateArgs(const NameWithTemplateArgs &N,
+                                 const Qualifiers *CVQuals) const {
+    visit(*N.Name);
+    visit(*N.TemplateArgs);
+  }
+  void visitGlobalQualifiedName(const GlobalQualifiedName &N,
+                                const Qualifiers *CVQuals) const {}
+  void visitStdQualifiedName(const StdQualifiedName &N,
+                             const Qualifiers *CVQuals) const {
+    S += "St";
+    if (N.Local)
+      S += "L";
+    visit(*N.Child);
+  }
+  void visitStdName(const StdName &N, const Qualifiers *) const { S += "St"; }
+  void visitSubstitution(const Substitution &N, const Qualifiers *) const {
+    S += "S";
+    switch (N.Index) {
+    case 0:
+      break;
+    case 1:
+      S += "0";
+      break;
+    default:
+      std::array<char, 13> Buffer;
+      size_t Ind = N.Index - 1;
+      auto I = Buffer.rbegin();
+      for (; Ind != 0; Ind /= 36) {
+        size_t C = Ind % 36;
+        *I++ = C < 10 ? '0' + C : 'A' + C - 10;
+      }
+      S += StringView(I.base(), Buffer.end());
+      break;
+    }
+    S += "_";
+  }
+  void visitExpandedSpecialSubstitution(const ExpandedSpecialSubstitution &N,
+                                        const Qualifiers *CVQuals) const {}
+  void visitSpecialSubstitution(const SpecialSubstitution &N,
+                                const Qualifiers *CVQuals) const {}
+  void visitCtorDtorName(const CtorDtorName &N,
+                         const Qualifiers *CVQuals) const {
+    S += N.IsDtor ? "D" : "C";
+    S << N.Flavor;
+  }
+  void visitDtorName(const DtorName &N, const Qualifiers *CVQuals) const {}
+  void visitUnnamedTypeName(const UnnamedTypeName &N,
+                            const Qualifiers *CVQuals) const {}
+  void visitClosureTypeName(const ClosureTypeName &N,
+                            const Qualifiers *) const {
+    S += "Ul";
+    mangle(N.Params, true);
+    S += "E";
+    S += N.Count;
+    S += "_";
+  }
+  void visitStructuredBindingName(const StructuredBindingName &N,
+                                  const Qualifiers *CVQuals) const {}
+  void visitExpr(const Expr &N, const Qualifiers *CVQuals) const {}
+  void visitBinaryExpr(const BinaryExpr &N, const Qualifiers *CVQuals) const {
+    mangle(N.InfixOperator);
+    visit(*N.LHS);
+    visit(*N.RHS);
+  }
+  void visitBracedExpr(const BracedExpr &N, const Qualifiers *CVQuals) const {}
+  void visitBracedRangeExpr(const BracedRangeExpr &N,
+                            const Qualifiers *CVQuals) const {}
+  void visitEnclosingExprX(const EnclosingExprX &N,
+                           const Qualifiers *CVQuals) const {
+    mangle(N.K);
+    visit(*N.Infix);
+    switch (N.K) {
+    case EnclosingExprX::Ksizeof:
+      break;
+    case EnclosingExprX::KdecltypeId:
+    case EnclosingExprX::Kdecltype:
+      S += 'E';
+      break;
+    }
+  }
+  void visitFunctionParam(const FunctionParam &N,
+                          const Qualifiers *CVQuals) const {
+    S += "f";
+    if (N.Level > 0) {
+      S += "L";
+      S << N.Level - 1;
+    }
+    S += "p";
+    mangle(N.CVR);
+    if (N.Number > 0)
+      S << N.Number - 1;
+    S += "_";
+  }
+  void visitIntegerExpr(const IntegerExpr &N, const Qualifiers *CVQuals) const {
+    S += "L";
+    visit(BuiltinType(N.Type));
+    S += N.Value;
+    S += "E";
+  }
+  void visitSizeofAliasParamPackExpr(const SizeofAliasParamPackExpr &N,
+                                     const Qualifiers *) const {
+    S += "sP";
+    mangle(N.Pack, false);
+    S += "E";
+  }
+  void visitSizeofParamPackExpr(const SizeofParamPackExpr &N,
+                                const Qualifiers *) const {
+    S += "sZ";
+    visit(*N.Pack);
+  }
+
+  void visit(const Node &N, const Qualifiers *CVQuals = nullptr) const;
+public:
+
+  Mangler(OutputStream &S_) : S(S_) {}
+
+  void mangle(const Node &N) const {
+    S += "_Z";
+    visit(N);
+  }
+};
+
+void Mangler::visit(const Node &N, const Qualifiers *CVQuals) const {
+#define CASE(T)                                                                \
+  case Node::K##T:                                                             \
+    visit##T(static_cast<const T &>(N), CVQuals);                              \
+    break
+  switch (N.getKind()) {
+    CASE(DotSuffix);
+    CASE(VendorExtQualType);
+    CASE(QualType);
+    CASE(ConversionOperatorType);
+    CASE(PostfixQualifiedType);
+    CASE(ElaboratedTypeSpefType);
+    CASE(NameType);
+    CASE(OperatorName);
+    CASE(BuiltinType);
+    CASE(AbiTagAttr);
+    CASE(DefaultArg);
+    CASE(EnableIfAttr);
+    CASE(ObjCProtoName);
+    CASE(PointerType);
+    CASE(ReferenceType);
+    CASE(PointerToMemberType);
+    CASE(ArrayType);
+    CASE(FunctionType);
+    CASE(NoexceptSpec);
+    CASE(DynamicExceptionSpec);
+    CASE(FunctionEncoding);
+    CASE(LiteralOperator);
+    CASE(SpecialName);
+    CASE(SpecialNameX);
+    CASE(CtorVtableSpecialName);
+    CASE(QualifiedName);
+    CASE(NestedName);
+    CASE(FullNestedName);
+    CASE(LocalName);
+    CASE(VectorType);
+    CASE(ParameterPack);
+    CASE(TemplateArgumentPack);
+    CASE(ParameterPackExpansion);
+    CASE(TemplateArgs);
+    CASE(TemplateExpression);
+    CASE(ForwardTemplateReference);
+    CASE(NameWithTemplateArgs);
+    CASE(GlobalQualifiedName);
+    CASE(StdQualifiedName);
+    CASE(StdName);
+    CASE(Substitution);
+    CASE(ExpandedSpecialSubstitution);
+    CASE(SpecialSubstitution);
+    CASE(CtorDtorName);
+    CASE(DtorName);
+    CASE(UnnamedTypeName);
+    CASE(ClosureTypeName);
+    CASE(StructuredBindingName);
+    CASE(Expr);
+    CASE(BinaryExpr);
+    CASE(BracedExpr);
+    CASE(BracedRangeExpr);
+    CASE(EnclosingExprX);
+    CASE(FunctionParam);
+    CASE(IntegerExpr);
+    CASE(SizeofAliasParamPackExpr);
+    CASE(SizeofParamPackExpr);
+  }
+}
+
 }  // unnamed namespace
 
 char *llvm::itaniumDemangle(const char *MangledName, char *Buf,
                             size_t *N, int *Status) {
   if (MangledName == nullptr || (Buf != nullptr && N == nullptr)) {
     if (Status)
       *Status = demangle_invalid_args;
     return nullptr;
char *ItaniumPartialDemangler::getFunctionReturnType(
   return S.getBuffer();
 }
 
 char *ItaniumPartialDemangler::finishDemangle(char *Buf, size_t *N) const {
   assert(RootNode != nullptr && "must call partialDemangle()");
   return printNode(static_cast<Node *>(RootNode), Buf, N);
 }
 
+char *ItaniumPartialDemangler::mangle(char *Buf, size_t *N) const {
+  OutputStream S;
+  if (initializeOutputStream(Buf, N, S, 128))
+    return nullptr;
+  Mangler(S).mangle(*static_cast<Node *>(RootNode));
+  S += '\0';
+  if (N != nullptr)
+    *N = S.getCurrentPosition();
+  return S.getBuffer();
+}
+
 bool ItaniumPartialDemangler::hasFunctionQualifiers() const {
   assert(RootNode != nullptr && "must call partialDemangle()");
   if (!isFunction())
     return false;
   auto *E = static_cast<FunctionEncoding *>(RootNode);
   return E->getCVQuals() != QualNone || E->getRefQual() != FrefQualNone;
 }
 

unittests/Demangle/PartialDemangleTest.cpp

// Res is nullptr. N remains unchanged.
     size_t N = OriginalSize;
     char *Res = D.getFunctionName(Buf, &N);
     EXPECT_EQ(nullptr, Res);
     EXPECT_EQ(OriginalSize, N);
   }
 
   std::free(Buf);
 }
+
+TEST(MangleTest, DM) {
+  llvm::ItaniumPartialDemangler IPD;
+  size_t Size = 1;
+  char *Buf = static_cast<char *>(std::malloc(Size));
+  auto doit = [&](const char *M) {
+    IPD.partialDemangle(M);
+    return Buf = IPD.finishDemangle(Buf, &Size);
+  };
+#define E(x, y) EXPECT_STREQ(x, doit(y))
+  E("f()", "_Z1fv");
+  E("A::f() const::f", "_ZZNK1A1fEvE1f");
+  E("A::f() const::A::f() const", "_ZZNK1A1fEvENK1A1fEv");
+  E("S::f(int)::'lambda'()::operator()() const", "_ZZN1S1fEiEd_NKUlvE_clEv");
+#undef E
+}
+
+TEST(MangleTest, M) {
+  llvm::ItaniumPartialDemangler IPD;
+  size_t Size = 1;
+  char *Buf = static_cast<char *>(std::malloc(Size));
+  auto doit = [&](const char *M) {
+    IPD.partialDemangle(M);
+    return Buf = IPD.mangle(Buf, &Size);
+  };
+#define E(x) EXPECT_STREQ(x, doit(x))
+  E("_Z1fv");
+  E("_Z1fii");
+  E("_ZN1f1gEv");
+  E("_ZN1f1g1hEv");
+  E("_ZNK1f1gEv");
+  E("_ZNrVK1f1gEv");
+  E("_ZN1fIvvE1gEv");
+  E("_ZN1fIE1gEv");
+  E("_Z1fPiRiOiRRi");
+  E("_Z1fPFilE");
+  E("_Z1fPFivE");
+  E("_ZN1AC1Ev");
+  E("_ZN1AcviEv");
+  E("_Z1fB2XXv");
+  E("_Z1fM1Ai");
+  E("_Z1fMN1X1AEi");
+  E("_Z1fRA10_i");
+  E("_Z1fILi2EEvRAplT_Li1E_i");
+  E("_Z1fILi1ELi2ELi3ELi4ELi5ELi6ELi7ELi8ELi9ELi10ELi11ELi12EEvRAplplT_T3_T10__i");
+  E("_Z1fM1AVKFicE");
+  E("_Z1fRFicE");
+  E("_Z1fM1AVKFicOE");
+  E("_Z1fM1AVKFicRE");
+  E("_Z1fPFicE");
+  E("_Z1fPDoFicE");
+  E("_Z1fIiEvPDOltstT_Li4EEFvvE");
+  E("_Z1fIiEvPDwT_EFvvE");
+  E("_Z1fUa9enable_ifIXeqfL0p_Li0EEEi");
+  E("_Z1fI1AEvT_PDtfL0pK_E");
+  E("_ZNKSt1A1fEv");
+  E("_ZSt1fv");
+  E("_ZStL1fv");
+  E("_Z1fIJiiEEvv");
+  E("_Z1fIJEEvv");
+  E("_Z2f0IJEEv1XIXsZT_EJDpRT_EE");
+  E("_Z2f0IJifdEEv1XIXsZT_EJDpRT_EE");
+  E("_Z1fN1q1w1e1r1t1y1u1i1o1p1q1w1e1r1t1y1u1i1o1p1QESJ_");
+  E("_Z1fN1q1w1e1r1t1y1u1i1o1p1q1w1e1r1t1y1u1i1o1p1q1w1e1r1t1y1u1i1o1p1q1w1e1r1t1y1u1i1o1p1QES13_");
+  E("_Z2f8IiJ2idIiES0_IfEEEvRAsPiDpT0_T_DpNS3_4typeEE_i");
+  E("_Z1fv.foo");
+  E("_Z1fU3exti");
+  E("_Z1fKi");
+  E("_Z1fCfGf");
+  E("_Z1fI1AEvTsNT_1XE");
+  E("_Z1fI1AEvTuNT_1XE");
+  E("_Z1fI1AEvTeNT_1XE");
+  E("_Z1fPU11objcproto1A11objc_object");
+  E("_Zli2_le");
+  E("_ZTV1A");
+  E("_ZTT1A");
+  E("_ZTI1A");
+  E("_ZTS1A");
+  E("_ZTW1A");
+  E("_ZTH1A");
+  E("_ZGVZ1fvE1a");
+  E("_ZZN1S1fEiEd_NKUlvE_clEv");
+}