This is an archive of the discontinued LLVM Phabricator instance.

Differential D122739

[demangler][NFC] Use def file for node names
ClosedPublic

Authored by urnathan on Mar 30 2022, 8:46 AM.

Details

Reviewers
dblaikie
ldionne
Group Reviewers
Restricted Project
Commits
rG369337e3c222: [demangler][NFC] Use def file for node names
Summary

In order to add a unit test, we need to expose the node names beyond ItaniumDemangle.h. This breaks them out into a def file, as suggested by @dblaikie in D122665

Diff Detail

Event Timeline

urnathan created this revision.Mar 30 2022, 8:46 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 30 2022, 8:46 AM
urnathan requested review of this revision.Mar 30 2022, 8:46 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 30 2022, 8:46 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
urnathan mentioned this in D122665: [demangler] Fix node matchers.Mar 30 2022, 8:48 AM
urnathan added a child revision: D122665: [demangler] Fix node matchers.
Harbormaster completed remote builds in B156976: Diff 419166.Mar 30 2022, 7:31 PM
urnathan added a reviewer: Restricted Project.Mar 31 2022, 9:45 AM
dblaikie accepted this revision.Mar 31 2022, 1:12 PM

Awesome, thanks!

This revision is now accepted and ready to land.Mar 31 2022, 1:12 PM
This revision was landed with ongoing or failed builds.Apr 1 2022, 5:03 AM
Closed by commit rG369337e3c222: [demangler][NFC] Use def file for node names (authored by urnathan). · Explain Why
This revision was automatically updated to reflect the committed changes.
urnathan added a commit: rG369337e3c222: [demangler][NFC] Use def file for node names.
Herald added a project: Restricted Project. · View Herald TranscriptApr 1 2022, 5:03 AM
Herald added 1 blocking reviewer(s): Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript

Revision Contents

PathSize
libcxxabi/
src/
demangle/
105 lines
94 lines
4 lines
llvm/
include/
llvm/
Demangle/
105 lines
94 lines

Diff 419720

libcxxabi/src/demangle/ItaniumDemangle.h

Show All 22 Lines
#include <cassert> #include <cassert>
#include <cctype> #include <cctype>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#include <limits> #include <limits>
#include <utility> #include <utility>
#define FOR_EACH_NODE_KIND(X) \
X(NodeArrayNode) \
X(DotSuffix) \
X(VendorExtQualType) \
X(QualType) \
X(ConversionOperatorType) \
X(PostfixQualifiedType) \
X(ElaboratedTypeSpefType) \
X(NameType) \
X(AbiTagAttr) \
X(EnableIfAttr) \
X(ObjCProtoName) \
X(PointerType) \
X(ReferenceType) \
X(PointerToMemberType) \
X(ArrayType) \
X(FunctionType) \
X(NoexceptSpec) \
X(DynamicExceptionSpec) \
X(FunctionEncoding) \
X(LiteralOperator) \
X(SpecialName) \
X(CtorVtableSpecialName) \
X(QualifiedName) \
X(NestedName) \
X(LocalName) \
X(ModuleName) \
X(ModuleEntity) \
X(VectorType) \
X(PixelVectorType) \
X(BinaryFPType) \
X(SyntheticTemplateParamName) \
X(TypeTemplateParamDecl) \
X(NonTypeTemplateParamDecl) \
X(TemplateTemplateParamDecl) \
X(TemplateParamPackDecl) \
X(ParameterPack) \
X(TemplateArgumentPack) \
X(ParameterPackExpansion) \
X(TemplateArgs) \
X(ForwardTemplateReference) \
X(NameWithTemplateArgs) \
X(GlobalQualifiedName) \
X(ExpandedSpecialSubstitution) \
X(SpecialSubstitution) \
X(CtorDtorName) \
X(DtorName) \
X(UnnamedTypeName) \
X(ClosureTypeName) \
X(StructuredBindingName) \
X(BinaryExpr) \
X(ArraySubscriptExpr) \
X(PostfixExpr) \
X(ConditionalExpr) \
X(MemberExpr) \
X(SubobjectExpr) \
X(EnclosingExpr) \
X(CastExpr) \
X(SizeofParamPackExpr) \
X(CallExpr) \
X(NewExpr) \
X(DeleteExpr) \
X(PrefixExpr) \
X(FunctionParam) \
X(ConversionExpr) \
X(PointerToMemberConversionExpr) \
X(InitListExpr) \
X(FoldExpr) \
X(ThrowExpr) \
X(BoolExpr) \
X(StringLiteral) \
X(LambdaExpr) \
X(EnumLiteral) \
X(IntegerLiteral) \
X(FloatLiteral) \
X(DoubleLiteral) \
X(LongDoubleLiteral) \
X(BracedExpr) \
X(BracedRangeExpr)
DEMANGLE_NAMESPACE_BEGIN DEMANGLE_NAMESPACE_BEGIN
template <class T, size_t N> class PODSmallVector { template <class T, size_t N> class PODSmallVector {
static_assert(std::is_pod<T>::value, static_assert(std::is_pod<T>::value,
"T is required to be a plain old data type"); "T is required to be a plain old data type");
T *First = nullptr; T *First = nullptr;
T *Last = nullptr; T *Last = nullptr;
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Linespublic:
} }
}; };
// Base class of all AST nodes. The AST is built by the parser, then is // 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. // traversed by the printLeft/Right functions to produce a demangled string.
class Node { class Node {
public: public:
enum Kind : unsigned char { enum Kind : unsigned char {
#define ENUMERATOR(NodeKind) K ## NodeKind, #define NODE(NodeKind) K##NodeKind,
FOR_EACH_NODE_KIND(ENUMERATOR) #include "ItaniumNodes.def"
#undef ENUMERATOR
}; };
/// Three-way bool to track a cached value. Unknown is possible if this node /// 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. /// has an unexpanded parameter pack below it that may affect this cache.
enum class Cache : unsigned char { Yes, No, Unknown, }; enum class Cache : unsigned char { Yes, No, Unknown, };
/// Operator precedence for expression nodes. Used to determine required /// Operator precedence for expression nodes. Used to determine required
/// parens in expression emission. /// parens in expression emission.
▲ Show 20 Lines • Show All 2,186 Lines • ▼ Show 20 Lines
using DoubleLiteral = FloatLiteralImpl<double>; using DoubleLiteral = FloatLiteralImpl<double>;
using LongDoubleLiteral = FloatLiteralImpl<long double>; using LongDoubleLiteral = FloatLiteralImpl<long double>;
/// Visit the node. Calls \c F(P), where \c P is the node cast to the /// Visit the node. Calls \c F(P), where \c P is the node cast to the
/// appropriate derived class. /// appropriate derived class.
template<typename Fn> template<typename Fn>
void Node::visit(Fn F) const { void Node::visit(Fn F) const {
switch (K) { switch (K) {
#define CASE(X) case K ## X: return F(static_cast<const X*>(this)); #define NODE(X) \
FOR_EACH_NODE_KIND(CASE) case K##X: \
#undef CASE return F(static_cast<const X *>(this));
#include "ItaniumNodes.def"
} }
assert(0 && "unknown mangling node kind"); assert(0 && "unknown mangling node kind");
} }
/// Determine the kind of a node from its type. /// Determine the kind of a node from its type.
template<typename NodeT> struct NodeKind; template<typename NodeT> struct NodeKind;
#define SPECIALIZATION(X) \ #define NODE(X) \
template<> struct NodeKind<X> { \ template <> struct NodeKind<X> { \
static constexpr Node::Kind Kind = Node::K##X; \ static constexpr Node::Kind Kind = Node::K##X; \
static constexpr const char *name() { return #X; } \ static constexpr const char *name() { return #X; } \
}; };
FOR_EACH_NODE_KIND(SPECIALIZATION) #include "ItaniumNodes.def"
#undef SPECIALIZATION
#undef FOR_EACH_NODE_KIND
template <typename Derived, typename Alloc> struct AbstractManglingParser { template <typename Derived, typename Alloc> struct AbstractManglingParser {
const char *First; const char *First;
const char *Last; const char *Last;
// Name stack, this is used by the parser to hold temporary names that were // 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 // parsed. The parser collapses multiple names into new nodes to construct
// the AST. Once the parser is finished, names.size() == 1. // the AST. Once the parser is finished, names.size() == 1.
▲ Show 20 Lines • Show All 3,103 Lines • Show Last 20 Lines

libcxxabi/src/demangle/ItaniumNodes.def

  • This file was added.
//===------------------------- ItaniumNodes.def ----------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Define the demangler's node names
#ifndef NODE
#error Define NODE to handle nodes
#endif
NODE(NodeArrayNode)
NODE(DotSuffix)
NODE(VendorExtQualType)
NODE(QualType)
NODE(ConversionOperatorType)
NODE(PostfixQualifiedType)
NODE(ElaboratedTypeSpefType)
NODE(NameType)
NODE(AbiTagAttr)
NODE(EnableIfAttr)
NODE(ObjCProtoName)
NODE(PointerType)
NODE(ReferenceType)
NODE(PointerToMemberType)
NODE(ArrayType)
NODE(FunctionType)
NODE(NoexceptSpec)
NODE(DynamicExceptionSpec)
NODE(FunctionEncoding)
NODE(LiteralOperator)
NODE(SpecialName)
NODE(CtorVtableSpecialName)
NODE(QualifiedName)
NODE(NestedName)
NODE(LocalName)
NODE(ModuleName)
NODE(ModuleEntity)
NODE(VectorType)
NODE(PixelVectorType)
NODE(BinaryFPType)
NODE(SyntheticTemplateParamName)
NODE(TypeTemplateParamDecl)
NODE(NonTypeTemplateParamDecl)
NODE(TemplateTemplateParamDecl)
NODE(TemplateParamPackDecl)
NODE(ParameterPack)
NODE(TemplateArgumentPack)
NODE(ParameterPackExpansion)
NODE(TemplateArgs)
NODE(ForwardTemplateReference)
NODE(NameWithTemplateArgs)
NODE(GlobalQualifiedName)
NODE(ExpandedSpecialSubstitution)
NODE(SpecialSubstitution)
NODE(CtorDtorName)
NODE(DtorName)
NODE(UnnamedTypeName)
NODE(ClosureTypeName)
NODE(StructuredBindingName)
NODE(BinaryExpr)
NODE(ArraySubscriptExpr)
NODE(PostfixExpr)
NODE(ConditionalExpr)
NODE(MemberExpr)
NODE(SubobjectExpr)
NODE(EnclosingExpr)
NODE(CastExpr)
NODE(SizeofParamPackExpr)
NODE(CallExpr)
NODE(NewExpr)
NODE(DeleteExpr)
NODE(PrefixExpr)
NODE(FunctionParam)
NODE(ConversionExpr)
NODE(PointerToMemberConversionExpr)
NODE(InitListExpr)
NODE(FoldExpr)
NODE(ThrowExpr)
NODE(BoolExpr)
NODE(StringLiteral)
NODE(LambdaExpr)
NODE(EnumLiteral)
NODE(IntegerLiteral)
NODE(FloatLiteral)
NODE(DoubleLiteral)
NODE(LongDoubleLiteral)
NODE(BracedExpr)
NODE(BracedRangeExpr)
#undef NODE

libcxxabi/src/demangle/cp-to-llvm.sh

#!/bin/bash #!/bin/bash
# Copies the 'demangle' library, excluding 'DemangleConfig.h', to llvm. If no # Copies the 'demangle' library, excluding 'DemangleConfig.h', to llvm. If no
# llvm directory is specified, then assume a monorepo layout. # llvm directory is specified, then assume a monorepo layout.
set -e set -e
cd $(dirname $0) cd $(dirname $0)
HDRS="ItaniumDemangle.h StringView.h Utility.h" HDRS="ItaniumDemangle.h ItaniumNodes.def StringView.h Utility.h"
LLVM_DEMANGLE_DIR=$1 LLVM_DEMANGLE_DIR=$1
if [[ -z "$LLVM_DEMANGLE_DIR" ]]; then if [[ -z "$LLVM_DEMANGLE_DIR" ]]; then
LLVM_DEMANGLE_DIR="../../../llvm/include/llvm/Demangle" LLVM_DEMANGLE_DIR="../../../llvm/include/llvm/Demangle"
fi fi
if [[ ! -d "$LLVM_DEMANGLE_DIR" ]]; then if [[ ! -d "$LLVM_DEMANGLE_DIR" ]]; then
echo "No such directory: $LLVM_DEMANGLE_DIR" >&2 echo "No such directory: $LLVM_DEMANGLE_DIR" >&2
exit 1 exit 1
fi fi
read -p "This will overwrite the copies of $FILES in $LLVM_DEMANGLE_DIR; are you sure? [y/N]" -n 1 -r ANSWER read -p "This will overwrite the copies of $FILES in $LLVM_DEMANGLE_DIR; are you sure? [y/N]" -n 1 -r ANSWER
echo echo
if [[ $ANSWER =~ ^[Yy]$ ]]; then if [[ $ANSWER =~ ^[Yy]$ ]]; then
cp -f README.txt $LLVM_DEMANGLE_DIR cp -f README.txt $LLVM_DEMANGLE_DIR
chmod -w $LLVM_DEMANGLE_DIR/README.txt chmod -w $LLVM_DEMANGLE_DIR/README.txt
for I in $HDRS ; do for I in $HDRS ; do
rm -f $LLVM_DEMANGLE_DIR/$I rm -f $LLVM_DEMANGLE_DIR/$I
dash=$(echo "$I---------------------------" | cut -c -27 |\ dash=$(echo "$I---------------------------" | cut -c -27 |\
sed 's|[^-]*||') sed 's|[^-]*||')
sed -e '1s|^//=*-* .*\.h -*.*=*// *$|//===--- '"$I $dash"'-*- mode:c++;eval:(read-only-mode) -*-===//|' \ sed -e '1s|^//=*-* .*\..* -*.*=*// *$|//===--- '"$I $dash"'-*- mode:c++;eval:(read-only-mode) -*-===//|' \
-e '2s|^// *$|// Do not edit! See README.txt.|' \ -e '2s|^// *$|// Do not edit! See README.txt.|' \
$I >$LLVM_DEMANGLE_DIR/$I $I >$LLVM_DEMANGLE_DIR/$I
chmod -w $LLVM_DEMANGLE_DIR/$I chmod -w $LLVM_DEMANGLE_DIR/$I
done done
fi fi

llvm/include/llvm/Demangle/ItaniumDemangle.h

Show All 22 Lines
#include <cassert> #include <cassert>
#include <cctype> #include <cctype>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#include <limits> #include <limits>
#include <utility> #include <utility>
#define FOR_EACH_NODE_KIND(X) \
X(NodeArrayNode) \
X(DotSuffix) \
X(VendorExtQualType) \
X(QualType) \
X(ConversionOperatorType) \
X(PostfixQualifiedType) \
X(ElaboratedTypeSpefType) \
X(NameType) \
X(AbiTagAttr) \
X(EnableIfAttr) \
X(ObjCProtoName) \
X(PointerType) \
X(ReferenceType) \
X(PointerToMemberType) \
X(ArrayType) \
X(FunctionType) \
X(NoexceptSpec) \
X(DynamicExceptionSpec) \
X(FunctionEncoding) \
X(LiteralOperator) \
X(SpecialName) \
X(CtorVtableSpecialName) \
X(QualifiedName) \
X(NestedName) \
X(LocalName) \
X(ModuleName) \
X(ModuleEntity) \
X(VectorType) \
X(PixelVectorType) \
X(BinaryFPType) \
X(SyntheticTemplateParamName) \
X(TypeTemplateParamDecl) \
X(NonTypeTemplateParamDecl) \
X(TemplateTemplateParamDecl) \
X(TemplateParamPackDecl) \
X(ParameterPack) \
X(TemplateArgumentPack) \
X(ParameterPackExpansion) \
X(TemplateArgs) \
X(ForwardTemplateReference) \
X(NameWithTemplateArgs) \
X(GlobalQualifiedName) \
X(ExpandedSpecialSubstitution) \
X(SpecialSubstitution) \
X(CtorDtorName) \
X(DtorName) \
X(UnnamedTypeName) \
X(ClosureTypeName) \
X(StructuredBindingName) \
X(BinaryExpr) \
X(ArraySubscriptExpr) \
X(PostfixExpr) \
X(ConditionalExpr) \
X(MemberExpr) \
X(SubobjectExpr) \
X(EnclosingExpr) \
X(CastExpr) \
X(SizeofParamPackExpr) \
X(CallExpr) \
X(NewExpr) \
X(DeleteExpr) \
X(PrefixExpr) \
X(FunctionParam) \
X(ConversionExpr) \
X(PointerToMemberConversionExpr) \
X(InitListExpr) \
X(FoldExpr) \
X(ThrowExpr) \
X(BoolExpr) \
X(StringLiteral) \
X(LambdaExpr) \
X(EnumLiteral) \
X(IntegerLiteral) \
X(FloatLiteral) \
X(DoubleLiteral) \
X(LongDoubleLiteral) \
X(BracedExpr) \
X(BracedRangeExpr)
DEMANGLE_NAMESPACE_BEGIN DEMANGLE_NAMESPACE_BEGIN
template <class T, size_t N> class PODSmallVector { template <class T, size_t N> class PODSmallVector {
static_assert(std::is_pod<T>::value, static_assert(std::is_pod<T>::value,
"T is required to be a plain old data type"); "T is required to be a plain old data type");
T *First = nullptr; T *First = nullptr;
T *Last = nullptr; T *Last = nullptr;
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Linespublic:
} }
}; };
// Base class of all AST nodes. The AST is built by the parser, then is // 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. // traversed by the printLeft/Right functions to produce a demangled string.
class Node { class Node {
public: public:
enum Kind : unsigned char { enum Kind : unsigned char {
#define ENUMERATOR(NodeKind) K ## NodeKind, #define NODE(NodeKind) K##NodeKind,
FOR_EACH_NODE_KIND(ENUMERATOR) #include "ItaniumNodes.def"
#undef ENUMERATOR
}; };
/// Three-way bool to track a cached value. Unknown is possible if this node /// 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. /// has an unexpanded parameter pack below it that may affect this cache.
enum class Cache : unsigned char { Yes, No, Unknown, }; enum class Cache : unsigned char { Yes, No, Unknown, };
/// Operator precedence for expression nodes. Used to determine required /// Operator precedence for expression nodes. Used to determine required
/// parens in expression emission. /// parens in expression emission.
▲ Show 20 Lines • Show All 2,186 Lines • ▼ Show 20 Lines
using DoubleLiteral = FloatLiteralImpl<double>; using DoubleLiteral = FloatLiteralImpl<double>;
using LongDoubleLiteral = FloatLiteralImpl<long double>; using LongDoubleLiteral = FloatLiteralImpl<long double>;
/// Visit the node. Calls \c F(P), where \c P is the node cast to the /// Visit the node. Calls \c F(P), where \c P is the node cast to the
/// appropriate derived class. /// appropriate derived class.
template<typename Fn> template<typename Fn>
void Node::visit(Fn F) const { void Node::visit(Fn F) const {
switch (K) { switch (K) {
#define CASE(X) case K ## X: return F(static_cast<const X*>(this)); #define NODE(X) \
FOR_EACH_NODE_KIND(CASE) case K##X: \
#undef CASE return F(static_cast<const X *>(this));
#include "ItaniumNodes.def"
} }
assert(0 && "unknown mangling node kind"); assert(0 && "unknown mangling node kind");
} }
/// Determine the kind of a node from its type. /// Determine the kind of a node from its type.
template<typename NodeT> struct NodeKind; template<typename NodeT> struct NodeKind;
#define SPECIALIZATION(X) \ #define NODE(X) \
template<> struct NodeKind<X> { \ template <> struct NodeKind<X> { \
static constexpr Node::Kind Kind = Node::K##X; \ static constexpr Node::Kind Kind = Node::K##X; \
static constexpr const char *name() { return #X; } \ static constexpr const char *name() { return #X; } \
}; };
FOR_EACH_NODE_KIND(SPECIALIZATION) #include "ItaniumNodes.def"
#undef SPECIALIZATION
#undef FOR_EACH_NODE_KIND
template <typename Derived, typename Alloc> struct AbstractManglingParser { template <typename Derived, typename Alloc> struct AbstractManglingParser {
const char *First; const char *First;
const char *Last; const char *Last;
// Name stack, this is used by the parser to hold temporary names that were // 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 // parsed. The parser collapses multiple names into new nodes to construct
// the AST. Once the parser is finished, names.size() == 1. // the AST. Once the parser is finished, names.size() == 1.
▲ Show 20 Lines • Show All 3,103 Lines • Show Last 20 Lines

llvm/include/llvm/Demangle/ItaniumNodes.def

  • This file was added.
//===--- ItaniumNodes.def ------------*- mode:c++;eval:(read-only-mode) -*-===//
// Do not edit! See README.txt.
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Define the demangler's node names
#ifndef NODE
#error Define NODE to handle nodes
#endif
NODE(NodeArrayNode)
NODE(DotSuffix)
NODE(VendorExtQualType)
NODE(QualType)
NODE(ConversionOperatorType)
NODE(PostfixQualifiedType)
NODE(ElaboratedTypeSpefType)
NODE(NameType)
NODE(AbiTagAttr)
NODE(EnableIfAttr)
NODE(ObjCProtoName)
NODE(PointerType)
NODE(ReferenceType)
NODE(PointerToMemberType)
NODE(ArrayType)
NODE(FunctionType)
NODE(NoexceptSpec)
NODE(DynamicExceptionSpec)
NODE(FunctionEncoding)
NODE(LiteralOperator)
NODE(SpecialName)
NODE(CtorVtableSpecialName)
NODE(QualifiedName)
NODE(NestedName)
NODE(LocalName)
NODE(ModuleName)
NODE(ModuleEntity)
NODE(VectorType)
NODE(PixelVectorType)
NODE(BinaryFPType)
NODE(SyntheticTemplateParamName)
NODE(TypeTemplateParamDecl)
NODE(NonTypeTemplateParamDecl)
NODE(TemplateTemplateParamDecl)
NODE(TemplateParamPackDecl)
NODE(ParameterPack)
NODE(TemplateArgumentPack)
NODE(ParameterPackExpansion)
NODE(TemplateArgs)
NODE(ForwardTemplateReference)
NODE(NameWithTemplateArgs)
NODE(GlobalQualifiedName)
NODE(ExpandedSpecialSubstitution)
NODE(SpecialSubstitution)
NODE(CtorDtorName)
NODE(DtorName)
NODE(UnnamedTypeName)
NODE(ClosureTypeName)
NODE(StructuredBindingName)
NODE(BinaryExpr)
NODE(ArraySubscriptExpr)
NODE(PostfixExpr)
NODE(ConditionalExpr)
NODE(MemberExpr)
NODE(SubobjectExpr)
NODE(EnclosingExpr)
NODE(CastExpr)
NODE(SizeofParamPackExpr)
NODE(CallExpr)
NODE(NewExpr)
NODE(DeleteExpr)
NODE(PrefixExpr)
NODE(FunctionParam)
NODE(ConversionExpr)
NODE(PointerToMemberConversionExpr)
NODE(InitListExpr)
NODE(FoldExpr)
NODE(ThrowExpr)
NODE(BoolExpr)
NODE(StringLiteral)
NODE(LambdaExpr)
NODE(EnumLiteral)
NODE(IntegerLiteral)
NODE(FloatLiteral)
NODE(DoubleLiteral)
NODE(LongDoubleLiteral)
NODE(BracedExpr)
NODE(BracedRangeExpr)
#undef NODE