[demangler] Fix node matchers

[urnathan]

Summary

This fixes up the matcher fallout from D120905

• Add instantiation tests to ItaniumDemangleTest, to make sure all match functions provide constructor arguments to the provided functor. This found some problems ...

• Fix the Node constructors that lost const qualification on arguments.

The node names are broken out into a def file by D122739, which this depends upon

[dblaikie]

llvm/include/llvm/Demangle/ItaniumDemangle.h

2377–2379

The modules-unfriendly nature of this worries me a bit.

Maybe we could change the FOR_EACH_NODE_KIND to a .def file instead? (basically take the macro out, put it in another (includable, intentionally non-modular) file that calls the includer-defined macro & undefs the macro at the end (so it doesn't persist/pollute other things))

We have a lot of these in LLVM, one example (though it handles a variet of different lists, which adds more complexity than will be needed here) is llvm/include/llvm/BinaryFormat/Dwarf.def

[dblaikie]

Sounds good

[urnathan]

committed d7692c0f9b06 2022-04-01 | [demangler] Fix node matcher test
to fix build bot: https://lab.llvm.org/buildbot/#/builders/216/builds/2249

libcxxabi/src/demangle/ItaniumDemangle.h

public:
   }
 };
 
 class PostfixQualifiedType final : public Node {
   const Node *Ty;
   const StringView Postfix;
 
 public:
-  PostfixQualifiedType(Node *Ty_, StringView Postfix_)
+  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;
   }
public:
   }
 };
 
 class VectorType final : public Node {
   const Node *BaseType;
   const Node *Dimension;
 
 public:
-  VectorType(const Node *BaseType_, Node *Dimension_)
-      : Node(KVectorType), BaseType(BaseType_),
-        Dimension(Dimension_) {}
+  VectorType(const Node *BaseType_, const Node *Dimension_)
+      : Node(KVectorType), BaseType(BaseType_), Dimension(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);

 };
 
 class EnclosingExpr : public Node {
   const StringView Prefix;
   const Node *Infix;
   const StringView Postfix;
 
 public:
-  EnclosingExpr(StringView Prefix_, Node *Infix_, Prec Prec_ = Prec::Primary)
+  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;

llvm/include/llvm/Demangle/ItaniumDemangle.h

public:
   }
 };
 
 class PostfixQualifiedType final : public Node {
   const Node *Ty;
   const StringView Postfix;
 
 public:
-  PostfixQualifiedType(Node *Ty_, StringView Postfix_)
+  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;
   }
public:
   }
 };
 
 class VectorType final : public Node {
   const Node *BaseType;
   const Node *Dimension;
 
 public:
-  VectorType(const Node *BaseType_, Node *Dimension_)
-      : Node(KVectorType), BaseType(BaseType_),
-        Dimension(Dimension_) {}
+  VectorType(const Node *BaseType_, const Node *Dimension_)
+      : Node(KVectorType), BaseType(BaseType_), Dimension(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);

 };
 
 class EnclosingExpr : public Node {
   const StringView Prefix;
   const Node *Infix;
   const StringView Postfix;
 
 public:
-  EnclosingExpr(StringView Prefix_, Node *Infix_, Prec Prec_ = Prec::Primary)
+  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;

 
 /// Determine the kind of a node from its type.
 template<typename NodeT> struct NodeKind;
 #define NODE(X)                                                                \
   template <> struct NodeKind<X> {                                             \
     static constexpr Node::Kind Kind = Node::K##X;                             \
     static constexpr const char *name() { return #X; }                         \
   };
 #include "ItaniumNodes.def"
 
 template <typename Derived, typename Alloc> struct AbstractManglingParser {
   const char *First;
   const char *Last;
 
   // Name stack, this is used by the parser to hold temporary names that were
   // parsed. The parser collapses multiple names into new nodes to construct
   // the AST. Once the parser is finished, names.size() == 1.
   PODSmallVector<Node *, 32> Names;
 

llvm/unittests/Demangle/ItaniumDemangleTest.cpp

public:
   }
 
   void *allocateNodeArray(size_t sz) {
     return Alloc.Allocate(sizeof(Node *) * sz, alignof(Node *));
   }
 };
 } // namespace
 
+namespace {
+// 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)...);
+  }
+};
+
+template <typename NT> void Visit(const NT *Node) { Node->match(Ctor<NT>{}); }
+#define NOMATCHER(X)                                                           \
+  template <> void Visit<itanium_demangle::X>(const itanium_demangle::X *) {}
+// Some nodes have no match member.
+NOMATCHER(ForwardTemplateReference)
+#undef NOMATCHER
+
+void __attribute__((used)) Visitor() {
+#define NODE(X) Visit(static_cast<const itanium_demangle::X *>(nullptr));
+#include "llvm/Demangle/ItaniumNodes.def"
+}
+} // namespace
+
 TEST(ItaniumDemangle, MethodOverride) {
   struct TestParser : AbstractManglingParser<TestParser, TestAllocator> {
     std::vector<char> Types;
 
     TestParser(const char *Str)
         : AbstractManglingParser(Str, Str + strlen(Str)) {}
 
     Node *parseType() {