[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

2460–2462

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/cxa_demangle.cpp

void print(TemplateParamKind TPK) {
     case TemplateParamKind::Type:
       return printStr("TemplateParamKind::Type");
     case TemplateParamKind::NonType:
       return printStr("TemplateParamKind::NonType");
     case TemplateParamKind::Template:
       return printStr("TemplateParamKind::Template");
     }
   }
-  void print(Node::Prec) {
-    // FIXME: Print Prec enumerator
+  void print(Node::Prec P) {
+    switch (P) {
+    case Node::Prec::Primary:
+      return printStr("Node::Prec::Primary");
+    case Node::Prec::Postfix:
+      return printStr("Node::Prec::Postfix");
+    case Node::Prec::Unary:
+      return printStr("Node::Prec::Unary");
+    case Node::Prec::Cast:
+      return printStr("Node::Prec::Cast");
+    case Node::Prec::PtrMem:
+      return printStr("Node::Prec::PtrMem");
+    case Node::Prec::Multiplicative:
+      return printStr("Node::Prec::Multiplicative");
+    case Node::Prec::Additive:
+      return printStr("Node::Prec::Additive");
+    case Node::Prec::Shift:
+      return printStr("Node::Prec::Shift");
+    case Node::Prec::Spaceship:
+      return printStr("Node::Prec::Spaceship");
+    case Node::Prec::Relational:
+      return printStr("Node::Prec::Relational");
+    case Node::Prec::Equality:
+      return printStr("Node::Prec::Equality");
+    case Node::Prec::And:
+      return printStr("Node::Prec::And");
+    case Node::Prec::Xor:
+      return printStr("Node::Prec::Xor");
+    case Node::Prec::Ior:
+      return printStr("Node::Prec::Ior");
+    case Node::Prec::AndIf:
+      return printStr("Node::Prec::AndIf");
+    case Node::Prec::OrIf:
+      return printStr("Node::Prec::OrIf");
+    case Node::Prec::Conditional:
+      return printStr("Node::Prec::Conditional");
+    case Node::Prec::Assign:
+      return printStr("Node::Prec::Assign");
+    case Node::Prec::Comma:
+      return printStr("Node::Prec::Comma");
+    case Node::Prec::Default:
+      return printStr("Node::Prec::Default");
+    }
   }
 
   void newLine() {
     printStr("\n");
     for (unsigned I = 0; I != Depth; ++I)
       printStr(" ");
     PendingNewline = false;
   }

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;

 #define SPECIALIZATION(X) \
   template<> struct NodeKind<X> { \
     static constexpr Node::Kind Kind = Node::K##X; \
     static constexpr const char *name() { return #X; } \
   };
 FOR_EACH_NODE_KIND(SPECIALIZATION)
 #undef SPECIALIZATION
 
+#ifndef LLVM_UNIT_TEST
 #undef FOR_EACH_NODE_KIND
+#endif
 
 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.

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;

 #define SPECIALIZATION(X) \
   template<> struct NodeKind<X> { \
     static constexpr Node::Kind Kind = Node::K##X; \
     static constexpr const char *name() { return #X; } \
   };
 FOR_EACH_NODE_KIND(SPECIALIZATION)
 #undef SPECIALIZATION
 
+#ifndef LLVM_UNIT_TEST
 #undef FOR_EACH_NODE_KIND
+#endif
 
 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.

llvm/lib/Demangle/ItaniumDemangle.cpp

void print(TemplateParamKind TPK) {
     case TemplateParamKind::Type:
       return printStr("TemplateParamKind::Type");
     case TemplateParamKind::NonType:
       return printStr("TemplateParamKind::NonType");
     case TemplateParamKind::Template:
       return printStr("TemplateParamKind::Template");
     }
   }
-  void print(llvm::itanium_demangle::Node::Prec) {
-    // Do nothing, the printing functions handle precedence with parentheses
-    // already.
+  void print(Node::Prec P) {
+    switch (P) {
+    case Node::Prec::Primary:
+      return printStr("Node::Prec::Primary");
+    case Node::Prec::Postfix:
+      return printStr("Node::Prec::Postfix");
+    case Node::Prec::Unary:
+      return printStr("Node::Prec::Unary");
+    case Node::Prec::Cast:
+      return printStr("Node::Prec::Cast");
+    case Node::Prec::PtrMem:
+      return printStr("Node::Prec::PtrMem");
+    case Node::Prec::Multiplicative:
+      return printStr("Node::Prec::Multiplicative");
+    case Node::Prec::Additive:
+      return printStr("Node::Prec::Additive");
+    case Node::Prec::Shift:
+      return printStr("Node::Prec::Shift");
+    case Node::Prec::Spaceship:
+      return printStr("Node::Prec::Spaceship");
+    case Node::Prec::Relational:
+      return printStr("Node::Prec::Relational");
+    case Node::Prec::Equality:
+      return printStr("Node::Prec::Equality");
+    case Node::Prec::And:
+      return printStr("Node::Prec::And");
+    case Node::Prec::Xor:
+      return printStr("Node::Prec::Xor");
+    case Node::Prec::Ior:
+      return printStr("Node::Prec::Ior");
+    case Node::Prec::AndIf:
+      return printStr("Node::Prec::AndIf");
+    case Node::Prec::OrIf:
+      return printStr("Node::Prec::OrIf");
+    case Node::Prec::Conditional:
+      return printStr("Node::Prec::Conditional");
+    case Node::Prec::Assign:
+      return printStr("Node::Prec::Assign");
+    case Node::Prec::Comma:
+      return printStr("Node::Prec::Comma");
+    case Node::Prec::Default:
+      return printStr("Node::Prec::Default");
+    }
   }
 
   void newLine() {
     printStr("\n");
     for (unsigned I = 0; I != Depth; ++I)
       printStr(" ");
     PendingNewline = false;
   }

llvm/unittests/Demangle/ItaniumDemangleTest.cpp

 //===------------------ ItaniumDemangleTest.cpp ---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#define LLVM_UNIT_TEST // Stop demangler undefing FOR_EACH_NODE_KIND
 #include "llvm/Demangle/ItaniumDemangle.h"
 #include "llvm/Support/Allocator.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cstdlib>
 #include <vector>
 
 using namespace llvm;
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 CALL(X) Visit(static_cast<const itanium_demangle::X *>(nullptr));
+  FOR_EACH_NODE_KIND(CALL)
+#undef CALL
+}
+} // namespace
+
 TEST(ItaniumDemangle, MethodOverride) {
   struct TestParser : AbstractManglingParser<TestParser, TestAllocator> {
     std::vector<char> Types;
 
     TestParser(const char *Str)
         : AbstractManglingParser(Str, Str + strlen(Str)) {}
 
     Node *parseType() {