[llvm] lldb abi_tag support 1/3 - Add equality comparison API to itanium_demangle::Node

[Michael137]

Summary

In LLDB we currently rely on hand-parsing demangled function
prototypes when selecting a candidate symbol for expression evaluation.
We now plan to use the Itanium mangle tree API to compare function
encodings instead.

This patch adds the ability to compare nodes of the Itanium mangle tree.

Testing

• Added unit-tests for each Node's new operator==

[Michael137]

• Fixed PointerToMemberType::operator==

[Michael137]

• Add necessary null-checks

[Michael137]

Planning to add unit-tests once we are fine with the approach in https://reviews.llvm.org/D131335

[Michael137]

• Rebase

[Michael137]

• Fix NodeArray::operator==()
• Fix FunctionEncoding::operator==()
• Start adding operator!=()

[Michael137]

• Start adding unit-tests

[Michael137]

• Remove debug logging

[Michael137]

Still WIP, but general approach is there. Before I add more unit-tests (i.e., around 75 test-cases, one for each Node type), are people ok with the general implementation/testing strategy?

[Michael137]

• Remove mistakenly added header

[Michael137]

• Reword commit message

[Michael137]

• Add more tests

[Michael137]

• Start adding asserts to operator==

[Michael137]

• Add more tests

[ldionne]

Once you use the libcxxabi sources as a base, the libcxxabi review group should kick in and our CI should get triggered.

llvm/include/llvm/Demangle/ItaniumDemangle.h

233

I think I don't understand why there is both operator== and equals. Do we really need both?

Instead, you could consider defining a virtual bool equals(Node const* Root) const = 0; and override it in subclasses, which seems to be a bit more in-line with what's done elsewhere in this file (e.g. printRight). Thoughts? It does mean that all overrides are going to have to check that Root->Kind == this->Kind, but that may be acceptable.

372

If you keep defining operator== after my comment above, I feel like all classes that get an operator== should also get an operator!= defined with the usual !(a == b).

435–440

Just a suggestion, non-blocking. I find that clearer but it may just be preference.

llvm/unittests/Demangle/ItaniumDemangleTestUtils.h

2

I suspect cp_to_llvm.sh will have to be updated to know about this new file.

[Michael137]

llvm/include/llvm/Demangle/ItaniumDemangle.h

233

That's a reasonable alternative. It does give us some more flexibility in comparing concrete vs. abstract nodes. With my implementation we'd have to cast a concrete node back to Node* to compare for equality which isn't very ergonomic.

372

Will do

435–440

I find your approach more readable :)
will do that instead, thanks

[Michael137]

llvm/unittests/Demangle/ItaniumDemangleTestUtils.h

2

It looks like the unit tests are exclusively in llvm/? I'll keep the tests in this directory for now

[Michael137]

• Move changes to libcxxabi/
• Add operator!=()

[Michael137]

• Remove redundant accessors

[Michael137]

• Sync

llvm/include/llvm/Demangle/ItaniumDemangle.h

public:
   Node(Kind K_, Cache RHSComponentCache_, Cache ArrayCache_ = Cache::No,
        Cache FunctionCache_ = Cache::No)
       : Node(K_, Prec::Primary, RHSComponentCache_, ArrayCache_,
              FunctionCache_) {}
 
   /// Visit the most-derived object corresponding to this object.
   template<typename Fn> void visit(Fn F) const;
 
+  /// Returns true if the tree rooted at this node is equivalent to
+  /// the tree rooted at the specified 'Root' node.
+  /// 
+  /// Equivalence of two nodes N1 and N2 is defined as:
+  /// 1. N1.getKind() == N2.getKind()
+  /// 2. N1 == N2 where '==' is defined by the
+  ///    kind of N1 and N2.
+  ///
+  /// Behaviour is undefined if 'Root == nullptr'.
+  bool equals(Node const* Root) const;
+
   // The following function is provided by all derived classes:
   //
   // Call F with arguments that, when passed to the constructor of this node,
   // would construct an equivalent node.
   //template<typename Fn> void match(Fn F) const;
 
   bool hasRHSComponent(OutputBuffer &OB) const {
     if (RHSComponentCache != Cache::Unknown)
for (size_t Idx = 0; Idx != NumElements; ++Idx) {
       if (AfterComma == OB.getCurrentPosition()) {
         OB.setCurrentPosition(BeforeComma);
         continue;
       }
 
       FirstElement = false;
     }
   }
+
+  friend bool operator==(NodeArray const& LHS, NodeArray const& RHS) {
+    if (LHS.size() != RHS.size())
+      return false;
+
+    auto** IT1 = LHS.begin();
+    auto** IT2 = RHS.begin();
+    for (; IT1 != LHS.end(); ++IT1, ++IT2)
+      if (!(*IT1)->equals(*IT2))
+        return false;
+
+    return true;
+  }
+
+  friend bool operator!=(NodeArray const& LHS, NodeArray const& RHS) {
+    return !(LHS == RHS);
+  }
 };
 
 struct NodeArrayNode : Node {
   NodeArray Array;
   NodeArrayNode(NodeArray Array_) : Node(KNodeArrayNode), Array(Array_) {}
 
   template<typename Fn> void match(Fn F) const { F(Array); }
 
   void printLeft(OutputBuffer &OB) const override { Array.printWithComma(OB); }
+
+  friend bool operator==(NodeArrayNode const& LHS, NodeArrayNode const& RHS) {
+    return LHS.Array == RHS.Array;
+  }
 };
 
 class DotSuffix final : public Node {
   const Node *Prefix;
   const StringView Suffix;
 
 public:
   DotSuffix(const Node *Prefix_, StringView Suffix_)
       : Node(KDotSuffix), Prefix(Prefix_), Suffix(Suffix_) {}
 
   template<typename Fn> void match(Fn F) const { F(Prefix, Suffix); }
 
   void printLeft(OutputBuffer &OB) const override {
     Prefix->print(OB);
     OB += " (";
     OB += Suffix;
     OB += ")";
   }
+
+  friend bool operator==(DotSuffix const& LHS, DotSuffix const& RHS) {
+    assert(LHS.Prefix != nullptr);
+    assert(RHS.Prefix != nullptr);
+
+    return LHS.Suffix == RHS.Suffix && LHS.Prefix->equals(RHS.Prefix);
+  }
 };
 
 class VendorExtQualType final : public Node {
   const Node *Ty;
   StringView Ext;
   const Node *TA;
 
 public:
   VendorExtQualType(const Node *Ty_, StringView Ext_, const Node *TA_)
       : Node(KVendorExtQualType), Ty(Ty_), Ext(Ext_), TA(TA_) {}
 
   const Node *getTy() const { return Ty; }
   StringView getExt() const { return Ext; }
   const Node *getTA() const { return TA; }
 
   template <typename Fn> void match(Fn F) const { F(Ty, Ext, TA); }
 
   void printLeft(OutputBuffer &OB) const override {
     Ty->print(OB);
     OB += " ";
     OB += Ext;
     if (TA != nullptr)
       TA->print(OB);
   }
+
+  friend bool operator==(VendorExtQualType const& LHS, VendorExtQualType const& RHS) {
+    assert(LHS.Ty != nullptr);
+    assert(RHS.Ty != nullptr);
+
+    if (!(LHS.Ext == RHS.Ext))
+      return false;
+
+    if (!LHS.Ty->equals(RHS.Ty))
+      return false;
+
+    if (!!LHS.TA != !!RHS.TA)
+      return false;
+
+    if (LHS.TA)
+      if (!LHS.TA->equals(RHS.TA))
+        return false;
+
+    return true;
+  }
 };
 
 enum FunctionRefQual : unsigned char {
   FrefQualNone,
   FrefQualLValue,
   FrefQualRValue,
 };
 
public:
   }
 
   void printLeft(OutputBuffer &OB) const override {
     Child->printLeft(OB);
     printQuals(OB);
   }
 
   void printRight(OutputBuffer &OB) const override { Child->printRight(OB); }
+
+  friend bool operator==(QualType const& LHS, QualType const& RHS) {
+    assert(LHS.Child != nullptr);
+    assert(RHS.Child != nullptr);
+
+    return LHS.Quals == RHS.Quals
+           && LHS.Child->equals(RHS.Child);
+  }
 };
 
 class ConversionOperatorType final : public Node {
   const Node *Ty;
 
 public:
   ConversionOperatorType(const Node *Ty_)
       : Node(KConversionOperatorType), Ty(Ty_) {}
 
   template<typename Fn> void match(Fn F) const { F(Ty); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "operator ";
     Ty->print(OB);
   }
+
+  friend bool operator==(ConversionOperatorType const& LHS,
+                         ConversionOperatorType const& RHS) {
+    return LHS.Ty->equals(RHS.Ty);
+  }
 };
 
 class PostfixQualifiedType final : public Node {
   const Node *Ty;
   const StringView Postfix;
 
 public:
   PostfixQualifiedType(const Node *Ty_, StringView Postfix_)
       : Node(KPostfixQualifiedType), Ty(Ty_), Postfix(Postfix_) {}
 
   template<typename Fn> void match(Fn F) const { F(Ty, Postfix); }
 
   void printLeft(OutputBuffer &OB) const override {
     Ty->printLeft(OB);
     OB += Postfix;
   }
+
+  friend bool operator==(PostfixQualifiedType const& LHS,
+                         PostfixQualifiedType const& RHS) {
+    return LHS.Postfix == RHS.Postfix
+           && LHS.Ty->equals(RHS.Ty);
+  }
 };
 
 class NameType final : public Node {
   const StringView Name;
 
 public:
   NameType(StringView Name_) : Node(KNameType), Name(Name_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name); }
 
   StringView getName() const { return Name; }
   StringView getBaseName() const override { return Name; }
 
   void printLeft(OutputBuffer &OB) const override { OB += Name; }
+
+  friend bool operator==(NameType const& LHS, NameType const& RHS) {
+    return LHS.Name == RHS.Name;
+  }
 };
 
 class BitIntType final : public Node {
   const Node *Size;
   bool Signed;
 
 public:
   BitIntType(const Node *Size_, bool Signed_)
       : Node(KBitIntType), Size(Size_), Signed(Signed_) {}
 
   template <typename Fn> void match(Fn F) const { F(Size, Signed); }
 
   void printLeft(OutputBuffer &OB) const override {
     if (!Signed)
       OB += "unsigned ";
     OB += "_BitInt";
     OB.printOpen();
     Size->printAsOperand(OB);
     OB.printClose();
   }
+
+  friend bool operator==(BitIntType const& LHS, BitIntType const& RHS) {
+    return LHS.Signed == RHS.Signed
+           && LHS.Size->equals(RHS.Size);
+  }
 };
 
 class ElaboratedTypeSpefType : public Node {
   StringView Kind;
   Node *Child;
 public:
   ElaboratedTypeSpefType(StringView Kind_, Node *Child_)
       : Node(KElaboratedTypeSpefType), Kind(Kind_), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Kind, Child); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += Kind;
     OB += ' ';
     Child->print(OB);
   }
+
+  friend bool operator==(ElaboratedTypeSpefType const& LHS,
+                         ElaboratedTypeSpefType const& RHS) {
+    return LHS.Kind == RHS.Kind
+           && LHS.Child->equals(RHS.Child);
+  }
 };
 
 struct AbiTagAttr : Node {
   Node *Base;
   StringView Tag;
 
   AbiTagAttr(Node* Base_, StringView Tag_)
       : Node(KAbiTagAttr, Base_->RHSComponentCache,
              Base_->ArrayCache, Base_->FunctionCache),
         Base(Base_), Tag(Tag_) {}
 
   template<typename Fn> void match(Fn F) const { F(Base, Tag); }
 
   void printLeft(OutputBuffer &OB) const override {
     Base->printLeft(OB);
     OB += "[abi:";
     OB += Tag;
     OB += "]";
   }
+
+  friend bool operator==(AbiTagAttr const& LHS, AbiTagAttr const& RHS) {
+    return LHS.Tag == RHS.Tag
+           && LHS.Base->equals(RHS.Base);
+  }
 };
 
 class EnableIfAttr : public Node {
   NodeArray Conditions;
 public:
   EnableIfAttr(NodeArray Conditions_)
       : Node(KEnableIfAttr), Conditions(Conditions_) {}
 
   template<typename Fn> void match(Fn F) const { F(Conditions); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += " [enable_if:";
     Conditions.printWithComma(OB);
     OB += ']';
   }
+
+  friend bool operator==(EnableIfAttr const& LHS,
+                         EnableIfAttr const& RHS) {
+    return LHS.Conditions == RHS.Conditions;
+  }
 };
 
 class ObjCProtoName : public Node {
   const Node *Ty;
   StringView Protocol;
 
   friend class PointerType;
 
public:
   }
 
   void printLeft(OutputBuffer &OB) const override {
     Ty->print(OB);
     OB += "<";
     OB += Protocol;
     OB += ">";
   }
+
+  friend bool operator==(ObjCProtoName const& LHS,
+                         ObjCProtoName const& RHS) {
+    return LHS.Protocol == RHS.Protocol
+           && LHS.Ty->equals(RHS.Ty);
+  }
 };
 
 class PointerType final : public Node {
   const Node *Pointee;
 
 public:
   PointerType(const Node *Pointee_)
       : Node(KPointerType, Pointee_->RHSComponentCache),
public:
   void printRight(OutputBuffer &OB) const override {
     if (Pointee->getKind() != KObjCProtoName ||
         !static_cast<const ObjCProtoName *>(Pointee)->isObjCObject()) {
       if (Pointee->hasArray(OB) || Pointee->hasFunction(OB))
         OB += ")";
       Pointee->printRight(OB);
     }
   }
+
+  friend bool operator==(PointerType const& LHS, PointerType const& RHS) {
+    return LHS.Pointee->equals(RHS.Pointee);
+  }
 };
 
 enum class ReferenceKind {
   LValue,
   RValue,
 };
 
 // Represents either a LValue or an RValue reference type.
void printRight(OutputBuffer &OB) const override {
     ScopedOverride<bool> SavePrinting(Printing, true);
     std::pair<ReferenceKind, const Node *> Collapsed = collapse(OB);
     if (!Collapsed.second)
       return;
     if (Collapsed.second->hasArray(OB) || Collapsed.second->hasFunction(OB))
       OB += ")";
     Collapsed.second->printRight(OB);
   }
+
+  friend bool operator==(ReferenceType const& LHS, ReferenceType const& RHS) {
+    return LHS.RK == RHS.RK
+           && LHS.Pointee->equals(RHS.Pointee);
+  }
 };
 
 class PointerToMemberType final : public Node {
   const Node *ClassType;
   const Node *MemberType;
 
 public:
   PointerToMemberType(const Node *ClassType_, const Node *MemberType_)
void printLeft(OutputBuffer &OB) const override {
     OB += "::*";
   }
 
   void printRight(OutputBuffer &OB) const override {
     if (MemberType->hasArray(OB) || MemberType->hasFunction(OB))
       OB += ")";
     MemberType->printRight(OB);
   }
+
+  friend bool operator==(PointerToMemberType const& LHS, PointerToMemberType const& RHS) {
+    return LHS.ClassType->equals(RHS.ClassType)
+           && LHS.MemberType->equals(RHS.MemberType);
+  }
 };
 
 class ArrayType final : public Node {
   const Node *Base;
   Node *Dimension;
 
 public:
   ArrayType(const Node *Base_, Node *Dimension_)
void printRight(OutputBuffer &OB) const override {
     if (OB.back() != ']')
       OB += " ";
     OB += "[";
     if (Dimension)
       Dimension->print(OB);
     OB += "]";
     Base->printRight(OB);
   }
+
+  friend bool operator==(ArrayType const& LHS, ArrayType const& RHS) {
+    return LHS.Base->equals(RHS.Base)
+           && LHS.Dimension->equals(RHS.Dimension);
+  }
 };
 
 class FunctionType final : public Node {
   const Node *Ret;
   NodeArray Params;
   Qualifiers CVQuals;
   FunctionRefQual RefQual;
   const Node *ExceptionSpec;
void printRight(OutputBuffer &OB) const override {
     else if (RefQual == FrefQualRValue)
       OB += " &&";
 
     if (ExceptionSpec != nullptr) {
       OB += ' ';
       ExceptionSpec->print(OB);
     }
   }
+
+  friend bool operator==(FunctionType const& LHS, FunctionType const& RHS) {
+    return LHS.CVQuals == RHS.CVQuals
+           && LHS.RefQual == RHS.RefQual
+           && LHS.Params == RHS.Params
+           && LHS.Ret->equals(RHS.Ret)
+           && LHS.ExceptionSpec->equals(RHS.ExceptionSpec);
+  }
 };
 
 class NoexceptSpec : public Node {
   const Node *E;
 public:
   NoexceptSpec(const Node *E_) : Node(KNoexceptSpec), E(E_) {}
 
   template<typename Fn> void match(Fn F) const { F(E); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "noexcept";
     OB.printOpen();
     E->printAsOperand(OB);
     OB.printClose();
   }
+
+  friend bool operator==(NoexceptSpec const& LHS, NoexceptSpec const& RHS) {
+    return LHS.E->equals(RHS.E);
+  }
 };
 
 class DynamicExceptionSpec : public Node {
   NodeArray Types;
 public:
   DynamicExceptionSpec(NodeArray Types_)
       : Node(KDynamicExceptionSpec), Types(Types_) {}
 
   template<typename Fn> void match(Fn F) const { F(Types); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "throw";
     OB.printOpen();
     Types.printWithComma(OB);
     OB.printClose();
   }
+
+  friend bool operator==(DynamicExceptionSpec const& LHS,
+                         DynamicExceptionSpec const& RHS) {
+    return LHS.Types == RHS.Types;
+  }
 };
 
 class FunctionEncoding final : public Node {
   const Node *Ret;
   const Node *Name;
   NodeArray Params;
   const Node *Attrs;
   Qualifiers CVQuals;
void printRight(OutputBuffer &OB) const override {
     if (RefQual == FrefQualLValue)
       OB += " &";
     else if (RefQual == FrefQualRValue)
       OB += " &&";
 
     if (Attrs != nullptr)
       Attrs->print(OB);
   }
+
+  friend bool operator==(FunctionEncoding const& LHS,
+                         FunctionEncoding const& RHS) {
+    assert(LHS.Name != nullptr);
+    assert(RHS.Name != nullptr);
+
+    if (LHS.CVQuals != RHS.CVQuals)
+      return false;
+
+    if (LHS.RefQual != RHS.RefQual)
+      return false;
+
+    if (!LHS.Name->equals(RHS.Name))
+      return false;
+
+    if (!!LHS.Ret != !!RHS.Ret)
+      return false;
+    
+    if (LHS.Ret)
+      if (!LHS.Ret->equals(RHS.Ret))
+          return false;
+
+    if (!!LHS.Attrs != !!RHS.Attrs)
+      return false;
+
+    if (LHS.Attrs)
+      if (!LHS.Attrs->equals(RHS.Attrs))
+        return false;
+
+    return LHS.Params == RHS.Params;
+  }
 };
 
 class LiteralOperator : public Node {
   const Node *OpName;
 
 public:
   LiteralOperator(const Node *OpName_)
       : Node(KLiteralOperator), OpName(OpName_) {}
 
   template<typename Fn> void match(Fn F) const { F(OpName); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "operator\"\" ";
     OpName->print(OB);
   }
+
+  friend bool operator==(LiteralOperator const& LHS,
+                         LiteralOperator const& RHS) {
+    assert(LHS.OpName != nullptr);
+    assert(RHS.OpName != nullptr);
+
+    return LHS.OpName->equals(RHS.OpName);
+  }
 };
 
 class SpecialName final : public Node {
   const StringView Special;
   const Node *Child;
 
 public:
   SpecialName(StringView Special_, const Node *Child_)
       : Node(KSpecialName), Special(Special_), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Special, Child); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += Special;
     Child->print(OB);
   }
+
+  friend bool operator==(SpecialName const& LHS,
+                         SpecialName const& RHS) {
+    assert(LHS.Child != nullptr);
+    assert(RHS.Child != nullptr);
+
+    return LHS.Special == RHS.Special
+           && LHS.Child->equals(RHS.Child);
+  }
 };
 
 class CtorVtableSpecialName final : public Node {
   const Node *FirstType;
   const Node *SecondType;
 
 public:
   CtorVtableSpecialName(const Node *FirstType_, const Node *SecondType_)
       : Node(KCtorVtableSpecialName),
         FirstType(FirstType_), SecondType(SecondType_) {}
 
   template<typename Fn> void match(Fn F) const { F(FirstType, SecondType); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "construction vtable for ";
     FirstType->print(OB);
     OB += "-in-";
     SecondType->print(OB);
   }
+
+  friend bool operator==(CtorVtableSpecialName const& LHS,
+                         CtorVtableSpecialName const& RHS) {
+    assert(LHS.FirstType != nullptr);
+    assert(RHS.FirstType != nullptr);
+
+    assert(LHS.SecondType != nullptr);
+    assert(RHS.SecondType != nullptr);
+
+    return LHS.FirstType->equals(RHS.FirstType)
+           && LHS.SecondType->equals(RHS.SecondType);
+  }
 };
 
 struct NestedName : Node {
   Node *Qual;
   Node *Name;
 
   NestedName(Node *Qual_, Node *Name_)
       : Node(KNestedName), Qual(Qual_), Name(Name_) {}
 
   template<typename Fn> void match(Fn F) const { F(Qual, Name); }
 
   StringView getBaseName() const override { return Name->getBaseName(); }
 
   void printLeft(OutputBuffer &OB) const override {
     Qual->print(OB);
     OB += "::";
     Name->print(OB);
   }
+
+  friend bool operator==(NestedName const& LHS,
+                         NestedName const& RHS) {
+    assert(LHS.Qual != nullptr);
+    assert(RHS.Qual != nullptr);
+
+    assert(LHS.Name != nullptr);
+    assert(RHS.Name != nullptr);
+
+    return LHS.Qual->equals(RHS.Qual)
+           && LHS.Name->equals(RHS.Name);
+  }
 };
 
 struct ModuleName : Node {
   ModuleName *Parent;
   Node *Name;
   bool IsPartition;
 
   ModuleName(ModuleName *Parent_, Node *Name_, bool IsPartition_ = false)
       : Node(KModuleName), Parent(Parent_), Name(Name_),
         IsPartition(IsPartition_) {}
 
   template <typename Fn> void match(Fn F) const {
     F(Parent, Name, IsPartition);
   }
 
   void printLeft(OutputBuffer &OB) const override {
     if (Parent)
       Parent->print(OB);
     if (Parent || IsPartition)
       OB += IsPartition ? ':' : '.';
     Name->print(OB);
   }
+
+  friend bool operator==(ModuleName const& LHS,
+                         ModuleName const& RHS) {
+    assert(LHS.Name != nullptr);
+    assert(RHS.Name != nullptr);
+
+    if (LHS.IsPartition != RHS.IsPartition)
+      return false;
+
+    if (!!LHS.Parent != !!RHS.Parent)
+      return false;
+
+    if (LHS.Parent)
+      if (!LHS.Parent->equals(RHS.Parent))
+        return false;
+     
+    return LHS.Name->equals(RHS.Name);
+  }
 };
 
 struct ModuleEntity : Node {
   ModuleName *Module;
   Node *Name;
 
   ModuleEntity(ModuleName *Module_, Node *Name_)
       : Node(KModuleEntity), Module(Module_), Name(Name_) {}
 
   template <typename Fn> void match(Fn F) const { F(Module, Name); }
 
   StringView getBaseName() const override { return Name->getBaseName(); }
 
   void printLeft(OutputBuffer &OB) const override {
     Name->print(OB);
     OB += '@';
     Module->print(OB);
   }
+
+  friend bool operator==(ModuleEntity const& LHS,
+                         ModuleEntity const& RHS) {
+    return LHS.Module->equals(RHS.Module)
+           && LHS.Name->equals(RHS.Name);
+  }
 };
 
 struct LocalName : Node {
   Node *Encoding;
   Node *Entity;
 
   LocalName(Node *Encoding_, Node *Entity_)
       : Node(KLocalName), Encoding(Encoding_), Entity(Entity_) {}
 
   template<typename Fn> void match(Fn F) const { F(Encoding, Entity); }
 
   void printLeft(OutputBuffer &OB) const override {
     Encoding->print(OB);
     OB += "::";
     Entity->print(OB);
   }
+
+  friend bool operator==(LocalName const& LHS, LocalName const& RHS) {
+    assert(LHS.Encoding != nullptr);
+    assert(RHS.Encoding != nullptr);
+
+    assert(LHS.Entity != nullptr);
+    assert(RHS.Entity != nullptr);
+
+    return LHS.Encoding->equals(RHS.Encoding)
+           && LHS.Entity->equals(RHS.Entity);
+  }
 };
 
 class QualifiedName final : public Node {
   // qualifier::name
   const Node *Qualifier;
   const Node *Name;
 
 public:
   QualifiedName(const Node *Qualifier_, const Node *Name_)
       : Node(KQualifiedName), Qualifier(Qualifier_), Name(Name_) {}
 
   template<typename Fn> void match(Fn F) const { F(Qualifier, Name); }
 
   StringView getBaseName() const override { return Name->getBaseName(); }
 
   void printLeft(OutputBuffer &OB) const override {
     Qualifier->print(OB);
     OB += "::";
     Name->print(OB);
   }
+
+  friend bool operator==(QualifiedName const& LHS,
+                         QualifiedName const& RHS) {
+    assert(LHS.Qualifier != nullptr);
+    assert(RHS.Qualifier != nullptr);
+
+    assert(LHS.Name != nullptr);
+    assert(RHS.Name != nullptr);
+
+    return LHS.Qualifier->equals(RHS.Qualifier)
+           && LHS.Name->equals(RHS.Name);
+  }
 };
 
 class VectorType final : public Node {
   const Node *BaseType;
   const Node *Dimension;
 
 public:
   VectorType(const Node *BaseType_, const Node *Dimension_)
       : Node(KVectorType), BaseType(BaseType_), Dimension(Dimension_) {}
 
   const Node *getBaseType() const { return BaseType; }
   const Node *getDimension() const { return Dimension; }
 
   template<typename Fn> void match(Fn F) const { F(BaseType, Dimension); }
 
   void printLeft(OutputBuffer &OB) const override {
     BaseType->print(OB);
     OB += " vector[";
     if (Dimension)
       Dimension->print(OB);
     OB += "]";
   }
+
+  friend bool operator==(VectorType const& LHS,
+                         VectorType const& RHS) {
+    return LHS.BaseType->equals(RHS.BaseType)
+           && LHS.Dimension->equals(RHS.Dimension);
+  }
 };
 
 class PixelVectorType final : public Node {
   const Node *Dimension;
 
 public:
   PixelVectorType(const Node *Dimension_)
       : Node(KPixelVectorType), Dimension(Dimension_) {}
 
   template<typename Fn> void match(Fn F) const { F(Dimension); }
 
   void printLeft(OutputBuffer &OB) const override {
     // FIXME: This should demangle as "vector pixel".
     OB += "pixel vector[";
     Dimension->print(OB);
     OB += "]";
   }
+
+  friend bool operator==(PixelVectorType const& LHS,
+                         PixelVectorType const& RHS) {
+    return LHS.Dimension->equals(RHS.Dimension);
+  }
 };
 
 class BinaryFPType final : public Node {
   const Node *Dimension;
 
 public:
   BinaryFPType(const Node *Dimension_)
       : Node(KBinaryFPType), Dimension(Dimension_) {}
 
   template<typename Fn> void match(Fn F) const { F(Dimension); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "_Float";
     Dimension->print(OB);
   }
+
+  friend bool operator==(BinaryFPType const& LHS,
+                         BinaryFPType const& RHS) {
+    return LHS.Dimension->equals(RHS.Dimension);
+  }
 };
 
 enum class TemplateParamKind { Type, NonType, Template };
 
 /// An invented name for a template parameter for which we don't have a
 /// corresponding template argument.
 ///
 /// This node is created when parsing the <lambda-sig> for a lambda with
case TemplateParamKind::NonType:
       break;
     case TemplateParamKind::Template:
       OB += "$TT";
       break;
     }
     if (Index > 0)
       OB << Index - 1;
   }
+
+  friend bool operator==(SyntheticTemplateParamName const& LHS,
+                         SyntheticTemplateParamName const& RHS) {
+    return LHS.Kind == RHS.Kind
+           && LHS.Index == RHS.Index;
+  }
 };
 
 /// A template type parameter declaration, 'typename T'.
 class TypeTemplateParamDecl final : public Node {
   Node *Name;
 
 public:
   TypeTemplateParamDecl(Node *Name_)
       : Node(KTypeTemplateParamDecl, Cache::Yes), Name(Name_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name); }
 
   void printLeft(OutputBuffer &OB) const override { OB += "typename "; }
 
   void printRight(OutputBuffer &OB) const override { Name->print(OB); }
+
+  friend bool operator==(TypeTemplateParamDecl const& LHS,
+                         TypeTemplateParamDecl const& RHS) {
+    return LHS.Name->equals(RHS.Name);
+  }
 };
 
 /// A non-type template parameter declaration, 'int N'.
 class NonTypeTemplateParamDecl final : public Node {
   Node *Name;
   Node *Type;
 
 public:
   NonTypeTemplateParamDecl(Node *Name_, Node *Type_)
       : Node(KNonTypeTemplateParamDecl, Cache::Yes), Name(Name_), Type(Type_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name, Type); }
 
   void printLeft(OutputBuffer &OB) const override {
     Type->printLeft(OB);
     if (!Type->hasRHSComponent(OB))
       OB += " ";
   }
 
   void printRight(OutputBuffer &OB) const override {
     Name->print(OB);
     Type->printRight(OB);
   }
+
+  friend bool operator==(NonTypeTemplateParamDecl const& LHS,
+                         NonTypeTemplateParamDecl const& RHS) {
+    return LHS.Name->equals(RHS.Name)
+           && LHS.Type->equals(RHS.Type);
+  }
 };
 
 /// A template template parameter declaration,
 /// 'template<typename T> typename N'.
 class TemplateTemplateParamDecl final : public Node {
   Node *Name;
   NodeArray Params;
 
 public:
   TemplateTemplateParamDecl(Node *Name_, NodeArray Params_)
       : Node(KTemplateTemplateParamDecl, Cache::Yes), Name(Name_),
         Params(Params_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name, Params); }
 
   void printLeft(OutputBuffer &OB) const override {
     ScopedOverride<unsigned> LT(OB.GtIsGt, 0);
     OB += "template<";
     Params.printWithComma(OB);
     OB += "> typename ";
   }
 
   void printRight(OutputBuffer &OB) const override { Name->print(OB); }
+
+  friend bool operator==(TemplateTemplateParamDecl const& LHS,
+                         TemplateTemplateParamDecl const& RHS) {
+    return LHS.Name->equals(RHS.Name)
+           && LHS.Params == RHS.Params;
+  }
 };
 
 /// A template parameter pack declaration, 'typename ...T'.
 class TemplateParamPackDecl final : public Node {
   Node *Param;
 
 public:
   TemplateParamPackDecl(Node *Param_)
       : Node(KTemplateParamPackDecl, Cache::Yes), Param(Param_) {}
 
   template<typename Fn> void match(Fn F) const { F(Param); }
 
   void printLeft(OutputBuffer &OB) const override {
     Param->printLeft(OB);
     OB += "...";
   }
 
   void printRight(OutputBuffer &OB) const override { Param->printRight(OB); }
+
+  friend bool operator==(TemplateParamPackDecl const& LHS,
+                         TemplateParamPackDecl const& RHS) {
+    return LHS.Param->equals(RHS.Param);
+  }
 };
 
 /// An unexpanded parameter pack (either in the expression or type context). If
 /// this AST is correct, this node will have a ParameterPackExpansion node above
 /// it.
 ///
 /// This node is created when some <template-args> are found that apply to an
 /// <encoding>, and is stored in the TemplateParams table. In order for this to
if (Idx < Data.size())
       Data[Idx]->printLeft(OB);
   }
   void printRight(OutputBuffer &OB) const override {
     initializePackExpansion(OB);
     size_t Idx = OB.CurrentPackIndex;
     if (Idx < Data.size())
       Data[Idx]->printRight(OB);
   }
+
+  friend bool operator==(ParameterPack const& LHS,
+                         ParameterPack const& RHS) {
+    return LHS.Data == RHS.Data;
+  }
 };
 
 /// A variadic template argument. This node represents an occurrence of
 /// J<something>E in some <template-args>. It isn't itself unexpanded, unless
 /// one of it's Elements is. The parser inserts a ParameterPack into the
 /// TemplateParams table if the <template-args> this pack belongs to apply to an
 /// <encoding>.
 class TemplateArgumentPack final : public Node {
   NodeArray Elements;
 public:
   TemplateArgumentPack(NodeArray Elements_)
       : Node(KTemplateArgumentPack), Elements(Elements_) {}
 
   template<typename Fn> void match(Fn F) const { F(Elements); }
 
   NodeArray getElements() const { return Elements; }
 
   void printLeft(OutputBuffer &OB) const override {
     Elements.printWithComma(OB);
   }
+
+  friend bool operator==(TemplateArgumentPack const& LHS,
+                         TemplateArgumentPack const& RHS) {
+    return LHS.Elements == RHS.Elements;
+  }
 };
 
 /// A pack expansion. Below this node, there are some unexpanded ParameterPacks
 /// which each have Child->ParameterPackSize elements.
 class ParameterPackExpansion final : public Node {
   const Node *Child;
 
 public:
void printLeft(OutputBuffer &OB) const override {
 
     // Else, iterate through the rest of the elements in the pack.
     for (unsigned I = 1, E = OB.CurrentPackMax; I < E; ++I) {
       OB += ", ";
       OB.CurrentPackIndex = I;
       Child->print(OB);
     }
   }
+
+  friend bool operator==(ParameterPackExpansion const& LHS,
+                         ParameterPackExpansion const& RHS) {
+    return LHS.Child->equals(RHS.Child);
+  }
 };
 
 class TemplateArgs final : public Node {
   NodeArray Params;
 
 public:
   TemplateArgs(NodeArray Params_) : Node(KTemplateArgs), Params(Params_) {}
 
   template<typename Fn> void match(Fn F) const { F(Params); }
 
   NodeArray getParams() { return Params; }
 
   void printLeft(OutputBuffer &OB) const override {
     ScopedOverride<unsigned> LT(OB.GtIsGt, 0);
     OB += "<";
     Params.printWithComma(OB);
     OB += ">";
   }
+
+  friend bool operator==(TemplateArgs const& LHS,
+                         TemplateArgs const& RHS) {
+    return LHS.Params == RHS.Params;
+  }
 };
 
 /// A forward-reference to a template argument that was not known at the point
 /// where the template parameter name was parsed in a mangling.
 ///
 /// This is created when demangling the name of a specialization of a
 /// conversion function template:
 ///
struct ForwardTemplateReference : Node {
   Node *Ref = nullptr;
 
   // If we're currently printing this node. It is possible (though invalid) for
   // a forward template reference to refer to itself via a substitution. This
   // creates a cyclic AST, which will stack overflow printing. To fix this, bail
   // out if more than one print* function is active.
   mutable bool Printing = false;
 
+  friend bool operator==(ForwardTemplateReference const& LHS,
+                         ForwardTemplateReference const& RHS) {
+    if (LHS.Index != RHS.Index)
+      return false;
+
+    if (!!LHS.Ref != !!RHS.Ref)
+      return false;
+
+    if (LHS.Ref)
+      if (!LHS.Ref->equals(RHS.Ref))
+        return false;
+
+    // Ignore 'Printing' member
+    return true;
+  }
+
   ForwardTemplateReference(size_t Index_)
       : Node(KForwardTemplateReference, Cache::Unknown, Cache::Unknown,
              Cache::Unknown),
         Index(Index_) {}
 
   // We don't provide a matcher for these, because the value of the node is
   // not determined by its construction parameters, and it generally needs
   // special handling.
struct NameWithTemplateArgs : Node {
   template<typename Fn> void match(Fn F) const { F(Name, TemplateArgs); }
 
   StringView getBaseName() const override { return Name->getBaseName(); }
 
   void printLeft(OutputBuffer &OB) const override {
     Name->print(OB);
     TemplateArgs->print(OB);
   }
+
+  friend bool operator==(NameWithTemplateArgs const& LHS,
+                         NameWithTemplateArgs const& RHS) {
+    return LHS.Name->equals(RHS.Name)
+           && LHS.TemplateArgs->equals(RHS.TemplateArgs);
+  }
 };
 
 class GlobalQualifiedName final : public Node {
   Node *Child;
 
 public:
   GlobalQualifiedName(Node* Child_)
       : Node(KGlobalQualifiedName), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Child); }
 
   StringView getBaseName() const override { return Child->getBaseName(); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "::";
     Child->print(OB);
   }
+
+  friend bool operator==(GlobalQualifiedName const& LHS,
+                         GlobalQualifiedName const& RHS) {
+    return LHS.Child->equals(RHS.Child);
+  }
 };
 
 enum class SpecialSubKind {
   allocator,
   basic_string,
   string,
   istream,
   ostream,
void printLeft(OutputBuffer &OB) const override {
     OB << "std::" << getBaseName();
     if (isInstantiation()) {
       OB << "<char, std::char_traits<char>";
       if (SSK == SpecialSubKind::string)
         OB << ", std::allocator<char>";
       OB << ">";
     }
   }
+
+  friend bool operator==(ExpandedSpecialSubstitution const& LHS,
+                         ExpandedSpecialSubstitution const& RHS) {
+    return LHS.SSK == RHS.SSK;
+  }
 };
 
 class SpecialSubstitution final : public ExpandedSpecialSubstitution {
 public:
   SpecialSubstitution(SpecialSubKind SSK_)
       : ExpandedSpecialSubstitution(SSK_, KSpecialSubstitution) {}
 
   template<typename Fn> void match(Fn F) const { F(SSK); }
public:
 
   template<typename Fn> void match(Fn F) const { F(Basename, IsDtor, Variant); }
 
   void printLeft(OutputBuffer &OB) const override {
     if (IsDtor)
       OB += "~";
     OB += Basename->getBaseName();
   }
+
+  friend bool operator==(CtorDtorName const& LHS,
+                         CtorDtorName const& RHS) {
+    assert(LHS.Basename != nullptr);
+    assert(RHS.Basename != nullptr);
+
+    return LHS.IsDtor == RHS.IsDtor
+           && LHS.Variant == RHS.Variant
+           && LHS.Basename->equals(RHS.Basename);
+  }
 };
 
 class DtorName : public Node {
   const Node *Base;
 
 public:
   DtorName(const Node *Base_) : Node(KDtorName), Base(Base_) {}
 
   template<typename Fn> void match(Fn F) const { F(Base); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "~";
     Base->printLeft(OB);
   }
+
+  friend bool operator==(DtorName const& LHS,
+                         DtorName const& RHS) {
+    assert(LHS.Base != nullptr);
+    assert(RHS.Base != nullptr);
+
+    return LHS.Base->equals(RHS.Base);
+  }
 };
 
 class UnnamedTypeName : public Node {
   const StringView Count;
 
 public:
   UnnamedTypeName(StringView Count_) : Node(KUnnamedTypeName), Count(Count_) {}
 
   template<typename Fn> void match(Fn F) const { F(Count); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "'unnamed";
     OB += Count;
     OB += "\'";
   }
+
+  friend bool operator==(UnnamedTypeName const& LHS,
+                         UnnamedTypeName const& RHS) {
+    return LHS.Count == RHS.Count;
+  }
 };
 
 class ClosureTypeName : public Node {
   NodeArray TemplateParams;
   NodeArray Params;
   StringView Count;
 
 public:
public:
   }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "\'lambda";
     OB += Count;
     OB += "\'";
     printDeclarator(OB);
   }
+
+  friend bool operator==(ClosureTypeName const& LHS,
+                         ClosureTypeName const& RHS) {
+    return LHS.TemplateParams == RHS.TemplateParams
+           && LHS.Params == RHS.Params
+           && LHS.Count == RHS.Count;
+  }
 };
 
 class StructuredBindingName : public Node {
   NodeArray Bindings;
 public:
   StructuredBindingName(NodeArray Bindings_)
       : Node(KStructuredBindingName), Bindings(Bindings_) {}
 
   template<typename Fn> void match(Fn F) const { F(Bindings); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB.printOpen('[');
     Bindings.printWithComma(OB);
     OB.printClose(']');
   }
+
+  friend bool operator==(StructuredBindingName const& LHS,
+                         StructuredBindingName const& RHS) {
+    return LHS.Bindings == RHS.Bindings;
+  }
 };
 
 // -- Expression Nodes --
 
 class BinaryExpr : public Node {
   const Node *LHS;
   const StringView InfixOperator;
   const Node *RHS;
void printLeft(OutputBuffer &OB) const override {
     if (!(InfixOperator == ","))
       OB += " ";
     OB += InfixOperator;
     OB += " ";
     RHS->printAsOperand(OB, getPrecedence(), IsAssign);
     if (ParenAll)
       OB.printClose();
   }
+
+  friend bool operator==(BinaryExpr const& LHS,
+                         BinaryExpr const& RHS) {
+    return LHS.InfixOperator == RHS.InfixOperator
+           && LHS.LHS->equals(RHS.LHS)
+           && LHS.RHS->equals(RHS.RHS);
+  }
 };
 
 class ArraySubscriptExpr : public Node {
   const Node *Op1;
   const Node *Op2;
 
 public:
   ArraySubscriptExpr(const Node *Op1_, const Node *Op2_, Prec Prec_)
       : Node(KArraySubscriptExpr, Prec_), Op1(Op1_), Op2(Op2_) {}
 
   template <typename Fn> void match(Fn F) const {
     F(Op1, Op2, getPrecedence());
   }
 
   void printLeft(OutputBuffer &OB) const override {
     Op1->printAsOperand(OB, getPrecedence());
     OB.printOpen('[');
     Op2->printAsOperand(OB);
     OB.printClose(']');
   }
+
+  friend bool operator==(ArraySubscriptExpr const& LHS,
+                         ArraySubscriptExpr const& RHS) {
+    return LHS.Op1->equals(RHS.Op1)
+           && LHS.Op2->equals(RHS.Op2);
+  }
 };
 
 class PostfixExpr : public Node {
   const Node *Child;
   const StringView Operator;
 
 public:
   PostfixExpr(const Node *Child_, StringView Operator_, Prec Prec_)
       : Node(KPostfixExpr, Prec_), Child(Child_), Operator(Operator_) {}
 
   template <typename Fn> void match(Fn F) const {
     F(Child, Operator, getPrecedence());
   }
 
   void printLeft(OutputBuffer &OB) const override {
     Child->printAsOperand(OB, getPrecedence(), true);
     OB += Operator;
   }
+
+  friend bool operator==(PostfixExpr const& LHS,
+                         PostfixExpr const& RHS) {
+    return LHS.Operator == RHS.Operator
+           && LHS.Child->equals(RHS.Child);
+  }
 };
 
 class ConditionalExpr : public Node {
   const Node *Cond;
   const Node *Then;
   const Node *Else;
 
 public:
   ConditionalExpr(const Node *Cond_, const Node *Then_, const Node *Else_,
                   Prec Prec_)
       : Node(KConditionalExpr, Prec_), Cond(Cond_), Then(Then_), Else(Else_) {}
 
   template <typename Fn> void match(Fn F) const {
     F(Cond, Then, Else, getPrecedence());
   }
 
   void printLeft(OutputBuffer &OB) const override {
     Cond->printAsOperand(OB, getPrecedence());
     OB += " ? ";
     Then->printAsOperand(OB);
     OB += " : ";
     Else->printAsOperand(OB, Prec::Assign, true);
   }
+
+  friend bool operator==(ConditionalExpr const& LHS,
+                         ConditionalExpr const& RHS) {
+    return LHS.Cond->equals(RHS.Cond)
+           && LHS.Then->equals(RHS.Then)
+           && LHS.Else->equals(RHS.Else);
+  }
 };
 
 class MemberExpr : public Node {
   const Node *LHS;
   const StringView Kind;
   const Node *RHS;
 
 public:
   MemberExpr(const Node *LHS_, StringView Kind_, const Node *RHS_, Prec Prec_)
       : Node(KMemberExpr, Prec_), LHS(LHS_), Kind(Kind_), RHS(RHS_) {}
 
   template <typename Fn> void match(Fn F) const {
     F(LHS, Kind, RHS, getPrecedence());
   }
 
   void printLeft(OutputBuffer &OB) const override {
     LHS->printAsOperand(OB, getPrecedence(), true);
     OB += Kind;
     RHS->printAsOperand(OB, getPrecedence(), false);
   }
+
+  friend bool operator==(MemberExpr const& LHS,
+                         MemberExpr const& RHS) {
+    return LHS.Kind == RHS.Kind
+           && LHS.LHS->equals(RHS.LHS)
+           && LHS.RHS->equals(RHS.RHS);
+  }
 };
 
 class SubobjectExpr : public Node {
   const Node *Type;
   const Node *SubExpr;
   StringView Offset;
   NodeArray UnionSelectors;
   bool OnePastTheEnd;
void printLeft(OutputBuffer &OB) const override {
     } else if (Offset[0] == 'n') {
       OB += "-";
       OB += Offset.dropFront();
     } else {
       OB += Offset;
     }
     OB += ">";
   }
+
+  friend bool operator==(SubobjectExpr const& LHS,
+                         SubobjectExpr const& RHS) {
+    return LHS.Offset == RHS.Offset
+           && LHS.OnePastTheEnd == RHS.OnePastTheEnd
+           && LHS.Type->equals(RHS.Type)
+           && LHS.SubExpr->equals(RHS.SubExpr)
+           && LHS.UnionSelectors == RHS.UnionSelectors;
+  }
 };
 
 class EnclosingExpr : public Node {
   const StringView Prefix;
   const Node *Infix;
   const StringView Postfix;
 
 public:
   EnclosingExpr(StringView Prefix_, const Node *Infix_,
                 Prec Prec_ = Prec::Primary)
       : Node(KEnclosingExpr, Prec_), Prefix(Prefix_), Infix(Infix_) {}
 
   template <typename Fn> void match(Fn F) const {
     F(Prefix, Infix, getPrecedence());
   }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += Prefix;
     OB.printOpen();
     Infix->print(OB);
     OB.printClose();
     OB += Postfix;
   }
+
+  friend bool operator==(EnclosingExpr const& LHS,
+                         EnclosingExpr const& RHS) {
+    return LHS.Prefix == RHS.Prefix
+           && LHS.Postfix == RHS.Postfix
+           && LHS.Infix->equals(RHS.Infix);
+  }
 };
 
 class CastExpr : public Node {
   // cast_kind<to>(from)
   const StringView CastKind;
   const Node *To;
   const Node *From;
 
OB += CastKind;
       OB += "<";
       To->printLeft(OB);
       OB += ">";
     }
     OB.printOpen();
     From->printAsOperand(OB);
     OB.printClose();
   }
+
+  friend bool operator==(CastExpr const& LHS,
+                         CastExpr const& RHS) {
+    return LHS.CastKind == RHS.CastKind
+           && LHS.To->equals(RHS.To)
+           && LHS.From->equals(RHS.From);
+  }
 };
 
 class SizeofParamPackExpr : public Node {
   const Node *Pack;
 
 public:
   SizeofParamPackExpr(const Node *Pack_)
       : Node(KSizeofParamPackExpr), Pack(Pack_) {}
 
   template<typename Fn> void match(Fn F) const { F(Pack); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "sizeof...";
     OB.printOpen();
     ParameterPackExpansion PPE(Pack);
     PPE.printLeft(OB);
     OB.printClose();
   }
+
+  friend bool operator==(SizeofParamPackExpr const& LHS,
+                         SizeofParamPackExpr const& RHS) {
+    return LHS.Pack->equals(RHS.Pack);
+  }
 };
 
 class CallExpr : public Node {
   const Node *Callee;
   NodeArray Args;
 
 public:
   CallExpr(const Node *Callee_, NodeArray Args_, Prec Prec_)
       : Node(KCallExpr, Prec_), Callee(Callee_), Args(Args_) {}
 
   template <typename Fn> void match(Fn F) const {
     F(Callee, Args, getPrecedence());
   }
 
   void printLeft(OutputBuffer &OB) const override {
     Callee->print(OB);
     OB.printOpen();
     Args.printWithComma(OB);
     OB.printClose();
   }
+
+  friend bool operator==(CallExpr const& LHS,
+                         CallExpr const& RHS) {
+    return LHS.Callee->equals(RHS.Callee)
+           && LHS.Args == RHS.Args;
+  }
 };
 
 class NewExpr : public Node {
   // new (expr_list) type(init_list)
   NodeArray ExprList;
   Node *Type;
   NodeArray InitList;
   bool IsGlobal; // ::operator new ?
void printLeft(OutputBuffer &OB) const override {
     OB += " ";
     Type->print(OB);
     if (!InitList.empty()) {
       OB.printOpen();
       InitList.printWithComma(OB);
       OB.printClose();
     }
   }
+
+  friend bool operator==(NewExpr const& LHS,
+                         NewExpr const& RHS) {
+    return LHS.IsGlobal == RHS.IsGlobal
+           && LHS.IsArray == RHS.IsArray
+           && LHS.Type->equals(RHS.Type)
+           && LHS.ExprList == RHS.ExprList
+           && LHS.InitList == RHS.InitList;
+  }
 };
 
 class DeleteExpr : public Node {
   Node *Op;
   bool IsGlobal;
   bool IsArray;
 
 public:
void printLeft(OutputBuffer &OB) const override {
     if (IsGlobal)
       OB += "::";
     OB += "delete";
     if (IsArray)
       OB += "[]";
     OB += ' ';
     Op->print(OB);
   }
+
+  friend bool operator==(DeleteExpr const& LHS,
+                         DeleteExpr const& RHS) {
+    return LHS.IsGlobal == RHS.IsGlobal
+           && LHS.IsArray == RHS.IsArray
+           && LHS.Op->equals(RHS.Op);
+  }
 };
 
 class PrefixExpr : public Node {
   StringView Prefix;
   Node *Child;
 
 public:
   PrefixExpr(StringView Prefix_, Node *Child_, Prec Prec_)
       : Node(KPrefixExpr, Prec_), Prefix(Prefix_), Child(Child_) {}
 
   template <typename Fn> void match(Fn F) const {
     F(Prefix, Child, getPrecedence());
   }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += Prefix;
     Child->printAsOperand(OB, getPrecedence());
   }
+
+  friend bool operator==(PrefixExpr const& LHS,
+                         PrefixExpr const& RHS) {
+    return LHS.Prefix == RHS.Prefix
+           && LHS.Child->equals(RHS.Child);
+  }
 };
 
 class FunctionParam : public Node {
   StringView Number;
 
 public:
   FunctionParam(StringView Number_) : Node(KFunctionParam), Number(Number_) {}
 
   template<typename Fn> void match(Fn F) const { F(Number); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "fp";
     OB += Number;
   }
+
+  friend bool operator==(FunctionParam const& LHS,
+                         FunctionParam const& RHS) {
+    return LHS.Number == RHS.Number;
+  }
 };
 
 class ConversionExpr : public Node {
   const Node *Type;
   NodeArray Expressions;
 
 public:
   ConversionExpr(const Node *Type_, NodeArray Expressions_, Prec Prec_)
       : Node(KConversionExpr, Prec_), Type(Type_), Expressions(Expressions_) {}
 
   template <typename Fn> void match(Fn F) const {
     F(Type, Expressions, getPrecedence());
   }
 
   void printLeft(OutputBuffer &OB) const override {
     OB.printOpen();
     Type->print(OB);
     OB.printClose();
     OB.printOpen();
     Expressions.printWithComma(OB);
     OB.printClose();
   }
+
+  friend bool operator==(ConversionExpr const& LHS,
+                         ConversionExpr const& RHS) {
+    return LHS.Type->equals(RHS.Type)
+           && LHS.Expressions == RHS.Expressions;
+  }
 };
 
 class PointerToMemberConversionExpr : public Node {
   const Node *Type;
   const Node *SubExpr;
   StringView Offset;
 
 public:
public:
   void printLeft(OutputBuffer &OB) const override {
     OB.printOpen();
     Type->print(OB);
     OB.printClose();
     OB.printOpen();
     SubExpr->print(OB);
     OB.printClose();
   }
+
+  friend bool operator==(PointerToMemberConversionExpr const& LHS,
+                         PointerToMemberConversionExpr const& RHS) {
+    return LHS.Offset == RHS.Offset
+           && LHS.Type->equals(RHS.Type)
+           && LHS.SubExpr->equals(RHS.SubExpr);
+  }
 };
 
 class InitListExpr : public Node {
   const Node *Ty;
   NodeArray Inits;
 public:
   InitListExpr(const Node *Ty_, NodeArray Inits_)
       : Node(KInitListExpr), Ty(Ty_), Inits(Inits_) {}
 
   template<typename Fn> void match(Fn F) const { F(Ty, Inits); }
 
   void printLeft(OutputBuffer &OB) const override {
     if (Ty)
       Ty->print(OB);
     OB += '{';
     Inits.printWithComma(OB);
     OB += '}';
   }
+
+  friend bool operator==(InitListExpr const& LHS,
+                         InitListExpr const& RHS) {
+    if (!!LHS.Ty != !!RHS.Ty)
+      return false;
+
+    if (LHS.Ty)
+      if (!LHS.Ty->equals(RHS.Ty))
+        return false;
+
+    return LHS.Inits == RHS.Inits;
+  }
 };
 
 class BracedExpr : public Node {
   const Node *Elem;
   const Node *Init;
   bool IsArray;
 public:
   BracedExpr(const Node *Elem_, const Node *Init_, bool IsArray_)
void printLeft(OutputBuffer &OB) const override {
     } else {
       OB += '.';
       Elem->print(OB);
     }
     if (Init->getKind() != KBracedExpr && Init->getKind() != KBracedRangeExpr)
       OB += " = ";
     Init->print(OB);
   }
+
+  friend bool operator==(BracedExpr const& LHS,
+                         BracedExpr const& RHS) {
+    return LHS.IsArray == RHS.IsArray
+           && LHS.Elem->equals(RHS.Elem)
+           && LHS.Init->equals(RHS.Init);
+  }
 };
 
 class BracedRangeExpr : public Node {
   const Node *First;
   const Node *Last;
   const Node *Init;
 public:
   BracedRangeExpr(const Node *First_, const Node *Last_, const Node *Init_)
       : Node(KBracedRangeExpr), First(First_), Last(Last_), Init(Init_) {}
 
   template<typename Fn> void match(Fn F) const { F(First, Last, Init); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += '[';
     First->print(OB);
     OB += " ... ";
     Last->print(OB);
     OB += ']';
     if (Init->getKind() != KBracedExpr && Init->getKind() != KBracedRangeExpr)
       OB += " = ";
     Init->print(OB);
   }
+
+  friend bool operator==(BracedRangeExpr const& LHS,
+                         BracedRangeExpr const& RHS) {
+    return LHS.First->equals(RHS.First)
+           && LHS.Last->equals(RHS.Last)
+           && LHS.Init->equals(RHS.Init);
+  }
 };
 
 class FoldExpr : public Node {
   const Node *Pack, *Init;
   StringView OperatorName;
   bool IsLeftFold;
 
 public:
if (IsLeftFold || Init != nullptr) {
       OB << " " << OperatorName << " ";
       if (IsLeftFold)
         PrintPack();
       else
         Init->printAsOperand(OB, Prec::Cast, true);
     }
     OB.printClose();
   }
+
+  friend bool operator==(FoldExpr const& LHS,
+                         FoldExpr const& RHS) {
+    if (LHS.IsLeftFold != RHS.IsLeftFold
+        || LHS.OperatorName == RHS.OperatorName)
+      return false;
+
+    if (!!LHS.Pack != !!RHS.Pack)
+      return false;
+
+    if (LHS.Pack)
+      if (!LHS.Pack->equals(RHS.Pack))
+        return false;
+
+    return LHS.Init->equals(RHS.Init);
+  }
 };
 
 class ThrowExpr : public Node {
   const Node *Op;
 
 public:
   ThrowExpr(const Node *Op_) : Node(KThrowExpr), Op(Op_) {}
 
   template<typename Fn> void match(Fn F) const { F(Op); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "throw ";
     Op->print(OB);
   }
+
+  friend bool operator==(ThrowExpr const& LHS,
+                         ThrowExpr const& RHS) {
+    return LHS.Op->equals(RHS.Op);
+  }
 };
 
 class BoolExpr : public Node {
   bool Value;
 
 public:
   BoolExpr(bool Value_) : Node(KBoolExpr), Value(Value_) {}
 
   template<typename Fn> void match(Fn F) const { F(Value); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += Value ? StringView("true") : StringView("false");
   }
+
+  friend bool operator==(BoolExpr const& LHS,
+                         BoolExpr const& RHS) {
+    return LHS.Value == RHS.Value;
+  }
 };
 
 class StringLiteral : public Node {
   const Node *Type;
 
 public:
   StringLiteral(const Node *Type_) : Node(KStringLiteral), Type(Type_) {}
 
   template<typename Fn> void match(Fn F) const { F(Type); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "\"<";
     Type->print(OB);
     OB += ">\"";
   }
+
+  friend bool operator==(StringLiteral const& LHS,
+                         StringLiteral const& RHS) {
+    assert(LHS.Type != nullptr);
+    assert(RHS.Type != nullptr);
+
+    return LHS.Type->equals(RHS.Type);
+  }
 };
 
 class LambdaExpr : public Node {
   const Node *Type;
 
 public:
   LambdaExpr(const Node *Type_) : Node(KLambdaExpr), Type(Type_) {}
 
   template<typename Fn> void match(Fn F) const { F(Type); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "[]";
     if (Type->getKind() == KClosureTypeName)
       static_cast<const ClosureTypeName *>(Type)->printDeclarator(OB);
     OB += "{...}";
   }
+
+  friend bool operator==(LambdaExpr const& LHS,
+                         LambdaExpr const& RHS) {
+    return LHS.Type->equals(RHS.Type);
+  }
 };
 
 class EnumLiteral : public Node {
   // ty(integer)
   const Node *Ty;
   StringView Integer;
 
 public:
   EnumLiteral(const Node *Ty_, StringView Integer_)
       : Node(KEnumLiteral), Ty(Ty_), Integer(Integer_) {}
 
   template<typename Fn> void match(Fn F) const { F(Ty, Integer); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB.printOpen();
     Ty->print(OB);
     OB.printClose();
 
     if (Integer[0] == 'n')
       OB << "-" << Integer.dropFront(1);
     else
       OB << Integer;
   }
+
+  friend bool operator==(EnumLiteral const& LHS,
+                         EnumLiteral const& RHS) {
+    assert(LHS.Ty != nullptr);
+    assert(RHS.Ty != nullptr);
+
+    return LHS.Integer == RHS.Integer
+           && LHS.Ty->equals(RHS.Ty);
+  }
 };
 
 class IntegerLiteral : public Node {
   StringView Type;
   StringView Value;
 
 public:
   IntegerLiteral(StringView Type_, StringView Value_)
if (Value[0] == 'n') {
       OB += '-';
       OB += Value.dropFront(1);
     } else
       OB += Value;
 
     if (Type.size() <= 3)
       OB += Type;
   }
+
+  friend bool operator==(IntegerLiteral const& LHS,
+                         IntegerLiteral const& RHS) {
+    return LHS.Type == RHS.Type
+           && LHS.Value == RHS.Value;
+  }
 };
 
 template <class Float> struct FloatData;
 
 namespace float_literal_impl {
 constexpr Node::Kind getFloatLiteralKind(float *) {
   return Node::KFloatLiteral;
 }

 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
       std::reverse(buf, e);
 #endif
       char num[FloatData<Float>::max_demangled_size] = {0};
       int n = snprintf(num, sizeof(num), FloatData<Float>::spec, value);
       OB += StringView(num, num + n);
     }
   }
+
+  friend bool operator==(FloatLiteralImpl<Float> const& LHS,
+                         FloatLiteralImpl<Float> const& RHS) {
+    return LHS.Contents == RHS.Contents;
+  }
 };
 
 using FloatLiteral = FloatLiteralImpl<float>;
 using DoubleLiteral = FloatLiteralImpl<double>;
 using LongDoubleLiteral = FloatLiteralImpl<long double>;
 
 /// Visit the node. Calls \c F(P), where \c P is the node cast to the
 /// appropriate derived class.

llvm/lib/Demangle/ItaniumDemangle.cpp

if (*first == '_') {
         ;
       if (t1 == last)
         first = last;
     }
   }
   return first;
 }
 
+bool Node::equals(Node const* Other) const {
+  assert(Other != nullptr);
+
+  if (K != Other->getKind())
+    return false;
+
+  switch (K) {
+#define NODE(X)                                                                \
+  case K##X:                                                                   \
+    return *static_cast<const X *>(this)  == *static_cast<const X *>(Other);
+#include "llvm/Demangle/ItaniumNodes.def"
+  }
+  assert(0 && "unknown mangling node kind");
+}
+
+
 #ifndef NDEBUG
 namespace {
 struct DumpVisitor {
   unsigned Depth = 0;
   bool PendingNewline = false;
 
   template<typename NodeT> static constexpr bool wantsNewline(const NodeT *) {
     return true;

llvm/unittests/Demangle/ItaniumDemangleTest.cpp

 //===------------------ ItaniumDemangleTest.cpp ---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Demangle/ItaniumDemangle.h"
+#include "ItaniumDemangleTestUtils.h"
+#include "llvm/IR/Argument.h"
 #include "llvm/Support/Allocator.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include <algorithm>
 #include <cstdlib>
+#include <iterator>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::itanium_demangle;
-
-namespace {
-class TestAllocator {
-  BumpPtrAllocator Alloc;
-
-public:
-  void reset() { Alloc.Reset(); }
-
-  template <typename T, typename... Args> T *makeNode(Args &&... args) {
-    return new (Alloc.Allocate(sizeof(T), alignof(T)))
-        T(std::forward<Args>(args)...);
-  }
-
-  void *allocateNodeArray(size_t sz) {
-    return Alloc.Allocate(sizeof(Node *) * sz, alignof(Node *));
-  }
-};
-} // namespace
+using namespace llvm::itanium_demangle::test_utils;
 
 namespace NodeMatcher {
 // Make sure the node matchers provide constructor parameters. This is a
 // compilation test.
 template <typename NT> struct Ctor {
   template <typename... Args> void operator()(Args &&...args) {
     auto _ = NT(std::forward<Args>(args)...);
   }
struct TestParser : AbstractManglingParser<TestParser, TestAllocator> {
     }
   };
 
   // void f(A<_Float16>, _Float16);
   TestParser Parser("_Z1f1AIDF16_EDF16_");
   ASSERT_NE(nullptr, Parser.parse());
   EXPECT_THAT(Parser.Types, testing::ElementsAre("_Float16", "A", "_Float16"));
 }
+
+TEST(ItaniumDemangle, Equality_NodeArray) {
+  ManglingNodeCreator Creator;
+
+  // Test empty NodeArray equality
+  std::vector<Node *> LHS;
+  std::vector<Node *> RHS;
+
+  // Empty == Empty
+  ASSERT_EQ(Creator.makeNodeArray(LHS.cbegin(), LHS.cend()),
+            Creator.makeNodeArray(RHS.cbegin(), RHS.cend()));
+
+  RHS.push_back(Creator.makeReferenceType(Qualifiers::QualNone, "test",
+                                          ReferenceKind::RValue));
+
+  // Empty vs. non-empty
+  ASSERT_NE(Creator.makeNodeArray(LHS.cbegin(), LHS.cend()),
+            Creator.makeNodeArray(RHS.cbegin(), RHS.cend()));
+
+  LHS.push_back(Creator.makeReferenceType(Qualifiers::QualNone, "test",
+                                          ReferenceKind::RValue));
+
+  // Equal single nodes
+  ASSERT_EQ(Creator.makeNodeArray(LHS.cbegin(), LHS.cend()),
+            Creator.makeNodeArray(RHS.cbegin(), RHS.cend()));
+
+  LHS.push_back(Creator.makeReferenceType(Qualifiers::QualNone, "test",
+                                          ReferenceKind::LValue));
+  RHS.push_back(Creator.makeReferenceType(Qualifiers::QualRestrict, "test",
+                                          ReferenceKind::RValue));
+
+  // Non-equal second node
+  ASSERT_NE(Creator.makeNodeArray(LHS.cbegin(), LHS.cend()),
+            Creator.makeNodeArray(RHS.cbegin(), RHS.cend()));
+}
+
+TEST(ItaniumDemangle, Equality_QualType) {
+  ManglingNodeCreator Creator;
+
+  {
+    // Same qualifiers and name
+    Node const *Q1 = Creator.makeQualType("Test", Qualifiers::QualVolatile);
+    Node const *Q2 = Creator.makeQualType("Test", Qualifiers::QualVolatile);
+    ASSERT_TRUE(test_utils::compareNodes(Q1, Q2));
+  }
+
+  {
+    // Different qualifiers
+    Node const *Q1 = Creator.makeQualType("Test", Qualifiers::QualNone);
+    Node const *Q2 = Creator.makeQualType("Test", Qualifiers::QualRestrict);
+    ASSERT_FALSE(test_utils::compareNodes(Q1, Q2));
+  }
+
+  {
+    // Different name
+    Node const *Q1 = Creator.makeQualType("Test", Qualifiers::QualNone);
+    Node const *Q2 = Creator.makeQualType("", Qualifiers::QualNone);
+    ASSERT_FALSE(test_utils::compareNodes(Q1, Q2));
+  }
+}
+
+TEST(ItaniumDemangle, Equality_NameType) {
+  ManglingNodeCreator Creator;
+
+  {
+    // Both empty
+    Node const *Q1 = Creator.makeNameType("");
+    Node const *Q2 = Creator.makeNameType("");
+    ASSERT_TRUE(test_utils::compareNodes(Q1, Q2));
+  }
+
+  {
+    // Both non-empty
+    Node const *Q1 = Creator.makeNameType("test");
+    Node const *Q2 = Creator.makeNameType("test");
+    ASSERT_TRUE(test_utils::compareNodes(Q1, Q2));
+  }
+
+  {
+    // Not equal
+    Node const *Q1 = Creator.makeNameType("test");
+    Node const *Q2 = Creator.makeNameType("tes");
+    ASSERT_FALSE(test_utils::compareNodes(Q1, Q2));
+  }
+}
+
+TEST(ItaniumDemangle, Equality_ReferenceType) {
+  ManglingNodeCreator Creator;
+
+  {
+    // Same type
+    Node const *Q1 = Creator.makeReferenceType(Qualifiers::QualVolatile, "Test",
+                                               ReferenceKind::LValue);
+    Node const *Q2 = Creator.makeReferenceType(Qualifiers::QualVolatile, "Test",
+                                               ReferenceKind::LValue);
+    ASSERT_TRUE(test_utils::compareNodes(Q1, Q2));
+  }
+
+  {
+    // Different name
+    Node const *Q1 = Creator.makeReferenceType(Qualifiers::QualVolatile, "Test",
+                                               ReferenceKind::LValue);
+    Node const *Q2 = Creator.makeReferenceType(Qualifiers::QualVolatile, "Tes",
+                                               ReferenceKind::LValue);
+    ASSERT_FALSE(test_utils::compareNodes(Q1, Q2));
+  }
+
+  {
+    // Different CV-qualifiers
+    Node const *Q1 = Creator.makeReferenceType(Qualifiers::QualVolatile, "Test",
+                                               ReferenceKind::LValue);
+    Node const *Q2 = Creator.makeReferenceType(Qualifiers::QualRestrict, "Test",
+                                               ReferenceKind::LValue);
+    ASSERT_FALSE(test_utils::compareNodes(Q1, Q2));
+  }
+
+  {
+    // Different ref-qualifiers
+    Node const *Q1 = Creator.makeReferenceType(Qualifiers::QualVolatile, "Test",
+                                               ReferenceKind::LValue);
+    Node const *Q2 = Creator.makeReferenceType(Qualifiers::QualVolatile, "Test",
+                                               ReferenceKind::RValue);
+    ASSERT_FALSE(test_utils::compareNodes(Q1, Q2));
+  }
+}
+
+TEST(ItaniumDemangle, Equality_TemplateArgs) {
+  ManglingNodeCreator Creator;
+
+  std::vector<Node *> LHS;
+  std::vector<Node *> RHS;
+
+  {
+    // Both empty
+    Node const *Q1 = Creator.makeTemplateArgs(LHS);
+    Node const *Q2 = Creator.makeTemplateArgs(RHS);
+    ASSERT_TRUE(test_utils::compareNodes(Q1, Q2));
+  }
+
+  LHS.push_back(Creator.makeNameType("test"));
+  RHS.push_back(Creator.makeNameType("test"));
+
+  {
+    // Both equal
+    Node const *Q1 = Creator.makeTemplateArgs(LHS);
+    Node const *Q2 = Creator.makeTemplateArgs(RHS);
+    ASSERT_TRUE(test_utils::compareNodes(Q1, Q2));
+  }
+
+  LHS.push_back(Creator.makeNameType("foo"));
+  RHS.push_back(Creator.makeNameType("bar"));
+
+  {
+    // Not equal anymore
+    Node const *Q1 = Creator.makeTemplateArgs(LHS);
+    Node const *Q2 = Creator.makeTemplateArgs(RHS);
+    ASSERT_FALSE(test_utils::compareNodes(Q1, Q2));
+  }
+}

llvm/unittests/Demangle/ItaniumDemangleTestUtils.h

+//===------------------ ItaniumDemangleTestUtils.h ------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEMANGLE_ITANIUMDEMANGLE_TEST_UTILS_H
+#define LLVM_DEMANGLE_ITANIUMDEMANGLE_TEST_UTILS_H
+
+#include "llvm/Demangle/Demangle.h"
+#include "llvm/Demangle/ItaniumDemangle.h"
+#include "llvm/Demangle/StringView.h"
+#include "llvm/Support/Allocator.h"
+
+#include <vector>
+
+namespace llvm::itanium_demangle::test_utils {
+
+class TestAllocator {
+  BumpPtrAllocator Alloc;
+
+public:
+  void reset() { Alloc.Reset(); }
+
+  template <typename T, typename... Args> T *makeNode(Args &&...args) {
+    return new (Alloc.Allocate(sizeof(T), alignof(T)))
+        T(std::forward<Args>(args)...);
+  }
+
+  void *allocateNodeArray(size_t sz) {
+    return Alloc.Allocate(sizeof(Node *) * sz, alignof(Node *));
+  }
+};
+
+struct ManglingNodeCreator
+    : AbstractManglingParser<ManglingNodeCreator, TestAllocator> {
+
+  ManglingNodeCreator() : AbstractManglingParser(nullptr, nullptr) {}
+
+  auto *makeNameType(StringView Type) { return make<NameType>(Type); }
+
+  auto *makeTemplateArgs(std::vector<Node *> const &Args) {
+    return make<TemplateArgs>(makeNodeArray(Args.cbegin(), Args.cend()));
+  }
+
+  auto *makeQualType(StringView VarName, Qualifiers Quals) {
+    return make<QualType>(makeNameType(VarName), Quals);
+  }
+
+  auto *makeReferenceType(Qualifiers Quals, StringView ArgName,
+                          ReferenceKind RefKind) {
+    return make<ReferenceType>(makeQualType(ArgName, Quals), RefKind);
+  }
+
+  auto *makeNameWithTemplateArgsNode(StringView FnName,
+                                     std::vector<Node *> const &Args) {
+    auto *TArgs = makeTemplateArgs(Args);
+    return make<NameWithTemplateArgs>(makeNameType(FnName), TArgs);
+  }
+
+  auto *makeFunctionEncoding(StringView FnName, NodeArray Params,
+                             Qualifiers CVQuals, FunctionRefQual RefQual) {
+    auto const *NameNode = makeNameType(FnName);
+    return make<FunctionEncoding>(nullptr, NameNode, Params, nullptr, CVQuals,
+                                  RefQual);
+  }
+};
+
+inline bool compareNodes(Node const *LHS, Node const *RHS) {
+  return LHS && RHS && LHS->equals(RHS);
+}
+
+} // namespace llvm::itanium_demangle::test_utils
+
+#endif // LLVM_DEMANGLE_ITANIUMDEMANGLE_TEST_UTILS_H