//===---------------- client_reflection_impl.hpp ----------------===//
//
//    AUTO-GENERATED -- DO NOT EDIT THIS FILE DIRECTLY
//
//===----------------------------------------------===//
#ifndef CPPX_META_client_reflection_impl_HPP
#define CPPX_META_client_reflection_impl_HPP

#include <cstdint> //for intptr_t
#include <utility> //for std::move
#include <cassert>

#define PP_EXPAND(...) __VA_ARGS__
#define PP_UNCNDL_REMOVE_PARENS(x) PP_EXPAND x

#ifdef __CONSUMER_SUPPORTS_REFLECTION_AND_META__
#   define M_template       template
#   define M_tbeg           <
#   define M_rtpack(Zs)     intptr_t... Zs
#   define M_c              , 
#   define M_pack(Zs)       Zs...
#   define M_tend           >
#   define M_getPtrVal_T_value  refldetail::getPtrVal<T>::value
#   define IFMETA_ELSE(MP_compiler_version, MP_idehlpr_version/*ignored*/)\
      PP_UNCNDL_REMOVE_PARENS(MP_compiler_version)
    /// DWR HACK so we can get non-static fields (for accessing with . or ->
    /// syntax, instead of :: syntax); we were getting errors using decltype
    /// on the __reflect_prop/cast statements but this fixes it.
#   define M_REFLTYPED_FIELD(MP_name, MP_idehlpr_t/*ignored*/, .../*expr*/)\
      private: static constexpr auto S_ ## MP_name = __VA_ARGS__;\
      public: decltype(S_ ## MP_name) MP_name = S_ ## MP_name;
    /**/
#   define RANGECLASS_SIZE_AND_GET(RKname, ElemT/*unused*/)\
            static constexpr size_t _size_() {\
              return __reflect_range_size(reflenums::RK_ ## RKname, reflenums::RKname::_this_, Xs...);\
            }\
            template<size_t _N_>\
            static constexpr auto _get_() {\
              return __reflect_range_nth(reflenums::RK_ ## RKname, reflenums::RKname::_this_, Xs..., _N_);\
            }
    /**/
#   define DEF_RANGE_REFLECTION_TUPLE(MemName, MethodSig, ElemT/*unused*/, InitArgs, ParamArgs)\
        template<intptr_t... Xs>\
        struct MemName ## _tuple {\
            static constexpr size_t _size_() {\
              return __reflect_range_size(\
                PP_UNCNDL_REMOVE_PARENS(InitArgs) PP_UNCNDL_REMOVE_PARENS(ParamArgs) );\
            }\
            template<size_t _N_>\
            static constexpr auto _get_() {\
              return __reflect_range_nth(\
                PP_UNCNDL_REMOVE_PARENS(InitArgs), _N_ PP_UNCNDL_REMOVE_PARENS(ParamArgs) );\
            }\
        };\
    /**/
#   define RANGE_REFLECTION(ClassName, MemName, MethodSig, ElemT, InitArgs, ParamArgs)\
        MethodSig -> typename ClassName:: template MemName ## _tuple<Xs...> { return {}; }
    /**/
#else //just code-completing
#   define M_template         
#   define M_tbeg             
#   define M_rtpack(Zs)       
#   define M_c                
#   define M_pack(Zs)         
#   define M_tend             
#   define M_getPtrVal_T_value  true
#   define IFMETA_ELSE(MP_compiler_version/*ignored*/, MP_idehlpr_version)\
      PP_UNCNDL_REMOVE_PARENS(MP_idehlpr_version)
#   define M_REFLTYPED_FIELD(MP_name, MP_idehlpr_t, .../*ignored*/)\
      PP_UNCNDL_REMOVE_PARENS(MP_idehlpr_t) MP_name;
    /**/
#   define DUMMY_ITERATOR_BEGIN_END(...)\
      private:\
          struct iterator_t {\
              constexpr __VA_ARGS__ operator*() const;\
              constexpr iterator_t &operator++();\
              constexpr iterator_t operator++(int);\
              constexpr bool operator==(const iterator_t &other) const;\
              constexpr bool operator!=(const iterator_t &other) const;\
          };\
      public:\
          iterator_t begin() const;\
          iterator_t end() const;
    /**/
#   define RANGECLASS_SIZE_AND_GET(RKname, ...) DUMMY_ITERATOR_BEGIN_END(__VA_ARGS__)
#   define DEF_RANGE_REFLECTION_TUPLE(MemName, MethodSig, ElemT/*unused*/, InitArgs, ParamArgs)
#   define RANGE_REFLECTION(ClassName, MemName, MethodSig, ElemT, InitArgs, ParamArgs)\
    MethodSig {\
      class dummy_range {\
          DUMMY_ITERATOR_BEGIN_END(PP_UNCNDL_REMOVE_PARENS(ElemT))\
      };\
      return dummy_range();\
    }
#   define DONT_USE \
      static_assert(false && "Not intended to be used, just to aid the IDE with code completion. "\
                  "You must #define __CONSUMER_SUPPORTS_REFLECTION_AND_META__ during actual compilation to turn the real implem on.")


#endif // end of stuff used when not really __CONSUMER_SUPPORTS_REFLECTION_AND_META__; 
       // rather, just helping IDE with code completion

#define M_template_rtpack(Xs)    M_template M_tbeg M_rtpack(Xs) M_tend
#define M_targpack(Xs)           M_tbeg M_pack(Xs) M_tend


/////// CASTING SUPPORT /////////


// COPIED FROM llvm/Support/Compiler.h:
# define LLVM_NODISCARD [[nodiscard]]

namespace llvm {

// COPIED FROM llvm/Support/type_traits:

/// If T is a pointer, just return it. If it is not, return T&.
template<typename T, typename Enable = void>
struct add_lvalue_reference_if_not_pointer {
  using type = T &;
};

template<typename T>
struct add_lvalue_reference_if_not_pointer<
        T, typename std::enable_if<std::is_pointer<T>::value>::type> {
  using type = T;
};

/// If T is a pointer to X, return a pointer to const X. If it is not,
/// return const T.
template<typename T, typename Enable = void>
struct add_const_past_pointer {
  using type = const T;
};

template<typename T>
struct add_const_past_pointer<
        T, typename std::enable_if<std::is_pointer<T>::value>::type> {
  using type = const typename std::remove_pointer<T>::type *;
};

// FROM llvm/Support/Casting.h:

//===----------------------------------------------------------------------===//
//                          isa<x> Support Templates
//===----------------------------------------------------------------------===//

/// Define a template that can be specialized by smart pointers to reflect the
/// fact that they are automatically dereferenced, and are not involved with the
/// template selection process...  the default implementation is a noop.
template<typename From>
struct simplify_type {
  using SimpleType = From; // The real type this represents...

  // An accessor to get the real value...
  static constexpr SimpleType &getSimplifiedValue(From &Val) { return Val; }
};

template<typename From>
struct simplify_type<const From> {
  using NonConstSimpleType = typename simplify_type<From>::SimpleType;
  using SimpleType =
  typename add_const_past_pointer<NonConstSimpleType>::type;
  using RetType =
  typename add_lvalue_reference_if_not_pointer<SimpleType>::type;

  static constexpr RetType getSimplifiedValue(const From &Val) {
    return simplify_type<From>::getSimplifiedValue(const_cast<From &>(Val));
  }
};

template<class X>
struct is_simple_type {
  static const bool value =
          std::is_same<X, typename simplify_type<X>::SimpleType>::value;
};

// The core of the implementation of isa<X> is here; To and From should be
// the names of classes.  This template can be specialized to customize the
// implementation of isa<> without rewriting it from scratch.
template<typename To, typename From, typename Enabler = void>
struct isa_impl {
  static constexpr bool doit(const From &Val) {
    return To::classof(&Val);
    // ^ NB: every castable reflection type needs a
    // static bool classof(...) member function reflected!
  }
};

/// Always allow upcasts, and perform no dynamic check for them.
template<typename To, typename From>
struct isa_impl<
        To, From, typename std::enable_if<std::is_base_of<To, From>::value>::type> {
  static constexpr bool doit(const From &) { return true; }
};

template<typename To, typename From>
struct isa_impl_cl {
  static constexpr bool doit(const From &Val) {
    return isa_impl<To, From>::doit(Val);
  }
};

template<typename To, typename From>
struct isa_impl_cl<To, const From> {
  static constexpr bool doit(const From &Val) {
    return isa_impl<To, From>::doit(Val);
  }
};


template<typename To, typename From>
struct isa_impl_cl<To, From *> {
  static constexpr bool doit(const From *Val) {
    assert(Val && "isa<> used on a null pointer");
    return isa_impl<To, From>::doit(*Val);
  }
};

template<typename To, typename From>
struct isa_impl_cl<To, From *const> {
  static constexpr bool doit(const From *Val) {
    assert(Val && "isa<> used on a null pointer");
    return isa_impl<To, From>::doit(*Val);
  }
};

template<typename To, typename From>
struct isa_impl_cl<To, const From *> {
  static constexpr bool doit(const From *Val) {
    assert(Val && "isa<> used on a null pointer");
    return isa_impl<To, From>::doit(*Val);
  }
};

template<typename To, typename From>
struct isa_impl_cl<To, const From *const> {
  static constexpr bool doit(const From *Val) {
    assert(Val && "isa<> used on a null pointer");
    return isa_impl<To, From>::doit(*Val);
  }
};

template<typename To, typename From, typename SimpleFrom>
struct isa_impl_wrap {
  // When From != SimplifiedType, we can simplify the type some more by using
  // the simplify_type template.
  static constexpr bool doit(const From &Val) {
    return isa_impl_wrap<To, SimpleFrom,
            typename simplify_type<SimpleFrom>::SimpleType>::doit(
            simplify_type<const From>::getSimplifiedValue(Val));
  }
};

template<typename To, typename FromTy>
struct isa_impl_wrap<To, FromTy, FromTy> {
  // When From == SimpleType, we are as simple as we are going to get.
  static constexpr bool doit(const FromTy &Val) {
    return isa_impl_cl<To, FromTy>::doit(Val);
  }
};

/// isa<X> - Return true if the parameter to the template is an instance of the
/// template type argument.  Used like this:
///
///  if (isa<Type>(myVal)) { ... }
///
template <class X, class Y> LLVM_NODISCARD constexpr bool isa(const Y &Val) {
  return isa_impl_wrap<X, const Y,
          typename simplify_type<const Y>::SimpleType>::doit(Val);
}

} // end namespace llvm




namespace cppx {

namespace meta {


namespace refldetail {

/// A number generated while building the version of Clang
/// which this reflection info was generated.  Reflection will
/// not be permitted unless this number matches that of the 
/// compiler.
static const unsigned __reflheaderid__ = 9271;


template<typename T> struct ptrwrp;
template<typename T> struct getPtrVal;

template< template<intptr_t...> class TMPL
        , intptr_t PtrVal >
struct getPtrVal<TMPL</*IsPtr=*/1, PtrVal>> {
  static constexpr intptr_t value = PtrVal;
};

template<typename T>
struct getPtrVal<ptrwrp<T>> {
  static constexpr intptr_t value = getPtrVal<T>::value;
};


/// ptrwrp_to_ptrs: helps us implement get() in ptrwrp so that
/// it removes all ptrwrp wrappings, replacing them with pointers.
/// e.g. ptrwrp_full_unwrp(ptrwrp<ptrwrp<A>> obj) returns obj of
/// type A**. We need this to permit proper derived->base conversions
/// for accessing proper function overloads from ptrwrp param types.
template<typename T>
constexpr auto ptrwrp_to_ptrs(ptrwrp<T> t) {
  return ptrwrp_full_get(t.get());
}
template<typename T>
constexpr auto ptrwrp_to_ptrs(const ptrwrp<T> *t) {
  return &ptrwrp_full_get(t->get());
}
template<typename T>
constexpr auto ptrwrp_to_ptrs(ptrwrp<T> *t) {
  return &ptrwrp_full_get(t->get());
}
template<typename T>
constexpr auto ptrwrp_to_ptrs(const T *t) {
  return t;
}
template<typename T>
constexpr auto ptrwrp_to_ptrs(T *t) {
  return t;
}

/// e.g.:
/// FunctionDecl*  <=>  ptrwrp<FunctionDecl::impl<Xs...>>
template<typename T>
class ptrwrp {
  T t;
public:
  constexpr T operator*() const noexcept { return t; }
    //^NB no need for ref return; reflection T behaves like a ref naturally
  constexpr const T * operator->() const noexcept { return &t; }
  constexpr T * operator->() noexcept { return &t; }
  constexpr auto get() const { return ptrwrp_to_ptrs(&t); }
  constexpr operator bool() const {
    return M_getPtrVal_T_value;
  }
  constexpr operator intptr_t() const {//TODO explicit perhaps
    return M_getPtrVal_T_value;
  }
  constexpr ptrwrp(T t = {}) : t(t) {}
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::ptrwrp(", (const char *)t, ")");
  }) , ( { return ""; } ) )
};
//Deduction guide: used by operator const char*() above:
IFMETA_ELSE( (template<typename T> ptrwrp(T t) -> ptrwrp<T>;), () )

} //namespace refldetail

#ifdef __CONSUMER_SUPPORTS_REFLECTION_AND_META__
  /// isa<X> - Return true if the parameter to the template is an instance of the
  /// template type argument.  Used like this:
  ///
  ///  if (isa<Tmpl>(myVal)) { ... }
  ///
  template< template<intptr_t...> class To
          , template<intptr_t...> class From
          , intptr_t... Xs >
  LLVM_NODISCARD constexpr bool isa(refldetail::ptrwrp<From<Xs...>> Val) {
    return ::llvm::isa<To<Xs...>>(Val.get());
  }

  /// cast<To> - Return the argument parameter cast to the specified type.  This
  /// casting operator asserts that the type is correct, so it does not return null
  /// on failure.  It does not allow a null argument (use cast_or_null for that).
  /// It is typically used like this:
  ///
  ///  cast<CXXRecordDecl>(myReflDecl)->bases()
  ///
  /// Note that cast may change the pointer value due to alignment issues --
  /// rather than messing around with that here we let clang handle it
  /// via __reflect_cast with an auto return type.
  template< template<intptr_t...> class To
          , template<intptr_t...> class From
          , intptr_t X >
  constexpr auto cast(const refldetail::ptrwrp<From</*IsPtr=*/1, X>> &Val) {
    return __reflect_cast(From<1,0>::ReflObjKind, To<1,0>::ReflObjKind, /*dyn=*/0, X);
  }

  /// Special case: for a non-ptrwrp argument (usually a non-pointer),
  /// just do a traditional slice if its possible.
  template< template<intptr_t...> class To
          , template<intptr_t...> class From
          , intptr_t... Xs >
  constexpr To<Xs...> cast(const From<Xs...> &Val) {
    static_assert(std::is_base_of<To<Xs...>, From<Xs...>>::value,
                  "Invalid reflection slice");
    return Val;
  }

  /// dyn_cast<To> -
  /// Return the argument parameter cast to the specified type.  This
  /// casting operator returns null if the argument is of the wrong type, so it can
  /// be used to test for a type as well as cast if successful.  This should be
  /// used in the context of an if statement like this:
  ///
  ///  if (auto RD = dyn_cast<CXXRecordDecl>(myReflectedDecl)) { ... }
  ///
  template< template<intptr_t...> class To
          , template<intptr_t...> class From
          , intptr_t X >
  constexpr auto dyn_cast(const refldetail::ptrwrp<From</*IsPtr=*/1, X>> &Val) {
    return __reflect_cast(From<1,0>::ReflObjKind, To<1,0>::ReflObjKind, /*dyn=*/1, X);
  }

#else
  template<typename To, typename From>
  constexpr bool isa(const From *from) { return true; }
  template<typename To, typename From>
  constexpr const To *cast(const From *from) { return (const To *)0; }
  template<typename To, typename From>
  constexpr const To *dyn_cast(const From *from) { return cast<To>(from); }
  
  //Non-const overloads (only needed to help IDE):
  template<typename To, typename From>
  constexpr To *cast(From *from) { return (To *)0; }
  template<typename To, typename From>
  constexpr refldetail::ptrwrp<To> cast(refldetail::ptrwrp<From> from) { return {}; }
  template<typename To, typename From>
  constexpr To cast(From from) { return from; }
  template<typename To, typename From>
  constexpr To *dyn_cast(From *from) { return cast<To>(from); }
  template<typename To, typename From>
  constexpr refldetail::ptrwrp<To> dyn_cast(refldetail::ptrwrp<From> from) { return cast<To>(from); }

  /// We define reflexpr(x) as a macro for non-meta-supporters, that returns
  /// a pointer to a dummy type instructing the user to properly cast it.
  /// Note that it doens't matter that this dummy type isn't related to the
  /// the types we cast to, as our dummy cast implems above don't do any actual
  /// casting; their goal here is to just helping the IDE navigate the types,
  /// without resorting to casting nullptrs (which raises other errors).
# define reflexpr(...)  (&cppx::meta::DfltNonnullObj<cppx::meta::_RememberToManuallyCastReflexprForNow_>)

  /// Cast this to whatever makes sense in the context; e.g. `cast<CXXRecordDecl>(reflexpr(SomeClass))`.
  /// Not necessary to compile, but definitely a good practice to help the IDE help you.
  /// We return a base Decl by default, since that's usually what you reflect,
  /// but sometimes a reflection will return a type;
  /// e.g. `template<typename T> MyMetaCls { auto proto_t_refl = reflexpr(T); };
  /// In such cases it's even more important to cast the reflexpr to avoid user confusion.
  struct _RememberToManuallyCastReflexprForNow_ {
    constexpr _RememberToManuallyCastReflexprForNow_() {}
  };
  template<typename T> T DfltNonnullObj;


  // While we're here let's also define __concatenate and __metaparse_expr for non-supporters:
# define __concatenate(...) ""
# define __metaparse_expr(expr, /**type*/...) (__VA_ARGS__)0

#endif

/// Turns a parameter pack of integers into a string literal, each int separated by a comma.
/// Needed to define the operator const char*()'s for each reflection type.
template<intptr_t... Xs>
struct concat_ints_w_commas;

template<intptr_t X, intptr_t... Xs>
struct concat_ints_w_commas<X, Xs...> {
  static constexpr const char *value = __concatenate(X, ",", concat_ints_w_commas<Xs...>::value);
};

template<intptr_t X>
struct concat_ints_w_commas<X> {
  static constexpr const char *value = __concatenate(X); //need __concatenate to turn the int into a string
};
namespace reflenums {

enum ReflectionObjKind {
  RK_none = 0,
  RK_llvm__APInt,
  RK_llvm__APInt__ms,
  RK_llvm__APInt__mu,
  RK_llvm__APFloatBase,
  RK_llvm__APFloat,
  RK_llvm__APSInt,
  RK_clang__APValue,
  RK_clang__APValue__LValueBase,
  RK_clang__DiagnosticOptions,
  RK_clang__FileID,
  RK_clang__SourceLocation,
  RK_clang__SourceRange,
  RK_clang__CharSourceRange,
  RK_clang__PresumedLoc,
  RK_clang__FullSourceLoc,
  RK_llvm__DebugEpochBase,
  RK_clang__FixItHint,
  RK_clang__DiagnosticsEngine,
  RK_clang__DiagnosticBuilder,
  RK_clang__DiagnosticConsumer,
  RK_clang__IdentifierInfo,
  RK_clang__IdentifierInfoLookup,
  RK_clang__IdentifierTable,
  RK_clang__Selector,
  RK_clang__SelectorTable,
  RK_clang__PartialDiagnostic,
  RK_clang__DeclarationName,
  RK_clang__DeclarationNameLoc,
  RK_clang__DeclarationNameInfo,
  RK_llvm__raw_ostream,
  RK_llvm__VersionTuple,
  RK_clang__Decl,
  RK_clang__DeclContextLookupResult,
  RK_clang__DeclContext,
  RK_clang__CharUnits,
  RK_clang__FileSystemOptions,
  RK_llvm__Twine,
  RK_llvm__sys__fs__UniqueID,
  RK_llvm__MemoryBuffer,
  RK_llvm__MemoryBufferRef,
  RK_clang__DirectoryEntry,
  RK_clang__FileEntry,
  RK_clang__FileManager,
  RK_clang__ASTFileSignature,
  RK_clang__Module,
  RK_clang__Module__Header,
  RK_clang__Module__DirectoryName,
  RK_clang__ExternalASTSource,
  RK_clang__ExternalASTSource__MemoryBufferSizes,
  RK_llvm__FoldingSetBase,
  RK_llvm__FoldingSetBase__Node,
  RK_llvm__FoldingSetNodeIDRef,
  RK_llvm__FoldingSetNodeID,
  RK_clang__NestedNameSpecifier,
  RK_clang__NestedNameSpecifierLoc,
  RK_clang__UncommonTemplateNameStorage,
  RK_clang__OverloadedTemplateStorage,
  RK_clang__SubstTemplateTemplateParmPackStorage,
  RK_clang__TemplateName,
  RK_clang__SubstTemplateTemplateParmStorage,
  RK_clang__QualifiedTemplateName,
  RK_clang__DependentTemplateName,
  RK_clang__LinkageInfo,
  RK_clang__Qualifiers,
  RK_clang__SplitQualType,
  RK_clang__QualType,
  RK_clang__ExtQualsTypeCommonBase,
  RK_clang__Type,
  RK_clang__BuiltinType,
  RK_clang__ComplexType,
  RK_clang__ParenType,
  RK_clang__PointerType,
  RK_clang__AdjustedType,
  RK_clang__DecayedType,
  RK_clang__BlockPointerType,
  RK_clang__ReferenceType,
  RK_clang__LValueReferenceType,
  RK_clang__RValueReferenceType,
  RK_clang__MemberPointerType,
  RK_clang__ArrayType,
  RK_clang__ConstantArrayType,
  RK_clang__IncompleteArrayType,
  RK_clang__VariableArrayType,
  RK_clang__DependentSizedArrayType,
  RK_clang__DependentAddressSpaceType,
  RK_clang__DependentSizedExtVectorType,
  RK_clang__VectorType,
  RK_clang__DependentVectorType,
  RK_clang__ExtVectorType,
  RK_clang__FunctionType,
  RK_clang__FunctionType__ExtInfo,
  RK_clang__FunctionNoProtoType,
  RK_clang__FunctionProtoType,
  RK_clang__FunctionProtoType__ExtParameterInfo,
  RK_clang__FunctionProtoType__ExceptionSpecInfo,
  RK_clang__FunctionProtoType__ExtProtoInfo,
  RK_clang__UnresolvedUsingType,
  RK_clang__TypedefType,
  RK_clang__TypeOfExprType,
  RK_clang__TypeOfType,
  RK_clang__DecltypeType,
  RK_clang__ReflectedType,
  RK_clang__UnaryTransformType,
  RK_clang__TagType,
  RK_clang__RecordType,
  RK_clang__EnumType,
  RK_clang__AttributedType,
  RK_clang__TemplateTypeParmType,
  RK_clang__SubstTemplateTypeParmType,
  RK_clang__SubstTemplateTypeParmPackType,
  RK_clang__DeducedType,
  RK_clang__AutoType,
  RK_clang__DeducedTemplateSpecializationType,
  RK_clang__TemplateSpecializationType,
  RK_clang__InjectedClassNameType,
  RK_clang__TypeWithKeyword,
  RK_clang__ElaboratedType,
  RK_clang__DependentNameType,
  RK_clang__DependentTemplateSpecializationType,
  RK_clang__PackExpansionType,
  RK_clang__ObjCTypeParamType,
  RK_clang__ObjCObjectType,
  RK_clang__ObjCInterfaceType,
  RK_clang__ObjCObjectPointerType,
  RK_clang__AtomicType,
  RK_clang__PipeType,
  RK_clang__TypeSourceInfo,
  RK_clang__TranslationUnitDecl,
  RK_clang__PragmaCommentDecl,
  RK_clang__PragmaDetectMismatchDecl,
  RK_clang__ExternCContextDecl,
  RK_clang__NamedDecl,
  RK_clang__LabelDecl,
  RK_clang__NamespaceDecl,
  RK_clang__ValueDecl,
  RK_clang__DeclaratorDecl,
  RK_clang__EvaluatedStmt,
  RK_clang__VarDecl,
  RK_clang__ImplicitParamDecl,
  RK_clang__ParmVarDecl,
  RK_clang__FunctionDecl,
  RK_clang__FieldDecl,
  RK_clang__EnumConstantDecl,
  RK_clang__IndirectFieldDecl,
  RK_clang__TypeDecl,
  RK_clang__TypedefNameDecl,
  RK_clang__TypedefDecl,
  RK_clang__TypeAliasDecl,
  RK_clang__TagDecl,
  RK_clang__EnumDecl,
  RK_clang__RecordDecl,
  RK_clang__FileScopeAsmDecl,
  RK_clang__BlockDecl,
  RK_clang__BlockDecl__Capture,
  RK_clang__CapturedDecl,
  RK_clang__ImportDecl,
  RK_clang__ExportDecl,
  RK_clang__EmptyDecl,
  RK_clang__DeclGroup,
  RK_clang__DeclGroupRef,
  RK_clang__Stmt,
  RK_clang__Stmt__EmptyShell,
  RK_clang__DeclStmt,
  RK_clang__NullStmt,
  RK_clang__CompoundStmt,
  RK_clang__SwitchCase,
  RK_clang__CaseStmt,
  RK_clang__DefaultStmt,
  RK_clang__LabelStmt,
  RK_clang__AttributedStmt,
  RK_clang__IfStmt,
  RK_clang__SwitchStmt,
  RK_clang__WhileStmt,
  RK_clang__DoStmt,
  RK_clang__ForStmt,
  RK_clang__GotoStmt,
  RK_clang__IndirectGotoStmt,
  RK_clang__ContinueStmt,
  RK_clang__BreakStmt,
  RK_clang__ReturnStmt,
  RK_clang__AsmStmt,
  RK_clang__GCCAsmStmt,
  RK_clang__MSAsmStmt,
  RK_clang__SEHExceptStmt,
  RK_clang__SEHFinallyStmt,
  RK_clang__SEHTryStmt,
  RK_clang__SEHLeaveStmt,
  RK_clang__CapturedStmt,
  RK_clang__CapturedStmt__Capture,
  RK_clang__TemplateArgument,
  RK_clang__TemplateArgumentLocInfo,
  RK_clang__TemplateArgumentLoc,
  RK_clang__TemplateArgumentListInfo,
  RK_clang__ASTTemplateArgumentListInfo,
  RK_clang__TypeLoc,
  RK_clang__UnqualTypeLoc,
  RK_clang__CommentOptions,
  RK_clang__comments__CommandInfo,
  RK_clang__comments__CommandTraits,
  RK_llvm__Triple,
  RK_clang__ObjCRuntime,
  RK_clang__SanitizerSet,
  RK_clang__LangOptionsBase,
  RK_clang__LangOptions,
  RK_clang__FPOptions,
  RK_clang__PrinterHelper,
  RK_clang__PrintingPolicy,
  RK_clang__SrcMgr__ContentCache,
  RK_clang__SrcMgr__FileInfo,
  RK_clang__SrcMgr__ExpansionInfo,
  RK_clang__SrcMgr__SLocEntry,
  RK_clang__SourceManager,
  RK_clang__RawComment,
  RK_clang__SanitizerBlacklist,
  RK_clang__TargetCXXABI,
  RK_clang__OpenCLOptions,
  RK_clang__TargetOptions,
  RK_llvm__Type,
  RK_llvm__IntegerType,
  RK_llvm__CompositeType,
  RK_llvm__StructType,
  RK_llvm__PointerType,
  RK_llvm__DataLayout,
  RK_llvm__StructLayout,
  RK_clang__TargetInfo,
  RK_clang__TargetInfo__ConstraintInfo,
  RK_clang__XRayFunctionFilter,
  RK_clang__TypeInfo,
  RK_clang__ASTContext,
  RK_clang__DeclAccessPair,
  RK_clang__UnresolvedSetIterator,
  RK_clang__UnresolvedSetImpl,
  RK_clang__Expr,
  RK_clang__Expr__Classification,
  RK_clang__Expr__EvalStatus,
  RK_clang__Expr__EvalResult,
  RK_clang__OpaqueValueExpr,
  RK_clang__DeclRefExpr,
  RK_clang__PredefinedExpr,
  RK_clang__APIntStorage,
  RK_clang__IntegerLiteral,
  RK_clang__FixedPointLiteral,
  RK_clang__CharacterLiteral,
  RK_clang__FloatingLiteral,
  RK_clang__ImaginaryLiteral,
  RK_clang__StringLiteral,
  RK_clang__ParenExpr,
  RK_clang__UnaryOperator,
  RK_clang__OffsetOfNode,
  RK_clang__OffsetOfExpr,
  RK_clang__UnaryExprOrTypeTraitExpr,
  RK_clang__ArraySubscriptExpr,
  RK_clang__CallExpr,
  RK_clang__MemberExpr,
  RK_clang__CompoundLiteralExpr,
  RK_clang__CastExpr,
  RK_clang__ImplicitCastExpr,
  RK_clang__ExplicitCastExpr,
  RK_clang__CStyleCastExpr,
  RK_clang__BinaryOperator,
  RK_clang__CompoundAssignOperator,
  RK_clang__AbstractConditionalOperator,
  RK_clang__ConditionalOperator,
  RK_clang__BinaryConditionalOperator,
  RK_clang__AddrLabelExpr,
  RK_clang__StmtExpr,
  RK_clang__ShuffleVectorExpr,
  RK_clang__ConvertVectorExpr,
  RK_clang__ChooseExpr,
  RK_clang__GNUNullExpr,
  RK_clang__VAArgExpr,
  RK_clang__InitListExpr,
  RK_clang__DesignatedInitExpr,
  RK_clang__DesignatedInitExpr__Designator,
  RK_clang__NoInitExpr,
  RK_clang__DesignatedInitUpdateExpr,
  RK_clang__ArrayInitLoopExpr,
  RK_clang__ArrayInitIndexExpr,
  RK_clang__ImplicitValueInitExpr,
  RK_clang__ParenListExpr,
  RK_clang__GenericSelectionExpr,
  RK_clang__ExtVectorElementExpr,
  RK_clang__BlockExpr,
  RK_clang__AsTypeExpr,
  RK_clang__PseudoObjectExpr,
  RK_clang__AtomicExpr,
  RK_clang__TypoExpr,
  RK_clang__Attr,
  RK_clang__InheritableAttr,
  RK_clang__ExternalSourceSymbolAttr,
  RK_clang__MSInheritanceAttr,
  RK_clang__MSVtorDispAttr,
  RK_clang__LambdaCapture,
  RK_clang__AccessSpecDecl,
  RK_clang__CXXBaseSpecifier,
  RK_clang__CXXRecordDecl,
  RK_clang__CXXDeductionGuideDecl,
  RK_clang__CXXMethodDecl,
  RK_clang__CXXCtorInitializer,
  RK_clang__InheritedConstructor,
  RK_clang__CXXConstructorDecl,
  RK_clang__CXXDestructorDecl,
  RK_clang__CXXConversionDecl,
  RK_clang__LinkageSpecDecl,
  RK_clang__UsingDirectiveDecl,
  RK_clang__NamespaceAliasDecl,
  RK_clang__UsingShadowDecl,
  RK_clang__ConstructorUsingShadowDecl,
  RK_clang__UsingDecl,
  RK_clang__UsingPackDecl,
  RK_clang__UnresolvedUsingValueDecl,
  RK_clang__UnresolvedUsingTypenameDecl,
  RK_clang__StaticAssertDecl,
  RK_clang__BindingDecl,
  RK_clang__DecompositionDecl,
  RK_clang__MSPropertyDecl,
  RK_clang__ConstexprDecl,
  RK_clang__TemplateParameterList,
  RK_clang__TemplateArgumentList,
  RK_clang__TemplateDecl,
  RK_clang__FunctionTemplateSpecializationInfo,
  RK_clang__MemberSpecializationInfo,
  RK_clang__DependentFunctionTemplateSpecializationInfo,
  RK_clang__RedeclarableTemplateDecl,
  RK_clang__FunctionTemplateDecl,
  RK_clang__TemplateTypeParmDecl,
  RK_clang__NonTypeTemplateParmDecl,
  RK_clang__TemplateTemplateParmDecl,
  RK_clang__BuiltinTemplateDecl,
  RK_clang__ClassTemplateSpecializationDecl,
  RK_clang__ClassTemplatePartialSpecializationDecl,
  RK_clang__ClassTemplateDecl,
  RK_clang__FriendTemplateDecl,
  RK_clang__TypeAliasTemplateDecl,
  RK_clang__ClassScopeFunctionSpecializationDecl,
  RK_clang__VarTemplateSpecializationDecl,
  RK_clang__VarTemplatePartialSpecializationDecl,
  RK_clang__VarTemplateDecl,
  RK_clang__FriendDecl,
  RK_clang__ObjCListBase,
  RK_clang__ObjCProtocolList,
  RK_clang__ObjCMethodDecl,
  RK_clang__ObjCTypeParamDecl,
  RK_clang__ObjCTypeParamList,
  RK_clang__ObjCPropertyDecl,
  RK_clang__ObjCContainerDecl,
  RK_clang__ObjCInterfaceDecl,
  RK_clang__ObjCIvarDecl,
  RK_clang__ObjCAtDefsFieldDecl,
  RK_clang__ObjCProtocolDecl,
  RK_clang__ObjCCategoryDecl,
  RK_clang__ObjCImplDecl,
  RK_clang__ObjCCategoryImplDecl,
  RK_clang__ObjCImplementationDecl,
  RK_clang__ObjCCompatibleAliasDecl,
  RK_clang__ObjCPropertyImplDecl,
  RK_clang__OMPThreadPrivateDecl,
  RK_clang__OMPDeclareReductionDecl,
  RK_clang__OMPCapturedExprDecl,
  RK_clang__CXXOperatorCallExpr,
  RK_clang__CXXMemberCallExpr,
  RK_clang__CUDAKernelCallExpr,
  RK_clang__CXXNamedCastExpr,
  RK_clang__CXXStaticCastExpr,
  RK_clang__CXXDynamicCastExpr,
  RK_clang__CXXReinterpretCastExpr,
  RK_clang__CXXConstCastExpr,
  RK_clang__UserDefinedLiteral,
  RK_clang__CXXBoolLiteralExpr,
  RK_clang__CXXNullPtrLiteralExpr,
  RK_clang__CXXStdInitializerListExpr,
  RK_clang__CXXTypeidExpr,
  RK_clang__MSPropertyRefExpr,
  RK_clang__MSPropertySubscriptExpr,
  RK_clang__CXXUuidofExpr,
  RK_clang__CXXThisExpr,
  RK_clang__CXXThrowExpr,
  RK_clang__CXXDefaultArgExpr,
  RK_clang__CXXDefaultInitExpr,
  RK_clang__CXXTemporary,
  RK_clang__CXXBindTemporaryExpr,
  RK_clang__CXXConstructExpr,
  RK_clang__CXXInheritedCtorInitExpr,
  RK_clang__CXXFunctionalCastExpr,
  RK_clang__CXXTemporaryObjectExpr,
  RK_clang__LambdaExpr,
  RK_clang__CXXScalarValueInitExpr,
  RK_clang__CXXNewExpr,
  RK_clang__CXXDeleteExpr,
  RK_clang__CXXPseudoDestructorExpr,
  RK_clang__TypeTraitExpr,
  RK_clang__ArrayTypeTraitExpr,
  RK_clang__ExpressionTraitExpr,
  RK_clang__OverloadExpr,
  RK_clang__OverloadExpr__FindResult,
  RK_clang__UnresolvedLookupExpr,
  RK_clang__DependentScopeDeclRefExpr,
  RK_clang__ExprWithCleanups,
  RK_clang__CXXUnresolvedConstructExpr,
  RK_clang__CXXDependentScopeMemberExpr,
  RK_clang__UnresolvedMemberExpr,
  RK_clang__CXXNoexceptExpr,
  RK_clang__PackExpansionExpr,
  RK_clang__SizeOfPackExpr,
  RK_clang__SubstNonTypeTemplateParmExpr,
  RK_clang__SubstNonTypeTemplateParmPackExpr,
  RK_clang__FunctionParmPackExpr,
  RK_clang__MaterializeTemporaryExpr,
  RK_clang__CXXFoldExpr,
  RK_clang__CoroutineSuspendExpr,
  RK_clang__CoawaitExpr,
  RK_clang__DependentCoawaitExpr,
  RK_clang__CoyieldExpr,
  RK_clang__ReflectionExpr,
  RK_clang__CompilerMessageExpr,
  RK_clang__CompilerDiagnosticExpr,
  RK_clang__CXXMetaparseExpr,
  RK_clang__ReflectionTraitExpr,
  RK_clang__ReflectNewExpr,
  RK_clang__ReflectDeleteExpr,
  RK_clang__CXXConstantExpr,
  RK_clang__CXXDependentIdExpr,
  RK_clang__CXXConcatenateExpr,
  RK_clang__ObjCStringLiteral,
  RK_clang__ObjCBoolLiteralExpr,
  RK_clang__ObjCBoxedExpr,
  RK_clang__ObjCArrayLiteral,
  RK_clang__ObjCDictionaryElement,
  RK_clang__ObjCDictionaryLiteral,
  RK_clang__ObjCEncodeExpr,
  RK_clang__ObjCSelectorExpr,
  RK_clang__ObjCProtocolExpr,
  RK_clang__ObjCIvarRefExpr,
  RK_clang__ObjCPropertyRefExpr,
  RK_clang__ObjCSubscriptRefExpr,
  RK_clang__ObjCMessageExpr,
  RK_clang__ObjCIsaExpr,
  RK_clang__ObjCIndirectCopyRestoreExpr,
  RK_clang__ObjCBridgedCastExpr,
  RK_clang__ObjCAvailabilityCheckExpr,
  RK_clang__OMPArraySectionExpr,
  RK_clang__CXXCatchStmt,
  RK_clang__CXXTryStmt,
  RK_clang__CXXForRangeStmt,
  RK_clang__CXXExpansionStmt,
  RK_clang__CXXTupleExpansionStmt,
  RK_clang__CXXPackExpansionStmt,
  RK_clang__MSDependentExistsStmt,
  RK_clang__CoroutineBodyStmt,
  RK_clang__CoroutineBodyStmt__CtorArgs,
  RK_clang__CoreturnStmt,
  RK_clang__CXXQueueMetaparseStmt,
  RK_clang__ObjCForCollectionStmt,
  RK_clang__ObjCAtCatchStmt,
  RK_clang__ObjCAtFinallyStmt,
  RK_clang__ObjCAtTryStmt,
  RK_clang__ObjCAtSynchronizedStmt,
  RK_clang__ObjCAtThrowStmt,
  RK_clang__ObjCAutoreleasePoolStmt,
  RK_clang__OMPClause,
  RK_clang__OMPExecutableDirective,
  RK_clang__OMPParallelDirective,
  RK_clang__OMPLoopDirective,
  RK_clang__OMPSimdDirective,
  RK_clang__OMPForDirective,
  RK_clang__OMPForSimdDirective,
  RK_clang__OMPSectionsDirective,
  RK_clang__OMPSectionDirective,
  RK_clang__OMPSingleDirective,
  RK_clang__OMPMasterDirective,
  RK_clang__OMPCriticalDirective,
  RK_clang__OMPParallelForDirective,
  RK_clang__OMPParallelForSimdDirective,
  RK_clang__OMPParallelSectionsDirective,
  RK_clang__OMPTaskDirective,
  RK_clang__OMPTaskyieldDirective,
  RK_clang__OMPBarrierDirective,
  RK_clang__OMPTaskwaitDirective,
  RK_clang__OMPTaskgroupDirective,
  RK_clang__OMPFlushDirective,
  RK_clang__OMPOrderedDirective,
  RK_clang__OMPAtomicDirective,
  RK_clang__OMPTargetDirective,
  RK_clang__OMPTargetDataDirective,
  RK_clang__OMPTargetEnterDataDirective,
  RK_clang__OMPTargetExitDataDirective,
  RK_clang__OMPTargetParallelDirective,
  RK_clang__OMPTargetParallelForDirective,
  RK_clang__OMPTeamsDirective,
  RK_clang__OMPCancellationPointDirective,
  RK_clang__OMPCancelDirective,
  RK_clang__OMPTaskLoopDirective,
  RK_clang__OMPTaskLoopSimdDirective,
  RK_clang__OMPDistributeDirective,
  RK_clang__OMPTargetUpdateDirective,
  RK_clang__OMPDistributeParallelForDirective,
  RK_clang__OMPDistributeParallelForSimdDirective,
  RK_clang__OMPDistributeSimdDirective,
  RK_clang__OMPTargetParallelForSimdDirective,
  RK_clang__OMPTargetSimdDirective,
  RK_clang__OMPTeamsDistributeDirective,
  RK_clang__OMPTeamsDistributeSimdDirective,
  RK_clang__OMPTeamsDistributeParallelForSimdDirective,
  RK_clang__OMPTeamsDistributeParallelForDirective,
  RK_clang__OMPTargetTeamsDirective,
  RK_clang__OMPTargetTeamsDistributeDirective,
  RK_clang__OMPTargetTeamsDistributeParallelForDirective,
  RK_clang__OMPTargetTeamsDistributeParallelForSimdDirective,
  RK_clang__OMPTargetTeamsDistributeSimdDirective,
  RK_clang__StoredDeclsMap,
  RK_clang__DependentDiagnostic,
  RK_reflcontainers__VectorStr,
  RK_reflcontainers__VectorInt,
  RK_reflcontainers__SetInt,
  RK_reflcontainers__SetStr,
  RK_reflcontainers__IntIntPair,
  RK_reflcontainers__IntStrPair,
  RK_reflcontainers__StrIntPair,
  RK_reflcontainers__StrStrPair,
  RK_reflcontainers__MapIntStr,
  RK_reflcontainers__MapStrInt,
  RK_reflcontainers__MapStrStr,
  RK_reflcontainers__MapIntInt,
}; //enum ReflectionObjKind


  namespace llvm__APInt {
    enum memnames {
      needsCleanup,
      Profile,
      isNegative,
      isNonNegative,
      isSignBitSet,
      isSignBitClear,
      isStrictlyPositive,
      isAllOnesValue,
      isNullValue,
      isOneValue,
      isMaxValue,
      isMaxSignedValue,
      isMinValue,
      isMinSignedValue,
      isIntN,
      isSignedIntN,
      isPowerOf2,
      isSignMask,
      getBoolValue,
      getLimitedValue,
      isSplat,
      isMask,
      isMask1,
      isShiftedMask,
      isSameValue,
      getRawData,
      operator_not,
      urem,
      srem,
      udivrem,
      sdivrem,
      operator_sub,
      operator_eq_eq,
      operator_eq_eq1,
      eq,
      operator_not_eq,
      operator_not_eq1,
      ne,
      ult,
      ult1,
      slt,
      slt1,
      ule,
      ule1,
      sle,
      sle1,
      ugt,
      ugt1,
      sgt,
      sgt1,
      uge,
      uge1,
      sge,
      sge1,
      intersects,
      isSubsetOf,
      getBitWidth,
      getNumWords,
      getNumWords1,
      getActiveBits,
      getActiveWords,
      getMinSignedBits,
      getZExtValue,
      getSExtValue,
      getBitsNeeded,
      countLeadingZeros,
      countLeadingOnes,
      getNumSignBits,
      countTrailingZeros,
      countTrailingOnes,
      countPopulation,
      print,
      toString,
      roundToDouble,
      roundToDouble1,
      signedRoundToDouble,
      bitsToDouble,
      bitsToFloat,
      logBase2,
      ceilLogBase2,
      nearestLogBase2,
      exactLogBase2,
      magic,
      magicu,
      tcSet,
      tcAssign,
      tcIsZero,
      tcExtractBit,
      tcExtract,
      tcSetBit,
      tcClearBit,
      tcLSB,
      tcMSB,
      tcNegate,
      tcAdd,
      tcAddPart,
      tcSubtract,
      tcSubtractPart,
      tcMultiplyPart,
      tcMultiply,
      tcFullMultiply,
      tcDivide,
      tcShiftLeft,
      tcShiftRight,
      tcAnd,
      tcOr,
      tcXor,
      tcComplement,
      tcCompare,
      tcIncrement,
      tcDecrement,
      tcSetLeastSignificantBits,
      dump,
    };
    static const unsigned _total_num_mems_ = dump + 1;
  }
  namespace llvm__APInt__ms {
    enum memnames {
      s,
    };
    static const unsigned _total_num_mems_ = s + 1;
  }
  namespace llvm__APInt__mu {
    enum memnames {
      a,
      s,
    };
    static const unsigned _total_num_mems_ = s + 1;
  }
  namespace llvm__APFloatBase {
    enum memnames {
    };
    static const unsigned _total_num_mems_ = 0;
  }
  namespace llvm__APFloat {
    enum memnames {
      needsCleanup,
      Profile,
      convertToInteger,
      convertToDouble,
      convertToFloat,
      compare,
      bitwiseIsEqual,
      isExactlyValue,
      convertToHexString,
      isZero,
      isInfinity,
      isNaN,
      isNegative,
      isDenormal,
      isSignaling,
      isNormal,
      isFinite,
      getCategory,
      isNonZero,
      isFiniteNonZero,
      isPosZero,
      isNegZero,
      isSmallest,
      isLargest,
      isInteger,
      print,
      dump,
      getExactInverse,
    };
    static const unsigned _total_num_mems_ = getExactInverse + 1;
  }
  namespace llvm__APSInt {
    enum memnames {
      isSigned,
      isUnsigned,
      toString,
      getExtValue,
      trunc,
      extend,
      extOrTrunc,
      operator_mod,
      operator_div,
      operator_gr_gr,
      operator_less,
      operator_gr,
      operator_less_eq,
      operator_gr_eq,
      operator_eq_eq,
      operator_not_eq,
      operator_eq_eq1,
      operator_not_eq1,
      operator_less_eq1,
      operator_gr_eq1,
      operator_less1,
      operator_gr1,
      operator_less_less,
      operator_minus,
      operator_and,
      operator_or,
      operator_exp,
      operator_star,
      operator_plus,
      operator_minus1,
      operator_tilde,
      getMaxValue,
      getMinValue,
      isSameValue,
      compareValues,
      get,
      getUnsigned,
      Profile,
    };
    static const unsigned _total_num_mems_ = Profile + 1;
  }
  namespace clang__APValue {
    enum memnames {
      needsCleanup,
      getKind,
      isUninit,
      isInt,
      isFloat,
      isComplexInt,
      isComplexFloat,
      isLValue,
      isVector,
      isArray,
      isStruct,
      isUnion,
      isMemberPointer,
      isAddrLabelDiff,
      dump,
      dump1,
      printPretty,
      getAsString,
      getInt,
      getFloat,
      getComplexIntReal,
      getComplexIntImag,
      getComplexFloatReal,
      getComplexFloatImag,
      getLValueBase,
      getLValueOffset,
      isLValueOnePastTheEnd,
      hasLValuePath,
      getLValueCallIndex,
      getLValueVersion,
      isNullPointer,
      getVectorElt,
      getVectorLength,
      getArrayInitializedElt,
      hasArrayFiller,
      getArrayFiller,
      getArrayInitializedElts,
      getArraySize,
      getStructNumBases,
      getStructNumFields,
      getStructBase,
      getStructField,
      getUnionField,
      getUnionValue,
      getMemberPointerDecl,
      isMemberPointerToDerivedMember,
      getMemberPointerPath,
      getAddrLabelDiffLHS,
      getAddrLabelDiffRHS,
    };
    static const unsigned _total_num_mems_ = getAddrLabelDiffRHS + 1;
  }
  namespace clang__APValue__LValueBase {
    enum memnames {
      getOpaqueValue,
      isNull,
      operator_bool,
      getCallIndex,
      getVersion,
      operator_eq_eq,
    };
    static const unsigned _total_num_mems_ = operator_eq_eq + 1;
  }
  namespace clang__DiagnosticOptions {
    enum memnames {
      Retain,
      Release,
      IgnoreWarnings,
      NoRewriteMacros,
      Pedantic,
      PedanticErrors,
      ShowColumn,
      ShowLocation,
      AbsolutePath,
      ShowCarets,
      ShowFixits,
      ShowSourceRanges,
      ShowParseableFixits,
      ShowPresumedLoc,
      ShowOptionNames,
      ShowNoteIncludeStack,
      ShowCategories,
      ShowColors,
      VerifyDiagnostics,
      ElideType,
      ShowTemplateTree,
      CLFallbackMode,
      ErrorLimit,
      MacroBacktraceLimit,
      TemplateBacktraceLimit,
      ConstexprBacktraceLimit,
      SpellCheckingLimit,
      SnippetLineLimit,
      TabStop,
      MessageLength,
      getFormat,
      getShowOverloads,
      getVerifyIgnoreUnexpected,
    };
    static const unsigned _total_num_mems_ = getVerifyIgnoreUnexpected + 1;
  }
  namespace clang__FileID {
    enum memnames {
      isValid,
      isInvalid,
      operator_eq_eq,
      operator_less,
      operator_less_eq,
      operator_not_eq,
      operator_gr,
      operator_gr_eq,
      getSentinel,
      getHashValue,
    };
    static const unsigned _total_num_mems_ = getHashValue + 1;
  }
  namespace clang__SourceLocation {
    enum memnames {
      isFileID,
      isMacroID,
      isValid,
      isInvalid,
      getLocWithOffset,
      getRawEncoding,
      getFromRawEncoding,
      getPtrEncoding,
      getFromPtrEncoding,
      isPairOfFileLocations,
      print,
      printToString,
      dump,
    };
    static const unsigned _total_num_mems_ = dump + 1;
  }
  namespace clang__SourceRange {
    enum memnames {
      getBegin,
      getEnd,
      isValid,
      isInvalid,
      operator_eq_eq,
      operator_not_eq,
    };
    static const unsigned _total_num_mems_ = operator_not_eq + 1;
  }
  namespace clang__CharSourceRange {
    enum memnames {
      getTokenRange,
      getCharRange,
      getTokenRange1,
      getCharRange1,
      isTokenRange,
      isCharRange,
      getBegin,
      getEnd,
      getAsRange,
      isValid,
      isInvalid,
    };
    static const unsigned _total_num_mems_ = isInvalid + 1;
  }
  namespace clang__PresumedLoc {
    enum memnames {
      isInvalid,
      isValid,
      getFilename,
      getLine,
      getColumn,
      getIncludeLoc,
    };
    static const unsigned _total_num_mems_ = getIncludeLoc + 1;
  }
  namespace clang__FullSourceLoc {
    enum memnames {
      hasManager,
      getManager,
      getFileID,
      getExpansionLoc,
      getSpellingLoc,
      getFileLoc,
      getPresumedLoc,
      isMacroArgExpansion,
      getImmediateMacroCallerLoc,
      getFileOffset,
      getExpansionLineNumber,
      getExpansionColumnNumber,
      getSpellingLineNumber,
      getSpellingColumnNumber,
      getCharacterData,
      getLineNumber,
      getColumnNumber,
      getFileEntry,
      getBufferData,
      isInSystemHeader,
      isBeforeInTranslationUnitThan,
      isBeforeInTranslationUnitThan1,
      dump,
      operator_eq_eq,
      operator_not_eq,
    };
    static const unsigned _total_num_mems_ = operator_not_eq + 1;
  }
  namespace llvm__DebugEpochBase {
    enum memnames {
    };
    static const unsigned _total_num_mems_ = 0;
  }
  namespace clang__FixItHint {
    enum memnames {
      RemoveRange,
      InsertFromRange,
      BeforePreviousInsertions,
      isNull,
      CreateInsertionFromRange,
      CreateRemoval,
      CreateRemoval1,
    };
    static const unsigned _total_num_mems_ = CreateRemoval1 + 1;
  }
  namespace clang__DiagnosticsEngine {
    enum memnames {
      Retain,
      Release,
      dump,
      dump1,
      getDiagnosticOptions,
      getClient,
      ownsClient,
      hasSourceManager,
      getSourceManager,
      getTemplateBacktraceLimit,
      getConstexprBacktraceLimit,
      getIgnoreAllWarnings,
      getEnableAllWarnings,
      getWarningsAsErrors,
      getErrorsAsFatal,
      getSuppressSystemWarnings,
      getSuppressAllDiagnostics,
      getShowOverloads,
      isLastDiagnosticIgnored,
      getExtensionHandlingBehavior,
      hasErrorOccurred,
      hasUncompilableErrorOccurred,
      hasFatalErrorOccurred,
      hasUnrecoverableErrorOccurred,
      getNumWarnings,
      isIgnored,
      getDiagnosticLevel,
      isDiagnosticInFlight,
      getFlagValue,
    };
    static const unsigned _total_num_mems_ = getFlagValue + 1;
  }
  namespace clang__DiagnosticBuilder {
    enum memnames {
      setForceEmit,
      operator_bool,
      AddString,
      AddTaggedVal,
      AddSourceRange,
      AddFixItHint,
      addFlagValue,
    };
    static const unsigned _total_num_mems_ = addFlagValue + 1;
  }
  namespace clang__DiagnosticConsumer {
    enum memnames {
      getNumErrors,
      getNumWarnings,
      IncludeInDiagnosticCounts,
    };
    static const unsigned _total_num_mems_ = IncludeInDiagnosticCounts + 1;
  }
  namespace clang__IdentifierInfo {
    enum memnames {
      isStr,
      getNameStart,
      getLength,
      getName,
      hasMacroDefinition,
      hadMacroDefinition,
      getTokenID,
      hasRevertedTokenIDToIdentifier,
      getPPKeywordID,
      getObjCKeywordID,
      hasRevertedBuiltin,
      getBuiltinID,
      getObjCOrBuiltinID,
      isExtensionToken,
      isFutureCompatKeyword,
      isPoisoned,
      isCPlusPlusOperatorKeyword,
      isKeyword,
      isCPlusPlusKeyword,
      isHandleIdentifierCase,
      isFromAST,
      hasChangedSinceDeserialization,
      hasFETokenInfoChangedSinceDeserialization,
      isOutOfDate,
      isModulesImport,
      isEditorPlaceholder,
      operator_less,
    };
    static const unsigned _total_num_mems_ = operator_less + 1;
  }
  namespace clang__IdentifierInfoLookup {
    enum memnames {
    };
    static const unsigned _total_num_mems_ = 0;
  }
  namespace clang__IdentifierTable {
    enum memnames {
      getExternalIdentifierLookup,
      size,
      PrintStats,
    };
    static const unsigned _total_num_mems_ = PrintStats + 1;
  }
  namespace clang__Selector {
    enum memnames {
      operator_eq_eq,
      operator_not_eq,
      getAsOpaquePtr,
      isNull,
      isKeywordSelector,
      isUnarySelector,
      getNumArgs,
      getIdentifierInfoForSlot,
      getNameForSlot,
      getAsString,
      print,
      dump,
      getMethodFamily,
      getStringFormatFamily,
      getEmptyMarker,
      getTombstoneMarker,
      getInstTypeMethodFamily,
    };
    static const unsigned _total_num_mems_ = getInstTypeMethodFamily + 1;
  }
  namespace clang__SelectorTable {
    enum memnames {
      getTotalMemory,
      constructSetterSelector,
      getPropertyNameFromSetterSelector,
    };
    static const unsigned _total_num_mems_ = getPropertyNameFromSetterSelector + 1;
  }
  namespace clang__PartialDiagnostic {
    enum memnames {
      getDiagID,
      AddTaggedVal,
      AddString,
      Emit,
      hasStorage,
      getNumArgs,
      operator_less_less,
      operator_less_less1,
      operator_less_less2,
      operator_less_less3,
      operator_less_less4,
      operator_less_less5,
      operator_less_less6,
      operator_less_less7,
    };
    static const unsigned _total_num_mems_ = operator_less_less7 + 1;
  }
  namespace clang__DeclarationName {
    enum memnames {
      getUsingDirectiveName,
      operator_bool,
      isEmpty,
      isIdentifier,
      isObjCZeroArgSelector,
      isObjCOneArgSelector,
      getNameKind,
      isDependentName,
      getAsString,
      getAsIdentifierInfo,
      getAsOpaqueInteger,
      getAsOpaquePtr,
      getFromOpaquePtr,
      getFromOpaqueInteger,
      getCXXNameType,
      getCXXDeductionGuideTemplate,
      getCXXOverloadedOperator,
      getCXXLiteralIdentifier,
      getCXXIdExprArguments,
      getObjCSelector,
      operator_eq_eq,
      operator_not_eq,
      getEmptyMarker,
      getTombstoneMarker,
      compare,
      dump,
    };
    static const unsigned _total_num_mems_ = dump + 1;
  }
  namespace clang__DeclarationNameLoc {
    enum memnames {
    };
    static const unsigned _total_num_mems_ = 0;
  }
  namespace clang__DeclarationNameInfo {
    enum memnames {
      getName,
      getLoc,
      getInfo,
      getNamedTypeInfo,
      getCXXOperatorNameRange,
      getCXXLiteralOperatorNameLoc,
      getCXXIdExprNameRange,
      isInstantiationDependent,
      containsUnexpandedParameterPack,
      getAsString,
      printName,
      getBeginLoc,
      getSourceRange,
      getLocStart,
      getLocEnd,
      getEndLoc,
    };
    static const unsigned _total_num_mems_ = getEndLoc + 1;
  }
  namespace llvm__raw_ostream {
    enum memnames {
      tell,
      GetBufferSize,
      GetNumBytesInBuffer,
      is_displayed,
      has_colors,
    };
    static const unsigned _total_num_mems_ = has_colors + 1;
  }
  namespace llvm__VersionTuple {
    enum memnames {
      empty,
      getMajor,
      operator_eq_eq,
      operator_not_eq,
      operator_less,
      operator_gr,
      operator_less_eq,
      operator_gr_eq,
      getAsString,
    };
    static const unsigned _total_num_mems_ = getAsString + 1;
  }
  namespace clang__Decl {
    enum memnames {
      getSourceRange,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getLocation,
      getKind,
      getDeclKindName,
      getNextDeclInContext,
      getDeclContext,
      getNonClosureContext,
      getTranslationUnitDecl,
      isInAnonymousNamespace,
      isInStdNamespace,
      getASTContext,
      getAccess,
      getAccessUnsafe,
      hasAttrs,
      attrs,
      getMaxAlignment,
      isInvalidDecl,
      isImplicit,
      isUsed,
      isReferenced,
      isThisDeclarationReferenced,
      instantiationsWillNeedParsing,
      isTopLevelDeclInObjCContainer,
      getExternalSourceSymbolAttr,
      isModulePrivate,
      isExported,
      hasDefiningAttr,
      getDefiningAttr,
      getVersionIntroduced,
      isWeakImported,
      isFromASTFile,
      getGlobalID,
      getOwningModuleID,
      getImportedOwningModule,
      getLocalOwningModule,
      hasOwningModule,
      getOwningModule,
      getOwningModuleForLinkage,
      isHidden,
      getModuleOwnershipKind,
      getIdentifierNamespace,
      isInIdentifierNamespace,
      getIdentifierNamespaceForKind,
      hasTagIdentifierNamespace,
      isTagIdentifierNamespace,
      getLexicalDeclContext,
      isOutOfLine,
      isTemplated,
      isDefinedOutsideFunctionOrMethod,
      isLexicallyWithinFunctionOrMethod,
      getParentFunctionOrMethod,
      getCanonicalDecl,
      isCanonicalDecl,
      redecls,
      getPreviousDecl,
      isFirstDecl,
      getMostRecentDecl,
      getBody,
      hasBody,
      getBodyRBrace,
      add,
      EnableStatistics,
      PrintStats,
      isTemplateParameter,
      isTemplateParameterPack,
      isParameterPack,
      isTemplateDecl,
      isFunctionOrFunctionTemplate,
      getDescribedTemplate,
      getAsFunction,
      getFriendObjectKind,
      classofKind,
      print,
      print1,
      printGroup,
      dump,
      dumpColor,
      dump1,
      getFunctionType,
    };
    static const unsigned _total_num_mems_ = getFunctionType + 1;
  }
  namespace clang__DeclContextLookupResult {
    enum memnames {
      _this_,
      empty,
      data,
      size,
      front,
      back,
      operator_sub,
      slice,
    };
    static const unsigned _total_num_mems_ = slice + 1;
  }
  namespace clang__DeclContext {
    enum memnames {
      getDeclKind,
      getDeclKindName,
      getParent,
      getLexicalParent,
      getLookupParent,
      getParentASTContext,
      isClosure,
      isObjCContainer,
      isFunctionOrMethod,
      isLookupContext,
      isFileContext,
      isTranslationUnit,
      isRecord,
      isNamespace,
      isStdNamespace,
      isInlineNamespace,
      isDependentContext,
      isTransparentContext,
      isExternCContext,
      getExternCContext,
      isExternCXXContext,
      Equals,
      Encloses,
      getNonClosureAncestor,
      getPrimaryContext,
      getRedeclContext,
      getEnclosingNamespaceContext,
      getOuterLexicalRecordContext,
      InEnclosingNamespaceSetOf,
      decls,
      decls_empty,
      noload_decls,
      containsDecl,
      containsDeclAndLoad,
      lookup,
      lookups,
      ddiags,
      getLookupPtr,
      hasExternalLexicalStorage,
      hasExternalVisibleStorage,
      isDeclInLexicalTraversal,
      shouldUseQualifiedLookup,
      classof,
      classof1,
      dumpDeclContext,
      dumpLookups,
      dumpLookups1,
    };
    static const unsigned _total_num_mems_ = dumpLookups1 + 1;
  }
  namespace clang__CharUnits {
    enum memnames {
      Zero,
      One,
      fromQuantity,
      operator_eq_eq,
      operator_not_eq,
      operator_less,
      operator_less_eq,
      operator_gr,
      operator_gr_eq,
      isZero,
      isOne,
      isPositive,
      isNegative,
      isPowerOfTwo,
      isMultipleOf,
      operator_star,
      operator_div,
      operator_div1,
      operator_mod,
      operator_mod1,
      operator_plus,
      operator_minus,
      operator_minus1,
      getQuantity,
      alignTo,
      alignmentAtOffset,
      alignmentOfArrayElement,
    };
    static const unsigned _total_num_mems_ = alignmentOfArrayElement + 1;
  }
  namespace clang__FileSystemOptions {
    enum memnames {
    };
    static const unsigned _total_num_mems_ = 0;
  }
  namespace llvm__Twine {
    enum memnames {
      isTriviallyEmpty,
      isSingleStringRef,
      str,
      getSingleStringRef,
      print,
      dump,
      printRepr,
      dumpRepr,
    };
    static const unsigned _total_num_mems_ = dumpRepr + 1;
  }
  namespace llvm__sys__fs__UniqueID {
    enum memnames {
      operator_eq_eq,
      operator_not_eq,
      operator_less,
      getDevice,
      getFile,
    };
    static const unsigned _total_num_mems_ = getFile + 1;
  }
  namespace llvm__MemoryBuffer {
    enum memnames {
      getBufferStart,
      getBufferEnd,
      getBufferSize,
      getBuffer,
      getBufferIdentifier,
      getBufferKind,
      getMemBufferRef,
    };
    static const unsigned _total_num_mems_ = getMemBufferRef + 1;
  }
  namespace llvm__MemoryBufferRef {
    enum memnames {
      getBuffer,
      getBufferIdentifier,
      getBufferStart,
      getBufferEnd,
      getBufferSize,
    };
    static const unsigned _total_num_mems_ = getBufferSize + 1;
  }
  namespace clang__DirectoryEntry {
    enum memnames {
      getName,
    };
    static const unsigned _total_num_mems_ = getName + 1;
  }
  namespace clang__FileEntry {
    enum memnames {
      getName,
      tryGetRealPathName,
      isValid,
      getSize,
      getUID,
      getUniqueID,
      isInPCH,
      getModificationTime,
      getDir,
      operator_less,
      isNamedPipe,
      closeFile,
    };
    static const unsigned _total_num_mems_ = closeFile + 1;
  }
  namespace clang__FileManager {
    enum memnames {
      Retain,
      Release,
      getFileSystemOpts,
      modifyFileEntry,
      PrintStats,
    };
    static const unsigned _total_num_mems_ = PrintStats + 1;
  }
  namespace clang__ASTFileSignature {
    enum memnames {
      _this_,
      cbegin,
      cend,
      size,
      max_size,
      empty,
      operator_sub,
      at,
      front,
      back,
      data,
      operator_bool,
    };
    static const unsigned _total_num_mems_ = operator_bool + 1;
  }
  namespace clang__Module {
    enum memnames {
      DefinitionLoc,
      Kind,
      Parent,
      Directory,
      Signature,
      ShadowingModule,
      IsMissingRequirement,
      HasIncompatibleModuleFile,
      IsAvailable,
      IsFromModuleFile,
      IsFramework,
      IsExplicit,
      IsSystem,
      IsExternC,
      IsInferred,
      InferSubmodules,
      InferExplicitSubmodules,
      InferExportWildcard,
      ConfigMacrosExhaustive,
      NoUndeclaredIncludes,
      ModuleMapIsPrivate,
      NameVisibility,
      InferredSubmoduleLoc,
      UseExportAsModuleLinkName,
      isAvailable,
      isSubModule,
      isSubModuleOf,
      isPartOfFramework,
      isSubFramework,
      getFullModuleName,
      getTopLevelModule,
      getTopLevelModuleName,
      getASTFile,
      getUmbrellaDir,
      getUmbrellaHeader,
      hasUmbrellaDir,
      directlyUses,
      isModuleVisible,
      getVisibilityID,
      submodules,
      getModuleInputBufferName,
      print,
      dump,
    };
    static const unsigned _total_num_mems_ = dump + 1;
  }
  namespace clang__Module__Header {
    enum memnames {
      Entry,
    };
    static const unsigned _total_num_mems_ = Entry + 1;
  }
  namespace clang__Module__DirectoryName {
    enum memnames {
      Entry,
    };
    static const unsigned _total_num_mems_ = Entry + 1;
  }
  namespace clang__ExternalASTSource {
    enum memnames {
      Retain,
      Release,
      getGeneration,
      getMemoryBufferSizes,
      getMemoryBufferSizes1,
    };
    static const unsigned _total_num_mems_ = getMemoryBufferSizes1 + 1;
  }
  namespace clang__ExternalASTSource__MemoryBufferSizes {
    enum memnames {
      malloc_bytes,
      mmap_bytes,
    };
    static const unsigned _total_num_mems_ = mmap_bytes + 1;
  }
  namespace llvm__FoldingSetBase {
    enum memnames {
      size,
      empty,
    };
    static const unsigned _total_num_mems_ = empty + 1;
  }
  namespace llvm__FoldingSetBase__Node {
    enum memnames {
      getNextInBucket,
    };
    static const unsigned _total_num_mems_ = getNextInBucket + 1;
  }
  namespace llvm__FoldingSetNodeIDRef {
    enum memnames {
      ComputeHash,
      operator_eq_eq,
      operator_not_eq,
      operator_less,
      getData,
      getSize,
    };
    static const unsigned _total_num_mems_ = getSize + 1;
  }
  namespace llvm__FoldingSetNodeID {
    enum memnames {
      ComputeHash,
      operator_eq_eq,
      operator_eq_eq1,
      operator_not_eq,
      operator_not_eq1,
      operator_less,
      operator_less1,
    };
    static const unsigned _total_num_mems_ = operator_less1 + 1;
  }
  namespace clang__NestedNameSpecifier {
    enum memnames {
      Create,
      Create1,
      Create2,
      Create3,
      Create4,
      GlobalSpecifier,
      SuperSpecifier,
      getPrefix,
      getKind,
      getAsIdentifier,
      getAsNamespace,
      getAsNamespaceAlias,
      getAsRecordDecl,
      getAsType,
      isDependent,
      isInstantiationDependent,
      containsUnexpandedParameterPack,
      print,
      Profile,
      dump,
      dump1,
    };
    static const unsigned _total_num_mems_ = dump1 + 1;
  }
  namespace clang__NestedNameSpecifierLoc {
    enum memnames {
      operator_bool,
      hasQualifier,
      getNestedNameSpecifier,
      getOpaqueData,
      getSourceRange,
      getLocalSourceRange,
      getBeginLoc,
      getEndLoc,
      getLocalBeginLoc,
      getLocalEndLoc,
      getPrefix,
      getTypeLoc,
      getDataLength,
      operator_eq_eq,
      operator_not_eq,
    };
    static const unsigned _total_num_mems_ = operator_not_eq + 1;
  }
  namespace clang__UncommonTemplateNameStorage {
    enum memnames {
      size,
    };
    static const unsigned _total_num_mems_ = size + 1;
  }
  namespace clang__OverloadedTemplateStorage {
    enum memnames {
      _this_,
    };
    static const unsigned _total_num_mems_ = 0;
  }
  namespace clang__SubstTemplateTemplateParmPackStorage {
    enum memnames {
      getParameterPack,
      getArgumentPack,
      Profile,
    };
    static const unsigned _total_num_mems_ = Profile + 1;
  }
  namespace clang__TemplateName {
    enum memnames {
      isNull,
      getKind,
      getAsTemplateDecl,
      getAsOverloadedTemplate,
      getAsSubstTemplateTemplateParm,
      getAsSubstTemplateTemplateParmPack,
      getAsQualifiedTemplateName,
      getAsDependentTemplateName,
      getUnderlying,
      getNameToSubstitute,
      isDependent,
      isInstantiationDependent,
      containsUnexpandedParameterPack,
      print,
      dump,
      dump1,
      getAsVoidPointer,
      getFromVoidPointer,
    };
    static const unsigned _total_num_mems_ = getFromVoidPointer + 1;
  }
  namespace clang__SubstTemplateTemplateParmStorage {
    enum memnames {
      getParameter,
      getReplacement,
      Profile,
    };
    static const unsigned _total_num_mems_ = Profile + 1;
  }
  namespace clang__QualifiedTemplateName {
    enum memnames {
      getQualifier,
      hasTemplateKeyword,
      getDecl,
      getTemplateDecl,
      Profile,
    };
    static const unsigned _total_num_mems_ = Profile + 1;
  }
  namespace clang__DependentTemplateName {
    enum memnames {
      getQualifier,
      isIdentifier,
      getIdentifier,
      isOverloadedOperator,
      getOperator,
      Profile,
      Profile1,
    };
    static const unsigned _total_num_mems_ = Profile1 + 1;
  }
  namespace clang__LinkageInfo {
    enum memnames {
      external,
      internal,
      uniqueExternal,
      none,
      visible_none,
      getLinkage,
      getVisibility,
      isVisibilityExplicit,
    };
    static const unsigned _total_num_mems_ = isVisibilityExplicit + 1;
  }
  namespace clang__Qualifiers {
    enum memnames {
      removeCommonQualifiers,
      fromFastMask,
      fromCVRMask,
      fromCVRUMask,
      fromOpaqueValue,
      getAsOpaqueValue,
      hasConst,
      hasVolatile,
      hasRestrict,
      hasCVRQualifiers,
      getCVRQualifiers,
      hasUnaligned,
      hasObjCGCAttr,
      getObjCGCAttr,
      withoutObjCGCAttr,
      withoutObjCLifetime,
      hasObjCLifetime,
      getObjCLifetime,
      hasNonTrivialObjCLifetime,
      hasStrongOrWeakObjCLifetime,
      hasAddressSpace,
      getAddressSpace,
      hasTargetSpecificAddressSpace,
      getAddressSpaceAttributePrintValue,
      hasFastQualifiers,
      getFastQualifiers,
      hasNonFastQualifiers,
      getNonFastQualifiers,
      hasQualifiers,
      empty,
      isAddressSpaceSupersetOf,
      compatiblyIncludes,
      compatiblyIncludesObjCLifetime,
      isStrictSupersetOf,
      operator_eq_eq,
      operator_not_eq,
      operator_bool,
      operator_plus,
      operator_minus,
      getAsString,
      getAsString1,
      isEmptyWhenPrinted,
      print,
      Profile,
    };
    static const unsigned _total_num_mems_ = Profile + 1;
  }
  namespace clang__SplitQualType {
    enum memnames {
      Ty,
      Quals,
      getSingleStepDesugaredType,
      operator_eq_eq,
      operator_not_eq,
    };
    static const unsigned _total_num_mems_ = operator_not_eq + 1;
  }
  namespace clang__QualType {
    enum memnames {
      getLocalFastQualifiers,
      getTypePtr,
      getTypePtrOrNull,
      getBaseTypeIdentifier,
      split,
      getAsOpaquePtr,
      getFromOpaquePtr,
      operator_star,
      operator_arrow,
      isCanonical,
      isCanonicalAsParam,
      isNull,
      isLocalConstQualified,
      isConstQualified,
      isLocalRestrictQualified,
      isRestrictQualified,
      isLocalVolatileQualified,
      isVolatileQualified,
      hasLocalQualifiers,
      hasQualifiers,
      hasLocalNonFastQualifiers,
      getLocalQualifiers,
      getQualifiers,
      getLocalCVRQualifiers,
      getCVRQualifiers,
      isConstant,
      isPODType,
      isCXX98PODType,
      isCXX11PODType,
      isTrivialType,
      isTriviallyCopyableType,
      mayBeDynamicClass,
      mayBeNotDynamicClass,
      withConst,
      withVolatile,
      withRestrict,
      withCVRQualifiers,
      withFastQualifiers,
      withExactLocalFastQualifiers,
      withoutLocalFastQualifiers,
      getCanonicalType,
      getLocalUnqualifiedType,
      getUnqualifiedType,
      getSplitUnqualifiedType,
      isMoreQualifiedThan,
      isAtLeastAsQualifiedAs,
      getNonReferenceType,
      getNonLValueExprType,
      getDesugaredType,
      getSplitDesugaredType,
      getSingleStepDesugaredType,
      IgnoreParens,
      operator_eq_eq,
      operator_not_eq,
      getAsString,
      getAsString1,
      getAsString2,
      getAsString3,
      getAsString_NoPrependScope,
      print,
      print1,
      print2,
      dump,
      dump1,
      dump2,
      Profile,
      getAddressSpace,
      getObjCGCAttr,
      isObjCGCWeak,
      isObjCGCStrong,
      getObjCLifetime,
      hasNonTrivialObjCLifetime,
      hasStrongOrWeakObjCLifetime,
      isNonWeakInMRRWithObjCWeak,
      isNonTrivialToPrimitiveDefaultInitialize,
      isNonTrivialToPrimitiveCopy,
      isNonTrivialToPrimitiveDestructiveMove,
      isDestructedType,
      isCForbiddenLValueType,
      substObjCMemberType,
      stripObjCKindOfType,
      getAtomicUnqualifiedType,
    };
    static const unsigned _total_num_mems_ = getAtomicUnqualifiedType + 1;
  }
  namespace clang__ExtQualsTypeCommonBase {
    enum memnames {
    };
    static const unsigned _total_num_mems_ = 0;
  }
  namespace clang__Type {
    enum memnames {
      getTypeClass,
      isFromAST,
      containsUnexpandedParameterPack,
      isCanonicalUnqualified,
      getLocallyUnqualifiedSingleStepDesugaredType,
      isIncompleteType,
      isIncompleteOrObjectType,
      isObjectType,
      isLiteralType,
      isStandardLayoutType,
      isBuiltinType,
      isSpecificBuiltinType,
      isPlaceholderType,
      getAsPlaceholderType,
      isSpecificPlaceholderType,
      isNonOverloadPlaceholderType,
      isIntegerType,
      isEnumeralType,
      isScopedEnumeralType,
      isBooleanType,
      isCharType,
      isWideCharType,
      isChar8Type,
      isChar16Type,
      isChar32Type,
      isAnyCharacterType,
      isIntegralType,
      isIntegralOrEnumerationType,
      isIntegralOrUnscopedEnumerationType,
      isRealFloatingType,
      isComplexType,
      isAnyComplexType,
      isFloatingType,
      isHalfType,
      isFloat16Type,
      isFloat128Type,
      isRealType,
      isArithmeticType,
      isVoidType,
      isScalarType,
      isAggregateType,
      isFundamentalType,
      isCompoundType,
      isFunctionType,
      isFunctionNoProtoType,
      isFunctionProtoType,
      isPointerType,
      isAnyPointerType,
      isBlockPointerType,
      isVoidPointerType,
      isReferenceType,
      isLValueReferenceType,
      isRValueReferenceType,
      isFunctionPointerType,
      isMemberPointerType,
      isMemberFunctionPointerType,
      isMemberDataPointerType,
      isArrayType,
      isConstantArrayType,
      isIncompleteArrayType,
      isVariableArrayType,
      isDependentSizedArrayType,
      isRecordType,
      isClassType,
      isStructureType,
      isObjCBoxableRecordType,
      isInterfaceType,
      isStructureOrClassType,
      isUnionType,
      isReflectedType,
      isComplexIntegerType,
      isVectorType,
      isExtVectorType,
      isDependentAddressSpaceType,
      isObjCObjectPointerType,
      isObjCRetainableType,
      isObjCLifetimeType,
      isObjCIndirectLifetimeType,
      isObjCNSObjectType,
      isObjCIndependentClassType,
      isObjCObjectType,
      isObjCQualifiedInterfaceType,
      isObjCQualifiedIdType,
      isObjCQualifiedClassType,
      isObjCObjectOrInterfaceType,
      isObjCIdType,
      isObjCInertUnsafeUnretainedType,
      isObjCIdOrObjectKindOfType,
      isObjCClassType,
      isObjCClassOrClassKindOfType,
      isBlockCompatibleObjCPointerType,
      isObjCSelType,
      isObjCBuiltinType,
      isObjCARCBridgableType,
      isCARCBridgableType,
      isTemplateTypeParmType,
      isNullPtrType,
      isAlignValT,
      isStdByteType,
      isAtomicType,
      isOCLImage1dROType,
      isOCLImage1dArrayROType,
      isOCLImage1dBufferROType,
      isOCLImage2dROType,
      isOCLImage2dArrayROType,
      isOCLImage2dDepthROType,
      isOCLImage2dArrayDepthROType,
      isOCLImage2dMSAAROType,
      isOCLImage2dArrayMSAAROType,
      isOCLImage2dMSAADepthROType,
      isOCLImage2dArrayMSAADepthROType,
      isOCLImage3dROType,
      isOCLImage1dWOType,
      isOCLImage1dArrayWOType,
      isOCLImage1dBufferWOType,
      isOCLImage2dWOType,
      isOCLImage2dArrayWOType,
      isOCLImage2dDepthWOType,
      isOCLImage2dArrayDepthWOType,
      isOCLImage2dMSAAWOType,
      isOCLImage2dArrayMSAAWOType,
      isOCLImage2dMSAADepthWOType,
      isOCLImage2dArrayMSAADepthWOType,
      isOCLImage3dWOType,
      isOCLImage1dRWType,
      isOCLImage1dArrayRWType,
      isOCLImage1dBufferRWType,
      isOCLImage2dRWType,
      isOCLImage2dArrayRWType,
      isOCLImage2dDepthRWType,
      isOCLImage2dArrayDepthRWType,
      isOCLImage2dMSAARWType,
      isOCLImage2dArrayMSAARWType,
      isOCLImage2dMSAADepthRWType,
      isOCLImage2dArrayMSAADepthRWType,
      isOCLImage3dRWType,
      isImageType,
      isSamplerT,
      isEventT,
      isClkEventT,
      isQueueT,
      isReserveIDT,
      isPipeType,
      isOpenCLSpecificType,
      isObjCARCImplicitlyUnretainedType,
      getObjCARCImplicitLifetime,
      getScalarTypeKind,
      isDependentType,
      isInstantiationDependentType,
      isUndeducedType,
      isVariablyModifiedType,
      hasSizedVLAType,
      hasUnnamedOrLocalType,
      isOverloadableType,
      isElaboratedTypeSpecifier,
      canDecayToPointerType,
      hasPointerRepresentation,
      hasObjCPointerRepresentation,
      hasIntegerRepresentation,
      hasSignedIntegerRepresentation,
      hasUnsignedIntegerRepresentation,
      hasFloatingRepresentation,
      getAsStructureType,
      getAsUnionType,
      getAsComplexIntegerType,
      getAsObjCInterfaceType,
      getAsObjCInterfacePointerType,
      getAsObjCQualifiedIdType,
      getAsObjCQualifiedClassType,
      getAsObjCQualifiedInterfaceType,
      getAsCXXRecordDecl,
      getAsRecordDecl,
      getAsTagDecl,
      getPointeeCXXRecordDecl,
      getContainedDeducedType,
      getContainedAutoType,
      hasAutoForTrailingReturnType,
      getAsArrayTypeUnsafe,
      castAsArrayTypeUnsafe,
      getBaseElementTypeUnsafe,
      getArrayElementTypeNoTypeQual,
      getPointeeOrArrayElementType,
      getPointeeType,
      getUnqualifiedDesugaredType,
      isPromotableIntegerType,
      isSignedIntegerType,
      isUnsignedIntegerType,
      isSignedIntegerOrEnumerationType,
      isUnsignedIntegerOrEnumerationType,
      isFixedPointType,
      isSaturatedFixedPointType,
      isUnsaturatedFixedPointType,
      isSignedFixedPointType,
      isUnsignedFixedPointType,
      isConstantSizeType,
      isSpecifierType,
      getLinkage,
      getVisibility,
      isVisibilityExplicit,
      getLinkageAndVisibility,
      isLinkageValid,
      canHaveNullability,
      acceptsObjCTypeParams,
      getTypeClassName,
      getCanonicalTypeInternal,
      dump,
      dump1,
    };
    static const unsigned _total_num_mems_ = dump1 + 1;
  }
  namespace clang__BuiltinType {
    enum memnames {
      getKind,
      getName,
      getNameAsCString,
      isSugared,
      desugar,
      isInteger,
      isSignedInteger,
      isUnsignedInteger,
      isFloatingPoint,
      isPlaceholderTypeKind,
      isPlaceholderType,
      isNonOverloadPlaceholderType,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ComplexType {
    enum memnames {
      getElementType,
      isSugared,
      desugar,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ParenType {
    enum memnames {
      getInnerType,
      isSugared,
      desugar,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__PointerType {
    enum memnames {
      getPointeeType,
      isAddressSpaceOverlapping,
      isSugared,
      desugar,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__AdjustedType {
    enum memnames {
      getOriginalType,
      getAdjustedType,
      isSugared,
      desugar,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__DecayedType {
    enum memnames {
      getDecayedType,
      getPointeeType,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__BlockPointerType {
    enum memnames {
      getPointeeType,
      isSugared,
      desugar,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ReferenceType {
    enum memnames {
      isSpelledAsLValue,
      isInnerRef,
      getPointeeTypeAsWritten,
      getPointeeType,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__LValueReferenceType {
    enum memnames {
      isSugared,
      desugar,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__RValueReferenceType {
    enum memnames {
      isSugared,
      desugar,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__MemberPointerType {
    enum memnames {
      getPointeeType,
      isMemberFunctionPointer,
      isMemberDataPointer,
      getClass,
      getMostRecentCXXRecordDecl,
      isSugared,
      desugar,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ArrayType {
    enum memnames {
      getElementType,
      getSizeModifier,
      getIndexTypeQualifiers,
      getIndexTypeCVRQualifiers,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ConstantArrayType {
    enum memnames {
      getSize,
      isSugared,
      desugar,
      getNumAddressingBits,
      getMaxSizeBits,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__IncompleteArrayType {
    enum memnames {
      isSugared,
      desugar,
      classof,
      Profile,
    };
    static const unsigned _total_num_mems_ = Profile + 1;
  }
  namespace clang__VariableArrayType {
    enum memnames {
      getSizeExpr,
      getBracketsRange,
      getLBracketLoc,
      getRBracketLoc,
      isSugared,
      desugar,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__DependentSizedArrayType {
    enum memnames {
      getSizeExpr,
      getBracketsRange,
      getLBracketLoc,
      getRBracketLoc,
      isSugared,
      desugar,
      classof,
      Profile,
    };
    static const unsigned _total_num_mems_ = Profile + 1;
  }
  namespace clang__DependentAddressSpaceType {
    enum memnames {
      getAddrSpaceExpr,
      getPointeeType,
      getAttributeLoc,
      isSugared,
      desugar,
      classof,
      Profile,
    };
    static const unsigned _total_num_mems_ = Profile + 1;
  }
  namespace clang__DependentSizedExtVectorType {
    enum memnames {
      getSizeExpr,
      getElementType,
      getAttributeLoc,
      isSugared,
      desugar,
      classof,
      Profile,
    };
    static const unsigned _total_num_mems_ = Profile + 1;
  }
  namespace clang__VectorType {
    enum memnames {
      getElementType,
      getNumElements,
      isVectorSizeTooLarge,
      isSugared,
      desugar,
      getVectorKind,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__DependentVectorType {
    enum memnames {
      getSizeExpr,
      getElementType,
      getAttributeLoc,
      getVectorKind,
      isSugared,
      desugar,
      classof,
      Profile,
    };
    static const unsigned _total_num_mems_ = Profile + 1;
  }
  namespace clang__ExtVectorType {
    enum memnames {
      getPointAccessorIdx,
      getNumericAccessorIdx,
      getAccessorIdx,
      isAccessorWithinNumElements,
      isSugared,
      desugar,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__FunctionType {
    enum memnames {
      getReturnType,
      getHasRegParm,
      getRegParmType,
      getNoReturnAttr,
      getCallConv,
      getExtInfo,
      isConst,
      isVolatile,
      isRestrict,
      getCallResultType,
      getNameForCallConv,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__FunctionType__ExtInfo {
    enum memnames {
      getNoReturn,
      getProducesResult,
      getNoCallerSavedRegs,
      getNoCfCheck,
      getHasRegParm,
      getRegParm,
      getCC,
      operator_eq_eq,
      operator_not_eq,
      withNoReturn,
      withProducesResult,
      withNoCallerSavedRegs,
      withNoCfCheck,
      withRegParm,
      withCallingConv,
      Profile,
    };
    static const unsigned _total_num_mems_ = Profile + 1;
  }
  namespace clang__FunctionNoProtoType {
    enum memnames {
      isSugared,
      desugar,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__FunctionProtoType {
    enum memnames {
      getNumParams,
      getParamType,
      getParamTypes,
      getExtProtoInfo,
      getExceptionSpecType,
      hasExceptionSpec,
      hasDynamicExceptionSpec,
      hasNoexceptExceptionSpec,
      hasDependentExceptionSpec,
      hasInstantiationDependentExceptionSpec,
      getNumExceptions,
      getExceptionType,
      getNoexceptExpr,
      getExceptionSpecDecl,
      getExceptionSpecTemplate,
      canThrow,
      isNothrow,
      isVariadic,
      isTemplateVariadic,
      hasTrailingReturn,
      getTypeQuals,
      getRefQualifier,
      param_types,
      exceptions,
      hasExtParameterInfos,
      getExtParameterInfos,
      getExtParameterInfosOrNull,
      getExtParameterInfo,
      getParameterABI,
      isParamConsumed,
      isSugared,
      desugar,
      printExceptionSpecification,
      classof,
      Profile,
    };
    static const unsigned _total_num_mems_ = Profile + 1;
  }
  namespace clang__FunctionProtoType__ExtParameterInfo {
    enum memnames {
      getABI,
      withABI,
      isConsumed,
      withIsConsumed,
      hasPassObjectSize,
      withHasPassObjectSize,
      isNoEscape,
      withIsNoEscape,
      getOpaqueValue,
      getFromOpaqueValue,
      operator_eq_eq,
      operator_not_eq,
    };
    static const unsigned _total_num_mems_ = operator_not_eq + 1;
  }
  namespace clang__FunctionProtoType__ExceptionSpecInfo {
    enum memnames {
      Type,
      NoexceptExpr,
      SourceDecl,
      SourceTemplate,
    };
    static const unsigned _total_num_mems_ = SourceTemplate + 1;
  }
  namespace clang__FunctionProtoType__ExtProtoInfo {
    enum memnames {
      ExtInfo,
      Variadic,
      HasTrailingReturn,
      TypeQuals,
      RefQualifier,
      ExceptionSpec,
      ExtParameterInfos,
    };
    static const unsigned _total_num_mems_ = ExtParameterInfos + 1;
  }
  namespace clang__UnresolvedUsingType {
    enum memnames {
      getDecl,
      isSugared,
      desugar,
      classof,
      Profile,
    };
    static const unsigned _total_num_mems_ = Profile + 1;
  }
  namespace clang__TypedefType {
    enum memnames {
      getDecl,
      isSugared,
      desugar,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__TypeOfExprType {
    enum memnames {
      getUnderlyingExpr,
      desugar,
      isSugared,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__TypeOfType {
    enum memnames {
      getUnderlyingType,
      desugar,
      isSugared,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__DecltypeType {
    enum memnames {
      getUnderlyingExpr,
      getUnderlyingType,
      desugar,
      isSugared,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ReflectedType {
    enum memnames {
      getTypeReflection,
      getUnderlyingType,
      isSugared,
      desugar,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__UnaryTransformType {
    enum memnames {
      isSugared,
      desugar,
      getUnderlyingType,
      getBaseType,
      getUTTKind,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__TagType {
    enum memnames {
      getDecl,
      isBeingDefined,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__RecordType {
    enum memnames {
      getDecl,
      hasConstFields,
      isSugared,
      desugar,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__EnumType {
    enum memnames {
      getDecl,
      isSugared,
      desugar,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__AttributedType {
    enum memnames {
      getAttrKind,
      getModifiedType,
      getEquivalentType,
      isSugared,
      desugar,
      isQualifier,
      isMSTypeSpec,
      isCallingConv,
      getNullabilityAttrKind,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__TemplateTypeParmType {
    enum memnames {
      getDepth,
      getIndex,
      isParameterPack,
      getDecl,
      getIdentifier,
      isSugared,
      desugar,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__SubstTemplateTypeParmType {
    enum memnames {
      getReplacedParameter,
      getReplacementType,
      isSugared,
      desugar,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__SubstTemplateTypeParmPackType {
    enum memnames {
      getIdentifier,
      getReplacedParameter,
      isSugared,
      desugar,
      getArgumentPack,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__DeducedType {
    enum memnames {
      isSugared,
      desugar,
      getDeducedType,
      isDeduced,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__AutoType {
    enum memnames {
      isDecltypeAuto,
      getKeyword,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__DeducedTemplateSpecializationType {
    enum memnames {
      getTemplateName,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__TemplateSpecializationType {
    enum memnames {
      _this_,
      isCurrentInstantiation,
      isTypeAlias,
      getAliasedType,
      getTemplateName,
      getArgs,
      getNumArgs,
      getArg,
      template_arguments,
      isSugared,
      desugar,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__InjectedClassNameType {
    enum memnames {
      getInjectedSpecializationType,
      getInjectedTST,
      getTemplateName,
      getDecl,
      isSugared,
      desugar,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__TypeWithKeyword {
    enum memnames {
      getKeyword,
      getKeywordForTypeSpec,
      getTagTypeKindForTypeSpec,
      getKeywordForTagTypeKind,
      getTagTypeKindForKeyword,
      KeywordIsTagTypeKind,
      getKeywordName,
      getTagTypeKindName,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ElaboratedType {
    enum memnames {
      getQualifier,
      getNamedType,
      desugar,
      isSugared,
      getOwnedTagDecl,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__DependentNameType {
    enum memnames {
      getQualifier,
      getIdentifier,
      isSugared,
      desugar,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__DependentTemplateSpecializationType {
    enum memnames {
      _this_,
      getQualifier,
      getIdentifier,
      getArgs,
      getNumArgs,
      getArg,
      template_arguments,
      isSugared,
      desugar,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__PackExpansionType {
    enum memnames {
      getPattern,
      isSugared,
      desugar,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCTypeParamType {
    enum memnames {
      quals,
      qual_empty,
      getNumProtocols,
      getProtocol,
      getProtocols,
      isSugared,
      desugar,
      classof,
      getDecl,
    };
    static const unsigned _total_num_mems_ = getDecl + 1;
  }
  namespace clang__ObjCObjectType {
    enum memnames {
      quals,
      qual_empty,
      getNumProtocols,
      getProtocol,
      getProtocols,
      getBaseType,
      isObjCId,
      isObjCClass,
      isObjCUnqualifiedId,
      isObjCUnqualifiedClass,
      isObjCUnqualifiedIdOrClass,
      isObjCQualifiedId,
      isObjCQualifiedClass,
      getInterface,
      isSpecialized,
      isSpecializedAsWritten,
      isUnspecialized,
      isUnspecializedAsWritten,
      getTypeArgs,
      getTypeArgsAsWritten,
      isKindOfTypeAsWritten,
      isKindOfType,
      getSuperClassType,
      stripObjCKindOfTypeAndQuals,
      isSugared,
      desugar,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCInterfaceType {
    enum memnames {
      getDecl,
      isSugared,
      desugar,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCObjectPointerType {
    enum memnames {
      getPointeeType,
      getObjectType,
      getInterfaceType,
      getInterfaceDecl,
      isObjCIdType,
      isObjCClassType,
      isObjCIdOrClassType,
      isObjCQualifiedIdType,
      isObjCQualifiedClassType,
      isKindOfType,
      isSpecialized,
      isSpecializedAsWritten,
      isUnspecialized,
      isUnspecializedAsWritten,
      getTypeArgs,
      getTypeArgsAsWritten,
      quals,
      qual_empty,
      getNumProtocols,
      getProtocol,
      isSugared,
      desugar,
      getSuperClassType,
      stripObjCKindOfTypeAndQuals,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__AtomicType {
    enum memnames {
      getValueType,
      isSugared,
      desugar,
      Profile,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__PipeType {
    enum memnames {
      getElementType,
      isSugared,
      desugar,
      Profile,
      classof,
      isReadOnly,
    };
    static const unsigned _total_num_mems_ = isReadOnly + 1;
  }
  namespace clang__TypeSourceInfo {
    enum memnames {
      getType,
      getTypeLoc,
    };
    static const unsigned _total_num_mems_ = getTypeLoc + 1;
  }
  namespace clang__TranslationUnitDecl {
    enum memnames {
      getASTContext,
      getAnonymousNamespace,
      Create,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__PragmaCommentDecl {
    enum memnames {
      CreateDeserialized,
      getCommentKind,
      getArg,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__PragmaDetectMismatchDecl {
    enum memnames {
      CreateDeserialized,
      getName,
      getValue,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ExternCContextDecl {
    enum memnames {
      Create,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__NamedDecl {
    enum memnames {
      getIdentifier,
      getName,
      getNameAsString,
      printName,
      getDeclName,
      printQualifiedName,
      printQualifiedName1,
      getQualifiedNameAsString,
      getNameForDiagnostic,
      declarationReplaces,
      hasLinkage,
      isCXXClassMember,
      isCXXInstanceMember,
      getLinkageInternal,
      getFormalLinkage,
      hasExternalFormalLinkage,
      isExternallyVisible,
      isExternallyDeclarable,
      getVisibility,
      getLinkageAndVisibility,
      isLinkageValid,
      hasLinkageBeenComputed,
      getUnderlyingDecl,
      getMostRecentDecl,
      getObjCFStringFormattingFamily,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__LabelDecl {
    enum memnames {
      Create,
      Create1,
      CreateDeserialized,
      getStmt,
      isGnuLocal,
      getSourceRange,
      isMSAsmLabel,
      isResolvedMSAsmLabel,
      getMSAsmLabel,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__NamespaceDecl {
    enum memnames {
      getPreviousDecl,
      getFirstDecl,
      getMostRecentDecl,
      Create,
      CreateDeserialized,
      isAnonymousNamespace,
      isInline,
      getOriginalNamespace,
      isOriginalNamespace,
      getAnonymousNamespace,
      getCanonicalDecl,
      getSourceRange,
      getLocStart,
      getBeginLoc,
      getRBraceLoc,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ValueDecl {
    enum memnames {
      getType,
      isWeak,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__DeclaratorDecl {
    enum memnames {
      getTypeSourceInfo,
      getInnerLocStart,
      getOuterLocStart,
      getSourceRange,
      getLocStart,
      getBeginLoc,
      getQualifier,
      getQualifierLoc,
      getNumTemplateParameterLists,
      getTemplateParameterList,
      getTypeSpecStartLoc,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__EvaluatedStmt {
    enum memnames {
      WasEvaluated,
      IsEvaluating,
      CheckedICE,
      CheckingICE,
      IsICE,
      Value,
    };
    static const unsigned _total_num_mems_ = Value + 1;
  }
  namespace clang__VarDecl {
    enum memnames {
      getPreviousDecl,
      getFirstDecl,
      getMostRecentDecl,
      getStorageClassSpecifierString,
      Create,
      Create1,
      CreateDeserialized,
      getSourceRange,
      getStorageClass,
      getTSCSpec,
      getTLSKind,
      hasLocalStorage,
      isStaticLocal,
      hasExternalStorage,
      hasGlobalStorage,
      getStorageDuration,
      getLanguageLinkage,
      isExternC,
      isInExternCContext,
      isInExternCXXContext,
      isLocalVarDecl,
      isLocalVarDeclOrParm,
      isFunctionOrMethodVarDecl,
      isStaticDataMember,
      getCanonicalDecl,
      isThisDeclarationADefinition,
      isThisDeclarationADefinition1,
      hasDefinition,
      hasDefinition1,
      getActingDefinition,
      getDefinition,
      getDefinition1,
      isOutOfLine,
      isFileVarDecl,
      getAnyInitializer,
      getAnyInitializer1,
      hasInit,
      getInit,
      isUsableInConstantExpressions,
      ensureEvaluatedStmt,
      evaluateValue,
      getEvaluatedValue,
      isInitKnownICE,
      isInitICE,
      checkInitIsICE,
      getInitStyle,
      isDirectInit,
      isThisDeclarationADemotedDefinition,
      isExceptionVariable,
      isNRVOVariable,
      isCXXForRangeDecl,
      isObjCForDecl,
      isARCPseudoStrong,
      isInline,
      isInlineSpecified,
      isConstexpr,
      isInitCapture,
      isPreviousDeclInSameBlockScope,
      getTemplateInstantiationPattern,
      getInstantiatedFromStaticDataMember,
      getTemplateSpecializationKind,
      getPointOfInstantiation,
      getMemberSpecializationInfo,
      getDescribedVarTemplate,
      isKnownToBeDefined,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ImplicitParamDecl {
    enum memnames {
      Create,
      Create1,
      CreateDeserialized,
      getParameterKind,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ParmVarDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getSourceRange,
      isObjCMethodParameter,
      getFunctionScopeDepth,
      getFunctionScopeIndex,
      getObjCDeclQualifier,
      isKNRPromoted,
      getDefaultArg,
      getDefaultArgRange,
      getUninstantiatedDefaultArg,
      hasDefaultArg,
      hasUnparsedDefaultArg,
      hasUninstantiatedDefaultArg,
      hasInheritedDefaultArg,
      getOriginalType,
      isParameterPack,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__FunctionDecl {
    enum memnames {
      getPreviousDecl,
      getFirstDecl,
      getMostRecentDecl,
      Create,
      Create1,
      CreateDeserialized,
      getNameInfo,
      getNameForDiagnostic,
      getSourceRange,
      hasBody,
      hasBody1,
      hasTrivialBody,
      isDefined,
      isDefined1,
      getDefinition,
      getBody,
      getBody1,
      isThisDeclarationADefinition,
      doesThisDeclarationHaveABody,
      isVariadic,
      isVirtualAsWritten,
      isPure,
      isLateTemplateParsed,
      isTrivial,
      isTrivialForCall,
      isDefaulted,
      isExplicitlyDefaulted,
      hasImplicitReturnZero,
      hasPrototype,
      hasWrittenPrototype,
      hasInheritedPrototype,
      isConstexpr,
      instantiationIsPending,
      usesSEHTry,
      isDeleted,
      isDeletedAsWritten,
      isMain,
      isMSVCRTEntryPoint,
      isReservedGlobalPlacementOperator,
      isReplaceableGlobalAllocationFunction,
      isDestroyingOperatorDelete,
      getLanguageLinkage,
      isExternC,
      isInExternCContext,
      isInExternCXXContext,
      isGlobal,
      isNoReturn,
      hasSkippedBody,
      willHaveBody,
      isMetaprogram,
      isMultiVersion,
      isCPUDispatchMultiVersion,
      isCPUSpecificMultiVersion,
      getCanonicalDecl,
      getBuiltinID,
      parameters,
      param_empty,
      param_size,
      getNumParams,
      getParamDecl,
      getMinRequiredArguments,
      getReturnType,
      getReturnTypeSourceRange,
      getExceptionSpecSourceRange,
      getCallResultType,
      getUnusedResultAttr,
      hasUnusedResultAttr,
      getStorageClass,
      isInlineSpecified,
      isInlined,
      isInlineDefinitionExternallyVisible,
      isMSExternInline,
      doesDeclarationForceExternallyVisibleDefinition,
      isOverloadedOperator,
      getOverloadedOperator,
      getLiteralIdentifier,
      getInstantiatedFromMemberFunction,
      getTemplatedKind,
      getMemberSpecializationInfo,
      getDescribedFunctionTemplate,
      isFunctionTemplateSpecialization,
      getClassScopeSpecializationPattern,
      getTemplateSpecializationInfo,
      isImplicitlyInstantiable,
      isTemplateInstantiation,
      getTemplateInstantiationPattern,
      getPrimaryTemplate,
      getTemplateSpecializationArgs,
      getTemplateSpecializationArgsAsWritten,
      getDependentSpecializationInfo,
      getTemplateSpecializationKind,
      getPointOfInstantiation,
      isOutOfLine,
      getMemoryFunctionKind,
      getODRHash,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__FieldDecl {
    enum memnames {
      getFirstDecl,
      Create,
      Create1,
      CreateDeserialized,
      getFieldIndex,
      isMutable,
      isBitField,
      isUnnamedBitfield,
      isAnonymousStructOrUnion,
      getBitWidth,
      getBitWidthValue,
      isZeroLengthBitField,
      getInClassInitStyle,
      hasInClassInitializer,
      getInClassInitializer,
      hasCapturedVLAType,
      getCapturedVLAType,
      getParent,
      getSourceRange,
      getCanonicalDecl,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__EnumConstantDecl {
    enum memnames {
      getFirstDecl,
      Create,
      CreateDeserialized,
      getInitExpr,
      getInitVal,
      getSourceRange,
      getCanonicalDecl,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__IndirectFieldDecl {
    enum memnames {
      getFirstDecl,
      CreateDeserialized,
      chain,
      getChainingSize,
      getAnonField,
      getVarDecl,
      getCanonicalDecl,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__TypeDecl {
    enum memnames {
      getTypeForDecl,
      getLocStart,
      getBeginLoc,
      getSourceRange,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__TypedefNameDecl {
    enum memnames {
      getPreviousDecl,
      getFirstDecl,
      getMostRecentDecl,
      isModed,
      getTypeSourceInfo,
      getUnderlyingType,
      getCanonicalDecl,
      getAnonDeclWithTypedefName,
      isTransparentTag,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__TypedefDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getSourceRange,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__TypeAliasDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getSourceRange,
      getDescribedAliasTemplate,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__TagDecl {
    enum memnames {
      getPreviousDecl,
      getFirstDecl,
      getMostRecentDecl,
      getBraceRange,
      getInnerLocStart,
      getOuterLocStart,
      getSourceRange,
      getCanonicalDecl,
      isThisDeclarationADefinition,
      isCompleteDefinition,
      isCompleteDefinitionRequired,
      isBeingDefined,
      isEmbeddedInDeclarator,
      isFreeStanding,
      isDependentType,
      getDefinition,
      getKindName,
      getTagKind,
      isStruct,
      isInterface,
      isClass,
      isUnion,
      isEnum,
      hasNameForLinkage,
      getTypedefNameForAnonDecl,
      getQualifier,
      getQualifierLoc,
      getNumTemplateParameterLists,
      getTemplateParameterList,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__EnumDecl {
    enum memnames {
      getCanonicalDecl,
      getPreviousDecl,
      getMostRecentDecl,
      getDefinition,
      Create,
      CreateDeserialized,
      enumerators,
      getPromotionType,
      getIntegerType,
      getIntegerTypeSourceInfo,
      getIntegerTypeRange,
      getNumPositiveBits,
      getNumNegativeBits,
      isScoped,
      isScopedUsingClassTag,
      isFixed,
      isComplete,
      isClosed,
      isClosedFlag,
      isClosedNonFlag,
      getTemplateInstantiationPattern,
      getInstantiatedFromMemberEnum,
      getTemplateSpecializationKind,
      getMemberSpecializationInfo,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__RecordDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getPreviousDecl,
      getMostRecentDecl,
      hasFlexibleArrayMember,
      isAnonymousStructOrUnion,
      hasObjectMember,
      hasVolatileMember,
      hasLoadedFieldsFromExternalStorage,
      isNonTrivialToPrimitiveDefaultInitialize,
      isNonTrivialToPrimitiveCopy,
      isNonTrivialToPrimitiveDestroy,
      canPassInRegisters,
      getArgPassingRestrictions,
      isParamDestroyedInCallee,
      isInjectedClassName,
      isLambda,
      isCapturedRecord,
      getDefinition,
      fields,
      field_empty,
      classof,
      classofKind,
      isMsStruct,
      mayInsertExtraPadding,
      findFirstNamedDataMember,
    };
    static const unsigned _total_num_mems_ = findFirstNamedDataMember + 1;
  }
  namespace clang__FileScopeAsmDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getAsmLoc,
      getRParenLoc,
      getSourceRange,
      getAsmString,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__BlockDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getCaretLocation,
      isVariadic,
      getCompoundBody,
      getBody,
      getSignatureAsWritten,
      parameters,
      param_empty,
      param_size,
      getNumParams,
      getParamDecl,
      hasCaptures,
      getNumCaptures,
      captures,
      capturesCXXThis,
      blockMissingReturnType,
      isConversionFromLambda,
      doesNotEscape,
      capturesVariable,
      getBlockManglingNumber,
      getBlockManglingContextDecl,
      getSourceRange,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__BlockDecl__Capture {
    enum memnames {
      getVariable,
      isByRef,
      isNested,
      hasCopyExpr,
      getCopyExpr,
    };
    static const unsigned _total_num_mems_ = getCopyExpr + 1;
  }
  namespace clang__CapturedDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getBody,
      isNothrow,
      getNumParams,
      getParam,
      parameters,
      getContextParam,
      getContextParamPosition,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ImportDecl {
    enum memnames {
      CreateImplicit,
      CreateDeserialized,
      getImportedModule,
      getIdentifierLocs,
      getSourceRange,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ExportDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getExportLoc,
      getRBraceLoc,
      getLocEnd,
      getEndLoc,
      getSourceRange,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__EmptyDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__DeclGroup {
    enum memnames {
      Create,
      size,
      operator_sub,
    };
    static const unsigned _total_num_mems_ = operator_sub + 1;
  }
  namespace clang__DeclGroupRef {
    enum memnames {
      _this_,
      Create,
      isNull,
      isSingleDecl,
      isDeclGroup,
      getSingleDecl,
      getDeclGroup,
      getAsOpaquePtr,
      getFromOpaquePtr,
    };
    static const unsigned _total_num_mems_ = getFromOpaquePtr + 1;
  }
  namespace clang__Stmt {
    enum memnames {
      operator_new,
      operator_new1,
      operator_new2,
      operator_delete,
      operator_delete1,
      operator_delete2,
      operator_delete3,
      getStmtClass,
      getStmtClassName,
      getSourceRange,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      addStmtClass,
      EnableStatistics,
      PrintStats,
      dump,
      dump1,
      dump2,
      dump3,
      dumpColor,
      dumpPretty,
      printPretty,
      viewAST,
      IgnoreImplicit,
      IgnoreContainers,
      stripLabelLikeStatements,
      children,
      Profile,
    };
    static const unsigned _total_num_mems_ = Profile + 1;
  }
  namespace clang__Stmt__EmptyShell {
    enum memnames {
    };
    static const unsigned _total_num_mems_ = 0;
  }
  namespace clang__DeclStmt {
    enum memnames {
      isSingleDecl,
      getSingleDecl,
      getDeclGroup,
      getStartLoc,
      getEndLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      classof,
      decls,
    };
    static const unsigned _total_num_mems_ = decls + 1;
  }
  namespace clang__NullStmt {
    enum memnames {
      getSemiLoc,
      hasLeadingEmptyMacro,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CompoundStmt {
    enum memnames {
      CreateEmpty,
      body_empty,
      size,
      body,
      body_front,
      body_back,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getLBracLoc,
      getRBracLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__SwitchCase {
    enum memnames {
      getNextSwitchCase,
      getKeywordLoc,
      getColonLoc,
      getSubStmt,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CaseStmt {
    enum memnames {
      getCaseLoc,
      getEllipsisLoc,
      getColonLoc,
      getLHS,
      getRHS,
      getSubStmt,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__DefaultStmt {
    enum memnames {
      getSubStmt,
      getDefaultLoc,
      getColonLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__LabelStmt {
    enum memnames {
      getIdentLoc,
      getDecl,
      getName,
      getSubStmt,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__AttributedStmt {
    enum memnames {
      CreateEmpty,
      getAttrLoc,
      getAttrs,
      getSubStmt,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__IfStmt {
    enum memnames {
      getConditionVariable,
      getConditionVariableDeclStmt,
      getInit,
      getCond,
      getThen,
      getElse,
      getIfLoc,
      getElseLoc,
      isConstexpr,
      isObjCAvailabilityCheck,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__SwitchStmt {
    enum memnames {
      getConditionVariable,
      getConditionVariableDeclStmt,
      getInit,
      getCond,
      getBody,
      getSwitchCaseList,
      getSwitchLoc,
      isAllEnumCasesCovered,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__WhileStmt {
    enum memnames {
      getConditionVariable,
      getConditionVariableDeclStmt,
      getCond,
      getBody,
      getWhileLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__DoStmt {
    enum memnames {
      getCond,
      getBody,
      getDoLoc,
      getWhileLoc,
      getRParenLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ForStmt {
    enum memnames {
      getConditionVariable,
      getConditionVariableDeclStmt,
      getInit,
      getCond,
      getInc,
      getBody,
      getForLoc,
      getLParenLoc,
      getRParenLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__GotoStmt {
    enum memnames {
      getLabel,
      getGotoLoc,
      getLabelLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__IndirectGotoStmt {
    enum memnames {
      getGotoLoc,
      getStarLoc,
      getTarget,
      getConstantTarget,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ContinueStmt {
    enum memnames {
      getContinueLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__BreakStmt {
    enum memnames {
      getBreakLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ReturnStmt {
    enum memnames {
      getRetValue,
      getReturnLoc,
      getNRVOCandidate,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__AsmStmt {
    enum memnames {
      getAsmLoc,
      isSimple,
      isVolatile,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      generateAsmString,
      getNumOutputs,
      getOutputConstraint,
      isOutputPlusConstraint,
      getOutputExpr,
      getNumPlusOperands,
      getNumInputs,
      getInputConstraint,
      getInputExpr,
      getNumClobbers,
      getClobber,
      classof,
      inputs,
      outputs,
    };
    static const unsigned _total_num_mems_ = outputs + 1;
  }
  namespace clang__GCCAsmStmt {
    enum memnames {
      getRParenLoc,
      getAsmString,
      generateAsmString,
      getOutputIdentifier,
      getOutputName,
      getOutputConstraint,
      getOutputConstraintLiteral,
      getOutputExpr,
      getInputIdentifier,
      getInputName,
      getInputConstraint,
      getInputConstraintLiteral,
      getInputExpr,
      getNamedOperand,
      getClobber,
      getClobberStringLiteral,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__MSAsmStmt {
    enum memnames {
      getLBraceLoc,
      getEndLoc,
      hasBraces,
      getAsmString,
      generateAsmString,
      getOutputConstraint,
      getOutputExpr,
      getInputConstraint,
      getInputExpr,
      getAllConstraints,
      getClobbers,
      getAllExprs,
      getClobber,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__SEHExceptStmt {
    enum memnames {
      Create,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getExceptLoc,
      getEndLoc,
      getFilterExpr,
      getBlock,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__SEHFinallyStmt {
    enum memnames {
      Create,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getFinallyLoc,
      getEndLoc,
      getBlock,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__SEHTryStmt {
    enum memnames {
      Create,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getTryLoc,
      getEndLoc,
      getIsCXXTry,
      getTryBlock,
      getHandler,
      getExceptHandler,
      getFinallyHandler,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__SEHLeaveStmt {
    enum memnames {
      getLeaveLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CapturedStmt {
    enum memnames {
      CreateDeserialized,
      getCapturedStmt,
      getCapturedDecl,
      getCapturedRegionKind,
      getCapturedRecordDecl,
      capturesVariable,
      captures,
      capture_size,
      capture_inits,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getSourceRange,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CapturedStmt__Capture {
    enum memnames {
      getCaptureKind,
      getLocation,
      capturesThis,
      capturesVariable,
      capturesVariableByCopy,
      capturesVariableArrayType,
      getCapturedVar,
    };
    static const unsigned _total_num_mems_ = getCapturedVar + 1;
  }
  namespace clang__TemplateArgument {
    enum memnames {
      getEmptyPack,
      getKind,
      isNull,
      isDependent,
      isInstantiationDependent,
      containsUnexpandedParameterPack,
      isPackExpansion,
      getAsType,
      getAsDecl,
      getParamTypeForDecl,
      getNullPtrType,
      getAsTemplate,
      getAsTemplateOrTemplatePattern,
      getAsIntegral,
      getIntegralType,
      getNonTypeTemplateArgumentType,
      getAsExpr,
      pack_elements,
      pack_size,
      getPackAsArray,
      structurallyEquals,
      getPackExpansionPattern,
      print,
      dump,
      dump1,
      Profile,
    };
    static const unsigned _total_num_mems_ = Profile + 1;
  }
  namespace clang__TemplateArgumentLocInfo {
    enum memnames {
      getAsTypeSourceInfo,
      getAsExpr,
      getTemplateQualifierLoc,
      getTemplateNameLoc,
      getTemplateEllipsisLoc,
    };
    static const unsigned _total_num_mems_ = getTemplateEllipsisLoc + 1;
  }
  namespace clang__TemplateArgumentLoc {
    enum memnames {
      getLocation,
      getSourceRange,
      getArgument,
      getLocInfo,
      getTypeSourceInfo,
      getSourceExpression,
      getSourceDeclExpression,
      getSourceNullPtrExpression,
      getSourceIntegralExpression,
      getTemplateQualifierLoc,
      getTemplateNameLoc,
      getTemplateEllipsisLoc,
    };
    static const unsigned _total_num_mems_ = getTemplateEllipsisLoc + 1;
  }
  namespace clang__TemplateArgumentListInfo {
    enum memnames {
      getLAngleLoc,
      getRAngleLoc,
      size,
      getArgumentArray,
      arguments,
      operator_sub,
    };
    static const unsigned _total_num_mems_ = operator_sub + 1;
  }
  namespace clang__ASTTemplateArgumentListInfo {
    enum memnames {
      LAngleLoc,
      RAngleLoc,
      NumTemplateArgs,
      getTemplateArgs,
      arguments,
      operator_sub,
      Create,
    };
    static const unsigned _total_num_mems_ = Create + 1;
  }
  namespace clang__TypeLoc {
    enum memnames {
      getTypeLocClass,
      isNull,
      operator_bool,
      getFullDataSizeForType,
      getLocalAlignmentForType,
      getType,
      getTypePtr,
      getOpaqueData,
      getBeginLoc,
      getEndLoc,
      getSourceRange,
      getLocStart,
      getLocEnd,
      getLocalSourceRange,
      getFullDataSize,
      getNextTypeLoc,
      getUnqualifiedLoc,
      IgnoreParens,
      findExplicitQualifierLoc,
      initialize,
      operator_eq_eq,
      operator_not_eq,
      findNullabilityLoc,
    };
    static const unsigned _total_num_mems_ = findNullabilityLoc + 1;
  }
  namespace clang__UnqualTypeLoc {
    enum memnames {
      getTypePtr,
      getTypeLocClass,
    };
    static const unsigned _total_num_mems_ = getTypeLocClass + 1;
  }
  namespace clang__CommentOptions {
    enum memnames {
      ParseAllComments,
    };
    static const unsigned _total_num_mems_ = ParseAllComments + 1;
  }
  namespace clang__comments__CommandInfo {
    enum memnames {
      getID,
      Name,
      EndCommandName,
      ID,
      NumArgs,
      IsInlineCommand,
      IsBlockCommand,
      IsBriefCommand,
      IsReturnsCommand,
      IsParamCommand,
      IsTParamCommand,
      IsThrowsCommand,
      IsDeprecatedCommand,
      IsHeaderfileCommand,
      IsEmptyParagraphAllowed,
      IsVerbatimBlockCommand,
      IsVerbatimBlockEndCommand,
      IsVerbatimLineCommand,
      IsDeclarationCommand,
      IsFunctionDeclarationCommand,
      IsRecordLikeDetailCommand,
      IsRecordLikeDeclarationCommand,
      IsUnknownCommand,
    };
    static const unsigned _total_num_mems_ = IsUnknownCommand + 1;
  }
  namespace clang__comments__CommandTraits {
    enum memnames {
      getCommandInfo,
      getBuiltinCommandInfo,
    };
    static const unsigned _total_num_mems_ = getBuiltinCommandInfo + 1;
  }
  namespace llvm__Triple {
    enum memnames {
      operator_eq_eq,
      operator_not_eq,
      normalize,
      normalize1,
      getArch,
      getSubArch,
      getVendor,
      getOS,
      hasEnvironment,
      getEnvironment,
      getObjectFormat,
      getOSMajorVersion,
      getArchName,
      getVendorName,
      getOSName,
      getEnvironmentName,
      getOSAndEnvironmentName,
      isArch64Bit,
      isArch32Bit,
      isArch16Bit,
      isOSVersionLT,
      isOSVersionLT1,
      isMacOSXVersionLT,
      isMacOSX,
      isiOS,
      isTvOS,
      isWatchOS,
      isWatchABI,
      isOSDarwin,
      isSimulatorEnvironment,
      isOSNetBSD,
      isOSOpenBSD,
      isOSFreeBSD,
      isOSFuchsia,
      isOSDragonFly,
      isOSSolaris,
      isOSIAMCU,
      isOSUnknown,
      isGNUEnvironment,
      isOSContiki,
      isOSHaiku,
      isWindowsMSVCEnvironment,
      isKnownWindowsMSVCEnvironment,
      isWindowsCoreCLREnvironment,
      isWindowsItaniumEnvironment,
      isWindowsCygwinEnvironment,
      isWindowsGNUEnvironment,
      isOSCygMing,
      isOSMSVCRT,
      isOSWindows,
      isOSNaCl,
      isOSLinux,
      isOSKFreeBSD,
      isOSGlibc,
      isOSBinFormatELF,
      isOSBinFormatCOFF,
      isOSBinFormatMachO,
      isOSBinFormatWasm,
      isPS4CPU,
      isPS4,
      isAndroid,
      isAndroidVersionLT,
      isMusl,
      isNVPTX,
      isThumb,
      isARM,
      isAArch64,
      isMIPS32,
      isMIPS64,
      isMIPS,
      supportsCOMDAT,
      hasDefaultEmulatedTLS,
      get32BitArchVariant,
      get64BitArchVariant,
      getBigEndianArchVariant,
      getLittleEndianArchVariant,
      getARMCPUForArch,
      isLittleEndian,
      isCompatibleWith,
      merge,
      getArchTypeName,
      getArchTypePrefix,
      getVendorTypeName,
      getOSTypeName,
      getEnvironmentTypeName,
      getArchTypeForLLVMName,
    };
    static const unsigned _total_num_mems_ = getArchTypeForLLVMName + 1;
  }
  namespace clang__ObjCRuntime {
    enum memnames {
      getKind,
      getVersion,
      isNonFragile,
      isFragile,
      isGNUFamily,
      isNeXTFamily,
      allowsARC,
      hasNativeARC,
      hasOptimizedSetter,
      allowsWeak,
      hasNativeWeak,
      hasSubscripting,
      allowsSizeofAlignof,
      allowsPointerArithmetic,
      isSubscriptPointerArithmetic,
      hasTerminate,
      hasWeakClassImport,
      hasUnwindExceptions,
      hasAtomicCopyHelper,
      hasARCUnsafeClaimAutoreleasedReturnValue,
      hasEmptyCollections,
      getAsString,
      operator_eq_eq,
      operator_not_eq,
    };
    static const unsigned _total_num_mems_ = operator_not_eq + 1;
  }
  namespace clang__SanitizerSet {
    enum memnames {
      has,
      hasOneOf,
      empty,
      Mask,
    };
    static const unsigned _total_num_mems_ = Mask + 1;
  }
  namespace clang__LangOptionsBase {
    enum memnames {
      C99,
      C11,
      C17,
      MSVCCompat,
      MicrosoftExt,
      AsmBlocks,
      Borland,
      CPlusPlus,
      CPlusPlus11,
      CPlusPlus14,
      CPlusPlus17,
      CPlusPlus2a,
      ObjC1,
      ObjC2,
      ObjCDefaultSynthProperties,
      EncodeExtendedBlockSig,
      ObjCInferRelatedResultType,
      AppExt,
      Trigraphs,
      LineComment,
      Bool,
      Half,
      WChar,
      Char8,
      DeclSpecKeyword,
      DollarIdents,
      AsmPreprocessor,
      GNUMode,
      GNUKeywords,
      ImplicitInt,
      Digraphs,
      HexFloats,
      CXXOperatorNames,
      AppleKext,
      PascalStrings,
      WritableStrings,
      ConstStrings,
      LaxVectorConversions,
      AltiVec,
      ZVector,
      Exceptions,
      ObjCExceptions,
      CXXExceptions,
      DWARFExceptions,
      SjLjExceptions,
      SEHExceptions,
      ExternCNoUnwind,
      TraditionalCPP,
      RTTI,
      RTTIData,
      MSBitfields,
      Freestanding,
      NoBuiltin,
      NoMathBuiltin,
      GNUAsm,
      CoroutinesTS,
      RelaxedTemplateTemplateArgs,
      DoubleSquareBracketAttributes,
      ThreadsafeStatics,
      POSIXThreads,
      Blocks,
      EmitAllDecls,
      MathErrno,
      HeinousExtensions,
      Modules,
      ModulesTS,
      CompilingPCH,
      BuildingPCHWithObjectFile,
      ModulesDeclUse,
      ModulesSearchAll,
      ModulesStrictDeclUse,
      ModulesErrorRecovery,
      ImplicitModules,
      ModulesLocalVisibility,
      Optimize,
      OptimizeSize,
      Static,
      PackStruct,
      MaxTypeAlign,
      AlignDouble,
      PICLevel,
      PIE,
      GNUInline,
      NoInlineDefine,
      Deprecated,
      FastMath,
      FiniteMathOnly,
      UnsafeFPMath,
      ObjCGCBitmapPrint,
      AccessControl,
      CharIsSigned,
      WCharSize,
      WCharIsSigned,
      ShortEnums,
      OpenCL,
      OpenCLVersion,
      OpenCLCPlusPlus,
      OpenCLCPlusPlusVersion,
      NativeHalfType,
      NativeHalfArgsAndReturns,
      HalfArgsAndReturns,
      CUDA,
      HIP,
      OpenMP,
      OpenMPSimd,
      OpenMPUseTLS,
      OpenMPIsDevice,
      OpenMPCUDAMode,
      OpenMPHostCXXExceptions,
      RenderScript,
      CUDAIsDevice,
      CUDAAllowVariadicFunctions,
      CUDAHostDeviceConstexpr,
      CUDADeviceApproxTranscendentals,
      CUDARelocatableDeviceCode,
      SizedDeallocation,
      AlignedAllocation,
      AlignedAllocationUnavailable,
      NewAlignOverride,
      ConceptsTS,
      Reflection,
      ModulesCodegen,
      ModulesDebugInfo,
      ElideConstructors,
      DumpRecordLayouts,
      DumpRecordLayoutsSimple,
      DumpVTableLayouts,
      NoConstantCFStrings,
      InlineVisibilityHidden,
      ParseUnknownAnytype,
      DebuggerSupport,
      DebuggerCastResultToId,
      DebuggerObjCLiteral,
      SpellChecking,
      SinglePrecisionConstants,
      FastRelaxedMath,
      NoBitFieldTypeAlign,
      HexagonQdsp6Compat,
      ObjCAutoRefCount,
      ObjCWeakRuntime,
      ObjCWeak,
      ObjCSubscriptingLegacyRuntime,
      CFProtectionBranch,
      FakeAddressSpaceMap,
      IncludeDefaultHeader,
      DelayedTemplateParsing,
      BlocksRuntimeOptional,
      CompleteMemberPointers,
      ArrowDepth,
      InstantiationDepth,
      ConstexprCallDepth,
      ConstexprStepLimit,
      BracketDepth,
      NumLargeByValueCopy,
      MSCompatibilityVersion,
      VtorDispMode,
      ApplePragmaPack,
      RetainCommentsFromSystemHeaders,
      SanitizeAddressFieldPadding,
      XRayInstrument,
      XRayAlwaysEmitCustomEvents,
      XRayAlwaysEmitTypedEvents,
      ForceEmitVTables,
      AllowEditorPlaceholders,
      FunctionAlignment,
      FixedPoint,
      PaddingOnUnsignedFixedPoint,
    };
    static const unsigned _total_num_mems_ = PaddingOnUnsignedFixedPoint + 1;
  }
  namespace clang__LangOptions {
    enum memnames {
      Sanitize,
      ObjCRuntime,
      CommentOpts,
      IsHeaderFile,
      getCompilingModule,
      getMSPointerToMemberRepresentationMethod,
      getDefaultCallingConv,
      getDefaultFPContractMode,
      getAddressSpaceMapMangling,
      getGC,
      getValueVisibilityMode,
      getTypeVisibilityMode,
      getStackProtector,
      getSignedOverflowBehavior,
      getClangABICompat,
      isCompilingModule,
      trackLocalOwningModule,
      isSignedOverflowDefined,
      isSubscriptPointerArithmetic,
      isCompatibleWithMSVC,
      isNoBuiltinFunc,
      allowsNonTrivialObjCLifetimeQualifiers,
      assumeFunctionsAreConvergent,
      getOpenCLVersionTuple,
    };
    static const unsigned _total_num_mems_ = getOpenCLVersionTuple + 1;
  }
  namespace clang__FPOptions {
    enum memnames {
      allowFPContractWithinStatement,
      allowFPContractAcrossStatement,
      getInt,
    };
    static const unsigned _total_num_mems_ = getInt + 1;
  }
  namespace clang__PrinterHelper {
    enum memnames {
    };
    static const unsigned _total_num_mems_ = 0;
  }
  namespace clang__PrintingPolicy {
    enum memnames {
      Indentation,
      SuppressSpecifiers,
      SuppressTagKeyword,
      IncludeTagDefinition,
      SuppressScope,
      SuppressUnwrittenScope,
      SuppressInitializers,
      ConstantArraySizeAsWritten,
      AnonymousTagLocations,
      SuppressStrongLifetime,
      SuppressLifetimeQualifiers,
      SuppressTemplateArgsInCXXConstructors,
      Bool,
      Restrict,
      Alignof,
      UnderscoreAlignof,
      UseVoidForZeroParams,
      TerseOutput,
      PolishForDeclaration,
      Half,
      MSWChar,
      IncludeNewlines,
      MSVCFormatting,
      ConstantsAsWritten,
      SuppressImplicitBase,
      FullyQualifiedName,
    };
    static const unsigned _total_num_mems_ = FullyQualifiedName + 1;
  }
  namespace clang__SrcMgr__ContentCache {
    enum memnames {
      OrigEntry,
      ContentsEntry,
      SourceLineCache,
      NumLines,
      BufferOverridden,
      IsSystemFile,
      IsTransient,
      getBuffer,
      getSize,
      getSizeBytesMapped,
      getMemoryBufferKind,
      getRawBuffer,
      isBufferInvalid,
      shouldFreeBuffer,
    };
    static const unsigned _total_num_mems_ = shouldFreeBuffer + 1;
  }
  namespace clang__SrcMgr__FileInfo {
    enum memnames {
      get,
      getIncludeLoc,
      getContentCache,
      getFileCharacteristic,
      hasLineDirectives,
    };
    static const unsigned _total_num_mems_ = hasLineDirectives + 1;
  }
  namespace clang__SrcMgr__ExpansionInfo {
    enum memnames {
      getSpellingLoc,
      getExpansionLocStart,
      getExpansionLocEnd,
      isExpansionTokenRange,
      getExpansionLocRange,
      isMacroArgExpansion,
      isMacroBodyExpansion,
      isFunctionMacroExpansion,
      create,
      createForMacroArg,
      createForTokenSplit,
    };
    static const unsigned _total_num_mems_ = createForTokenSplit + 1;
  }
  namespace clang__SrcMgr__SLocEntry {
    enum memnames {
      getOffset,
      isExpansion,
      isFile,
      getFile,
      getExpansion,
      get,
      get1,
    };
    static const unsigned _total_num_mems_ = get1 + 1;
  }
  namespace clang__SourceManager {
    enum memnames {
      Retain,
      Release,
      getDiagnostics,
      getFileManager,
      userFilesAreVolatile,
      getMainFileID,
      getPreambleFileID,
      isFileOverridden,
      getBuffer,
      getBuffer1,
      getFileEntryForID,
      getFileEntryForSLocEntry,
      getBufferData,
      getNumCreatedFIDsForFileID,
      setNumCreatedFIDsForFileID,
      getFileID,
      getFilename,
      getLocForStartOfFile,
      getLocForEndOfFile,
      getIncludeLoc,
      getExpansionLoc,
      getFileLoc,
      getImmediateExpansionRange,
      getExpansionRange,
      getExpansionRange1,
      getExpansionRange2,
      getSpellingLoc,
      getImmediateSpellingLoc,
      getComposedLoc,
      getFileOffset,
      isMacroArgExpansion,
      isMacroBodyExpansion,
      isAtStartOfImmediateMacroExpansion,
      isAtEndOfImmediateMacroExpansion,
      isInSLocAddrSpace,
      isInSameSLocAddrSpace,
      getCharacterData,
      getColumnNumber,
      getSpellingColumnNumber,
      getExpansionColumnNumber,
      getPresumedColumnNumber,
      getLineNumber,
      getSpellingLineNumber,
      getExpansionLineNumber,
      getPresumedLineNumber,
      getBufferName,
      getFileCharacteristic,
      getPresumedLoc,
      isInMainFile,
      isWrittenInSameFile,
      isWrittenInMainFile,
      isInSystemHeader,
      isInExternCSystemHeader,
      isInSystemMacro,
      getFileIDSize,
      isInFileID,
      hasLineTable,
      getContentCacheSize,
      getDataStructureSizes,
      translateFileLineCol,
      translateFile,
      translateLineCol,
      getMacroArgExpandedLocation,
      isBeforeInTranslationUnit,
      isBeforeInSLocAddrSpace,
      isBeforeInSLocAddrSpace1,
      isPointWithin,
      hasFileInfo,
      PrintStats,
      dump,
      local_sloc_entry_size,
      getLocalSLocEntry,
      loaded_sloc_entry_size,
      getLoadedSLocEntry,
      getSLocEntry,
      getNextLocalOffset,
      isLoadedSourceLocation,
      isLocalSourceLocation,
      isLoadedFileID,
      isLocalFileID,
      getImmediateMacroCallerLoc,
      getTopMacroCallerLoc,
    };
    static const unsigned _total_num_mems_ = getTopMacroCallerLoc + 1;
  }
  namespace clang__RawComment {
    enum memnames {
      getKind,
      isInvalid,
      isMerged,
      isAttached,
      isTrailingComment,
      isAlmostTrailingComment,
      isOrdinary,
      isDocumentation,
      getRawText,
      getSourceRange,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getBriefText,
      getFormattedText,
    };
    static const unsigned _total_num_mems_ = getFormattedText + 1;
  }
  namespace clang__SanitizerBlacklist {
    enum memnames {
      isBlacklistedGlobal,
      isBlacklistedType,
      isBlacklistedFunction,
      isBlacklistedFile,
      isBlacklistedLocation,
    };
    static const unsigned _total_num_mems_ = isBlacklistedLocation + 1;
  }
  namespace clang__TargetCXXABI {
    enum memnames {
      getKind,
      isItaniumFamily,
      isMicrosoft,
      areMemberFunctionsAligned,
      areArgsDestroyedLeftToRightInCallee,
      hasConstructorVariants,
      hasPrimaryVBases,
      hasKeyFunctions,
      canKeyFunctionBeInline,
      getTailPaddingUseRules,
      operator_eq_eq,
      operator_not_eq,
    };
    static const unsigned _total_num_mems_ = operator_not_eq + 1;
  }
  namespace clang__OpenCLOptions {
    enum memnames {
      isKnown,
      isEnabled,
      isSupported,
      isSupportedCore,
      isSupportedExtension,
    };
    static const unsigned _total_num_mems_ = isSupportedExtension + 1;
  }
  namespace clang__TargetOptions {
    enum memnames {
      EABIVersion,
      SupportedOpenCLOptions,
      ForceEnableInt128,
      NVPTXUseShortPointers,
    };
    static const unsigned _total_num_mems_ = NVPTXUseShortPointers + 1;
  }
  namespace llvm__Type {
    enum memnames {
      print,
      dump,
      getTypeID,
      isVoidTy,
      isHalfTy,
      isFloatTy,
      isDoubleTy,
      isX86_FP80Ty,
      isFP128Ty,
      isPPC_FP128Ty,
      isFloatingPointTy,
      isX86_MMXTy,
      isFPOrFPVectorTy,
      isLabelTy,
      isMetadataTy,
      isTokenTy,
      isIntegerTy,
      isIntegerTy1,
      isIntOrIntVectorTy,
      isIntOrIntVectorTy1,
      isIntOrPtrTy,
      isFunctionTy,
      isStructTy,
      isArrayTy,
      isPointerTy,
      isPtrOrPtrVectorTy,
      isVectorTy,
      canLosslesslyBitCastTo,
      isEmptyTy,
      isFirstClassType,
      isSingleValueType,
      isAggregateType,
      getPrimitiveSizeInBits,
      getScalarSizeInBits,
      getFPMantissaWidth,
      getScalarType,
      subtypes,
      getContainedType,
      getNumContainedTypes,
      getIntegerBitWidth,
      getFunctionParamType,
      getFunctionNumParams,
      isFunctionVarArg,
      getStructName,
      getStructNumElements,
      getStructElementType,
      getSequentialElementType,
      getArrayNumElements,
      getArrayElementType,
      getVectorNumElements,
      getVectorElementType,
      getPointerElementType,
      getPointerAddressSpace,
      getPointerTo,
    };
    static const unsigned _total_num_mems_ = getPointerTo + 1;
  }
  namespace llvm__IntegerType {
    enum memnames {
      getBitWidth,
      getBitMask,
      getSignBit,
      isPowerOf2ByteWidth,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace llvm__CompositeType {
    enum memnames {
      getTypeAtIndex,
      indexValid,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace llvm__StructType {
    enum memnames {
      isPacked,
      isLiteral,
      isOpaque,
      hasName,
      getName,
      isValidElementType,
      elements,
      isLayoutIdentical,
      getNumElements,
      getElementType,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace llvm__PointerType {
    enum memnames {
      get,
      getUnqual,
      getElementType,
      isValidElementType,
      isLoadableOrStorableType,
      getAddressSpace,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace llvm__DataLayout {
    enum memnames {
      operator_eq_eq,
      operator_not_eq,
      isLittleEndian,
      isBigEndian,
      isDefault,
      isLegalInteger,
      isIllegalInteger,
      exceedsNaturalStackAlignment,
      getStackAlignment,
      getAllocaAddrSpace,
      getProgramAddressSpace,
      hasMicrosoftFastStdCallMangling,
      doNotMangleLeadingQuestionMark,
      hasLinkerPrivateGlobalPrefix,
      getLinkerPrivateGlobalPrefix,
      getGlobalPrefix,
      getPrivateGlobalPrefix,
      getManglingComponent,
      fitsInLegalInteger,
      getPointerABIAlignment,
      getPointerPrefAlignment,
      getPointerSize,
      getIndexSize,
      getNonIntegralAddressSpaces,
      isNonIntegralPointerType,
      isNonIntegralPointerType1,
      getPointerSizeInBits,
      getIndexSizeInBits,
      getPointerTypeSizeInBits,
      getIndexTypeSizeInBits,
      getPointerTypeSize,
      getTypeSizeInBits,
      getTypeStoreSize,
      getTypeStoreSizeInBits,
      getTypeAllocSize,
      getTypeAllocSizeInBits,
      getABITypeAlignment,
      getABIIntegerTypeAlignment,
      getPrefTypeAlignment,
      getPreferredTypeAlignmentShift,
      getIntPtrType,
      getLargestLegalIntTypeSizeInBits,
      getIndexType,
      getStructLayout,
    };
    static const unsigned _total_num_mems_ = getStructLayout + 1;
  }
  namespace llvm__StructLayout {
    enum memnames {
      getSizeInBytes,
      getSizeInBits,
      getAlignment,
      hasPadding,
      getElementContainingOffset,
      getElementOffset,
      getElementOffsetInBits,
    };
    static const unsigned _total_num_mems_ = getElementOffsetInBits + 1;
  }
  namespace clang__TargetInfo {
    enum memnames {
      Retain,
      Release,
      getTargetOpts,
      getSizeType,
      getSignedSizeType,
      getIntMaxType,
      getUIntMaxType,
      getPtrDiffType,
      getUnsignedPtrDiffType,
      getIntPtrType,
      getUIntPtrType,
      getWCharType,
      getWIntType,
      getChar16Type,
      getChar32Type,
      getInt64Type,
      getUInt64Type,
      getSigAtomicType,
      getProcessIDType,
      getCorrespondingUnsignedType,
      getTypeWidth,
      getIntTypeByWidth,
      getLeastIntTypeByWidth,
      getRealTypeByWidth,
      getTypeAlign,
      isTypeSigned,
      getPointerWidth,
      getPointerAlign,
      getMaxPointerWidth,
      getNullPointerValue,
      getBoolWidth,
      getBoolAlign,
      getCharWidth,
      getCharAlign,
      getShortWidth,
      getShortAlign,
      getIntWidth,
      getIntAlign,
      getLongWidth,
      getLongAlign,
      getLongLongWidth,
      getLongLongAlign,
      getShortAccumWidth,
      getShortAccumAlign,
      getAccumWidth,
      getAccumAlign,
      getLongAccumWidth,
      getLongAccumAlign,
      getShortFractWidth,
      getShortFractAlign,
      getFractWidth,
      getFractAlign,
      getLongFractWidth,
      getLongFractAlign,
      getShortAccumScale,
      getShortAccumIBits,
      getAccumScale,
      getAccumIBits,
      getLongAccumScale,
      getLongAccumIBits,
      getUnsignedShortAccumScale,
      getUnsignedShortAccumIBits,
      getUnsignedAccumScale,
      getUnsignedAccumIBits,
      getUnsignedLongAccumScale,
      getUnsignedLongAccumIBits,
      getShortFractScale,
      getFractScale,
      getLongFractScale,
      getUnsignedShortFractScale,
      getUnsignedFractScale,
      getUnsignedLongFractScale,
      hasInt128Type,
      hasLegalHalfType,
      hasFloat128Type,
      getSuitableAlign,
      getDefaultAlignForAttributeAligned,
      getMinGlobalAlign,
      getNewAlign,
      getWCharWidth,
      getWCharAlign,
      getChar16Width,
      getChar16Align,
      getChar32Width,
      getChar32Align,
      getHalfWidth,
      getHalfAlign,
      getFloatWidth,
      getFloatAlign,
      getDoubleWidth,
      getDoubleAlign,
      getLongDoubleWidth,
      getLongDoubleAlign,
      getFloat128Width,
      getFloat128Align,
      useFloat128ManglingForLongDouble,
      getFloatEvalMethod,
      getLargeArrayMinWidth,
      getLargeArrayAlign,
      getMaxAtomicPromoteWidth,
      getMaxAtomicInlineWidth,
      hasBuiltinAtomic,
      getMaxVectorAlign,
      getSimdDefaultAlign,
      getIntMaxTWidth,
      getUnwindWordWidth,
      getRegisterWidth,
      getMCountName,
      useSignedCharForObjCBool,
      useBitFieldTypeAlignment,
      useZeroLengthBitfieldAlignment,
      getZeroLengthBitfieldBoundary,
      useExplicitBitFieldAlignment,
      hasAlignMac68kSupport,
      getTypeName,
      getTypeConstantSuffix,
      getTypeFormatModifier,
      useObjCFPRetForRealType,
      useObjCFP2RetForComplexLongDouble,
      useFP16ConversionIntrinsics,
      useAddressSpaceMapMangling,
      isCLZForZeroUndef,
      getBuiltinVaListKind,
      hasBuiltinMSVaList,
      isRenderScriptTarget,
      isValidClobber,
      isValidGCCRegisterName,
      getNormalizedGCCRegisterName,
      getConstraintRegister,
      validateOutputConstraint,
      validateOutputSize,
      validateInputSize,
      getClobbers,
      isNan2008,
      getTriple,
      getDataLayout,
      hasProtectedVisibility,
      isValidSectionSpecifier,
      getABI,
      getCXXABI,
      isValidCPUName,
      isValidFeatureName,
      hasFeature,
      supportsMultiVersioning,
      validateCpuSupports,
      multiVersionSortPriority,
      validateCpuIs,
      validateCPUSpecificCPUDispatch,
      CPUSpecificManglingCharacter,
      getRegParmMax,
      isTLSSupported,
      getMaxTLSAlign,
      isVLASupported,
      isSEHTrySupported,
      hasNoAsmVariants,
      getEHDataRegisterNumber,
      getStaticInitSectionSpecifier,
      getPlatformName,
      getPlatformMinVersion,
      isBigEndian,
      isLittleEndian,
      getDefaultCallingConv,
      checkCallingConvention,
      getCallingConvKind,
      hasSjLjLowering,
      checkCFProtectionBranchSupported,
      checkCFProtectionReturnSupported,
      allowsLargerPreferedTypeAlignment,
      getSupportedOpenCLOpts,
      getOpenCLTypeAddrSpace,
      getVtblPtrAddressSpace,
      validateTarget,
    };
    static const unsigned _total_num_mems_ = validateTarget + 1;
  }
  namespace clang__TargetInfo__ConstraintInfo {
    enum memnames {
      Flags,
      TiedOperand,
      isReadWrite,
      allowsRegister,
      allowsMemory,
      hasMatchingInput,
      hasTiedOperand,
      getTiedOperand,
      requiresImmediateConstant,
      isValidAsmImmediate,
    };
    static const unsigned _total_num_mems_ = isValidAsmImmediate + 1;
  }
  namespace clang__XRayFunctionFilter {
    enum memnames {
      shouldImbueFunction,
      shouldImbueFunctionsInFile,
      shouldImbueLocation,
    };
    static const unsigned _total_num_mems_ = shouldImbueLocation + 1;
  }
  namespace clang__TypeInfo {
    enum memnames {
      Width,
      Align,
      AlignIsRequired,
    };
    static const unsigned _total_num_mems_ = AlignIsRequired + 1;
  }
  namespace clang__ASTContext {
    enum memnames {
      Retain,
      Release,
      Idents,
      Selectors,
      getPrintingPolicy,
      getSourceManager,
      Allocate,
      Deallocate,
      getASTAllocatedMemory,
      getSideTableAllocatedMemory,
      getTargetInfo,
      getAuxTargetInfo,
      getIntTypeForBitwidth,
      getRealTypeForBitwidth,
      AtomicUsesUnsupportedLibcall,
      getLangOpts,
      getSanitizerBlacklist,
      getXRayFilter,
      getDiagnostics,
      getFullLoc,
      CommentsLoaded,
      getRawCommentForDeclNoCache,
      getRawCommentForAnyRedecl,
      getCommentCommandTraits,
      overridden_methods_size,
      getNextLocalImport,
      local_imports,
      getTranslationUnitDecl,
      getExternCContextDecl,
      getMakeIntegerSeqDecl,
      getTypePackElementDecl,
      AutoDeductTy,
      AutoRRefDeductTy,
      VaListTagDecl,
      getExternalSource,
      PrintStats,
      getInt128Decl,
      getUInt128Decl,
      getAddrSpaceQualType,
      removeAddrSpaceQualType,
      getObjCGCQualType,
      getRestrictType,
      getVolatileType,
      getConstType,
      getComplexType,
      getPointerType,
      getAdjustedType,
      getDecayedType,
      getAtomicType,
      getBlockPointerType,
      getBlockDescriptorType,
      getReadPipeType,
      getWritePipeType,
      getBlockDescriptorExtendedType,
      getOpenCLTypeKind,
      getOpenCLTypeAddrSpace,
      getLValueReferenceType,
      getRValueReferenceType,
      getMemberPointerType,
      getVariableArrayType,
      getDependentSizedArrayType,
      getIncompleteArrayType,
      getConstantArrayType,
      getVariableArrayDecayedType,
      getVectorType,
      getDependentVectorType,
      getExtVectorType,
      getDependentSizedExtVectorType,
      getDependentAddressSpaceType,
      getFunctionNoProtoType,
      getFunctionNoProtoType1,
      adjustStringLiteralBaseType,
      getTypeDeclType,
      getTypedefType,
      getRecordType,
      getEnumType,
      getInjectedClassNameType,
      getSubstTemplateTypeParmType,
      getTemplateTypeParmType,
      getTemplateSpecializationType,
      getTemplateSpecializationTypeInfo,
      getParenType,
      getElaboratedType,
      getDependentNameType,
      getDependentTemplateSpecializationType,
      getObjCInterfaceType,
      getObjCObjectType,
      getObjCObjectPointerType,
      getTypeOfExprType,
      getTypeOfType,
      getDecltypeType,
      getReflectedType,
      getUnaryTransformType,
      getAutoType,
      getAutoDeductType,
      getAutoRRefDeductType,
      getDeducedTemplateSpecializationType,
      getTagDeclType,
      getWCharType,
      getWideCharType,
      getSignedWCharType,
      getUnsignedWCharType,
      getWIntType,
      getIntPtrType,
      getUIntPtrType,
      getPointerDiffType,
      getUnsignedPointerDiffType,
      getProcessIDType,
      getCFConstantStringType,
      getObjCSuperType,
      getRawCFConstantStringType,
      getCFConstantStringDecl,
      getCFConstantStringTagDecl,
      getObjCConstantStringInterface,
      getObjCNSStringType,
      getObjCIdRedefinitionType,
      getObjCClassRedefinitionType,
      getObjCSelRedefinitionType,
      getBoolName,
      getMakeIntegerSeqName,
      getTypePackElementName,
      getFILEType,
      getjmp_bufType,
      getsigjmp_bufType,
      getucontext_tType,
      getLogicalOperationType,
      getLegacyIntegralTypeEncoding,
      getObjCEncodingForFunctionDecl,
      getObjCEncodingForMethodDecl,
      getObjCEncodingForBlock,
      getObjCEncodingForPropertyDecl,
      ProtocolCompatibleWithProtocol,
      getObjCPropertyImplDeclForPropertyDecl,
      getObjCEncodingTypeSize,
      getObjCIdDecl,
      getObjCIdType,
      getObjCSelDecl,
      getObjCSelType,
      getObjCClassDecl,
      getObjCClassType,
      getObjCProtocolDecl,
      getBOOLDecl,
      getBOOLType,
      getObjCProtoType,
      getBuiltinVaListDecl,
      getBuiltinVaListType,
      getVaListTagDecl,
      getBuiltinMSVaListDecl,
      getBuiltinMSVaListType,
      canBuiltinBeRedeclared,
      getCVRQualifiedType,
      getQualifiedType,
      getQualifiedType1,
      getQualifiedType2,
      getUnqualifiedObjCPointerType,
      getFixedPointScale,
      getFixedPointIBits,
      getNameForTemplate,
      getOverloadedTemplateName,
      getQualifiedTemplateName,
      getDependentTemplateName,
      getDependentTemplateName1,
      getSubstTemplateTemplateParm,
      getSubstTemplateTemplateParmPack,
      getObjCGCAttrKind,
      isObjCNSObjectType,
      getTypeInfo,
      getTypeInfo1,
      getOpenMPDefaultSimdAlign,
      getTypeSize,
      getTypeSize1,
      getCharWidth,
      toCharUnitsFromBits,
      toBits,
      getTypeSizeInChars,
      getTypeSizeInChars1,
      getTypeAlign,
      getTypeAlign1,
      getTypeUnadjustedAlign,
      getTypeUnadjustedAlign1,
      getTypeAlignIfKnown,
      getTypeAlignInChars,
      getTypeAlignInChars1,
      getTypeUnadjustedAlignInChars,
      getTypeUnadjustedAlignInChars1,
      isAlignmentRequired,
      isAlignmentRequired1,
      getPreferredTypeAlign,
      getTargetDefaultAlignForAttributeAligned,
      getAlignOfGlobalVar,
      getAlignOfGlobalVarInChars,
      getDeclAlign,
      DumpRecordLayout,
      getOffsetOfBaseWithVBPtr,
      getFieldOffset,
      lookupFieldBitOffset,
      isNearlyEmpty,
      CountNonClassIvars,
      hasUniqueObjectRepresentations,
      getCanonicalType,
      hasSameType,
      hasSameType1,
      hasSameUnqualifiedType,
      hasSameNullabilityTypeQualifier,
      getCanonicalNestedNameSpecifier,
      getDefaultCallingConvention,
      getCanonicalTemplateName,
      getCanonicalTemplateArgument,
      getAsArrayType,
      getAsConstantArrayType,
      getAsVariableArrayType,
      getAsIncompleteArrayType,
      getAsDependentSizedArrayType,
      getBaseElementType,
      getBaseElementType1,
      getConstantArrayElementCount,
      getAdjustedParameterType,
      getSignatureParameterType,
      getExceptionObjectType,
      getArrayDecayedType,
      getPromotedIntegerType,
      getInnerObjCOwnership,
      isPromotableBitField,
      getIntegerTypeOrder,
      getFloatingTypeOrder,
      getFloatingTypeOfSizeWithinDomain,
      getTargetAddressSpace,
      getTargetAddressSpace1,
      getTargetAddressSpace2,
      getTargetNullPointerValue,
      addressSpaceMapManglingFor,
      isObjCIdType,
      isObjCClassType,
      isObjCSelType,
      getIntWidth,
      getCorrespondingUnsignedType,
      getCorrespondingSaturatedType,
      MakeIntValue,
      getObjCMethodRedeclaration,
      getObjContainingInterface,
      CreateTypeSourceInfo,
      getTrivialTypeSourceInfo,
      GetGVALinkageForFunction,
      getManglingNumber,
      getStaticLocalNumber,
      getParameterIndex,
      isMSStaticDataMemberInlineDefinition,
      getInlineVariableDefinitionKind,
    };
    static const unsigned _total_num_mems_ = getInlineVariableDefinitionKind + 1;
  }
  namespace clang__DeclAccessPair {
    enum memnames {
      make,
      getDecl,
      getAccess,
      operator_arrow,
    };
    static const unsigned _total_num_mems_ = operator_arrow + 1;
  }
  namespace clang__UnresolvedSetIterator {
    enum memnames {
      operator_plus,
      operator_plus1,
      operator_minus,
      operator_not_eq,
      operator_gr,
      operator_less_eq,
      operator_gr_eq,
      operator_arrow,
      operator_minus1,
      operator_eq_eq,
      operator_less,
      operator_star,
      getDecl,
      setDecl,
      getAccess,
      getPair,
    };
    static const unsigned _total_num_mems_ = getPair + 1;
  }
  namespace clang__UnresolvedSetImpl {
    enum memnames {
      _this_,
      empty,
      size,
      operator_sub,
    };
    static const unsigned _total_num_mems_ = operator_sub + 1;
  }
  namespace clang__Expr {
    enum memnames {
      getType,
      isValueDependent,
      isTypeDependent,
      isInstantiationDependent,
      containsUnexpandedParameterPack,
      getExprLoc,
      isUnusedResultAWarning,
      isLValue,
      isRValue,
      isXValue,
      isGLValue,
      ClassifyLValue,
      isModifiableLvalue,
      Classify,
      ClassifyModifiable,
      getValueKindForType,
      getValueKind,
      getObjectKind,
      isOrdinaryOrBitFieldObject,
      refersToBitField,
      getSourceBitField,
      getReferencedDeclOfCallee,
      getObjCProperty,
      isObjCSelfExpr,
      refersToVectorElement,
      refersToGlobalRegisterVar,
      hasPlaceholderType,
      hasPlaceholderType1,
      isKnownToHaveBooleanValue,
      isIntegerConstantExpr,
      isIntegerConstantExpr1,
      isCXX98IntegralConstantExpr,
      isCXX11ConstantExpr,
      isConstantInitializer,
      EvaluateAsRValue,
      EvaluateAsInt,
      EvaluateAsString,
      EvaluateAsVoid,
      EvaluateAsFloat,
      isEvaluatable,
      HasSideEffects,
      hasNonTrivialCall,
      EvaluateForOverflow,
      EvaluateAsLValue,
      EvaluateAsConstantExpr,
      isNullPointerConstant,
      isOBJCGCCandidate,
      isBoundMemberFunction,
      findBoundMemberType,
      IgnoreImplicit,
      IgnoreConversionOperator,
      IgnoreParenImpCasts,
      IgnoreParenLValueCasts,
      ignoreParenBaseCasts,
      isDefaultArgument,
      isTemporaryObject,
      isImplicitCXXThis,
      IgnoreImpCasts,
      IgnoreParens,
      IgnoreParenCasts,
      IgnoreCasts,
      IgnoreParenNoopCasts,
      getBestDynamicClassType,
      getBestDynamicClassTypeExpr,
      skipRValueSubobjectAdjustments,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__Expr__Classification {
    enum memnames {
      getKind,
      getModifiable,
      isLValue,
      isXValue,
      isGLValue,
      isPRValue,
      isRValue,
      isModifiable,
      makeSimpleLValue,
    };
    static const unsigned _total_num_mems_ = makeSimpleLValue + 1;
  }
  namespace clang__Expr__EvalStatus {
    enum memnames {
      HasSideEffects,
      HasUndefinedBehavior,
      hasSideEffects,
    };
    static const unsigned _total_num_mems_ = hasSideEffects + 1;
  }
  namespace clang__Expr__EvalResult {
    enum memnames {
      isGlobalLValue,
    };
    static const unsigned _total_num_mems_ = isGlobalLValue + 1;
  }
  namespace clang__OpaqueValueExpr {
    enum memnames {
      findInCopyConstruct,
      getLocation,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getExprLoc,
      children,
      getSourceExpr,
      isUnique,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__DeclRefExpr {
    enum memnames {
      Create,
      Create1,
      CreateEmpty,
      getDecl,
      getNameInfo,
      getLocation,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      hasQualifier,
      getQualifierLoc,
      getQualifier,
      getFoundDecl,
      hasTemplateKWAndArgsInfo,
      getTemplateKeywordLoc,
      getLAngleLoc,
      getRAngleLoc,
      hasTemplateKeyword,
      hasExplicitTemplateArgs,
      copyTemplateArgumentsInto,
      getTemplateArgs,
      getNumTemplateArgs,
      template_arguments,
      hadMultipleCandidates,
      refersToEnclosingVariableOrCapture,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__PredefinedExpr {
    enum memnames {
      getIdentType,
      getLocation,
      getFunctionName,
      getIdentTypeName,
      ComputeName,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__APIntStorage {
    enum memnames {
    };
    static const unsigned _total_num_mems_ = 0;
  }
  namespace clang__IntegerLiteral {
    enum memnames {
      Create,
      Create1,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getLocation,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__FixedPointLiteral {
    enum memnames {
      CreateFromRawInt,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getLocation,
      classof,
      getValueAsString,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__CharacterLiteral {
    enum memnames {
      getLocation,
      getKind,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getValue,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__FloatingLiteral {
    enum memnames {
      Create,
      Create1,
      isExact,
      getValueAsApproximateDouble,
      getLocation,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__ImaginaryLiteral {
    enum memnames {
      getSubExpr,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__StringLiteral {
    enum memnames {
      CreateEmpty,
      getString,
      getBytes,
      outputString,
      getCodeUnit,
      getByteLength,
      getLength,
      getCharByteWidth,
      getKind,
      isAscii,
      isWide,
      isUTF8,
      isUTF16,
      isUTF32,
      isPascal,
      containsNonAscii,
      containsNonAsciiOrNull,
      getNumConcatenated,
      getStrTokenLoc,
      getLocationOfByte,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__ParenExpr {
    enum memnames {
      getSubExpr,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getLParen,
      getRParen,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__UnaryOperator {
    enum memnames {
      getOpcode,
      getSubExpr,
      getOperatorLoc,
      canOverflow,
      isPostfix,
      isPrefix,
      isPrefix1,
      isPostfix1,
      isIncrementOp,
      isIncrementOp1,
      isDecrementOp,
      isDecrementOp1,
      isIncrementDecrementOp,
      isIncrementDecrementOp1,
      isArithmeticOp,
      isArithmeticOp1,
      getOpcodeStr,
      getOverloadedOpcode,
      getOverloadedOperator,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getExprLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__OffsetOfNode {
    enum memnames {
      getKind,
      getArrayExprIndex,
      getField,
      getFieldName,
      getBase,
      getSourceRange,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
    };
    static const unsigned _total_num_mems_ = getEndLoc + 1;
  }
  namespace clang__OffsetOfExpr {
    enum memnames {
      CreateEmpty,
      getOperatorLoc,
      getRParenLoc,
      getTypeSourceInfo,
      getComponent,
      getNumComponents,
      getIndexExpr,
      getNumExpressions,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__UnaryExprOrTypeTraitExpr {
    enum memnames {
      getKind,
      isArgumentType,
      getArgumentType,
      getArgumentTypeInfo,
      getArgumentExpr,
      getTypeOfArgument,
      getOperatorLoc,
      getRParenLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__ArraySubscriptExpr {
    enum memnames {
      getLHS,
      getRHS,
      getBase,
      getIdx,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getRBracketLoc,
      getExprLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__CallExpr {
    enum memnames {
      getCallee,
      getCalleeDecl,
      getDirectCallee,
      getNumArgs,
      getArgs,
      getArg,
      arguments,
      getNumCommas,
      getBuiltinCallee,
      isUnevaluatedBuiltinCall,
      getCallReturnType,
      getRParenLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      isBuiltinAssumeFalse,
      isCallToStdMove,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__MemberExpr {
    enum memnames {
      Create,
      getBase,
      getMemberDecl,
      getFoundDecl,
      hasQualifier,
      getQualifierLoc,
      getQualifier,
      getTemplateKeywordLoc,
      getLAngleLoc,
      getRAngleLoc,
      hasTemplateKeyword,
      hasExplicitTemplateArgs,
      copyTemplateArgumentsInto,
      getTemplateArgs,
      getNumTemplateArgs,
      template_arguments,
      getMemberNameInfo,
      getOperatorLoc,
      isArrow,
      getMemberLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getExprLoc,
      isImplicitAccess,
      hadMultipleCandidates,
      performsVirtualDispatch,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__CompoundLiteralExpr {
    enum memnames {
      getInitializer,
      isFileScope,
      getLParenLoc,
      getTypeSourceInfo,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__CastExpr {
    enum memnames {
      getCastKind,
      getCastKindName,
      getCastKindName1,
      getSubExpr,
      getSubExprAsWritten,
      getConversionFunction,
      path_empty,
      path_size,
      getTargetUnionField,
      getTargetFieldForToUnionCast,
      getTargetFieldForToUnionCast1,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__ImplicitCastExpr {
    enum memnames {
      isPartOfExplicitCast,
      CreateEmpty,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ExplicitCastExpr {
    enum memnames {
      getTypeInfoAsWritten,
      getTypeAsWritten,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CStyleCastExpr {
    enum memnames {
      CreateEmpty,
      getLParenLoc,
      getRParenLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__BinaryOperator {
    enum memnames {
      getExprLoc,
      getOperatorLoc,
      getOpcode,
      getLHS,
      getRHS,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getOpcodeStr,
      getOpcodeStr1,
      getOverloadedOpcode,
      getOverloadedOperator,
      isPtrMemOp,
      isMultiplicativeOp,
      isMultiplicativeOp1,
      isAdditiveOp,
      isAdditiveOp1,
      isShiftOp,
      isShiftOp1,
      isBitwiseOp,
      isBitwiseOp1,
      isRelationalOp,
      isRelationalOp1,
      isEqualityOp,
      isEqualityOp1,
      isComparisonOp,
      isComparisonOp1,
      negateComparisonOp,
      reverseComparisonOp,
      isLogicalOp,
      isLogicalOp1,
      isAssignmentOp,
      isAssignmentOp1,
      isCompoundAssignmentOp,
      isCompoundAssignmentOp1,
      getOpForCompoundAssignment,
      isShiftAssignOp,
      isShiftAssignOp1,
      isNullPointerArithmeticExtension,
      classof,
      children,
      getFPFeatures,
      isFPContractableWithinStatement,
    };
    static const unsigned _total_num_mems_ = isFPContractableWithinStatement + 1;
  }
  namespace clang__CompoundAssignOperator {
    enum memnames {
      getComputationLHSType,
      getComputationResultType,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__AbstractConditionalOperator {
    enum memnames {
      getCond,
      getTrueExpr,
      getFalseExpr,
      getQuestionLoc,
      getColonLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ConditionalOperator {
    enum memnames {
      getCond,
      getTrueExpr,
      getFalseExpr,
      getLHS,
      getRHS,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__BinaryConditionalOperator {
    enum memnames {
      getCommon,
      getOpaqueValue,
      getCond,
      getTrueExpr,
      getFalseExpr,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__AddrLabelExpr {
    enum memnames {
      getAmpAmpLoc,
      getLabelLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getLabel,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__StmtExpr {
    enum memnames {
      getSubStmt,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getLParenLoc,
      getRParenLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__ShuffleVectorExpr {
    enum memnames {
      getBuiltinLoc,
      getRParenLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      getNumSubExprs,
      getExpr,
      getShuffleMaskIdx,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__ConvertVectorExpr {
    enum memnames {
      getSrcExpr,
      getTypeSourceInfo,
      getBuiltinLoc,
      getRParenLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__ChooseExpr {
    enum memnames {
      isConditionTrue,
      isConditionDependent,
      getChosenSubExpr,
      getCond,
      getLHS,
      getRHS,
      getBuiltinLoc,
      getRParenLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__GNUNullExpr {
    enum memnames {
      getTokenLocation,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__VAArgExpr {
    enum memnames {
      getSubExpr,
      isMicrosoftABI,
      getWrittenTypeInfo,
      getBuiltinLoc,
      getRParenLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__InitListExpr {
    enum memnames {
      _this_,
      getNumInits,
      getInits,
      inits,
      getInit,
      getArrayFiller,
      hasArrayFiller,
      getInitializedFieldInUnion,
      isExplicit,
      isStringLiteralInit,
      isTransparent,
      isIdiomaticZeroInitializer,
      getLBraceLoc,
      getRBraceLoc,
      isSemanticForm,
      getSemanticForm,
      isSyntacticForm,
      getSyntacticForm,
      hadArrayRangeDesignator,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__DesignatedInitExpr {
    enum memnames {
      CreateEmpty,
      size,
      designators,
      getDesignator,
      getArrayIndex,
      getArrayRangeStart,
      getArrayRangeEnd,
      getEqualOrColonLoc,
      usesGNUSyntax,
      getInit,
      getNumSubExprs,
      getSubExpr,
      getDesignatorsSourceRange,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__DesignatedInitExpr__Designator {
    enum memnames {
      isFieldDesignator,
      isArrayDesignator,
      isArrayRangeDesignator,
      getFieldName,
      getField,
      getDotLoc,
      getFieldLoc,
      getLBracketLoc,
      getRBracketLoc,
      getEllipsisLoc,
      getFirstExprIndex,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getSourceRange,
    };
    static const unsigned _total_num_mems_ = getSourceRange + 1;
  }
  namespace clang__NoInitExpr {
    enum memnames {
      classof,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__DesignatedInitUpdateExpr {
    enum memnames {
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      getBase,
      getUpdater,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__ArrayInitLoopExpr {
    enum memnames {
      getCommonExpr,
      getSubExpr,
      classof,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__ArrayInitIndexExpr {
    enum memnames {
      classof,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__ImplicitValueInitExpr {
    enum memnames {
      classof,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__ParenListExpr {
    enum memnames {
      getNumExprs,
      getExpr,
      getLParenLoc,
      getRParenLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__GenericSelectionExpr {
    enum memnames {
      getNumAssocs,
      getGenericLoc,
      getDefaultLoc,
      getRParenLoc,
      getAssocExpr,
      getAssocExprs,
      getAssocTypeSourceInfo,
      getAssocTypeSourceInfos,
      getAssocType,
      getControllingExpr,
      isResultDependent,
      getResultIndex,
      getResultExpr,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__ExtVectorElementExpr {
    enum memnames {
      getBase,
      getAccessor,
      getAccessorLoc,
      getNumElements,
      containsDuplicateElements,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      isArrow,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__BlockExpr {
    enum memnames {
      getBlockDecl,
      getCaretLocation,
      getBody,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getFunctionType,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__AsTypeExpr {
    enum memnames {
      getSrcExpr,
      getBuiltinLoc,
      getRParenLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__PseudoObjectExpr {
    enum memnames {
      Create,
      getSyntacticForm,
      getResultExprIndex,
      getResultExpr,
      getNumSemanticExprs,
      semantics,
      getSemanticExpr,
      getExprLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      children,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__AtomicExpr {
    enum memnames {
      getNumSubExprs,
      getPtr,
      getOrder,
      getScope,
      getVal1,
      getOrderFail,
      getVal2,
      getWeak,
      getValueType,
      getOp,
      getNumSubExprs1,
      getSubExprs,
      isVolatile,
      isCmpXChg,
      isOpenCL,
      getBuiltinLoc,
      getRParenLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      children,
    };
    static const unsigned _total_num_mems_ = children + 1;
  }
  namespace clang__TypoExpr {
    enum memnames {
      children,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__Attr {
    enum memnames {
      operator_new,
      operator_delete,
      getKind,
      getSpellingListIndex,
      getSpelling,
      getLocation,
      getRange,
      isInherited,
      isImplicit,
      isPackExpansion,
      clone,
      isLateParsed,
      printPretty,
    };
    static const unsigned _total_num_mems_ = printPretty + 1;
  }
  namespace clang__InheritableAttr {
    enum memnames {
      shouldInheritEvenIfAlreadyPresent,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ExternalSourceSymbolAttr {
    enum memnames {
      clone,
      printPretty,
      getSpelling,
      getLanguage,
      getLanguageLength,
      getDefinedIn,
      getDefinedInLength,
      getGeneratedDeclaration,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__MSInheritanceAttr {
    enum memnames {
      CreateImplicit,
      CreateImplicit1,
      clone,
      printPretty,
      getSpelling,
      getSemanticSpelling,
      getBestCase,
      hasVBPtrOffsetField,
      hasNVOffsetField,
      hasVBTableOffsetField,
      hasOnlyOneField,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__MSVtorDispAttr {
    enum memnames {
      CreateImplicit,
      clone,
      printPretty,
      getSpelling,
      getVdm,
      getVtorDispMode,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__LambdaCapture {
    enum memnames {
      getCaptureKind,
      capturesThis,
      capturesVariable,
      capturesVLAType,
      getCapturedVar,
      isImplicit,
      isExplicit,
      getLocation,
      isPackExpansion,
      getEllipsisLoc,
    };
    static const unsigned _total_num_mems_ = getEllipsisLoc + 1;
  }
  namespace clang__AccessSpecDecl {
    enum memnames {
      getAccessSpecifierLoc,
      getColonLoc,
      getSourceRange,
      Create,
      CreateDeserialized,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__CXXBaseSpecifier {
    enum memnames {
      getSourceRange,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getBaseTypeLoc,
      isVirtual,
      isBaseOfClass,
      isPackExpansion,
      getInheritConstructors,
      getEllipsisLoc,
      getAccessSpecifier,
      getAccessSpecifierAsWritten,
      getType,
      getTypeSourceInfo,
    };
    static const unsigned _total_num_mems_ = getTypeSourceInfo + 1;
  }
  namespace clang__CXXRecordDecl {
    enum memnames {
      getCanonicalDecl,
      getPreviousDecl,
      getMostRecentDecl,
      getMostRecentNonInjectedDecl,
      getDefinition,
      hasDefinition,
      Create,
      CreateLambda,
      CreateDeserialized,
      isDynamicClass,
      mayBeDynamicClass,
      mayBeNonDynamicClass,
      isParsingBaseSpecifiers,
      isInstantiation,
      getODRHash,
      getNumBases,
      bases,
      getNumVBases,
      vbases,
      hasAnyDependentBases,
      methods,
      ctors,
      friends,
      hasFriends,
      defaultedCopyConstructorIsDeleted,
      defaultedMoveConstructorIsDeleted,
      defaultedDestructorIsDeleted,
      hasSimpleCopyConstructor,
      hasSimpleMoveConstructor,
      hasSimpleMoveAssignment,
      hasSimpleDestructor,
      hasDefaultConstructor,
      needsImplicitDefaultConstructor,
      hasUserDeclaredConstructor,
      hasUserProvidedDefaultConstructor,
      hasUserDeclaredCopyConstructor,
      needsImplicitCopyConstructor,
      needsOverloadResolutionForCopyConstructor,
      implicitCopyConstructorHasConstParam,
      hasCopyConstructorWithConstParam,
      hasUserDeclaredMoveOperation,
      hasUserDeclaredMoveConstructor,
      hasMoveConstructor,
      needsImplicitMoveConstructor,
      needsOverloadResolutionForMoveConstructor,
      hasUserDeclaredCopyAssignment,
      needsImplicitCopyAssignment,
      needsOverloadResolutionForCopyAssignment,
      implicitCopyAssignmentHasConstParam,
      hasCopyAssignmentWithConstParam,
      hasUserDeclaredMoveAssignment,
      hasMoveAssignment,
      needsImplicitMoveAssignment,
      needsOverloadResolutionForMoveAssignment,
      hasUserDeclaredDestructor,
      needsImplicitDestructor,
      needsOverloadResolutionForDestructor,
      isLambda,
      isGenericLambda,
      getLambdaCallOperator,
      getLambdaStaticInvoker,
      getGenericLambdaTemplateParameterList,
      getLambdaCaptureDefault,
      captures,
      isAggregate,
      hasInClassInitializer,
      hasUninitializedReferenceMember,
      isPOD,
      isCLike,
      isEmpty,
      hasDirectFields,
      isPolymorphic,
      isAbstract,
      isStandardLayout,
      isCXX11StandardLayout,
      hasMutableFields,
      hasVariantMembers,
      hasTrivialDefaultConstructor,
      hasNonTrivialDefaultConstructor,
      hasConstexprNonCopyMoveConstructor,
      defaultedDefaultConstructorIsConstexpr,
      hasConstexprDefaultConstructor,
      hasTrivialCopyConstructor,
      hasTrivialCopyConstructorForCall,
      hasNonTrivialCopyConstructor,
      hasNonTrivialCopyConstructorForCall,
      hasTrivialMoveConstructor,
      hasTrivialMoveConstructorForCall,
      hasNonTrivialMoveConstructor,
      hasNonTrivialMoveConstructorForCall,
      hasTrivialCopyAssignment,
      hasNonTrivialCopyAssignment,
      hasTrivialMoveAssignment,
      hasNonTrivialMoveAssignment,
      hasTrivialDestructor,
      hasTrivialDestructorForCall,
      hasNonTrivialDestructor,
      hasNonTrivialDestructorForCall,
      allowConstDefaultInit,
      hasIrrelevantDestructor,
      hasNonLiteralTypeFieldsOrBases,
      hasInheritedConstructor,
      hasInheritedAssignment,
      isTriviallyCopyable,
      isTrivial,
      isLiteral,
      getInstantiatedFromMemberClass,
      getMemberSpecializationInfo,
      getDescribedClassTemplate,
      getTemplateSpecializationKind,
      getTemplateInstantiationPattern,
      getDestructor,
      isAnyDestructorNoReturn,
      isLocalClass,
      isCurrentInstantiation,
      isDerivedFrom,
      isVirtuallyDerivedFrom,
      isProvablyNotDerivedFrom,
      viewInheritance,
      MergeAccess,
      mayBeAbstract,
      getLambdaManglingNumber,
      getLambdaContextDecl,
      getMSInheritanceModel,
      calculateInheritanceModel,
      nullFieldOffsetIsZero,
      getMSVtorDispMode,
      isDependentLambda,
      getLambdaTypeInfo,
      isInterfaceLike,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__CXXDeductionGuideDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      isExplicit,
      isExplicitSpecified,
      getDeducedTemplate,
      isCopyDeductionCandidate,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__CXXMethodDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      isStatic,
      isInstance,
      isStaticOverloadedOperator,
      isConst,
      isVolatile,
      isVirtual,
      getDevirtualizedMethod,
      isUsualDeallocationFunction,
      isCopyAssignmentOperator,
      isMoveAssignmentOperator,
      getCanonicalDecl,
      getMostRecentDecl,
      isUserProvided,
      size_overridden_methods,
      getParent,
      getThisType,
      getTypeQualifiers,
      getRefQualifier,
      hasInlineBody,
      isLambdaStaticInvoker,
      getCorrespondingMethodInClass,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__CXXCtorInitializer {
    enum memnames {
      isBaseInitializer,
      isMemberInitializer,
      isAnyMemberInitializer,
      isIndirectMemberInitializer,
      isInClassMemberInitializer,
      isDelegatingInitializer,
      isPackExpansion,
      getEllipsisLoc,
      getBaseClassLoc,
      getBaseClass,
      isBaseVirtual,
      getTypeSourceInfo,
      getMember,
      getAnyMember,
      getIndirectMember,
      getMemberLocation,
      getSourceLocation,
      getSourceRange,
      isWritten,
      getSourceOrder,
      getLParenLoc,
      getRParenLoc,
      getInit,
    };
    static const unsigned _total_num_mems_ = getInit + 1;
  }
  namespace clang__InheritedConstructor {
    enum memnames {
      operator_bool,
      getShadowDecl,
      getConstructor,
    };
    static const unsigned _total_num_mems_ = getConstructor + 1;
  }
  namespace clang__CXXConstructorDecl {
    enum memnames {
      CreateDeserialized,
      Create,
      inits,
      getNumCtorInitializers,
      isExplicitSpecified,
      isExplicit,
      isDelegatingConstructor,
      getTargetConstructor,
      isDefaultConstructor,
      isCopyConstructor,
      isMoveConstructor,
      isCopyOrMoveConstructor,
      isConvertingConstructor,
      isSpecializationCopyingObject,
      isInheritingConstructor,
      getInheritedConstructor,
      getCanonicalDecl,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__CXXDestructorDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getOperatorDelete,
      getOperatorDeleteThisArg,
      getCanonicalDecl,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__CXXConversionDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      isExplicitSpecified,
      isExplicit,
      getConversionType,
      isLambdaToBlockPointerConversion,
      getCanonicalDecl,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__LinkageSpecDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getLanguage,
      hasBraces,
      getExternLoc,
      getRBraceLoc,
      getLocEnd,
      getEndLoc,
      getSourceRange,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__UsingDirectiveDecl {
    enum memnames {
      getQualifierLoc,
      getQualifier,
      getNominatedNamespaceAsWritten,
      getNominatedNamespace,
      getCommonAncestor,
      getUsingLoc,
      getNamespaceKeyLocation,
      getIdentLocation,
      Create,
      CreateDeserialized,
      getSourceRange,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__NamespaceAliasDecl {
    enum memnames {
      getPreviousDecl,
      getFirstDecl,
      getMostRecentDecl,
      Create,
      CreateDeserialized,
      getCanonicalDecl,
      getQualifierLoc,
      getQualifier,
      getNamespace,
      getAliasLoc,
      getNamespaceLoc,
      getTargetNameLoc,
      getAliasedNamespace,
      getSourceRange,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__UsingShadowDecl {
    enum memnames {
      getPreviousDecl,
      getFirstDecl,
      getMostRecentDecl,
      Create,
      CreateDeserialized,
      getCanonicalDecl,
      getTargetDecl,
      getUsingDecl,
      getNextUsingShadowDecl,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ConstructorUsingShadowDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getParent,
      getNominatedBaseClassShadowDecl,
      getConstructedBaseClassShadowDecl,
      getNominatedBaseClass,
      getConstructedBaseClass,
      constructsVirtualBase,
      getConstructor,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__UsingDecl {
    enum memnames {
      getFirstDecl,
      getUsingLoc,
      getQualifierLoc,
      getQualifier,
      getNameInfo,
      isAccessDeclaration,
      hasTypename,
      shadows,
      shadow_size,
      Create,
      CreateDeserialized,
      getSourceRange,
      getCanonicalDecl,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__UsingPackDecl {
    enum memnames {
      getFirstDecl,
      getInstantiatedFromUsingDecl,
      expansions,
      CreateDeserialized,
      getSourceRange,
      getCanonicalDecl,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__UnresolvedUsingValueDecl {
    enum memnames {
      getFirstDecl,
      getUsingLoc,
      isAccessDeclaration,
      getQualifierLoc,
      getQualifier,
      getNameInfo,
      isPackExpansion,
      getEllipsisLoc,
      Create,
      CreateDeserialized,
      getSourceRange,
      getCanonicalDecl,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__UnresolvedUsingTypenameDecl {
    enum memnames {
      getFirstDecl,
      getUsingLoc,
      getTypenameLoc,
      getQualifierLoc,
      getQualifier,
      getNameInfo,
      isPackExpansion,
      getEllipsisLoc,
      Create,
      CreateDeserialized,
      getCanonicalDecl,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__StaticAssertDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getAssertExpr,
      getMessage,
      isFailed,
      getRParenLoc,
      getSourceRange,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__BindingDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getBinding,
      getHoldingVar,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__DecompositionDecl {
    enum memnames {
      CreateDeserialized,
      bindings,
      printName,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__MSPropertyDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      classof,
      hasGetter,
      getGetterId,
      hasSetter,
      getSetterId,
    };
    static const unsigned _total_num_mems_ = getSetterId + 1;
  }
  namespace clang__ConstexprDecl {
    enum memnames {
      getLambdaExpr,
      isDependent,
      CreateDeserialized,
      hasFunctionRepresentation,
      hasLambdaRepresentation,
      getFunctionDecl,
      getClosureDecl,
      getClosureCallOperator,
      hasBody,
      getBody,
      getCallExpr,
      getSourceRange,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__TemplateParameterList {
    enum memnames {
      _this_,
      size,
      asArray,
      getParam,
      getMinRequiredArguments,
      getDepth,
      containsUnexpandedParameterPack,
      getRequiresClause,
      getTemplateLoc,
      getLAngleLoc,
      getRAngleLoc,
      getSourceRange,
    };
    static const unsigned _total_num_mems_ = getSourceRange + 1;
  }
  namespace clang__TemplateArgumentList {
    enum memnames {
      get,
      operator_sub,
      asArray,
      size,
      data,
    };
    static const unsigned _total_num_mems_ = data + 1;
  }
  namespace clang__TemplateDecl {
    enum memnames {
      getTemplateParameters,
      getRequiresClause,
      getAssociatedConstraints,
      getTemplatedDecl,
      classof,
      classofKind,
      getSourceRange,
    };
    static const unsigned _total_num_mems_ = getSourceRange + 1;
  }
  namespace clang__FunctionTemplateSpecializationInfo {
    enum memnames {
      Create,
      Function,
      TemplateArguments,
      TemplateArgumentsAsWritten,
      PointOfInstantiation,
      getTemplate,
      getTemplateSpecializationKind,
      isExplicitSpecialization,
      isExplicitInstantiationOrSpecialization,
      getPointOfInstantiation,
    };
    static const unsigned _total_num_mems_ = getPointOfInstantiation + 1;
  }
  namespace clang__MemberSpecializationInfo {
    enum memnames {
      getInstantiatedFrom,
      getTemplateSpecializationKind,
      isExplicitSpecialization,
      getPointOfInstantiation,
    };
    static const unsigned _total_num_mems_ = getPointOfInstantiation + 1;
  }
  namespace clang__DependentFunctionTemplateSpecializationInfo {
    enum memnames {
      Create,
      getNumTemplates,
      getTemplate,
      getTemplateArgs,
      getNumTemplateArgs,
      getTemplateArg,
      getLAngleLoc,
      getRAngleLoc,
    };
    static const unsigned _total_num_mems_ = getRAngleLoc + 1;
  }
  namespace clang__RedeclarableTemplateDecl {
    enum memnames {
      getPreviousDecl,
      getFirstDecl,
      getMostRecentDecl,
      getCanonicalDecl,
      isMemberSpecialization,
      getInstantiatedFromMemberTemplate,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__FunctionTemplateDecl {
    enum memnames {
      LoadLazySpecializations,
      getTemplatedDecl,
      isThisDeclarationADefinition,
      getCanonicalDecl,
      getPreviousDecl,
      getMostRecentDecl,
      getInstantiatedFromMemberTemplate,
      specializations,
      Create,
      CreateDeserialized,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__TemplateTypeParmDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      wasDeclaredWithTypename,
      hasDefaultArgument,
      getDefaultArgument,
      getDefaultArgumentInfo,
      getDefaultArgumentLoc,
      defaultArgumentWasInherited,
      getDepth,
      getIndex,
      isParameterPack,
      getSourceRange,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__NonTypeTemplateParmDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      CreateDeserialized1,
      getSourceRange,
      hasDefaultArgument,
      getDefaultArgument,
      getDefaultArgumentLoc,
      defaultArgumentWasInherited,
      isParameterPack,
      isPackExpansion,
      isExpandedParameterPack,
      getNumExpansionTypes,
      getExpansionType,
      getExpansionTypeSourceInfo,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__TemplateTemplateParmDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      CreateDeserialized1,
      isParameterPack,
      isPackExpansion,
      isExpandedParameterPack,
      getNumExpansionTemplateParameters,
      getExpansionTemplateParameters,
      hasDefaultArgument,
      getDefaultArgument,
      getDefaultArgumentLoc,
      defaultArgumentWasInherited,
      getSourceRange,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__BuiltinTemplateDecl {
    enum memnames {
      classof,
      classofKind,
      getSourceRange,
    };
    static const unsigned _total_num_mems_ = getSourceRange + 1;
  }
  namespace clang__ClassTemplateSpecializationDecl {
    enum memnames {
      CreateDeserialized,
      getNameForDiagnostic,
      getSpecializedTemplate,
      getTemplateArgs,
      getSpecializationKind,
      isExplicitSpecialization,
      isExplicitInstantiationOrSpecialization,
      getPointOfInstantiation,
      getTemplateInstantiationArgs,
      getTypeAsWritten,
      getExternLoc,
      getTemplateKeywordLoc,
      getSourceRange,
      Profile,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ClassTemplatePartialSpecializationDecl {
    enum memnames {
      CreateDeserialized,
      getTemplateParameters,
      getTemplateArgsAsWritten,
      getInstantiatedFromMember,
      getInstantiatedFromMemberTemplate,
      getInjectedSpecializationType,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ClassTemplateDecl {
    enum memnames {
      LoadLazySpecializations,
      getTemplatedDecl,
      isThisDeclarationADefinition,
      Create,
      CreateDeserialized,
      getCanonicalDecl,
      getPreviousDecl,
      getMostRecentDecl,
      getInstantiatedFromMemberTemplate,
      specializations,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__FriendTemplateDecl {
    enum memnames {
      CreateDeserialized,
      getFriendType,
      getFriendDecl,
      getFriendLoc,
      getTemplateParameterList,
      getNumTemplateParameters,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__TypeAliasTemplateDecl {
    enum memnames {
      getTemplatedDecl,
      getCanonicalDecl,
      getPreviousDecl,
      getInstantiatedFromMemberTemplate,
      Create,
      CreateDeserialized,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ClassScopeFunctionSpecializationDecl {
    enum memnames {
      getSpecialization,
      hasExplicitTemplateArgs,
      templateArgs,
      Create,
      CreateDeserialized,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__VarTemplateSpecializationDecl {
    enum memnames {
      CreateDeserialized,
      getNameForDiagnostic,
      getSpecializedTemplate,
      getTemplateArgs,
      getTemplateArgsInfo,
      getSpecializationKind,
      isExplicitSpecialization,
      isExplicitInstantiationOrSpecialization,
      getPointOfInstantiation,
      getTemplateInstantiationArgs,
      getTypeAsWritten,
      getExternLoc,
      getTemplateKeywordLoc,
      Profile,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__VarTemplatePartialSpecializationDecl {
    enum memnames {
      CreateDeserialized,
      getTemplateParameters,
      getTemplateArgsAsWritten,
      getInstantiatedFromMember,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__VarTemplateDecl {
    enum memnames {
      LoadLazySpecializations,
      getTemplatedDecl,
      isThisDeclarationADefinition,
      Create,
      CreateDeserialized,
      getCanonicalDecl,
      getPreviousDecl,
      getMostRecentDecl,
      getInstantiatedFromMemberTemplate,
      specializations,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__FriendDecl {
    enum memnames {
      CreateDeserialized,
      getFriendType,
      getFriendTypeNumTemplateParameterLists,
      getFriendTypeTemplateParameterList,
      getFriendDecl,
      getFriendLoc,
      getSourceRange,
      isUnsupportedFriend,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ObjCListBase {
    enum memnames {
      size,
      empty,
    };
    static const unsigned _total_num_mems_ = empty + 1;
  }
  namespace clang__ObjCProtocolList {
    enum memnames {
      _this_,
      operator_sub,
    };
    static const unsigned _total_num_mems_ = operator_sub + 1;
  }
  namespace clang__ObjCMethodDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getCanonicalDecl,
      getObjCDeclQualifier,
      hasRelatedResultType,
      isRedeclaration,
      getDeclaratorEndLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getSourceRange,
      getSelectorStartLoc,
      getSelectorLoc,
      getNumSelectorLocs,
      getClassInterface,
      getSelector,
      getReturnType,
      getReturnTypeSourceRange,
      getSendResultType,
      getSendResultType1,
      getReturnTypeSourceInfo,
      param_size,
      parameters,
      getSelfDecl,
      getCmdDecl,
      getMethodFamily,
      isInstanceMethod,
      isVariadic,
      isClassMethod,
      isPropertyAccessor,
      isDefined,
      isOverriding,
      hasSkippedBody,
      findPropertyDecl,
      getImplementationControl,
      isOptional,
      isThisDeclarationADesignatedInitializer,
      isDesignatedInitializerForTheInterface,
      hasBody,
      getBody,
      isThisDeclarationADefinition,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ObjCTypeParamDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getSourceRange,
      getVariance,
      getVarianceLoc,
      getIndex,
      hasExplicitBound,
      getColonLoc,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ObjCTypeParamList {
    enum memnames {
      _this_,
      size,
      front,
      back,
      getLAngleLoc,
      getRAngleLoc,
      getSourceRange,
    };
    static const unsigned _total_num_mems_ = getSourceRange + 1;
  }
  namespace clang__ObjCPropertyDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getAtLoc,
      getLParenLoc,
      getTypeSourceInfo,
      getType,
      getUsageType,
      getPropertyAttributes,
      getPropertyAttributesAsWritten,
      isReadOnly,
      isAtomic,
      isRetaining,
      isInstanceProperty,
      isClassProperty,
      getQueryKind,
      getQueryKind1,
      getSetterKind,
      getGetterName,
      getGetterNameLoc,
      getSetterName,
      getSetterNameLoc,
      getGetterMethodDecl,
      getSetterMethodDecl,
      getPropertyImplementation,
      isOptional,
      getPropertyIvarDecl,
      getSourceRange,
      getDefaultSynthIvarName,
      findPropertyDecl,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ObjCContainerDecl {
    enum memnames {
      properties,
      instance_properties,
      class_properties,
      methods,
      instance_methods,
      class_methods,
      getMethod,
      getInstanceMethod,
      getClassMethod,
      HasUserDeclaredSetterMethod,
      getIvarDecl,
      FindPropertyDeclaration,
      getAtStartLoc,
      getAtEndRange,
      getSourceRange,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ObjCInterfaceDecl {
    enum memnames {
      getPreviousDecl,
      getFirstDecl,
      getMostRecentDecl,
      Create,
      CreateDeserialized,
      getTypeParamList,
      getTypeParamListAsWritten,
      getSourceRange,
      hasDesignatedInitializers,
      declaresOrInheritsDesignatedInitializers,
      getReferencedProtocols,
      getImplementation,
      FindCategoryDeclaration,
      getCategoryInstanceMethod,
      getCategoryClassMethod,
      getCategoryMethod,
      protocols,
      protocol_locs,
      all_referenced_protocols,
      ivars,
      ivar_size,
      ivar_empty,
      getObjCRuntimeNameAsString,
      isDesignatedInitializer,
      isThisDeclarationADefinition,
      hasDefinition,
      getDefinition,
      getSuperClassType,
      getSuperClassTInfo,
      getSuperClass,
      visible_categories,
      visible_categories_empty,
      known_categories,
      known_categories_empty,
      visible_extensions,
      visible_extensions_empty,
      known_extensions,
      known_extensions_empty,
      getCategoryListRaw,
      FindPropertyVisibleInPrimaryClass,
      isSuperClassOf,
      isArcWeakrefUnavailable,
      isObjCRequiresPropertyDefs,
      lookupMethod,
      lookupInstanceMethod,
      lookupClassMethod,
      lookupPrivateMethod,
      lookupPropertyAccessor,
      getEndOfDefinitionLoc,
      getSuperClassLoc,
      isImplicitInterfaceDecl,
      getCanonicalDecl,
      getTypeForDecl,
      setTypeForDecl,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ObjCIvarDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getContainingInterface,
      getNextIvar,
      getAccessControl,
      getCanonicalAccessControl,
      getSynthesize,
      getUsageType,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ObjCAtDefsFieldDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ObjCProtocolDecl {
    enum memnames {
      getPreviousDecl,
      getFirstDecl,
      getMostRecentDecl,
      Create,
      CreateDeserialized,
      getReferencedProtocols,
      protocols,
      protocol_locs,
      protocol_size,
      lookupMethod,
      lookupInstanceMethod,
      lookupClassMethod,
      hasDefinition,
      getDefinition,
      isThisDeclarationADefinition,
      getObjCRuntimeNameAsString,
      getSourceRange,
      getCanonicalDecl,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ObjCCategoryDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getClassInterface,
      getTypeParamList,
      getImplementation,
      getReferencedProtocols,
      protocols,
      protocol_size,
      protocol_locs,
      getNextClassCategory,
      getNextClassCategoryRaw,
      IsClassExtension,
      ivars,
      ivar_size,
      ivar_empty,
      getCategoryNameLoc,
      getIvarLBraceLoc,
      getIvarRBraceLoc,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ObjCImplDecl {
    enum memnames {
      getClassInterface,
      FindPropertyImplDecl,
      FindPropertyImplIvarDecl,
      property_impls,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ObjCCategoryImplDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getCategoryDecl,
      getCategoryNameLoc,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ObjCImplementationDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      inits,
      getNumIvarInitializers,
      hasNonZeroConstructors,
      hasDestructors,
      getIdentifier,
      getName,
      getNameAsString,
      getObjCRuntimeNameAsString,
      getSuperClass,
      getSuperClassLoc,
      getIvarLBraceLoc,
      getIvarRBraceLoc,
      ivars,
      ivar_size,
      ivar_empty,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ObjCCompatibleAliasDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getClassInterface,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__ObjCPropertyImplDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getSourceRange,
      getLocStart,
      getBeginLoc,
      getPropertyDecl,
      getPropertyImplementation,
      getPropertyIvarDecl,
      getPropertyIvarDeclLoc,
      isIvarNameSpecified,
      getGetterCXXConstructor,
      getSetterCXXAssignment,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__OMPThreadPrivateDecl {
    enum memnames {
      CreateDeserialized,
      varlist_size,
      varlist_empty,
      varlists,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__OMPDeclareReductionDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getCombiner,
      getInitializer,
      getInitializerKind,
      getPrevDeclInScope,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__OMPCapturedExprDecl {
    enum memnames {
      Create,
      CreateDeserialized,
      getSourceRange,
      classof,
      classofKind,
    };
    static const unsigned _total_num_mems_ = classofKind + 1;
  }
  namespace clang__CXXOperatorCallExpr {
    enum memnames {
      getOperator,
      isAssignmentOp,
      isAssignmentOp1,
      isInfixBinaryOp,
      getOperatorLoc,
      getExprLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getSourceRange,
      classof,
      getFPFeatures,
      isFPContractableWithinStatement,
    };
    static const unsigned _total_num_mems_ = isFPContractableWithinStatement + 1;
  }
  namespace clang__CXXMemberCallExpr {
    enum memnames {
      getImplicitObjectArgument,
      getMethodDecl,
      getRecordDecl,
      getExprLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CUDAKernelCallExpr {
    enum memnames {
      getConfig,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXNamedCastExpr {
    enum memnames {
      getCastName,
      getOperatorLoc,
      getRParenLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getAngleBrackets,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXStaticCastExpr {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXDynamicCastExpr {
    enum memnames {
      CreateEmpty,
      isAlwaysNull,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXReinterpretCastExpr {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXConstCastExpr {
    enum memnames {
      Create,
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__UserDefinedLiteral {
    enum memnames {
      getLiteralOperatorKind,
      getCookedLiteral,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getUDSuffixLoc,
      getUDSuffix,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXBoolLiteralExpr {
    enum memnames {
      getValue,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getLocation,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXNullPtrLiteralExpr {
    enum memnames {
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getLocation,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXStdInitializerListExpr {
    enum memnames {
      getSubExpr,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getSourceRange,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXTypeidExpr {
    enum memnames {
      isPotentiallyEvaluated,
      isTypeOperand,
      getTypeOperand,
      getTypeOperandSourceInfo,
      getExprOperand,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getSourceRange,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__MSPropertyRefExpr {
    enum memnames {
      getSourceRange,
      isImplicitAccess,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
      getBaseExpr,
      getPropertyDecl,
      isArrow,
      getMemberLoc,
      getQualifierLoc,
    };
    static const unsigned _total_num_mems_ = getQualifierLoc + 1;
  }
  namespace clang__MSPropertySubscriptExpr {
    enum memnames {
      getBase,
      getIdx,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getRBracketLoc,
      getExprLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXUuidofExpr {
    enum memnames {
      isTypeOperand,
      getTypeOperand,
      getTypeOperandSourceInfo,
      getExprOperand,
      getUuidStr,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getSourceRange,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXThisExpr {
    enum memnames {
      getLocation,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      isImplicit,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXThrowExpr {
    enum memnames {
      getSubExpr,
      getThrowLoc,
      isThrownVariableInScope,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXDefaultArgExpr {
    enum memnames {
      Create,
      getParam,
      getExpr,
      getUsedLocation,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getExprLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXDefaultInitExpr {
    enum memnames {
      Create,
      getField,
      getExpr,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXTemporary {
    enum memnames {
      Create,
      getDestructor,
    };
    static const unsigned _total_num_mems_ = getDestructor + 1;
  }
  namespace clang__CXXBindTemporaryExpr {
    enum memnames {
      Create,
      getTemporary,
      getSubExpr,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXConstructExpr {
    enum memnames {
      getConstructor,
      getLocation,
      isElidable,
      hadMultipleCandidates,
      isListInitialization,
      isStdInitListInitialization,
      requiresZeroInitialization,
      getConstructionKind,
      arguments,
      getArgs,
      getNumArgs,
      getArg,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getParenOrBraceRange,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXInheritedCtorInitExpr {
    enum memnames {
      getConstructor,
      constructsVBase,
      getConstructionKind,
      inheritedFromVBase,
      getLocation,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXFunctionalCastExpr {
    enum memnames {
      CreateEmpty,
      getLParenLoc,
      getRParenLoc,
      isListInitialization,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXTemporaryObjectExpr {
    enum memnames {
      getTypeSourceInfo,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__LambdaExpr {
    enum memnames {
      CreateDeserialized,
      getCaptureDefault,
      getCaptureDefaultLoc,
      isInitCapture,
      captures,
      capture_size,
      explicit_captures,
      implicit_captures,
      capture_inits,
      getIntroducerRange,
      getLambdaClass,
      getCallOperator,
      getTemplateParameterList,
      isGenericLambda,
      getBody,
      isMutable,
      hasExplicitParameters,
      hasExplicitResultType,
      classof,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
    };
    static const unsigned _total_num_mems_ = getEndLoc + 1;
  }
  namespace clang__CXXScalarValueInitExpr {
    enum memnames {
      getTypeSourceInfo,
      getRParenLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXNewExpr {
    enum memnames {
      getAllocatedType,
      getAllocatedTypeSourceInfo,
      shouldNullCheckAllocation,
      getOperatorNew,
      getOperatorDelete,
      isArray,
      getArraySize,
      getNumPlacementArgs,
      getPlacementArg,
      isParenTypeId,
      getTypeIdParens,
      isGlobalNew,
      hasInitializer,
      getInitializationStyle,
      getInitializer,
      getConstructExpr,
      passAlignment,
      doesUsualArrayDeleteWantSize,
      placement_arguments,
      getStartLoc,
      getBeginLoc,
      getEndLoc,
      getDirectInitRange,
      getSourceRange,
      getLocStart,
      getLocEnd,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXDeleteExpr {
    enum memnames {
      isGlobalDelete,
      isArrayForm,
      isArrayFormAsWritten,
      doesUsualArrayDeleteWantSize,
      getOperatorDelete,
      getArgument,
      getDestroyedType,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXPseudoDestructorExpr {
    enum memnames {
      getBase,
      hasQualifier,
      getQualifierLoc,
      getQualifier,
      isArrow,
      getOperatorLoc,
      getScopeTypeInfo,
      getColonColonLoc,
      getTildeLoc,
      getDestroyedTypeInfo,
      getDestroyedTypeIdentifier,
      getDestroyedType,
      getDestroyedTypeLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__TypeTraitExpr {
    enum memnames {
      CreateDeserialized,
      getTrait,
      getValue,
      getNumArgs,
      getArg,
      getArgs,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ArrayTypeTraitExpr {
    enum memnames {
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getTrait,
      getQueriedType,
      getQueriedTypeSourceInfo,
      getValue,
      getDimensionExpression,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ExpressionTraitExpr {
    enum memnames {
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getTrait,
      getQueriedExpression,
      getValue,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OverloadExpr {
    enum memnames {
      find,
      getNamingClass,
      decls,
      getNumDecls,
      getNameInfo,
      getName,
      getNameLoc,
      getQualifier,
      getQualifierLoc,
      getTemplateKeywordLoc,
      getLAngleLoc,
      getRAngleLoc,
      hasTemplateKeyword,
      hasExplicitTemplateArgs,
      getTemplateArgs,
      getNumTemplateArgs,
      template_arguments,
      copyTemplateArgumentsInto,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OverloadExpr__FindResult {
    enum memnames {
      Expression,
      IsAddressOfOperand,
      HasFormOfMemberPointer,
    };
    static const unsigned _total_num_mems_ = HasFormOfMemberPointer + 1;
  }
  namespace clang__UnresolvedLookupExpr {
    enum memnames {
      Create,
      Create1,
      CreateEmpty,
      requiresADL,
      isOverloaded,
      getNamingClass,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__DependentScopeDeclRefExpr {
    enum memnames {
      Create,
      CreateEmpty,
      getNameInfo,
      getDeclName,
      getLocation,
      getQualifierLoc,
      getQualifier,
      getTemplateKeywordLoc,
      getLAngleLoc,
      getRAngleLoc,
      hasTemplateKeyword,
      hasExplicitTemplateArgs,
      copyTemplateArgumentsInto,
      getTemplateArgs,
      getNumTemplateArgs,
      template_arguments,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ExprWithCleanups {
    enum memnames {
      Create,
      getObjects,
      getNumObjects,
      getObject,
      getSubExpr,
      cleanupsHaveSideEffects,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXUnresolvedConstructExpr {
    enum memnames {
      CreateEmpty,
      getTypeAsWritten,
      getTypeSourceInfo,
      getLParenLoc,
      getRParenLoc,
      isListInitialization,
      arg_size,
      getArg,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXDependentScopeMemberExpr {
    enum memnames {
      Create,
      CreateEmpty,
      isImplicitAccess,
      getBase,
      getBaseType,
      isArrow,
      getOperatorLoc,
      getQualifier,
      getQualifierLoc,
      getFirstQualifierFoundInScope,
      getMemberNameInfo,
      getMember,
      getMemberLoc,
      getTemplateKeywordLoc,
      getLAngleLoc,
      getRAngleLoc,
      hasTemplateKeyword,
      hasExplicitTemplateArgs,
      copyTemplateArgumentsInto,
      getTemplateArgs,
      getNumTemplateArgs,
      template_arguments,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__UnresolvedMemberExpr {
    enum memnames {
      Create,
      CreateEmpty,
      isImplicitAccess,
      getBase,
      getBaseType,
      hasUnresolvedUsing,
      isArrow,
      getOperatorLoc,
      getNamingClass,
      getMemberNameInfo,
      getMemberName,
      getMemberLoc,
      getExprLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXNoexceptExpr {
    enum memnames {
      getOperand,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getSourceRange,
      getValue,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__PackExpansionExpr {
    enum memnames {
      getPattern,
      getEllipsisLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__SizeOfPackExpr {
    enum memnames {
      CreateDeserialized,
      getOperatorLoc,
      getPackLoc,
      getRParenLoc,
      getPack,
      getPackLength,
      isPartiallySubstituted,
      getPartialArguments,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__SubstNonTypeTemplateParmExpr {
    enum memnames {
      getNameLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getReplacement,
      getParameter,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__SubstNonTypeTemplateParmPackExpr {
    enum memnames {
      getParameterPack,
      getParameterPackLocation,
      getArgumentPack,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__FunctionParmPackExpr {
    enum memnames {
      _this_,
      CreateEmpty,
      getParameterPack,
      getParameterPackLocation,
      getNumExpansions,
      getExpansion,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__MaterializeTemporaryExpr {
    enum memnames {
      getTemporary,
      GetTemporaryExpr,
      getStorageDuration,
      getExtendingDecl,
      getManglingNumber,
      isBoundToLvalueReference,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXFoldExpr {
    enum memnames {
      getLHS,
      getRHS,
      isRightFold,
      isLeftFold,
      getPattern,
      getInit,
      getEllipsisLoc,
      getOperator,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CoroutineSuspendExpr {
    enum memnames {
      getKeywordLoc,
      getCommonExpr,
      getOpaqueValue,
      getReadyExpr,
      getSuspendExpr,
      getResumeExpr,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CoawaitExpr {
    enum memnames {
      getOperand,
      isImplicit,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__DependentCoawaitExpr {
    enum memnames {
      getOperand,
      getOperatorCoawaitLookup,
      getKeywordLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CoyieldExpr {
    enum memnames {
      getOperand,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ReflectionExpr {
    enum memnames {
      isReflexpr,
      hasTypeOperand,
      hasExpressionOperand,
      getTypeOperand,
      getExpressionOperand,
      getOperatorLoc,
      getLocStart,
      getLocEnd,
    };
    static const unsigned _total_num_mems_ = getLocEnd + 1;
  }
  namespace clang__CompilerMessageExpr {
    enum memnames {
      Create,
      CreateEmpty,
      getMessage,
      getKWLoc,
      getRParenLoc,
      getLocStart,
      getLocEnd,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CompilerDiagnosticExpr {
    enum memnames {
      CreateEmpty,
      getKWLoc,
      getRParenLoc,
      arg_size,
      getArgs,
      getArg,
      isError,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXMetaparseExpr {
    enum memnames {
      getExprSrcCode,
      getLocStart,
      getLocEnd,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ReflectionTraitExpr {
    enum memnames {
      getTraitKind,
      getNumArgs,
      getArg,
      getArgs,
      getKWLoc,
      getRParenLoc,
      getLocStart,
      getLocEnd,
      getASTContext_p,
      getObjKind,
      callbacksAreSet,
      readyToConvertToStringLiteral,
      getMemNum,
      isPtr,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ReflectNewExpr {
    enum memnames {
      getNumArgs,
      getArg,
      getArgs,
      getObjKind,
      getTraitLoc,
      getRParenLoc,
      getLocStart,
      getLocEnd,
    };
    static const unsigned _total_num_mems_ = getLocEnd + 1;
  }
  namespace clang__ReflectDeleteExpr {
    enum memnames {
      getNumArgs,
      getArg,
      getArgs,
      getObjKind,
      getTraitLoc,
      getRParenLoc,
      getLocStart,
      getLocEnd,
    };
    static const unsigned _total_num_mems_ = getLocEnd + 1;
  }
  namespace clang__CXXConstantExpr {
    enum memnames {
      getExpression,
      getValue,
      getLocStart,
      getLocEnd,
      children,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXDependentIdExpr {
    enum memnames {
      getNameInfo,
      getLocStart,
      getLocEnd,
      getSourceRange,
      children,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXConcatenateExpr {
    enum memnames {
      getNumOperands,
      getOperand,
      getOperands,
      children,
      getIntroLoc,
      getLocStart,
      getLocEnd,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCStringLiteral {
    enum memnames {
      getString,
      getAtLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCBoolLiteralExpr {
    enum memnames {
      getValue,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getLocation,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCBoxedExpr {
    enum memnames {
      getSubExpr,
      getBoxingMethod,
      getAtLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getSourceRange,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCArrayLiteral {
    enum memnames {
      CreateEmpty,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getSourceRange,
      getElements,
      getNumElements,
      getElement,
      getArrayWithObjectsMethod,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCDictionaryElement {
    enum memnames {
      Key,
      Value,
      EllipsisLoc,
      isPackExpansion,
    };
    static const unsigned _total_num_mems_ = isPackExpansion + 1;
  }
  namespace clang__ObjCDictionaryLiteral {
    enum memnames {
      CreateEmpty,
      getNumElements,
      getKeyValueElement,
      getDictWithObjectsMethod,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getSourceRange,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCEncodeExpr {
    enum memnames {
      getAtLoc,
      getRParenLoc,
      getEncodedType,
      getEncodedTypeSourceInfo,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCSelectorExpr {
    enum memnames {
      getSelector,
      getAtLoc,
      getRParenLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getNumArgs,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCProtocolExpr {
    enum memnames {
      getProtocol,
      getProtocolIdLoc,
      getAtLoc,
      getRParenLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCIvarRefExpr {
    enum memnames {
      getDecl,
      getBase,
      isArrow,
      isFreeIvar,
      getLocation,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getOpLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCPropertyRefExpr {
    enum memnames {
      isImplicitProperty,
      isExplicitProperty,
      getExplicitProperty,
      getImplicitPropertyGetter,
      getImplicitPropertySetter,
      getGetterSelector,
      getSetterSelector,
      isMessagingGetter,
      isMessagingSetter,
      getBase,
      getLocation,
      getReceiverLocation,
      getSuperReceiverType,
      getClassReceiver,
      isObjectReceiver,
      isSuperReceiver,
      isClassReceiver,
      getReceiverType,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCSubscriptRefExpr {
    enum memnames {
      getRBracket,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getBaseExpr,
      getKeyExpr,
      getAtIndexMethodDecl,
      setAtIndexMethodDecl,
      isArraySubscriptRefExpr,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCMessageExpr {
    enum memnames {
      CreateEmpty,
      isImplicit,
      getReceiverKind,
      getReceiverRange,
      isInstanceMessage,
      isClassMessage,
      getInstanceReceiver,
      getClassReceiver,
      getClassReceiverTypeInfo,
      getSuperLoc,
      getReceiverType,
      getReceiverInterface,
      getSuperType,
      getSelector,
      getMethodDecl,
      getMethodFamily,
      getNumArgs,
      getArgs,
      getArg,
      isDelegateInitCall,
      getLeftLoc,
      getRightLoc,
      getSelectorStartLoc,
      getSelectorLoc,
      getNumSelectorLocs,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      arguments,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCIsaExpr {
    enum memnames {
      getBase,
      isArrow,
      getIsaMemberLoc,
      getOpLoc,
      getLocStart,
      getBeginLoc,
      getBaseLocEnd,
      getLocEnd,
      getEndLoc,
      getExprLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCIndirectCopyRestoreExpr {
    enum memnames {
      getSubExpr,
      shouldCopy,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getExprLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCBridgedCastExpr {
    enum memnames {
      getLParenLoc,
      getBridgeKind,
      getBridgeKindName,
      getBridgeKeywordLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCAvailabilityCheckExpr {
    enum memnames {
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getSourceRange,
      hasVersion,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPArraySectionExpr {
    enum memnames {
      getBase,
      getBaseOriginalType,
      getLowerBound,
      getLength,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getColonLoc,
      getRBracketLoc,
      getExprLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXCatchStmt {
    enum memnames {
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getCatchLoc,
      getExceptionDecl,
      getCaughtType,
      getHandlerBlock,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXTryStmt {
    enum memnames {
      Create,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getTryLoc,
      getEndLoc,
      getTryBlock,
      getNumHandlers,
      getHandler,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXForRangeStmt {
    enum memnames {
      getLoopVariable,
      getRangeInit,
      getRangeStmt,
      getBeginStmt,
      getEndStmt,
      getCond,
      getInc,
      getLoopVarStmt,
      getBody,
      getForLoc,
      getCoawaitLoc,
      getColonLoc,
      getRParenLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXExpansionStmt {
    enum memnames {
      getRangeVarStmt,
      getRangeVariable,
      getLoopVarStmt,
      getLoopVariable,
      getBody,
      getSize,
      getInstantiatedStatements,
      getForLoc,
      getEllipsisLoc,
      getColonLoc,
      getRParenLoc,
      getLocStart,
      getLocEnd,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXTupleExpansionStmt {
    enum memnames {
      getRangeVarStmt,
      getRangeInit,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXPackExpansionStmt {
    enum memnames {
      getUnexpandedPack,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__MSDependentExistsStmt {
    enum memnames {
      getKeywordLoc,
      isIfExists,
      isIfNotExists,
      getQualifierLoc,
      getNameInfo,
      getSubStmt,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CoroutineBodyStmt {
    enum memnames {
      Create,
      Create1,
      hasDependentPromiseType,
      getBody,
      getPromiseDeclStmt,
      getPromiseDecl,
      getInitSuspendStmt,
      getFinalSuspendStmt,
      getExceptionHandler,
      getFallthroughHandler,
      getAllocate,
      getDeallocate,
      getReturnValueInit,
      getResultDecl,
      getReturnStmt,
      getReturnStmtOnAllocFailure,
      getParamMoves,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CoroutineBodyStmt__CtorArgs {
    enum memnames {
      Body,
      Promise,
      InitialSuspend,
      FinalSuspend,
      OnException,
      OnFallthrough,
      Allocate,
      Deallocate,
      ReturnValue,
      ResultDecl,
      ReturnStmt,
      ReturnStmtOnAllocFailure,
    };
    static const unsigned _total_num_mems_ = ReturnStmtOnAllocFailure + 1;
  }
  namespace clang__CoreturnStmt {
    enum memnames {
      getKeywordLoc,
      getOperand,
      getPromiseCall,
      isImplicit,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__CXXQueueMetaparseStmt {
    enum memnames {
      getNewSrcCode,
      getIntroLoc,
      getLocStart,
      getLocEnd,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCForCollectionStmt {
    enum memnames {
      getElement,
      getCollection,
      getBody,
      getForLoc,
      getRParenLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCAtCatchStmt {
    enum memnames {
      getCatchBody,
      getCatchParamDecl,
      getAtCatchLoc,
      getRParenLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      hasEllipsis,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCAtFinallyStmt {
    enum memnames {
      getFinallyBody,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getAtFinallyLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCAtTryStmt {
    enum memnames {
      Create,
      CreateEmpty,
      getAtTryLoc,
      getTryBody,
      getNumCatchStmts,
      getCatchStmt,
      getFinallyStmt,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCAtSynchronizedStmt {
    enum memnames {
      getAtSynchronizedLoc,
      getSynchBody,
      getSynchExpr,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCAtThrowStmt {
    enum memnames {
      getThrowExpr,
      getThrowLoc,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__ObjCAutoreleasePoolStmt {
    enum memnames {
      getSubStmt,
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getAtLoc,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPClause {
    enum memnames {
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getClauseKind,
      isImplicit,
      children,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPExecutableDirective {
    enum memnames {
      getLocStart,
      getBeginLoc,
      getLocEnd,
      getEndLoc,
      getNumClauses,
      getClause,
      hasAssociatedStmt,
      getAssociatedStmt,
      getCapturedStmt,
      getInnermostCapturedStmt,
      getDirectiveKind,
      classof,
      clauses,
    };
    static const unsigned _total_num_mems_ = clauses + 1;
  }
  namespace clang__OMPParallelDirective {
    enum memnames {
      CreateEmpty,
      hasCancel,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPLoopDirective {
    enum memnames {
      getCollapsedNumber,
      getIterationVariable,
      getLastIteration,
      getCalcLastIteration,
      getPreCond,
      getCond,
      getInit,
      getInc,
      getPreInits,
      getIsLastIterVariable,
      getLowerBoundVariable,
      getUpperBoundVariable,
      getStrideVariable,
      getEnsureUpperBound,
      getNextLowerBound,
      getNextUpperBound,
      getNumIterations,
      getPrevLowerBoundVariable,
      getPrevUpperBoundVariable,
      getDistInc,
      getPrevEnsureUpperBound,
      getCombinedLowerBoundVariable,
      getCombinedUpperBoundVariable,
      getCombinedEnsureUpperBound,
      getCombinedInit,
      getCombinedCond,
      getCombinedNextLowerBound,
      getCombinedNextUpperBound,
      getBody,
      counters,
      private_counters,
      inits,
      updates,
      finals,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPSimdDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPForDirective {
    enum memnames {
      CreateEmpty,
      hasCancel,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPForSimdDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPSectionsDirective {
    enum memnames {
      CreateEmpty,
      hasCancel,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPSectionDirective {
    enum memnames {
      Create,
      CreateEmpty,
      hasCancel,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPSingleDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPMasterDirective {
    enum memnames {
      Create,
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPCriticalDirective {
    enum memnames {
      CreateEmpty,
      getDirectiveName,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPParallelForDirective {
    enum memnames {
      CreateEmpty,
      hasCancel,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPParallelForSimdDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPParallelSectionsDirective {
    enum memnames {
      CreateEmpty,
      hasCancel,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTaskDirective {
    enum memnames {
      CreateEmpty,
      hasCancel,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTaskyieldDirective {
    enum memnames {
      Create,
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPBarrierDirective {
    enum memnames {
      Create,
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTaskwaitDirective {
    enum memnames {
      Create,
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTaskgroupDirective {
    enum memnames {
      CreateEmpty,
      getReductionRef,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPFlushDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPOrderedDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPAtomicDirective {
    enum memnames {
      CreateEmpty,
      getX,
      getUpdateExpr,
      isXLHSInRHSPart,
      isPostfixUpdate,
      getV,
      getExpr,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTargetDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTargetDataDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTargetEnterDataDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTargetExitDataDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTargetParallelDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTargetParallelForDirective {
    enum memnames {
      CreateEmpty,
      hasCancel,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTeamsDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPCancellationPointDirective {
    enum memnames {
      Create,
      CreateEmpty,
      getCancelRegion,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPCancelDirective {
    enum memnames {
      CreateEmpty,
      getCancelRegion,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTaskLoopDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTaskLoopSimdDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPDistributeDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTargetUpdateDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPDistributeParallelForDirective {
    enum memnames {
      CreateEmpty,
      hasCancel,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPDistributeParallelForSimdDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPDistributeSimdDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTargetParallelForSimdDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTargetSimdDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTeamsDistributeDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTeamsDistributeSimdDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTeamsDistributeParallelForSimdDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTeamsDistributeParallelForDirective {
    enum memnames {
      CreateEmpty,
      hasCancel,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTargetTeamsDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTargetTeamsDistributeDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTargetTeamsDistributeParallelForDirective {
    enum memnames {
      CreateEmpty,
      hasCancel,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTargetTeamsDistributeParallelForSimdDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__OMPTargetTeamsDistributeSimdDirective {
    enum memnames {
      CreateEmpty,
      classof,
    };
    static const unsigned _total_num_mems_ = classof + 1;
  }
  namespace clang__StoredDeclsMap {
    enum memnames {
      empty,
      size,
      count,
      isPointerIntoBucketsArray,
      getPointerIntoBucketsArray,
      getMemorySize,
      DestroyAll,
    };
    static const unsigned _total_num_mems_ = DestroyAll + 1;
  }
  namespace clang__DependentDiagnostic {
    enum memnames {
      Create,
      getKind,
      isAccessToMember,
      getAccess,
      getAccessLoc,
      getAccessTarget,
      getAccessNamingClass,
      getAccessBaseObjectType,
      getDiagnostic,
    };
    static const unsigned _total_num_mems_ = getDiagnostic + 1;
  }
  namespace reflcontainers__VectorStr {
    enum memnames {
      _this_,
      clone,
      size,
      empty,
      clear,
      resize,
      capacity,
      reserve,
      shrink_to_fit,
      push_back,
      pop_back,
      dealloc,
      at,
      assign,
      front,
      back,
    };
    static const unsigned _total_num_mems_ = back + 1;
  }
  namespace reflcontainers__VectorInt {
    enum memnames {
      _this_,
      clone,
      size,
      empty,
      clear,
      resize,
      capacity,
      reserve,
      shrink_to_fit,
      push_back,
      pop_back,
      dealloc,
      at,
      assign,
      front,
      back,
      assign1,
      push_back1,
    };
    static const unsigned _total_num_mems_ = push_back1 + 1;
  }
  namespace reflcontainers__SetInt {
    enum memnames {
      _this_,
      clone,
      size,
      empty,
      clear,
      contains,
      insert,
      erase,
      at_ith,
      dealloc,
      contains1,
      insert1,
      erase1,
    };
    static const unsigned _total_num_mems_ = erase1 + 1;
  }
  namespace reflcontainers__SetStr {
    enum memnames {
      _this_,
      clone,
      size,
      empty,
      clear,
      contains,
      insert,
      erase,
      at_ith,
      dealloc,
    };
    static const unsigned _total_num_mems_ = dealloc + 1;
  }
  namespace reflcontainers__IntIntPair {
    enum memnames {
      first,
      second,
    };
    static const unsigned _total_num_mems_ = second + 1;
  }
  namespace reflcontainers__IntStrPair {
    enum memnames {
      first,
      second,
    };
    static const unsigned _total_num_mems_ = second + 1;
  }
  namespace reflcontainers__StrIntPair {
    enum memnames {
      first,
      second,
    };
    static const unsigned _total_num_mems_ = second + 1;
  }
  namespace reflcontainers__StrStrPair {
    enum memnames {
      first,
      second,
    };
    static const unsigned _total_num_mems_ = second + 1;
  }
  namespace reflcontainers__MapIntStr {
    enum memnames {
      _this_,
      clone,
      size,
      empty,
      clear,
      at_ith,
      at_ith_key,
      at_ith_val,
      dealloc,
      contains,
      at,
      assign,
      erase,
      erase1,
      contains1,
      at1,
      assign1,
    };
    static const unsigned _total_num_mems_ = assign1 + 1;
  }
  namespace reflcontainers__MapStrInt {
    enum memnames {
      _this_,
      clone,
      size,
      empty,
      clear,
      at_ith,
      at_ith_key,
      at_ith_val,
      dealloc,
      contains,
      at,
      assign,
      erase,
      assign1,
    };
    static const unsigned _total_num_mems_ = assign1 + 1;
  }
  namespace reflcontainers__MapStrStr {
    enum memnames {
      _this_,
      clone,
      size,
      empty,
      clear,
      at_ith,
      at_ith_key,
      at_ith_val,
      dealloc,
      contains,
      at,
      assign,
      erase,
    };
    static const unsigned _total_num_mems_ = erase + 1;
  }
  namespace reflcontainers__MapIntInt {
    enum memnames {
      _this_,
      clone,
      size,
      empty,
      clear,
      at_ith,
      at_ith_key,
      at_ith_val,
      dealloc,
      contains,
      at,
      assign,
      erase,
      erase1,
      contains1,
      at1,
      assign1,
      assign2,
      assign3,
    };
    static const unsigned _total_num_mems_ = assign3 + 1;
  }
  
} //namespace reflenums


namespace refldetail {


  namespace clang {
  }

  namespace clang {
  }

  namespace llvm {
    struct APInt {
      M_template_rtpack(Xs) struct impl;
      struct ms {
        M_template_rtpack(Xs) struct impl;
      };
      struct mu {
        M_template_rtpack(Xs) struct impl;
      };
    };
  }

  namespace llvm {
    struct APFloatBase {
      M_template_rtpack(Xs) struct impl;
      enum cmpResult : unsigned int;
      enum roundingMode : unsigned int;
      enum opStatus : unsigned int;
      enum fltCategory : unsigned int;
    };
    struct APFloat {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace llvm {
    struct APSInt {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct APValue {
      M_template_rtpack(Xs) struct impl;
      enum ValueKind : unsigned int;
    DEF_RANGE_REFLECTION_TUPLE(getMemberPointerPath,
      constexpr auto getMemberPointerPath() const ,
        (const class clang::CXXRecordDecl *),
        (reflenums::RK_clang__APValue, reflenums::clang__APValue::getMemberPointerPath, Xs...), () )
      struct LValueBase {
        M_template_rtpack(Xs) struct impl;
      };
    };
  }

  namespace clang {
  }

  namespace clang {
  }

  namespace clang {

    namespace diag {
      enum class Severity : int;
    }
  }

  namespace clang {
    enum OverloadsShown : unsigned int;
    enum class DiagnosticLevelMask : unsigned int;
    struct DiagnosticOptions {
      M_template_rtpack(Xs) struct impl;
      enum TextDiagnosticFormat : unsigned int;
    };
  }

  namespace clang {
    struct FileID {
      M_template_rtpack(Xs) struct impl;
    };
    struct SourceLocation {
      M_template_rtpack(Xs) struct impl;
    };
    struct SourceRange {
      M_template_rtpack(Xs) struct impl;
    };
    struct CharSourceRange {
      M_template_rtpack(Xs) struct impl;
    };
    struct PresumedLoc {
      M_template_rtpack(Xs) struct impl;
    };
    struct FullSourceLoc {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    enum AccessSpecifier : unsigned int;
    enum ExprValueKind : unsigned int;
    enum ExprObjectKind : unsigned int;
    enum TemplateSpecializationKind : unsigned int;
    enum ThreadStorageClassSpecifier : unsigned int;
    enum StorageClass : unsigned int;
    enum InClassInitStyle : unsigned int;
    enum CallingConv : unsigned int;
    enum StorageDuration : unsigned int;
    enum class NullabilityKind : uint8_t;
    enum class ParameterABI : int;
    enum ReflectionTraitKind : unsigned int;
  }

  namespace llvm {
    struct DebugEpochBase {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct FixItHint {
      M_template_rtpack(Xs) struct impl;
    };
    struct DiagnosticsEngine {
      M_template_rtpack(Xs) struct impl;
      enum Level : unsigned int;
      enum ArgumentKind : unsigned int;
    };
    struct DiagnosticBuilder {
      M_template_rtpack(Xs) struct impl;
    };
    struct DiagnosticConsumer {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {

    namespace tok {
      enum TokenKind : unsigned short;
      enum PPKeywordKind : unsigned int;
      enum ObjCKeywordKind : unsigned int;
    }
  }

  namespace clang {
    struct IdentifierInfo {
      M_template_rtpack(Xs) struct impl;
    };
    struct IdentifierInfoLookup {
      M_template_rtpack(Xs) struct impl;
    };
    struct IdentifierTable {
      M_template_rtpack(Xs) struct impl;
    };
    enum ObjCMethodFamily : unsigned int;
    enum ObjCInstanceTypeFamily : unsigned int;
    enum ObjCStringFormatFamily : unsigned int;
    struct Selector {
      M_template_rtpack(Xs) struct impl;
    };
    struct SelectorTable {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct PartialDiagnostic {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct DeclarationName {
      M_template_rtpack(Xs) struct impl;
      enum NameKind : unsigned int;
    DEF_RANGE_REFLECTION_TUPLE(getCXXIdExprArguments,
      constexpr auto getCXXIdExprArguments() const ,
        (class clang::Expr *),
        (reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::getCXXIdExprArguments, Xs...), () )
    };
    struct DeclarationNameLoc {
      M_template_rtpack(Xs) struct impl;
    };
    struct DeclarationNameInfo {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace llvm {
    struct raw_ostream {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace llvm {
    struct VersionTuple {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    enum AvailabilityResult : unsigned int;
    struct Decl {
      M_template_rtpack(Xs) struct impl;
      enum Kind : unsigned int;
      enum ObjCDeclQualifier : unsigned int;
      enum class ModuleOwnershipKind : unsigned int;
      enum FriendObjectKind : unsigned int;
    DEF_RANGE_REFLECTION_TUPLE(attrs,
      constexpr auto attrs() const ,
        (class clang::Attr *const),
        (reflenums::RK_clang__Decl, reflenums::clang__Decl::attrs, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(redecls,
      constexpr auto redecls() const ,
        (class clang::Decl *const),
        (reflenums::RK_clang__Decl, reflenums::clang__Decl::redecls, Xs...), () )
    };
    struct DeclContextLookupResult {
      M_template_rtpack(Xs) struct impl;
    };
    struct DeclContext {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(decls,
      constexpr auto decls() const ,
        (class clang::Decl *const),
        (reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::decls, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(noload_decls,
      constexpr auto noload_decls() const ,
        (class clang::Decl *const),
        (reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::noload_decls, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(lookups,
      constexpr auto lookups() const ,
        (class clang::DeclContextLookupResult),
        (reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::lookups, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(ddiags,
      constexpr auto ddiags() const ,
        (class clang::DependentDiagnostic *),
        (reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::ddiags, Xs...), () )
    };
  }

  namespace clang {
    struct CharUnits {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct FileSystemOptions {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace llvm {
    struct Twine {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace llvm {

    namespace sys {

      namespace fs {
        struct UniqueID {
          M_template_rtpack(Xs) struct impl;
        };
      }
    }
  }

  namespace llvm {
    struct MemoryBuffer {
      M_template_rtpack(Xs) struct impl;
      enum BufferKind : unsigned int;
    };
    struct MemoryBufferRef {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
  }

  namespace clang {
    struct DirectoryEntry {
      M_template_rtpack(Xs) struct impl;
    };
    struct FileEntry {
      M_template_rtpack(Xs) struct impl;
    };
    struct FileManager {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct ASTFileSignature {
      M_template_rtpack(Xs) struct impl;
    };
    struct Module {
      M_template_rtpack(Xs) struct impl;
      enum ModuleKind : unsigned int;
      enum NameVisibilityKind : unsigned int;
    DEF_RANGE_REFLECTION_TUPLE(submodules,
      constexpr auto submodules() const ,
        (class clang::Module *const),
        (reflenums::RK_clang__Module, reflenums::clang__Module::submodules, Xs...), () )
      struct Header {
        M_template_rtpack(Xs) struct impl;
      };
      struct DirectoryName {
        M_template_rtpack(Xs) struct impl;
      };
    };
  }

  namespace clang {
    struct ExternalASTSource {
      M_template_rtpack(Xs) struct impl;
      struct MemoryBufferSizes {
        M_template_rtpack(Xs) struct impl;
      };
    };
  }

  namespace clang {
  }

  namespace llvm {
    struct FoldingSetBase {
      M_template_rtpack(Xs) struct impl;
      struct Node {
        M_template_rtpack(Xs) struct impl;
      };
    };
    struct FoldingSetNodeIDRef {
      M_template_rtpack(Xs) struct impl;
    };
    struct FoldingSetNodeID {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct NestedNameSpecifier {
      M_template_rtpack(Xs) struct impl;
      enum SpecifierKind : unsigned int;
    };
    struct NestedNameSpecifierLoc {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
  }

  namespace clang {
    struct UncommonTemplateNameStorage {
      M_template_rtpack(Xs) struct impl;
    };
    struct OverloadedTemplateStorage {
      M_template_rtpack(Xs) struct impl;
    };
    struct SubstTemplateTemplateParmPackStorage {
      M_template_rtpack(Xs) struct impl;
    };
    struct TemplateName {
      M_template_rtpack(Xs) struct impl;
      enum NameKind : unsigned int;
    };
    struct SubstTemplateTemplateParmStorage {
      M_template_rtpack(Xs) struct impl;
    };
    struct QualifiedTemplateName {
      M_template_rtpack(Xs) struct impl;
    };
    struct DependentTemplateName {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    enum class LangAS : unsigned int;
  }

  namespace clang {
    enum ExceptionSpecificationType : unsigned int;
    enum CanThrowResult : unsigned int;
  }

  namespace clang {
    enum Linkage : unsigned char;
    enum LanguageLinkage : unsigned int;
    enum GVALinkage : unsigned int;
  }

  namespace clang {
    enum Visibility : unsigned int;
    struct LinkageInfo {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
  }

  namespace clang {
    struct Qualifiers {
      M_template_rtpack(Xs) struct impl;
      enum GC : unsigned int;
      enum ObjCLifetime : unsigned int;
    };
    struct SplitQualType {
      M_template_rtpack(Xs) struct impl;
    };
    enum class ObjCSubstitutionContext : int;
    struct QualType {
      M_template_rtpack(Xs) struct impl;
      enum PrimitiveDefaultInitializeKind : unsigned int;
      enum PrimitiveCopyKind : unsigned int;
      enum DestructionKind : unsigned int;
    };
  }

  namespace clang {
    struct ExtQualsTypeCommonBase {
      M_template_rtpack(Xs) struct impl;
    };
    enum RefQualifierKind : unsigned int;
    enum class AutoTypeKeyword : int;
    struct Type {
      M_template_rtpack(Xs) struct impl;
      enum TypeClass : unsigned int;
      enum ScalarTypeKind : unsigned int;
    };
    struct BuiltinType {
      M_template_rtpack(Xs) struct impl;
      enum Kind : unsigned int;
    };
    struct ComplexType {
      M_template_rtpack(Xs) struct impl;
    };
    struct ParenType {
      M_template_rtpack(Xs) struct impl;
    };
    struct PointerType {
      M_template_rtpack(Xs) struct impl;
    };
    struct AdjustedType {
      M_template_rtpack(Xs) struct impl;
    };
    struct DecayedType {
      M_template_rtpack(Xs) struct impl;
    };
    struct BlockPointerType {
      M_template_rtpack(Xs) struct impl;
    };
    struct ReferenceType {
      M_template_rtpack(Xs) struct impl;
    };
    struct LValueReferenceType {
      M_template_rtpack(Xs) struct impl;
    };
    struct RValueReferenceType {
      M_template_rtpack(Xs) struct impl;
    };
    struct MemberPointerType {
      M_template_rtpack(Xs) struct impl;
    };
    struct ArrayType {
      M_template_rtpack(Xs) struct impl;
      enum ArraySizeModifier : unsigned int;
    };
    struct ConstantArrayType {
      M_template_rtpack(Xs) struct impl;
    };
    struct IncompleteArrayType {
      M_template_rtpack(Xs) struct impl;
    };
    struct VariableArrayType {
      M_template_rtpack(Xs) struct impl;
    };
    struct DependentSizedArrayType {
      M_template_rtpack(Xs) struct impl;
    };
    struct DependentAddressSpaceType {
      M_template_rtpack(Xs) struct impl;
    };
    struct DependentSizedExtVectorType {
      M_template_rtpack(Xs) struct impl;
    };
    struct VectorType {
      M_template_rtpack(Xs) struct impl;
      enum VectorKind : unsigned int;
    };
    struct DependentVectorType {
      M_template_rtpack(Xs) struct impl;
    };
    struct ExtVectorType {
      M_template_rtpack(Xs) struct impl;
    };
    struct FunctionType {
      M_template_rtpack(Xs) struct impl;
      struct ExtInfo {
        M_template_rtpack(Xs) struct impl;
      };
    };
    struct FunctionNoProtoType {
      M_template_rtpack(Xs) struct impl;
    };
    struct FunctionProtoType {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(getParamTypes,
      constexpr auto getParamTypes() const ,
        (class clang::QualType),
        (reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::getParamTypes, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(param_types,
      constexpr auto param_types() const ,
        (const class clang::QualType),
        (reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::param_types, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(exceptions,
      constexpr auto exceptions() const ,
        (class clang::QualType),
        (reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::exceptions, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(getExtParameterInfos,
      constexpr auto getExtParameterInfos() const ,
        (class clang::FunctionProtoType::ExtParameterInfo),
        (reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::getExtParameterInfos, Xs...), () )
      struct ExtParameterInfo {
        M_template_rtpack(Xs) struct impl;
      };
      struct ExceptionSpecInfo {
        M_template_rtpack(Xs) struct impl;
      };
      struct ExtProtoInfo {
        M_template_rtpack(Xs) struct impl;
      };
    };
    struct UnresolvedUsingType {
      M_template_rtpack(Xs) struct impl;
    };
    struct TypedefType {
      M_template_rtpack(Xs) struct impl;
    };
    struct TypeOfExprType {
      M_template_rtpack(Xs) struct impl;
    };
    struct TypeOfType {
      M_template_rtpack(Xs) struct impl;
    };
    struct DecltypeType {
      M_template_rtpack(Xs) struct impl;
    };
    struct ReflectedType {
      M_template_rtpack(Xs) struct impl;
    };
    struct UnaryTransformType {
      M_template_rtpack(Xs) struct impl;
      enum UTTKind : unsigned int;
    };
    struct TagType {
      M_template_rtpack(Xs) struct impl;
    };
    struct RecordType {
      M_template_rtpack(Xs) struct impl;
    };
    struct EnumType {
      M_template_rtpack(Xs) struct impl;
    };
    struct AttributedType {
      M_template_rtpack(Xs) struct impl;
      enum Kind : unsigned int;
    };
    struct TemplateTypeParmType {
      M_template_rtpack(Xs) struct impl;
    };
    struct SubstTemplateTypeParmType {
      M_template_rtpack(Xs) struct impl;
    };
    struct SubstTemplateTypeParmPackType {
      M_template_rtpack(Xs) struct impl;
    };
    struct DeducedType {
      M_template_rtpack(Xs) struct impl;
    };
    struct AutoType {
      M_template_rtpack(Xs) struct impl;
    };
    struct DeducedTemplateSpecializationType {
      M_template_rtpack(Xs) struct impl;
    };
    struct TemplateSpecializationType {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(template_arguments,
      constexpr auto template_arguments() const ,
        (class clang::TemplateArgument),
        (reflenums::RK_clang__TemplateSpecializationType, reflenums::clang__TemplateSpecializationType::template_arguments, Xs...), () )
    };
    struct InjectedClassNameType {
      M_template_rtpack(Xs) struct impl;
    };
    enum TagTypeKind : unsigned int;
    enum ElaboratedTypeKeyword : unsigned int;
    struct TypeWithKeyword {
      M_template_rtpack(Xs) struct impl;
    };
    struct ElaboratedType {
      M_template_rtpack(Xs) struct impl;
    };
    struct DependentNameType {
      M_template_rtpack(Xs) struct impl;
    };
    struct DependentTemplateSpecializationType {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(template_arguments,
      constexpr auto template_arguments() const ,
        (class clang::TemplateArgument),
        (reflenums::RK_clang__DependentTemplateSpecializationType, reflenums::clang__DependentTemplateSpecializationType::template_arguments, Xs...), () )
    };
    struct PackExpansionType {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCTypeParamType {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(quals,
      constexpr auto quals() const ,
        (class clang::ObjCProtocolDecl *const),
        (reflenums::RK_clang__ObjCTypeParamType, reflenums::clang__ObjCTypeParamType::quals, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(getProtocols,
      constexpr auto getProtocols() const ,
        (class clang::ObjCProtocolDecl *),
        (reflenums::RK_clang__ObjCTypeParamType, reflenums::clang__ObjCTypeParamType::getProtocols, Xs...), () )
    };
    struct ObjCObjectType {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(quals,
      constexpr auto quals() const ,
        (class clang::ObjCProtocolDecl *const),
        (reflenums::RK_clang__ObjCObjectType, reflenums::clang__ObjCObjectType::quals, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(getProtocols,
      constexpr auto getProtocols() const ,
        (class clang::ObjCProtocolDecl *),
        (reflenums::RK_clang__ObjCObjectType, reflenums::clang__ObjCObjectType::getProtocols, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(getTypeArgs,
      constexpr auto getTypeArgs() const ,
        (class clang::QualType),
        (reflenums::RK_clang__ObjCObjectType, reflenums::clang__ObjCObjectType::getTypeArgs, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(getTypeArgsAsWritten,
      constexpr auto getTypeArgsAsWritten() const ,
        (class clang::QualType),
        (reflenums::RK_clang__ObjCObjectType, reflenums::clang__ObjCObjectType::getTypeArgsAsWritten, Xs...), () )
    };
    struct ObjCInterfaceType {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCObjectPointerType {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(getTypeArgs,
      constexpr auto getTypeArgs() const ,
        (class clang::QualType),
        (reflenums::RK_clang__ObjCObjectPointerType, reflenums::clang__ObjCObjectPointerType::getTypeArgs, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(getTypeArgsAsWritten,
      constexpr auto getTypeArgsAsWritten() const ,
        (class clang::QualType),
        (reflenums::RK_clang__ObjCObjectPointerType, reflenums::clang__ObjCObjectPointerType::getTypeArgsAsWritten, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(quals,
      constexpr auto quals() const ,
        (class clang::ObjCProtocolDecl *const),
        (reflenums::RK_clang__ObjCObjectPointerType, reflenums::clang__ObjCObjectPointerType::quals, Xs...), () )
    };
    struct AtomicType {
      M_template_rtpack(Xs) struct impl;
    };
    struct PipeType {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    enum OverloadedOperatorKind : int;
  }

  namespace clang {
    enum PragmaMSCommentKind : unsigned int;
  }

  namespace clang {
    struct TypeSourceInfo {
      M_template_rtpack(Xs) struct impl;
    };
    struct TranslationUnitDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct PragmaCommentDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct PragmaDetectMismatchDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct ExternCContextDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct NamedDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct LabelDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct NamespaceDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct ValueDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct DeclaratorDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct EvaluatedStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct VarDecl {
      M_template_rtpack(Xs) struct impl;
      enum InitializationStyle : unsigned int;
      enum TLSKind : unsigned int;
      enum DefinitionKind : unsigned int;
    };
    struct ImplicitParamDecl {
      M_template_rtpack(Xs) struct impl;
      enum ImplicitParamKind : unsigned int;
    };
    struct ParmVarDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct FunctionDecl {
      M_template_rtpack(Xs) struct impl;
      enum TemplatedKind : unsigned int;
    DEF_RANGE_REFLECTION_TUPLE(parameters,
      constexpr auto parameters() const ,
        (class clang::ParmVarDecl *),
        (reflenums::RK_clang__FunctionDecl, reflenums::clang__FunctionDecl::parameters, Xs...), () )
    };
    struct FieldDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct EnumConstantDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct IndirectFieldDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(chain,
      constexpr auto chain() const ,
        (class clang::NamedDecl *),
        (reflenums::RK_clang__IndirectFieldDecl, reflenums::clang__IndirectFieldDecl::chain, Xs...), () )
    };
    struct TypeDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct TypedefNameDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct TypedefDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct TypeAliasDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct TagDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct EnumDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(enumerators,
      constexpr auto enumerators() const ,
        (class clang::EnumConstantDecl *),
        (reflenums::RK_clang__EnumDecl, reflenums::clang__EnumDecl::enumerators, Xs...), () )
    };
    struct RecordDecl {
      M_template_rtpack(Xs) struct impl;
      enum ArgPassingKind : unsigned int;
    DEF_RANGE_REFLECTION_TUPLE(fields,
      constexpr auto fields() const ,
        (class clang::FieldDecl *),
        (reflenums::RK_clang__RecordDecl, reflenums::clang__RecordDecl::fields, Xs...), () )
    };
    struct FileScopeAsmDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct BlockDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(parameters,
      constexpr auto parameters() const ,
        (class clang::ParmVarDecl *),
        (reflenums::RK_clang__BlockDecl, reflenums::clang__BlockDecl::parameters, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(captures,
      constexpr auto captures() const ,
        (class clang::BlockDecl::Capture),
        (reflenums::RK_clang__BlockDecl, reflenums::clang__BlockDecl::captures, Xs...), () )
      struct Capture {
        M_template_rtpack(Xs) struct impl;
      };
    };
    struct CapturedDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(parameters,
      constexpr auto parameters() const ,
        (class clang::ImplicitParamDecl *),
        (reflenums::RK_clang__CapturedDecl, reflenums::clang__CapturedDecl::parameters, Xs...), () )
    };
    struct ImportDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(getIdentifierLocs,
      constexpr auto getIdentifierLocs() const ,
        (class clang::SourceLocation),
        (reflenums::RK_clang__ImportDecl, reflenums::clang__ImportDecl::getIdentifierLocs, Xs...), () )
    };
    struct ExportDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct EmptyDecl {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct DeclGroup {
      M_template_rtpack(Xs) struct impl;
    };
    struct DeclGroupRef {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
  }

  namespace clang {
    enum CapturedRegionKind : unsigned int;
  }

  namespace clang {
    struct Stmt {
      M_template_rtpack(Xs) struct impl;
      enum StmtClass : unsigned int;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__Stmt, reflenums::clang__Stmt::children, Xs...), () )
      struct EmptyShell {
        M_template_rtpack(Xs) struct impl;
      };
    };
    struct DeclStmt {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(decls,
      constexpr auto decls() const ,
        (class clang::Decl *const),
        (reflenums::RK_clang__DeclStmt, reflenums::clang__DeclStmt::decls, Xs...), () )
    };
    struct NullStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct CompoundStmt {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(body,
      constexpr auto body() const ,
        (class clang::Stmt *const),
        (reflenums::RK_clang__CompoundStmt, reflenums::clang__CompoundStmt::body, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__CompoundStmt, reflenums::clang__CompoundStmt::children, Xs...), () )
    };
    struct SwitchCase {
      M_template_rtpack(Xs) struct impl;
    };
    struct CaseStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct DefaultStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct LabelStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct AttributedStmt {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(getAttrs,
      constexpr auto getAttrs() const ,
        (const class clang::Attr *),
        (reflenums::RK_clang__AttributedStmt, reflenums::clang__AttributedStmt::getAttrs, Xs...), () )
    };
    struct IfStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct SwitchStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct WhileStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct DoStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct ForStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct GotoStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct IndirectGotoStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct ContinueStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct BreakStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct ReturnStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct AsmStmt {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(inputs,
      constexpr auto inputs() const ,
        (const class clang::Expr *const),
        (reflenums::RK_clang__AsmStmt, reflenums::clang__AsmStmt::inputs, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(outputs,
      constexpr auto outputs() const ,
        (const class clang::Expr *const),
        (reflenums::RK_clang__AsmStmt, reflenums::clang__AsmStmt::outputs, Xs...), () )
    };
    struct GCCAsmStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct MSAsmStmt {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(getAllConstraints,
      constexpr auto getAllConstraints() const ,
        (class llvm::StringRef),
        (reflenums::RK_clang__MSAsmStmt, reflenums::clang__MSAsmStmt::getAllConstraints, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(getClobbers,
      constexpr auto getClobbers() const ,
        (class llvm::StringRef),
        (reflenums::RK_clang__MSAsmStmt, reflenums::clang__MSAsmStmt::getClobbers, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(getAllExprs,
      constexpr auto getAllExprs() const ,
        (class clang::Expr *),
        (reflenums::RK_clang__MSAsmStmt, reflenums::clang__MSAsmStmt::getAllExprs, Xs...), () )
    };
    struct SEHExceptStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct SEHFinallyStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct SEHTryStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct SEHLeaveStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct CapturedStmt {
      M_template_rtpack(Xs) struct impl;
      enum VariableCaptureKind : unsigned int;
    DEF_RANGE_REFLECTION_TUPLE(captures,
      constexpr auto captures() const ,
        (const class clang::CapturedStmt::Capture),
        (reflenums::RK_clang__CapturedStmt, reflenums::clang__CapturedStmt::captures, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(capture_inits,
      constexpr auto capture_inits() const ,
        (class clang::Expr *const),
        (reflenums::RK_clang__CapturedStmt, reflenums::clang__CapturedStmt::capture_inits, Xs...), () )
      struct Capture {
        M_template_rtpack(Xs) struct impl;
      };
    };
  }

  namespace clang {
    struct TemplateArgument {
      M_template_rtpack(Xs) struct impl;
      enum ArgKind : unsigned int;
    DEF_RANGE_REFLECTION_TUPLE(pack_elements,
      constexpr auto pack_elements() const ,
        (class clang::TemplateArgument),
        (reflenums::RK_clang__TemplateArgument, reflenums::clang__TemplateArgument::pack_elements, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(getPackAsArray,
      constexpr auto getPackAsArray() const ,
        (class clang::TemplateArgument),
        (reflenums::RK_clang__TemplateArgument, reflenums::clang__TemplateArgument::getPackAsArray, Xs...), () )
    };
    struct TemplateArgumentLocInfo {
      M_template_rtpack(Xs) struct impl;
    };
    struct TemplateArgumentLoc {
      M_template_rtpack(Xs) struct impl;
    };
    struct TemplateArgumentListInfo {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(arguments,
      constexpr auto arguments() const ,
        (class clang::TemplateArgumentLoc),
        (reflenums::RK_clang__TemplateArgumentListInfo, reflenums::clang__TemplateArgumentListInfo::arguments, Xs...), () )
    };
    struct ASTTemplateArgumentListInfo {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(arguments,
      constexpr auto arguments() const ,
        (class clang::TemplateArgumentLoc),
        (reflenums::RK_clang__ASTTemplateArgumentListInfo, reflenums::clang__ASTTemplateArgumentListInfo::arguments, Xs...), () )
    };
  }

  namespace clang {
    struct TypeLoc {
      M_template_rtpack(Xs) struct impl;
      enum TypeLocClass : unsigned int;
    };
    struct UnqualTypeLoc {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
  }

  namespace clang {
  }

  namespace clang {
  }

  namespace clang {
    struct CommentOptions {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {

    namespace comments {
      struct CommandInfo {
        M_template_rtpack(Xs) struct impl;
      };
      struct CommandTraits {
        M_template_rtpack(Xs) struct impl;
      };
    }
  }

  namespace clang {
  }

  namespace llvm {
    struct Triple {
      M_template_rtpack(Xs) struct impl;
      enum ArchType : unsigned int;
      enum SubArchType : unsigned int;
      enum VendorType : unsigned int;
      enum OSType : unsigned int;
      enum EnvironmentType : unsigned int;
      enum ObjectFormatType : unsigned int;
    };
  }

  namespace clang {
    struct ObjCRuntime {
      M_template_rtpack(Xs) struct impl;
      enum Kind : unsigned int;
    };
  }

  namespace clang {
    struct SanitizerSet {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct LangOptionsBase {
      M_template_rtpack(Xs) struct impl;
    };
    struct LangOptions {
      M_template_rtpack(Xs) struct impl;
      enum GCMode : unsigned int;
      enum StackProtectorMode : unsigned int;
      enum SignedOverflowBehaviorTy : unsigned int;
      enum CompilingModuleKind : unsigned int;
      enum PragmaMSPointersToMembersKind : unsigned int;
      enum DefaultCallingConvention : unsigned int;
      enum AddrSpaceMapMangling : unsigned int;
      enum MSVCMajorVersion : unsigned int;
      enum class ClangABI : int;
      enum FPContractModeKind : unsigned int;
    };
    struct FPOptions {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct PrinterHelper {
      M_template_rtpack(Xs) struct impl;
    };
    struct PrintingPolicy {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {

    namespace SrcMgr {
      enum CharacteristicKind : unsigned int;
      struct ContentCache {
        M_template_rtpack(Xs) struct impl;
      };
      struct FileInfo {
        M_template_rtpack(Xs) struct impl;
      };
      struct ExpansionInfo {
        M_template_rtpack(Xs) struct impl;
      };
      struct SLocEntry {
        M_template_rtpack(Xs) struct impl;
      };
    }
    struct SourceManager {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct RawComment {
      M_template_rtpack(Xs) struct impl;
      enum CommentKind : unsigned int;
    };
  }

  namespace clang {
  }

  namespace clang {
    struct SanitizerBlacklist {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct TargetCXXABI {
      M_template_rtpack(Xs) struct impl;
      enum Kind : unsigned int;
      enum TailPaddingUseRules : unsigned int;
    };
  }

  namespace clang {
    struct OpenCLOptions {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace llvm {
    enum class EABI : int;
  }

  namespace clang {
    struct TargetOptions {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace llvm {
    struct Type {
      M_template_rtpack(Xs) struct impl;
      enum TypeID : unsigned int;
    DEF_RANGE_REFLECTION_TUPLE(subtypes,
      constexpr auto subtypes() const ,
        (class llvm::Type *),
        (reflenums::RK_llvm__Type, reflenums::llvm__Type::subtypes, Xs...), () )
    };
  }

  namespace llvm {
    struct IntegerType {
      M_template_rtpack(Xs) struct impl;
    };
    struct CompositeType {
      M_template_rtpack(Xs) struct impl;
    };
    struct StructType {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(elements,
      constexpr auto elements() const ,
        (class llvm::Type *),
        (reflenums::RK_llvm__StructType, reflenums::llvm__StructType::elements, Xs...), () )
    };
    struct PointerType {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace llvm {
    struct DataLayout {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(getNonIntegralAddressSpaces,
      constexpr auto getNonIntegralAddressSpaces() const ,
        (unsigned int),
        (reflenums::RK_llvm__DataLayout, reflenums::llvm__DataLayout::getNonIntegralAddressSpaces, Xs...), () )
    };
    struct StructLayout {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct TargetInfo {
      M_template_rtpack(Xs) struct impl;
      enum IntType : unsigned int;
      enum RealType : unsigned int;
      enum BuiltinVaListKind : unsigned int;
      enum CallingConvMethodType : unsigned int;
      enum CallingConvCheckResult : unsigned int;
      enum CallingConvKind : unsigned int;
      enum OpenCLTypeKind : unsigned int;
      struct ConstraintInfo {
        M_template_rtpack(Xs) struct impl;
      };
    };
  }

  namespace clang {
    struct XRayFunctionFilter {
      M_template_rtpack(Xs) struct impl;
      enum class ImbueAttribute : int;
    };
  }

  namespace clang {
    struct TypeInfo {
      M_template_rtpack(Xs) struct impl;
    };
    struct ASTContext {
      M_template_rtpack(Xs) struct impl;
      enum class InlineVariableDefinitionKind : int;
    DEF_RANGE_REFLECTION_TUPLE(local_imports,
      constexpr auto local_imports() const ,
        (class clang::ImportDecl *),
        (reflenums::RK_clang__ASTContext, reflenums::clang__ASTContext::local_imports, Xs...), () )
    };
  }

  namespace clang {
  }

  namespace clang {
    struct DeclAccessPair {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct UnresolvedSetIterator {
      M_template_rtpack(Xs) struct impl;
    };
    struct UnresolvedSetImpl {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
  }

  namespace clang {
    enum CastKind : unsigned int;
    enum BinaryOperatorKind : unsigned int;
    enum UnaryOperatorKind : unsigned int;
    enum ObjCBridgeCastKind : unsigned int;
  }

  namespace clang {
  }

  namespace clang {
  }

  namespace clang {
    enum TypeTrait : unsigned int;
    enum ArrayTypeTrait : unsigned int;
    enum UnaryExprOrTypeTrait : unsigned int;
  }

  namespace clang {
    struct Expr {
      M_template_rtpack(Xs) struct impl;
      enum LValueClassification : unsigned int;
      enum isModifiableLvalueResult : unsigned int;
      enum SideEffectsKind : unsigned int;
      enum ConstExprUsage : unsigned int;
      enum NullPointerConstantKind : unsigned int;
      enum NullPointerConstantValueDependence : unsigned int;
      struct Classification {
        M_template_rtpack(Xs) struct impl;
        enum Kinds : unsigned int;
        enum ModifiableType : unsigned int;
      };
      struct EvalStatus {
        M_template_rtpack(Xs) struct impl;
      };
      struct EvalResult {
        M_template_rtpack(Xs) struct impl;
      };
    };
    struct OpaqueValueExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__OpaqueValueExpr, reflenums::clang__OpaqueValueExpr::children, Xs...), () )
    };
    struct DeclRefExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(template_arguments,
      constexpr auto template_arguments() const ,
        (class clang::TemplateArgumentLoc),
        (reflenums::RK_clang__DeclRefExpr, reflenums::clang__DeclRefExpr::template_arguments, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__DeclRefExpr, reflenums::clang__DeclRefExpr::children, Xs...), () )
    };
    struct PredefinedExpr {
      M_template_rtpack(Xs) struct impl;
      enum IdentType : unsigned int;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__PredefinedExpr, reflenums::clang__PredefinedExpr::children, Xs...), () )
    };
    struct APIntStorage {
      M_template_rtpack(Xs) struct impl;
    };
    struct IntegerLiteral {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__IntegerLiteral, reflenums::clang__IntegerLiteral::children, Xs...), () )
    };
    struct FixedPointLiteral {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__FixedPointLiteral, reflenums::clang__FixedPointLiteral::children, Xs...), () )
    };
    struct CharacterLiteral {
      M_template_rtpack(Xs) struct impl;
      enum CharacterKind : unsigned int;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__CharacterLiteral, reflenums::clang__CharacterLiteral::children, Xs...), () )
    };
    struct FloatingLiteral {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__FloatingLiteral, reflenums::clang__FloatingLiteral::children, Xs...), () )
    };
    struct ImaginaryLiteral {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__ImaginaryLiteral, reflenums::clang__ImaginaryLiteral::children, Xs...), () )
    };
    struct StringLiteral {
      M_template_rtpack(Xs) struct impl;
      enum StringKind : unsigned int;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__StringLiteral, reflenums::clang__StringLiteral::children, Xs...), () )
    };
    struct ParenExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__ParenExpr, reflenums::clang__ParenExpr::children, Xs...), () )
    };
    struct UnaryOperator {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__UnaryOperator, reflenums::clang__UnaryOperator::children, Xs...), () )
    };
    struct OffsetOfNode {
      M_template_rtpack(Xs) struct impl;
      enum Kind : unsigned int;
    };
    struct OffsetOfExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__OffsetOfExpr, reflenums::clang__OffsetOfExpr::children, Xs...), () )
    };
    struct UnaryExprOrTypeTraitExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__UnaryExprOrTypeTraitExpr, reflenums::clang__UnaryExprOrTypeTraitExpr::children, Xs...), () )
    };
    struct ArraySubscriptExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__ArraySubscriptExpr, reflenums::clang__ArraySubscriptExpr::children, Xs...), () )
    };
    struct CallExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(arguments,
      constexpr auto arguments() const ,
        (const class clang::Expr *const),
        (reflenums::RK_clang__CallExpr, reflenums::clang__CallExpr::arguments, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__CallExpr, reflenums::clang__CallExpr::children, Xs...), () )
    };
    struct MemberExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(template_arguments,
      constexpr auto template_arguments() const ,
        (class clang::TemplateArgumentLoc),
        (reflenums::RK_clang__MemberExpr, reflenums::clang__MemberExpr::template_arguments, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__MemberExpr, reflenums::clang__MemberExpr::children, Xs...), () )
    };
    struct CompoundLiteralExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__CompoundLiteralExpr, reflenums::clang__CompoundLiteralExpr::children, Xs...), () )
    };
    struct CastExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__CastExpr, reflenums::clang__CastExpr::children, Xs...), () )
    };
    struct ImplicitCastExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct ExplicitCastExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CStyleCastExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct BinaryOperator {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__BinaryOperator, reflenums::clang__BinaryOperator::children, Xs...), () )
    };
    struct CompoundAssignOperator {
      M_template_rtpack(Xs) struct impl;
    };
    struct AbstractConditionalOperator {
      M_template_rtpack(Xs) struct impl;
    };
    struct ConditionalOperator {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__ConditionalOperator, reflenums::clang__ConditionalOperator::children, Xs...), () )
    };
    struct BinaryConditionalOperator {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__BinaryConditionalOperator, reflenums::clang__BinaryConditionalOperator::children, Xs...), () )
    };
    struct AddrLabelExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__AddrLabelExpr, reflenums::clang__AddrLabelExpr::children, Xs...), () )
    };
    struct StmtExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__StmtExpr, reflenums::clang__StmtExpr::children, Xs...), () )
    };
    struct ShuffleVectorExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__ShuffleVectorExpr, reflenums::clang__ShuffleVectorExpr::children, Xs...), () )
    };
    struct ConvertVectorExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__ConvertVectorExpr, reflenums::clang__ConvertVectorExpr::children, Xs...), () )
    };
    struct ChooseExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__ChooseExpr, reflenums::clang__ChooseExpr::children, Xs...), () )
    };
    struct GNUNullExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__GNUNullExpr, reflenums::clang__GNUNullExpr::children, Xs...), () )
    };
    struct VAArgExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__VAArgExpr, reflenums::clang__VAArgExpr::children, Xs...), () )
    };
    struct InitListExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(inits,
      constexpr auto inits() const ,
        (class clang::Expr *),
        (reflenums::RK_clang__InitListExpr, reflenums::clang__InitListExpr::inits, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__InitListExpr, reflenums::clang__InitListExpr::children, Xs...), () )
    };
    struct DesignatedInitExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(designators,
      constexpr auto designators() const ,
        (class clang::DesignatedInitExpr::Designator),
        (reflenums::RK_clang__DesignatedInitExpr, reflenums::clang__DesignatedInitExpr::designators, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__DesignatedInitExpr, reflenums::clang__DesignatedInitExpr::children, Xs...), () )
      struct Designator {
        M_template_rtpack(Xs) struct impl;
      };
    };
    struct NoInitExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__NoInitExpr, reflenums::clang__NoInitExpr::children, Xs...), () )
    };
    struct DesignatedInitUpdateExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__DesignatedInitUpdateExpr, reflenums::clang__DesignatedInitUpdateExpr::children, Xs...), () )
    };
    struct ArrayInitLoopExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__ArrayInitLoopExpr, reflenums::clang__ArrayInitLoopExpr::children, Xs...), () )
    };
    struct ArrayInitIndexExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__ArrayInitIndexExpr, reflenums::clang__ArrayInitIndexExpr::children, Xs...), () )
    };
    struct ImplicitValueInitExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__ImplicitValueInitExpr, reflenums::clang__ImplicitValueInitExpr::children, Xs...), () )
    };
    struct ParenListExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__ParenListExpr, reflenums::clang__ParenListExpr::children, Xs...), () )
    };
    struct GenericSelectionExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(getAssocExprs,
      constexpr auto getAssocExprs() const ,
        (class clang::Expr *),
        (reflenums::RK_clang__GenericSelectionExpr, reflenums::clang__GenericSelectionExpr::getAssocExprs, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(getAssocTypeSourceInfos,
      constexpr auto getAssocTypeSourceInfos() const ,
        (class clang::TypeSourceInfo *),
        (reflenums::RK_clang__GenericSelectionExpr, reflenums::clang__GenericSelectionExpr::getAssocTypeSourceInfos, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__GenericSelectionExpr, reflenums::clang__GenericSelectionExpr::children, Xs...), () )
    };
    struct ExtVectorElementExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__ExtVectorElementExpr, reflenums::clang__ExtVectorElementExpr::children, Xs...), () )
    };
    struct BlockExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__BlockExpr, reflenums::clang__BlockExpr::children, Xs...), () )
    };
    struct AsTypeExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__AsTypeExpr, reflenums::clang__AsTypeExpr::children, Xs...), () )
    };
    struct PseudoObjectExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(semantics,
      constexpr auto semantics() const ,
        (const class clang::Expr *const),
        (reflenums::RK_clang__PseudoObjectExpr, reflenums::clang__PseudoObjectExpr::semantics, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__PseudoObjectExpr, reflenums::clang__PseudoObjectExpr::children, Xs...), () )
    };
    struct AtomicExpr {
      M_template_rtpack(Xs) struct impl;
      enum AtomicOp : unsigned int;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__AtomicExpr, reflenums::clang__AtomicExpr::children, Xs...), () )
    };
    struct TypoExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__TypoExpr, reflenums::clang__TypoExpr::children, Xs...), () )
    };
  }

  namespace clang {

    namespace attr {
      enum Kind : unsigned int;
    }
  }

  namespace clang {
    enum OpenMPDirectiveKind : unsigned int;
    enum OpenMPClauseKind : unsigned int;
  }

  namespace clang {
    struct Attr {
      M_template_rtpack(Xs) struct impl;
    };
    struct InheritableAttr {
      M_template_rtpack(Xs) struct impl;
    };
    struct ExternalSourceSymbolAttr {
      M_template_rtpack(Xs) struct impl;
    };
    struct MSInheritanceAttr {
      M_template_rtpack(Xs) struct impl;
      enum Spelling : unsigned int;
    };
    struct MSVtorDispAttr {
      M_template_rtpack(Xs) struct impl;
      enum Mode : unsigned int;
    };
  }

  namespace clang {
    enum LambdaCaptureDefault : unsigned int;
    enum LambdaCaptureKind : unsigned int;
  }

  namespace clang {
    struct LambdaCapture {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
  }

  namespace clang {
  }

  namespace clang {
  }

  namespace clang {
  }

  namespace clang {
  }

  namespace clang {
    struct AccessSpecDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXBaseSpecifier {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXRecordDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(bases,
      constexpr auto bases() const ,
        (const class clang::CXXBaseSpecifier),
        (reflenums::RK_clang__CXXRecordDecl, reflenums::clang__CXXRecordDecl::bases, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(vbases,
      constexpr auto vbases() const ,
        (const class clang::CXXBaseSpecifier),
        (reflenums::RK_clang__CXXRecordDecl, reflenums::clang__CXXRecordDecl::vbases, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(methods,
      constexpr auto methods() const ,
        (class clang::CXXMethodDecl *),
        (reflenums::RK_clang__CXXRecordDecl, reflenums::clang__CXXRecordDecl::methods, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(ctors,
      constexpr auto ctors() const ,
        (class clang::CXXConstructorDecl *),
        (reflenums::RK_clang__CXXRecordDecl, reflenums::clang__CXXRecordDecl::ctors, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(friends,
      constexpr auto friends() const ,
        (class clang::FriendDecl *),
        (reflenums::RK_clang__CXXRecordDecl, reflenums::clang__CXXRecordDecl::friends, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(captures,
      constexpr auto captures() const ,
        (const class clang::LambdaCapture),
        (reflenums::RK_clang__CXXRecordDecl, reflenums::clang__CXXRecordDecl::captures, Xs...), () )
    };
    struct CXXDeductionGuideDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXMethodDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXCtorInitializer {
      M_template_rtpack(Xs) struct impl;
    };
    struct InheritedConstructor {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXConstructorDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(inits,
      constexpr auto inits() const ,
        (class clang::CXXCtorInitializer *const),
        (reflenums::RK_clang__CXXConstructorDecl, reflenums::clang__CXXConstructorDecl::inits, Xs...), () )
    };
    struct CXXDestructorDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXConversionDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct LinkageSpecDecl {
      M_template_rtpack(Xs) struct impl;
      enum LanguageIDs : unsigned int;
    };
    struct UsingDirectiveDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct NamespaceAliasDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct UsingShadowDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct ConstructorUsingShadowDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct UsingDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(shadows,
      constexpr auto shadows() const ,
        (class clang::UsingShadowDecl *),
        (reflenums::RK_clang__UsingDecl, reflenums::clang__UsingDecl::shadows, Xs...), () )
    };
    struct UsingPackDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(expansions,
      constexpr auto expansions() const ,
        (class clang::NamedDecl *),
        (reflenums::RK_clang__UsingPackDecl, reflenums::clang__UsingPackDecl::expansions, Xs...), () )
    };
    struct UnresolvedUsingValueDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct UnresolvedUsingTypenameDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct StaticAssertDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct BindingDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct DecompositionDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(bindings,
      constexpr auto bindings() const ,
        (class clang::BindingDecl *),
        (reflenums::RK_clang__DecompositionDecl, reflenums::clang__DecompositionDecl::bindings, Xs...), () )
    };
    struct MSPropertyDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct ConstexprDecl {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct TemplateParameterList {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(asArray,
      constexpr auto asArray() const ,
        (const class clang::NamedDecl *),
        (reflenums::RK_clang__TemplateParameterList, reflenums::clang__TemplateParameterList::asArray, Xs...), () )
    };
    struct TemplateArgumentList {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(asArray,
      constexpr auto asArray() const ,
        (class clang::TemplateArgument),
        (reflenums::RK_clang__TemplateArgumentList, reflenums::clang__TemplateArgumentList::asArray, Xs...), () )
    };
    struct TemplateDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct FunctionTemplateSpecializationInfo {
      M_template_rtpack(Xs) struct impl;
    };
    struct MemberSpecializationInfo {
      M_template_rtpack(Xs) struct impl;
    };
    struct DependentFunctionTemplateSpecializationInfo {
      M_template_rtpack(Xs) struct impl;
    };
    struct RedeclarableTemplateDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct FunctionTemplateDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(specializations,
      constexpr auto specializations() const ,
        (class clang::FunctionDecl *),
        (reflenums::RK_clang__FunctionTemplateDecl, reflenums::clang__FunctionTemplateDecl::specializations, Xs...), () )
    };
    struct TemplateTypeParmDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct NonTypeTemplateParmDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct TemplateTemplateParmDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct BuiltinTemplateDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct ClassTemplateSpecializationDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct ClassTemplatePartialSpecializationDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct ClassTemplateDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(specializations,
      constexpr auto specializations() const ,
        (class clang::ClassTemplateSpecializationDecl *),
        (reflenums::RK_clang__ClassTemplateDecl, reflenums::clang__ClassTemplateDecl::specializations, Xs...), () )
    };
    struct FriendTemplateDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct TypeAliasTemplateDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct ClassScopeFunctionSpecializationDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct VarTemplateSpecializationDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct VarTemplatePartialSpecializationDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct VarTemplateDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(specializations,
      constexpr auto specializations() const ,
        (class clang::VarTemplateSpecializationDecl *),
        (reflenums::RK_clang__VarTemplateDecl, reflenums::clang__VarTemplateDecl::specializations, Xs...), () )
    };
  }

  namespace clang {
    struct FriendDecl {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
  }

  namespace clang {
    struct ObjCListBase {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCProtocolList {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCMethodDecl {
      M_template_rtpack(Xs) struct impl;
      enum ImplementationControl : unsigned int;
    DEF_RANGE_REFLECTION_TUPLE(parameters,
      constexpr auto parameters() const ,
        (class clang::ParmVarDecl *),
        (reflenums::RK_clang__ObjCMethodDecl, reflenums::clang__ObjCMethodDecl::parameters, Xs...), () )
    };
    enum class ObjCTypeParamVariance : uint8_t;
    struct ObjCTypeParamDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCTypeParamList {
      M_template_rtpack(Xs) struct impl;
    };
    enum class ObjCPropertyQueryKind : uint8_t;
    struct ObjCPropertyDecl {
      M_template_rtpack(Xs) struct impl;
      enum PropertyAttributeKind : unsigned int;
      enum SetterKind : unsigned int;
      enum PropertyControl : unsigned int;
    };
    struct ObjCContainerDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(properties,
      constexpr auto properties() const ,
        (class clang::ObjCPropertyDecl *),
        (reflenums::RK_clang__ObjCContainerDecl, reflenums::clang__ObjCContainerDecl::properties, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(instance_properties,
      constexpr auto instance_properties() const ,
        (class clang::ObjCPropertyDecl *),
        (reflenums::RK_clang__ObjCContainerDecl, reflenums::clang__ObjCContainerDecl::instance_properties, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(class_properties,
      constexpr auto class_properties() const ,
        (class clang::ObjCPropertyDecl *),
        (reflenums::RK_clang__ObjCContainerDecl, reflenums::clang__ObjCContainerDecl::class_properties, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(methods,
      constexpr auto methods() const ,
        (class clang::ObjCMethodDecl *),
        (reflenums::RK_clang__ObjCContainerDecl, reflenums::clang__ObjCContainerDecl::methods, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(instance_methods,
      constexpr auto instance_methods() const ,
        (class clang::ObjCMethodDecl *),
        (reflenums::RK_clang__ObjCContainerDecl, reflenums::clang__ObjCContainerDecl::instance_methods, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(class_methods,
      constexpr auto class_methods() const ,
        (class clang::ObjCMethodDecl *),
        (reflenums::RK_clang__ObjCContainerDecl, reflenums::clang__ObjCContainerDecl::class_methods, Xs...), () )
    };
    struct ObjCInterfaceDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(protocols,
      constexpr auto protocols() const ,
        (class clang::ObjCProtocolDecl *const),
        (reflenums::RK_clang__ObjCInterfaceDecl, reflenums::clang__ObjCInterfaceDecl::protocols, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(protocol_locs,
      constexpr auto protocol_locs() const ,
        (const class clang::SourceLocation),
        (reflenums::RK_clang__ObjCInterfaceDecl, reflenums::clang__ObjCInterfaceDecl::protocol_locs, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(all_referenced_protocols,
      constexpr auto all_referenced_protocols() const ,
        (class clang::ObjCProtocolDecl *const),
        (reflenums::RK_clang__ObjCInterfaceDecl, reflenums::clang__ObjCInterfaceDecl::all_referenced_protocols, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(ivars,
      constexpr auto ivars() const ,
        (class clang::ObjCIvarDecl *),
        (reflenums::RK_clang__ObjCInterfaceDecl, reflenums::clang__ObjCInterfaceDecl::ivars, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(visible_categories,
      constexpr auto visible_categories() const ,
        (class clang::ObjCCategoryDecl *),
        (reflenums::RK_clang__ObjCInterfaceDecl, reflenums::clang__ObjCInterfaceDecl::visible_categories, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(known_categories,
      constexpr auto known_categories() const ,
        (class clang::ObjCCategoryDecl *),
        (reflenums::RK_clang__ObjCInterfaceDecl, reflenums::clang__ObjCInterfaceDecl::known_categories, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(visible_extensions,
      constexpr auto visible_extensions() const ,
        (class clang::ObjCCategoryDecl *),
        (reflenums::RK_clang__ObjCInterfaceDecl, reflenums::clang__ObjCInterfaceDecl::visible_extensions, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(known_extensions,
      constexpr auto known_extensions() const ,
        (class clang::ObjCCategoryDecl *),
        (reflenums::RK_clang__ObjCInterfaceDecl, reflenums::clang__ObjCInterfaceDecl::known_extensions, Xs...), () )
    };
    struct ObjCIvarDecl {
      M_template_rtpack(Xs) struct impl;
      enum AccessControl : unsigned int;
    };
    struct ObjCAtDefsFieldDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCProtocolDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(protocols,
      constexpr auto protocols() const ,
        (class clang::ObjCProtocolDecl *const),
        (reflenums::RK_clang__ObjCProtocolDecl, reflenums::clang__ObjCProtocolDecl::protocols, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(protocol_locs,
      constexpr auto protocol_locs() const ,
        (const class clang::SourceLocation),
        (reflenums::RK_clang__ObjCProtocolDecl, reflenums::clang__ObjCProtocolDecl::protocol_locs, Xs...), () )
    };
    struct ObjCCategoryDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(protocols,
      constexpr auto protocols() const ,
        (class clang::ObjCProtocolDecl *const),
        (reflenums::RK_clang__ObjCCategoryDecl, reflenums::clang__ObjCCategoryDecl::protocols, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(protocol_locs,
      constexpr auto protocol_locs() const ,
        (const class clang::SourceLocation),
        (reflenums::RK_clang__ObjCCategoryDecl, reflenums::clang__ObjCCategoryDecl::protocol_locs, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(ivars,
      constexpr auto ivars() const ,
        (class clang::ObjCIvarDecl *),
        (reflenums::RK_clang__ObjCCategoryDecl, reflenums::clang__ObjCCategoryDecl::ivars, Xs...), () )
    };
    struct ObjCImplDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(property_impls,
      constexpr auto property_impls() const ,
        (class clang::ObjCPropertyImplDecl *),
        (reflenums::RK_clang__ObjCImplDecl, reflenums::clang__ObjCImplDecl::property_impls, Xs...), () )
    };
    struct ObjCCategoryImplDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCImplementationDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(inits,
      constexpr auto inits() const ,
        (class clang::CXXCtorInitializer *const),
        (reflenums::RK_clang__ObjCImplementationDecl, reflenums::clang__ObjCImplementationDecl::inits, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(ivars,
      constexpr auto ivars() const ,
        (class clang::ObjCIvarDecl *),
        (reflenums::RK_clang__ObjCImplementationDecl, reflenums::clang__ObjCImplementationDecl::ivars, Xs...), () )
    };
    struct ObjCCompatibleAliasDecl {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCPropertyImplDecl {
      M_template_rtpack(Xs) struct impl;
      enum Kind : unsigned int;
    };
  }

  namespace clang {
    struct OMPThreadPrivateDecl {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(varlists,
      constexpr auto varlists() const ,
        (const class clang::Expr *const),
        (reflenums::RK_clang__OMPThreadPrivateDecl, reflenums::clang__OMPThreadPrivateDecl::varlists, Xs...), () )
    };
    struct OMPDeclareReductionDecl {
      M_template_rtpack(Xs) struct impl;
      enum InitKind : unsigned int;
    };
    struct OMPCapturedExprDecl {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    enum ExpressionTrait : unsigned int;
  }

  namespace clang {
    struct CXXOperatorCallExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXMemberCallExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CUDAKernelCallExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXNamedCastExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXStaticCastExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXDynamicCastExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXReinterpretCastExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXConstCastExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct UserDefinedLiteral {
      M_template_rtpack(Xs) struct impl;
      enum LiteralOperatorKind : unsigned int;
    };
    struct CXXBoolLiteralExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXNullPtrLiteralExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXStdInitializerListExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXTypeidExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct MSPropertyRefExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct MSPropertySubscriptExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXUuidofExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXThisExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXThrowExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXDefaultArgExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXDefaultInitExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXTemporary {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXBindTemporaryExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXConstructExpr {
      M_template_rtpack(Xs) struct impl;
      enum ConstructionKind : unsigned int;
    DEF_RANGE_REFLECTION_TUPLE(arguments,
      constexpr auto arguments() const ,
        (const class clang::Expr *const),
        (reflenums::RK_clang__CXXConstructExpr, reflenums::clang__CXXConstructExpr::arguments, Xs...), () )
    };
    struct CXXInheritedCtorInitExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXFunctionalCastExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXTemporaryObjectExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct LambdaExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(captures,
      constexpr auto captures() const ,
        (const class clang::LambdaCapture),
        (reflenums::RK_clang__LambdaExpr, reflenums::clang__LambdaExpr::captures, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(explicit_captures,
      constexpr auto explicit_captures() const ,
        (const class clang::LambdaCapture),
        (reflenums::RK_clang__LambdaExpr, reflenums::clang__LambdaExpr::explicit_captures, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(implicit_captures,
      constexpr auto implicit_captures() const ,
        (const class clang::LambdaCapture),
        (reflenums::RK_clang__LambdaExpr, reflenums::clang__LambdaExpr::implicit_captures, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(capture_inits,
      constexpr auto capture_inits() const ,
        (class clang::Expr *const),
        (reflenums::RK_clang__LambdaExpr, reflenums::clang__LambdaExpr::capture_inits, Xs...), () )
    };
    struct CXXScalarValueInitExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXNewExpr {
      M_template_rtpack(Xs) struct impl;
      enum InitializationStyle : unsigned int;
    DEF_RANGE_REFLECTION_TUPLE(placement_arguments,
      constexpr auto placement_arguments() const ,
        (const class clang::Expr *const),
        (reflenums::RK_clang__CXXNewExpr, reflenums::clang__CXXNewExpr::placement_arguments, Xs...), () )
    };
    struct CXXDeleteExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXPseudoDestructorExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct TypeTraitExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(getArgs,
      constexpr auto getArgs() const ,
        (class clang::TypeSourceInfo *),
        (reflenums::RK_clang__TypeTraitExpr, reflenums::clang__TypeTraitExpr::getArgs, Xs...), () )
    };
    struct ArrayTypeTraitExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct ExpressionTraitExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct OverloadExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(decls,
      constexpr auto decls() const ,
        (class clang::NamedDecl *),
        (reflenums::RK_clang__OverloadExpr, reflenums::clang__OverloadExpr::decls, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(template_arguments,
      constexpr auto template_arguments() const ,
        (class clang::TemplateArgumentLoc),
        (reflenums::RK_clang__OverloadExpr, reflenums::clang__OverloadExpr::template_arguments, Xs...), () )
      struct FindResult {
        M_template_rtpack(Xs) struct impl;
      };
    };
    struct UnresolvedLookupExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct DependentScopeDeclRefExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(template_arguments,
      constexpr auto template_arguments() const ,
        (class clang::TemplateArgumentLoc),
        (reflenums::RK_clang__DependentScopeDeclRefExpr, reflenums::clang__DependentScopeDeclRefExpr::template_arguments, Xs...), () )
    };
    struct ExprWithCleanups {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(getObjects,
      constexpr auto getObjects() const ,
        (class clang::BlockDecl *),
        (reflenums::RK_clang__ExprWithCleanups, reflenums::clang__ExprWithCleanups::getObjects, Xs...), () )
    };
    struct CXXUnresolvedConstructExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXDependentScopeMemberExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(template_arguments,
      constexpr auto template_arguments() const ,
        (class clang::TemplateArgumentLoc),
        (reflenums::RK_clang__CXXDependentScopeMemberExpr, reflenums::clang__CXXDependentScopeMemberExpr::template_arguments, Xs...), () )
    };
    struct UnresolvedMemberExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXNoexceptExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct PackExpansionExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct SizeOfPackExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(getPartialArguments,
      constexpr auto getPartialArguments() const ,
        (class clang::TemplateArgument),
        (reflenums::RK_clang__SizeOfPackExpr, reflenums::clang__SizeOfPackExpr::getPartialArguments, Xs...), () )
    };
    struct SubstNonTypeTemplateParmExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct SubstNonTypeTemplateParmPackExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct FunctionParmPackExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct MaterializeTemporaryExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXFoldExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CoroutineSuspendExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CoawaitExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct DependentCoawaitExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CoyieldExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct ReflectionExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CompilerMessageExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CompilerDiagnosticExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(getArgs,
      constexpr auto getArgs() const ,
        (const class clang::Expr *),
        (reflenums::RK_clang__CompilerDiagnosticExpr, reflenums::clang__CompilerDiagnosticExpr::getArgs, Xs...), () )
    };
    struct CXXMetaparseExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct ReflectionTraitExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct ReflectNewExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct ReflectDeleteExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXConstantExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__CXXConstantExpr, reflenums::clang__CXXConstantExpr::children, Xs...), () )
    };
    struct CXXDependentIdExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__CXXDependentIdExpr, reflenums::clang__CXXDependentIdExpr::children, Xs...), () )
    };
    struct CXXConcatenateExpr {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__CXXConcatenateExpr, reflenums::clang__CXXConcatenateExpr::children, Xs...), () )
    };
  }

  namespace clang {
    struct ObjCStringLiteral {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCBoolLiteralExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCBoxedExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCArrayLiteral {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCDictionaryElement {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct ObjCDictionaryLiteral {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCEncodeExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCSelectorExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCProtocolExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCIvarRefExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCPropertyRefExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCSubscriptRefExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCMessageExpr {
      M_template_rtpack(Xs) struct impl;
      enum ReceiverKind : unsigned int;
    DEF_RANGE_REFLECTION_TUPLE(arguments,
      constexpr auto arguments() const ,
        (const class clang::Expr *const),
        (reflenums::RK_clang__ObjCMessageExpr, reflenums::clang__ObjCMessageExpr::arguments, Xs...), () )
    };
    struct ObjCIsaExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCIndirectCopyRestoreExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCBridgedCastExpr {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCAvailabilityCheckExpr {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct OMPArraySectionExpr {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct CXXCatchStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXTryStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXForRangeStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXExpansionStmt {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(getInstantiatedStatements,
      constexpr auto getInstantiatedStatements() const ,
        (class clang::Stmt *),
        (reflenums::RK_clang__CXXExpansionStmt, reflenums::clang__CXXExpansionStmt::getInstantiatedStatements, Xs...), () )
    };
    struct CXXTupleExpansionStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXPackExpansionStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct MSDependentExistsStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct CoroutineBodyStmt {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(getParamMoves,
      constexpr auto getParamMoves() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__CoroutineBodyStmt, reflenums::clang__CoroutineBodyStmt::getParamMoves, Xs...), () )
      struct CtorArgs {
        M_template_rtpack(Xs) struct impl;
      };
    };
    struct CoreturnStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct CXXQueueMetaparseStmt {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct ObjCForCollectionStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCAtCatchStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCAtFinallyStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCAtTryStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCAtSynchronizedStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCAtThrowStmt {
      M_template_rtpack(Xs) struct impl;
    };
    struct ObjCAutoreleasePoolStmt {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct OMPClause {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(children,
      constexpr auto children() const ,
        (const class clang::Stmt *),
        (reflenums::RK_clang__OMPClause, reflenums::clang__OMPClause::children, Xs...), () )
    };
  }

  namespace clang {
    struct OMPExecutableDirective {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(clauses,
      constexpr auto clauses() const ,
        (class clang::OMPClause *),
        (reflenums::RK_clang__OMPExecutableDirective, reflenums::clang__OMPExecutableDirective::clauses, Xs...), () )
    };
    struct OMPParallelDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPLoopDirective {
      M_template_rtpack(Xs) struct impl;
    DEF_RANGE_REFLECTION_TUPLE(counters,
      constexpr auto counters() const ,
        (class clang::Expr *),
        (reflenums::RK_clang__OMPLoopDirective, reflenums::clang__OMPLoopDirective::counters, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(private_counters,
      constexpr auto private_counters() const ,
        (class clang::Expr *),
        (reflenums::RK_clang__OMPLoopDirective, reflenums::clang__OMPLoopDirective::private_counters, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(inits,
      constexpr auto inits() const ,
        (class clang::Expr *),
        (reflenums::RK_clang__OMPLoopDirective, reflenums::clang__OMPLoopDirective::inits, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(updates,
      constexpr auto updates() const ,
        (class clang::Expr *),
        (reflenums::RK_clang__OMPLoopDirective, reflenums::clang__OMPLoopDirective::updates, Xs...), () )
    DEF_RANGE_REFLECTION_TUPLE(finals,
      constexpr auto finals() const ,
        (class clang::Expr *),
        (reflenums::RK_clang__OMPLoopDirective, reflenums::clang__OMPLoopDirective::finals, Xs...), () )
    };
    struct OMPSimdDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPForDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPForSimdDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPSectionsDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPSectionDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPSingleDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPMasterDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPCriticalDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPParallelForDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPParallelForSimdDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPParallelSectionsDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTaskDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTaskyieldDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPBarrierDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTaskwaitDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTaskgroupDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPFlushDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPOrderedDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPAtomicDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTargetDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTargetDataDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTargetEnterDataDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTargetExitDataDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTargetParallelDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTargetParallelForDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTeamsDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPCancellationPointDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPCancelDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTaskLoopDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTaskLoopSimdDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPDistributeDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTargetUpdateDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPDistributeParallelForDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPDistributeParallelForSimdDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPDistributeSimdDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTargetParallelForSimdDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTargetSimdDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTeamsDistributeDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTeamsDistributeSimdDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTeamsDistributeParallelForSimdDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTeamsDistributeParallelForDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTargetTeamsDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTargetTeamsDistributeDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTargetTeamsDistributeParallelForDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTargetTeamsDistributeParallelForSimdDirective {
      M_template_rtpack(Xs) struct impl;
    };
    struct OMPTargetTeamsDistributeSimdDirective {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
    struct StoredDeclsMap {
      M_template_rtpack(Xs) struct impl;
    };
  }

  namespace clang {
  }

  namespace clang {
    struct DependentDiagnostic {
      M_template_rtpack(Xs) struct impl;
      enum AccessNonce : unsigned int;
    };
  }

  namespace reflcontainers {
    struct VectorStr {
      M_template_rtpack(Xs) struct impl;
    };
    struct VectorInt {
      M_template_rtpack(Xs) struct impl;
    };
    struct SetInt {
      M_template_rtpack(Xs) struct impl;
    };
    struct SetStr {
      M_template_rtpack(Xs) struct impl;
    };
    struct IntIntPair {
      M_template_rtpack(Xs) struct impl;
    };
    struct IntStrPair {
      M_template_rtpack(Xs) struct impl;
    };
    struct StrIntPair {
      M_template_rtpack(Xs) struct impl;
    };
    struct StrStrPair {
      M_template_rtpack(Xs) struct impl;
    };
    struct MapIntStr {
      M_template_rtpack(Xs) struct impl;
    };
    struct MapStrInt {
      M_template_rtpack(Xs) struct impl;
    };
    struct MapStrStr {
      M_template_rtpack(Xs) struct impl;
    };
    struct MapIntInt {
      M_template_rtpack(Xs) struct impl;
    };
  }

#ifdef __CONSUMER_SUPPORTS_REFLECTION_AND_META__
  template<class T, int PTROFFSET, intptr_t... Xs>
  struct impl_offset;
  template<class T, int PTROFFSET, intptr_t... Xs>
  using impl_offset_t = typename impl_offset<T, PTROFFSET, Xs...>::type;

  // Pointer specialization
  template<class T, int PTROFFSET, intptr_t PTRVAL>
  struct impl_offset<T, PTROFFSET, /*IsPtr*/1, PTRVAL>
  {
    using type = typename T::template impl</*IsPtr*/1, PTRVAL + PTROFFSET>;
  };

  // Value specialization (TODO)
  template<class T, int PTROFFSET, intptr_t... OBJDATACHUNKs>
  struct impl_offset<T, PTROFFSET, /*IsPtr*/0, OBJDATACHUNKs...>
  {
    static_assert(sizeof(T) == -1,
                  "This specialization not yet implemented! "
                  "To implement, need to bitshift each OBJDATACHUNK by PTROFFSET, "
                  "but also move the shifted stuff into the end of val to its left, "
                  "i.e. ignore the boundaries between chunks. Definitely doable." );
  };
#else
  template<class T, int PTROFFSET>
  using impl_offset_t = typename T::impl;
#endif

} //namespace refldetail

  namespace clang {
  }

  namespace clang {
  }

  namespace llvm {
  M_template_rtpack(Zs) using APInt = struct refldetail::llvm::APInt::M_template impl M_targpack(Zs);
  }

  namespace llvm {
  M_template_rtpack(Zs) using APFloatBase = struct refldetail::llvm::APFloatBase::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using APFloat = struct refldetail::llvm::APFloat::M_template impl M_targpack(Zs);
  }

  namespace llvm {
  M_template_rtpack(Zs) using APSInt = struct refldetail::llvm::APSInt::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using APValue = struct refldetail::clang::APValue::M_template impl M_targpack(Zs);
  }

  namespace clang {
  }

  namespace clang {
  }

  namespace clang {

    namespace diag {
  using Severity = enum refldetail::clang::diag::Severity;
    }
  }

  namespace clang {
  using OverloadsShown = enum refldetail::clang::OverloadsShown;
  using DiagnosticLevelMask = enum refldetail::clang::DiagnosticLevelMask;
  M_template_rtpack(Zs) using DiagnosticOptions = struct refldetail::clang::DiagnosticOptions::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using FileID = struct refldetail::clang::FileID::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SourceLocation = struct refldetail::clang::SourceLocation::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SourceRange = struct refldetail::clang::SourceRange::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CharSourceRange = struct refldetail::clang::CharSourceRange::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using PresumedLoc = struct refldetail::clang::PresumedLoc::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using FullSourceLoc = struct refldetail::clang::FullSourceLoc::M_template impl M_targpack(Zs);
  }

  namespace clang {
  using AccessSpecifier = enum refldetail::clang::AccessSpecifier;
  using ExprValueKind = enum refldetail::clang::ExprValueKind;
  using ExprObjectKind = enum refldetail::clang::ExprObjectKind;
  using TemplateSpecializationKind = enum refldetail::clang::TemplateSpecializationKind;
  using ThreadStorageClassSpecifier = enum refldetail::clang::ThreadStorageClassSpecifier;
  using StorageClass = enum refldetail::clang::StorageClass;
  using InClassInitStyle = enum refldetail::clang::InClassInitStyle;
  using CallingConv = enum refldetail::clang::CallingConv;
  using StorageDuration = enum refldetail::clang::StorageDuration;
  using NullabilityKind = enum refldetail::clang::NullabilityKind;
  using ParameterABI = enum refldetail::clang::ParameterABI;
  using ReflectionTraitKind = enum refldetail::clang::ReflectionTraitKind;
  }

  namespace llvm {
  M_template_rtpack(Zs) using DebugEpochBase = struct refldetail::llvm::DebugEpochBase::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using FixItHint = struct refldetail::clang::FixItHint::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DiagnosticsEngine = struct refldetail::clang::DiagnosticsEngine::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DiagnosticBuilder = struct refldetail::clang::DiagnosticBuilder::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DiagnosticConsumer = struct refldetail::clang::DiagnosticConsumer::M_template impl M_targpack(Zs);
  }

  namespace clang {

    namespace tok {
  using TokenKind = enum refldetail::clang::tok::TokenKind;
  using PPKeywordKind = enum refldetail::clang::tok::PPKeywordKind;
  using ObjCKeywordKind = enum refldetail::clang::tok::ObjCKeywordKind;
    }
  }

  namespace clang {
  M_template_rtpack(Zs) using IdentifierInfo = struct refldetail::clang::IdentifierInfo::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using IdentifierInfoLookup = struct refldetail::clang::IdentifierInfoLookup::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using IdentifierTable = struct refldetail::clang::IdentifierTable::M_template impl M_targpack(Zs);
  using ObjCMethodFamily = enum refldetail::clang::ObjCMethodFamily;
  using ObjCInstanceTypeFamily = enum refldetail::clang::ObjCInstanceTypeFamily;
  using ObjCStringFormatFamily = enum refldetail::clang::ObjCStringFormatFamily;
  M_template_rtpack(Zs) using Selector = struct refldetail::clang::Selector::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SelectorTable = struct refldetail::clang::SelectorTable::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using PartialDiagnostic = struct refldetail::clang::PartialDiagnostic::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using DeclarationName = struct refldetail::clang::DeclarationName::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DeclarationNameLoc = struct refldetail::clang::DeclarationNameLoc::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DeclarationNameInfo = struct refldetail::clang::DeclarationNameInfo::M_template impl M_targpack(Zs);
  }

  namespace llvm {
  M_template_rtpack(Zs) using raw_ostream = struct refldetail::llvm::raw_ostream::M_template impl M_targpack(Zs);
  }

  namespace llvm {
  M_template_rtpack(Zs) using VersionTuple = struct refldetail::llvm::VersionTuple::M_template impl M_targpack(Zs);
  }

  namespace clang {
  using AvailabilityResult = enum refldetail::clang::AvailabilityResult;
  M_template_rtpack(Zs) using Decl = struct refldetail::clang::Decl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DeclContextLookupResult = struct refldetail::clang::DeclContextLookupResult::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DeclContext = struct refldetail::clang::DeclContext::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using CharUnits = struct refldetail::clang::CharUnits::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using FileSystemOptions = struct refldetail::clang::FileSystemOptions::M_template impl M_targpack(Zs);
  }

  namespace llvm {
  M_template_rtpack(Zs) using Twine = struct refldetail::llvm::Twine::M_template impl M_targpack(Zs);
  }

  namespace llvm {

    namespace sys {

      namespace fs {
  M_template_rtpack(Zs) using UniqueID = struct refldetail::llvm::sys::fs::UniqueID::M_template impl M_targpack(Zs);
      }
    }
  }

  namespace llvm {
  M_template_rtpack(Zs) using MemoryBuffer = struct refldetail::llvm::MemoryBuffer::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using MemoryBufferRef = struct refldetail::llvm::MemoryBufferRef::M_template impl M_targpack(Zs);
  }

  namespace clang {
  }

  namespace clang {
  M_template_rtpack(Zs) using DirectoryEntry = struct refldetail::clang::DirectoryEntry::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using FileEntry = struct refldetail::clang::FileEntry::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using FileManager = struct refldetail::clang::FileManager::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using ASTFileSignature = struct refldetail::clang::ASTFileSignature::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using Module = struct refldetail::clang::Module::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using ExternalASTSource = struct refldetail::clang::ExternalASTSource::M_template impl M_targpack(Zs);
  }

  namespace clang {
  }

  namespace llvm {
  M_template_rtpack(Zs) using FoldingSetBase = struct refldetail::llvm::FoldingSetBase::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using FoldingSetNodeIDRef = struct refldetail::llvm::FoldingSetNodeIDRef::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using FoldingSetNodeID = struct refldetail::llvm::FoldingSetNodeID::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using NestedNameSpecifier = struct refldetail::clang::NestedNameSpecifier::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using NestedNameSpecifierLoc = struct refldetail::clang::NestedNameSpecifierLoc::M_template impl M_targpack(Zs);
  }

  namespace clang {
  }

  namespace clang {
  M_template_rtpack(Zs) using UncommonTemplateNameStorage = struct refldetail::clang::UncommonTemplateNameStorage::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OverloadedTemplateStorage = struct refldetail::clang::OverloadedTemplateStorage::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SubstTemplateTemplateParmPackStorage = struct refldetail::clang::SubstTemplateTemplateParmPackStorage::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TemplateName = struct refldetail::clang::TemplateName::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SubstTemplateTemplateParmStorage = struct refldetail::clang::SubstTemplateTemplateParmStorage::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using QualifiedTemplateName = struct refldetail::clang::QualifiedTemplateName::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DependentTemplateName = struct refldetail::clang::DependentTemplateName::M_template impl M_targpack(Zs);
  }

  namespace clang {
  using LangAS = enum refldetail::clang::LangAS;
  }

  namespace clang {
  using ExceptionSpecificationType = enum refldetail::clang::ExceptionSpecificationType;
  using CanThrowResult = enum refldetail::clang::CanThrowResult;
  }

  namespace clang {
  using Linkage = enum refldetail::clang::Linkage;
  using LanguageLinkage = enum refldetail::clang::LanguageLinkage;
  using GVALinkage = enum refldetail::clang::GVALinkage;
  }

  namespace clang {
  using Visibility = enum refldetail::clang::Visibility;
  M_template_rtpack(Zs) using LinkageInfo = struct refldetail::clang::LinkageInfo::M_template impl M_targpack(Zs);
  }

  namespace clang {
  }

  namespace clang {
  M_template_rtpack(Zs) using Qualifiers = struct refldetail::clang::Qualifiers::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SplitQualType = struct refldetail::clang::SplitQualType::M_template impl M_targpack(Zs);
  using ObjCSubstitutionContext = enum refldetail::clang::ObjCSubstitutionContext;
  M_template_rtpack(Zs) using QualType = struct refldetail::clang::QualType::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using ExtQualsTypeCommonBase = struct refldetail::clang::ExtQualsTypeCommonBase::M_template impl M_targpack(Zs);
  using RefQualifierKind = enum refldetail::clang::RefQualifierKind;
  using AutoTypeKeyword = enum refldetail::clang::AutoTypeKeyword;
  M_template_rtpack(Zs) using Type = struct refldetail::clang::Type::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using BuiltinType = struct refldetail::clang::BuiltinType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ComplexType = struct refldetail::clang::ComplexType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ParenType = struct refldetail::clang::ParenType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using PointerType = struct refldetail::clang::PointerType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using AdjustedType = struct refldetail::clang::AdjustedType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DecayedType = struct refldetail::clang::DecayedType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using BlockPointerType = struct refldetail::clang::BlockPointerType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ReferenceType = struct refldetail::clang::ReferenceType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using LValueReferenceType = struct refldetail::clang::LValueReferenceType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using RValueReferenceType = struct refldetail::clang::RValueReferenceType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using MemberPointerType = struct refldetail::clang::MemberPointerType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ArrayType = struct refldetail::clang::ArrayType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ConstantArrayType = struct refldetail::clang::ConstantArrayType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using IncompleteArrayType = struct refldetail::clang::IncompleteArrayType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using VariableArrayType = struct refldetail::clang::VariableArrayType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DependentSizedArrayType = struct refldetail::clang::DependentSizedArrayType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DependentAddressSpaceType = struct refldetail::clang::DependentAddressSpaceType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DependentSizedExtVectorType = struct refldetail::clang::DependentSizedExtVectorType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using VectorType = struct refldetail::clang::VectorType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DependentVectorType = struct refldetail::clang::DependentVectorType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ExtVectorType = struct refldetail::clang::ExtVectorType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using FunctionType = struct refldetail::clang::FunctionType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using FunctionNoProtoType = struct refldetail::clang::FunctionNoProtoType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using FunctionProtoType = struct refldetail::clang::FunctionProtoType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using UnresolvedUsingType = struct refldetail::clang::UnresolvedUsingType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TypedefType = struct refldetail::clang::TypedefType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TypeOfExprType = struct refldetail::clang::TypeOfExprType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TypeOfType = struct refldetail::clang::TypeOfType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DecltypeType = struct refldetail::clang::DecltypeType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ReflectedType = struct refldetail::clang::ReflectedType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using UnaryTransformType = struct refldetail::clang::UnaryTransformType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TagType = struct refldetail::clang::TagType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using RecordType = struct refldetail::clang::RecordType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using EnumType = struct refldetail::clang::EnumType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using AttributedType = struct refldetail::clang::AttributedType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TemplateTypeParmType = struct refldetail::clang::TemplateTypeParmType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SubstTemplateTypeParmType = struct refldetail::clang::SubstTemplateTypeParmType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SubstTemplateTypeParmPackType = struct refldetail::clang::SubstTemplateTypeParmPackType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DeducedType = struct refldetail::clang::DeducedType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using AutoType = struct refldetail::clang::AutoType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DeducedTemplateSpecializationType = struct refldetail::clang::DeducedTemplateSpecializationType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TemplateSpecializationType = struct refldetail::clang::TemplateSpecializationType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using InjectedClassNameType = struct refldetail::clang::InjectedClassNameType::M_template impl M_targpack(Zs);
  using TagTypeKind = enum refldetail::clang::TagTypeKind;
  using ElaboratedTypeKeyword = enum refldetail::clang::ElaboratedTypeKeyword;
  M_template_rtpack(Zs) using TypeWithKeyword = struct refldetail::clang::TypeWithKeyword::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ElaboratedType = struct refldetail::clang::ElaboratedType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DependentNameType = struct refldetail::clang::DependentNameType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DependentTemplateSpecializationType = struct refldetail::clang::DependentTemplateSpecializationType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using PackExpansionType = struct refldetail::clang::PackExpansionType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCTypeParamType = struct refldetail::clang::ObjCTypeParamType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCObjectType = struct refldetail::clang::ObjCObjectType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCInterfaceType = struct refldetail::clang::ObjCInterfaceType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCObjectPointerType = struct refldetail::clang::ObjCObjectPointerType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using AtomicType = struct refldetail::clang::AtomicType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using PipeType = struct refldetail::clang::PipeType::M_template impl M_targpack(Zs);
  }

  namespace clang {
  using OverloadedOperatorKind = enum refldetail::clang::OverloadedOperatorKind;
  }

  namespace clang {
  using PragmaMSCommentKind = enum refldetail::clang::PragmaMSCommentKind;
  }

  namespace clang {
  M_template_rtpack(Zs) using TypeSourceInfo = struct refldetail::clang::TypeSourceInfo::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TranslationUnitDecl = struct refldetail::clang::TranslationUnitDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using PragmaCommentDecl = struct refldetail::clang::PragmaCommentDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using PragmaDetectMismatchDecl = struct refldetail::clang::PragmaDetectMismatchDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ExternCContextDecl = struct refldetail::clang::ExternCContextDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using NamedDecl = struct refldetail::clang::NamedDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using LabelDecl = struct refldetail::clang::LabelDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using NamespaceDecl = struct refldetail::clang::NamespaceDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ValueDecl = struct refldetail::clang::ValueDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DeclaratorDecl = struct refldetail::clang::DeclaratorDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using EvaluatedStmt = struct refldetail::clang::EvaluatedStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using VarDecl = struct refldetail::clang::VarDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ImplicitParamDecl = struct refldetail::clang::ImplicitParamDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ParmVarDecl = struct refldetail::clang::ParmVarDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using FunctionDecl = struct refldetail::clang::FunctionDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using FieldDecl = struct refldetail::clang::FieldDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using EnumConstantDecl = struct refldetail::clang::EnumConstantDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using IndirectFieldDecl = struct refldetail::clang::IndirectFieldDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TypeDecl = struct refldetail::clang::TypeDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TypedefNameDecl = struct refldetail::clang::TypedefNameDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TypedefDecl = struct refldetail::clang::TypedefDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TypeAliasDecl = struct refldetail::clang::TypeAliasDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TagDecl = struct refldetail::clang::TagDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using EnumDecl = struct refldetail::clang::EnumDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using RecordDecl = struct refldetail::clang::RecordDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using FileScopeAsmDecl = struct refldetail::clang::FileScopeAsmDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using BlockDecl = struct refldetail::clang::BlockDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CapturedDecl = struct refldetail::clang::CapturedDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ImportDecl = struct refldetail::clang::ImportDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ExportDecl = struct refldetail::clang::ExportDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using EmptyDecl = struct refldetail::clang::EmptyDecl::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using DeclGroup = struct refldetail::clang::DeclGroup::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DeclGroupRef = struct refldetail::clang::DeclGroupRef::M_template impl M_targpack(Zs);
  }

  namespace clang {
  }

  namespace clang {
  using CapturedRegionKind = enum refldetail::clang::CapturedRegionKind;
  }

  namespace clang {
  M_template_rtpack(Zs) using Stmt = struct refldetail::clang::Stmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DeclStmt = struct refldetail::clang::DeclStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using NullStmt = struct refldetail::clang::NullStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CompoundStmt = struct refldetail::clang::CompoundStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SwitchCase = struct refldetail::clang::SwitchCase::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CaseStmt = struct refldetail::clang::CaseStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DefaultStmt = struct refldetail::clang::DefaultStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using LabelStmt = struct refldetail::clang::LabelStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using AttributedStmt = struct refldetail::clang::AttributedStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using IfStmt = struct refldetail::clang::IfStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SwitchStmt = struct refldetail::clang::SwitchStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using WhileStmt = struct refldetail::clang::WhileStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DoStmt = struct refldetail::clang::DoStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ForStmt = struct refldetail::clang::ForStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using GotoStmt = struct refldetail::clang::GotoStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using IndirectGotoStmt = struct refldetail::clang::IndirectGotoStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ContinueStmt = struct refldetail::clang::ContinueStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using BreakStmt = struct refldetail::clang::BreakStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ReturnStmt = struct refldetail::clang::ReturnStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using AsmStmt = struct refldetail::clang::AsmStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using GCCAsmStmt = struct refldetail::clang::GCCAsmStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using MSAsmStmt = struct refldetail::clang::MSAsmStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SEHExceptStmt = struct refldetail::clang::SEHExceptStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SEHFinallyStmt = struct refldetail::clang::SEHFinallyStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SEHTryStmt = struct refldetail::clang::SEHTryStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SEHLeaveStmt = struct refldetail::clang::SEHLeaveStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CapturedStmt = struct refldetail::clang::CapturedStmt::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using TemplateArgument = struct refldetail::clang::TemplateArgument::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TemplateArgumentLocInfo = struct refldetail::clang::TemplateArgumentLocInfo::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TemplateArgumentLoc = struct refldetail::clang::TemplateArgumentLoc::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TemplateArgumentListInfo = struct refldetail::clang::TemplateArgumentListInfo::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ASTTemplateArgumentListInfo = struct refldetail::clang::ASTTemplateArgumentListInfo::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using TypeLoc = struct refldetail::clang::TypeLoc::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using UnqualTypeLoc = struct refldetail::clang::UnqualTypeLoc::M_template impl M_targpack(Zs);
  }

  namespace clang {
  }

  namespace clang {
  }

  namespace clang {
  }

  namespace clang {
  M_template_rtpack(Zs) using CommentOptions = struct refldetail::clang::CommentOptions::M_template impl M_targpack(Zs);
  }

  namespace clang {

    namespace comments {
  M_template_rtpack(Zs) using CommandInfo = struct refldetail::clang::comments::CommandInfo::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CommandTraits = struct refldetail::clang::comments::CommandTraits::M_template impl M_targpack(Zs);
    }
  }

  namespace clang {
  }

  namespace llvm {
  M_template_rtpack(Zs) using Triple = struct refldetail::llvm::Triple::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using ObjCRuntime = struct refldetail::clang::ObjCRuntime::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using SanitizerSet = struct refldetail::clang::SanitizerSet::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using LangOptionsBase = struct refldetail::clang::LangOptionsBase::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using LangOptions = struct refldetail::clang::LangOptions::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using FPOptions = struct refldetail::clang::FPOptions::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using PrinterHelper = struct refldetail::clang::PrinterHelper::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using PrintingPolicy = struct refldetail::clang::PrintingPolicy::M_template impl M_targpack(Zs);
  }

  namespace clang {

    namespace SrcMgr {
  using CharacteristicKind = enum refldetail::clang::SrcMgr::CharacteristicKind;
  M_template_rtpack(Zs) using ContentCache = struct refldetail::clang::SrcMgr::ContentCache::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using FileInfo = struct refldetail::clang::SrcMgr::FileInfo::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ExpansionInfo = struct refldetail::clang::SrcMgr::ExpansionInfo::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SLocEntry = struct refldetail::clang::SrcMgr::SLocEntry::M_template impl M_targpack(Zs);
    }
  M_template_rtpack(Zs) using SourceManager = struct refldetail::clang::SourceManager::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using RawComment = struct refldetail::clang::RawComment::M_template impl M_targpack(Zs);
  }

  namespace clang {
  }

  namespace clang {
  M_template_rtpack(Zs) using SanitizerBlacklist = struct refldetail::clang::SanitizerBlacklist::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using TargetCXXABI = struct refldetail::clang::TargetCXXABI::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using OpenCLOptions = struct refldetail::clang::OpenCLOptions::M_template impl M_targpack(Zs);
  }

  namespace llvm {
  using EABI = enum refldetail::llvm::EABI;
  }

  namespace clang {
  M_template_rtpack(Zs) using TargetOptions = struct refldetail::clang::TargetOptions::M_template impl M_targpack(Zs);
  }

  namespace llvm {
  M_template_rtpack(Zs) using Type = struct refldetail::llvm::Type::M_template impl M_targpack(Zs);
  }

  namespace llvm {
  M_template_rtpack(Zs) using IntegerType = struct refldetail::llvm::IntegerType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CompositeType = struct refldetail::llvm::CompositeType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using StructType = struct refldetail::llvm::StructType::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using PointerType = struct refldetail::llvm::PointerType::M_template impl M_targpack(Zs);
  }

  namespace llvm {
  M_template_rtpack(Zs) using DataLayout = struct refldetail::llvm::DataLayout::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using StructLayout = struct refldetail::llvm::StructLayout::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using TargetInfo = struct refldetail::clang::TargetInfo::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using XRayFunctionFilter = struct refldetail::clang::XRayFunctionFilter::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using TypeInfo = struct refldetail::clang::TypeInfo::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ASTContext = struct refldetail::clang::ASTContext::M_template impl M_targpack(Zs);
  }

  namespace clang {
  }

  namespace clang {
  M_template_rtpack(Zs) using DeclAccessPair = struct refldetail::clang::DeclAccessPair::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using UnresolvedSetIterator = struct refldetail::clang::UnresolvedSetIterator::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using UnresolvedSetImpl = struct refldetail::clang::UnresolvedSetImpl::M_template impl M_targpack(Zs);
  }

  namespace clang {
  }

  namespace clang {
  using CastKind = enum refldetail::clang::CastKind;
  using BinaryOperatorKind = enum refldetail::clang::BinaryOperatorKind;
  using UnaryOperatorKind = enum refldetail::clang::UnaryOperatorKind;
  using ObjCBridgeCastKind = enum refldetail::clang::ObjCBridgeCastKind;
  }

  namespace clang {
  }

  namespace clang {
  }

  namespace clang {
  using TypeTrait = enum refldetail::clang::TypeTrait;
  using ArrayTypeTrait = enum refldetail::clang::ArrayTypeTrait;
  using UnaryExprOrTypeTrait = enum refldetail::clang::UnaryExprOrTypeTrait;
  }

  namespace clang {
  M_template_rtpack(Zs) using Expr = struct refldetail::clang::Expr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OpaqueValueExpr = struct refldetail::clang::OpaqueValueExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DeclRefExpr = struct refldetail::clang::DeclRefExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using PredefinedExpr = struct refldetail::clang::PredefinedExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using APIntStorage = struct refldetail::clang::APIntStorage::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using IntegerLiteral = struct refldetail::clang::IntegerLiteral::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using FixedPointLiteral = struct refldetail::clang::FixedPointLiteral::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CharacterLiteral = struct refldetail::clang::CharacterLiteral::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using FloatingLiteral = struct refldetail::clang::FloatingLiteral::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ImaginaryLiteral = struct refldetail::clang::ImaginaryLiteral::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using StringLiteral = struct refldetail::clang::StringLiteral::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ParenExpr = struct refldetail::clang::ParenExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using UnaryOperator = struct refldetail::clang::UnaryOperator::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OffsetOfNode = struct refldetail::clang::OffsetOfNode::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OffsetOfExpr = struct refldetail::clang::OffsetOfExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using UnaryExprOrTypeTraitExpr = struct refldetail::clang::UnaryExprOrTypeTraitExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ArraySubscriptExpr = struct refldetail::clang::ArraySubscriptExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CallExpr = struct refldetail::clang::CallExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using MemberExpr = struct refldetail::clang::MemberExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CompoundLiteralExpr = struct refldetail::clang::CompoundLiteralExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CastExpr = struct refldetail::clang::CastExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ImplicitCastExpr = struct refldetail::clang::ImplicitCastExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ExplicitCastExpr = struct refldetail::clang::ExplicitCastExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CStyleCastExpr = struct refldetail::clang::CStyleCastExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using BinaryOperator = struct refldetail::clang::BinaryOperator::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CompoundAssignOperator = struct refldetail::clang::CompoundAssignOperator::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using AbstractConditionalOperator = struct refldetail::clang::AbstractConditionalOperator::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ConditionalOperator = struct refldetail::clang::ConditionalOperator::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using BinaryConditionalOperator = struct refldetail::clang::BinaryConditionalOperator::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using AddrLabelExpr = struct refldetail::clang::AddrLabelExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using StmtExpr = struct refldetail::clang::StmtExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ShuffleVectorExpr = struct refldetail::clang::ShuffleVectorExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ConvertVectorExpr = struct refldetail::clang::ConvertVectorExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ChooseExpr = struct refldetail::clang::ChooseExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using GNUNullExpr = struct refldetail::clang::GNUNullExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using VAArgExpr = struct refldetail::clang::VAArgExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using InitListExpr = struct refldetail::clang::InitListExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DesignatedInitExpr = struct refldetail::clang::DesignatedInitExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using NoInitExpr = struct refldetail::clang::NoInitExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DesignatedInitUpdateExpr = struct refldetail::clang::DesignatedInitUpdateExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ArrayInitLoopExpr = struct refldetail::clang::ArrayInitLoopExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ArrayInitIndexExpr = struct refldetail::clang::ArrayInitIndexExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ImplicitValueInitExpr = struct refldetail::clang::ImplicitValueInitExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ParenListExpr = struct refldetail::clang::ParenListExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using GenericSelectionExpr = struct refldetail::clang::GenericSelectionExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ExtVectorElementExpr = struct refldetail::clang::ExtVectorElementExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using BlockExpr = struct refldetail::clang::BlockExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using AsTypeExpr = struct refldetail::clang::AsTypeExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using PseudoObjectExpr = struct refldetail::clang::PseudoObjectExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using AtomicExpr = struct refldetail::clang::AtomicExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TypoExpr = struct refldetail::clang::TypoExpr::M_template impl M_targpack(Zs);
  }

  namespace clang {

    namespace attr {
  using Kind = enum refldetail::clang::attr::Kind;
    }
  }

  namespace clang {
  using OpenMPDirectiveKind = enum refldetail::clang::OpenMPDirectiveKind;
  using OpenMPClauseKind = enum refldetail::clang::OpenMPClauseKind;
  }

  namespace clang {
  M_template_rtpack(Zs) using Attr = struct refldetail::clang::Attr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using InheritableAttr = struct refldetail::clang::InheritableAttr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ExternalSourceSymbolAttr = struct refldetail::clang::ExternalSourceSymbolAttr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using MSInheritanceAttr = struct refldetail::clang::MSInheritanceAttr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using MSVtorDispAttr = struct refldetail::clang::MSVtorDispAttr::M_template impl M_targpack(Zs);
  }

  namespace clang {
  using LambdaCaptureDefault = enum refldetail::clang::LambdaCaptureDefault;
  using LambdaCaptureKind = enum refldetail::clang::LambdaCaptureKind;
  }

  namespace clang {
  M_template_rtpack(Zs) using LambdaCapture = struct refldetail::clang::LambdaCapture::M_template impl M_targpack(Zs);
  }

  namespace clang {
  }

  namespace clang {
  }

  namespace clang {
  }

  namespace clang {
  }

  namespace clang {
  }

  namespace clang {
  M_template_rtpack(Zs) using AccessSpecDecl = struct refldetail::clang::AccessSpecDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXBaseSpecifier = struct refldetail::clang::CXXBaseSpecifier::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXRecordDecl = struct refldetail::clang::CXXRecordDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXDeductionGuideDecl = struct refldetail::clang::CXXDeductionGuideDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXMethodDecl = struct refldetail::clang::CXXMethodDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXCtorInitializer = struct refldetail::clang::CXXCtorInitializer::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using InheritedConstructor = struct refldetail::clang::InheritedConstructor::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXConstructorDecl = struct refldetail::clang::CXXConstructorDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXDestructorDecl = struct refldetail::clang::CXXDestructorDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXConversionDecl = struct refldetail::clang::CXXConversionDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using LinkageSpecDecl = struct refldetail::clang::LinkageSpecDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using UsingDirectiveDecl = struct refldetail::clang::UsingDirectiveDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using NamespaceAliasDecl = struct refldetail::clang::NamespaceAliasDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using UsingShadowDecl = struct refldetail::clang::UsingShadowDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ConstructorUsingShadowDecl = struct refldetail::clang::ConstructorUsingShadowDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using UsingDecl = struct refldetail::clang::UsingDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using UsingPackDecl = struct refldetail::clang::UsingPackDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using UnresolvedUsingValueDecl = struct refldetail::clang::UnresolvedUsingValueDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using UnresolvedUsingTypenameDecl = struct refldetail::clang::UnresolvedUsingTypenameDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using StaticAssertDecl = struct refldetail::clang::StaticAssertDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using BindingDecl = struct refldetail::clang::BindingDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DecompositionDecl = struct refldetail::clang::DecompositionDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using MSPropertyDecl = struct refldetail::clang::MSPropertyDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ConstexprDecl = struct refldetail::clang::ConstexprDecl::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using TemplateParameterList = struct refldetail::clang::TemplateParameterList::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TemplateArgumentList = struct refldetail::clang::TemplateArgumentList::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TemplateDecl = struct refldetail::clang::TemplateDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using FunctionTemplateSpecializationInfo = struct refldetail::clang::FunctionTemplateSpecializationInfo::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using MemberSpecializationInfo = struct refldetail::clang::MemberSpecializationInfo::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DependentFunctionTemplateSpecializationInfo = struct refldetail::clang::DependentFunctionTemplateSpecializationInfo::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using RedeclarableTemplateDecl = struct refldetail::clang::RedeclarableTemplateDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using FunctionTemplateDecl = struct refldetail::clang::FunctionTemplateDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TemplateTypeParmDecl = struct refldetail::clang::TemplateTypeParmDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using NonTypeTemplateParmDecl = struct refldetail::clang::NonTypeTemplateParmDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TemplateTemplateParmDecl = struct refldetail::clang::TemplateTemplateParmDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using BuiltinTemplateDecl = struct refldetail::clang::BuiltinTemplateDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ClassTemplateSpecializationDecl = struct refldetail::clang::ClassTemplateSpecializationDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ClassTemplatePartialSpecializationDecl = struct refldetail::clang::ClassTemplatePartialSpecializationDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ClassTemplateDecl = struct refldetail::clang::ClassTemplateDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using FriendTemplateDecl = struct refldetail::clang::FriendTemplateDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TypeAliasTemplateDecl = struct refldetail::clang::TypeAliasTemplateDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ClassScopeFunctionSpecializationDecl = struct refldetail::clang::ClassScopeFunctionSpecializationDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using VarTemplateSpecializationDecl = struct refldetail::clang::VarTemplateSpecializationDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using VarTemplatePartialSpecializationDecl = struct refldetail::clang::VarTemplatePartialSpecializationDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using VarTemplateDecl = struct refldetail::clang::VarTemplateDecl::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using FriendDecl = struct refldetail::clang::FriendDecl::M_template impl M_targpack(Zs);
  }

  namespace clang {
  }

  namespace clang {
  M_template_rtpack(Zs) using ObjCListBase = struct refldetail::clang::ObjCListBase::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCProtocolList = struct refldetail::clang::ObjCProtocolList::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCMethodDecl = struct refldetail::clang::ObjCMethodDecl::M_template impl M_targpack(Zs);
  using ObjCTypeParamVariance = enum refldetail::clang::ObjCTypeParamVariance;
  M_template_rtpack(Zs) using ObjCTypeParamDecl = struct refldetail::clang::ObjCTypeParamDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCTypeParamList = struct refldetail::clang::ObjCTypeParamList::M_template impl M_targpack(Zs);
  using ObjCPropertyQueryKind = enum refldetail::clang::ObjCPropertyQueryKind;
  M_template_rtpack(Zs) using ObjCPropertyDecl = struct refldetail::clang::ObjCPropertyDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCContainerDecl = struct refldetail::clang::ObjCContainerDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCInterfaceDecl = struct refldetail::clang::ObjCInterfaceDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCIvarDecl = struct refldetail::clang::ObjCIvarDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCAtDefsFieldDecl = struct refldetail::clang::ObjCAtDefsFieldDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCProtocolDecl = struct refldetail::clang::ObjCProtocolDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCCategoryDecl = struct refldetail::clang::ObjCCategoryDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCImplDecl = struct refldetail::clang::ObjCImplDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCCategoryImplDecl = struct refldetail::clang::ObjCCategoryImplDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCImplementationDecl = struct refldetail::clang::ObjCImplementationDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCCompatibleAliasDecl = struct refldetail::clang::ObjCCompatibleAliasDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCPropertyImplDecl = struct refldetail::clang::ObjCPropertyImplDecl::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using OMPThreadPrivateDecl = struct refldetail::clang::OMPThreadPrivateDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPDeclareReductionDecl = struct refldetail::clang::OMPDeclareReductionDecl::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPCapturedExprDecl = struct refldetail::clang::OMPCapturedExprDecl::M_template impl M_targpack(Zs);
  }

  namespace clang {
  using ExpressionTrait = enum refldetail::clang::ExpressionTrait;
  }

  namespace clang {
  M_template_rtpack(Zs) using CXXOperatorCallExpr = struct refldetail::clang::CXXOperatorCallExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXMemberCallExpr = struct refldetail::clang::CXXMemberCallExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CUDAKernelCallExpr = struct refldetail::clang::CUDAKernelCallExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXNamedCastExpr = struct refldetail::clang::CXXNamedCastExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXStaticCastExpr = struct refldetail::clang::CXXStaticCastExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXDynamicCastExpr = struct refldetail::clang::CXXDynamicCastExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXReinterpretCastExpr = struct refldetail::clang::CXXReinterpretCastExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXConstCastExpr = struct refldetail::clang::CXXConstCastExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using UserDefinedLiteral = struct refldetail::clang::UserDefinedLiteral::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXBoolLiteralExpr = struct refldetail::clang::CXXBoolLiteralExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXNullPtrLiteralExpr = struct refldetail::clang::CXXNullPtrLiteralExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXStdInitializerListExpr = struct refldetail::clang::CXXStdInitializerListExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXTypeidExpr = struct refldetail::clang::CXXTypeidExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using MSPropertyRefExpr = struct refldetail::clang::MSPropertyRefExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using MSPropertySubscriptExpr = struct refldetail::clang::MSPropertySubscriptExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXUuidofExpr = struct refldetail::clang::CXXUuidofExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXThisExpr = struct refldetail::clang::CXXThisExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXThrowExpr = struct refldetail::clang::CXXThrowExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXDefaultArgExpr = struct refldetail::clang::CXXDefaultArgExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXDefaultInitExpr = struct refldetail::clang::CXXDefaultInitExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXTemporary = struct refldetail::clang::CXXTemporary::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXBindTemporaryExpr = struct refldetail::clang::CXXBindTemporaryExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXConstructExpr = struct refldetail::clang::CXXConstructExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXInheritedCtorInitExpr = struct refldetail::clang::CXXInheritedCtorInitExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXFunctionalCastExpr = struct refldetail::clang::CXXFunctionalCastExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXTemporaryObjectExpr = struct refldetail::clang::CXXTemporaryObjectExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using LambdaExpr = struct refldetail::clang::LambdaExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXScalarValueInitExpr = struct refldetail::clang::CXXScalarValueInitExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXNewExpr = struct refldetail::clang::CXXNewExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXDeleteExpr = struct refldetail::clang::CXXDeleteExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXPseudoDestructorExpr = struct refldetail::clang::CXXPseudoDestructorExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using TypeTraitExpr = struct refldetail::clang::TypeTraitExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ArrayTypeTraitExpr = struct refldetail::clang::ArrayTypeTraitExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ExpressionTraitExpr = struct refldetail::clang::ExpressionTraitExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OverloadExpr = struct refldetail::clang::OverloadExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using UnresolvedLookupExpr = struct refldetail::clang::UnresolvedLookupExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DependentScopeDeclRefExpr = struct refldetail::clang::DependentScopeDeclRefExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ExprWithCleanups = struct refldetail::clang::ExprWithCleanups::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXUnresolvedConstructExpr = struct refldetail::clang::CXXUnresolvedConstructExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXDependentScopeMemberExpr = struct refldetail::clang::CXXDependentScopeMemberExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using UnresolvedMemberExpr = struct refldetail::clang::UnresolvedMemberExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXNoexceptExpr = struct refldetail::clang::CXXNoexceptExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using PackExpansionExpr = struct refldetail::clang::PackExpansionExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SizeOfPackExpr = struct refldetail::clang::SizeOfPackExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SubstNonTypeTemplateParmExpr = struct refldetail::clang::SubstNonTypeTemplateParmExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SubstNonTypeTemplateParmPackExpr = struct refldetail::clang::SubstNonTypeTemplateParmPackExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using FunctionParmPackExpr = struct refldetail::clang::FunctionParmPackExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using MaterializeTemporaryExpr = struct refldetail::clang::MaterializeTemporaryExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXFoldExpr = struct refldetail::clang::CXXFoldExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CoroutineSuspendExpr = struct refldetail::clang::CoroutineSuspendExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CoawaitExpr = struct refldetail::clang::CoawaitExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DependentCoawaitExpr = struct refldetail::clang::DependentCoawaitExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CoyieldExpr = struct refldetail::clang::CoyieldExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ReflectionExpr = struct refldetail::clang::ReflectionExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CompilerMessageExpr = struct refldetail::clang::CompilerMessageExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CompilerDiagnosticExpr = struct refldetail::clang::CompilerDiagnosticExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXMetaparseExpr = struct refldetail::clang::CXXMetaparseExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ReflectionTraitExpr = struct refldetail::clang::ReflectionTraitExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ReflectNewExpr = struct refldetail::clang::ReflectNewExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ReflectDeleteExpr = struct refldetail::clang::ReflectDeleteExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXConstantExpr = struct refldetail::clang::CXXConstantExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXDependentIdExpr = struct refldetail::clang::CXXDependentIdExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXConcatenateExpr = struct refldetail::clang::CXXConcatenateExpr::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using ObjCStringLiteral = struct refldetail::clang::ObjCStringLiteral::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCBoolLiteralExpr = struct refldetail::clang::ObjCBoolLiteralExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCBoxedExpr = struct refldetail::clang::ObjCBoxedExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCArrayLiteral = struct refldetail::clang::ObjCArrayLiteral::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCDictionaryElement = struct refldetail::clang::ObjCDictionaryElement::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using ObjCDictionaryLiteral = struct refldetail::clang::ObjCDictionaryLiteral::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCEncodeExpr = struct refldetail::clang::ObjCEncodeExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCSelectorExpr = struct refldetail::clang::ObjCSelectorExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCProtocolExpr = struct refldetail::clang::ObjCProtocolExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCIvarRefExpr = struct refldetail::clang::ObjCIvarRefExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCPropertyRefExpr = struct refldetail::clang::ObjCPropertyRefExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCSubscriptRefExpr = struct refldetail::clang::ObjCSubscriptRefExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCMessageExpr = struct refldetail::clang::ObjCMessageExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCIsaExpr = struct refldetail::clang::ObjCIsaExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCIndirectCopyRestoreExpr = struct refldetail::clang::ObjCIndirectCopyRestoreExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCBridgedCastExpr = struct refldetail::clang::ObjCBridgedCastExpr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCAvailabilityCheckExpr = struct refldetail::clang::ObjCAvailabilityCheckExpr::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using OMPArraySectionExpr = struct refldetail::clang::OMPArraySectionExpr::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using CXXCatchStmt = struct refldetail::clang::CXXCatchStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXTryStmt = struct refldetail::clang::CXXTryStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXForRangeStmt = struct refldetail::clang::CXXForRangeStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXExpansionStmt = struct refldetail::clang::CXXExpansionStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXTupleExpansionStmt = struct refldetail::clang::CXXTupleExpansionStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXPackExpansionStmt = struct refldetail::clang::CXXPackExpansionStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using MSDependentExistsStmt = struct refldetail::clang::MSDependentExistsStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CoroutineBodyStmt = struct refldetail::clang::CoroutineBodyStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CoreturnStmt = struct refldetail::clang::CoreturnStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using CXXQueueMetaparseStmt = struct refldetail::clang::CXXQueueMetaparseStmt::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using ObjCForCollectionStmt = struct refldetail::clang::ObjCForCollectionStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCAtCatchStmt = struct refldetail::clang::ObjCAtCatchStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCAtFinallyStmt = struct refldetail::clang::ObjCAtFinallyStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCAtTryStmt = struct refldetail::clang::ObjCAtTryStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCAtSynchronizedStmt = struct refldetail::clang::ObjCAtSynchronizedStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCAtThrowStmt = struct refldetail::clang::ObjCAtThrowStmt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ObjCAutoreleasePoolStmt = struct refldetail::clang::ObjCAutoreleasePoolStmt::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using OMPClause = struct refldetail::clang::OMPClause::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using OMPExecutableDirective = struct refldetail::clang::OMPExecutableDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPParallelDirective = struct refldetail::clang::OMPParallelDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPLoopDirective = struct refldetail::clang::OMPLoopDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPSimdDirective = struct refldetail::clang::OMPSimdDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPForDirective = struct refldetail::clang::OMPForDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPForSimdDirective = struct refldetail::clang::OMPForSimdDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPSectionsDirective = struct refldetail::clang::OMPSectionsDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPSectionDirective = struct refldetail::clang::OMPSectionDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPSingleDirective = struct refldetail::clang::OMPSingleDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPMasterDirective = struct refldetail::clang::OMPMasterDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPCriticalDirective = struct refldetail::clang::OMPCriticalDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPParallelForDirective = struct refldetail::clang::OMPParallelForDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPParallelForSimdDirective = struct refldetail::clang::OMPParallelForSimdDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPParallelSectionsDirective = struct refldetail::clang::OMPParallelSectionsDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTaskDirective = struct refldetail::clang::OMPTaskDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTaskyieldDirective = struct refldetail::clang::OMPTaskyieldDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPBarrierDirective = struct refldetail::clang::OMPBarrierDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTaskwaitDirective = struct refldetail::clang::OMPTaskwaitDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTaskgroupDirective = struct refldetail::clang::OMPTaskgroupDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPFlushDirective = struct refldetail::clang::OMPFlushDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPOrderedDirective = struct refldetail::clang::OMPOrderedDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPAtomicDirective = struct refldetail::clang::OMPAtomicDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTargetDirective = struct refldetail::clang::OMPTargetDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTargetDataDirective = struct refldetail::clang::OMPTargetDataDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTargetEnterDataDirective = struct refldetail::clang::OMPTargetEnterDataDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTargetExitDataDirective = struct refldetail::clang::OMPTargetExitDataDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTargetParallelDirective = struct refldetail::clang::OMPTargetParallelDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTargetParallelForDirective = struct refldetail::clang::OMPTargetParallelForDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTeamsDirective = struct refldetail::clang::OMPTeamsDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPCancellationPointDirective = struct refldetail::clang::OMPCancellationPointDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPCancelDirective = struct refldetail::clang::OMPCancelDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTaskLoopDirective = struct refldetail::clang::OMPTaskLoopDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTaskLoopSimdDirective = struct refldetail::clang::OMPTaskLoopSimdDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPDistributeDirective = struct refldetail::clang::OMPDistributeDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTargetUpdateDirective = struct refldetail::clang::OMPTargetUpdateDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPDistributeParallelForDirective = struct refldetail::clang::OMPDistributeParallelForDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPDistributeParallelForSimdDirective = struct refldetail::clang::OMPDistributeParallelForSimdDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPDistributeSimdDirective = struct refldetail::clang::OMPDistributeSimdDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTargetParallelForSimdDirective = struct refldetail::clang::OMPTargetParallelForSimdDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTargetSimdDirective = struct refldetail::clang::OMPTargetSimdDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTeamsDistributeDirective = struct refldetail::clang::OMPTeamsDistributeDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTeamsDistributeSimdDirective = struct refldetail::clang::OMPTeamsDistributeSimdDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTeamsDistributeParallelForSimdDirective = struct refldetail::clang::OMPTeamsDistributeParallelForSimdDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTeamsDistributeParallelForDirective = struct refldetail::clang::OMPTeamsDistributeParallelForDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTargetTeamsDirective = struct refldetail::clang::OMPTargetTeamsDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTargetTeamsDistributeDirective = struct refldetail::clang::OMPTargetTeamsDistributeDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTargetTeamsDistributeParallelForDirective = struct refldetail::clang::OMPTargetTeamsDistributeParallelForDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTargetTeamsDistributeParallelForSimdDirective = struct refldetail::clang::OMPTargetTeamsDistributeParallelForSimdDirective::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using OMPTargetTeamsDistributeSimdDirective = struct refldetail::clang::OMPTargetTeamsDistributeSimdDirective::M_template impl M_targpack(Zs);
  }

  namespace clang {
  M_template_rtpack(Zs) using StoredDeclsMap = struct refldetail::clang::StoredDeclsMap::M_template impl M_targpack(Zs);
  }

  namespace clang {
  }

  namespace clang {
  M_template_rtpack(Zs) using DependentDiagnostic = struct refldetail::clang::DependentDiagnostic::M_template impl M_targpack(Zs);
  }

  namespace reflcontainers {
  M_template_rtpack(Zs) using VectorStr = struct refldetail::reflcontainers::VectorStr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using VectorInt = struct refldetail::reflcontainers::VectorInt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SetInt = struct refldetail::reflcontainers::SetInt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using SetStr = struct refldetail::reflcontainers::SetStr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using IntIntPair = struct refldetail::reflcontainers::IntIntPair::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using IntStrPair = struct refldetail::reflcontainers::IntStrPair::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using StrIntPair = struct refldetail::reflcontainers::StrIntPair::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using StrStrPair = struct refldetail::reflcontainers::StrStrPair::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using MapIntStr = struct refldetail::reflcontainers::MapIntStr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using MapStrInt = struct refldetail::reflcontainers::MapStrInt::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using MapStrStr = struct refldetail::reflcontainers::MapStrStr::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using MapIntInt = struct refldetail::reflcontainers::MapIntInt::M_template impl M_targpack(Zs);
  }
namespace refldetail {


/// Class for arbitrary precision integers.
///
/// APInt is a functional replacement for common case unsigned integer type like
/// "unsigned", "unsigned long" or "uint64_t", but also allows non-byte-width
/// integer sizes and large integer value types such as 3-bits, 15-bits, or more
/// than 64-bits of precision. APInt provides a variety of arithmetic operators
/// and methods to manipulate integer values of any bit-width. It supports both
/// the typical integer arithmetic and comparison operations as well as bitwise
/// manipulation.
///
/// The class has several invariants worth noting:
///   * All bit, byte, and word positions are zero-based.
///   * Once the bit width is set, it doesn't change except by the Truncate,
///     SignExtend, or ZeroExtend operations.
///   * All binary operators must be on APInt instances of the same bit width.
///     Attempting to use these operators on instances with different bit
///     widths will yield an assertion.
///   * The value is stored canonically as an unsigned value. For operations
///     where it makes a difference, there are both signed and unsigned variants
///     of the operation. For example, sdiv and udiv. However, because the bit
///     widths must be the same, operations such as Mul and Add produce the same
///     results regardless of whether the values are interpreted as signed or
///     not.
///   * In general, the class tries to follow the style of computation that LLVM
///     uses in its IR. This simplifies its use for LLVM.
///
M_template_rtpack(Xs)
struct llvm::APInt::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_llvm__APInt;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::llvm::APInt::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  static const unsigned long long WORD_MAX = 18446744073709551615u;
  /// Returns whether this instance allocated memory.
  constexpr bool needsCleanup() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::needsCleanup, Xs...); }) , (;) )
  /// Used to insert APInt objects, or objects that contain APInt objects, into
  ///  FoldingSets.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) id) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::Profile, Xs..., Y0s...); }) , (;) )
  /// Determine sign of this APInt.
  ///
  /// This tests the high bit of this APInt to determine if it is set.
  ///
  /// \returns true if this APInt is negative, false otherwise
  constexpr bool isNegative() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isNegative, Xs...); }) , (;) )
  /// Determine if this APInt Value is non-negative (>= 0)
  ///
  /// This tests the high bit of the APInt to determine if it is unset.
  constexpr bool isNonNegative() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isNonNegative, Xs...); }) , (;) )
  /// Determine if sign bit of this APInt is set.
  ///
  /// This tests the high bit of this APInt to determine if it is set.
  ///
  /// \returns true if this APInt has its sign bit set, false otherwise.
  constexpr bool isSignBitSet() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isSignBitSet, Xs...); }) , (;) )
  /// Determine if sign bit of this APInt is clear.
  ///
  /// This tests the high bit of this APInt to determine if it is clear.
  ///
  /// \returns true if this APInt has its sign bit clear, false otherwise.
  constexpr bool isSignBitClear() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isSignBitClear, Xs...); }) , (;) )
  /// Determine if this APInt Value is positive.
  ///
  /// This tests if the value of this APInt is positive (> 0). Note
  /// that 0 is not a positive value.
  ///
  /// \returns true if this APInt is positive.
  constexpr bool isStrictlyPositive() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isStrictlyPositive, Xs...); }) , (;) )
  /// Determine if all bits are set
  ///
  /// This checks to see if the value has all bits of the APInt are set or not.
  constexpr bool isAllOnesValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isAllOnesValue, Xs...); }) , (;) )
  /// Determine if all bits are clear
  ///
  /// This checks to see if the value has all bits of the APInt are clear or
  /// not.
  constexpr bool isNullValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isNullValue, Xs...); }) , (;) )
  /// Determine if this is a value of 1.
  ///
  /// This checks to see if the value of this APInt is one.
  constexpr bool isOneValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isOneValue, Xs...); }) , (;) )
  /// Determine if this is the largest unsigned value.
  ///
  /// This checks to see if the value of this APInt is the maximum unsigned
  /// value for the APInt's bit width.
  constexpr bool isMaxValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isMaxValue, Xs...); }) , (;) )
  /// Determine if this is the largest signed value.
  ///
  /// This checks to see if the value of this APInt is the maximum signed
  /// value for the APInt's bit width.
  constexpr bool isMaxSignedValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isMaxSignedValue, Xs...); }) , (;) )
  /// Determine if this is the smallest unsigned value.
  ///
  /// This checks to see if the value of this APInt is the minimum unsigned
  /// value for the APInt's bit width.
  constexpr bool isMinValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isMinValue, Xs...); }) , (;) )
  /// Determine if this is the smallest signed value.
  ///
  /// This checks to see if the value of this APInt is the minimum signed
  /// value for the APInt's bit width.
  constexpr bool isMinSignedValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isMinSignedValue, Xs...); }) , (;) )
  /// Check if this APInt has an N-bits unsigned integer value.
  constexpr bool isIntN(unsigned int N) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isIntN, Xs..., N); }) , (;) )
  /// Check if this APInt has an N-bits signed integer value.
  constexpr bool isSignedIntN(unsigned int N) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isSignedIntN, Xs..., N); }) , (;) )
  /// Check if this APInt's value is a power of two greater than zero.
  ///
  /// \returns true if the argument APInt value is a power of two > 0.
  constexpr bool isPowerOf2() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isPowerOf2, Xs...); }) , (;) )
  /// Check if the APInt's value is returned by getSignMask.
  ///
  /// \returns true if this is the value returned by getSignMask.
  constexpr bool isSignMask() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isSignMask, Xs...); }) , (;) )
  /// Convert APInt to a boolean value.
  ///
  /// This converts the APInt to a boolean value as a test against zero.
  constexpr bool getBoolValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::getBoolValue, Xs...); }) , (;) )
  /// If this value is smaller than the specified limit, return it, otherwise
  /// return the limit value.  This causes the value to saturate to the limit.
  constexpr unsigned long long getLimitedValue(unsigned long long Limit = 18446744073709551615ULL) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::getLimitedValue, Xs..., Limit); }) , (;) )
  /// Check if the APInt consists of a repeated bit pattern.
  ///
  /// e.g. 0x01010101 satisfies isSplat(8).
  /// \param SplatSizeInBits The size of the pattern in bits. Must divide bit
  /// width without remainder.
  constexpr bool isSplat(unsigned int SplatSizeInBits) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isSplat, Xs..., SplatSizeInBits); }) , (;) )
  /// \returns true if this APInt value is a sequence of \param numBits ones
  /// starting at the least significant bit with the remainder zero.
  constexpr bool isMask(unsigned int numBits) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isMask, Xs..., numBits); }) , (;) )
  /// \returns true if this APInt is a non-empty sequence of ones starting at
  /// the least significant bit with the remainder zero.
  /// Ex. isMask(0x0000FFFFU) == true.
  constexpr bool isMask() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isMask1, Xs...); }) , (;) )
  /// Return true if this APInt value contains a sequence of ones with
  /// the remainder zero.
  constexpr bool isShiftedMask() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isShiftedMask, Xs...); }) , (;) )
  /// Determine if two APInts have the same value, after zero-extending
  /// one of them (if needed!) to ensure that the bit-widths match.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr bool isSameValue(IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APInt &)) I1, IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::llvm::APInt &)) I2) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isSameValue, Xs..., Y0s..., Y1s...); }) , (;) )
  /// This function returns a pointer to the internal storage of the APInt.
  /// This is useful for writing out the APInt in binary form without any
  /// conversions.
  constexpr const unsigned long long * getRawData() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::getRawData, Xs...); }) , (;) )
  /// Logical negation operator.
  ///
  /// Performs logical negation operation on this APInt.
  ///
  /// \returns true if *this is zero, false otherwise.
  constexpr bool operator!() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::operator_not, Xs...); }) , (;) )
  constexpr unsigned long long urem(unsigned long long RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::urem, Xs..., RHS); }) , (;) )
  constexpr long long srem(long long RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::srem, Xs..., RHS); }) , (;) )
  /// Dual division/remainder interface.
  ///
  /// Sometimes it is convenient to divide two APInt values and obtain both the
  /// quotient and remainder. This function does both operations in the same
  /// computation making it a little more efficient. The pair of input arguments
  /// may overlap with the pair of output arguments. It is safe to call
  /// udivrem(X, Y, X, Y), for example.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_c M_rtpack(Y3s) M_tend
  static constexpr void udivrem(IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APInt &)) LHS, IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::llvm::APInt &)) RHS, IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y2s...>), (typename meta::llvm::APInt &)) Quotient, IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y3s...>), (typename meta::llvm::APInt &)) Remainder) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::udivrem, Xs..., Y0s..., Y1s..., Y2s..., Y3s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_c M_rtpack(Y3s) M_tend
  static constexpr void sdivrem(IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APInt &)) LHS, IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::llvm::APInt &)) RHS, IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y2s...>), (typename meta::llvm::APInt &)) Quotient, IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y3s...>), (typename meta::llvm::APInt &)) Remainder) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::sdivrem, Xs..., Y0s..., Y1s..., Y2s..., Y3s...); }) , (;) )
  /// Array-indexing support.
  ///
  /// \returns the bit value at bitPosition
  constexpr bool operator[](unsigned int bitPosition) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::operator_sub, Xs..., bitPosition); }) , (;) )
  /// Equality operator.
  ///
  /// Compares this APInt with RHS for the validity of the equality
  /// relationship.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator==(IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::operator_eq_eq, Xs..., Y0s...); }) , (;) )
  /// Equality operator.
  ///
  /// Compares this APInt with a uint64_t for the validity of the equality
  /// relationship.
  ///
  /// \returns true if *this == Val
  constexpr bool operator==(unsigned long long Val) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::operator_eq_eq1, Xs..., Val); }) , (;) )
  /// Equality comparison.
  ///
  /// Compares this APInt with RHS for the validity of the equality
  /// relationship.
  ///
  /// \returns true if *this == Val
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool eq(IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::eq, Xs..., Y0s...); }) , (;) )
  /// Inequality operator.
  ///
  /// Compares this APInt with RHS for the validity of the inequality
  /// relationship.
  ///
  /// \returns true if *this != Val
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator!=(IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::operator_not_eq, Xs..., Y0s...); }) , (;) )
  /// Inequality operator.
  ///
  /// Compares this APInt with a uint64_t for the validity of the inequality
  /// relationship.
  ///
  /// \returns true if *this != Val
  constexpr bool operator!=(unsigned long long Val) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::operator_not_eq1, Xs..., Val); }) , (;) )
  /// Inequality comparison
  ///
  /// Compares this APInt with RHS for the validity of the inequality
  /// relationship.
  ///
  /// \returns true if *this != Val
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool ne(IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::ne, Xs..., Y0s...); }) , (;) )
  /// Unsigned less than comparison
  ///
  /// Regards both *this and RHS as unsigned quantities and compares them for
  /// the validity of the less-than relationship.
  ///
  /// \returns true if *this < RHS when both are considered unsigned.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool ult(IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::ult, Xs..., Y0s...); }) , (;) )
  /// Unsigned less than comparison
  ///
  /// Regards both *this as an unsigned quantity and compares it with RHS for
  /// the validity of the less-than relationship.
  ///
  /// \returns true if *this < RHS when considered unsigned.
  constexpr bool ult(unsigned long long RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::ult1, Xs..., RHS); }) , (;) )
  /// Signed less than comparison
  ///
  /// Regards both *this and RHS as signed quantities and compares them for
  /// validity of the less-than relationship.
  ///
  /// \returns true if *this < RHS when both are considered signed.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool slt(IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::slt, Xs..., Y0s...); }) , (;) )
  /// Signed less than comparison
  ///
  /// Regards both *this as a signed quantity and compares it with RHS for
  /// the validity of the less-than relationship.
  ///
  /// \returns true if *this < RHS when considered signed.
  constexpr bool slt(long long RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::slt1, Xs..., RHS); }) , (;) )
  /// Unsigned less or equal comparison
  ///
  /// Regards both *this and RHS as unsigned quantities and compares them for
  /// validity of the less-or-equal relationship.
  ///
  /// \returns true if *this <= RHS when both are considered unsigned.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool ule(IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::ule, Xs..., Y0s...); }) , (;) )
  /// Unsigned less or equal comparison
  ///
  /// Regards both *this as an unsigned quantity and compares it with RHS for
  /// the validity of the less-or-equal relationship.
  ///
  /// \returns true if *this <= RHS when considered unsigned.
  constexpr bool ule(unsigned long long RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::ule1, Xs..., RHS); }) , (;) )
  /// Signed less or equal comparison
  ///
  /// Regards both *this and RHS as signed quantities and compares them for
  /// validity of the less-or-equal relationship.
  ///
  /// \returns true if *this <= RHS when both are considered signed.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool sle(IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::sle, Xs..., Y0s...); }) , (;) )
  /// Signed less or equal comparison
  ///
  /// Regards both *this as a signed quantity and compares it with RHS for the
  /// validity of the less-or-equal relationship.
  ///
  /// \returns true if *this <= RHS when considered signed.
  constexpr bool sle(unsigned long long RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::sle1, Xs..., RHS); }) , (;) )
  /// Unsigned greather than comparison
  ///
  /// Regards both *this and RHS as unsigned quantities and compares them for
  /// the validity of the greater-than relationship.
  ///
  /// \returns true if *this > RHS when both are considered unsigned.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool ugt(IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::ugt, Xs..., Y0s...); }) , (;) )
  /// Unsigned greater than comparison
  ///
  /// Regards both *this as an unsigned quantity and compares it with RHS for
  /// the validity of the greater-than relationship.
  ///
  /// \returns true if *this > RHS when considered unsigned.
  constexpr bool ugt(unsigned long long RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::ugt1, Xs..., RHS); }) , (;) )
  /// Signed greather than comparison
  ///
  /// Regards both *this and RHS as signed quantities and compares them for the
  /// validity of the greater-than relationship.
  ///
  /// \returns true if *this > RHS when both are considered signed.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool sgt(IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::sgt, Xs..., Y0s...); }) , (;) )
  /// Signed greater than comparison
  ///
  /// Regards both *this as a signed quantity and compares it with RHS for
  /// the validity of the greater-than relationship.
  ///
  /// \returns true if *this > RHS when considered signed.
  constexpr bool sgt(long long RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::sgt1, Xs..., RHS); }) , (;) )
  /// Unsigned greater or equal comparison
  ///
  /// Regards both *this and RHS as unsigned quantities and compares them for
  /// validity of the greater-or-equal relationship.
  ///
  /// \returns true if *this >= RHS when both are considered unsigned.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool uge(IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::uge, Xs..., Y0s...); }) , (;) )
  /// Unsigned greater or equal comparison
  ///
  /// Regards both *this as an unsigned quantity and compares it with RHS for
  /// the validity of the greater-or-equal relationship.
  ///
  /// \returns true if *this >= RHS when considered unsigned.
  constexpr bool uge(unsigned long long RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::uge1, Xs..., RHS); }) , (;) )
  /// Signed greater or equal comparison
  ///
  /// Regards both *this and RHS as signed quantities and compares them for
  /// validity of the greater-or-equal relationship.
  ///
  /// \returns true if *this >= RHS when both are considered signed.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool sge(IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::sge, Xs..., Y0s...); }) , (;) )
  /// Signed greater or equal comparison
  ///
  /// Regards both *this as a signed quantity and compares it with RHS for
  /// the validity of the greater-or-equal relationship.
  ///
  /// \returns true if *this >= RHS when considered signed.
  constexpr bool sge(long long RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::sge1, Xs..., RHS); }) , (;) )
  /// This operation tests if there are any pairs of corresponding bits
  /// between this APInt and RHS that are both set.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool intersects(IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::intersects, Xs..., Y0s...); }) , (;) )
  /// This operation checks that all bits set in this APInt are also set in RHS.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isSubsetOf(IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::isSubsetOf, Xs..., Y0s...); }) , (;) )
  /// Return the number of bits in the APInt.
  constexpr unsigned int getBitWidth() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::getBitWidth, Xs...); }) , (;) )
  /// Get the number of words.
  ///
  /// Here one word's bitwidth equals to that of uint64_t.
  ///
  /// \returns the number of words to hold the integer value of this APInt.
  constexpr unsigned int getNumWords() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::getNumWords, Xs...); }) , (;) )
  /// Get the number of words.
  ///
  /// *NOTE* Here one word's bitwidth equals to that of uint64_t.
  ///
  /// \returns the number of words to hold the integer value with a given bit
  /// width.
  static constexpr unsigned int getNumWords(unsigned int BitWidth) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::getNumWords1, Xs..., BitWidth); }) , (;) )
  /// Compute the number of active bits in the value
  ///
  /// This function returns the number of active bits which is defined as the
  /// bit width minus the number of leading zeros. This is used in several
  /// computations to see how "wide" the value is.
  constexpr unsigned int getActiveBits() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::getActiveBits, Xs...); }) , (;) )
  /// Compute the number of active words in the value of this APInt.
  ///
  /// This is used in conjunction with getActiveData to extract the raw value of
  /// the APInt.
  constexpr unsigned int getActiveWords() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::getActiveWords, Xs...); }) , (;) )
  /// Get the minimum bit size for this signed APInt
  ///
  /// Computes the minimum bit width for this APInt while considering it to be a
  /// signed (and probably negative) value. If the value is not negative, this
  /// function returns the same value as getActiveBits()+1. Otherwise, it
  /// returns the smallest bit width that will retain the negative value. For
  /// example, -1 can be written as 0b1 or 0xFFFFFFFFFF. 0b1 is shorter and so
  /// for -1, this function will always return 1.
  constexpr unsigned int getMinSignedBits() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::getMinSignedBits, Xs...); }) , (;) )
  /// Get zero extended value
  ///
  /// This method attempts to return the value of this APInt as a zero extended
  /// uint64_t. The bitwidth must be <= 64 or the value must fit within a
  /// uint64_t. Otherwise an assertion will result.
  constexpr unsigned long long getZExtValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::getZExtValue, Xs...); }) , (;) )
  /// Get sign extended value
  ///
  /// This method attempts to return the value of this APInt as a sign extended
  /// int64_t. The bit width must be <= 64 or the value must fit within an
  /// int64_t. Otherwise an assertion will result.
  constexpr long long getSExtValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::getSExtValue, Xs...); }) , (;) )
  /// Get bits required for string value.
  ///
  /// This method determines how many bits are required to hold the APInt
  /// equivalent of the string given by \p str.
  static constexpr unsigned int getBitsNeeded(const char * str, unsigned char radix) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::getBitsNeeded, Xs..., str, radix); }) , (;) )
  /// The APInt version of the countLeadingZeros functions in
  ///   MathExtras.h.
  ///
  /// It counts the number of zeros from the most significant bit to the first
  /// one bit.
  ///
  /// \returns BitWidth if the value is zero, otherwise returns the number of
  ///   zeros from the most significant bit to the first one bits.
  constexpr unsigned int countLeadingZeros() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::countLeadingZeros, Xs...); }) , (;) )
  /// Count the number of leading one bits.
  ///
  /// This function is an APInt version of the countLeadingOnes
  /// functions in MathExtras.h. It counts the number of ones from the most
  /// significant bit to the first zero bit.
  ///
  /// \returns 0 if the high order bit is not set, otherwise returns the number
  /// of 1 bits from the most significant to the least
  constexpr unsigned int countLeadingOnes() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::countLeadingOnes, Xs...); }) , (;) )
  /// Computes the number of leading bits of this APInt that are equal to its
  /// sign bit.
  constexpr unsigned int getNumSignBits() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::getNumSignBits, Xs...); }) , (;) )
  /// Count the number of trailing zero bits.
  ///
  /// This function is an APInt version of the countTrailingZeros
  /// functions in MathExtras.h. It counts the number of zeros from the least
  /// significant bit to the first set bit.
  ///
  /// \returns BitWidth if the value is zero, otherwise returns the number of
  /// zeros from the least significant bit to the first one bit.
  constexpr unsigned int countTrailingZeros() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::countTrailingZeros, Xs...); }) , (;) )
  /// Count the number of trailing one bits.
  ///
  /// This function is an APInt version of the countTrailingOnes
  /// functions in MathExtras.h. It counts the number of ones from the least
  /// significant bit to the first zero bit.
  ///
  /// \returns BitWidth if the value is all ones, otherwise returns the number
  /// of ones from the least significant bit to the first zero bit.
  constexpr unsigned int countTrailingOnes() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::countTrailingOnes, Xs...); }) , (;) )
  /// Count the number of bits set.
  ///
  /// This function is an APInt version of the countPopulation functions
  /// in MathExtras.h. It counts the number of 1 bits in the APInt value.
  ///
  /// \returns 0 if the value is zero, otherwise returns the number of set bits.
  constexpr unsigned int countPopulation() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::countPopulation, Xs...); }) , (;) )
  /// @}
  /// \name Conversion Functions
  /// @{
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void print(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) OS, bool isSigned) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::print, Xs..., Y0s..., isSigned); }) , (;) )
  /// Return the APInt as a std::string.
  ///
  /// Note that this is an inefficient method.  It is better to pass in a
  /// SmallVector/SmallString to the methods above to avoid thrashing the heap
  /// for the string.
  constexpr const char * toString(unsigned int Radix, bool Signed) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::toString, Xs..., Radix, Signed); }) , (;) )
  /// Converts this APInt to a double value.
  constexpr double roundToDouble(bool isSigned) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::roundToDouble, Xs..., isSigned); }) , (;) )
  /// Converts this unsigned APInt to a double value.
  constexpr double roundToDouble() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::roundToDouble1, Xs...); }) , (;) )
  /// Converts this signed APInt to a double value.
  constexpr double signedRoundToDouble() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::signedRoundToDouble, Xs...); }) , (;) )
  /// Converts APInt bits to a double
  ///
  /// The conversion does not do a translation from integer to double, it just
  /// re-interprets the bits as a double. Note that it is valid to do this on
  /// any bit width. Exactly 64 bits will be translated.
  constexpr double bitsToDouble() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::bitsToDouble, Xs...); }) , (;) )
  /// Converts APInt bits to a double
  ///
  /// The conversion does not do a translation from integer to float, it just
  /// re-interprets the bits as a float. Note that it is valid to do this on
  /// any bit width. Exactly 32 bits will be translated.
  constexpr float bitsToFloat() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::bitsToFloat, Xs...); }) , (;) )
  /// \returns the floor log base 2 of this APInt.
  constexpr unsigned int logBase2() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::logBase2, Xs...); }) , (;) )
  /// \returns the ceil log base 2 of this APInt.
  constexpr unsigned int ceilLogBase2() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::ceilLogBase2, Xs...); }) , (;) )
  /// \returns the nearest log base 2 of this APInt. Ties round up.
  ///
  /// NOTE: When we have a BitWidth of 1, we define:
  ///
  ///   log2(0) = UINT32_MAX
  ///   log2(1) = 0
  ///
  /// to get around any mathematical concerns resulting from
  /// referencing 2 in a space where 2 does no exist.
  constexpr unsigned int nearestLogBase2() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::nearestLogBase2, Xs...); }) , (;) )
  /// \returns the log base 2 of this APInt if its an exact power of two, -1
  /// otherwise
  constexpr int exactLogBase2() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::exactLogBase2, Xs...); }) , (;) )
  M_template_rtpack(Zs) using ms = struct refldetail::llvm::APInt::ms::M_template impl M_targpack(Zs);
  constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APInt::ms) )
  magic() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::magic, Xs...); }) , (;) )
  M_template_rtpack(Zs) using mu = struct refldetail::llvm::APInt::mu::M_template impl M_targpack(Zs);
  constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APInt::mu) )
  magicu(unsigned int LeadingZeros = 0) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::magicu, Xs..., LeadingZeros); }) , (;) )
  /// Sets the least significant part of a bignum to the input value, and zeroes
  /// out higher parts.
  static constexpr void tcSet(unsigned long long * p0, unsigned long long p1, unsigned int p2) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcSet, Xs..., p0, p1, p2); }) , (;) )
  /// Assign one bignum to another.
  static constexpr void tcAssign(unsigned long long * p0, const unsigned long long * p1, unsigned int p2) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcAssign, Xs..., p0, p1, p2); }) , (;) )
  /// Returns true if a bignum is zero, false otherwise.
  static constexpr bool tcIsZero(const unsigned long long * p0, unsigned int p1) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcIsZero, Xs..., p0, p1); }) , (;) )
  /// Extract the given bit of a bignum; returns 0 or 1.  Zero-based.
  static constexpr int tcExtractBit(const unsigned long long * p0, unsigned int bit) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcExtractBit, Xs..., p0, bit); }) , (;) )
  /// Copy the bit vector of width srcBITS from SRC, starting at bit srcLSB, to
  /// DST, of dstCOUNT parts, such that the bit srcLSB becomes the least
  /// significant bit of DST.  All high bits above srcBITS in DST are
  /// zero-filled.
  static constexpr void tcExtract(unsigned long long * p0, unsigned int dstCount, const unsigned long long * p2, unsigned int srcBits, unsigned int srcLSB) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcExtract, Xs..., p0, dstCount, p2, srcBits, srcLSB); }) , (;) )
  /// Set the given bit of a bignum.  Zero-based.
  static constexpr void tcSetBit(unsigned long long * p0, unsigned int bit) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcSetBit, Xs..., p0, bit); }) , (;) )
  /// Clear the given bit of a bignum.  Zero-based.
  static constexpr void tcClearBit(unsigned long long * p0, unsigned int bit) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcClearBit, Xs..., p0, bit); }) , (;) )
  /// Returns the bit number of the least or most significant set bit of a
  /// number.  If the input number has no bits set -1U is returned.
  static constexpr unsigned int tcLSB(const unsigned long long * p0, unsigned int n) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcLSB, Xs..., p0, n); }) , (;) )
  static constexpr unsigned int tcMSB(const unsigned long long * parts, unsigned int n) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcMSB, Xs..., parts, n); }) , (;) )
  /// Negate a bignum in-place.
  static constexpr void tcNegate(unsigned long long * p0, unsigned int p1) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcNegate, Xs..., p0, p1); }) , (;) )
  /// DST += RHS + CARRY where CARRY is zero or one.  Returns the carry flag.
  static constexpr unsigned long long tcAdd(unsigned long long * p0, const unsigned long long * p1, unsigned long long carry, unsigned int p3) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcAdd, Xs..., p0, p1, carry, p3); }) , (;) )
  /// DST += RHS.  Returns the carry flag.
  static constexpr unsigned long long tcAddPart(unsigned long long * p0, unsigned long long p1, unsigned int p2) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcAddPart, Xs..., p0, p1, p2); }) , (;) )
  /// DST -= RHS + CARRY where CARRY is zero or one. Returns the carry flag.
  static constexpr unsigned long long tcSubtract(unsigned long long * p0, const unsigned long long * p1, unsigned long long carry, unsigned int p3) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcSubtract, Xs..., p0, p1, carry, p3); }) , (;) )
  /// DST -= RHS.  Returns the carry flag.
  static constexpr unsigned long long tcSubtractPart(unsigned long long * p0, unsigned long long p1, unsigned int p2) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcSubtractPart, Xs..., p0, p1, p2); }) , (;) )
  /// DST += SRC * MULTIPLIER + PART   if add is true
  /// DST  = SRC * MULTIPLIER + PART   if add is false
  ///
  /// Requires 0 <= DSTPARTS <= SRCPARTS + 1.  If DST overlaps SRC they must
  /// start at the same point, i.e. DST == SRC.
  ///
  /// If DSTPARTS == SRC_PARTS + 1 no overflow occurs and zero is returned.
  /// Otherwise DST is filled with the least significant DSTPARTS parts of the
  /// result, and if all of the omitted higher parts were zero return zero,
  /// otherwise overflow occurred and return one.
  static constexpr int tcMultiplyPart(unsigned long long * dst, const unsigned long long * src, unsigned long long multiplier, unsigned long long carry, unsigned int srcParts, unsigned int dstParts, bool add) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcMultiplyPart, Xs..., dst, src, multiplier, carry, srcParts, dstParts, add); }) , (;) )
  /// DST = LHS * RHS, where DST has the same width as the operands and is
  /// filled with the least significant parts of the result.  Returns one if
  /// overflow occurred, otherwise zero.  DST must be disjoint from both
  /// operands.
  static constexpr int tcMultiply(unsigned long long * p0, const unsigned long long * p1, const unsigned long long * p2, unsigned int p3) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcMultiply, Xs..., p0, p1, p2, p3); }) , (;) )
  /// DST = LHS * RHS, where DST has width the sum of the widths of the
  /// operands. No overflow occurs. DST must be disjoint from both operands.
  static constexpr void tcFullMultiply(unsigned long long * p0, const unsigned long long * p1, const unsigned long long * p2, unsigned int p3, unsigned int p4) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcFullMultiply, Xs..., p0, p1, p2, p3, p4); }) , (;) )
  /// If RHS is zero LHS and REMAINDER are left unchanged, return one.
  /// Otherwise set LHS to LHS / RHS with the fractional part discarded, set
  /// REMAINDER to the remainder, return zero.  i.e.
  ///
  ///  OLD_LHS = RHS * LHS + REMAINDER
  ///
  /// SCRATCH is a bignum of the same size as the operands and result for use by
  /// the routine; its contents need not be initialized and are destroyed.  LHS,
  /// REMAINDER and SCRATCH must be distinct.
  static constexpr int tcDivide(unsigned long long * lhs, const unsigned long long * rhs, unsigned long long * remainder, unsigned long long * scratch, unsigned int parts) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcDivide, Xs..., lhs, rhs, remainder, scratch, parts); }) , (;) )
  /// Shift a bignum left Count bits. Shifted in bits are zero. There are no
  /// restrictions on Count.
  static constexpr void tcShiftLeft(unsigned long long * p0, unsigned int Words, unsigned int Count) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcShiftLeft, Xs..., p0, Words, Count); }) , (;) )
  /// Shift a bignum right Count bits.  Shifted in bits are zero.  There are no
  /// restrictions on Count.
  static constexpr void tcShiftRight(unsigned long long * p0, unsigned int Words, unsigned int Count) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcShiftRight, Xs..., p0, Words, Count); }) , (;) )
  /// The obvious AND, OR and XOR and complement operations.
  static constexpr void tcAnd(unsigned long long * p0, const unsigned long long * p1, unsigned int p2) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcAnd, Xs..., p0, p1, p2); }) , (;) )
  static constexpr void tcOr(unsigned long long * p0, const unsigned long long * p1, unsigned int p2) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcOr, Xs..., p0, p1, p2); }) , (;) )
  static constexpr void tcXor(unsigned long long * p0, const unsigned long long * p1, unsigned int p2) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcXor, Xs..., p0, p1, p2); }) , (;) )
  static constexpr void tcComplement(unsigned long long * p0, unsigned int p1) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcComplement, Xs..., p0, p1); }) , (;) )
  /// Comparison (unsigned) of two bignums.
  static constexpr int tcCompare(const unsigned long long * p0, const unsigned long long * p1, unsigned int p2) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcCompare, Xs..., p0, p1, p2); }) , (;) )
  /// Increment a bignum in-place.  Return the carry flag.
  static constexpr unsigned long long tcIncrement(unsigned long long * dst, unsigned int parts) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcIncrement, Xs..., dst, parts); }) , (;) )
  /// Decrement a bignum in-place.  Return the borrow flag.
  static constexpr unsigned long long tcDecrement(unsigned long long * dst, unsigned int parts) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcDecrement, Xs..., dst, parts); }) , (;) )
  /// Set the least significant BITS and clear the rest.
  static constexpr void tcSetLeastSignificantBits(unsigned long long * p0, unsigned int p1, unsigned int bits) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::tcSetLeastSignificantBits, Xs..., p0, p1, bits); }) , (;) )
  /// debug method
  constexpr void dump() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APInt, reflenums::llvm__APInt::dump, Xs...); }) , (;) )
};

/// Magic data for optimising signed division by a constant.
M_template_rtpack(Xs)
struct llvm::APInt::ms::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_llvm__APInt__ms;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::llvm::APInt::ms::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  ///< shift amount
  unsigned int s
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_llvm__APInt__ms, reflenums::llvm__APInt__ms::s, Xs...);), (;) )
};

/// Magic data for optimising unsigned division by a constant.
M_template_rtpack(Xs)
struct llvm::APInt::mu::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_llvm__APInt__mu;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::llvm::APInt::mu::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  ///< add indicator
  bool a
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_llvm__APInt__mu, reflenums::llvm__APInt__mu::a, Xs...);), (;) )
  ///< shift amount
  unsigned int s
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_llvm__APInt__mu, reflenums::llvm__APInt__mu::s, Xs...);), (;) )
};

/// IEEE-754R 5.11: Floating Point Comparison Relations.
enum llvm::APFloatBase::cmpResult : unsigned int {
  cmpLessThan,
  cmpEqual,
  cmpGreaterThan,
  cmpUnordered,
};

/// IEEE-754R 4.3: Rounding-direction attributes.
enum llvm::APFloatBase::roundingMode : unsigned int {
  rmNearestTiesToEven,
  rmTowardPositive,
  rmTowardNegative,
  rmTowardZero,
  rmNearestTiesToAway,
};

/// IEEE-754R 7: Default exception handling.
///
/// opUnderflow or opOverflow are always returned or-ed with opInexact.
enum llvm::APFloatBase::opStatus : unsigned int {
  opOK = 0,
  opInvalidOp = 1,
  opDivByZero = 2,
  opOverflow = 4,
  opUnderflow = 8,
  opInexact = 16,
};

/// Category of internally-represented number.
enum llvm::APFloatBase::fltCategory : unsigned int {
  fcInfinity,
  fcNaN,
  fcNormal,
  fcZero,
};

/// A self-contained host- and target-independent arbitrary-precision
/// floating-point software implementation.
///
/// APFloat uses bignum integer arithmetic as provided by static functions in
/// the APInt class.  The library will work with bignum integers whose parts are
/// any unsigned type at least 16 bits wide, but 64 bits is recommended.
///
/// Written for clarity rather than speed, in particular with a view to use in
/// the front-end of a cross compiler so that target arithmetic can be correctly
/// performed on the host.  Performance should nonetheless be reasonable,
/// particularly for its intended use.  It may be useful as a base
/// implementation for a run-time library during development of a faster
/// target-specific one.
///
/// All 5 rounding modes in the IEEE-754R draft are handled correctly for all
/// implemented operations.  Currently implemented operations are add, subtract,
/// multiply, divide, fused-multiply-add, conversion-to-float,
/// conversion-to-integer and conversion-from-integer.  New rounding modes
/// (e.g. away from zero) can be added with three or four lines of code.
///
/// Four formats are built-in: IEEE single precision, double precision,
/// quadruple precision, and x87 80-bit extended double (when operating with
/// full extended precision).  Adding a new format that obeys IEEE semantics
/// only requires adding two lines of code: a declaration and definition of the
/// format.
///
/// All operations return the status of that operation as an exception bit-mask,
/// so multiple operations can be done consecutively with their results or-ed
/// together.  The returned status can be useful for compiler diagnostics; e.g.,
/// inexact, underflow and overflow can be easily diagnosed on constant folding,
/// and compiler optimizers can determine what exceptions would be raised by
/// folding operations and optimize, or perhaps not optimize, accordingly.
///
/// At present, underflow tininess is detected after rounding; it should be
/// straight forward to add support for the before-rounding case too.
///
/// The library reads hexadecimal floating point numbers as per C99, and
/// correctly rounds if necessary according to the specified rounding mode.
/// Syntax is required to have been validated by the caller.  It also converts
/// floating point numbers to hexadecimal text as per the C99 %a and %A
/// conversions.  The output precision (or alternatively the natural minimal
/// precision) can be specified; if the requested precision is less than the
/// natural precision the output is correctly rounded for the specified rounding
/// mode.
///
/// It also reads decimal floating point numbers and correctly rounds according
/// to the specified rounding mode.
///
/// Conversion to decimal text is not currently implemented.
///
/// Non-zero finite numbers are represented internally as a sign bit, a 16-bit
/// signed exponent, and the significand as an array of integer parts.  After
/// normalization of a number of precision P the exponent is within the range of
/// the format, and if the number is not denormal the P-th bit of the
/// significand is set as an explicit integer bit.  For denormals the most
/// significant bit is shifted right so that the exponent is maintained at the
/// format's minimum, so that the smallest denormal has just the least
/// significant bit of the significand set.  The sign of zeroes and infinities
/// is significant; the exponent and significand of such numbers is not stored,
/// but has a known implicit (deterministic) value: 0 for the significands, 0
/// for zero exponent, all 1 bits for infinity exponent.  For NaNs the sign and
/// significand are deterministic, although not really meaningful, and preserved
/// in non-conversion operations.  The exponent is implicitly all 1 bits.
///
/// APFloat does not provide any exception handling beyond default exception
/// handling. We represent Signaling NaNs via IEEE-754R 2008 6.2.1 should clause
/// by encoding Signaling NaNs with the first bit of its trailing significand as
/// 0.
///
/// TODO
/// ====
///
/// Some features that may or may not be worth adding:
///
/// Binary to decimal conversion (hard).
///
/// Optional ability to detect underflow tininess before rounding.
///
/// New formats: x87 in single and double precision mode (IEEE apart from
/// extended exponent range) (hard).
///
/// New operations: sqrt, IEEE remainder, C90 fmod, nexttoward.
///
M_template_rtpack(Xs)
struct llvm::APFloatBase::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_llvm__APFloatBase;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::llvm::APFloatBase::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  static const unsigned int integerPartWidth = 64u;
  using cmpResult = enum refldetail::llvm::APFloatBase::cmpResult;
  using roundingMode = enum refldetail::llvm::APFloatBase::roundingMode;
  using opStatus = enum refldetail::llvm::APFloatBase::opStatus;
  using fltCategory = enum refldetail::llvm::APFloatBase::fltCategory;
};

M_template_rtpack(Xs)
struct llvm::APFloat::impl : impl_offset_t<llvm::APFloatBase, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_llvm__APFloat;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::llvm::APFloat::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr bool needsCleanup() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::needsCleanup, Xs...); }) , (;) )
  /// Used to insert APFloat objects, or objects that contain APFloat objects,
  /// into FoldingSets.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) NID) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::Profile, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr enum llvm::APFloatBase::opStatus convertToInteger(IFMETA_ELSE((const llvm::APSInt::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::APSInt &)) Result, enum llvm::APFloatBase::roundingMode RM, bool * IsExact) const IFMETA_ELSE( ({    return (enum llvm::APFloatBase::opStatus)__reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::convertToInteger, Xs..., Y0s..., RM, IsExact); }) , (;) )
  constexpr double convertToDouble() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::convertToDouble, Xs...); }) , (;) )
  constexpr float convertToFloat() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::convertToFloat, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr enum llvm::APFloatBase::cmpResult compare(IFMETA_ELSE((const llvm::APFloat::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APFloat &)) RHS) const IFMETA_ELSE( ({    return (enum llvm::APFloatBase::cmpResult)__reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::compare, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool bitwiseIsEqual(IFMETA_ELSE((const llvm::APFloat::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APFloat &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::bitwiseIsEqual, Xs..., Y0s...); }) , (;) )
  /// We don't rely on operator== working on double values, as
  /// it returns true for things that are clearly not equal, like -0.0 and 0.0.
  /// As such, this method can be used to do an exact bit-for-bit comparison of
  /// two floating point values.
  ///
  /// We leave the version with the double argument here because it's just so
  /// convenient to write "2.0" and the like.  Without this function we'd
  /// have to duplicate its logic everywhere it's called.
  constexpr bool isExactlyValue(double V) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::isExactlyValue, Xs..., V); }) , (;) )
  constexpr unsigned int convertToHexString(char * DST, unsigned int HexDigits, bool UpperCase, enum llvm::APFloatBase::roundingMode RM) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::convertToHexString, Xs..., DST, HexDigits, UpperCase, RM); }) , (;) )
  constexpr bool isZero() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::isZero, Xs...); }) , (;) )
  constexpr bool isInfinity() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::isInfinity, Xs...); }) , (;) )
  constexpr bool isNaN() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::isNaN, Xs...); }) , (;) )
  constexpr bool isNegative() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::isNegative, Xs...); }) , (;) )
  constexpr bool isDenormal() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::isDenormal, Xs...); }) , (;) )
  constexpr bool isSignaling() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::isSignaling, Xs...); }) , (;) )
  constexpr bool isNormal() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::isNormal, Xs...); }) , (;) )
  constexpr bool isFinite() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::isFinite, Xs...); }) , (;) )
  constexpr enum llvm::APFloatBase::fltCategory getCategory() const IFMETA_ELSE( ({    return (enum llvm::APFloatBase::fltCategory)__reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::getCategory, Xs...); }) , (;) )
  constexpr bool isNonZero() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::isNonZero, Xs...); }) , (;) )
  constexpr bool isFiniteNonZero() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::isFiniteNonZero, Xs...); }) , (;) )
  constexpr bool isPosZero() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::isPosZero, Xs...); }) , (;) )
  constexpr bool isNegZero() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::isNegZero, Xs...); }) , (;) )
  constexpr bool isSmallest() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::isSmallest, Xs...); }) , (;) )
  constexpr bool isLargest() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::isLargest, Xs...); }) , (;) )
  constexpr bool isInteger() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::isInteger, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void print(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) p0) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::print, Xs..., Y0s...); }) , (;) )
  constexpr void dump() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::dump, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool getExactInverse(IFMETA_ELSE((const llvm::APFloat::template impl</*ptrorref=*/1, Y0s...> *), (typename meta::llvm::APFloat *)) inv) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APFloat, reflenums::llvm__APFloat::getExactInverse, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  constexpr bool getExactInverse(ptrwrp<Y0> p0) const {
      return getExactInverse(p0.get());
  }), () )
};

M_template_rtpack(Xs)
struct llvm::APSInt::impl : impl_offset_t<llvm::APInt, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_llvm__APSInt;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::llvm::APSInt::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr bool isSigned() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::isSigned, Xs...); }) , (;) )
  constexpr bool isUnsigned() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::isUnsigned, Xs...); }) , (;) )
  /// toString - Converts an APInt to a std::string.  This is an inefficient
  /// method; you should prefer passing in a SmallString instead.
  constexpr const char * toString(unsigned int Radix) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::toString, Xs..., Radix); }) , (;) )
  /// Get the correctly-extended \c int64_t value.
  constexpr long long getExtValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::getExtValue, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APSInt) )
  trunc(unsigned int width) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::trunc, Xs..., width); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APSInt) )
  extend(unsigned int width) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::extend, Xs..., width); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APSInt) )
  extOrTrunc(unsigned int width) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::extOrTrunc, Xs..., width); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APSInt) )
  operator%(IFMETA_ELSE((const llvm::APSInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APSInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_mod, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APSInt) )
  operator/(IFMETA_ELSE((const llvm::APSInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APSInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_div, Xs..., Y0s...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APSInt) )
  operator>>(unsigned int Amt) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_gr_gr, Xs..., Amt); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator<(IFMETA_ELSE((const llvm::APSInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APSInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_less, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator>(IFMETA_ELSE((const llvm::APSInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APSInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_gr, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator<=(IFMETA_ELSE((const llvm::APSInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APSInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_less_eq, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator>=(IFMETA_ELSE((const llvm::APSInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APSInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_gr_eq, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator==(IFMETA_ELSE((const llvm::APSInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APSInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_eq_eq, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator!=(IFMETA_ELSE((const llvm::APSInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APSInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_not_eq, Xs..., Y0s...); }) , (;) )
  constexpr bool operator==(long long RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_eq_eq1, Xs..., RHS); }) , (;) )
  constexpr bool operator!=(long long RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_not_eq1, Xs..., RHS); }) , (;) )
  constexpr bool operator<=(long long RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_less_eq1, Xs..., RHS); }) , (;) )
  constexpr bool operator>=(long long RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_gr_eq1, Xs..., RHS); }) , (;) )
  constexpr bool operator<(long long RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_less1, Xs..., RHS); }) , (;) )
  constexpr bool operator>(long long RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_gr1, Xs..., RHS); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APSInt) )
  operator<<(unsigned int Bits) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_less_less, Xs..., Bits); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APSInt) )
  operator-() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_minus, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APSInt) )
  operator&(IFMETA_ELSE((const llvm::APSInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APSInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_and, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APSInt) )
  operator|(IFMETA_ELSE((const llvm::APSInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APSInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_or, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APSInt) )
  operator^(IFMETA_ELSE((const llvm::APSInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APSInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_exp, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APSInt) )
  operator*(IFMETA_ELSE((const llvm::APSInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APSInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_star, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APSInt) )
  operator+(IFMETA_ELSE((const llvm::APSInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APSInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_plus, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APSInt) )
  operator-(IFMETA_ELSE((const llvm::APSInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APSInt &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_minus1, Xs..., Y0s...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APSInt) )
  operator~() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::operator_tilde, Xs...); }) , (;) )
  /// getMaxValue - Return the APSInt representing the maximum integer value
  ///  with the given bit width and signedness.
  static constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APSInt) )
  getMaxValue(unsigned int numBits, bool Unsigned) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::getMaxValue, Xs..., numBits, Unsigned); }) , (;) )
  /// getMinValue - Return the APSInt representing the minimum integer value
  ///  with the given bit width and signedness.
  static constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APSInt) )
  getMinValue(unsigned int numBits, bool Unsigned) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::getMinValue, Xs..., numBits, Unsigned); }) , (;) )
  /// Determine if two APSInts have the same value, zero- or
  /// sign-extending as needed.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr bool isSameValue(IFMETA_ELSE((const llvm::APSInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APSInt &)) I1, IFMETA_ELSE((const llvm::APSInt::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::llvm::APSInt &)) I2) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::isSameValue, Xs..., Y0s..., Y1s...); }) , (;) )
  /// Compare underlying values of two numbers.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr int compareValues(IFMETA_ELSE((const llvm::APSInt::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::APSInt &)) I1, IFMETA_ELSE((const llvm::APSInt::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::llvm::APSInt &)) I2) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::compareValues, Xs..., Y0s..., Y1s...); }) , (;) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APSInt) )
  get(long long X) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::get, Xs..., X); }) , (;) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::llvm::APSInt) )
  getUnsigned(unsigned long long X) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::getUnsigned, Xs..., X); }) , (;) )
  /// Profile - Used to insert APSInt objects, or objects that contain APSInt
  ///  objects, into FoldingSets.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__APSInt, reflenums::llvm__APSInt::Profile, Xs..., Y0s...); }) , (;) )
};

enum clang::APValue::ValueKind : unsigned int {
  Uninitialized,
  Int,
  Float,
  ComplexInt,
  ComplexFloat,
  LValue,
  Vector,
  Array,
  Struct,
  Union,
  MemberPointer,
  AddrLabelDiff,
};

/// APValue - This class implements a discriminated union of [uninitialized]
/// [APSInt] [APFloat], [Complex APSInt] [Complex APFloat], [Expr + Offset],
/// [Vector: N * APValue], [Array: N * APValue]
M_template_rtpack(Xs)
struct clang::APValue::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__APValue;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::APValue::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  using ValueKind = enum refldetail::clang::APValue::ValueKind;
  M_template_rtpack(Zs) using LValueBase = struct refldetail::clang::APValue::LValueBase::M_template impl M_targpack(Zs);
  static const unsigned long DataSize = 64u;
  /// Returns whether the object performed allocations.
  ///
  /// If APValues are constructed via placement new, \c needsCleanup()
  /// indicates whether the destructor must be called in order to correctly
  /// free all allocated memory.
  constexpr bool needsCleanup() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::needsCleanup, Xs...); }) , (;) )
  constexpr enum clang::APValue::ValueKind getKind() const IFMETA_ELSE( ({    return (enum clang::APValue::ValueKind)__reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getKind, Xs...); }) , (;) )
  constexpr bool isUninit() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::isUninit, Xs...); }) , (;) )
  constexpr bool isInt() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::isInt, Xs...); }) , (;) )
  constexpr bool isFloat() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::isFloat, Xs...); }) , (;) )
  constexpr bool isComplexInt() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::isComplexInt, Xs...); }) , (;) )
  constexpr bool isComplexFloat() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::isComplexFloat, Xs...); }) , (;) )
  constexpr bool isLValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::isLValue, Xs...); }) , (;) )
  constexpr bool isVector() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::isVector, Xs...); }) , (;) )
  constexpr bool isArray() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::isArray, Xs...); }) , (;) )
  constexpr bool isStruct() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::isStruct, Xs...); }) , (;) )
  constexpr bool isUnion() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::isUnion, Xs...); }) , (;) )
  constexpr bool isMemberPointer() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::isMemberPointer, Xs...); }) , (;) )
  constexpr bool isAddrLabelDiff() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::isAddrLabelDiff, Xs...); }) , (;) )
  constexpr void dump() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::dump, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void dump(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) OS) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::dump1, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  constexpr void printPretty(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) OS, IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y1s...>), (typename meta::clang::ASTContext &)) Ctx, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y2s...>), (typename meta::clang::QualType)) Ty) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::printPretty, Xs..., Y0s..., Y1s..., Y2s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  constexpr const char * getAsString(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (typename meta::clang::ASTContext &)) Ctx, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::QualType)) Ty) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getAsString, Xs..., Y0s..., Y1s...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::llvm::APSInt &) )
  getInt() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getInt, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::llvm::APFloat &) )
  getFloat() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getFloat, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::llvm::APSInt &) )
  getComplexIntReal() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getComplexIntReal, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::llvm::APSInt &) )
  getComplexIntImag() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getComplexIntImag, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::llvm::APFloat &) )
  getComplexFloatReal() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getComplexFloatReal, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::llvm::APFloat &) )
  getComplexFloatImag() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getComplexFloatImag, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::APValue::LValueBase) )
  getLValueBase() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getLValueBase, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::CharUnits &) )
  getLValueOffset() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getLValueOffset, Xs...); }) , (;) )
  constexpr bool isLValueOnePastTheEnd() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::isLValueOnePastTheEnd, Xs...); }) , (;) )
  constexpr bool hasLValuePath() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::hasLValuePath, Xs...); }) , (;) )
  constexpr unsigned int getLValueCallIndex() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getLValueCallIndex, Xs...); }) , (;) )
  constexpr unsigned int getLValueVersion() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getLValueVersion, Xs...); }) , (;) )
  constexpr bool isNullPointer() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::isNullPointer, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::APValue &) )
  getVectorElt(unsigned int I) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getVectorElt, Xs..., I); }) , (;) )
  constexpr unsigned int getVectorLength() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getVectorLength, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::APValue &) )
  getArrayInitializedElt(unsigned int I) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getArrayInitializedElt, Xs..., I); }) , (;) )
  constexpr bool hasArrayFiller() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::hasArrayFiller, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::APValue &) )
  getArrayFiller() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getArrayFiller, Xs...); }) , (;) )
  constexpr unsigned int getArrayInitializedElts() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getArrayInitializedElts, Xs...); }) , (;) )
  constexpr unsigned int getArraySize() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getArraySize, Xs...); }) , (;) )
  constexpr unsigned int getStructNumBases() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getStructNumBases, Xs...); }) , (;) )
  constexpr unsigned int getStructNumFields() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getStructNumFields, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::APValue &) )
  getStructBase(unsigned int i) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getStructBase, Xs..., i); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::APValue &) )
  getStructField(unsigned int i) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getStructField, Xs..., i); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::FieldDecl *) )
  getUnionField() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getUnionField, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::APValue &) )
  getUnionValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getUnionValue, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::ValueDecl *) )
  getMemberPointerDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getMemberPointerDecl, Xs...); }) , (;) )
  constexpr bool isMemberPointerToDerivedMember() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::isMemberPointerToDerivedMember, Xs...); }) , (;) )
  RANGE_REFLECTION(clang::APValue, getMemberPointerPath,
      constexpr auto getMemberPointerPath() const ,
      (const typename meta::clang::CXXRecordDecl *),
      (reflenums::RK_clang__APValue, reflenums::clang__APValue::getMemberPointerPath, Xs...), () )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::AddrLabelExpr *) )
  getAddrLabelDiffLHS() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getAddrLabelDiffLHS, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::AddrLabelExpr *) )
  getAddrLabelDiffRHS() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue, reflenums::clang__APValue::getAddrLabelDiffRHS, Xs...); }) , (;) )
};

M_template_rtpack(Xs)
struct clang::APValue::LValueBase::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__APValue__LValueBase;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::APValue::LValueBase::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr void * getOpaqueValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue__LValueBase, reflenums::clang__APValue__LValueBase::getOpaqueValue, Xs...); }) , (;) )
  constexpr bool isNull() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue__LValueBase, reflenums::clang__APValue__LValueBase::isNull, Xs...); }) , (;) )
  constexpr explicit operator bool() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue__LValueBase, reflenums::clang__APValue__LValueBase::operator_bool, Xs...); }) , (;) )
  constexpr unsigned int getCallIndex() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue__LValueBase, reflenums::clang__APValue__LValueBase::getCallIndex, Xs...); }) , (;) )
  constexpr unsigned int getVersion() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue__LValueBase, reflenums::clang__APValue__LValueBase::getVersion, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator==(IFMETA_ELSE((const clang::APValue::LValueBase::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::APValue::LValueBase &)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__APValue__LValueBase, reflenums::clang__APValue__LValueBase::operator_eq_eq, Xs..., Y0s...); }) , (;) )
};

/// Enum values that allow the client to map NOTEs, WARNINGs, and EXTENSIONs
  /// to either Ignore (nothing), Remark (emit a remark), Warning
  /// (emit a warning) or Error (emit as an error).  It allows clients to
  /// map ERRORs to Error or Fatal (stop emitting diagnostics after this one).
enum class clang::diag::Severity : int {
  ///< Do not present this diagnostic, ignore it.
  Ignored = 1,
  ///< Present this diagnostic as a remark.
  Remark = 2,
  ///< Present this diagnostic as a warning.
  Warning = 3,
  ///< Present this diagnostic as an error.
  Error = 4,
  ///< Present this diagnostic as a fatal error.
  Fatal = 5,
};

/// Specifies which overload candidates to display when overload
/// resolution fails.
enum clang::OverloadsShown : unsigned int {
  /// Show all overloads.
  Ovl_All,
  /// Show just the "best" overload candidates.
  Ovl_Best,
};

/// A bitmask representing the diagnostic levels used by
/// VerifyDiagnosticConsumer.
enum class clang::DiagnosticLevelMask : unsigned int {
  None = 0,
  Note = 1,
  Remark = 2,
  Warning = 4,
  Error = 8,
  All = 15,
};

enum clang::DiagnosticOptions::TextDiagnosticFormat : unsigned int {
  Clang,
  MSVC,
  Vi,
};

/// Options for controlling the compiler diagnostics engine.
M_template_rtpack(Xs)
struct clang::DiagnosticOptions::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DiagnosticOptions;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DiagnosticOptions::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr void Retain() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::Retain, Xs...); }) , (;) )
  constexpr void Release() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::Release, Xs...); }) , (;) )
  using TextDiagnosticFormat = enum refldetail::clang::DiagnosticOptions::TextDiagnosticFormat;
  bool IgnoreWarnings
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::IgnoreWarnings, Xs...);), (;) )
  /// -w
  bool NoRewriteMacros
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::NoRewriteMacros, Xs...);), (;) )
  /// -Wno-rewrite-macros
  bool Pedantic
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::Pedantic, Xs...);), (;) )
  /// -pedantic
  bool PedanticErrors
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::PedanticErrors, Xs...);), (;) )
  /// -pedantic-errors
  bool ShowColumn
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::ShowColumn, Xs...);), (;) )
  /// Show column number on diagnostics.
  bool ShowLocation
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::ShowLocation, Xs...);), (;) )
  /// Show source location information.
  bool AbsolutePath
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::AbsolutePath, Xs...);), (;) )
  /// Use absolute paths.
  bool ShowCarets
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::ShowCarets, Xs...);), (;) )
  /// Show carets in diagnostics.
  bool ShowFixits
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::ShowFixits, Xs...);), (;) )
  /// Show fixit information.
  bool ShowSourceRanges
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::ShowSourceRanges, Xs...);), (;) )
  /// Show source ranges in numeric form.
  bool ShowParseableFixits
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::ShowParseableFixits, Xs...);), (;) )
  /// Show machine parseable fix-its.
  bool ShowPresumedLoc
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::ShowPresumedLoc, Xs...);), (;) )
  /// Show presumed location for diagnostics.
  bool ShowOptionNames
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::ShowOptionNames, Xs...);), (;) )
  /// Show the option name for mappable
                                /// diagnostics.
  bool ShowNoteIncludeStack
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::ShowNoteIncludeStack, Xs...);), (;) )
  /// Show include stacks for notes.
  unsigned int ShowCategories
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::ShowCategories, Xs...);), (;) )
  /// Format for diagnostics:
  bool ShowColors
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::ShowColors, Xs...);), (;) )
  /// Overload candidates to show.
  bool VerifyDiagnostics
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::VerifyDiagnostics, Xs...);), (;) )
  /// Ignore unexpected diagnostics of
                                        /// the specified levels when using
                                        /// -verify.
  bool ElideType
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::ElideType, Xs...);), (;) )
  /// Elide identical types in template diffing
  bool ShowTemplateTree
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::ShowTemplateTree, Xs...);), (;) )
  /// Print a template tree when diffing
  bool CLFallbackMode
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::CLFallbackMode, Xs...);), (;) )
  /// Format for clang-cl fallback mode
  unsigned int ErrorLimit
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::ErrorLimit, Xs...);), (;) )
  /// Limit # errors emitted.
/// Limit depth of macro expansion backtrace.
  unsigned int MacroBacktraceLimit
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::MacroBacktraceLimit, Xs...);), (;) )
  /// Limit depth of instantiation backtrace.
  unsigned int TemplateBacktraceLimit
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::TemplateBacktraceLimit, Xs...);), (;) )
  /// Limit depth of constexpr backtrace.
  unsigned int ConstexprBacktraceLimit
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::ConstexprBacktraceLimit, Xs...);), (;) )
  /// Limit number of times to perform spell checking.
  unsigned int SpellCheckingLimit
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::SpellCheckingLimit, Xs...);), (;) )
  /// Limit number of lines shown in a snippet.
  unsigned int SnippetLineLimit
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::SnippetLineLimit, Xs...);), (;) )
  unsigned int TabStop
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::TabStop, Xs...);), (;) )
  /// The distance between tab stops.
/// Column limit for formatting message diagnostics, or 0 if unused.
  unsigned int MessageLength
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::MessageLength, Xs...);), (;) )
  /// -w
                                /// -Wno-rewrite-macros
                                /// -pedantic
                                /// -pedantic-errors
                                /// Show column number on diagnostics.
                                /// Show source location information.
                                /// Use absolute paths.
                                /// Show carets in diagnostics.
                                /// Show fixit information.
                                /// Show source ranges in numeric form.
                                   /// Show machine parseable fix-its.
                                /// Show presumed location for diagnostics.
                                /// Show the option name for mappable
                                /// diagnostics.
                                    /// Show include stacks for notes.
                                    /// Show categories: 0 -> none, 1 -> Number,
                                    /// 2 -> Full Name.
  constexpr enum clang::DiagnosticOptions::TextDiagnosticFormat getFormat() const IFMETA_ELSE( ({    return (enum clang::DiagnosticOptions::TextDiagnosticFormat)__reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::getFormat, Xs...); }) , (;) )
  /// Show diagnostics with ANSI color sequences.
  constexpr enum clang::OverloadsShown getShowOverloads() const IFMETA_ELSE( ({    return (enum clang::OverloadsShown)__reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::getShowOverloads, Xs...); }) , (;) )
  /// Check that diagnostics match the expected
                                 /// diagnostics, indicated by markers in the
                                 /// input source file.
  constexpr enum clang::DiagnosticLevelMask getVerifyIgnoreUnexpected() const IFMETA_ELSE( ({    return (enum clang::DiagnosticLevelMask)__reflect_prop(reflenums::RK_clang__DiagnosticOptions, reflenums::clang__DiagnosticOptions::getVerifyIgnoreUnexpected, Xs...); }) , (;) )
};

/// An opaque identifier used by SourceManager which refers to a
/// source file (MemoryBuffer) along with its \#include path and \#line data.
///
M_template_rtpack(Xs)
struct clang::FileID::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__FileID;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::FileID::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr bool isValid() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileID, reflenums::clang__FileID::isValid, Xs...); }) , (;) )
  constexpr bool isInvalid() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileID, reflenums::clang__FileID::isInvalid, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator==(IFMETA_ELSE((const clang::FileID::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::FileID &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileID, reflenums::clang__FileID::operator_eq_eq, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator<(IFMETA_ELSE((const clang::FileID::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::FileID &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileID, reflenums::clang__FileID::operator_less, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator<=(IFMETA_ELSE((const clang::FileID::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::FileID &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileID, reflenums::clang__FileID::operator_less_eq, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator!=(IFMETA_ELSE((const clang::FileID::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::FileID &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileID, reflenums::clang__FileID::operator_not_eq, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator>(IFMETA_ELSE((const clang::FileID::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::FileID &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileID, reflenums::clang__FileID::operator_gr, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator>=(IFMETA_ELSE((const clang::FileID::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::FileID &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileID, reflenums::clang__FileID::operator_gr_eq, Xs..., Y0s...); }) , (;) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::FileID) )
  getSentinel() IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileID, reflenums::clang__FileID::getSentinel, Xs...); }) , (;) )
  constexpr unsigned int getHashValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileID, reflenums::clang__FileID::getHashValue, Xs...); }) , (;) )
};

/// Encodes a location in the source. The SourceManager can decode this
/// to get at the full include stack, line and column information.
///
/// Technically, a source location is simply an offset into the manager's view
/// of the input source, which is all input buffers (including macro
/// expansions) concatenated in an effectively arbitrary order. The manager
/// actually maintains two blocks of input buffers. One, starting at offset
/// 0 and growing upwards, contains all buffers from this module. The other,
/// starting at the highest possible offset and growing downwards, contains
/// buffers of loaded modules.
///
/// In addition, one bit of SourceLocation is used for quick access to the
/// information whether the location is in a file or a macro expansion.
///
/// It is important that this type remains small. It is currently 32 bits wide.
M_template_rtpack(Xs)
struct clang::SourceLocation::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__SourceLocation;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::SourceLocation::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr bool isFileID() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SourceLocation, reflenums::clang__SourceLocation::isFileID, Xs...); }) , (;) )
  constexpr bool isMacroID() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SourceLocation, reflenums::clang__SourceLocation::isMacroID, Xs...); }) , (;) )
  /// Return true if this is a valid SourceLocation object.
  ///
  /// Invalid SourceLocations are often used when events have no corresponding
  /// location in the source (e.g. a diagnostic is required for a command line
  /// option).
  constexpr bool isValid() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SourceLocation, reflenums::clang__SourceLocation::isValid, Xs...); }) , (;) )
  constexpr bool isInvalid() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SourceLocation, reflenums::clang__SourceLocation::isInvalid, Xs...); }) , (;) )
  /// Return a source location with the specified offset from this
  /// SourceLocation.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getLocWithOffset(int Offset) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SourceLocation, reflenums::clang__SourceLocation::getLocWithOffset, Xs..., Offset); }) , (;) )
  /// When a SourceLocation itself cannot be used, this returns
  /// an (opaque) 32-bit integer encoding for it.
  ///
  /// This should only be passed to SourceLocation::getFromRawEncoding, it
  /// should not be inspected directly.
  constexpr unsigned int getRawEncoding() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SourceLocation, reflenums::clang__SourceLocation::getRawEncoding, Xs...); }) , (;) )
  /// Turn a raw encoding of a SourceLocation object into
  /// a real SourceLocation.
  ///
  /// \see getRawEncoding.
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getFromRawEncoding(unsigned int Encoding) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SourceLocation, reflenums::clang__SourceLocation::getFromRawEncoding, Xs..., Encoding); }) , (;) )
  /// When a SourceLocation itself cannot be used, this returns
  /// an (opaque) pointer encoding for it.
  ///
  /// This should only be passed to SourceLocation::getFromPtrEncoding, it
  /// should not be inspected directly.
  constexpr void * getPtrEncoding() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SourceLocation, reflenums::clang__SourceLocation::getPtrEncoding, Xs...); }) , (;) )
  /// Turn a pointer encoding of a SourceLocation object back
  /// into a real SourceLocation.
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getFromPtrEncoding(const void * Encoding) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SourceLocation, reflenums::clang__SourceLocation::getFromPtrEncoding, Xs..., Encoding); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr bool isPairOfFileLocations(IFMETA_ELSE((const clang::SourceLocation::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::SourceLocation)) Start, IFMETA_ELSE((const clang::SourceLocation::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::SourceLocation)) End) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SourceLocation, reflenums::clang__SourceLocation::isPairOfFileLocations, Xs..., Y0s..., Y1s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  constexpr void print(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) OS, IFMETA_ELSE((const clang::SourceManager::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::clang::SourceManager &)) SM) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__SourceLocation, reflenums::clang__SourceLocation::print, Xs..., Y0s..., Y1s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr const char * printToString(IFMETA_ELSE((const clang::SourceManager::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::SourceManager &)) SM) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SourceLocation, reflenums::clang__SourceLocation::printToString, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void dump(IFMETA_ELSE((const clang::SourceManager::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::SourceManager &)) SM) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__SourceLocation, reflenums::clang__SourceLocation::dump, Xs..., Y0s...); }) , (;) )
};

/// A trivial tuple used to represent a source range.
M_template_rtpack(Xs)
struct clang::SourceRange::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__SourceRange;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::SourceRange::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getBegin() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SourceRange, reflenums::clang__SourceRange::getBegin, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getEnd() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SourceRange, reflenums::clang__SourceRange::getEnd, Xs...); }) , (;) )
  constexpr bool isValid() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SourceRange, reflenums::clang__SourceRange::isValid, Xs...); }) , (;) )
  constexpr bool isInvalid() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SourceRange, reflenums::clang__SourceRange::isInvalid, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator==(IFMETA_ELSE((const clang::SourceRange::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::SourceRange &)) X) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SourceRange, reflenums::clang__SourceRange::operator_eq_eq, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator!=(IFMETA_ELSE((const clang::SourceRange::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::SourceRange &)) X) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SourceRange, reflenums::clang__SourceRange::operator_not_eq, Xs..., Y0s...); }) , (;) )
};

/// Represents a character-granular source range.
///
/// The underlying SourceRange can either specify the starting/ending character
/// of the range, or it can specify the start of the range and the start of the
/// last token of the range (a "token range").  In the token range case, the
/// size of the last token must be measured to determine the actual end of the
/// range.
M_template_rtpack(Xs)
struct clang::CharSourceRange::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__CharSourceRange;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::CharSourceRange::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::CharSourceRange) )
  getTokenRange(IFMETA_ELSE((const clang::SourceRange::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::SourceRange)) R) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharSourceRange, reflenums::clang__CharSourceRange::getTokenRange, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::CharSourceRange) )
  getCharRange(IFMETA_ELSE((const clang::SourceRange::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::SourceRange)) R) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharSourceRange, reflenums::clang__CharSourceRange::getCharRange, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::CharSourceRange) )
  getTokenRange(IFMETA_ELSE((const clang::SourceLocation::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::SourceLocation)) B, IFMETA_ELSE((const clang::SourceLocation::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::SourceLocation)) E) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharSourceRange, reflenums::clang__CharSourceRange::getTokenRange1, Xs..., Y0s..., Y1s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::CharSourceRange) )
  getCharRange(IFMETA_ELSE((const clang::SourceLocation::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::SourceLocation)) B, IFMETA_ELSE((const clang::SourceLocation::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::SourceLocation)) E) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharSourceRange, reflenums::clang__CharSourceRange::getCharRange1, Xs..., Y0s..., Y1s...); }) , (;) )
  /// Return true if the end of this range specifies the start of
  /// the last token.  Return false if the end of this range specifies the last
  /// character in the range.
  constexpr bool isTokenRange() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharSourceRange, reflenums::clang__CharSourceRange::isTokenRange, Xs...); }) , (;) )
  constexpr bool isCharRange() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharSourceRange, reflenums::clang__CharSourceRange::isCharRange, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getBegin() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharSourceRange, reflenums::clang__CharSourceRange::getBegin, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getEnd() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharSourceRange, reflenums::clang__CharSourceRange::getEnd, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceRange) )
  getAsRange() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharSourceRange, reflenums::clang__CharSourceRange::getAsRange, Xs...); }) , (;) )
  constexpr bool isValid() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharSourceRange, reflenums::clang__CharSourceRange::isValid, Xs...); }) , (;) )
  constexpr bool isInvalid() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharSourceRange, reflenums::clang__CharSourceRange::isInvalid, Xs...); }) , (;) )
};

/// Represents an unpacked "presumed" location which can be presented
/// to the user.
///
/// A 'presumed' location can be modified by \#line and GNU line marker
/// directives and is always the expansion point of a normal location.
///
/// You can get a PresumedLoc from a SourceLocation with SourceManager.
M_template_rtpack(Xs)
struct clang::PresumedLoc::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__PresumedLoc;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::PresumedLoc::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// Return true if this object is invalid or uninitialized.
  ///
  /// This occurs when created with invalid source locations or when walking
  /// off the top of a \#include stack.
  constexpr bool isInvalid() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PresumedLoc, reflenums::clang__PresumedLoc::isInvalid, Xs...); }) , (;) )
  constexpr bool isValid() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PresumedLoc, reflenums::clang__PresumedLoc::isValid, Xs...); }) , (;) )
  /// Return the presumed filename of this location.
  ///
  /// This can be affected by \#line etc.
  constexpr const char * getFilename() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PresumedLoc, reflenums::clang__PresumedLoc::getFilename, Xs...); }) , (;) )
  /// Return the presumed line number of this location.
  ///
  /// This can be affected by \#line etc.
  constexpr unsigned int getLine() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PresumedLoc, reflenums::clang__PresumedLoc::getLine, Xs...); }) , (;) )
  /// Return the presumed column number of this location.
  ///
  /// This cannot be affected by \#line, but is packaged here for convenience.
  constexpr unsigned int getColumn() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PresumedLoc, reflenums::clang__PresumedLoc::getColumn, Xs...); }) , (;) )
  /// Return the presumed include location of this location.
  ///
  /// This can be affected by GNU linemarker directives.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getIncludeLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PresumedLoc, reflenums::clang__PresumedLoc::getIncludeLoc, Xs...); }) , (;) )
};

/// A SourceLocation and its associated SourceManager.
///
/// This is useful for argument passing to functions that expect both objects.
M_template_rtpack(Xs)
struct clang::FullSourceLoc::impl : impl_offset_t<clang::SourceLocation, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__FullSourceLoc;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::FullSourceLoc::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr bool hasManager() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::hasManager, Xs...); }) , (;) )
  /// \pre This FullSourceLoc has an associated SourceManager.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::SourceManager &) )
  getManager() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::getManager, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FileID) )
  getFileID() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::getFileID, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FullSourceLoc) )
  getExpansionLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::getExpansionLoc, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FullSourceLoc) )
  getSpellingLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::getSpellingLoc, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FullSourceLoc) )
  getFileLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::getFileLoc, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::PresumedLoc) )
  getPresumedLoc(bool UseLineDirectives = true) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::getPresumedLoc, Xs..., UseLineDirectives); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isMacroArgExpansion(IFMETA_ELSE((const clang::FullSourceLoc::template impl</*ptrorref=*/1, Y0s...> *), (typename meta::clang::FullSourceLoc *)) StartLoc = {}) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::isMacroArgExpansion, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  constexpr bool isMacroArgExpansion(ptrwrp<Y0> p0 = {}) const {
      return isMacroArgExpansion(p0.get());
  }), () )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FullSourceLoc) )
  getImmediateMacroCallerLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::getImmediateMacroCallerLoc, Xs...); }) , (;) )
  constexpr unsigned int getFileOffset() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::getFileOffset, Xs...); }) , (;) )
  constexpr unsigned int getExpansionLineNumber(bool * Invalid = nullptr) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::getExpansionLineNumber, Xs..., Invalid); }) , (;) )
  constexpr unsigned int getExpansionColumnNumber(bool * Invalid = nullptr) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::getExpansionColumnNumber, Xs..., Invalid); }) , (;) )
  constexpr unsigned int getSpellingLineNumber(bool * Invalid = nullptr) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::getSpellingLineNumber, Xs..., Invalid); }) , (;) )
  constexpr unsigned int getSpellingColumnNumber(bool * Invalid = nullptr) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::getSpellingColumnNumber, Xs..., Invalid); }) , (;) )
  constexpr const char * getCharacterData(bool * Invalid = nullptr) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::getCharacterData, Xs..., Invalid); }) , (;) )
  constexpr unsigned int getLineNumber(bool * Invalid = nullptr) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::getLineNumber, Xs..., Invalid); }) , (;) )
  constexpr unsigned int getColumnNumber(bool * Invalid = nullptr) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::getColumnNumber, Xs..., Invalid); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::FileEntry *) )
  getFileEntry() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::getFileEntry, Xs...); }) , (;) )
  /// Return a StringRef to the source buffer data for the
  /// specified FileID.
  constexpr const char * getBufferData(bool * Invalid = nullptr) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::getBufferData, Xs..., Invalid); }) , (;) )
  constexpr bool isInSystemHeader() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::isInSystemHeader, Xs...); }) , (;) )
  /// Determines the order of 2 source locations in the translation unit.
  ///
  /// \returns true if this source location comes before 'Loc', false otherwise.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isBeforeInTranslationUnitThan(IFMETA_ELSE((const clang::SourceLocation::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::SourceLocation)) Loc) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::isBeforeInTranslationUnitThan, Xs..., Y0s...); }) , (;) )
  /// Determines the order of 2 source locations in the translation unit.
  ///
  /// \returns true if this source location comes before 'Loc', false otherwise.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isBeforeInTranslationUnitThan(IFMETA_ELSE((const clang::FullSourceLoc::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::FullSourceLoc)) Loc) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::isBeforeInTranslationUnitThan1, Xs..., Y0s...); }) , (;) )
  /// Prints information about this FullSourceLoc to stderr.
  ///
  /// This is useful for debugging.
  constexpr void dump() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::dump, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr bool operator==(IFMETA_ELSE((const clang::FullSourceLoc::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::FullSourceLoc &)) LHS, IFMETA_ELSE((const clang::FullSourceLoc::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::clang::FullSourceLoc &)) RHS) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::operator_eq_eq, Xs..., Y0s..., Y1s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr bool operator!=(IFMETA_ELSE((const clang::FullSourceLoc::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::FullSourceLoc &)) LHS, IFMETA_ELSE((const clang::FullSourceLoc::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::clang::FullSourceLoc &)) RHS) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FullSourceLoc, reflenums::clang__FullSourceLoc::operator_not_eq, Xs..., Y0s..., Y1s...); }) , (;) )
};

/// A C++ access specifier (public, private, protected), plus the
/// special value "none" which means different things in different contexts.
enum clang::AccessSpecifier : unsigned int {
  AS_public,
  AS_protected,
  AS_private,
  AS_none,
};

/// The categorization of expression values, currently following the
/// C++11 scheme.
enum clang::ExprValueKind : unsigned int {
  /// An r-value expression (a pr-value in the C++11 taxonomy)
  /// produces a temporary value.
  VK_RValue,
  /// An l-value expression is a reference to an object with
  /// independent storage.
  VK_LValue,
  /// An x-value expression is a reference to an object with
  /// independent storage but which can be "moved", i.e.
  /// efficiently cannibalized for its resources.
  VK_XValue,
};

/// A further classification of the kind of object referenced by an
/// l-value or x-value.
enum clang::ExprObjectKind : unsigned int {
  /// An ordinary object is located at an address in memory.
  OK_Ordinary,
  /// A bitfield object is a bitfield on a C or C++ record.
  OK_BitField,
  /// A vector component is an element or range of elements on a vector.
  OK_VectorComponent,
  /// An Objective-C property is a logical field of an Objective-C
  /// object which is read and written via Objective-C method calls.
  OK_ObjCProperty,
  /// An Objective-C array/dictionary subscripting which reads an
  /// object or writes at the subscripted array/dictionary element via
  /// Objective-C method calls.
  OK_ObjCSubscript,
};

/// Describes the kind of template specialization that a
/// particular template specialization declaration represents.
enum clang::TemplateSpecializationKind : unsigned int {
  /// This template specialization was formed from a template-id but
  /// has not yet been declared, defined, or instantiated.
  TSK_Undeclared = 0,
  /// This template specialization was implicitly instantiated from a
  /// template. (C++ [temp.inst]).
  TSK_ImplicitInstantiation,
  /// This template specialization was declared or defined by an
  /// explicit specialization (C++ [temp.expl.spec]) or partial
  /// specialization (C++ [temp.class.spec]).
  TSK_ExplicitSpecialization,
  /// This template specialization was instantiated from a template
  /// due to an explicit instantiation declaration request
  /// (C++11 [temp.explicit]).
  TSK_ExplicitInstantiationDeclaration,
  /// This template specialization was instantiated from a template
  /// due to an explicit instantiation definition request
  /// (C++ [temp.explicit]).
  TSK_ExplicitInstantiationDefinition,
};

/// Thread storage-class-specifier.
enum clang::ThreadStorageClassSpecifier : unsigned int {
  TSCS_unspecified,
  /// GNU __thread.
  TSCS___thread,
  /// C++11 thread_local. Implies 'static' at block scope, but not at
  /// class scope.
  TSCS_thread_local,
  /// C11 _Thread_local. Must be combined with either 'static' or 'extern'
  /// if used at block scope.
  TSCS__Thread_local,
};

/// Storage classes.
enum clang::StorageClass : unsigned int {
  SC_None,
  SC_Extern,
  SC_Static,
  SC_PrivateExtern,
  SC_Auto,
  SC_Register,
};

/// In-class initialization styles for non-static data members.
enum clang::InClassInitStyle : unsigned int {
  ///< No in-class initializer.
  ICIS_NoInit,
  ///< Copy initialization.
  ICIS_CopyInit,
  ///< Direct list-initialization.
  ICIS_ListInit,
};

/// CallingConv - Specifies the calling convention that a function uses.
enum clang::CallingConv : unsigned int {
  CC_C,
  CC_X86StdCall,
  CC_X86FastCall,
  CC_X86ThisCall,
  CC_X86VectorCall,
  CC_X86Pascal,
  CC_Win64,
  CC_X86_64SysV,
  CC_X86RegCall,
  CC_AAPCS,
  CC_AAPCS_VFP,
  CC_IntelOclBicc,
  CC_SpirFunction,
  CC_OpenCLKernel,
  CC_Swift,
  CC_PreserveMost,
  CC_PreserveAll,
};

/// The storage duration for an object (per C++ [basic.stc]).
enum clang::StorageDuration : unsigned int {
  ///< Full-expression storage duration (for temporaries).
  SD_FullExpression,
  ///< Automatic storage duration (most local variables).
  SD_Automatic,
  ///< Thread storage duration.
  SD_Thread,
  ///< Static storage duration.
  SD_Static,
  ///< Dynamic storage duration.
  SD_Dynamic,
};

/// Describes the nullability of a particular type.
enum class clang::NullabilityKind : uint8_t {
  /// Values of this type can never be null.
  NonNull = 0,
  /// Values of this type can be null.
  Nullable,
  /// Whether values of this type can be null is (explicitly)
  /// unspecified. This captures a (fairly rare) case where we
  /// can't conclude anything about the nullability of the type even
  /// though it has been considered.
  Unspecified,
};

/// Kinds of parameter ABI.
enum class clang::ParameterABI : int {
  /// This parameter uses ordinary ABI rules for its type.
  Ordinary,
  /// This parameter (which must have pointer type) is a Swift
  /// indirect result parameter.
  SwiftIndirectResult,
  /// This parameter (which must have pointer-to-pointer type) uses
  /// the special Swift error-result ABI treatment.  There can be at
  /// most one parameter on a given function that uses this treatment.
  SwiftErrorResult,
  /// This parameter (which must have pointer type) uses the special
  /// Swift context-pointer ABI treatment.  There can be at
  /// most one parameter on a given function that uses this treatment.
  SwiftContext,
};

enum clang::ReflectionTraitKind : unsigned int {
  RTK_prop,
  ///__reflect_prop
  RTK_range_nth,
  ///__reflect_range_nth
  RTK_range_size,
  ///__reflect_range_size
  RTK_cast,
};

/// A base class for data structure classes wishing to make iterators
/// ("handles") pointing into themselves fail-fast.  When building without
/// asserts, this class is empty and does nothing.
///
/// DebugEpochBase does not by itself track handles pointing into itself.  The
/// expectation is that routines touching the handles will poll on
/// isHandleInSync at appropriate points to assert that the handle they're using
/// is still valid.
///
M_template_rtpack(Xs)
struct llvm::DebugEpochBase::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_llvm__DebugEpochBase;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::llvm::DebugEpochBase::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
};

/// Annotates a diagnostic with some code that should be
/// inserted, removed, or replaced to fix the problem.
///
/// This kind of hint should be used when we are certain that the
/// introduction, removal, or modification of a particular (small!)
/// amount of code will correct a compilation error. The compiler
/// should also provide full recovery from such errors, such that
/// suppressing the diagnostic output can still result in successful
/// compilation.
M_template_rtpack(Xs)
struct clang::FixItHint::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__FixItHint;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::FixItHint::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// Code that should be replaced to correct the error. Empty for an
  /// insertion hint.
  M_REFLTYPED_FIELD(RemoveRange, (typename meta::clang::CharSourceRange), __reflect_prop(reflenums::RK_clang__FixItHint, reflenums::clang__FixItHint::RemoveRange, Xs...))
  /// Code in the specific range that should be inserted in the insertion
  /// location.
  M_REFLTYPED_FIELD(InsertFromRange, (typename meta::clang::CharSourceRange), __reflect_prop(reflenums::RK_clang__FixItHint, reflenums::clang__FixItHint::InsertFromRange, Xs...))
  bool BeforePreviousInsertions
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__FixItHint, reflenums::clang__FixItHint::BeforePreviousInsertions, Xs...);), (;) )
  constexpr bool isNull() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FixItHint, reflenums::clang__FixItHint::isNull, Xs...); }) , (;) )
  /// Create a code modification hint that inserts the given
  /// code from \p FromRange at a specific location.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::FixItHint) )
  CreateInsertionFromRange(IFMETA_ELSE((const clang::SourceLocation::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::SourceLocation)) InsertionLoc, IFMETA_ELSE((const clang::CharSourceRange::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::CharSourceRange)) FromRange, bool BeforePreviousInsertions = false) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FixItHint, reflenums::clang__FixItHint::CreateInsertionFromRange, Xs..., Y0s..., Y1s..., BeforePreviousInsertions); }) , (;) )
  /// Create a code modification hint that removes the given
  /// source range.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::FixItHint) )
  CreateRemoval(IFMETA_ELSE((const clang::CharSourceRange::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::CharSourceRange)) RemoveRange) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FixItHint, reflenums::clang__FixItHint::CreateRemoval, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::FixItHint) )
  CreateRemoval(IFMETA_ELSE((const clang::SourceRange::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::SourceRange)) RemoveRange) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FixItHint, reflenums::clang__FixItHint::CreateRemoval1, Xs..., Y0s...); }) , (;) )
};

/// The level of the diagnostic, after it has been through mapping.
enum clang::DiagnosticsEngine::Level : unsigned int {
  Ignored = 0,
  Note = 1,
  Remark = 2,
  Warning = 3,
  Error = 4,
  Fatal = 5,
};

enum clang::DiagnosticsEngine::ArgumentKind : unsigned int {
  /// std::string
  ak_std_string,
  /// const char *
  ak_c_string,
  /// int
  ak_sint,
  /// unsigned
  ak_uint,
  /// enum TokenKind : unsigned
  ak_tokenkind,
  /// IdentifierInfo
  ak_identifierinfo,
  /// QualType
  ak_qualtype,
  /// DeclarationName
  ak_declarationname,
  /// NamedDecl *
  ak_nameddecl,
  /// NestedNameSpecifier *
  ak_nestednamespec,
  /// DeclContext *
  ak_declcontext,
  /// pair<QualType, QualType>
  ak_qualtype_pair,
  /// Attr *
  ak_attr,
};

/// Concrete class used by the front-end to report problems and issues.
///
/// This massages the diagnostics (e.g. handling things like "report warnings
/// as errors" and passes them off to the DiagnosticConsumer for reporting to
/// the user. DiagnosticsEngine is tied to one translation unit and one
/// SourceManager.
M_template_rtpack(Xs)
struct clang::DiagnosticsEngine::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DiagnosticsEngine;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DiagnosticsEngine::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr void Retain() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::Retain, Xs...); }) , (;) )
  constexpr void Release() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::Release, Xs...); }) , (;) )
  using Level = enum refldetail::clang::DiagnosticsEngine::Level;
  using ArgumentKind = enum refldetail::clang::DiagnosticsEngine::ArgumentKind;
  constexpr void dump() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::dump, Xs...); }) , (;) )
  constexpr void dump(const char * DiagName) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::dump1, Xs..., DiagName); }) , (;) )
  /// Retrieve the diagnostic options.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::DiagnosticOptions &) )
  getDiagnosticOptions() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::getDiagnosticOptions, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::DiagnosticConsumer *) )
  getClient() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::getClient, Xs...); }) , (;) )
  /// Determine whether this \c DiagnosticsEngine object own its client.
  constexpr bool ownsClient() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::ownsClient, Xs...); }) , (;) )
  constexpr bool hasSourceManager() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::hasSourceManager, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceManager &) )
  getSourceManager() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::getSourceManager, Xs...); }) , (;) )
  /// Retrieve the maximum number of template instantiation
  /// notes to emit along with a given diagnostic.
  constexpr unsigned int getTemplateBacktraceLimit() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::getTemplateBacktraceLimit, Xs...); }) , (;) )
  /// Retrieve the maximum number of constexpr evaluation
  /// notes to emit along with a given diagnostic.
  constexpr unsigned int getConstexprBacktraceLimit() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::getConstexprBacktraceLimit, Xs...); }) , (;) )
  constexpr bool getIgnoreAllWarnings() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::getIgnoreAllWarnings, Xs...); }) , (;) )
  constexpr bool getEnableAllWarnings() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::getEnableAllWarnings, Xs...); }) , (;) )
  constexpr bool getWarningsAsErrors() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::getWarningsAsErrors, Xs...); }) , (;) )
  constexpr bool getErrorsAsFatal() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::getErrorsAsFatal, Xs...); }) , (;) )
  constexpr bool getSuppressSystemWarnings() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::getSuppressSystemWarnings, Xs...); }) , (;) )
  constexpr bool getSuppressAllDiagnostics() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::getSuppressAllDiagnostics, Xs...); }) , (;) )
  constexpr enum clang::OverloadsShown getShowOverloads() const IFMETA_ELSE( ({    return (enum clang::OverloadsShown)__reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::getShowOverloads, Xs...); }) , (;) )
  /// Determine whether the previous diagnostic was ignored. This can
  /// be used by clients that want to determine whether notes attached to a
  /// diagnostic will be suppressed.
  constexpr bool isLastDiagnosticIgnored() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::isLastDiagnosticIgnored, Xs...); }) , (;) )
  constexpr enum clang::diag::Severity getExtensionHandlingBehavior() const IFMETA_ELSE( ({    return (enum clang::diag::Severity)__reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::getExtensionHandlingBehavior, Xs...); }) , (;) )
  constexpr bool hasErrorOccurred() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::hasErrorOccurred, Xs...); }) , (;) )
  /// Errors that actually prevent compilation, not those that are
  /// upgraded from a warning by -Werror.
  constexpr bool hasUncompilableErrorOccurred() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::hasUncompilableErrorOccurred, Xs...); }) , (;) )
  constexpr bool hasFatalErrorOccurred() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::hasFatalErrorOccurred, Xs...); }) , (;) )
  /// Determine whether any kind of unrecoverable error has occurred.
  constexpr bool hasUnrecoverableErrorOccurred() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::hasUnrecoverableErrorOccurred, Xs...); }) , (;) )
  constexpr unsigned int getNumWarnings() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::getNumWarnings, Xs...); }) , (;) )
  /// Determine whether the diagnostic is known to be ignored.
  ///
  /// This can be used to opportunistically avoid expensive checks when it's
  /// known for certain that the diagnostic has been suppressed at the
  /// specified location \p Loc.
  ///
  /// \param Loc The source location we are interested in finding out the
  /// diagnostic state. Can be null in order to query the latest state.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isIgnored(unsigned int DiagID, IFMETA_ELSE((const clang::SourceLocation::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::SourceLocation)) Loc) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::isIgnored, Xs..., DiagID, Y0s...); }) , (;) )
  /// Based on the way the client configured the DiagnosticsEngine
  /// object, classify the specified diagnostic ID into a Level, consumable by
  /// the DiagnosticConsumer.
  ///
  /// To preserve invariant assumptions, this function should not be used to
  /// influence parse or semantic analysis actions. Instead consider using
  /// \c isIgnored().
  ///
  /// \param Loc The source location we are interested in finding out the
  /// diagnostic state. Can be null in order to query the latest state.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr enum clang::DiagnosticsEngine::Level getDiagnosticLevel(unsigned int DiagID, IFMETA_ELSE((const clang::SourceLocation::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::SourceLocation)) Loc) const IFMETA_ELSE( ({    return (enum clang::DiagnosticsEngine::Level)__reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::getDiagnosticLevel, Xs..., DiagID, Y0s...); }) , (;) )
  /// Determine whethere there is already a diagnostic in flight.
  constexpr bool isDiagnosticInFlight() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::isDiagnosticInFlight, Xs...); }) , (;) )
  /// Return the value associated with this diagnostic flag.
  constexpr const char * getFlagValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticsEngine, reflenums::clang__DiagnosticsEngine::getFlagValue, Xs...); }) , (;) )
};

/// A little helper class used to produce diagnostics.
///
/// This is constructed by the DiagnosticsEngine::Report method, and
/// allows insertion of extra information (arguments and source ranges) into
/// the currently "in flight" diagnostic.  When the temporary for the builder
/// is destroyed, the diagnostic is issued.
///
/// Note that many of these will be created as temporary objects (many call
/// sites), so we want them to be small and we never want their address taken.
/// This ensures that compilers with somewhat reasonable optimizers will promote
/// the common fields to registers, eliminating increments of the NumArgs field,
/// for example.
M_template_rtpack(Xs)
struct clang::DiagnosticBuilder::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DiagnosticBuilder;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DiagnosticBuilder::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// Forces the diagnostic to be emitted.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::DiagnosticBuilder &) )
  setForceEmit() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticBuilder, reflenums::clang__DiagnosticBuilder::setForceEmit, Xs...); }) , (;) )
  /// Conversion of DiagnosticBuilder to bool always returns \c true.
  ///
  /// This allows is to be used in boolean error contexts (where \c true is
  /// used to indicate that an error has occurred), like:
  /// \code
  /// return Diag(...);
  /// \endcode
  constexpr operator bool() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticBuilder, reflenums::clang__DiagnosticBuilder::operator_bool, Xs...); }) , (;) )
  constexpr void AddString(const char * S) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DiagnosticBuilder, reflenums::clang__DiagnosticBuilder::AddString, Xs..., S); }) , (;) )
  constexpr void AddTaggedVal(intptr_t V, enum clang::DiagnosticsEngine::ArgumentKind Kind) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DiagnosticBuilder, reflenums::clang__DiagnosticBuilder::AddTaggedVal, Xs..., V, Kind); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void AddSourceRange(IFMETA_ELSE((const clang::CharSourceRange::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::CharSourceRange &)) R) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DiagnosticBuilder, reflenums::clang__DiagnosticBuilder::AddSourceRange, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void AddFixItHint(IFMETA_ELSE((const clang::FixItHint::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::FixItHint &)) Hint) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DiagnosticBuilder, reflenums::clang__DiagnosticBuilder::AddFixItHint, Xs..., Y0s...); }) , (;) )
  constexpr void addFlagValue(const char * V) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DiagnosticBuilder, reflenums::clang__DiagnosticBuilder::addFlagValue, Xs..., V); }) , (;) )
};

/// Abstract interface, implemented by clients of the front-end, which
/// formats and prints fully processed diagnostics.
M_template_rtpack(Xs)
struct clang::DiagnosticConsumer::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DiagnosticConsumer;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DiagnosticConsumer::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr unsigned int getNumErrors() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticConsumer, reflenums::clang__DiagnosticConsumer::getNumErrors, Xs...); }) , (;) )
  constexpr unsigned int getNumWarnings() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticConsumer, reflenums::clang__DiagnosticConsumer::getNumWarnings, Xs...); }) , (;) )
  /// Indicates whether the diagnostics handled by this
  /// DiagnosticConsumer should be included in the number of diagnostics
  /// reported by DiagnosticsEngine.
  ///
  /// The default implementation returns true.
  constexpr bool IncludeInDiagnosticCounts() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DiagnosticConsumer, reflenums::clang__DiagnosticConsumer::IncludeInDiagnosticCounts, Xs...); }) , (;) )
};

/// Provides a simple uniform namespace for tokens from all C languages.
enum clang::tok::TokenKind : unsigned short {
  unknown,
  eof,
  eod,
  code_completion,
  comment,
  identifier,
  raw_identifier,
  numeric_constant,
  char_constant,
  wide_char_constant,
  utf8_char_constant,
  utf16_char_constant,
  utf32_char_constant,
  string_literal,
  wide_string_literal,
  angle_string_literal,
  utf8_string_literal,
  utf16_string_literal,
  utf32_string_literal,
  l_square,
  r_square,
  l_paren,
  r_paren,
  l_brace,
  r_brace,
  period,
  ellipsis,
  amp,
  ampamp,
  ampequal,
  star,
  starequal,
  plus,
  plusplus,
  plusequal,
  minus,
  arrow,
  minusminus,
  minusequal,
  tilde,
  exclaim,
  exclaimequal,
  slash,
  slashequal,
  percent,
  percentequal,
  less,
  lessless,
  lessequal,
  lesslessequal,
  spaceship,
  greater,
  greatergreater,
  greaterequal,
  greatergreaterequal,
  caret,
  caretequal,
  pipe,
  pipepipe,
  pipeequal,
  question,
  colon,
  semi,
  equal,
  equalequal,
  comma,
  hash,
  hashhash,
  hashat,
  periodstar,
  arrowstar,
  coloncolon,
  dollar,
  at,
  lesslessless,
  greatergreatergreater,
  caretcaret,
  kw_auto,
  kw_break,
  kw_case,
  kw_char,
  kw_const,
  kw_continue,
  kw_default,
  kw_do,
  kw_double,
  kw_else,
  kw_enum,
  kw_extern,
  kw_float,
  kw_for,
  kw_goto,
  kw_if,
  kw_inline,
  kw_int,
  kw_long,
  kw_register,
  kw_restrict,
  kw_return,
  kw_short,
  kw_signed,
  kw_sizeof,
  kw_static,
  kw_struct,
  kw_switch,
  kw_typedef,
  kw_union,
  kw_unsigned,
  kw_void,
  kw_volatile,
  kw_while,
  kw__Alignas,
  kw__Alignof,
  kw__Atomic,
  kw__Bool,
  kw__Complex,
  kw__Generic,
  kw__Imaginary,
  kw__Noreturn,
  kw__Static_assert,
  kw__Thread_local,
  kw___func__,
  kw___objc_yes,
  kw___objc_no,
  kw_asm,
  kw_bool,
  kw_catch,
  kw_class,
  kw_const_cast,
  kw_delete,
  kw_dynamic_cast,
  kw_explicit,
  kw_export,
  kw_false,
  kw_friend,
  kw_mutable,
  kw_namespace,
  kw_new,
  kw_operator,
  kw_private,
  kw_protected,
  kw_public,
  kw_reinterpret_cast,
  kw_static_cast,
  kw_template,
  kw_this,
  kw_throw,
  kw_true,
  kw_try,
  kw_typename,
  kw_typeid,
  kw_using,
  kw_virtual,
  kw_wchar_t,
  kw_alignas,
  kw_alignof,
  kw_char16_t,
  kw_char32_t,
  kw_constexpr,
  kw_decltype,
  kw_noexcept,
  kw_nullptr,
  kw_static_assert,
  kw_thread_local,
  kw_concept,
  kw_requires,
  kw_co_await,
  kw_co_return,
  kw_co_yield,
  kw_module,
  kw_import,
  kw_char8_t,
  kw__Float16,
  kw__Accum,
  kw__Fract,
  kw__Sat,
  kw_reflexpr,
  kw_idexpr,
  ////END
  kw__Decimal32,
  ////END
  kw__Decimal64,
  ////END
  kw__Decimal128,
  ////END
  kw___null,
  ////END
  kw___alignof,
  ////END
  kw___attribute,
  ////END
  kw___builtin_choose_expr,
  ////END
  kw___builtin_offsetof,
  ////END
  kw___builtin_types_compatible_p,
  ////END
  kw___builtin_va_arg,
  ////END
  kw___extension__,
  ////END
  kw___float128,
  ////END
  kw___imag,
  ////END
  kw___int128,
  ////END
  kw___label__,
  ////END
  kw___real,
  ////END
  kw___thread,
  ////END
  kw___FUNCTION__,
  ////END
  kw___PRETTY_FUNCTION__,
  ////END
  kw___auto_type,
  ////END
  kw_typeof,
  ////END
  kw___FUNCDNAME__,
  ////END
  kw___FUNCSIG__,
  ////END
  kw_L__FUNCTION__,
  ////END
  kw_L__FUNCSIG__,
  ////END
  kw___is_interface_class,
  ////END
  kw___is_sealed,
  ////END
  kw___is_destructible,
  ////END
  kw___is_trivially_destructible,
  ////END
  kw___is_nothrow_destructible,
  ////END
  kw___is_nothrow_assignable,
  ////END
  kw___is_constructible,
  ////END
  kw___is_nothrow_constructible,
  ////END
  kw___is_assignable,
  ////END
  kw___has_nothrow_assign,
  ////END
  kw___has_nothrow_move_assign,
  ////END
  kw___has_nothrow_copy,
  ////END
  kw___has_nothrow_constructor,
  ////END
  kw___has_trivial_assign,
  ////END
  kw___has_trivial_move_assign,
  ////END
  kw___has_trivial_copy,
  ////END
  kw___has_trivial_constructor,
  ////END
  kw___has_trivial_move_constructor,
  ////END
  kw___has_trivial_destructor,
  ////END
  kw___has_virtual_destructor,
  ////END
  kw___is_abstract,
  ////END
  kw___is_aggregate,
  ////END
  kw___is_base_of,
  ////END
  kw___is_class,
  ////END
  kw___is_convertible_to,
  ////END
  kw___is_empty,
  ////END
  kw___is_enum,
  ////END
  kw___is_final,
  ////END
  kw___is_literal,
  ////END
  kw___is_pod,
  ////END
  kw___is_polymorphic,
  ////END
  kw___is_trivial,
  ////END
  kw___is_union,
  ////END
  kw___has_unique_object_representations,
  ////END
  kw___is_trivially_constructible,
  ////END
  kw___is_trivially_copyable,
  ////END
  kw___is_trivially_assignable,
  ////END
  kw___reference_binds_to_temporary,
  ////END
  kw___underlying_type,
  ////END
  kw___is_lvalue_expr,
  ////END
  kw___is_rvalue_expr,
  ////END
  kw___is_arithmetic,
  ////END
  kw___is_floating_point,
  ////END
  kw___is_integral,
  ////END
  kw___is_complete_type,
  ////END
  kw___is_void,
  ////END
  kw___is_array,
  ////END
  kw___is_function,
  ////END
  kw___is_reference,
  ////END
  kw___is_lvalue_reference,
  ////END
  kw___is_rvalue_reference,
  ////END
  kw___is_fundamental,
  ////END
  kw___is_object,
  ////END
  kw___is_scalar,
  ////END
  kw___is_compound,
  ////END
  kw___is_pointer,
  ////END
  kw___is_member_object_pointer,
  ////END
  kw___is_member_function_pointer,
  ////END
  kw___is_member_pointer,
  ////END
  kw___is_const,
  ////END
  kw___is_volatile,
  ////END
  kw___is_standard_layout,
  ////END
  kw___is_signed,
  ////END
  kw___is_unsigned,
  ////END
  kw___is_same,
  ////END
  kw___is_convertible,
  ////END
  kw___array_rank,
  ////END
  kw___array_extent,
  ////END
  kw___queue_metaparse,
  ////END
  kw___metaparse_expr,
  ////END
  kw___reflect_prop,
  ////END
  kw___reflect_range_nth,
  ////END
  kw___reflect_range_size,
  ////END
  kw___reflect_cast,
  ////END
  kw___reflect_new,
  ////END
  kw___reflect_delete,
  //// Placeholders for future syntax
  kw___concatenate,
  //// Placeholders for future syntax
  kw___compiler_debug,
  //// Placeholders for future syntax
  kw___compiler_diag,
  //// Placeholders for future syntax
  kw___private_extern__,
  //// Placeholders for future syntax
  kw___module_private__,
  //// Placeholders for future syntax
  kw___declspec,
  //// Placeholders for future syntax
  kw___cdecl,
  //// Placeholders for future syntax
  kw___stdcall,
  //// Placeholders for future syntax
  kw___fastcall,
  //// Placeholders for future syntax
  kw___thiscall,
  //// Placeholders for future syntax
  kw___regcall,
  //// Placeholders for future syntax
  kw___vectorcall,
  //// Placeholders for future syntax
  kw___forceinline,
  //// Placeholders for future syntax
  kw___unaligned,
  //// Placeholders for future syntax
  kw___super,
  //// Placeholders for future syntax
  kw___global,
  //// Placeholders for future syntax
  kw___local,
  //// Placeholders for future syntax
  kw___constant,
  //// Placeholders for future syntax
  kw___private,
  //// Placeholders for future syntax
  kw___generic,
  //// Placeholders for future syntax
  kw___kernel,
  //// Placeholders for future syntax
  kw___read_only,
  //// Placeholders for future syntax
  kw___write_only,
  //// Placeholders for future syntax
  kw___read_write,
  //// Placeholders for future syntax
  kw___builtin_astype,
  //// Placeholders for future syntax
  kw_vec_step,
  //// Placeholders for future syntax
  kw_image1d_t,
  //// Placeholders for future syntax
  kw_image1d_array_t,
  //// Placeholders for future syntax
  kw_image1d_buffer_t,
  //// Placeholders for future syntax
  kw_image2d_t,
  //// Placeholders for future syntax
  kw_image2d_array_t,
  //// Placeholders for future syntax
  kw_image2d_depth_t,
  //// Placeholders for future syntax
  kw_image2d_array_depth_t,
  //// Placeholders for future syntax
  kw_image2d_msaa_t,
  //// Placeholders for future syntax
  kw_image2d_array_msaa_t,
  //// Placeholders for future syntax
  kw_image2d_msaa_depth_t,
  //// Placeholders for future syntax
  kw_image2d_array_msaa_depth_t,
  //// Placeholders for future syntax
  kw_image3d_t,
  //// Placeholders for future syntax
  kw___builtin_omp_required_simd_align,
  //// Placeholders for future syntax
  kw_pipe,
  //// Placeholders for future syntax
  kw___pascal,
  //// Placeholders for future syntax
  kw___vector,
  //// Placeholders for future syntax
  kw___pixel,
  //// Placeholders for future syntax
  kw___bool,
  //// Placeholders for future syntax
  kw_half,
  //// Placeholders for future syntax
  kw___bridge,
  //// Placeholders for future syntax
  kw___bridge_transfer,
  //// Placeholders for future syntax
  kw___bridge_retained,
  //// Placeholders for future syntax
  kw___bridge_retain,
  //// Placeholders for future syntax
  kw___covariant,
  //// Placeholders for future syntax
  kw___contravariant,
  //// Placeholders for future syntax
  kw___kindof,
  //// Placeholders for future syntax
  kw__Nonnull,
  //// Placeholders for future syntax
  kw__Nullable,
  //// Placeholders for future syntax
  kw__Null_unspecified,
  //// Placeholders for future syntax
  kw___ptr64,
  //// Placeholders for future syntax
  kw___ptr32,
  //// Placeholders for future syntax
  kw___sptr,
  //// Placeholders for future syntax
  kw___uptr,
  //// Placeholders for future syntax
  kw___w64,
  //// Placeholders for future syntax
  kw___uuidof,
  //// Placeholders for future syntax
  kw___try,
  //// Placeholders for future syntax
  kw___finally,
  //// Placeholders for future syntax
  kw___leave,
  //// Placeholders for future syntax
  kw___int64,
  //// Placeholders for future syntax
  kw___if_exists,
  //// Placeholders for future syntax
  kw___if_not_exists,
  //// Placeholders for future syntax
  kw___single_inheritance,
  //// Placeholders for future syntax
  kw___multiple_inheritance,
  //// Placeholders for future syntax
  kw___virtual_inheritance,
  //// Placeholders for future syntax
  kw___interface,
  //// Placeholders for future syntax
  kw___builtin_convertvector,
  //// Placeholders for future syntax
  kw___builtin_available,
  //// Placeholders for future syntax
  kw___unknown_anytype,
  annot_cxxscope,
  annot_typename,
  annot_template_id,
  annot_primary_expr,
  annot_decltype,
  ////END
  annot_refltype,
  annot_pragma_unused,
  annot_pragma_vis,
  annot_pragma_pack,
  annot_pragma_parser_crash,
  annot_pragma_captured,
  annot_pragma_dump,
  annot_pragma_msstruct,
  annot_pragma_align,
  annot_pragma_weak,
  annot_pragma_weakalias,
  annot_pragma_redefine_extname,
  annot_pragma_fp_contract,
  annot_pragma_ms_pointers_to_members,
  annot_pragma_ms_vtordisp,
  annot_pragma_ms_pragma,
  annot_pragma_opencl_extension,
  annot_pragma_openmp,
  annot_pragma_openmp_end,
  annot_pragma_loop_hint,
  annot_pragma_fp,
  annot_pragma_attribute,
  annot_module_include,
  annot_module_begin,
  annot_module_end,
  NUM_TOKENS,
};

/// Provides a namespace for preprocessor keywords which start with a
/// '#' at the beginning of the line.
enum clang::tok::PPKeywordKind : unsigned int {
  pp_not_keyword,
  pp_if,
  pp_ifdef,
  pp_ifndef,
  pp_elif,
  pp_else,
  pp_endif,
  pp_defined,
  pp_include,
  pp___include_macros,
  pp_define,
  pp_undef,
  pp_line,
  pp_error,
  pp_pragma,
  pp_import,
  pp_include_next,
  pp_warning,
  pp_ident,
  pp_sccs,
  pp_assert,
  pp_unassert,
  pp___public_macro,
  pp___private_macro,
  NUM_PP_KEYWORDS,
};

/// Provides a namespace for Objective-C keywords which start with
/// an '@'.
enum clang::tok::ObjCKeywordKind : unsigned int {
  objc_not_keyword,
  objc_class,
  objc_compatibility_alias,
  objc_defs,
  objc_encode,
  objc_end,
  objc_implementation,
  objc_interface,
  objc_private,
  objc_protected,
  objc_protocol,
  objc_public,
  objc_selector,
  objc_throw,
  objc_try,
  objc_catch,
  objc_finally,
  objc_synchronized,
  objc_autoreleasepool,
  objc_property,
  objc_package,
  objc_required,
  objc_optional,
  objc_synthesize,
  objc_dynamic,
  objc_import,
  objc_available,
  NUM_OBJC_KEYWORDS,
};

/// One of these records is kept for each identifier that
/// is lexed.  This contains information about whether the token was \#define'd,
/// is a language keyword, or if it is a front-end token of some sort (e.g. a
/// variable or function name).  The preprocessor keeps this information in a
/// set, and all tok::identifier tokens have a pointer to one of these.
M_template_rtpack(Xs)
struct clang::IdentifierInfo::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__IdentifierInfo;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::IdentifierInfo::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// Return true if this is the identifier for the specified StringRef.
  constexpr bool isStr(const char * Str) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::isStr, Xs..., Str); }) , (;) )
  /// Return the beginning of the actual null-terminated string for this
  /// identifier.
  constexpr const char * getNameStart() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::getNameStart, Xs...); }) , (;) )
  /// Efficiently return the length of this identifier info.
  constexpr unsigned int getLength() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::getLength, Xs...); }) , (;) )
  /// Return the actual identifier string.
  constexpr const char * getName() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::getName, Xs...); }) , (;) )
  /// Return true if this identifier is \#defined to some other value.
  /// \note The current definition may be in a module and not currently visible.
  constexpr bool hasMacroDefinition() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::hasMacroDefinition, Xs...); }) , (;) )
  /// Returns true if this identifier was \#defined to some value at any
  /// moment. In this case there should be an entry for the identifier in the
  /// macro history table in Preprocessor.
  constexpr bool hadMacroDefinition() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::hadMacroDefinition, Xs...); }) , (;) )
  /// If this is a source-language token (e.g. 'for'), this API
  /// can be used to cause the lexer to map identifiers to source-language
  /// tokens.
  constexpr enum clang::tok::TokenKind getTokenID() const IFMETA_ELSE( ({    return (enum clang::tok::TokenKind)__reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::getTokenID, Xs...); }) , (;) )
  /// True if revertTokenIDToIdentifier() was called.
  constexpr bool hasRevertedTokenIDToIdentifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::hasRevertedTokenIDToIdentifier, Xs...); }) , (;) )
  /// Return the preprocessor keyword ID for this identifier.
  ///
  /// For example, "define" will return tok::pp_define.
  constexpr enum clang::tok::PPKeywordKind getPPKeywordID() const IFMETA_ELSE( ({    return (enum clang::tok::PPKeywordKind)__reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::getPPKeywordID, Xs...); }) , (;) )
  /// Return the Objective-C keyword ID for the this identifier.
  ///
  /// For example, 'class' will return tok::objc_class if ObjC is enabled.
  constexpr enum clang::tok::ObjCKeywordKind getObjCKeywordID() const IFMETA_ELSE( ({    return (enum clang::tok::ObjCKeywordKind)__reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::getObjCKeywordID, Xs...); }) , (;) )
  /// True if setNotBuiltin() was called.
  constexpr bool hasRevertedBuiltin() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::hasRevertedBuiltin, Xs...); }) , (;) )
  /// Return a value indicating whether this is a builtin function.
  ///
  /// 0 is not-built-in. 1+ are specific builtin functions.
  constexpr unsigned int getBuiltinID() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::getBuiltinID, Xs...); }) , (;) )
  constexpr unsigned int getObjCOrBuiltinID() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::getObjCOrBuiltinID, Xs...); }) , (;) )
  /// get/setExtension - Initialize information about whether or not this
  /// language token is an extension.  This controls extension warnings, and is
  /// only valid if a custom token ID is set.
  constexpr bool isExtensionToken() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::isExtensionToken, Xs...); }) , (;) )
  /// is/setIsFutureCompatKeyword - Initialize information about whether or not
  /// this language token is a keyword in a newer or proposed Standard. This
  /// controls compatibility warnings, and is only true when not parsing the
  /// corresponding Standard. Once a compatibility problem has been diagnosed
  /// with this keyword, the flag will be cleared.
  constexpr bool isFutureCompatKeyword() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::isFutureCompatKeyword, Xs...); }) , (;) )
  /// Return true if this token has been poisoned.
  constexpr bool isPoisoned() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::isPoisoned, Xs...); }) , (;) )
  constexpr bool isCPlusPlusOperatorKeyword() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::isCPlusPlusOperatorKeyword, Xs...); }) , (;) )
  /// Return true if this token is a keyword in the specified language.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isKeyword(IFMETA_ELSE((const clang::LangOptions::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::LangOptions &)) LangOpts) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::isKeyword, Xs..., Y0s...); }) , (;) )
  /// Return true if this token is a C++ keyword in the specified
  /// language.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isCPlusPlusKeyword(IFMETA_ELSE((const clang::LangOptions::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::LangOptions &)) LangOpts) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::isCPlusPlusKeyword, Xs..., Y0s...); }) , (;) )
  /// Return true if the Preprocessor::HandleIdentifier must be called
  /// on a token of this identifier.
  ///
  /// If this returns false, we know that HandleIdentifier will not affect
  /// the token.
  constexpr bool isHandleIdentifierCase() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::isHandleIdentifierCase, Xs...); }) , (;) )
  /// Return true if the identifier in its current state was loaded
  /// from an AST file.
  constexpr bool isFromAST() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::isFromAST, Xs...); }) , (;) )
  /// Determine whether this identifier has changed since it was loaded
  /// from an AST file.
  constexpr bool hasChangedSinceDeserialization() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::hasChangedSinceDeserialization, Xs...); }) , (;) )
  /// Determine whether the frontend token information for this
  /// identifier has changed since it was loaded from an AST file.
  constexpr bool hasFETokenInfoChangedSinceDeserialization() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::hasFETokenInfoChangedSinceDeserialization, Xs...); }) , (;) )
  /// Determine whether the information for this identifier is out of
  /// date with respect to the external source.
  constexpr bool isOutOfDate() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::isOutOfDate, Xs...); }) , (;) )
  /// Determine whether this is the contextual keyword \c import.
  constexpr bool isModulesImport() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::isModulesImport, Xs...); }) , (;) )
  /// Return true if this identifier is an editor placeholder.
  ///
  /// Editor placeholders are produced by the code-completion engine and are
  /// represented as characters between '<#' and '#>' in the source code. An
  /// example of auto-completed call with a placeholder parameter is shown
  /// below:
  /// \code
  ///   function(<#int x#>);
  /// \endcode
  constexpr bool isEditorPlaceholder() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::isEditorPlaceholder, Xs...); }) , (;) )
  /// Provide less than operator for lexicographical sorting.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator<(IFMETA_ELSE((const clang::IdentifierInfo::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::IdentifierInfo &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierInfo, reflenums::clang__IdentifierInfo::operator_less, Xs..., Y0s...); }) , (;) )
};

/// Provides lookups to, and iteration over, IdentiferInfo objects.
M_template_rtpack(Xs)
struct clang::IdentifierInfoLookup::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__IdentifierInfoLookup;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::IdentifierInfoLookup::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
};

/// Implements an efficient mapping from strings to IdentifierInfo nodes.
///
/// This has no other purpose, but this is an extremely performance-critical
/// piece of the code, as each occurrence of every identifier goes through
/// here when lexed.
M_template_rtpack(Xs)
struct clang::IdentifierTable::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__IdentifierTable;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::IdentifierTable::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// Retrieve the external identifier lookup object, if any.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::IdentifierInfoLookup *) )
  getExternalIdentifierLookup() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierTable, reflenums::clang__IdentifierTable::getExternalIdentifierLookup, Xs...); }) , (;) )
  constexpr unsigned int size() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IdentifierTable, reflenums::clang__IdentifierTable::size, Xs...); }) , (;) )
  /// Print some statistics to stderr that indicate how well the
  /// hashing is doing.
  constexpr void PrintStats() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__IdentifierTable, reflenums::clang__IdentifierTable::PrintStats, Xs...); }) , (;) )
};

/// A family of Objective-C methods.
///
/// These families have no inherent meaning in the language, but are
/// nonetheless central enough in the existing implementations to
/// merit direct AST support.  While, in theory, arbitrary methods can
/// be considered to form families, we focus here on the methods
/// involving allocation and retain-count management, as these are the
/// most "core" and the most likely to be useful to diverse clients
/// without extra information.
///
/// Both selectors and actual method declarations may be classified
/// into families.  Method families may impose additional restrictions
/// beyond their selector name; for example, a method called '_init'
/// that returns void is not considered to be in the 'init' family
/// (but would be if it returned 'id').  It is also possible to
/// explicitly change or remove a method's family.  Therefore the
/// method's family should be considered the single source of truth.
enum clang::ObjCMethodFamily : unsigned int {
  /// No particular method family.
  OMF_None,
  /// No particular method family.
  OMF_alloc,
  /// No particular method family.
  OMF_copy,
  /// No particular method family.
  OMF_init,
  /// No particular method family.
  OMF_mutableCopy,
  /// No particular method family.
  OMF_new,
  /// No particular method family.
  OMF_autorelease,
  /// No particular method family.
  OMF_dealloc,
  /// No particular method family.
  OMF_finalize,
  /// No particular method family.
  OMF_release,
  /// No particular method family.
  OMF_retain,
  /// No particular method family.
  OMF_retainCount,
  /// No particular method family.
  OMF_self,
  /// No particular method family.
  OMF_initialize,
  /// No particular method family.
  OMF_performSelector,
};

/// A family of Objective-C methods.
///
/// These are family of methods whose result type is initially 'id', but
/// but are candidate for the result type to be changed to 'instancetype'.
enum clang::ObjCInstanceTypeFamily : unsigned int {
  OIT_None,
  OIT_Array,
  OIT_Dictionary,
  OIT_Singleton,
  OIT_Init,
  OIT_ReturnsSelf,
};

enum clang::ObjCStringFormatFamily : unsigned int {
  SFF_None,
  SFF_NSString,
  SFF_CFString,
};

/// Smart pointer class that efficiently represents Objective-C method
/// names.
///
/// This class will either point to an IdentifierInfo or a
/// MultiKeywordSelector (which is private). This enables us to optimize
/// selectors that take no arguments and selectors that take 1 argument, which
/// accounts for 78% of all selectors in Cocoa.h.
M_template_rtpack(Xs)
struct clang::Selector::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__Selector;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::Selector::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// operator==/!= - Indicate whether the specified selectors are identical.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator==(IFMETA_ELSE((const clang::Selector::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::Selector)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Selector, reflenums::clang__Selector::operator_eq_eq, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator!=(IFMETA_ELSE((const clang::Selector::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::Selector)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Selector, reflenums::clang__Selector::operator_not_eq, Xs..., Y0s...); }) , (;) )
  constexpr void * getAsOpaquePtr() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Selector, reflenums::clang__Selector::getAsOpaquePtr, Xs...); }) , (;) )
  /// Determine whether this is the empty selector.
  constexpr bool isNull() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Selector, reflenums::clang__Selector::isNull, Xs...); }) , (;) )
  constexpr bool isKeywordSelector() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Selector, reflenums::clang__Selector::isKeywordSelector, Xs...); }) , (;) )
  constexpr bool isUnarySelector() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Selector, reflenums::clang__Selector::isUnarySelector, Xs...); }) , (;) )
  constexpr unsigned int getNumArgs() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Selector, reflenums::clang__Selector::getNumArgs, Xs...); }) , (;) )
  /// Retrieve the identifier at a given position in the selector.
  ///
  /// Note that the identifier pointer returned may be NULL. Clients that only
  /// care about the text of the identifier string, and not the specific,
  /// uniqued identifier pointer, should use \c getNameForSlot(), which returns
  /// an empty string when the identifier pointer would be NULL.
  ///
  /// \param argIndex The index for which we want to retrieve the identifier.
  /// This index shall be less than \c getNumArgs() unless this is a keyword
  /// selector, in which case 0 is the only permissible value.
  ///
  /// \returns the uniqued identifier for this slot, or NULL if this slot has
  /// no corresponding identifier.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::IdentifierInfo *) )
  getIdentifierInfoForSlot(unsigned int argIndex) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Selector, reflenums::clang__Selector::getIdentifierInfoForSlot, Xs..., argIndex); }) , (;) )
  /// Retrieve the name at a given position in the selector.
  ///
  /// \param argIndex The index for which we want to retrieve the name.
  /// This index shall be less than \c getNumArgs() unless this is a keyword
  /// selector, in which case 0 is the only permissible value.
  ///
  /// \returns the name for this slot, which may be the empty string if no
  /// name was supplied.
  constexpr const char * getNameForSlot(unsigned int argIndex) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Selector, reflenums::clang__Selector::getNameForSlot, Xs..., argIndex); }) , (;) )
  /// Derive the full selector name (e.g. "foo:bar:") and return
  /// it as an std::string.
  constexpr const char * getAsString() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Selector, reflenums::clang__Selector::getAsString, Xs...); }) , (;) )
  /// Prints the full selector name (e.g. "foo:bar:").
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void print(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) OS) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__Selector, reflenums::clang__Selector::print, Xs..., Y0s...); }) , (;) )
  constexpr void dump() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__Selector, reflenums::clang__Selector::dump, Xs...); }) , (;) )
  /// Derive the conventional family of this method.
  constexpr enum clang::ObjCMethodFamily getMethodFamily() const IFMETA_ELSE( ({    return (enum clang::ObjCMethodFamily)__reflect_prop(reflenums::RK_clang__Selector, reflenums::clang__Selector::getMethodFamily, Xs...); }) , (;) )
  constexpr enum clang::ObjCStringFormatFamily getStringFormatFamily() const IFMETA_ELSE( ({    return (enum clang::ObjCStringFormatFamily)__reflect_prop(reflenums::RK_clang__Selector, reflenums::clang__Selector::getStringFormatFamily, Xs...); }) , (;) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::Selector) )
  getEmptyMarker() IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Selector, reflenums::clang__Selector::getEmptyMarker, Xs...); }) , (;) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::Selector) )
  getTombstoneMarker() IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Selector, reflenums::clang__Selector::getTombstoneMarker, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr enum clang::ObjCInstanceTypeFamily getInstTypeMethodFamily(IFMETA_ELSE((const clang::Selector::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::Selector)) sel) IFMETA_ELSE( ({    return (enum clang::ObjCInstanceTypeFamily)__reflect_prop(reflenums::RK_clang__Selector, reflenums::clang__Selector::getInstTypeMethodFamily, Xs..., Y0s...); }) , (;) )
};

/// This table allows us to fully hide how we implement
/// multi-keyword caching.
M_template_rtpack(Xs)
struct clang::SelectorTable::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__SelectorTable;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::SelectorTable::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// Return the total amount of memory allocated for managing selectors.
  constexpr unsigned long getTotalMemory() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SelectorTable, reflenums::clang__SelectorTable::getTotalMemory, Xs...); }) , (;) )
  /// Return the default setter selector for the given identifier.
  ///
  /// This is "set" + \p Name where the initial character of \p Name
  /// has been capitalized.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::Selector) )
  constructSetterSelector(IFMETA_ELSE((const clang::IdentifierTable::template impl</*ptrorref=*/1, Y0s...>), (typename meta::clang::IdentifierTable &)) Idents, IFMETA_ELSE((const clang::SelectorTable::template impl</*ptrorref=*/1, Y1s...>), (typename meta::clang::SelectorTable &)) SelTable, IFMETA_ELSE((const clang::IdentifierInfo::template impl</*ptrorref=*/1, Y2s...> *), (const typename meta::clang::IdentifierInfo *)) Name) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SelectorTable, reflenums::clang__SelectorTable::constructSetterSelector, Xs..., Y0s..., Y1s..., Y2s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2>
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::Selector) )
  constructSetterSelector(Y0 p0, Y1 p1, ptrwrp<Y2> p2) {
      return constructSetterSelector(p0, p1, p2.get());
  }), () )
  /// Return the property name for the given setter selector.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr const char * getPropertyNameFromSetterSelector(IFMETA_ELSE((const clang::Selector::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::Selector)) Sel) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SelectorTable, reflenums::clang__SelectorTable::getPropertyNameFromSetterSelector, Xs..., Y0s...); }) , (;) )
};

M_template_rtpack(Xs)
struct clang::PartialDiagnostic::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__PartialDiagnostic;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::PartialDiagnostic::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr unsigned int getDiagID() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PartialDiagnostic, reflenums::clang__PartialDiagnostic::getDiagID, Xs...); }) , (;) )
  constexpr void AddTaggedVal(intptr_t V, enum clang::DiagnosticsEngine::ArgumentKind Kind) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__PartialDiagnostic, reflenums::clang__PartialDiagnostic::AddTaggedVal, Xs..., V, Kind); }) , (;) )
  constexpr void AddString(const char * V) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__PartialDiagnostic, reflenums::clang__PartialDiagnostic::AddString, Xs..., V); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void Emit(IFMETA_ELSE((const clang::DiagnosticBuilder::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::DiagnosticBuilder &)) DB) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__PartialDiagnostic, reflenums::clang__PartialDiagnostic::Emit, Xs..., Y0s...); }) , (;) )
  constexpr bool hasStorage() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PartialDiagnostic, reflenums::clang__PartialDiagnostic::hasStorage, Xs...); }) , (;) )
  constexpr unsigned int getNumArgs() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PartialDiagnostic, reflenums::clang__PartialDiagnostic::getNumArgs, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  friend constexpr IFMETA_ELSE( (auto), (const typename meta::clang::PartialDiagnostic &) )
  operator<<(IFMETA_ELSE((const clang::PartialDiagnostic::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::PartialDiagnostic &)) PD, unsigned int I) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PartialDiagnostic, reflenums::clang__PartialDiagnostic::operator_less_less, Xs..., Y0s..., I); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  friend constexpr IFMETA_ELSE( (auto), (const typename meta::clang::PartialDiagnostic &) )
  operator<<(IFMETA_ELSE((const clang::PartialDiagnostic::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::PartialDiagnostic &)) PD, int I) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PartialDiagnostic, reflenums::clang__PartialDiagnostic::operator_less_less1, Xs..., Y0s..., I); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr IFMETA_ELSE( (auto), (const typename meta::clang::PartialDiagnostic &) )
  operator<<(IFMETA_ELSE((const clang::PartialDiagnostic::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::PartialDiagnostic &)) PD, IFMETA_ELSE((const clang::IdentifierInfo::template impl</*ptrorref=*/1, Y1s...> *), (const typename meta::clang::IdentifierInfo *)) II) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PartialDiagnostic, reflenums::clang__PartialDiagnostic::operator_less_less2, Xs..., Y0s..., Y1s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1>
  friend constexpr IFMETA_ELSE( (auto), (const typename meta::clang::PartialDiagnostic &) )
  operator<<(Y0 p0, ptrwrp<Y1> p1) {
      return operator<<(p0, p1.get());
  }), () )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr IFMETA_ELSE( (auto), (const typename meta::clang::PartialDiagnostic &) )
  operator<<(IFMETA_ELSE((const clang::PartialDiagnostic::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::PartialDiagnostic &)) PD, IFMETA_ELSE((const clang::SourceRange::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::SourceRange)) R) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PartialDiagnostic, reflenums::clang__PartialDiagnostic::operator_less_less3, Xs..., Y0s..., Y1s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr IFMETA_ELSE( (auto), (const typename meta::clang::PartialDiagnostic &) )
  operator<<(IFMETA_ELSE((const clang::PartialDiagnostic::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::PartialDiagnostic &)) PD, IFMETA_ELSE((const clang::CharSourceRange::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::clang::CharSourceRange &)) R) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PartialDiagnostic, reflenums::clang__PartialDiagnostic::operator_less_less4, Xs..., Y0s..., Y1s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr IFMETA_ELSE( (auto), (const typename meta::clang::PartialDiagnostic &) )
  operator<<(IFMETA_ELSE((const clang::PartialDiagnostic::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::PartialDiagnostic &)) PD, IFMETA_ELSE((const clang::FixItHint::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::clang::FixItHint &)) Hint) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PartialDiagnostic, reflenums::clang__PartialDiagnostic::operator_less_less5, Xs..., Y0s..., Y1s...); }) , (;) )
};

/// NameKind - The kind of name this object contains.
enum clang::DeclarationName::NameKind : unsigned int {
  Identifier,
  ObjCZeroArgSelector,
  ObjCOneArgSelector,
  ObjCMultiArgSelector,
  CXXConstructorName,
  CXXDestructorName,
  CXXConversionFunctionName,
  CXXDeductionGuideName,
  CXXOperatorName,
  CXXLiteralOperatorName,
  CXXIdExprName,
  CXXUsingDirective,
};

/// DeclarationName - The name of a declaration. In the common case,
/// this just stores an IdentifierInfo pointer to a normal
/// name. However, it also provides encodings for Objective-C
/// selectors (optimizing zero- and one-argument selectors, which make
/// up 78% percent of all selectors in Cocoa.h) and special C++ names
/// for constructors, destructors, and conversion functions.
M_template_rtpack(Xs)
struct clang::DeclarationName::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DeclarationName;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DeclarationName::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  using NameKind = enum refldetail::clang::DeclarationName::NameKind;
  static const unsigned int NumNameKinds = 12u;
  /// getUsingDirectiveName - Return name for all using-directives.
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::DeclarationName) )
  getUsingDirectiveName() IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::getUsingDirectiveName, Xs...); }) , (;) )
  constexpr explicit operator bool() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::operator_bool, Xs...); }) , (;) )
  /// Evaluates true when this declaration name is empty.
  constexpr bool isEmpty() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::isEmpty, Xs...); }) , (;) )
  /// Predicate functions for querying what type of name this is.
  constexpr bool isIdentifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::isIdentifier, Xs...); }) , (;) )
  constexpr bool isObjCZeroArgSelector() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::isObjCZeroArgSelector, Xs...); }) , (;) )
  constexpr bool isObjCOneArgSelector() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::isObjCOneArgSelector, Xs...); }) , (;) )
  /// getNameKind - Determine what kind of name this is.
  constexpr enum clang::DeclarationName::NameKind getNameKind() const IFMETA_ELSE( ({    return (enum clang::DeclarationName::NameKind)__reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::getNameKind, Xs...); }) , (;) )
  /// Determines whether the name itself is dependent, e.g., because it
  /// involves a C++ type that is itself dependent.
  ///
  /// Note that this does not capture all of the notions of "dependent name",
  /// because an identifier can be a dependent name if it is used as the
  /// callee in a call expression with dependent arguments.
  constexpr bool isDependentName() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::isDependentName, Xs...); }) , (;) )
  /// getNameAsString - Retrieve the human-readable string for this name.
  constexpr const char * getAsString() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::getAsString, Xs...); }) , (;) )
  /// getAsIdentifierInfo - Retrieve the IdentifierInfo * stored in
  /// this declaration name, or NULL if this declaration name isn't a
  /// simple identifier.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::IdentifierInfo *) )
  getAsIdentifierInfo() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::getAsIdentifierInfo, Xs...); }) , (;) )
  /// getAsOpaqueInteger - Get the representation of this declaration
  /// name as an opaque integer.
  constexpr unsigned long getAsOpaqueInteger() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::getAsOpaqueInteger, Xs...); }) , (;) )
  /// getAsOpaquePtr - Get the representation of this declaration name as
  /// an opaque pointer.
  constexpr void * getAsOpaquePtr() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::getAsOpaquePtr, Xs...); }) , (;) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::DeclarationName) )
  getFromOpaquePtr(void * P) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::getFromOpaquePtr, Xs..., P); }) , (;) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::DeclarationName) )
  getFromOpaqueInteger(unsigned long P) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::getFromOpaqueInteger, Xs..., P); }) , (;) )
  /// getCXXNameType - If this name is one of the C++ names (of a
  /// constructor, destructor, or conversion function), return the
  /// type associated with that name.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getCXXNameType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::getCXXNameType, Xs...); }) , (;) )
  /// If this name is the name of a C++ deduction guide, return the
  /// template associated with that name.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TemplateDecl *) )
  getCXXDeductionGuideTemplate() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::getCXXDeductionGuideTemplate, Xs...); }) , (;) )
  /// getCXXOverloadedOperator - If this name is the name of an
  /// overloadable operator in C++ (e.g., @c operator+), retrieve the
  /// kind of overloaded operator.
  constexpr enum clang::OverloadedOperatorKind getCXXOverloadedOperator() const IFMETA_ELSE( ({    return (enum clang::OverloadedOperatorKind)__reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::getCXXOverloadedOperator, Xs...); }) , (;) )
  /// getCXXLiteralIdentifier - If this name is the name of a literal
  /// operator, retrieve the identifier associated with it.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::IdentifierInfo *) )
  getCXXLiteralIdentifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::getCXXLiteralIdentifier, Xs...); }) , (;) )
  /// getCXXIdExprArguments - If this is an idexpr name, retrieve the list
  /// of arguments.
  RANGE_REFLECTION(clang::DeclarationName, getCXXIdExprArguments,
      constexpr auto getCXXIdExprArguments() const ,
      (typename meta::clang::Expr *),
      (reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::getCXXIdExprArguments, Xs...), () )
  /// getObjCSelector - Get the Objective-C selector stored in this
  /// declaration name.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Selector) )
  getObjCSelector() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::getObjCSelector, Xs...); }) , (;) )
  /// operator== - Determine whether the specified names are identical..
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr bool operator==(IFMETA_ELSE((const clang::DeclarationName::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::DeclarationName)) LHS, IFMETA_ELSE((const clang::DeclarationName::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::DeclarationName)) RHS) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::operator_eq_eq, Xs..., Y0s..., Y1s...); }) , (;) )
  /// operator!= - Determine whether the specified names are different.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr bool operator!=(IFMETA_ELSE((const clang::DeclarationName::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::DeclarationName)) LHS, IFMETA_ELSE((const clang::DeclarationName::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::DeclarationName)) RHS) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::operator_not_eq, Xs..., Y0s..., Y1s...); }) , (;) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::DeclarationName) )
  getEmptyMarker() IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::getEmptyMarker, Xs...); }) , (;) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::DeclarationName) )
  getTombstoneMarker() IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::getTombstoneMarker, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr int compare(IFMETA_ELSE((const clang::DeclarationName::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::DeclarationName)) LHS, IFMETA_ELSE((const clang::DeclarationName::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::DeclarationName)) RHS) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::compare, Xs..., Y0s..., Y1s...); }) , (;) )
  constexpr void dump() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DeclarationName, reflenums::clang__DeclarationName::dump, Xs...); }) , (;) )
};

/// DeclarationNameLoc - Additional source/type location info
/// for a declaration name. Needs a DeclarationName in order
/// to be interpreted correctly.
M_template_rtpack(Xs)
struct clang::DeclarationNameLoc::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DeclarationNameLoc;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DeclarationNameLoc::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
};

/// DeclarationNameInfo - A collector data type for bundling together
/// a DeclarationName and the correspnding source/type location info.
M_template_rtpack(Xs)
struct clang::DeclarationNameInfo::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DeclarationNameInfo;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DeclarationNameInfo::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// getName - Returns the embedded declaration name.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::DeclarationName) )
  getName() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationNameInfo, reflenums::clang__DeclarationNameInfo::getName, Xs...); }) , (;) )
  /// getLoc - Returns the main location of the declaration name.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationNameInfo, reflenums::clang__DeclarationNameInfo::getLoc, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::DeclarationNameLoc &) )
  getInfo() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationNameInfo, reflenums::clang__DeclarationNameInfo::getInfo, Xs...); }) , (;) )
  /// getNamedTypeInfo - Returns the source type info associated to
  /// the name. Assumes it is a constructor, destructor or conversion.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TypeSourceInfo *) )
  getNamedTypeInfo() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationNameInfo, reflenums::clang__DeclarationNameInfo::getNamedTypeInfo, Xs...); }) , (;) )
  /// getCXXOperatorNameRange - Gets the range of the operator name
  /// (without the operator keyword). Assumes it is a (non-literal) operator.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceRange) )
  getCXXOperatorNameRange() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationNameInfo, reflenums::clang__DeclarationNameInfo::getCXXOperatorNameRange, Xs...); }) , (;) )
  /// getCXXLiteralOperatorNameLoc - Returns the location of the literal
  /// operator name (not the operator keyword).
  /// Assumes it is a literal operator.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getCXXLiteralOperatorNameLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationNameInfo, reflenums::clang__DeclarationNameInfo::getCXXLiteralOperatorNameLoc, Xs...); }) , (;) )
  /// The source range of the idexpr operator.
  /// Reuses the structure of operator names.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceRange) )
  getCXXIdExprNameRange() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationNameInfo, reflenums::clang__DeclarationNameInfo::getCXXIdExprNameRange, Xs...); }) , (;) )
  /// Determine whether this name involves a template parameter.
  constexpr bool isInstantiationDependent() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationNameInfo, reflenums::clang__DeclarationNameInfo::isInstantiationDependent, Xs...); }) , (;) )
  /// Determine whether this name contains an unexpanded
  /// parameter pack.
  constexpr bool containsUnexpandedParameterPack() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationNameInfo, reflenums::clang__DeclarationNameInfo::containsUnexpandedParameterPack, Xs...); }) , (;) )
  /// getAsString - Retrieve the human-readable string for this name.
  constexpr const char * getAsString() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationNameInfo, reflenums::clang__DeclarationNameInfo::getAsString, Xs...); }) , (;) )
  /// printName - Print the human-readable name to a stream.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void printName(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) OS) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DeclarationNameInfo, reflenums::clang__DeclarationNameInfo::printName, Xs..., Y0s...); }) , (;) )
  /// getBeginLoc - Retrieve the location of the first token.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getBeginLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationNameInfo, reflenums::clang__DeclarationNameInfo::getBeginLoc, Xs...); }) , (;) )
  /// getSourceRange - The range of the declaration name.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceRange) )
  getSourceRange() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationNameInfo, reflenums::clang__DeclarationNameInfo::getSourceRange, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getLocStart() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationNameInfo, reflenums::clang__DeclarationNameInfo::getLocStart, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getLocEnd() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationNameInfo, reflenums::clang__DeclarationNameInfo::getLocEnd, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getEndLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclarationNameInfo, reflenums::clang__DeclarationNameInfo::getEndLoc, Xs...); }) , (;) )
};

/// This class implements an extremely fast bulk output stream that can *only*
/// output to a stream.  It does not support seeking, reopening, rewinding, line
/// buffered disciplines etc. It is a simple buffer that outputs
/// a chunk at a time.
M_template_rtpack(Xs)
struct llvm::raw_ostream::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_llvm__raw_ostream;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::llvm::raw_ostream::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// tell - Return the current offset with the file.
  constexpr unsigned long long tell() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__raw_ostream, reflenums::llvm__raw_ostream::tell, Xs...); }) , (;) )
  constexpr unsigned long GetBufferSize() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__raw_ostream, reflenums::llvm__raw_ostream::GetBufferSize, Xs...); }) , (;) )
  constexpr unsigned long GetNumBytesInBuffer() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__raw_ostream, reflenums::llvm__raw_ostream::GetNumBytesInBuffer, Xs...); }) , (;) )
  /// This function determines if this stream is connected to a "tty" or
  /// "console" window. That is, the output would be displayed to the user
  /// rather than being put on a pipe or stored in a file.
  constexpr bool is_displayed() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__raw_ostream, reflenums::llvm__raw_ostream::is_displayed, Xs...); }) , (;) )
  /// This function determines if this stream is displayed and supports colors.
  constexpr bool has_colors() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__raw_ostream, reflenums::llvm__raw_ostream::has_colors, Xs...); }) , (;) )
};

/// Represents a version number in the form major[.minor[.subminor[.build]]].
M_template_rtpack(Xs)
struct llvm::VersionTuple::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_llvm__VersionTuple;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::llvm::VersionTuple::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// Determine whether this version information is empty
  /// (e.g., all version components are zero).
  constexpr bool empty() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__VersionTuple, reflenums::llvm__VersionTuple::empty, Xs...); }) , (;) )
  /// Retrieve the major version number.
  constexpr unsigned int getMajor() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__VersionTuple, reflenums::llvm__VersionTuple::getMajor, Xs...); }) , (;) )
  /// Determine if two version numbers are equivalent. If not
  /// provided, minor and subminor version numbers are considered to be zero.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr bool operator==(IFMETA_ELSE((const llvm::VersionTuple::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::VersionTuple &)) X, IFMETA_ELSE((const llvm::VersionTuple::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::llvm::VersionTuple &)) Y) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__VersionTuple, reflenums::llvm__VersionTuple::operator_eq_eq, Xs..., Y0s..., Y1s...); }) , (;) )
  /// Determine if two version numbers are not equivalent.
  ///
  /// If not provided, minor and subminor version numbers are considered to be
  /// zero.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr bool operator!=(IFMETA_ELSE((const llvm::VersionTuple::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::VersionTuple &)) X, IFMETA_ELSE((const llvm::VersionTuple::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::llvm::VersionTuple &)) Y) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__VersionTuple, reflenums::llvm__VersionTuple::operator_not_eq, Xs..., Y0s..., Y1s...); }) , (;) )
  /// Determine whether one version number precedes another.
  ///
  /// If not provided, minor and subminor version numbers are considered to be
  /// zero.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr bool operator<(IFMETA_ELSE((const llvm::VersionTuple::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::VersionTuple &)) X, IFMETA_ELSE((const llvm::VersionTuple::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::llvm::VersionTuple &)) Y) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__VersionTuple, reflenums::llvm__VersionTuple::operator_less, Xs..., Y0s..., Y1s...); }) , (;) )
  /// Determine whether one version number follows another.
  ///
  /// If not provided, minor and subminor version numbers are considered to be
  /// zero.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr bool operator>(IFMETA_ELSE((const llvm::VersionTuple::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::VersionTuple &)) X, IFMETA_ELSE((const llvm::VersionTuple::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::llvm::VersionTuple &)) Y) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__VersionTuple, reflenums::llvm__VersionTuple::operator_gr, Xs..., Y0s..., Y1s...); }) , (;) )
  /// Determine whether one version number precedes or is
  /// equivalent to another.
  ///
  /// If not provided, minor and subminor version numbers are considered to be
  /// zero.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr bool operator<=(IFMETA_ELSE((const llvm::VersionTuple::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::VersionTuple &)) X, IFMETA_ELSE((const llvm::VersionTuple::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::llvm::VersionTuple &)) Y) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__VersionTuple, reflenums::llvm__VersionTuple::operator_less_eq, Xs..., Y0s..., Y1s...); }) , (;) )
  /// Determine whether one version number follows or is
  /// equivalent to another.
  ///
  /// If not provided, minor and subminor version numbers are considered to be
  /// zero.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr bool operator>=(IFMETA_ELSE((const llvm::VersionTuple::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::VersionTuple &)) X, IFMETA_ELSE((const llvm::VersionTuple::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::llvm::VersionTuple &)) Y) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__VersionTuple, reflenums::llvm__VersionTuple::operator_gr_eq, Xs..., Y0s..., Y1s...); }) , (;) )
  /// Retrieve a string representation of the version number.
  constexpr const char * getAsString() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__VersionTuple, reflenums::llvm__VersionTuple::getAsString, Xs...); }) , (;) )
};

/// Captures the result of checking the availability of a
/// declaration.
enum clang::AvailabilityResult : unsigned int {
  AR_Available = 0,
  AR_NotYetIntroduced,
  AR_Deprecated,
  AR_Unavailable,
};

/// Lists the kind of concrete classes of Decl.
enum clang::Decl::Kind : unsigned int {
  AccessSpec,
  Block,
  Captured,
  ClassScopeFunctionSpecialization,
  Constexpr,
  Empty,
  Export,
  ExternCContext,
  FileScopeAsm,
  Friend,
  FriendTemplate,
  Import,
  LinkageSpec,
  Label,
  Namespace,
  NamespaceAlias,
  ObjCCompatibleAlias,
  ObjCCategory,
  ObjCCategoryImpl,
  ObjCImplementation,
  firstObjCImpl = 18,
  lastObjCImpl = 19,
  ObjCInterface,
  ObjCProtocol,
  firstObjCContainer = 17,
  lastObjCContainer = 21,
  ObjCMethod,
  ObjCProperty,
  BuiltinTemplate,
  ClassTemplate,
  FunctionTemplate,
  TypeAliasTemplate,
  VarTemplate,
  firstRedeclarableTemplate = 25,
  lastRedeclarableTemplate = 28,
  TemplateTemplateParm,
  firstTemplate = 24,
  lastTemplate = 29,
  Enum,
  Record,
  CXXRecord,
  ClassTemplateSpecialization,
  ClassTemplatePartialSpecialization,
  firstClassTemplateSpecialization = 33,
  lastClassTemplateSpecialization = 34,
  firstCXXRecord = 32,
  lastCXXRecord = 34,
  firstRecord = 31,
  lastRecord = 34,
  firstTag = 30,
  lastTag = 34,
  TemplateTypeParm,
  ObjCTypeParam,
  TypeAlias,
  Typedef,
  firstTypedefName = 36,
  lastTypedefName = 38,
  UnresolvedUsingTypename,
  firstType = 30,
  lastType = 39,
  Using,
  UsingDirective,
  UsingPack,
  UsingShadow,
  ConstructorUsingShadow,
  firstUsingShadow = 43,
  lastUsingShadow = 44,
  Binding,
  Field,
  ObjCAtDefsField,
  ObjCIvar,
  firstField = 46,
  lastField = 48,
  Function,
  CXXDeductionGuide,
  CXXMethod,
  CXXConstructor,
  CXXConversion,
  CXXDestructor,
  firstCXXMethod = 51,
  lastCXXMethod = 54,
  firstFunction = 49,
  lastFunction = 54,
  MSProperty,
  NonTypeTemplateParm,
  Var,
  Decomposition,
  ImplicitParam,
  OMPCapturedExpr,
  ParmVar,
  VarTemplateSpecialization,
  VarTemplatePartialSpecialization,
  firstVarTemplateSpecialization = 62,
  lastVarTemplateSpecialization = 63,
  firstVar = 57,
  lastVar = 63,
  firstDeclarator = 46,
  lastDeclarator = 63,
  EnumConstant,
  IndirectField,
  OMPDeclareReduction,
  UnresolvedUsingValue,
  firstValue = 45,
  lastValue = 67,
  firstNamed = 13,
  lastNamed = 67,
  OMPThreadPrivate,
  ObjCPropertyImpl,
  PragmaComment,
  PragmaDetectMismatch,
  StaticAssert,
  TranslationUnit,
  firstDecl = 0,
  lastDecl = 73,
};

/// ObjCDeclQualifier - 'Qualifiers' written next to the return and
/// parameter types in method declarations.  Other than remembering
/// them and mangling them into the method's signature string, these
/// are ignored by the compiler; they are consumed by certain
/// remote-messaging frameworks.
///
/// in, inout, and out are mutually exclusive and apply only to
/// method parameters.  bycopy and byref are mutually exclusive and
/// apply only to method parameters (?).  oneway applies only to
/// results.  All of these expect their corresponding parameter to
/// have a particular type.  None of this is currently enforced by
/// clang.
///
/// This should be kept in sync with ObjCDeclSpec::ObjCDeclQualifier.
enum clang::Decl::ObjCDeclQualifier : unsigned int {
  OBJC_TQ_None = 0,
  OBJC_TQ_In = 1,
  OBJC_TQ_Inout = 2,
  OBJC_TQ_Out = 4,
  OBJC_TQ_Bycopy = 8,
  OBJC_TQ_Byref = 16,
  OBJC_TQ_Oneway = 32,
  /// The nullability qualifier is set when the nullability of the
  /// result or parameter was expressed via a context-sensitive
  /// keyword.
  OBJC_TQ_CSNullability = 64,
};

/// The kind of ownership a declaration has, for visibility purposes.
/// This enumeration is designed such that higher values represent higher
/// levels of name hiding.
enum class clang::Decl::ModuleOwnershipKind : unsigned int {
  /// This declaration is not owned by a module.
  Unowned,
  /// This declaration has an owning module, but is globally visible
  /// (typically because its owning module is visible and we know that
  /// modules cannot later become hidden in this compilation).
  /// After serialization and deserialization, this will be converted
  /// to VisibleWhenImported.
  Visible,
  /// This declaration has an owning module, and is visible when that
  /// module is imported.
  VisibleWhenImported,
  /// This declaration has an owning module, but is only visible to
  /// lookups that occur within that module.
  ModulePrivate,
};

enum clang::Decl::FriendObjectKind : unsigned int {
  ///< Not a friend object.
  FOK_None,
  ///< A friend of a previously-declared entity.
  FOK_Declared,
  ///< A friend of a previously-undeclared entity.
  FOK_Undeclared,
};

/// Decl - This represents one declaration (or definition), e.g. a variable,
/// typedef, function, struct, etc.
///
/// Note: There are objects tacked on before the *beginning* of Decl
/// (and its subclasses) in its Decl::operator new(). Proper alignment
/// of all subclasses (not requiring more than the alignment of Decl) is
/// asserted in DeclBase.cpp.
M_template_rtpack(Xs)
struct clang::Decl::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__Decl;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::Decl::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  using Kind = enum refldetail::clang::Decl::Kind;
  using ObjCDeclQualifier = enum refldetail::clang::Decl::ObjCDeclQualifier;
  using ModuleOwnershipKind = enum refldetail::clang::Decl::ModuleOwnershipKind;
  /// Source range that this declaration covers.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceRange) )
  getSourceRange() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getSourceRange, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getLocStart() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getLocStart, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getBeginLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getBeginLoc, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getLocEnd() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getLocEnd, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getEndLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getEndLoc, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getLocation() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getLocation, Xs...); }) , (;) )
  constexpr enum clang::Decl::Kind getKind() const IFMETA_ELSE( ({    return (enum clang::Decl::Kind)__reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getKind, Xs...); }) , (;) )
  constexpr const char * getDeclKindName() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getDeclKindName, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::Decl *) )
  getNextDeclInContext() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getNextDeclInContext, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::DeclContext *) )
  getDeclContext() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getDeclContext, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::Decl *) )
  getNonClosureContext() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getNonClosureContext, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::TranslationUnitDecl *) )
  getTranslationUnitDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getTranslationUnitDecl, Xs...); }) , (;) )
  constexpr bool isInAnonymousNamespace() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isInAnonymousNamespace, Xs...); }) , (;) )
  constexpr bool isInStdNamespace() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isInStdNamespace, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::ASTContext &) )
  getASTContext() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getASTContext, Xs...); }) , (;) )
  constexpr enum clang::AccessSpecifier getAccess() const IFMETA_ELSE( ({    return (enum clang::AccessSpecifier)__reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getAccess, Xs...); }) , (;) )
  /// Retrieve the access specifier for this declaration, even though
  /// it may not yet have been properly set.
  constexpr enum clang::AccessSpecifier getAccessUnsafe() const IFMETA_ELSE( ({    return (enum clang::AccessSpecifier)__reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getAccessUnsafe, Xs...); }) , (;) )
  constexpr bool hasAttrs() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::hasAttrs, Xs...); }) , (;) )
  RANGE_REFLECTION(clang::Decl, attrs,
      constexpr auto attrs() const ,
      (typename meta::clang::Attr *const),
      (reflenums::RK_clang__Decl, reflenums::clang__Decl::attrs, Xs...), () )
  /// getMaxAlignment - return the maximum alignment specified by attributes
  /// on this decl, 0 if there are none.
  constexpr unsigned int getMaxAlignment() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getMaxAlignment, Xs...); }) , (;) )
  constexpr bool isInvalidDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isInvalidDecl, Xs...); }) , (;) )
  /// isImplicit - Indicates whether the declaration was implicitly
  /// generated by the implementation. If false, this declaration
  /// was written explicitly in the source code.
  constexpr bool isImplicit() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isImplicit, Xs...); }) , (;) )
  /// Whether *any* (re-)declaration of the entity was used, meaning that
  /// a definition is required.
  ///
  /// \param CheckUsedAttr When true, also consider the "used" attribute
  /// (in addition to the "used" bit set by \c setUsed()) when determining
  /// whether the function is used.
  constexpr bool isUsed(bool CheckUsedAttr = true) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isUsed, Xs..., CheckUsedAttr); }) , (;) )
  /// Whether any declaration of this entity was referenced.
  constexpr bool isReferenced() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isReferenced, Xs...); }) , (;) )
  /// Whether this declaration was referenced. This should not be relied
  /// upon for anything other than debugging.
  constexpr bool isThisDeclarationReferenced() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isThisDeclarationReferenced, Xs...); }) , (;) )
  ////END
  constexpr bool instantiationsWillNeedParsing() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::instantiationsWillNeedParsing, Xs...); }) , (;) )
  /// Whether this declaration is a top-level declaration (function,
  /// global variable, etc.) that is lexically inside an objc container
  /// definition.
  constexpr bool isTopLevelDeclInObjCContainer() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isTopLevelDeclInObjCContainer, Xs...); }) , (;) )
  /// Looks on this and related declarations for an applicable
  /// external source symbol attribute.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::ExternalSourceSymbolAttr *) )
  getExternalSourceSymbolAttr() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getExternalSourceSymbolAttr, Xs...); }) , (;) )
  /// Whether this declaration was marked as being private to the
  /// module in which it was defined.
  constexpr bool isModulePrivate() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isModulePrivate, Xs...); }) , (;) )
  /// Whether this declaration is exported (by virtue of being lexically
  /// within an ExportDecl or by being a NamespaceDecl).
  constexpr bool isExported() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isExported, Xs...); }) , (;) )
  /// Return true if this declaration has an attribute which acts as
  /// definition of the entity, such as 'alias' or 'ifunc'.
  constexpr bool hasDefiningAttr() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::hasDefiningAttr, Xs...); }) , (;) )
  /// Return this declaration's defining attribute if it has one.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::Attr *) )
  getDefiningAttr() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getDefiningAttr, Xs...); }) , (;) )
  /// Retrieve the version of the target platform in which this
  /// declaration was introduced.
  ///
  /// \returns An empty version tuple if this declaration has no 'introduced'
  /// availability attributes, or the version tuple that's specified in the
  /// attribute otherwise.
  constexpr IFMETA_ELSE( (auto), (typename meta::llvm::VersionTuple) )
  getVersionIntroduced() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getVersionIntroduced, Xs...); }) , (;) )
  /// Determine whether this is a weak-imported symbol.
  ///
  /// Weak-imported symbols are typically marked with the
  /// 'weak_import' attribute, but may also be marked with an
  /// 'availability' attribute where we're targing a platform prior to
  /// the introduction of this feature.
  constexpr bool isWeakImported() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isWeakImported, Xs...); }) , (;) )
  /// Determine whether this declaration came from an AST file (such as
  /// a precompiled header or module) rather than having been parsed.
  constexpr bool isFromASTFile() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isFromASTFile, Xs...); }) , (;) )
  /// Retrieve the global declaration ID associated with this
  /// declaration, which specifies where this Decl was loaded from.
  constexpr unsigned int getGlobalID() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getGlobalID, Xs...); }) , (;) )
  /// Retrieve the global ID of the module that owns this particular
  /// declaration.
  constexpr unsigned int getOwningModuleID() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getOwningModuleID, Xs...); }) , (;) )
  /// Get the imported owning module, if this decl is from an imported
  /// (non-local) module.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Module *) )
  getImportedOwningModule() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getImportedOwningModule, Xs...); }) , (;) )
  /// Get the local owning module, if known. Returns nullptr if owner is
  /// not yet known or declaration is not from a module.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Module *) )
  getLocalOwningModule() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getLocalOwningModule, Xs...); }) , (;) )
  /// Is this declaration owned by some module?
  constexpr bool hasOwningModule() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::hasOwningModule, Xs...); }) , (;) )
  /// Get the module that owns this declaration (for visibility purposes).
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Module *) )
  getOwningModule() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getOwningModule, Xs...); }) , (;) )
  /// Get the module that owns this declaration for linkage purposes.
  /// There only ever is such a module under the C++ Modules TS.
  ///
  /// \param IgnoreLinkage Ignore the linkage of the entity; assume that
  /// all declarations in a global module fragment are unowned.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Module *) )
  getOwningModuleForLinkage(bool IgnoreLinkage = false) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getOwningModuleForLinkage, Xs..., IgnoreLinkage); }) , (;) )
  /// Determine whether this declaration might be hidden from name
  /// lookup. Note that the declaration might be visible even if this returns
  /// \c false, if the owning module is visible within the query context.
  constexpr bool isHidden() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isHidden, Xs...); }) , (;) )
  /// Get the kind of module ownership for this declaration.
  constexpr enum clang::Decl::ModuleOwnershipKind getModuleOwnershipKind() const IFMETA_ELSE( ({    return (enum clang::Decl::ModuleOwnershipKind)__reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getModuleOwnershipKind, Xs...); }) , (;) )
  constexpr unsigned int getIdentifierNamespace() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getIdentifierNamespace, Xs...); }) , (;) )
  constexpr bool isInIdentifierNamespace(unsigned int NS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isInIdentifierNamespace, Xs..., NS); }) , (;) )
  static constexpr unsigned int getIdentifierNamespaceForKind(enum clang::Decl::Kind DK) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getIdentifierNamespaceForKind, Xs..., DK); }) , (;) )
  constexpr bool hasTagIdentifierNamespace() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::hasTagIdentifierNamespace, Xs...); }) , (;) )
  static constexpr bool isTagIdentifierNamespace(unsigned int NS) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isTagIdentifierNamespace, Xs..., NS); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::DeclContext *) )
  getLexicalDeclContext() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getLexicalDeclContext, Xs...); }) , (;) )
  /// Determine whether this declaration is declared out of line (outside its
  /// semantic context).
  constexpr bool isOutOfLine() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isOutOfLine, Xs...); }) , (;) )
  /// Determine whether this declaration is a templated entity (whether it is
  constexpr bool isTemplated() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isTemplated, Xs...); }) , (;) )
  /// isDefinedOutsideFunctionOrMethod - This predicate returns true if this
  /// scoped decl is defined outside the current function or method.  This is
  /// roughly global variables and functions, but also handles enums (which
  /// could be defined inside or outside a function etc).
  constexpr bool isDefinedOutsideFunctionOrMethod() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isDefinedOutsideFunctionOrMethod, Xs...); }) , (;) )
  /// Returns true if this declaration lexically is inside a function.
  /// It recognizes non-defining declarations as well as members of local
  /// classes:
  /// \code
  ///     void foo() { void bar(); }
  ///     void foo2() { class ABC { void bar(); }; }
  /// \endcode
  constexpr bool isLexicallyWithinFunctionOrMethod() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isLexicallyWithinFunctionOrMethod, Xs...); }) , (;) )
  /// If this decl is defined inside a function/method/block it returns
  /// the corresponding DeclContext, otherwise it returns null.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::DeclContext *) )
  getParentFunctionOrMethod() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getParentFunctionOrMethod, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::Decl *) )
  getCanonicalDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getCanonicalDecl, Xs...); }) , (;) )
  /// Whether this particular Decl is a canonical one.
  constexpr bool isCanonicalDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isCanonicalDecl, Xs...); }) , (;) )
  /// Returns an iterator range for all the redeclarations of the same
  /// decl. It will iterate at least once (when this decl is the only one).
  RANGE_REFLECTION(clang::Decl, redecls,
      constexpr auto redecls() const ,
      (typename meta::clang::Decl *const),
      (reflenums::RK_clang__Decl, reflenums::clang__Decl::redecls, Xs...), () )
  /// Retrieve the most recent declaration that declares the same entity
  /// as this declaration, or NULL if there is no previous declaration.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::Decl *) )
  getPreviousDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getPreviousDecl, Xs...); }) , (;) )
  /// True if this is the first declaration in its redeclaration chain.
  constexpr bool isFirstDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isFirstDecl, Xs...); }) , (;) )
  /// Retrieve the most recent declaration that declares the same entity
  /// as this declaration (which may be this declaration).
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::Decl *) )
  getMostRecentDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getMostRecentDecl, Xs...); }) , (;) )
  /// getBody - If this Decl represents a declaration for a body of code,
  ///  such as a function or method definition, this method returns the
  ///  top-level Stmt* of that body.  Otherwise this method returns null.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Stmt *) )
  getBody() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getBody, Xs...); }) , (;) )
  /// Returns true if this \c Decl represents a declaration for a body of
  /// code, such as a function or method definition.
  /// Note that \c hasBody can also return true if any redeclaration of this
  /// \c Decl represents a declaration for a body of code.
  constexpr bool hasBody() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::hasBody, Xs...); }) , (;) )
  /// getBodyRBrace - Gets the right brace of the body, if a body exists.
  /// This works whether the body is a CompoundStmt or a CXXTryStmt.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getBodyRBrace() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getBodyRBrace, Xs...); }) , (;) )
  static constexpr void add(enum clang::Decl::Kind k) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::add, Xs..., k); }) , (;) )
  static constexpr void EnableStatistics() IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::EnableStatistics, Xs...); }) , (;) )
  static constexpr void PrintStats() IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::PrintStats, Xs...); }) , (;) )
  /// isTemplateParameter - Determines whether this declaration is a
  /// template parameter.
  constexpr bool isTemplateParameter() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isTemplateParameter, Xs...); }) , (;) )
  /// isTemplateParameter - Determines whether this declaration is a
  /// template parameter pack.
  constexpr bool isTemplateParameterPack() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isTemplateParameterPack, Xs...); }) , (;) )
  /// Whether this declaration is a parameter pack.
  constexpr bool isParameterPack() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isParameterPack, Xs...); }) , (;) )
  /// returns true if this declaration is a template
  constexpr bool isTemplateDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isTemplateDecl, Xs...); }) , (;) )
  /// Whether this declaration is a function or function template.
  constexpr bool isFunctionOrFunctionTemplate() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::isFunctionOrFunctionTemplate, Xs...); }) , (;) )
  /// If this is a declaration that describes some template, this
  /// method returns that template declaration.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TemplateDecl *) )
  getDescribedTemplate() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getDescribedTemplate, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::FunctionDecl *) )
  getAsFunction() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getAsFunction, Xs...); }) , (;) )
  using FriendObjectKind = enum refldetail::clang::Decl::FriendObjectKind;
  /// Determines whether this declaration is the object of a
  /// friend declaration and, if so, what kind.
  ///
  /// There is currently no direct way to find the associated FriendDecl.
  constexpr enum clang::Decl::FriendObjectKind getFriendObjectKind() const IFMETA_ELSE( ({    return (enum clang::Decl::FriendObjectKind)__reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getFriendObjectKind, Xs...); }) , (;) )
  static constexpr bool classofKind(enum clang::Decl::Kind K) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::classofKind, Xs..., K); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void print(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) Out, unsigned int Indentation = 0, bool PrintInstantiation = false) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::print, Xs..., Y0s..., Indentation, PrintInstantiation); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  constexpr void print(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) Out, IFMETA_ELSE((const clang::PrintingPolicy::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::clang::PrintingPolicy &)) Policy, unsigned int Indentation = 0, bool PrintInstantiation = false) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::print1, Xs..., Y0s..., Y1s..., Indentation, PrintInstantiation); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr void printGroup(IFMETA_ELSE((const clang::Decl::template impl</*ptrorref=*/1, Y0s...> * *), (typename meta::clang::Decl **)) Begin, unsigned int NumDecls, IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y1s...>), (typename meta::llvm::raw_ostream &)) Out, IFMETA_ELSE((const clang::PrintingPolicy::template impl</*ptrorref=*/1, Y2s...>), (const typename meta::clang::PrintingPolicy &)) Policy, unsigned int Indentation = 0) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::printGroup, Xs..., Y0s..., NumDecls, Y1s..., Y2s..., Indentation); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2>
  static constexpr void printGroup(ptrwrp<Y0> p0, unsigned int p1, Y1 p2, Y2 p3, unsigned int p4 = 0) {
      return printGroup(p0.get(), p1, p2, p3, p4);
  }), () )
  constexpr void dump() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::dump, Xs...); }) , (;) )
  constexpr void dumpColor() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::dumpColor, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void dump(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) Out, bool Deserialize = false) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::dump1, Xs..., Y0s..., Deserialize); }) , (;) )
  /// Looks through the Decl's underlying type to extract a FunctionType
  /// when possible. Will return null if the type underlying the Decl does not
  /// have a FunctionType.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::FunctionType *) )
  getFunctionType(bool BlocksToo = true) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Decl, reflenums::clang__Decl::getFunctionType, Xs..., BlocksToo); }) , (;) )
};

/// The results of name lookup within a DeclContext. This is either a
/// single result (with no stable storage) or a collection of results (with
/// stable storage provided by the lookup table).
M_template_rtpack(Xs)
struct clang::DeclContextLookupResult::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DeclContextLookupResult;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DeclContextLookupResult::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr bool empty() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContextLookupResult, reflenums::clang__DeclContextLookupResult::empty, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::NamedDecl *const *) )
  data() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContextLookupResult, reflenums::clang__DeclContextLookupResult::data, Xs...); }) , (;) )
  constexpr unsigned long size() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContextLookupResult, reflenums::clang__DeclContextLookupResult::size, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::NamedDecl *const &) )
  front() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContextLookupResult, reflenums::clang__DeclContextLookupResult::front, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::NamedDecl *const &) )
  back() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContextLookupResult, reflenums::clang__DeclContextLookupResult::back, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::NamedDecl *const &) )
  operator[](unsigned long N) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContextLookupResult, reflenums::clang__DeclContextLookupResult::operator_sub, Xs..., N); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::DeclContextLookupResult) )
  slice(unsigned long N) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContextLookupResult, reflenums::clang__DeclContextLookupResult::slice, Xs..., N); }) , (;) )
  RANGECLASS_SIZE_AND_GET(clang__DeclContextLookupResult, typename meta::clang::NamedDecl *const);
};

/// DeclContext - This is used only as base class of specific decl types that
/// can act as declaration contexts. These decls are (only the top classes
/// that directly derive from DeclContext are mentioned, not their subclasses):
///
///   TranslationUnitDecl
///   NamespaceDecl
///   FunctionDecl
///   TagDecl
///   ObjCMethodDecl
///   ObjCContainerDecl
///   LinkageSpecDecl
///   ExportDecl
///   BlockDecl
///   OMPDeclareReductionDecl
M_template_rtpack(Xs)
struct clang::DeclContext::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DeclContext;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DeclContext::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr enum clang::Decl::Kind getDeclKind() const IFMETA_ELSE( ({    return (enum clang::Decl::Kind)__reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::getDeclKind, Xs...); }) , (;) )
  constexpr const char * getDeclKindName() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::getDeclKindName, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::DeclContext *) )
  getParent() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::getParent, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::DeclContext *) )
  getLexicalParent() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::getLexicalParent, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::DeclContext *) )
  getLookupParent() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::getLookupParent, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::ASTContext &) )
  getParentASTContext() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::getParentASTContext, Xs...); }) , (;) )
  constexpr bool isClosure() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::isClosure, Xs...); }) , (;) )
  constexpr bool isObjCContainer() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::isObjCContainer, Xs...); }) , (;) )
  constexpr bool isFunctionOrMethod() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::isFunctionOrMethod, Xs...); }) , (;) )
  /// Test whether the context supports looking up names.
  constexpr bool isLookupContext() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::isLookupContext, Xs...); }) , (;) )
  constexpr bool isFileContext() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::isFileContext, Xs...); }) , (;) )
  constexpr bool isTranslationUnit() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::isTranslationUnit, Xs...); }) , (;) )
  constexpr bool isRecord() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::isRecord, Xs...); }) , (;) )
  constexpr bool isNamespace() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::isNamespace, Xs...); }) , (;) )
  constexpr bool isStdNamespace() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::isStdNamespace, Xs...); }) , (;) )
  constexpr bool isInlineNamespace() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::isInlineNamespace, Xs...); }) , (;) )
  /// Determines whether this context is dependent on a
  /// template parameter.
  constexpr bool isDependentContext() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::isDependentContext, Xs...); }) , (;) )
  /// isTransparentContext - Determines whether this context is a
  /// "transparent" context, meaning that the members declared in this
  /// context are semantically declared in the nearest enclosing
  /// non-transparent (opaque) context but are lexically declared in
  /// this context. For example, consider the enumerators of an
  /// enumeration type:
  /// @code
  /// enum E {
  ///   Val1
  /// };
  /// @endcode
  /// Here, E is a transparent context, so its enumerator (Val1) will
  /// appear (semantically) that it is in the same context of E.
  /// Examples of transparent contexts include: enumerations (except for
  /// C++0x scoped enums), and C++ linkage specifications.
  constexpr bool isTransparentContext() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::isTransparentContext, Xs...); }) , (;) )
  /// Determines whether this context or some of its ancestors is a
  /// linkage specification context that specifies C linkage.
  constexpr bool isExternCContext() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::isExternCContext, Xs...); }) , (;) )
  /// Retrieve the nearest enclosing C linkage specification context.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::LinkageSpecDecl *) )
  getExternCContext() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::getExternCContext, Xs...); }) , (;) )
  /// Determines whether this context or some of its ancestors is a
  /// linkage specification context that specifies C++ linkage.
  constexpr bool isExternCXXContext() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::isExternCXXContext, Xs...); }) , (;) )
  /// Determine whether this declaration context is equivalent
  /// to the declaration context DC.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool Equals(IFMETA_ELSE((const clang::DeclContext::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::DeclContext *)) DC) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::Equals, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  constexpr bool Equals(ptrwrp<Y0> p0) const {
      return Equals(p0.get());
  }), () )
  /// Determine whether this declaration context encloses the
  /// declaration context DC.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool Encloses(IFMETA_ELSE((const clang::DeclContext::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::DeclContext *)) DC) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::Encloses, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  constexpr bool Encloses(ptrwrp<Y0> p0) const {
      return Encloses(p0.get());
  }), () )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::Decl *) )
  getNonClosureAncestor() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::getNonClosureAncestor, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::DeclContext *) )
  getPrimaryContext() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::getPrimaryContext, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::DeclContext *) )
  getRedeclContext() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::getRedeclContext, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::DeclContext *) )
  getEnclosingNamespaceContext() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::getEnclosingNamespaceContext, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::RecordDecl *) )
  getOuterLexicalRecordContext() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::getOuterLexicalRecordContext, Xs...); }) , (;) )
  /// Test if this context is part of the enclosing namespace set of
  /// the context NS, as defined in C++0x [namespace.def]p9. If either context
  /// isn't a namespace, this is equivalent to Equals().
  ///
  /// The enclosing namespace set of a namespace is the namespace and, if it is
  /// inline, its enclosing namespace, recursively.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool InEnclosingNamespaceSetOf(IFMETA_ELSE((const clang::DeclContext::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::DeclContext *)) NS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::InEnclosingNamespaceSetOf, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  constexpr bool InEnclosingNamespaceSetOf(ptrwrp<Y0> p0) const {
      return InEnclosingNamespaceSetOf(p0.get());
  }), () )
  /// decls_begin/decls_end - Iterate over the declarations stored in
  /// this context.
  RANGE_REFLECTION(clang::DeclContext, decls,
      constexpr auto decls() const ,
      (typename meta::clang::Decl *const),
      (reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::decls, Xs...), () )
  constexpr bool decls_empty() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::decls_empty, Xs...); }) , (;) )
  /// noload_decls_begin/end - Iterate over the declarations stored in this
  /// context that are currently loaded; don't attempt to retrieve anything
  /// from an external source.
  RANGE_REFLECTION(clang::DeclContext, noload_decls,
      constexpr auto noload_decls() const ,
      (typename meta::clang::Decl *const),
      (reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::noload_decls, Xs...), () )
  /// Checks whether a declaration is in this context.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool containsDecl(IFMETA_ELSE((const clang::Decl::template impl</*ptrorref=*/1, Y0s...> *), (typename meta::clang::Decl *)) D) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::containsDecl, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  constexpr bool containsDecl(ptrwrp<Y0> p0) const {
      return containsDecl(p0.get());
  }), () )
  /// Checks whether a declaration is in this context.
  /// This also loads the Decls from the external source before the check.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool containsDeclAndLoad(IFMETA_ELSE((const clang::Decl::template impl</*ptrorref=*/1, Y0s...> *), (typename meta::clang::Decl *)) D) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::containsDeclAndLoad, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  constexpr bool containsDeclAndLoad(ptrwrp<Y0> p0) const {
      return containsDeclAndLoad(p0.get());
  }), () )
  /// lookup - Find the declarations (if any) with the given Name in
  /// this context. Returns a range of iterators that contains all of
  /// the declarations with this name, with object, function, member,
  /// and enumerator names preceding any tag name. Note that this
  /// routine will not look into parent contexts.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::DeclContextLookupResult) )
  lookup(IFMETA_ELSE((const clang::DeclarationName::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::DeclarationName)) Name) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::lookup, Xs..., Y0s...); }) , (;) )
  RANGE_REFLECTION(clang::DeclContext, lookups,
      constexpr auto lookups() const ,
      (typename meta::clang::DeclContextLookupResult),
      (reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::lookups, Xs...), () )
  RANGE_REFLECTION(clang::DeclContext, ddiags,
      constexpr auto ddiags() const ,
      (typename meta::clang::DependentDiagnostic *),
      (reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::ddiags, Xs...), () )
  /// Retrieve the internal representation of the lookup structure.
  /// This may omit some names if we are lazily building the structure.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::StoredDeclsMap *) )
  getLookupPtr() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::getLookupPtr, Xs...); }) , (;) )
  /// Whether this DeclContext has external storage containing
  /// additional declarations that are lexically in this context.
  constexpr bool hasExternalLexicalStorage() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::hasExternalLexicalStorage, Xs...); }) , (;) )
  /// Whether this DeclContext has external storage containing
  /// additional declarations that are visible in this context.
  constexpr bool hasExternalVisibleStorage() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::hasExternalVisibleStorage, Xs...); }) , (;) )
  /// Determine whether the given declaration is stored in the list of
  /// declarations lexically within this context.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isDeclInLexicalTraversal(IFMETA_ELSE((const clang::Decl::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Decl *)) D) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::isDeclInLexicalTraversal, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  constexpr bool isDeclInLexicalTraversal(ptrwrp<Y0> p0) const {
      return isDeclInLexicalTraversal(p0.get());
  }), () )
  constexpr bool shouldUseQualifiedLookup() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::shouldUseQualifiedLookup, Xs...); }) , (;) )
  ////END
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Decl::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Decl *)) D) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::DeclContext::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::DeclContext *)) D) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::classof1, Xs..., Y0s...); }) , (;) )
  constexpr void dumpDeclContext() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::dumpDeclContext, Xs...); }) , (;) )
  constexpr void dumpLookups() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::dumpLookups, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void dumpLookups(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) OS, bool DumpDecls = false, bool Deserialize = false) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DeclContext, reflenums::clang__DeclContext::dumpLookups1, Xs..., Y0s..., DumpDecls, Deserialize); }) , (;) )
};

/// CharUnits - This is an opaque type for sizes expressed in character units.
  /// Instances of this type represent a quantity as a multiple of the size
  /// of the standard C type, char, on the target architecture. As an opaque
  /// type, CharUnits protects you from accidentally combining operations on
  /// quantities in bit units and character units.
  ///
  /// In both C and C++, an object of type 'char', 'signed char', or 'unsigned
  /// char' occupies exactly one byte, so 'character unit' and 'byte' refer to
  /// the same quantity of storage. However, we use the term 'character unit'
  /// rather than 'byte' to avoid an implication that a character unit is
  /// exactly 8 bits.
  ///
  /// For portability, never assume that a target character is 8 bits wide. Use
  /// CharUnit values wherever you calculate sizes, offsets, or alignments
  /// in character units.
M_template_rtpack(Xs)
struct clang::CharUnits::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__CharUnits;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::CharUnits::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// Zero - Construct a CharUnits quantity of zero.
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::CharUnits) )
  Zero() IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::Zero, Xs...); }) , (;) )
  /// One - Construct a CharUnits quantity of one.
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::CharUnits) )
  One() IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::One, Xs...); }) , (;) )
  /// fromQuantity - Construct a CharUnits quantity from a raw integer type.
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::CharUnits) )
  fromQuantity(long long Quantity) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::fromQuantity, Xs..., Quantity); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator==(IFMETA_ELSE((const clang::CharUnits::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::CharUnits &)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::operator_eq_eq, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator!=(IFMETA_ELSE((const clang::CharUnits::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::CharUnits &)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::operator_not_eq, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator<(IFMETA_ELSE((const clang::CharUnits::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::CharUnits &)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::operator_less, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator<=(IFMETA_ELSE((const clang::CharUnits::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::CharUnits &)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::operator_less_eq, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator>(IFMETA_ELSE((const clang::CharUnits::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::CharUnits &)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::operator_gr, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator>=(IFMETA_ELSE((const clang::CharUnits::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::CharUnits &)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::operator_gr_eq, Xs..., Y0s...); }) , (;) )
  /// isZero - Test whether the quantity equals zero.
  constexpr bool isZero() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::isZero, Xs...); }) , (;) )
  /// isOne - Test whether the quantity equals one.
  constexpr bool isOne() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::isOne, Xs...); }) , (;) )
  /// isPositive - Test whether the quantity is greater than zero.
  constexpr bool isPositive() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::isPositive, Xs...); }) , (;) )
  /// isNegative - Test whether the quantity is less than zero.
  constexpr bool isNegative() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::isNegative, Xs...); }) , (;) )
  /// isPowerOfTwo - Test whether the quantity is a power of two.
      /// Zero is not a power of two.
  constexpr bool isPowerOfTwo() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::isPowerOfTwo, Xs...); }) , (;) )
  /// Test whether this is a multiple of the other value.
      ///
      /// Among other things, this promises that
      /// self.alignTo(N) will just return self.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isMultipleOf(IFMETA_ELSE((const clang::CharUnits::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::CharUnits)) N) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::isMultipleOf, Xs..., Y0s...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::CharUnits) )
  operator*(long long N) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::operator_star, Xs..., N); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::CharUnits) )
  operator/(long long N) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::operator_div, Xs..., N); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr long long operator/(IFMETA_ELSE((const clang::CharUnits::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::CharUnits &)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::operator_div1, Xs..., Y0s...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::CharUnits) )
  operator%(long long N) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::operator_mod, Xs..., N); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr long long operator%(IFMETA_ELSE((const clang::CharUnits::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::CharUnits &)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::operator_mod1, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::CharUnits) )
  operator+(IFMETA_ELSE((const clang::CharUnits::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::CharUnits &)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::operator_plus, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::CharUnits) )
  operator-(IFMETA_ELSE((const clang::CharUnits::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::CharUnits &)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::operator_minus, Xs..., Y0s...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::CharUnits) )
  operator-() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::operator_minus1, Xs...); }) , (;) )
  /// getQuantity - Get the raw integer representation of this quantity.
  constexpr long long getQuantity() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::getQuantity, Xs...); }) , (;) )
  /// alignTo - Returns the next integer (mod 2**64) that is
      /// greater than or equal to this quantity and is a multiple of \p Align.
      /// Align must be non-zero.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::CharUnits) )
  alignTo(IFMETA_ELSE((const clang::CharUnits::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::CharUnits &)) Align) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::alignTo, Xs..., Y0s...); }) , (;) )
  /// Given that this is a non-zero alignment value, what is the
      /// alignment at the given offset?
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::CharUnits) )
  alignmentAtOffset(IFMETA_ELSE((const clang::CharUnits::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::CharUnits)) offset) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::alignmentAtOffset, Xs..., Y0s...); }) , (;) )
  /// Given that this is the alignment of the first element of an
      /// array, return the minimum alignment of any element in the array.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::CharUnits) )
  alignmentOfArrayElement(IFMETA_ELSE((const clang::CharUnits::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::CharUnits)) elementSize) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__CharUnits, reflenums::clang__CharUnits::alignmentOfArrayElement, Xs..., Y0s...); }) , (;) )
};

/// Keeps track of options that affect how file operations are performed.
M_template_rtpack(Xs)
struct clang::FileSystemOptions::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__FileSystemOptions;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::FileSystemOptions::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
};

/// Twine - A lightweight data structure for efficiently representing the
  /// concatenation of temporary values as strings.
  ///
  /// A Twine is a kind of rope, it represents a concatenated string using a
  /// binary-tree, where the string is the preorder of the nodes. Since the
  /// Twine can be efficiently rendered into a buffer when its result is used,
  /// it avoids the cost of generating temporary values for intermediate string
  /// results -- particularly in cases when the Twine result is never
  /// required. By explicitly tracking the type of leaf nodes, we can also avoid
  /// the creation of temporary strings for conversions operations (such as
  /// appending an integer to a string).
  ///
  /// A Twine is not intended for use directly and should not be stored, its
  /// implementation relies on the ability to store pointers to temporary stack
  /// objects which may be deallocated at the end of a statement. Twines should
  /// only be used accepted as const references in arguments, when an API wishes
  /// to accept possibly-concatenated strings.
  ///
  /// Twines support a special 'null' value, which always concatenates to form
  /// itself, and renders as an empty string. This can be returned from APIs to
  /// effectively nullify any concatenations performed on the result.
  ///
  /// \b Implementation
  ///
  /// Given the nature of a Twine, it is not possible for the Twine's
  /// concatenation method to construct interior nodes; the result must be
  /// represented inside the returned value. For this reason a Twine object
  /// actually holds two values, the left- and right-hand sides of a
  /// concatenation. We also have nullary Twine objects, which are effectively
  /// sentinel values that represent empty strings.
  ///
  /// Thus, a Twine can effectively have zero, one, or two children. The \see
  /// isNullary(), \see isUnary(), and \see isBinary() predicates exist for
  /// testing the number of children.
  ///
  /// We maintain a number of invariants on Twine objects (FIXME: Why):
  ///  - Nullary twines are always represented with their Kind on the left-hand
  ///    side, and the Empty kind on the right-hand side.
  ///  - Unary twines are always represented with the value on the left-hand
  ///    side, and the Empty kind on the right-hand side.
  ///  - If a Twine has another Twine as a child, that child should always be
  ///    binary (otherwise it could have been folded into the parent).
  ///
  /// These invariants are check by \see isValid().
  ///
  /// \b Efficiency Considerations
  ///
  /// The Twine is designed to yield efficient and small code for common
  /// situations. For this reason, the concat() method is inlined so that
  /// concatenations of leaf nodes can be optimized into stores directly into a
  /// single stack allocated object.
  ///
  /// In practice, not all compilers can be trusted to optimize concat() fully,
  /// so we provide two additional methods (and accompanying operator+
  /// overloads) to guarantee that particularly important cases (cstring plus
  /// StringRef) codegen as desired.
M_template_rtpack(Xs)
struct llvm::Twine::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_llvm__Twine;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::llvm::Twine::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// Check if this twine is trivially empty; a false return value does not
    /// necessarily mean the twine is empty.
  constexpr bool isTriviallyEmpty() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__Twine, reflenums::llvm__Twine::isTriviallyEmpty, Xs...); }) , (;) )
  /// Return true if this twine can be dynamically accessed as a single
    /// StringRef value with getSingleStringRef().
  constexpr bool isSingleStringRef() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__Twine, reflenums::llvm__Twine::isSingleStringRef, Xs...); }) , (;) )
  /// Return the twine contents as a std::string.
  constexpr const char * str() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__Twine, reflenums::llvm__Twine::str, Xs...); }) , (;) )
  /// This returns the twine as a single StringRef.  This method is only valid
    /// if isSingleStringRef() is true.
  constexpr const char * getSingleStringRef() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__Twine, reflenums::llvm__Twine::getSingleStringRef, Xs...); }) , (;) )
  /// Write the concatenated string represented by this twine to the
    /// stream \p OS.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void print(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) OS) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__Twine, reflenums::llvm__Twine::print, Xs..., Y0s...); }) , (;) )
  /// Dump the concatenated string represented by this twine to stderr.
  constexpr void dump() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__Twine, reflenums::llvm__Twine::dump, Xs...); }) , (;) )
  /// Write the representation of this twine to the stream \p OS.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void printRepr(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) OS) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__Twine, reflenums::llvm__Twine::printRepr, Xs..., Y0s...); }) , (;) )
  /// Dump the representation of this twine to stderr.
  constexpr void dumpRepr() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_llvm__Twine, reflenums::llvm__Twine::dumpRepr, Xs...); }) , (;) )
};

M_template_rtpack(Xs)
struct llvm::sys::fs::UniqueID::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_llvm__sys__fs__UniqueID;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::llvm::sys::fs::UniqueID::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator==(IFMETA_ELSE((const llvm::sys::fs::UniqueID::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::sys::fs::UniqueID &)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__sys__fs__UniqueID, reflenums::llvm__sys__fs__UniqueID::operator_eq_eq, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator!=(IFMETA_ELSE((const llvm::sys::fs::UniqueID::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::sys::fs::UniqueID &)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__sys__fs__UniqueID, reflenums::llvm__sys__fs__UniqueID::operator_not_eq, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator<(IFMETA_ELSE((const llvm::sys::fs::UniqueID::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::sys::fs::UniqueID &)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__sys__fs__UniqueID, reflenums::llvm__sys__fs__UniqueID::operator_less, Xs..., Y0s...); }) , (;) )
  constexpr unsigned long long getDevice() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__sys__fs__UniqueID, reflenums::llvm__sys__fs__UniqueID::getDevice, Xs...); }) , (;) )
  constexpr unsigned long long getFile() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__sys__fs__UniqueID, reflenums::llvm__sys__fs__UniqueID::getFile, Xs...); }) , (;) )
};

/// The kind of memory backing used to support the MemoryBuffer.
enum llvm::MemoryBuffer::BufferKind : unsigned int {
  MemoryBuffer_Malloc,
  MemoryBuffer_MMap,
};

/// This interface provides simple read-only access to a block of memory, and
/// provides simple methods for reading files and standard input into a memory
/// buffer.  In addition to basic access to the characters in the file, this
/// interface guarantees you can read one character past the end of the file,
/// and that this character will read as '\0'.
///
/// The '\0' guarantee is needed to support an optimization -- it's intended to
/// be more efficient for clients which are reading all the data to stop
/// reading when they encounter a '\0' than to continually check the file
/// position to see if it has reached the end of the file.
M_template_rtpack(Xs)
struct llvm::MemoryBuffer::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_llvm__MemoryBuffer;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::llvm::MemoryBuffer::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr const char * getBufferStart() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__MemoryBuffer, reflenums::llvm__MemoryBuffer::getBufferStart, Xs...); }) , (;) )
  constexpr const char * getBufferEnd() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__MemoryBuffer, reflenums::llvm__MemoryBuffer::getBufferEnd, Xs...); }) , (;) )
  constexpr unsigned long getBufferSize() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__MemoryBuffer, reflenums::llvm__MemoryBuffer::getBufferSize, Xs...); }) , (;) )
  constexpr const char * getBuffer() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__MemoryBuffer, reflenums::llvm__MemoryBuffer::getBuffer, Xs...); }) , (;) )
  /// Return an identifier for this buffer, typically the filename it was read
  /// from.
  constexpr const char * getBufferIdentifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__MemoryBuffer, reflenums::llvm__MemoryBuffer::getBufferIdentifier, Xs...); }) , (;) )
  using BufferKind = enum refldetail::llvm::MemoryBuffer::BufferKind;
  /// Return information on the memory mechanism used to support the
  /// MemoryBuffer.
  constexpr enum llvm::MemoryBuffer::BufferKind getBufferKind() const IFMETA_ELSE( ({    return (enum llvm::MemoryBuffer::BufferKind)__reflect_prop(reflenums::RK_llvm__MemoryBuffer, reflenums::llvm__MemoryBuffer::getBufferKind, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::llvm::MemoryBufferRef) )
  getMemBufferRef() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__MemoryBuffer, reflenums::llvm__MemoryBuffer::getMemBufferRef, Xs...); }) , (;) )
};

M_template_rtpack(Xs)
struct llvm::MemoryBufferRef::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_llvm__MemoryBufferRef;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::llvm::MemoryBufferRef::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr const char * getBuffer() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__MemoryBufferRef, reflenums::llvm__MemoryBufferRef::getBuffer, Xs...); }) , (;) )
  constexpr const char * getBufferIdentifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__MemoryBufferRef, reflenums::llvm__MemoryBufferRef::getBufferIdentifier, Xs...); }) , (;) )
  constexpr const char * getBufferStart() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__MemoryBufferRef, reflenums::llvm__MemoryBufferRef::getBufferStart, Xs...); }) , (;) )
  constexpr const char * getBufferEnd() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__MemoryBufferRef, reflenums::llvm__MemoryBufferRef::getBufferEnd, Xs...); }) , (;) )
  constexpr unsigned long getBufferSize() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__MemoryBufferRef, reflenums::llvm__MemoryBufferRef::getBufferSize, Xs...); }) , (;) )
};

/// Cached information about one directory (either on disk or in
/// the virtual file system).
M_template_rtpack(Xs)
struct clang::DirectoryEntry::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DirectoryEntry;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DirectoryEntry::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr const char * getName() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DirectoryEntry, reflenums::clang__DirectoryEntry::getName, Xs...); }) , (;) )
};

/// Cached information about one file (either on disk
/// or in the virtual file system).
///
/// If the 'File' member is valid, then this FileEntry has an open file
/// descriptor for the file.
M_template_rtpack(Xs)
struct clang::FileEntry::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__FileEntry;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::FileEntry::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr const char * getName() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileEntry, reflenums::clang__FileEntry::getName, Xs...); }) , (;) )
  constexpr const char * tryGetRealPathName() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileEntry, reflenums::clang__FileEntry::tryGetRealPathName, Xs...); }) , (;) )
  constexpr bool isValid() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileEntry, reflenums::clang__FileEntry::isValid, Xs...); }) , (;) )
  constexpr long long getSize() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileEntry, reflenums::clang__FileEntry::getSize, Xs...); }) , (;) )
  constexpr unsigned int getUID() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileEntry, reflenums::clang__FileEntry::getUID, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::llvm::sys::fs::UniqueID &) )
  getUniqueID() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileEntry, reflenums::clang__FileEntry::getUniqueID, Xs...); }) , (;) )
  constexpr bool isInPCH() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileEntry, reflenums::clang__FileEntry::isInPCH, Xs...); }) , (;) )
  constexpr long getModificationTime() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileEntry, reflenums::clang__FileEntry::getModificationTime, Xs...); }) , (;) )
  /// Return the directory the file lives in.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::DirectoryEntry *) )
  getDir() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileEntry, reflenums::clang__FileEntry::getDir, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator<(IFMETA_ELSE((const clang::FileEntry::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::FileEntry &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileEntry, reflenums::clang__FileEntry::operator_less, Xs..., Y0s...); }) , (;) )
  /// Check whether the file is a named pipe (and thus can't be opened by
  /// the native FileManager methods).
  constexpr bool isNamedPipe() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileEntry, reflenums::clang__FileEntry::isNamedPipe, Xs...); }) , (;) )
  constexpr void closeFile() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__FileEntry, reflenums::clang__FileEntry::closeFile, Xs...); }) , (;) )
};

/// Implements support for file system lookup, file system caching,
/// and directory search management.
///
/// This also handles more advanced properties, such as uniquing files based
/// on "inode", so that a file with two names (e.g. symlinked) will be treated
/// as a single file.
///
M_template_rtpack(Xs)
struct clang::FileManager::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__FileManager;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::FileManager::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr void Retain() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__FileManager, reflenums::clang__FileManager::Retain, Xs...); }) , (;) )
  constexpr void Release() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__FileManager, reflenums::clang__FileManager::Release, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::FileSystemOptions &) )
  getFileSystemOpts() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FileManager, reflenums::clang__FileManager::getFileSystemOpts, Xs...); }) , (;) )
  /// Modifies the size and modification time of a previously created
  /// FileEntry. Use with caution.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr void modifyFileEntry(IFMETA_ELSE((const clang::FileEntry::template impl</*ptrorref=*/1, Y0s...> *), (typename meta::clang::FileEntry *)) File, long long Size, long ModificationTime) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__FileManager, reflenums::clang__FileManager::modifyFileEntry, Xs..., Y0s..., Size, ModificationTime); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr void modifyFileEntry(ptrwrp<Y0> p0, long long p1, long p2) {
      return modifyFileEntry(p0.get(), p1, p2);
  }), () )
  constexpr void PrintStats() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__FileManager, reflenums::clang__FileManager::PrintStats, Xs...); }) , (;) )
};

/// The signature of a module, which is a hash of the AST content.
M_template_rtpack(Xs)
struct clang::ASTFileSignature::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__ASTFileSignature;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::ASTFileSignature::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr const unsigned int * cbegin() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ASTFileSignature, reflenums::clang__ASTFileSignature::cbegin, Xs...); }) , (;) )
  constexpr const unsigned int * cend() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ASTFileSignature, reflenums::clang__ASTFileSignature::cend, Xs...); }) , (;) )
  constexpr unsigned long size() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ASTFileSignature, reflenums::clang__ASTFileSignature::size, Xs...); }) , (;) )
  constexpr unsigned long max_size() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ASTFileSignature, reflenums::clang__ASTFileSignature::max_size, Xs...); }) , (;) )
  constexpr bool empty() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ASTFileSignature, reflenums::clang__ASTFileSignature::empty, Xs...); }) , (;) )
  constexpr const unsigned int & operator[](unsigned long __n) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ASTFileSignature, reflenums::clang__ASTFileSignature::operator_sub, Xs..., __n); }) , (;) )
  constexpr const unsigned int & at(unsigned long __n) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ASTFileSignature, reflenums::clang__ASTFileSignature::at, Xs..., __n); }) , (;) )
  constexpr const unsigned int & front() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ASTFileSignature, reflenums::clang__ASTFileSignature::front, Xs...); }) , (;) )
  constexpr const unsigned int & back() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ASTFileSignature, reflenums::clang__ASTFileSignature::back, Xs...); }) , (;) )
  constexpr const unsigned int * data() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ASTFileSignature, reflenums::clang__ASTFileSignature::data, Xs...); }) , (;) )
  constexpr explicit operator bool() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ASTFileSignature, reflenums::clang__ASTFileSignature::operator_bool, Xs...); }) , (;) )
  RANGECLASS_SIZE_AND_GET(clang__ASTFileSignature, const unsigned int);
};

enum clang::Module::ModuleKind : unsigned int {
  /// This is a module that was defined by a module map and built out
  /// of header files.
  ModuleMapModule,
  /// This is a C++ Modules TS module interface unit.
  ModuleInterfaceUnit,
  /// This is a fragment of the global module within some C++ Modules
  /// TS module.
  GlobalModuleFragment,
};

/// Describes the visibility of the various names within a
/// particular module.
enum clang::Module::NameVisibilityKind : unsigned int {
  /// All of the names in this module are hidden.
  Hidden,
  /// All of the names in this module are visible.
  AllVisible,
};

/// Describes a module or submodule.
M_template_rtpack(Xs)
struct clang::Module::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__Module;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::Module::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// The location of the module definition.
  M_REFLTYPED_FIELD(DefinitionLoc, (typename meta::clang::SourceLocation), __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::DefinitionLoc, Xs...))
  using ModuleKind = enum refldetail::clang::Module::ModuleKind;
  /// The kind of this module.
  enum clang::Module::ModuleKind Kind
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::Kind, Xs...);), (;) )
  /// The parent of this module. This will be NULL for the top-level
  /// module.
  M_REFLTYPED_FIELD(Parent, (typename meta::clang::Module *), __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::Parent, Xs...))
  /// The build directory of this module. This is the directory in
  /// which the module is notionally built, and relative to which its headers
  /// are found.
  M_REFLTYPED_FIELD(Directory, (const typename meta::clang::DirectoryEntry *), __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::Directory, Xs...))
  /// The module signature.
  M_REFLTYPED_FIELD(Signature, (typename meta::clang::ASTFileSignature), __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::Signature, Xs...))
  static const int NumHeaderKinds = 5u;
  M_template_rtpack(Zs) using Header = struct refldetail::clang::Module::Header::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using DirectoryName = struct refldetail::clang::Module::DirectoryName::M_template impl M_targpack(Zs);
  /// A module with the same name that shadows this module.
  M_REFLTYPED_FIELD(ShadowingModule, (typename meta::clang::Module *), __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::ShadowingModule, Xs...))
  /// Whether this module is missing a feature from \c Requirements.
  bool IsMissingRequirement
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::IsMissingRequirement, Xs...);), (;) )
  /// Whether we tried and failed to load a module file for this module.
  bool HasIncompatibleModuleFile
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::HasIncompatibleModuleFile, Xs...);), (;) )
  /// Whether this module is available in the current translation unit.
  ///
  /// If the module is missing headers or does not meet all requirements then
  /// this bit will be 0.
  bool IsAvailable
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::IsAvailable, Xs...);), (;) )
  /// Whether this module was loaded from a module file.
  bool IsFromModuleFile
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::IsFromModuleFile, Xs...);), (;) )
  /// Whether this is a framework module.
  bool IsFramework
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::IsFramework, Xs...);), (;) )
  /// Whether this is an explicit submodule.
  bool IsExplicit
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::IsExplicit, Xs...);), (;) )
  /// Whether this is a "system" module (which assumes that all
  /// headers in it are system headers).
  bool IsSystem
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::IsSystem, Xs...);), (;) )
  /// Whether this is an 'extern "C"' module (which implicitly puts all
  /// headers in it within an 'extern "C"' block, and allows the module to be
  /// imported within such a block).
  bool IsExternC
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::IsExternC, Xs...);), (;) )
  /// Whether this is an inferred submodule (module * { ... }).
  bool IsInferred
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::IsInferred, Xs...);), (;) )
  /// Whether we should infer submodules for this module based on
  /// the headers.
  ///
  /// Submodules can only be inferred for modules with an umbrella header.
  bool InferSubmodules
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::InferSubmodules, Xs...);), (;) )
  /// Whether, when inferring submodules, the inferred submodules
  /// should be explicit.
  bool InferExplicitSubmodules
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::InferExplicitSubmodules, Xs...);), (;) )
  /// Whether, when inferring submodules, the inferr submodules should
  /// export all modules they import (e.g., the equivalent of "export *").
  bool InferExportWildcard
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::InferExportWildcard, Xs...);), (;) )
  /// Whether the set of configuration macros is exhaustive.
  ///
  /// When the set of configuration macros is exhaustive, meaning
  /// that no identifier not in this list should affect how the module is
  /// built.
  bool ConfigMacrosExhaustive
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::ConfigMacrosExhaustive, Xs...);), (;) )
  /// Whether files in this module can only include non-modular headers
  /// and headers from used modules.
  bool NoUndeclaredIncludes
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::NoUndeclaredIncludes, Xs...);), (;) )
  /// Whether this module came from a "private" module map, found next
  /// to a regular (public) module map.
  bool ModuleMapIsPrivate
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::ModuleMapIsPrivate, Xs...);), (;) )
  using NameVisibilityKind = enum refldetail::clang::Module::NameVisibilityKind;
  /// The visibility of names within this particular module.
  enum clang::Module::NameVisibilityKind NameVisibility
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::NameVisibility, Xs...);), (;) )
  /// The location of the inferred submodule.
  M_REFLTYPED_FIELD(InferredSubmoduleLoc, (typename meta::clang::SourceLocation), __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::InferredSubmoduleLoc, Xs...))
  /// Autolinking uses the framework name for linking purposes
  /// when this is false and the export_as name otherwise.
  bool UseExportAsModuleLinkName
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::UseExportAsModuleLinkName, Xs...);), (;) )
  /// Determine whether this module is available for use within the
  /// current translation unit.
  constexpr bool isAvailable() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::isAvailable, Xs...); }) , (;) )
  /// Determine whether this module is a submodule.
  constexpr bool isSubModule() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::isSubModule, Xs...); }) , (;) )
  /// Determine whether this module is a submodule of the given other
  /// module.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isSubModuleOf(IFMETA_ELSE((const clang::Module::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Module *)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::isSubModuleOf, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  constexpr bool isSubModuleOf(ptrwrp<Y0> p0) const {
      return isSubModuleOf(p0.get());
  }), () )
  /// Determine whether this module is a part of a framework,
  /// either because it is a framework module or because it is a submodule
  /// of a framework module.
  constexpr bool isPartOfFramework() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::isPartOfFramework, Xs...); }) , (;) )
  /// Determine whether this module is a subframework of another
  /// framework.
  constexpr bool isSubFramework() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::isSubFramework, Xs...); }) , (;) )
  /// Retrieve the full name of this module, including the path from
  /// its top-level module.
  /// \param AllowStringLiterals If \c true, components that might not be
  ///        lexically valid as identifiers will be emitted as string literals.
  constexpr const char * getFullModuleName(bool AllowStringLiterals = false) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::getFullModuleName, Xs..., AllowStringLiterals); }) , (;) )
  /// Retrieve the top-level module for this (sub)module, which may
  /// be this module.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::Module *) )
  getTopLevelModule() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::getTopLevelModule, Xs...); }) , (;) )
  /// Retrieve the name of the top-level module.
  constexpr const char * getTopLevelModuleName() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::getTopLevelModuleName, Xs...); }) , (;) )
  /// The serialized AST file for this module, if one was created.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::FileEntry *) )
  getASTFile() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::getASTFile, Xs...); }) , (;) )
  /// Retrieve the directory for which this module serves as the
  /// umbrella.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Module::DirectoryName) )
  getUmbrellaDir() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::getUmbrellaDir, Xs...); }) , (;) )
  /// Retrieve the header that serves as the umbrella header for this
  /// module.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Module::Header) )
  getUmbrellaHeader() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::getUmbrellaHeader, Xs...); }) , (;) )
  /// Determine whether this module has an umbrella directory that is
  /// not based on an umbrella header.
  constexpr bool hasUmbrellaDir() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::hasUmbrellaDir, Xs...); }) , (;) )
  /// Determine whether this module has declared its intention to
  /// directly use another module.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool directlyUses(IFMETA_ELSE((const clang::Module::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Module *)) Requested) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::directlyUses, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  constexpr bool directlyUses(ptrwrp<Y0> p0) const {
      return directlyUses(p0.get());
  }), () )
  /// Determine whether the specified module would be visible to
  /// a lookup at the end of this module.
  ///
  /// FIXME: This may return incorrect results for (submodules of) the
  /// module currently being built, if it's queried before we see all
  /// of its imports.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isModuleVisible(IFMETA_ELSE((const clang::Module::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Module *)) M) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::isModuleVisible, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  constexpr bool isModuleVisible(ptrwrp<Y0> p0) const {
      return isModuleVisible(p0.get());
  }), () )
  constexpr unsigned int getVisibilityID() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::getVisibilityID, Xs...); }) , (;) )
  RANGE_REFLECTION(clang::Module, submodules,
      constexpr auto submodules() const ,
      (typename meta::clang::Module *const),
      (reflenums::RK_clang__Module, reflenums::clang__Module::submodules, Xs...), () )
  static constexpr const char * getModuleInputBufferName() IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::getModuleInputBufferName, Xs...); }) , (;) )
  /// Print the module map for this module to the given stream.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void print(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) OS, unsigned int Indent = 0) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::print, Xs..., Y0s..., Indent); }) , (;) )
  /// Dump the contents of this module to the given output stream.
  constexpr void dump() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__Module, reflenums::clang__Module::dump, Xs...); }) , (;) )
};

/// Information about a header directive as found in the module map
  /// file.
M_template_rtpack(Xs)
struct clang::Module::Header::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__Module__Header;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::Module::Header::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  M_REFLTYPED_FIELD(Entry, (const typename meta::clang::FileEntry *), __reflect_prop(reflenums::RK_clang__Module__Header, reflenums::clang__Module__Header::Entry, Xs...))
};

/// Information about a directory name as found in the module map
  /// file.
M_template_rtpack(Xs)
struct clang::Module::DirectoryName::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__Module__DirectoryName;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::Module::DirectoryName::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  M_REFLTYPED_FIELD(Entry, (const typename meta::clang::DirectoryEntry *), __reflect_prop(reflenums::RK_clang__Module__DirectoryName, reflenums::clang__Module__DirectoryName::Entry, Xs...))
};

/// Abstract interface for external sources of AST nodes.
///
/// External AST sources provide AST nodes constructed from some
/// external source, such as a precompiled header. External AST
/// sources can resolve types and declarations from abstract IDs into
/// actual type and declaration nodes, and read parts of declaration
/// contexts.
M_template_rtpack(Xs)
struct clang::ExternalASTSource::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__ExternalASTSource;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::ExternalASTSource::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr void Retain() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__ExternalASTSource, reflenums::clang__ExternalASTSource::Retain, Xs...); }) , (;) )
  constexpr void Release() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__ExternalASTSource, reflenums::clang__ExternalASTSource::Release, Xs...); }) , (;) )
  /// Get the current generation of this AST source. This number
  /// is incremented each time the AST source lazily extends an existing
  /// entity.
  constexpr unsigned int getGeneration() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ExternalASTSource, reflenums::clang__ExternalASTSource::getGeneration, Xs...); }) , (;) )
  M_template_rtpack(Zs) using MemoryBufferSizes = struct refldetail::clang::ExternalASTSource::MemoryBufferSizes::M_template impl M_targpack(Zs);
  /// Return the amount of memory used by memory buffers, breaking down
  /// by heap-backed versus mmap'ed memory.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::ExternalASTSource::MemoryBufferSizes) )
  getMemoryBufferSizes() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ExternalASTSource, reflenums::clang__ExternalASTSource::getMemoryBufferSizes, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void getMemoryBufferSizes(IFMETA_ELSE((const clang::ExternalASTSource::MemoryBufferSizes::template impl</*ptrorref=*/1, Y0s...>), (typename meta::clang::ExternalASTSource::MemoryBufferSizes &)) sizes) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__ExternalASTSource, reflenums::clang__ExternalASTSource::getMemoryBufferSizes1, Xs..., Y0s...); }) , (;) )
};

M_template_rtpack(Xs)
struct clang::ExternalASTSource::MemoryBufferSizes::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__ExternalASTSource__MemoryBufferSizes;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::ExternalASTSource::MemoryBufferSizes::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  unsigned long malloc_bytes
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__ExternalASTSource__MemoryBufferSizes, reflenums::clang__ExternalASTSource__MemoryBufferSizes::malloc_bytes, Xs...);), (;) )
  unsigned long mmap_bytes
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__ExternalASTSource__MemoryBufferSizes, reflenums::clang__ExternalASTSource__MemoryBufferSizes::mmap_bytes, Xs...);), (;) )
};

/// FoldingSetBase - Implements the folding set functionality.  The main
/// structure is an array of buckets.  Each bucket is indexed by the hash of
/// the nodes it contains.  The bucket itself points to the nodes contained
/// in the bucket via a singly linked list.  The last node in the list points
/// back to the bucket to facilitate node removal.
///
M_template_rtpack(Xs)
struct llvm::FoldingSetBase::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_llvm__FoldingSetBase;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::llvm::FoldingSetBase::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  M_template_rtpack(Zs) using Node = struct refldetail::llvm::FoldingSetBase::Node::M_template impl M_targpack(Zs);
  /// size - Returns the number of nodes in the folding set.
  constexpr unsigned int size() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__FoldingSetBase, reflenums::llvm__FoldingSetBase::size, Xs...); }) , (;) )
  /// empty - Returns true if there are no nodes in the folding set.
  constexpr bool empty() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__FoldingSetBase, reflenums::llvm__FoldingSetBase::empty, Xs...); }) , (;) )
};

/// Node - This class is used to maintain the singly linked bucket list in
  /// a folding set.
M_template_rtpack(Xs)
struct llvm::FoldingSetBase::Node::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_llvm__FoldingSetBase__Node;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::llvm::FoldingSetBase::Node::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr void * getNextInBucket() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__FoldingSetBase__Node, reflenums::llvm__FoldingSetBase__Node::getNextInBucket, Xs...); }) , (;) )
};

/// FoldingSetNodeIDRef - This class describes a reference to an interned
/// FoldingSetNodeID, which can be a useful to store node id data rather
/// than using plain FoldingSetNodeIDs, since the 32-element SmallVector
/// is often much larger than necessary, and the possibility of heap
/// allocation means it requires a non-trivial destructor call.
M_template_rtpack(Xs)
struct llvm::FoldingSetNodeIDRef::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_llvm__FoldingSetNodeIDRef;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::llvm::FoldingSetNodeIDRef::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// ComputeHash - Compute a strong hash value for this FoldingSetNodeIDRef,
  /// used to lookup the node in the FoldingSetBase.
  constexpr unsigned int ComputeHash() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__FoldingSetNodeIDRef, reflenums::llvm__FoldingSetNodeIDRef::ComputeHash, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator==(IFMETA_ELSE((const llvm::FoldingSetNodeIDRef::template impl</*ptrorref=*/0, Y0s...>), (typename meta::llvm::FoldingSetNodeIDRef)) p0) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__FoldingSetNodeIDRef, reflenums::llvm__FoldingSetNodeIDRef::operator_eq_eq, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator!=(IFMETA_ELSE((const llvm::FoldingSetNodeIDRef::template impl</*ptrorref=*/0, Y0s...>), (typename meta::llvm::FoldingSetNodeIDRef)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__FoldingSetNodeIDRef, reflenums::llvm__FoldingSetNodeIDRef::operator_not_eq, Xs..., Y0s...); }) , (;) )
  /// Used to compare the "ordering" of two nodes as defined by the
  /// profiled bits and their ordering defined by memcmp().
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator<(IFMETA_ELSE((const llvm::FoldingSetNodeIDRef::template impl</*ptrorref=*/0, Y0s...>), (typename meta::llvm::FoldingSetNodeIDRef)) p0) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__FoldingSetNodeIDRef, reflenums::llvm__FoldingSetNodeIDRef::operator_less, Xs..., Y0s...); }) , (;) )
  constexpr const unsigned int * getData() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__FoldingSetNodeIDRef, reflenums::llvm__FoldingSetNodeIDRef::getData, Xs...); }) , (;) )
  constexpr unsigned long getSize() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__FoldingSetNodeIDRef, reflenums::llvm__FoldingSetNodeIDRef::getSize, Xs...); }) , (;) )
};

/// FoldingSetNodeID - This class is used to gather all the unique data bits of
/// a node.  When all the bits are gathered this class is used to produce a
/// hash value for the node.
M_template_rtpack(Xs)
struct llvm::FoldingSetNodeID::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_llvm__FoldingSetNodeID;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::llvm::FoldingSetNodeID::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// ComputeHash - Compute a strong hash value for this FoldingSetNodeID, used
  /// to lookup the node in the FoldingSetBase.
  constexpr unsigned int ComputeHash() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__FoldingSetNodeID, reflenums::llvm__FoldingSetNodeID::ComputeHash, Xs...); }) , (;) )
  /// operator== - Used to compare two nodes to each other.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator==(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::FoldingSetNodeID &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__FoldingSetNodeID, reflenums::llvm__FoldingSetNodeID::operator_eq_eq, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator==(IFMETA_ELSE((const llvm::FoldingSetNodeIDRef::template impl</*ptrorref=*/0, Y0s...>), (const typename meta::llvm::FoldingSetNodeIDRef)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__FoldingSetNodeID, reflenums::llvm__FoldingSetNodeID::operator_eq_eq1, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator!=(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::FoldingSetNodeID &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__FoldingSetNodeID, reflenums::llvm__FoldingSetNodeID::operator_not_eq, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator!=(IFMETA_ELSE((const llvm::FoldingSetNodeIDRef::template impl</*ptrorref=*/0, Y0s...>), (const typename meta::llvm::FoldingSetNodeIDRef)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__FoldingSetNodeID, reflenums::llvm__FoldingSetNodeID::operator_not_eq1, Xs..., Y0s...); }) , (;) )
  /// Used to compare the "ordering" of two nodes as defined by the
  /// profiled bits and their ordering defined by memcmp().
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator<(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::llvm::FoldingSetNodeID &)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__FoldingSetNodeID, reflenums::llvm__FoldingSetNodeID::operator_less, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator<(IFMETA_ELSE((const llvm::FoldingSetNodeIDRef::template impl</*ptrorref=*/0, Y0s...>), (const typename meta::llvm::FoldingSetNodeIDRef)) RHS) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_llvm__FoldingSetNodeID, reflenums::llvm__FoldingSetNodeID::operator_less1, Xs..., Y0s...); }) , (;) )
};

/// The kind of specifier that completes this nested name
/// specifier.
enum clang::NestedNameSpecifier::SpecifierKind : unsigned int {
  /// An identifier, stored as an IdentifierInfo*.
  Identifier,
  /// A namespace, stored as a NamespaceDecl*.
  Namespace,
  /// A namespace alias, stored as a NamespaceAliasDecl*.
  NamespaceAlias,
  /// A type, stored as a Type*.
  TypeSpec,
  /// A type that was preceded by the 'template' keyword,
  /// stored as a Type*.
  TypeSpecWithTemplate,
  /// The global specifier '::'. There is no stored value.
  Global,
  /// Microsoft's '__super' specifier, stored as a CXXRecordDecl* of
  /// the class it appeared in.
  Super,
};

/// Represents a C++ nested name specifier, such as
/// "\::std::vector<int>::".
///
/// C++ nested name specifiers are the prefixes to qualified
/// names. For example, "foo::" in "foo::x" is a nested name
/// specifier. Nested name specifiers are made up of a sequence of
/// specifiers, each of which can be a namespace, type, identifier
/// (for dependent names), decltype specifier, or the global specifier ('::').
/// The last two specifiers can only appear at the start of a
/// nested-namespace-specifier.
M_template_rtpack(Xs)
struct clang::NestedNameSpecifier::impl : impl_offset_t<llvm::FoldingSetBase::Node, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__NestedNameSpecifier;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::NestedNameSpecifier::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  using SpecifierKind = enum refldetail::clang::NestedNameSpecifier::SpecifierKind;
  /// Builds a specifier combining a prefix and an identifier.
  ///
  /// The prefix must be dependent, since nested name specifiers
  /// referencing an identifier are only permitted when the identifier
  /// cannot be resolved.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::NestedNameSpecifier *) )
  Create(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Context, IFMETA_ELSE((const clang::NestedNameSpecifier::template impl</*ptrorref=*/1, Y1s...> *), (typename meta::clang::NestedNameSpecifier *)) Prefix, IFMETA_ELSE((const clang::IdentifierInfo::template impl</*ptrorref=*/1, Y2s...> *), (typename meta::clang::IdentifierInfo *)) II) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::Create, Xs..., Y0s..., Y1s..., Y2s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2>
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::NestedNameSpecifier *) )
  Create(Y0 p0, ptrwrp<Y1> p1, ptrwrp<Y2> p2) {
      return Create(p0, p1.get(), p2.get());
  }), () )
  /// Builds a nested name specifier that names a namespace.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::NestedNameSpecifier *) )
  Create(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Context, IFMETA_ELSE((const clang::NestedNameSpecifier::template impl</*ptrorref=*/1, Y1s...> *), (typename meta::clang::NestedNameSpecifier *)) Prefix, IFMETA_ELSE((const clang::NamespaceDecl::template impl</*ptrorref=*/1, Y2s...> *), (const typename meta::clang::NamespaceDecl *)) NS) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::Create1, Xs..., Y0s..., Y1s..., Y2s...); }) , (;) )
  /// Builds a nested name specifier that names a namespace alias.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::NestedNameSpecifier *) )
  Create(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Context, IFMETA_ELSE((const clang::NestedNameSpecifier::template impl</*ptrorref=*/1, Y1s...> *), (typename meta::clang::NestedNameSpecifier *)) Prefix, IFMETA_ELSE((const clang::NamespaceAliasDecl::template impl</*ptrorref=*/1, Y2s...> *), (typename meta::clang::NamespaceAliasDecl *)) Alias) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::Create2, Xs..., Y0s..., Y1s..., Y2s...); }) , (;) )
  /// Builds a nested name specifier that names a type.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::NestedNameSpecifier *) )
  Create(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Context, IFMETA_ELSE((const clang::NestedNameSpecifier::template impl</*ptrorref=*/1, Y1s...> *), (typename meta::clang::NestedNameSpecifier *)) Prefix, bool Template, IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y2s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::Create3, Xs..., Y0s..., Y1s..., Template, Y2s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2>
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::NestedNameSpecifier *) )
  Create(Y0 p0, ptrwrp<Y1> p1, bool p2, ptrwrp<Y2> p3) {
      return Create(p0, p1.get(), p2, p3.get());
  }), () )
  /// Builds a specifier that consists of just an identifier.
  ///
  /// The nested-name-specifier is assumed to be dependent, but has no
  /// prefix because the prefix is implied by something outside of the
  /// nested name specifier, e.g., in "x->Base::f", the "x" has a dependent
  /// type.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::NestedNameSpecifier *) )
  Create(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Context, IFMETA_ELSE((const clang::IdentifierInfo::template impl</*ptrorref=*/1, Y1s...> *), (typename meta::clang::IdentifierInfo *)) II) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::Create4, Xs..., Y0s..., Y1s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1>
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::NestedNameSpecifier *) )
  Create(Y0 p0, ptrwrp<Y1> p1) {
      return Create(p0, p1.get());
  }), () )
  /// Returns the nested name specifier representing the global
  /// scope.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::NestedNameSpecifier *) )
  GlobalSpecifier(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Context) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::GlobalSpecifier, Xs..., Y0s...); }) , (;) )
  /// Returns the nested name specifier representing the __super scope
  /// for the given CXXRecordDecl.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::NestedNameSpecifier *) )
  SuperSpecifier(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Context, IFMETA_ELSE((const clang::CXXRecordDecl::template impl</*ptrorref=*/1, Y1s...> *), (typename meta::clang::CXXRecordDecl *)) RD) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::SuperSpecifier, Xs..., Y0s..., Y1s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1>
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::NestedNameSpecifier *) )
  SuperSpecifier(Y0 p0, ptrwrp<Y1> p1) {
      return SuperSpecifier(p0, p1.get());
  }), () )
  /// Return the prefix of this nested name specifier.
  ///
  /// The prefix contains all of the parts of the nested name
  /// specifier that preced this current specifier. For example, for a
  /// nested name specifier that represents "foo::bar::", the current
  /// specifier will contain "bar::" and the prefix will contain
  /// "foo::".
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::NestedNameSpecifier *) )
  getPrefix() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::getPrefix, Xs...); }) , (;) )
  /// Determine what kind of nested name specifier is stored.
  constexpr enum clang::NestedNameSpecifier::SpecifierKind getKind() const IFMETA_ELSE( ({    return (enum clang::NestedNameSpecifier::SpecifierKind)__reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::getKind, Xs...); }) , (;) )
  /// Retrieve the identifier stored in this nested name
  /// specifier.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::IdentifierInfo *) )
  getAsIdentifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::getAsIdentifier, Xs...); }) , (;) )
  /// Retrieve the namespace stored in this nested name
  /// specifier.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::NamespaceDecl *) )
  getAsNamespace() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::getAsNamespace, Xs...); }) , (;) )
  /// Retrieve the namespace alias stored in this nested name
  /// specifier.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::NamespaceAliasDecl *) )
  getAsNamespaceAlias() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::getAsNamespaceAlias, Xs...); }) , (;) )
  /// Retrieve the record declaration stored in this nested name
  /// specifier.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::CXXRecordDecl *) )
  getAsRecordDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::getAsRecordDecl, Xs...); }) , (;) )
  /// Retrieve the type stored in this nested name specifier.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::Type *) )
  getAsType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::getAsType, Xs...); }) , (;) )
  /// Whether this nested name specifier refers to a dependent
  /// type or not.
  constexpr bool isDependent() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::isDependent, Xs...); }) , (;) )
  /// Whether this nested name specifier involves a template
  /// parameter.
  constexpr bool isInstantiationDependent() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::isInstantiationDependent, Xs...); }) , (;) )
  /// Whether this nested-name-specifier contains an unexpanded
  /// parameter pack (for C++11 variadic templates).
  constexpr bool containsUnexpandedParameterPack() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::containsUnexpandedParameterPack, Xs...); }) , (;) )
  /// Print this nested name specifier to the given output
  /// stream.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  constexpr void print(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) OS, IFMETA_ELSE((const clang::PrintingPolicy::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::clang::PrintingPolicy &)) Policy) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::print, Xs..., Y0s..., Y1s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::Profile, Xs..., Y0s...); }) , (;) )
  /// Dump the nested name specifier to standard output to aid
  /// in debugging.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void dump(IFMETA_ELSE((const clang::LangOptions::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::LangOptions &)) LO) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::dump, Xs..., Y0s...); }) , (;) )
  constexpr void dump() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__NestedNameSpecifier, reflenums::clang__NestedNameSpecifier::dump1, Xs...); }) , (;) )
};

/// A C++ nested-name-specifier augmented with source location
/// information.
M_template_rtpack(Xs)
struct clang::NestedNameSpecifierLoc::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__NestedNameSpecifierLoc;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::NestedNameSpecifierLoc::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// Evaluates true when this nested-name-specifier location is
  /// non-empty.
  constexpr explicit operator bool() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifierLoc, reflenums::clang__NestedNameSpecifierLoc::operator_bool, Xs...); }) , (;) )
  /// Evaluates true when this nested-name-specifier location is
  /// empty.
  constexpr bool hasQualifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifierLoc, reflenums::clang__NestedNameSpecifierLoc::hasQualifier, Xs...); }) , (;) )
  /// Retrieve the nested-name-specifier to which this instance
  /// refers.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::NestedNameSpecifier *) )
  getNestedNameSpecifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifierLoc, reflenums::clang__NestedNameSpecifierLoc::getNestedNameSpecifier, Xs...); }) , (;) )
  /// Retrieve the opaque pointer that refers to source-location data.
  constexpr void * getOpaqueData() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifierLoc, reflenums::clang__NestedNameSpecifierLoc::getOpaqueData, Xs...); }) , (;) )
  /// Retrieve the source range covering the entirety of this
  /// nested-name-specifier.
  ///
  /// For example, if this instance refers to a nested-name-specifier
  /// \c \::std::vector<int>::, the returned source range would cover
  /// from the initial '::' to the last '::'.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceRange) )
  getSourceRange() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifierLoc, reflenums::clang__NestedNameSpecifierLoc::getSourceRange, Xs...); }) , (;) )
  /// Retrieve the source range covering just the last part of
  /// this nested-name-specifier, not including the prefix.
  ///
  /// For example, if this instance refers to a nested-name-specifier
  /// \c \::std::vector<int>::, the returned source range would cover
  /// from "vector" to the last '::'.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceRange) )
  getLocalSourceRange() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifierLoc, reflenums::clang__NestedNameSpecifierLoc::getLocalSourceRange, Xs...); }) , (;) )
  /// Retrieve the location of the beginning of this
  /// nested-name-specifier.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getBeginLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifierLoc, reflenums::clang__NestedNameSpecifierLoc::getBeginLoc, Xs...); }) , (;) )
  /// Retrieve the location of the end of this
  /// nested-name-specifier.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getEndLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifierLoc, reflenums::clang__NestedNameSpecifierLoc::getEndLoc, Xs...); }) , (;) )
  /// Retrieve the location of the beginning of this
  /// component of the nested-name-specifier.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getLocalBeginLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifierLoc, reflenums::clang__NestedNameSpecifierLoc::getLocalBeginLoc, Xs...); }) , (;) )
  /// Retrieve the location of the end of this component of the
  /// nested-name-specifier.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getLocalEndLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifierLoc, reflenums::clang__NestedNameSpecifierLoc::getLocalEndLoc, Xs...); }) , (;) )
  /// Return the prefix of this nested-name-specifier.
  ///
  /// For example, if this instance refers to a nested-name-specifier
  /// \c \::std::vector<int>::, the prefix is \c \::std::. Note that the
  /// returned prefix may be empty, if this is the first component of
  /// the nested-name-specifier.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::NestedNameSpecifierLoc) )
  getPrefix() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifierLoc, reflenums::clang__NestedNameSpecifierLoc::getPrefix, Xs...); }) , (;) )
  /// For a nested-name-specifier that refers to a type,
  /// retrieve the type with source-location information.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TypeLoc) )
  getTypeLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifierLoc, reflenums::clang__NestedNameSpecifierLoc::getTypeLoc, Xs...); }) , (;) )
  /// Determines the data length for the entire
  /// nested-name-specifier.
  constexpr unsigned int getDataLength() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifierLoc, reflenums::clang__NestedNameSpecifierLoc::getDataLength, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr bool operator==(IFMETA_ELSE((const clang::NestedNameSpecifierLoc::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::NestedNameSpecifierLoc)) X, IFMETA_ELSE((const clang::NestedNameSpecifierLoc::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::NestedNameSpecifierLoc)) Y) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifierLoc, reflenums::clang__NestedNameSpecifierLoc::operator_eq_eq, Xs..., Y0s..., Y1s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr bool operator!=(IFMETA_ELSE((const clang::NestedNameSpecifierLoc::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::NestedNameSpecifierLoc)) X, IFMETA_ELSE((const clang::NestedNameSpecifierLoc::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::NestedNameSpecifierLoc)) Y) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__NestedNameSpecifierLoc, reflenums::clang__NestedNameSpecifierLoc::operator_not_eq, Xs..., Y0s..., Y1s...); }) , (;) )
};

/// Implementation class used to describe either a set of overloaded
/// template names or an already-substituted template template parameter pack.
M_template_rtpack(Xs)
struct clang::UncommonTemplateNameStorage::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__UncommonTemplateNameStorage;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::UncommonTemplateNameStorage::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr unsigned int size() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__UncommonTemplateNameStorage, reflenums::clang__UncommonTemplateNameStorage::size, Xs...); }) , (;) )
};

/// A structure for storing the information associated with an
/// overloaded template name.
M_template_rtpack(Xs)
struct clang::OverloadedTemplateStorage::impl : impl_offset_t<clang::UncommonTemplateNameStorage, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__OverloadedTemplateStorage;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::OverloadedTemplateStorage::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  RANGECLASS_SIZE_AND_GET(clang__OverloadedTemplateStorage, typename meta::clang::NamedDecl *const);
};

/// A structure for storing an already-substituted template template
/// parameter pack.
///
/// This kind of template names occurs when the parameter pack has been
/// provided with a template template argument pack in a context where its
/// enclosing pack expansion could not be fully expanded.
M_template_rtpack(Xs)
struct clang::SubstTemplateTemplateParmPackStorage::impl : impl_offset_t<clang::UncommonTemplateNameStorage, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 8 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__SubstTemplateTemplateParmPackStorage;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::SubstTemplateTemplateParmPackStorage::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// Retrieve the template template parameter pack being substituted.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TemplateTemplateParmDecl *) )
  getParameterPack() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SubstTemplateTemplateParmPackStorage, reflenums::clang__SubstTemplateTemplateParmPackStorage::getParameterPack, Xs...); }) , (;) )
  /// Retrieve the template template argument pack with which this
  /// parameter was substituted.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TemplateArgument) )
  getArgumentPack() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SubstTemplateTemplateParmPackStorage, reflenums::clang__SubstTemplateTemplateParmPackStorage::getArgumentPack, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_c M_rtpack(Y3s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y1s...>), (typename meta::clang::ASTContext &)) Context, IFMETA_ELSE((const clang::TemplateTemplateParmDecl::template impl</*ptrorref=*/1, Y2s...> *), (typename meta::clang::TemplateTemplateParmDecl *)) Parameter, IFMETA_ELSE((const clang::TemplateArgument::template impl</*ptrorref=*/1, Y3s...>), (const typename meta::clang::TemplateArgument &)) ArgPack) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__SubstTemplateTemplateParmPackStorage, reflenums::clang__SubstTemplateTemplateParmPackStorage::Profile, Xs..., Y0s..., Y1s..., Y2s..., Y3s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2, typename Y3>
  static constexpr void Profile(Y0 p0, Y1 p1, ptrwrp<Y2> p2, Y3 p3) {
      return Profile(p0, p1, p2.get(), p3);
  }), () )
};

enum clang::TemplateName::NameKind : unsigned int {
  /// A single template declaration.
  Template,
  /// A set of overloaded template declarations.
  OverloadedTemplate,
  /// A qualified template name, where the qualification is kept
  /// to describe the source code as written.
  QualifiedTemplate,
  /// A dependent template name that has not been resolved to a
  /// template (or set of templates).
  DependentTemplate,
  /// A template template parameter that has been substituted
  /// for some other template name.
  SubstTemplateTemplateParm,
  /// A template template parameter pack that has been substituted for
  /// a template template argument pack, but has not yet been expanded into
  /// individual arguments.
  SubstTemplateTemplateParmPack,
};

/// Represents a C++ template name within the type system.
///
/// A C++ template name refers to a template within the C++ type
/// system. In most cases, a template name is simply a reference to a
/// class template, e.g.
///
/// \code
/// template<typename T> class X { };
///
/// X<int> xi;
/// \endcode
///
/// Here, the 'X' in \c X<int> is a template name that refers to the
/// declaration of the class template X, above. Template names can
/// also refer to function templates, C++0x template aliases, etc.
///
/// Some template names are dependent. For example, consider:
///
/// \code
/// template<typename MetaFun, typename T1, typename T2> struct apply2 {
///   typedef typename MetaFun::template apply<T1, T2>::type type;
/// };
/// \endcode
///
/// Here, "apply" is treated as a template name within the typename
/// specifier in the typedef. "apply" is a nested template, and can
/// only be understood in the context of
M_template_rtpack(Xs)
struct clang::TemplateName::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__TemplateName;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::TemplateName::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  using NameKind = enum refldetail::clang::TemplateName::NameKind;
  /// Determine whether this template name is NULL.
  constexpr bool isNull() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateName, reflenums::clang__TemplateName::isNull, Xs...); }) , (;) )
  constexpr enum clang::TemplateName::NameKind getKind() const IFMETA_ELSE( ({    return (enum clang::TemplateName::NameKind)__reflect_prop(reflenums::RK_clang__TemplateName, reflenums::clang__TemplateName::getKind, Xs...); }) , (;) )
  /// Retrieve the underlying template declaration that
  /// this template name refers to, if known.
  ///
  /// \returns The template declaration that this template name refers
  /// to, if any. If the template name does not refer to a specific
  /// declaration because it is a dependent name, or if it refers to a
  /// set of function templates, returns NULL.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TemplateDecl *) )
  getAsTemplateDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateName, reflenums::clang__TemplateName::getAsTemplateDecl, Xs...); }) , (;) )
  ///
  /// \returns The set of overloaded function templates that this template
  /// name refers to, if known. If the template name does not refer to a
  /// specific set of function templates because it is a dependent name or
  /// refers to a single template, returns NULL.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::OverloadedTemplateStorage *) )
  getAsOverloadedTemplate() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateName, reflenums::clang__TemplateName::getAsOverloadedTemplate, Xs...); }) , (;) )
  /// Retrieve the substituted template template parameter, if
  /// known.
  ///
  /// \returns The storage for the substituted template template parameter,
  /// if known. Otherwise, returns NULL.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SubstTemplateTemplateParmStorage *) )
  getAsSubstTemplateTemplateParm() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateName, reflenums::clang__TemplateName::getAsSubstTemplateTemplateParm, Xs...); }) , (;) )
  /// Retrieve the substituted template template parameter pack, if
  /// known.
  ///
  /// \returns The storage for the substituted template template parameter pack,
  /// if known. Otherwise, returns NULL.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SubstTemplateTemplateParmPackStorage *) )
  getAsSubstTemplateTemplateParmPack() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateName, reflenums::clang__TemplateName::getAsSubstTemplateTemplateParmPack, Xs...); }) , (;) )
  /// Retrieve the underlying qualified template name
  /// structure, if any.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualifiedTemplateName *) )
  getAsQualifiedTemplateName() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateName, reflenums::clang__TemplateName::getAsQualifiedTemplateName, Xs...); }) , (;) )
  /// Retrieve the underlying dependent template name
  /// structure, if any.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::DependentTemplateName *) )
  getAsDependentTemplateName() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateName, reflenums::clang__TemplateName::getAsDependentTemplateName, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TemplateName) )
  getUnderlying() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateName, reflenums::clang__TemplateName::getUnderlying, Xs...); }) , (;) )
  /// Get the template name to substitute when this template name is used as a
  /// template template argument. This refers to the most recent declaration of
  /// the template, including any default template arguments.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TemplateName) )
  getNameToSubstitute() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateName, reflenums::clang__TemplateName::getNameToSubstitute, Xs...); }) , (;) )
  /// Determines whether this is a dependent template name.
  constexpr bool isDependent() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateName, reflenums::clang__TemplateName::isDependent, Xs...); }) , (;) )
  /// Determines whether this is a template name that somehow
  /// depends on a template parameter.
  constexpr bool isInstantiationDependent() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateName, reflenums::clang__TemplateName::isInstantiationDependent, Xs...); }) , (;) )
  /// Determines whether this template name contains an
  /// unexpanded parameter pack (for C++0x variadic templates).
  constexpr bool containsUnexpandedParameterPack() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateName, reflenums::clang__TemplateName::containsUnexpandedParameterPack, Xs...); }) , (;) )
  /// Print the template name.
  ///
  /// \param OS the output stream to which the template name will be
  /// printed.
  ///
  /// \param SuppressNNS if true, don't print the
  /// nested-name-specifier that precedes the template name (if it has
  /// one).
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  constexpr void print(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) OS, IFMETA_ELSE((const clang::PrintingPolicy::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::clang::PrintingPolicy &)) Policy, bool SuppressNNS = false) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__TemplateName, reflenums::clang__TemplateName::print, Xs..., Y0s..., Y1s..., SuppressNNS); }) , (;) )
  /// Debugging aid that dumps the template name.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void dump(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) OS) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__TemplateName, reflenums::clang__TemplateName::dump, Xs..., Y0s...); }) , (;) )
  /// Debugging aid that dumps the template name to standard
  /// error.
  constexpr void dump() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__TemplateName, reflenums::clang__TemplateName::dump1, Xs...); }) , (;) )
  /// Retrieve the template name as a void pointer.
  constexpr void * getAsVoidPointer() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateName, reflenums::clang__TemplateName::getAsVoidPointer, Xs...); }) , (;) )
  /// Build a template name from a void pointer.
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::TemplateName) )
  getFromVoidPointer(void * Ptr) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateName, reflenums::clang__TemplateName::getFromVoidPointer, Xs..., Ptr); }) , (;) )
};

/// A structure for storing the information associated with a
/// substituted template template parameter.
M_template_rtpack(Xs)
struct clang::SubstTemplateTemplateParmStorage::impl : impl_offset_t<clang::UncommonTemplateNameStorage, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 8 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__SubstTemplateTemplateParmStorage;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::SubstTemplateTemplateParmStorage::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TemplateTemplateParmDecl *) )
  getParameter() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SubstTemplateTemplateParmStorage, reflenums::clang__SubstTemplateTemplateParmStorage::getParameter, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TemplateName) )
  getReplacement() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SubstTemplateTemplateParmStorage, reflenums::clang__SubstTemplateTemplateParmStorage::getReplacement, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::TemplateTemplateParmDecl::template impl</*ptrorref=*/1, Y1s...> *), (typename meta::clang::TemplateTemplateParmDecl *)) parameter, IFMETA_ELSE((const clang::TemplateName::template impl</*ptrorref=*/0, Y2s...>), (typename meta::clang::TemplateName)) replacement) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__SubstTemplateTemplateParmStorage, reflenums::clang__SubstTemplateTemplateParmStorage::Profile, Xs..., Y0s..., Y1s..., Y2s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2>
  static constexpr void Profile(Y0 p0, ptrwrp<Y1> p1, Y2 p2) {
      return Profile(p0, p1.get(), p2);
  }), () )
};

/// Represents a template name that was expressed as a
/// qualified name.
///
/// This kind of template name refers to a template name that was
/// preceded by a nested name specifier, e.g., \c std::vector. Here,
/// the nested name specifier is "std::" and the template name is the
/// declaration for "vector". The QualifiedTemplateName class is only
/// used to provide "sugar" for template names that were expressed
/// with a qualified name, and has no semantic meaning. In this
/// manner, it is to TemplateName what ElaboratedType is to Type,
/// providing extra syntactic sugar for downstream clients.
M_template_rtpack(Xs)
struct clang::QualifiedTemplateName::impl : impl_offset_t<llvm::FoldingSetBase::Node, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__QualifiedTemplateName;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::QualifiedTemplateName::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// Return the nested name specifier that qualifies this name.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::NestedNameSpecifier *) )
  getQualifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualifiedTemplateName, reflenums::clang__QualifiedTemplateName::getQualifier, Xs...); }) , (;) )
  /// Whether the template name was prefixed by the "template"
  /// keyword.
  constexpr bool hasTemplateKeyword() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualifiedTemplateName, reflenums::clang__QualifiedTemplateName::hasTemplateKeyword, Xs...); }) , (;) )
  /// The template declaration that this qualified name refers
  /// to.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TemplateDecl *) )
  getDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualifiedTemplateName, reflenums::clang__QualifiedTemplateName::getDecl, Xs...); }) , (;) )
  /// The template declaration to which this qualified name
  /// refers.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TemplateDecl *) )
  getTemplateDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualifiedTemplateName, reflenums::clang__QualifiedTemplateName::getTemplateDecl, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::NestedNameSpecifier::template impl</*ptrorref=*/1, Y1s...> *), (typename meta::clang::NestedNameSpecifier *)) NNS, bool TemplateKeyword, IFMETA_ELSE((const clang::TemplateDecl::template impl</*ptrorref=*/1, Y2s...> *), (typename meta::clang::TemplateDecl *)) Template) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__QualifiedTemplateName, reflenums::clang__QualifiedTemplateName::Profile, Xs..., Y0s..., Y1s..., TemplateKeyword, Y2s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2>
  static constexpr void Profile(Y0 p0, ptrwrp<Y1> p1, bool p2, ptrwrp<Y2> p3) {
      return Profile(p0, p1.get(), p2, p3.get());
  }), () )
};

/// Represents a dependent template name that cannot be
/// resolved prior to template instantiation.
///
/// This kind of template name refers to a dependent template name,
/// including its nested name specifier (if any). For example,
/// DependentTemplateName can refer to "MetaFun::template apply",
/// where "MetaFun::" is the nested name specifier and "apply" is the
/// template name referenced. The "template" keyword is implied.
M_template_rtpack(Xs)
struct clang::DependentTemplateName::impl : impl_offset_t<llvm::FoldingSetBase::Node, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DependentTemplateName;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DependentTemplateName::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// Return the nested name specifier that qualifies this name.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::NestedNameSpecifier *) )
  getQualifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentTemplateName, reflenums::clang__DependentTemplateName::getQualifier, Xs...); }) , (;) )
  /// Determine whether this template name refers to an identifier.
  constexpr bool isIdentifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentTemplateName, reflenums::clang__DependentTemplateName::isIdentifier, Xs...); }) , (;) )
  /// Returns the identifier to which this template name refers.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::IdentifierInfo *) )
  getIdentifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentTemplateName, reflenums::clang__DependentTemplateName::getIdentifier, Xs...); }) , (;) )
  /// Determine whether this template name refers to an overloaded
  /// operator.
  constexpr bool isOverloadedOperator() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentTemplateName, reflenums::clang__DependentTemplateName::isOverloadedOperator, Xs...); }) , (;) )
  /// Return the overloaded operator to which this template name refers.
  constexpr enum clang::OverloadedOperatorKind getOperator() const IFMETA_ELSE( ({    return (enum clang::OverloadedOperatorKind)__reflect_prop(reflenums::RK_clang__DependentTemplateName, reflenums::clang__DependentTemplateName::getOperator, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::NestedNameSpecifier::template impl</*ptrorref=*/1, Y1s...> *), (typename meta::clang::NestedNameSpecifier *)) NNS, IFMETA_ELSE((const clang::IdentifierInfo::template impl</*ptrorref=*/1, Y2s...> *), (const typename meta::clang::IdentifierInfo *)) Identifier) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DependentTemplateName, reflenums::clang__DependentTemplateName::Profile, Xs..., Y0s..., Y1s..., Y2s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2>
  static constexpr void Profile(Y0 p0, ptrwrp<Y1> p1, ptrwrp<Y2> p2) {
      return Profile(p0, p1.get(), p2.get());
  }), () )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::NestedNameSpecifier::template impl</*ptrorref=*/1, Y1s...> *), (typename meta::clang::NestedNameSpecifier *)) NNS, enum clang::OverloadedOperatorKind Operator) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DependentTemplateName, reflenums::clang__DependentTemplateName::Profile1, Xs..., Y0s..., Y1s..., Operator); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1>
  static constexpr void Profile(Y0 p0, ptrwrp<Y1> p1, enum clang::OverloadedOperatorKind p2) {
      return Profile(p0, p1.get(), p2);
  }), () )
};

/// Defines the address space values used by the address space qualifier
/// of QualType.
///
enum class clang::LangAS : unsigned int {
  Default = 0,
  opencl_global,
  opencl_local,
  opencl_constant,
  opencl_private,
  opencl_generic,
  cuda_device,
  cuda_constant,
  cuda_shared,
  FirstTargetAddressSpace,
};

/// The various types of exception specifications that exist in C++11.
enum clang::ExceptionSpecificationType : unsigned int {
  ///< no exception specification
  EST_None,
  ///< throw()
  EST_DynamicNone,
  ///< throw(T1, T2)
  EST_Dynamic,
  ///< Microsoft throw(...) extension
  EST_MSAny,
  ///< noexcept
  EST_BasicNoexcept,
  ///< noexcept(expression), value-dependent
  EST_DependentNoexcept,
  ///< noexcept(expression), evals to 'false'
  EST_NoexceptFalse,
  ///< noexcept(expression), evals to 'true'
  EST_NoexceptTrue,
  ///< not evaluated yet, for special member function
  EST_Unevaluated,
  ///< not instantiated yet
  EST_Uninstantiated,
  ///< not parsed yet
  EST_Unparsed,
};

/// Possible results from evaluation of a noexcept expression.
enum clang::CanThrowResult : unsigned int {
  CT_Cannot,
  CT_Dependent,
  CT_Can,
};

/// Describes the different kinds of linkage
/// (C++ [basic.link], C99 6.2.2) that an entity may have.
enum clang::Linkage : unsigned char {
  /// No linkage, which means that the entity is unique and
  /// can only be referred to from within its scope.
  NoLinkage = 0,
  /// Internal linkage, which indicates that the entity can
  /// be referred to from within the translation unit (but not other
  /// translation units).
  InternalLinkage,
  /// External linkage within a unique namespace.
  ///
  /// From the language perspective, these entities have external
  /// linkage. However, since they reside in an anonymous namespace,
  /// their names are unique to this translation unit, which is
  /// equivalent to having internal linkage from the code-generation
  /// point of view.
  UniqueExternalLinkage,
  /// No linkage according to the standard, but is visible from other
  /// translation units because of types defined in a inline function.
  VisibleNoLinkage,
  /// Internal linkage according to the Modules TS, but can be referred
  /// to from other translation units indirectly through inline functions and
  /// templates in the module interface.
  ModuleInternalLinkage,
  /// Module linkage, which indicates that the entity can be referred
  /// to from other translation units within the same module, and indirectly
  /// from arbitrary other translation units through inline functions and
  /// templates in the module interface.
  ModuleLinkage,
  /// External linkage, which indicates that the entity can
  /// be referred to from other translation units.
  ExternalLinkage,
};

/// Describes the different kinds of language linkage
/// (C++ [dcl.link]) that an entity may have.
enum clang::LanguageLinkage : unsigned int {
  CLanguageLinkage,
  CXXLanguageLinkage,
  NoLanguageLinkage,
};

/// A more specific kind of linkage than enum Linkage.
///
/// This is relevant to CodeGen and AST file reading.
enum clang::GVALinkage : unsigned int {
  GVA_Internal,
  GVA_AvailableExternally,
  GVA_DiscardableODR,
  GVA_StrongExternal,
  GVA_StrongODR,
};

/// Describes the different kinds of visibility that a declaration
/// may have.
///
/// Visibility determines how a declaration interacts with the dynamic
/// linker.  It may also affect whether the symbol can be found by runtime
/// symbol lookup APIs.
///
/// Visibility is not described in any language standard and
/// (nonetheless) sometimes has odd behavior.  Not all platforms
/// support all visibility kinds.
enum clang::Visibility : unsigned int {
  /// Objects with "hidden" visibility are not seen by the dynamic
  /// linker.
  HiddenVisibility,
  /// Objects with "protected" visibility are seen by the dynamic
  /// linker but always dynamically resolve to an object within this
  /// shared object.
  ProtectedVisibility,
  /// Objects with "default" visibility are seen by the dynamic linker
  /// and act like normal objects.
  DefaultVisibility,
};

M_template_rtpack(Xs)
struct clang::LinkageInfo::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__LinkageInfo;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::LinkageInfo::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::LinkageInfo) )
  external() IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__LinkageInfo, reflenums::clang__LinkageInfo::external, Xs...); }) , (;) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::LinkageInfo) )
  internal() IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__LinkageInfo, reflenums::clang__LinkageInfo::internal, Xs...); }) , (;) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::LinkageInfo) )
  uniqueExternal() IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__LinkageInfo, reflenums::clang__LinkageInfo::uniqueExternal, Xs...); }) , (;) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::LinkageInfo) )
  none() IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__LinkageInfo, reflenums::clang__LinkageInfo::none, Xs...); }) , (;) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::LinkageInfo) )
  visible_none() IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__LinkageInfo, reflenums::clang__LinkageInfo::visible_none, Xs...); }) , (;) )
  constexpr enum clang::Linkage getLinkage() const IFMETA_ELSE( ({    return (enum clang::Linkage)__reflect_prop(reflenums::RK_clang__LinkageInfo, reflenums::clang__LinkageInfo::getLinkage, Xs...); }) , (;) )
  constexpr enum clang::Visibility getVisibility() const IFMETA_ELSE( ({    return (enum clang::Visibility)__reflect_prop(reflenums::RK_clang__LinkageInfo, reflenums::clang__LinkageInfo::getVisibility, Xs...); }) , (;) )
  constexpr bool isVisibilityExplicit() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__LinkageInfo, reflenums::clang__LinkageInfo::isVisibilityExplicit, Xs...); }) , (;) )
};

enum clang::Qualifiers::GC : unsigned int {
  GCNone = 0,
  Weak,
  Strong,
};

enum clang::Qualifiers::ObjCLifetime : unsigned int {
  /// There is no lifetime qualification on this type.
  OCL_None,
  /// This object can be modified without requiring retains or
  /// releases.
  OCL_ExplicitNone,
  /// Assigning into this object requires the old value to be
  /// released and the new value to be retained.  The timing of the
  /// release of the old value is inexact: it may be moved to
  /// immediately after the last known point where the value is
  /// live.
  OCL_Strong,
  /// Reading or writing from this object requires a barrier call.
  OCL_Weak,
  /// Assigning into this object requires a lifetime extension.
  OCL_Autoreleasing,
};

/// The collection of all-type qualifiers we support.
/// Clang supports five independent qualifiers:
/// * C99: const, volatile, and restrict
/// * MS: __unaligned
/// * Embedded C (TR18037): address spaces
/// * Objective C: the GC attributes (none, weak, or strong)
M_template_rtpack(Xs)
struct clang::Qualifiers::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__Qualifiers;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::Qualifiers::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  using GC = enum refldetail::clang::Qualifiers::GC;
  using ObjCLifetime = enum refldetail::clang::Qualifiers::ObjCLifetime;
  /// Returns the common set of qualifiers while removing them from
  /// the given sets.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::Qualifiers) )
  removeCommonQualifiers(IFMETA_ELSE((const clang::Qualifiers::template impl</*ptrorref=*/1, Y0s...>), (typename meta::clang::Qualifiers &)) L, IFMETA_ELSE((const clang::Qualifiers::template impl</*ptrorref=*/1, Y1s...>), (typename meta::clang::Qualifiers &)) R) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::removeCommonQualifiers, Xs..., Y0s..., Y1s...); }) , (;) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::Qualifiers) )
  fromFastMask(unsigned int Mask) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::fromFastMask, Xs..., Mask); }) , (;) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::Qualifiers) )
  fromCVRMask(unsigned int CVR) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::fromCVRMask, Xs..., CVR); }) , (;) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::Qualifiers) )
  fromCVRUMask(unsigned int CVRU) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::fromCVRUMask, Xs..., CVRU); }) , (;) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::Qualifiers) )
  fromOpaqueValue(unsigned int opaque) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::fromOpaqueValue, Xs..., opaque); }) , (;) )
  constexpr unsigned int getAsOpaqueValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::getAsOpaqueValue, Xs...); }) , (;) )
  constexpr bool hasConst() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::hasConst, Xs...); }) , (;) )
  constexpr bool hasVolatile() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::hasVolatile, Xs...); }) , (;) )
  constexpr bool hasRestrict() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::hasRestrict, Xs...); }) , (;) )
  constexpr bool hasCVRQualifiers() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::hasCVRQualifiers, Xs...); }) , (;) )
  constexpr unsigned int getCVRQualifiers() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::getCVRQualifiers, Xs...); }) , (;) )
  constexpr bool hasUnaligned() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::hasUnaligned, Xs...); }) , (;) )
  constexpr bool hasObjCGCAttr() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::hasObjCGCAttr, Xs...); }) , (;) )
  constexpr enum clang::Qualifiers::GC getObjCGCAttr() const IFMETA_ELSE( ({    return (enum clang::Qualifiers::GC)__reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::getObjCGCAttr, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Qualifiers) )
  withoutObjCGCAttr() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::withoutObjCGCAttr, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Qualifiers) )
  withoutObjCLifetime() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::withoutObjCLifetime, Xs...); }) , (;) )
  constexpr bool hasObjCLifetime() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::hasObjCLifetime, Xs...); }) , (;) )
  constexpr enum clang::Qualifiers::ObjCLifetime getObjCLifetime() const IFMETA_ELSE( ({    return (enum clang::Qualifiers::ObjCLifetime)__reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::getObjCLifetime, Xs...); }) , (;) )
  /// True if the lifetime is neither None or ExplicitNone.
  constexpr bool hasNonTrivialObjCLifetime() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::hasNonTrivialObjCLifetime, Xs...); }) , (;) )
  /// True if the lifetime is either strong or weak.
  constexpr bool hasStrongOrWeakObjCLifetime() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::hasStrongOrWeakObjCLifetime, Xs...); }) , (;) )
  constexpr bool hasAddressSpace() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::hasAddressSpace, Xs...); }) , (;) )
  constexpr enum clang::LangAS getAddressSpace() const IFMETA_ELSE( ({    return (enum clang::LangAS)__reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::getAddressSpace, Xs...); }) , (;) )
  constexpr bool hasTargetSpecificAddressSpace() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::hasTargetSpecificAddressSpace, Xs...); }) , (;) )
  /// Get the address space attribute value to be printed by diagnostics.
  constexpr unsigned int getAddressSpaceAttributePrintValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::getAddressSpaceAttributePrintValue, Xs...); }) , (;) )
  constexpr bool hasFastQualifiers() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::hasFastQualifiers, Xs...); }) , (;) )
  constexpr unsigned int getFastQualifiers() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::getFastQualifiers, Xs...); }) , (;) )
  /// Return true if the set contains any qualifiers which require an ExtQuals
  /// node to be allocated.
  constexpr bool hasNonFastQualifiers() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::hasNonFastQualifiers, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Qualifiers) )
  getNonFastQualifiers() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::getNonFastQualifiers, Xs...); }) , (;) )
  /// Return true if the set contains any qualifiers.
  constexpr bool hasQualifiers() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::hasQualifiers, Xs...); }) , (;) )
  constexpr bool empty() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::empty, Xs...); }) , (;) )
  /// Returns true if this address space is a superset of the other one.
  /// OpenCL v2.0 defines conversion rules (OpenCLC v2.0 s6.5.5) and notion of
  /// overlapping address spaces.
  /// CL1.1 or CL1.2:
  ///   every address space is a superset of itself.
  /// CL2.0 adds:
  ///   __generic is a superset of any address space except for __constant.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isAddressSpaceSupersetOf(IFMETA_ELSE((const clang::Qualifiers::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::Qualifiers)) other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::isAddressSpaceSupersetOf, Xs..., Y0s...); }) , (;) )
  /// Determines if these qualifiers compatibly include another set.
  /// Generally this answers the question of whether an object with the other
  /// qualifiers can be safely used as an object with these qualifiers.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool compatiblyIncludes(IFMETA_ELSE((const clang::Qualifiers::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::Qualifiers)) other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::compatiblyIncludes, Xs..., Y0s...); }) , (;) )
  /// Determines if these qualifiers compatibly include another set of
  /// qualifiers from the narrow perspective of Objective-C ARC lifetime.
  ///
  /// One set of Objective-C lifetime qualifiers compatibly includes the other
  /// if the lifetime qualifiers match, or if both are non-__weak and the
  /// including set also contains the 'const' qualifier, or both are non-__weak
  /// and one is None (which can only happen in non-ARC modes).
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool compatiblyIncludesObjCLifetime(IFMETA_ELSE((const clang::Qualifiers::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::Qualifiers)) other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::compatiblyIncludesObjCLifetime, Xs..., Y0s...); }) , (;) )
  /// Determine whether this set of qualifiers is a strict superset of
  /// another set of qualifiers, not considering qualifier compatibility.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isStrictSupersetOf(IFMETA_ELSE((const clang::Qualifiers::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::Qualifiers)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::isStrictSupersetOf, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator==(IFMETA_ELSE((const clang::Qualifiers::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::Qualifiers)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::operator_eq_eq, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator!=(IFMETA_ELSE((const clang::Qualifiers::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::Qualifiers)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::operator_not_eq, Xs..., Y0s...); }) , (;) )
  constexpr explicit operator bool() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::operator_bool, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr IFMETA_ELSE( (auto), (typename meta::clang::Qualifiers) )
  operator+(IFMETA_ELSE((const clang::Qualifiers::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::Qualifiers)) L, IFMETA_ELSE((const clang::Qualifiers::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::Qualifiers)) R) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::operator_plus, Xs..., Y0s..., Y1s...); }) , (;) )
  /// Compute the difference between two qualifier sets.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr IFMETA_ELSE( (auto), (typename meta::clang::Qualifiers) )
  operator-(IFMETA_ELSE((const clang::Qualifiers::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::Qualifiers)) L, IFMETA_ELSE((const clang::Qualifiers::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::Qualifiers)) R) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::operator_minus, Xs..., Y0s..., Y1s...); }) , (;) )
  constexpr const char * getAsString() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::getAsString, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr const char * getAsString(IFMETA_ELSE((const clang::PrintingPolicy::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::PrintingPolicy &)) Policy) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::getAsString1, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isEmptyWhenPrinted(IFMETA_ELSE((const clang::PrintingPolicy::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::PrintingPolicy &)) Policy) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::isEmptyWhenPrinted, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  constexpr void print(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) OS, IFMETA_ELSE((const clang::PrintingPolicy::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::clang::PrintingPolicy &)) Policy, bool appendSpaceIfNonEmpty = false) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::print, Xs..., Y0s..., Y1s..., appendSpaceIfNonEmpty); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__Qualifiers, reflenums::clang__Qualifiers::Profile, Xs..., Y0s...); }) , (;) )
  static const unsigned int UMask = 8u;
  static const unsigned int UShift = 3u;
  static const unsigned int GCAttrMask = 48u;
  static const unsigned int GCAttrShift = 4u;
  static const unsigned int LifetimeMask = 448u;
  static const unsigned int LifetimeShift = 6u;
  static const unsigned int AddressSpaceMask = 4294966784u;
  static const unsigned int AddressSpaceShift = 9u;
};

/// A std::pair-like structure for storing a qualified type split
/// into its local qualifiers and its locally-unqualified type.
M_template_rtpack(Xs)
struct clang::SplitQualType::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__SplitQualType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::SplitQualType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// The locally-unqualified type.
  M_REFLTYPED_FIELD(Ty, (const typename meta::clang::Type *), __reflect_prop(reflenums::RK_clang__SplitQualType, reflenums::clang__SplitQualType::Ty, Xs...))
  /// The local qualifiers.
  M_REFLTYPED_FIELD(Quals, (typename meta::clang::Qualifiers), __reflect_prop(reflenums::RK_clang__SplitQualType, reflenums::clang__SplitQualType::Quals, Xs...))
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SplitQualType) )
  getSingleStepDesugaredType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SplitQualType, reflenums::clang__SplitQualType::getSingleStepDesugaredType, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr bool operator==(IFMETA_ELSE((const clang::SplitQualType::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::SplitQualType)) a, IFMETA_ELSE((const clang::SplitQualType::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::SplitQualType)) b) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SplitQualType, reflenums::clang__SplitQualType::operator_eq_eq, Xs..., Y0s..., Y1s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr bool operator!=(IFMETA_ELSE((const clang::SplitQualType::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::SplitQualType)) a, IFMETA_ELSE((const clang::SplitQualType::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::SplitQualType)) b) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SplitQualType, reflenums::clang__SplitQualType::operator_not_eq, Xs..., Y0s..., Y1s...); }) , (;) )
};

/// The kind of type we are substituting Objective-C type arguments into.
///
/// The kind of substitution affects the replacement of type parameters when
/// no concrete type information is provided, e.g., when dealing with an
/// unspecialized type.
enum class clang::ObjCSubstitutionContext : int {
  /// An ordinary type.
  Ordinary,
  /// The result type of a method or function.
  Result,
  /// The parameter type of a method or function.
  Parameter,
  /// The type of a property.
  Property,
  /// The superclass of a type.
  Superclass,
};

enum clang::QualType::PrimitiveDefaultInitializeKind : unsigned int {
  /// The type does not fall into any of the following categories. Note that
  /// this case is zero-valued so that values of this enum can be used as a
  /// boolean condition for non-triviality.
  PDIK_Trivial,
  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __strong qualifier.
  PDIK_ARCStrong,
  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __weak qualifier.
  PDIK_ARCWeak,
  /// The type is a struct containing a field whose type is not PCK_Trivial.
  PDIK_Struct,
};

enum clang::QualType::PrimitiveCopyKind : unsigned int {
  /// The type does not fall into any of the following categories. Note that
  /// this case is zero-valued so that values of this enum can be used as a
  /// boolean condition for non-triviality.
  PCK_Trivial,
  /// The type would be trivial except that it is volatile-qualified. Types
  /// that fall into one of the other non-trivial cases may additionally be
  /// volatile-qualified.
  PCK_VolatileTrivial,
  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __strong qualifier.
  PCK_ARCStrong,
  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __weak qualifier.
  PCK_ARCWeak,
  /// The type is a struct containing a field whose type is neither
  /// PCK_Trivial nor PCK_VolatileTrivial.
  /// Note that a C++ struct type does not necessarily match this; C++ copying
  /// semantics are too complex to express here, in part because they depend
  /// on the exact constructor or assignment operator that is chosen by
  /// overload resolution to do the copy.
  PCK_Struct,
};

enum clang::QualType::DestructionKind : unsigned int {
  DK_none,
  DK_cxx_destructor,
  DK_objc_strong_lifetime,
  DK_objc_weak_lifetime,
  DK_nontrivial_c_struct,
};

/// A (possibly-)qualified type.
///
/// For efficiency, we don't store CV-qualified types as nodes on their
/// own: instead each reference to a type stores the qualifiers.  This
/// greatly reduces the number of nodes we need to allocate for types (for
/// example we only need one for 'int', 'const int', 'volatile int',
/// 'const volatile int', etc).
///
/// As an added efficiency bonus, instead of making this a pair, we
/// just store the two bits we care about in the low bits of the
/// pointer.  To handle the packing/unpacking, we make QualType be a
/// simple wrapper class that acts like a smart pointer.  A third bit
/// indicates whether there are extended qualifiers present, in which
/// case the pointer points to a special structure.
M_template_rtpack(Xs)
struct clang::QualType::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__QualType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::QualType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr unsigned int getLocalFastQualifiers() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getLocalFastQualifiers, Xs...); }) , (;) )
  /// Retrieves a pointer to the underlying (unqualified) type.
  ///
  /// This function requires that the type not be NULL. If the type might be
  /// NULL, use the (slightly less efficient) \c getTypePtrOrNull().
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::Type *) )
  getTypePtr() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getTypePtr, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::Type *) )
  getTypePtrOrNull() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getTypePtrOrNull, Xs...); }) , (;) )
  /// Retrieves a pointer to the name of the base type.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::IdentifierInfo *) )
  getBaseTypeIdentifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getBaseTypeIdentifier, Xs...); }) , (;) )
  /// Divides a QualType into its unqualified type and a set of local
  /// qualifiers.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SplitQualType) )
  split() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::split, Xs...); }) , (;) )
  constexpr void * getAsOpaquePtr() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getAsOpaquePtr, Xs...); }) , (;) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getFromOpaquePtr(const void * Ptr) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getFromOpaquePtr, Xs..., Ptr); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::Type &) )
  operator*() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::operator_star, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::Type *) )
  operator->() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::operator_arrow, Xs...); }) , (;) )
  constexpr bool isCanonical() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isCanonical, Xs...); }) , (;) )
  constexpr bool isCanonicalAsParam() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isCanonicalAsParam, Xs...); }) , (;) )
  /// Return true if this QualType doesn't point to a type yet.
  constexpr bool isNull() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isNull, Xs...); }) , (;) )
  /// Determine whether this particular QualType instance has the
  /// "const" qualifier set, without looking through typedefs that may have
  /// added "const" at a different level.
  constexpr bool isLocalConstQualified() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isLocalConstQualified, Xs...); }) , (;) )
  /// Determine whether this type is const-qualified.
  constexpr bool isConstQualified() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isConstQualified, Xs...); }) , (;) )
  /// Determine whether this particular QualType instance has the
  /// "restrict" qualifier set, without looking through typedefs that may have
  /// added "restrict" at a different level.
  constexpr bool isLocalRestrictQualified() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isLocalRestrictQualified, Xs...); }) , (;) )
  /// Determine whether this type is restrict-qualified.
  constexpr bool isRestrictQualified() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isRestrictQualified, Xs...); }) , (;) )
  /// Determine whether this particular QualType instance has the
  /// "volatile" qualifier set, without looking through typedefs that may have
  /// added "volatile" at a different level.
  constexpr bool isLocalVolatileQualified() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isLocalVolatileQualified, Xs...); }) , (;) )
  /// Determine whether this type is volatile-qualified.
  constexpr bool isVolatileQualified() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isVolatileQualified, Xs...); }) , (;) )
  /// Determine whether this particular QualType instance has any
  /// qualifiers, without looking through any typedefs that might add
  /// qualifiers at a different level.
  constexpr bool hasLocalQualifiers() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::hasLocalQualifiers, Xs...); }) , (;) )
  /// Determine whether this type has any qualifiers.
  constexpr bool hasQualifiers() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::hasQualifiers, Xs...); }) , (;) )
  /// Determine whether this particular QualType instance has any
  /// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType
  /// instance.
  constexpr bool hasLocalNonFastQualifiers() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::hasLocalNonFastQualifiers, Xs...); }) , (;) )
  /// Retrieve the set of qualifiers local to this particular QualType
  /// instance, not including any qualifiers acquired through typedefs or
  /// other sugar.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Qualifiers) )
  getLocalQualifiers() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getLocalQualifiers, Xs...); }) , (;) )
  /// Retrieve the set of qualifiers applied to this type.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Qualifiers) )
  getQualifiers() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getQualifiers, Xs...); }) , (;) )
  /// Retrieve the set of CVR (const-volatile-restrict) qualifiers
  /// local to this particular QualType instance, not including any qualifiers
  /// acquired through typedefs or other sugar.
  constexpr unsigned int getLocalCVRQualifiers() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getLocalCVRQualifiers, Xs...); }) , (;) )
  /// Retrieve the set of CVR (const-volatile-restrict) qualifiers
  /// applied to this type.
  constexpr unsigned int getCVRQualifiers() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getCVRQualifiers, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isConstant(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Ctx) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isConstant, Xs..., Y0s...); }) , (;) )
  /// Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isPODType(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Context) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isPODType, Xs..., Y0s...); }) , (;) )
  /// Return true if this is a POD type according to the rules of the C++98
  /// standard, regardless of the current compilation's language.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isCXX98PODType(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Context) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isCXX98PODType, Xs..., Y0s...); }) , (;) )
  /// Return true if this is a POD type according to the more relaxed rules
  /// of the C++11 standard, regardless of the current compilation's language.
  /// (C++0x [basic.types]p9). Note that, unlike
  /// CXXRecordDecl::isCXX11StandardLayout, this takes DRs into account.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isCXX11PODType(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Context) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isCXX11PODType, Xs..., Y0s...); }) , (;) )
  /// Return true if this is a trivial type per (C++0x [basic.types]p9)
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isTrivialType(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Context) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isTrivialType, Xs..., Y0s...); }) , (;) )
  /// Return true if this is a trivially copyable type (C++0x [basic.types]p9)
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isTriviallyCopyableType(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Context) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isTriviallyCopyableType, Xs..., Y0s...); }) , (;) )
  /// Returns true if it is a class and it might be dynamic.
  constexpr bool mayBeDynamicClass() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::mayBeDynamicClass, Xs...); }) , (;) )
  /// Returns true if it is not a class or if the class might not be dynamic.
  constexpr bool mayBeNotDynamicClass() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::mayBeNotDynamicClass, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  withConst() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::withConst, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  withVolatile() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::withVolatile, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  withRestrict() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::withRestrict, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  withCVRQualifiers(unsigned int CVR) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::withCVRQualifiers, Xs..., CVR); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  withFastQualifiers(unsigned int TQs) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::withFastQualifiers, Xs..., TQs); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  withExactLocalFastQualifiers(unsigned int TQs) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::withExactLocalFastQualifiers, Xs..., TQs); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  withoutLocalFastQualifiers() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::withoutLocalFastQualifiers, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getCanonicalType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getCanonicalType, Xs...); }) , (;) )
  /// Return this type with all of the instance-specific qualifiers
  /// removed, but without removing any qualifiers that may have been applied
  /// through typedefs.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getLocalUnqualifiedType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getLocalUnqualifiedType, Xs...); }) , (;) )
  /// Retrieve the unqualified variant of the given type,
  /// removing as little sugar as possible.
  ///
  /// This routine looks through various kinds of sugar to find the
  /// least-desugared type that is unqualified. For example, given:
  ///
  /// \code
  /// typedef int Integer;
  /// typedef const Integer CInteger;
  /// typedef CInteger DifferenceType;
  /// \endcode
  ///
  /// Executing \c getUnqualifiedType() on the type \c DifferenceType will
  /// desugar until we hit the type \c Integer, which has no qualifiers on it.
  ///
  /// The resulting type might still be qualified if it's sugar for an array
  /// type.  To strip qualifiers even from within a sugared array type, use
  /// ASTContext::getUnqualifiedArrayType.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getUnqualifiedType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getUnqualifiedType, Xs...); }) , (;) )
  /// Retrieve the unqualified variant of the given type, removing as little
  /// sugar as possible.
  ///
  /// Like getUnqualifiedType(), but also returns the set of
  /// qualifiers that were built up.
  ///
  /// The resulting type might still be qualified if it's sugar for an array
  /// type.  To strip qualifiers even from within a sugared array type, use
  /// ASTContext::getUnqualifiedArrayType.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SplitQualType) )
  getSplitUnqualifiedType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getSplitUnqualifiedType, Xs...); }) , (;) )
  /// Determine whether this type is more qualified than the other
  /// given type, requiring exact equality for non-CVR qualifiers.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isMoreQualifiedThan(IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::QualType)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isMoreQualifiedThan, Xs..., Y0s...); }) , (;) )
  /// Determine whether this type is at least as qualified as the other
  /// given type, requiring exact equality for non-CVR qualifiers.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isAtLeastAsQualifiedAs(IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::QualType)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isAtLeastAsQualifiedAs, Xs..., Y0s...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getNonReferenceType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getNonReferenceType, Xs...); }) , (;) )
  /// Determine the type of a (typically non-lvalue) expression with the
  /// specified result type.
  ///
  /// This routine should be used for expressions for which the return type is
  /// explicitly specified (e.g., in a cast or call) and isn't necessarily
  /// an lvalue. It removes a top-level reference (since there are no
  /// expressions of reference type) and deletes top-level cvr-qualifiers
  /// from non-class types (in C++) or all types (in C).
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getNonLValueExprType(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Context) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getNonLValueExprType, Xs..., Y0s...); }) , (;) )
  /// Return the specified type with any "sugar" removed from
  /// the type.  This takes off typedefs, typeof's etc.  If the outer level of
  /// the type is already concrete, it returns it unmodified.  This is similar
  /// to getting the canonical type, but it doesn't remove *all* typedefs.  For
  /// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
  /// concrete.
  ///
  /// Qualifiers are left in place.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getDesugaredType(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Context) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getDesugaredType, Xs..., Y0s...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SplitQualType) )
  getSplitDesugaredType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getSplitDesugaredType, Xs...); }) , (;) )
  /// Return the specified type with one level of "sugar" removed from
  /// the type.
  ///
  /// This routine takes off the first typedef, typeof, etc. If the outer level
  /// of the type is already concrete, it returns it unmodified.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getSingleStepDesugaredType(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Context) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getSingleStepDesugaredType, Xs..., Y0s...); }) , (;) )
  /// Returns the specified type after dropping any
  /// outer-level parentheses.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  IgnoreParens() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::IgnoreParens, Xs...); }) , (;) )
  /// Indicate whether the specified types and qualifiers are identical.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr bool operator==(IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::QualType &)) LHS, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::clang::QualType &)) RHS) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::operator_eq_eq, Xs..., Y0s..., Y1s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr bool operator!=(IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::QualType &)) LHS, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::clang::QualType &)) RHS) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::operator_not_eq, Xs..., Y0s..., Y1s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr const char * getAsString(IFMETA_ELSE((const clang::SplitQualType::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::SplitQualType)) split, IFMETA_ELSE((const clang::PrintingPolicy::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::clang::PrintingPolicy &)) Policy) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getAsString, Xs..., Y0s..., Y1s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr const char * getAsString(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) ty, IFMETA_ELSE((const clang::Qualifiers::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::Qualifiers)) qs, IFMETA_ELSE((const clang::PrintingPolicy::template impl</*ptrorref=*/1, Y2s...>), (const typename meta::clang::PrintingPolicy &)) Policy) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getAsString1, Xs..., Y0s..., Y1s..., Y2s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2>
  static constexpr const char * getAsString(ptrwrp<Y0> p0, Y1 p1, Y2 p2) {
      return getAsString(p0.get(), p1, p2);
  }), () )
  constexpr const char * getAsString() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getAsString2, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr const char * getAsString(IFMETA_ELSE((const clang::PrintingPolicy::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::PrintingPolicy &)) Policy) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getAsString3, Xs..., Y0s...); }) , (;) )
  constexpr const char * getAsString_NoPrependScope() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getAsString_NoPrependScope, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  constexpr void print(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) OS, IFMETA_ELSE((const clang::PrintingPolicy::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::clang::PrintingPolicy &)) Policy, IFMETA_ELSE((const llvm::Twine::template impl</*ptrorref=*/1, Y2s...>), (const typename meta::llvm::Twine &)) PlaceHolder = {}, unsigned int Indentation = 0) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::print, Xs..., Y0s..., Y1s..., Y2s..., Indentation); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_c M_rtpack(Y3s) M_tend
  static constexpr void print(IFMETA_ELSE((const clang::SplitQualType::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::SplitQualType)) split, IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y1s...>), (typename meta::llvm::raw_ostream &)) OS, IFMETA_ELSE((const clang::PrintingPolicy::template impl</*ptrorref=*/1, Y2s...>), (const typename meta::clang::PrintingPolicy &)) policy, IFMETA_ELSE((const llvm::Twine::template impl</*ptrorref=*/1, Y3s...>), (const typename meta::llvm::Twine &)) PlaceHolder, unsigned int Indentation = 0) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::print1, Xs..., Y0s..., Y1s..., Y2s..., Y3s..., Indentation); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_c M_rtpack(Y3s) M_c M_rtpack(Y4s) M_tend
  static constexpr void print(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) ty, IFMETA_ELSE((const clang::Qualifiers::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::Qualifiers)) qs, IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y2s...>), (typename meta::llvm::raw_ostream &)) OS, IFMETA_ELSE((const clang::PrintingPolicy::template impl</*ptrorref=*/1, Y3s...>), (const typename meta::clang::PrintingPolicy &)) policy, IFMETA_ELSE((const llvm::Twine::template impl</*ptrorref=*/1, Y4s...>), (const typename meta::llvm::Twine &)) PlaceHolder, unsigned int Indentation = 0, bool MayAppendScope = true) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::print2, Xs..., Y0s..., Y1s..., Y2s..., Y3s..., Y4s..., Indentation, MayAppendScope); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2, typename Y3, typename Y4>
  static constexpr void print(ptrwrp<Y0> p0, Y1 p1, Y2 p2, Y3 p3, Y4 p4, unsigned int p5 = 0, bool p6 = true) {
      return print(p0.get(), p1, p2, p3, p4, p5, p6);
  }), () )
  constexpr void dump(const char * s) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::dump, Xs..., s); }) , (;) )
  constexpr void dump() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::dump1, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void dump(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) OS) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::dump2, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::Profile, Xs..., Y0s...); }) , (;) )
  /// Return the address space of this type.
  constexpr enum clang::LangAS getAddressSpace() const IFMETA_ELSE( ({    return (enum clang::LangAS)__reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getAddressSpace, Xs...); }) , (;) )
  /// Returns gc attribute of this type.
  constexpr enum clang::Qualifiers::GC getObjCGCAttr() const IFMETA_ELSE( ({    return (enum clang::Qualifiers::GC)__reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getObjCGCAttr, Xs...); }) , (;) )
  /// true when Type is objc's weak.
  constexpr bool isObjCGCWeak() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isObjCGCWeak, Xs...); }) , (;) )
  /// true when Type is objc's strong.
  constexpr bool isObjCGCStrong() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isObjCGCStrong, Xs...); }) , (;) )
  /// Returns lifetime attribute of this type.
  constexpr enum clang::Qualifiers::ObjCLifetime getObjCLifetime() const IFMETA_ELSE( ({    return (enum clang::Qualifiers::ObjCLifetime)__reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getObjCLifetime, Xs...); }) , (;) )
  constexpr bool hasNonTrivialObjCLifetime() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::hasNonTrivialObjCLifetime, Xs...); }) , (;) )
  constexpr bool hasStrongOrWeakObjCLifetime() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::hasStrongOrWeakObjCLifetime, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isNonWeakInMRRWithObjCWeak(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Context) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isNonWeakInMRRWithObjCWeak, Xs..., Y0s...); }) , (;) )
  using PrimitiveDefaultInitializeKind = enum refldetail::clang::QualType::PrimitiveDefaultInitializeKind;
  /// Check if this is a non-trivial type that would cause a C struct
  /// transitively containing this type to be non-trivial to default initialize
  /// and return the kind.
  constexpr enum clang::QualType::PrimitiveDefaultInitializeKind isNonTrivialToPrimitiveDefaultInitialize() const IFMETA_ELSE( ({    return (enum clang::QualType::PrimitiveDefaultInitializeKind)__reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isNonTrivialToPrimitiveDefaultInitialize, Xs...); }) , (;) )
  using PrimitiveCopyKind = enum refldetail::clang::QualType::PrimitiveCopyKind;
  /// Check if this is a non-trivial type that would cause a C struct
  /// transitively containing this type to be non-trivial to copy and return the
  /// kind.
  constexpr enum clang::QualType::PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const IFMETA_ELSE( ({    return (enum clang::QualType::PrimitiveCopyKind)__reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isNonTrivialToPrimitiveCopy, Xs...); }) , (;) )
  /// Check if this is a non-trivial type that would cause a C struct
  /// transitively containing this type to be non-trivial to destructively
  /// move and return the kind. Destructive move in this context is a C++-style
  /// move in which the source object is placed in a valid but unspecified state
  /// after it is moved, as opposed to a truly destructive move in which the
  /// source object is placed in an uninitialized state.
  constexpr enum clang::QualType::PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const IFMETA_ELSE( ({    return (enum clang::QualType::PrimitiveCopyKind)__reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isNonTrivialToPrimitiveDestructiveMove, Xs...); }) , (;) )
  using DestructionKind = enum refldetail::clang::QualType::DestructionKind;
  /// Returns a nonzero value if objects of this type require
  /// non-trivial work to clean up after.  Non-zero because it's
  /// conceivable that qualifiers (objc_gc(weak)?) could make
  /// something require destruction.
  constexpr enum clang::QualType::DestructionKind isDestructedType() const IFMETA_ELSE( ({    return (enum clang::QualType::DestructionKind)__reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isDestructedType, Xs...); }) , (;) )
  /// Determine whether expressions of the given type are forbidden
  /// from being lvalues in C.
  ///
  /// The expression types that are forbidden to be lvalues are:
  ///   - 'void', but not qualified void
  ///   - function types
  ///
  /// The exact rule here is C99 6.3.2.1:
  ///   An lvalue is an expression with an object type or an incomplete
  ///   type other than void.
  constexpr bool isCForbiddenLValueType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::isCForbiddenLValueType, Xs...); }) , (;) )
  /// Substitute type arguments from an object type for the Objective-C type
  /// parameters used in the subject type.
  ///
  /// This operation combines the computation of type arguments for
  /// substitution (\c Type::getObjCSubstitutions) with the actual process of
  /// substitution (\c QualType::substObjCTypeArgs) for the convenience of
  /// callers that need to perform a single substitution in isolation.
  ///
  /// \param objectType The type of the object whose member type we're
  /// substituting into. For example, this might be the receiver of a message
  /// or the base of a property access.
  ///
  /// \param dc The declaration context from which the subject type was
  /// retrieved, which indicates (for example) which type parameters should
  /// be substituted.
  ///
  /// \param context The context in which the subject type was written.
  ///
  /// \returns the subject type after replacing all of the Objective-C type
  /// parameters with their corresponding arguments.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  substObjCMemberType(IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::QualType)) objectType, IFMETA_ELSE((const clang::DeclContext::template impl</*ptrorref=*/1, Y1s...> *), (const typename meta::clang::DeclContext *)) dc, enum clang::ObjCSubstitutionContext context) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::substObjCMemberType, Xs..., Y0s..., Y1s..., context); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1>
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  substObjCMemberType(Y0 p0, ptrwrp<Y1> p1, enum clang::ObjCSubstitutionContext p2) const {
      return substObjCMemberType(p0, p1.get(), p2);
  }), () )
  /// Strip Objective-C "__kindof" types from the given type.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  stripObjCKindOfType(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) ctx) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::stripObjCKindOfType, Xs..., Y0s...); }) , (;) )
  /// Remove all qualifiers including _Atomic.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getAtomicUnqualifiedType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__QualType, reflenums::clang__QualType::getAtomicUnqualifiedType, Xs...); }) , (;) )
};

/// Base class that is common to both the \c ExtQuals and \c Type
/// classes, which allows \c QualType to access the common fields between the
/// two.
M_template_rtpack(Xs)
struct clang::ExtQualsTypeCommonBase::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__ExtQualsTypeCommonBase;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::ExtQualsTypeCommonBase::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
};

/// The kind of C++11 ref-qualifier associated with a function type.
/// This determines whether a member function's "this" object can be an
/// lvalue, rvalue, or neither.
enum clang::RefQualifierKind : unsigned int {
  /// No ref-qualifier was provided.
  RQ_None = 0,
  /// An lvalue ref-qualifier was provided (\c &).
  RQ_LValue,
  /// An rvalue ref-qualifier was provided (\c &&).
  RQ_RValue,
};

/// Which keyword(s) were used to create an AutoType.
enum class clang::AutoTypeKeyword : int {
  /// auto
  Auto,
  /// decltype(auto)
  DecltypeAuto,
  /// __auto_type (GNU extension)
  GNUAutoType,
};

enum clang::Type::TypeClass : unsigned int {
  Builtin,
  Complex,
  Pointer,
  BlockPointer,
  LValueReference,
  RValueReference,
  MemberPointer,
  ConstantArray,
  IncompleteArray,
  VariableArray,
  DependentSizedArray,
  DependentSizedExtVector,
  DependentAddressSpace,
  Vector,
  DependentVector,
  ExtVector,
  FunctionProto,
  FunctionNoProto,
  UnresolvedUsing,
  Paren,
  Typedef,
  Adjusted,
  Decayed,
  TypeOfExpr,
  TypeOf,
  Decltype,
  Reflected,
  UnaryTransform,
  Record,
  Enum,
  Elaborated,
  Attributed,
  TemplateTypeParm,
  SubstTemplateTypeParm,
  SubstTemplateTypeParmPack,
  TemplateSpecialization,
  Auto,
  DeducedTemplateSpecialization,
  InjectedClassName,
  ////END
  DependentName,
  ////END
  DependentTemplateSpecialization,
  ////END
  PackExpansion,
  ////END
  ObjCTypeParam,
  ////END
  ObjCObject,
  ////END
  ObjCInterface,
  ////END
  ObjCObjectPointer,
  ////END
  Pipe,
  ////END
  Atomic,
  ////END
  TypeLast = 47,
  ////END
  TagFirst = 28,
  ////END
  TagLast = 29,
};

enum clang::Type::ScalarTypeKind : unsigned int {
  STK_CPointer,
  STK_BlockPointer,
  STK_ObjCObjectPointer,
  STK_MemberPointer,
  STK_Bool,
  STK_Integral,
  STK_Floating,
  STK_IntegralComplex,
  STK_FloatingComplex,
};

/// The base class of the type hierarchy.
///
/// A central concept with types is that each type always has a canonical
/// type.  A canonical type is the type with any typedef names stripped out
/// of it or the types it references.  For example, consider:
///
///  typedef int  foo;
///  typedef foo* bar;
///    'int *'    'foo *'    'bar'
///
/// There will be a Type object created for 'int'.  Since int is canonical, its
/// CanonicalType pointer points to itself.  There is also a Type for 'foo' (a
/// TypedefType).  Its CanonicalType pointer points to the 'int' Type.  Next
/// there is a PointerType that represents 'int*', which, like 'int', is
/// canonical.  Finally, there is a PointerType type for 'foo*' whose canonical
/// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
/// is also 'int*'.
///
/// Non-canonical types are useful for emitting diagnostics, without losing
/// information about typedefs being used.  Canonical types are useful for type
/// comparisons (they allow by-pointer equality tests) and useful for reasoning
/// about whether something has a particular form (e.g. is a function type),
/// because they implicitly, recursively, strip all typedefs out of a type.
///
/// Types, once created, are immutable.
///
M_template_rtpack(Xs)
struct clang::Type::impl : impl_offset_t<clang::ExtQualsTypeCommonBase, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__Type;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::Type::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  using TypeClass = enum refldetail::clang::Type::TypeClass;
  constexpr enum clang::Type::TypeClass getTypeClass() const IFMETA_ELSE( ({    return (enum clang::Type::TypeClass)__reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getTypeClass, Xs...); }) , (;) )
  /// Whether this type comes from an AST file.
  constexpr bool isFromAST() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isFromAST, Xs...); }) , (;) )
  /// Whether this type is or contains an unexpanded parameter
  /// pack, used to support C++0x variadic templates.
  ///
  /// A type that contains a parameter pack shall be expanded by the
  /// ellipsis operator at some point. For example, the typedef in the
  /// following example contains an unexpanded parameter pack 'T':
  ///
  /// \code
  /// template<typename ...T>
  /// struct X {
  ///   typedef T* pointer_types; // ill-formed; T is a parameter pack.
  /// };
  /// \endcode
  ///
  /// Note that this routine does not specify which
  constexpr bool containsUnexpandedParameterPack() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::containsUnexpandedParameterPack, Xs...); }) , (;) )
  /// Determines if this type would be canonical if it had no further
  /// qualification.
  constexpr bool isCanonicalUnqualified() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isCanonicalUnqualified, Xs...); }) , (;) )
  /// Pull a single level of sugar off of this locally-unqualified type.
  /// Users should generally prefer SplitQualType::getSingleStepDesugaredType()
  /// or QualType::getSingleStepDesugaredType(const ASTContext&).
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getLocallyUnqualifiedSingleStepDesugaredType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getLocallyUnqualifiedSingleStepDesugaredType, Xs...); }) , (;) )
  /// Return true if this is an incomplete type.
  /// A type that can describe objects, but which lacks information needed to
  /// determine its size (e.g. void, or a fwd declared struct). Clients of this
  /// routine will need to determine if the size is actually required.
  ///
  /// Def If non-null, and the type refers to some kind of declaration
  /// that can be completed (such as a C struct, C++ class, or Objective-C
  /// class), will be set to the declaration.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isIncompleteType(IFMETA_ELSE((const clang::NamedDecl::template impl</*ptrorref=*/1, Y0s...> * *), (typename meta::clang::NamedDecl **)) Def = {}) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isIncompleteType, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  constexpr bool isIncompleteType(ptrwrp<Y0> p0 = {}) const {
      return isIncompleteType(p0.get());
  }), () )
  /// Return true if this is an incomplete or object
  /// type, in other words, not a function type.
  constexpr bool isIncompleteOrObjectType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isIncompleteOrObjectType, Xs...); }) , (;) )
  /// Determine whether this type is an object type.
  constexpr bool isObjectType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjectType, Xs...); }) , (;) )
  /// Return true if this is a literal type
  /// (C++11 [basic.types]p10)
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isLiteralType(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Ctx) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isLiteralType, Xs..., Y0s...); }) , (;) )
  /// Test if this type is a standard-layout type.
  /// (C++0x [basic.type]p9)
  constexpr bool isStandardLayoutType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isStandardLayoutType, Xs...); }) , (;) )
  /// Returns true if the type is a builtin type.
  constexpr bool isBuiltinType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isBuiltinType, Xs...); }) , (;) )
  /// Test for a particular builtin type.
  constexpr bool isSpecificBuiltinType(unsigned int K) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isSpecificBuiltinType, Xs..., K); }) , (;) )
  /// Test for a type which does not represent an actual type-system type but
  /// is instead used as a placeholder for various convenient purposes within
  /// Clang.  All such types are BuiltinTypes.
  constexpr bool isPlaceholderType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isPlaceholderType, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::BuiltinType *) )
  getAsPlaceholderType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getAsPlaceholderType, Xs...); }) , (;) )
  /// Test for a specific placeholder type.
  constexpr bool isSpecificPlaceholderType(unsigned int K) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isSpecificPlaceholderType, Xs..., K); }) , (;) )
  /// Test for a placeholder type other than Overload; see
  /// BuiltinType::isNonOverloadPlaceholderType.
  constexpr bool isNonOverloadPlaceholderType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isNonOverloadPlaceholderType, Xs...); }) , (;) )
  /// isIntegerType() does *not* include complex integers (a GCC extension).
  /// isComplexIntegerType() can be used to test for complex integers.
  constexpr bool isIntegerType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isIntegerType, Xs...); }) , (;) )
  constexpr bool isEnumeralType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isEnumeralType, Xs...); }) , (;) )
  /// Determine whether this type is a scoped enumeration type.
  constexpr bool isScopedEnumeralType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isScopedEnumeralType, Xs...); }) , (;) )
  constexpr bool isBooleanType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isBooleanType, Xs...); }) , (;) )
  constexpr bool isCharType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isCharType, Xs...); }) , (;) )
  constexpr bool isWideCharType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isWideCharType, Xs...); }) , (;) )
  constexpr bool isChar8Type() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isChar8Type, Xs...); }) , (;) )
  constexpr bool isChar16Type() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isChar16Type, Xs...); }) , (;) )
  constexpr bool isChar32Type() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isChar32Type, Xs...); }) , (;) )
  constexpr bool isAnyCharacterType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isAnyCharacterType, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isIntegralType(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Ctx) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isIntegralType, Xs..., Y0s...); }) , (;) )
  /// Determine whether this type is an integral or enumeration type.
  constexpr bool isIntegralOrEnumerationType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isIntegralOrEnumerationType, Xs...); }) , (;) )
  /// Determine whether this type is an integral or unscoped enumeration type.
  constexpr bool isIntegralOrUnscopedEnumerationType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isIntegralOrUnscopedEnumerationType, Xs...); }) , (;) )
  /// Floating point categories.
  constexpr bool isRealFloatingType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isRealFloatingType, Xs...); }) , (;) )
  /// isComplexType() does *not* include complex integers (a GCC extension).
  /// isComplexIntegerType() can be used to test for complex integers.
  constexpr bool isComplexType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isComplexType, Xs...); }) , (;) )
  constexpr bool isAnyComplexType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isAnyComplexType, Xs...); }) , (;) )
  constexpr bool isFloatingType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isFloatingType, Xs...); }) , (;) )
  constexpr bool isHalfType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isHalfType, Xs...); }) , (;) )
  constexpr bool isFloat16Type() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isFloat16Type, Xs...); }) , (;) )
  constexpr bool isFloat128Type() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isFloat128Type, Xs...); }) , (;) )
  constexpr bool isRealType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isRealType, Xs...); }) , (;) )
  constexpr bool isArithmeticType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isArithmeticType, Xs...); }) , (;) )
  constexpr bool isVoidType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isVoidType, Xs...); }) , (;) )
  constexpr bool isScalarType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isScalarType, Xs...); }) , (;) )
  constexpr bool isAggregateType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isAggregateType, Xs...); }) , (;) )
  constexpr bool isFundamentalType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isFundamentalType, Xs...); }) , (;) )
  constexpr bool isCompoundType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isCompoundType, Xs...); }) , (;) )
  constexpr bool isFunctionType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isFunctionType, Xs...); }) , (;) )
  constexpr bool isFunctionNoProtoType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isFunctionNoProtoType, Xs...); }) , (;) )
  constexpr bool isFunctionProtoType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isFunctionProtoType, Xs...); }) , (;) )
  constexpr bool isPointerType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isPointerType, Xs...); }) , (;) )
  constexpr bool isAnyPointerType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isAnyPointerType, Xs...); }) , (;) )
  constexpr bool isBlockPointerType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isBlockPointerType, Xs...); }) , (;) )
  constexpr bool isVoidPointerType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isVoidPointerType, Xs...); }) , (;) )
  constexpr bool isReferenceType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isReferenceType, Xs...); }) , (;) )
  constexpr bool isLValueReferenceType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isLValueReferenceType, Xs...); }) , (;) )
  constexpr bool isRValueReferenceType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isRValueReferenceType, Xs...); }) , (;) )
  constexpr bool isFunctionPointerType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isFunctionPointerType, Xs...); }) , (;) )
  constexpr bool isMemberPointerType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isMemberPointerType, Xs...); }) , (;) )
  constexpr bool isMemberFunctionPointerType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isMemberFunctionPointerType, Xs...); }) , (;) )
  constexpr bool isMemberDataPointerType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isMemberDataPointerType, Xs...); }) , (;) )
  constexpr bool isArrayType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isArrayType, Xs...); }) , (;) )
  constexpr bool isConstantArrayType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isConstantArrayType, Xs...); }) , (;) )
  constexpr bool isIncompleteArrayType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isIncompleteArrayType, Xs...); }) , (;) )
  constexpr bool isVariableArrayType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isVariableArrayType, Xs...); }) , (;) )
  constexpr bool isDependentSizedArrayType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isDependentSizedArrayType, Xs...); }) , (;) )
  constexpr bool isRecordType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isRecordType, Xs...); }) , (;) )
  constexpr bool isClassType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isClassType, Xs...); }) , (;) )
  constexpr bool isStructureType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isStructureType, Xs...); }) , (;) )
  constexpr bool isObjCBoxableRecordType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCBoxableRecordType, Xs...); }) , (;) )
  constexpr bool isInterfaceType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isInterfaceType, Xs...); }) , (;) )
  constexpr bool isStructureOrClassType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isStructureOrClassType, Xs...); }) , (;) )
  constexpr bool isUnionType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isUnionType, Xs...); }) , (;) )
  constexpr bool isReflectedType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isReflectedType, Xs...); }) , (;) )
  constexpr bool isComplexIntegerType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isComplexIntegerType, Xs...); }) , (;) )
  constexpr bool isVectorType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isVectorType, Xs...); }) , (;) )
  constexpr bool isExtVectorType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isExtVectorType, Xs...); }) , (;) )
  constexpr bool isDependentAddressSpaceType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isDependentAddressSpaceType, Xs...); }) , (;) )
  constexpr bool isObjCObjectPointerType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCObjectPointerType, Xs...); }) , (;) )
  constexpr bool isObjCRetainableType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCRetainableType, Xs...); }) , (;) )
  constexpr bool isObjCLifetimeType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCLifetimeType, Xs...); }) , (;) )
  constexpr bool isObjCIndirectLifetimeType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCIndirectLifetimeType, Xs...); }) , (;) )
  constexpr bool isObjCNSObjectType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCNSObjectType, Xs...); }) , (;) )
  constexpr bool isObjCIndependentClassType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCIndependentClassType, Xs...); }) , (;) )
  constexpr bool isObjCObjectType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCObjectType, Xs...); }) , (;) )
  constexpr bool isObjCQualifiedInterfaceType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCQualifiedInterfaceType, Xs...); }) , (;) )
  constexpr bool isObjCQualifiedIdType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCQualifiedIdType, Xs...); }) , (;) )
  constexpr bool isObjCQualifiedClassType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCQualifiedClassType, Xs...); }) , (;) )
  constexpr bool isObjCObjectOrInterfaceType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCObjectOrInterfaceType, Xs...); }) , (;) )
  constexpr bool isObjCIdType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCIdType, Xs...); }) , (;) )
  constexpr bool isObjCInertUnsafeUnretainedType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCInertUnsafeUnretainedType, Xs...); }) , (;) )
  /// Whether the type is Objective-C 'id' or a __kindof type of an
  /// object type, e.g., __kindof NSView * or __kindof id
  /// <NSCopying>.
  ///
  /// \param bound Will be set to the bound on non-id subtype types,
  /// which will be (possibly specialized) Objective-C class type, or
  /// null for 'id.
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  constexpr bool isObjCIdOrObjectKindOfType(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) ctx, IFMETA_ELSE((const clang::ObjCObjectType::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::clang::ObjCObjectType *&)) bound) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCIdOrObjectKindOfType, Xs..., Y0s..., Y1s...); }) , (;) )
  constexpr bool isObjCClassType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCClassType, Xs...); }) , (;) )
  /// Whether the type is Objective-C 'Class' or a __kindof type of an
  /// Class type, e.g., __kindof Class <NSCopying>.
  ///
  /// Unlike \c isObjCIdOrObjectKindOfType, there is no relevant bound
  /// here because Objective-C's type system cannot express "a class
  /// object for a subclass of NSFoo".
  constexpr bool isObjCClassOrClassKindOfType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCClassOrClassKindOfType, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isBlockCompatibleObjCPointerType(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (typename meta::clang::ASTContext &)) ctx) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isBlockCompatibleObjCPointerType, Xs..., Y0s...); }) , (;) )
  constexpr bool isObjCSelType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCSelType, Xs...); }) , (;) )
  constexpr bool isObjCBuiltinType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCBuiltinType, Xs...); }) , (;) )
  constexpr bool isObjCARCBridgableType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCARCBridgableType, Xs...); }) , (;) )
  constexpr bool isCARCBridgableType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isCARCBridgableType, Xs...); }) , (;) )
  constexpr bool isTemplateTypeParmType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isTemplateTypeParmType, Xs...); }) , (;) )
  constexpr bool isNullPtrType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isNullPtrType, Xs...); }) , (;) )
  constexpr bool isAlignValT() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isAlignValT, Xs...); }) , (;) )
  constexpr bool isStdByteType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isStdByteType, Xs...); }) , (;) )
  constexpr bool isAtomicType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isAtomicType, Xs...); }) , (;) )
  constexpr bool isOCLImage1dROType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage1dROType, Xs...); }) , (;) )
  constexpr bool isOCLImage1dArrayROType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage1dArrayROType, Xs...); }) , (;) )
  constexpr bool isOCLImage1dBufferROType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage1dBufferROType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dROType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dROType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dArrayROType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dArrayROType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dDepthROType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dDepthROType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dArrayDepthROType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dArrayDepthROType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dMSAAROType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dMSAAROType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dArrayMSAAROType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dArrayMSAAROType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dMSAADepthROType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dMSAADepthROType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dArrayMSAADepthROType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dArrayMSAADepthROType, Xs...); }) , (;) )
  constexpr bool isOCLImage3dROType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage3dROType, Xs...); }) , (;) )
  constexpr bool isOCLImage1dWOType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage1dWOType, Xs...); }) , (;) )
  constexpr bool isOCLImage1dArrayWOType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage1dArrayWOType, Xs...); }) , (;) )
  constexpr bool isOCLImage1dBufferWOType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage1dBufferWOType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dWOType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dWOType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dArrayWOType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dArrayWOType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dDepthWOType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dDepthWOType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dArrayDepthWOType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dArrayDepthWOType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dMSAAWOType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dMSAAWOType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dArrayMSAAWOType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dArrayMSAAWOType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dMSAADepthWOType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dMSAADepthWOType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dArrayMSAADepthWOType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dArrayMSAADepthWOType, Xs...); }) , (;) )
  constexpr bool isOCLImage3dWOType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage3dWOType, Xs...); }) , (;) )
  constexpr bool isOCLImage1dRWType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage1dRWType, Xs...); }) , (;) )
  constexpr bool isOCLImage1dArrayRWType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage1dArrayRWType, Xs...); }) , (;) )
  constexpr bool isOCLImage1dBufferRWType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage1dBufferRWType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dRWType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dRWType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dArrayRWType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dArrayRWType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dDepthRWType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dDepthRWType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dArrayDepthRWType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dArrayDepthRWType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dMSAARWType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dMSAARWType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dArrayMSAARWType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dArrayMSAARWType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dMSAADepthRWType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dMSAADepthRWType, Xs...); }) , (;) )
  constexpr bool isOCLImage2dArrayMSAADepthRWType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage2dArrayMSAADepthRWType, Xs...); }) , (;) )
  constexpr bool isOCLImage3dRWType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOCLImage3dRWType, Xs...); }) , (;) )
  constexpr bool isImageType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isImageType, Xs...); }) , (;) )
  constexpr bool isSamplerT() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isSamplerT, Xs...); }) , (;) )
  constexpr bool isEventT() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isEventT, Xs...); }) , (;) )
  constexpr bool isClkEventT() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isClkEventT, Xs...); }) , (;) )
  constexpr bool isQueueT() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isQueueT, Xs...); }) , (;) )
  constexpr bool isReserveIDT() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isReserveIDT, Xs...); }) , (;) )
  constexpr bool isPipeType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isPipeType, Xs...); }) , (;) )
  constexpr bool isOpenCLSpecificType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOpenCLSpecificType, Xs...); }) , (;) )
  /// Determines if this type, which must satisfy
  /// isObjCLifetimeType(), is implicitly __unsafe_unretained rather
  /// than implicitly __strong.
  constexpr bool isObjCARCImplicitlyUnretainedType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isObjCARCImplicitlyUnretainedType, Xs...); }) , (;) )
  /// Return the implicit lifetime for this type, which must not be dependent.
  constexpr enum clang::Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const IFMETA_ELSE( ({    return (enum clang::Qualifiers::ObjCLifetime)__reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getObjCARCImplicitLifetime, Xs...); }) , (;) )
  using ScalarTypeKind = enum refldetail::clang::Type::ScalarTypeKind;
  /// Given that this is a scalar type, classify it.
  constexpr enum clang::Type::ScalarTypeKind getScalarTypeKind() const IFMETA_ELSE( ({    return (enum clang::Type::ScalarTypeKind)__reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getScalarTypeKind, Xs...); }) , (;) )
  /// Whether this type is a dependent type, meaning that its definition
  /// somehow depends on a template parameter (C++ [temp.dep.type]).
  constexpr bool isDependentType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isDependentType, Xs...); }) , (;) )
  /// Determine whether this type is an instantiation-dependent type,
  /// meaning that the type involves a template parameter (even if the
  /// definition does not actually depend on the type substituted for that
  /// template parameter).
  constexpr bool isInstantiationDependentType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isInstantiationDependentType, Xs...); }) , (;) )
  /// Determine whether this type is an undeduced type, meaning that
  /// it somehow involves a C++11 'auto' type or similar which has not yet been
  /// deduced.
  constexpr bool isUndeducedType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isUndeducedType, Xs...); }) , (;) )
  /// Whether this type is a variably-modified type (C99 6.7.5).
  constexpr bool isVariablyModifiedType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isVariablyModifiedType, Xs...); }) , (;) )
  /// Whether this type involves a variable-length array type
  /// with a definite size.
  constexpr bool hasSizedVLAType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::hasSizedVLAType, Xs...); }) , (;) )
  /// Whether this type is or contains a local or unnamed type.
  constexpr bool hasUnnamedOrLocalType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::hasUnnamedOrLocalType, Xs...); }) , (;) )
  constexpr bool isOverloadableType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isOverloadableType, Xs...); }) , (;) )
  /// Determine wither this type is a C++ elaborated-type-specifier.
  constexpr bool isElaboratedTypeSpecifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isElaboratedTypeSpecifier, Xs...); }) , (;) )
  constexpr bool canDecayToPointerType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::canDecayToPointerType, Xs...); }) , (;) )
  /// Whether this type is represented natively as a pointer.  This includes
  /// pointers, references, block pointers, and Objective-C interface,
  /// qualified id, and qualified interface types, as well as nullptr_t.
  constexpr bool hasPointerRepresentation() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::hasPointerRepresentation, Xs...); }) , (;) )
  /// Whether this type can represent an objective pointer type for the
  /// purpose of GC'ability
  constexpr bool hasObjCPointerRepresentation() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::hasObjCPointerRepresentation, Xs...); }) , (;) )
  /// Determine whether this type has an integer representation
  /// of some sort, e.g., it is an integer type or a vector.
  constexpr bool hasIntegerRepresentation() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::hasIntegerRepresentation, Xs...); }) , (;) )
  /// Determine whether this type has an signed integer representation
  /// of some sort, e.g., it is an signed integer type or a vector.
  constexpr bool hasSignedIntegerRepresentation() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::hasSignedIntegerRepresentation, Xs...); }) , (;) )
  /// Determine whether this type has an unsigned integer representation
  /// of some sort, e.g., it is an unsigned integer type or a vector.
  constexpr bool hasUnsignedIntegerRepresentation() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::hasUnsignedIntegerRepresentation, Xs...); }) , (;) )
  /// Determine whether this type has a floating-point representation
  /// of some sort, e.g., it is a floating-point type or a vector thereof.
  constexpr bool hasFloatingRepresentation() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::hasFloatingRepresentation, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::RecordType *) )
  getAsStructureType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getAsStructureType, Xs...); }) , (;) )
  /// NOTE: getAs*ArrayType are methods on ASTContext.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::RecordType *) )
  getAsUnionType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getAsUnionType, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::ComplexType *) )
  getAsComplexIntegerType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getAsComplexIntegerType, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::ObjCObjectType *) )
  getAsObjCInterfaceType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getAsObjCInterfaceType, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::ObjCObjectPointerType *) )
  getAsObjCInterfacePointerType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getAsObjCInterfacePointerType, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::ObjCObjectPointerType *) )
  getAsObjCQualifiedIdType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getAsObjCQualifiedIdType, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::ObjCObjectPointerType *) )
  getAsObjCQualifiedClassType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getAsObjCQualifiedClassType, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::ObjCObjectType *) )
  getAsObjCQualifiedInterfaceType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getAsObjCQualifiedInterfaceType, Xs...); }) , (;) )
  /// Retrieves the CXXRecordDecl that this type refers to, either
  /// because the type is a RecordType or because it is the injected-class-name
  /// type of a class template or class template partial specialization.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::CXXRecordDecl *) )
  getAsCXXRecordDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getAsCXXRecordDecl, Xs...); }) , (;) )
  /// Retrieves the RecordDecl this type refers to.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::RecordDecl *) )
  getAsRecordDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getAsRecordDecl, Xs...); }) , (;) )
  /// Retrieves the TagDecl that this type refers to, either
  /// because the type is a TagType or because it is the injected-class-name
  /// type of a class template or class template partial specialization.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TagDecl *) )
  getAsTagDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getAsTagDecl, Xs...); }) , (;) )
  /// If this is a pointer or reference to a RecordType, return the
  /// CXXRecordDecl that the type refers to.
  ///
  /// If this is not a pointer or reference, or the type being pointed to does
  /// not refer to a CXXRecordDecl, returns NULL.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::CXXRecordDecl *) )
  getPointeeCXXRecordDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getPointeeCXXRecordDecl, Xs...); }) , (;) )
  /// Get the DeducedType whose type will be deduced for a variable with
  /// an initializer of this type. This looks through declarators like pointer
  /// types, but not through decltype or typedefs.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::DeducedType *) )
  getContainedDeducedType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getContainedDeducedType, Xs...); }) , (;) )
  /// Get the AutoType whose type will be deduced for a variable with
  /// an initializer of this type. This looks through declarators like pointer
  /// types, but not through decltype or typedefs.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::AutoType *) )
  getContainedAutoType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getContainedAutoType, Xs...); }) , (;) )
  /// Determine whether this type was written with a leading 'auto'
  /// corresponding to a trailing return type (possibly for a nested
  /// function type within a pointer to function type or similar).
  constexpr bool hasAutoForTrailingReturnType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::hasAutoForTrailingReturnType, Xs...); }) , (;) )
  /// A variant of getAs<> for array types which silently discards
  /// qualifiers from the outermost type.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::ArrayType *) )
  getAsArrayTypeUnsafe() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getAsArrayTypeUnsafe, Xs...); }) , (;) )
  /// A variant of castAs<> for array type which silently discards
  /// qualifiers from the outermost type.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::ArrayType *) )
  castAsArrayTypeUnsafe() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::castAsArrayTypeUnsafe, Xs...); }) , (;) )
  /// Get the base element type of this type, potentially discarding type
  /// qualifiers.  This should never be used when type qualifiers
  /// are meaningful.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::Type *) )
  getBaseElementTypeUnsafe() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getBaseElementTypeUnsafe, Xs...); }) , (;) )
  /// If this is an array type, return the element type of the array,
  /// potentially with type qualifiers missing.
  /// This should never be used when type qualifiers are meaningful.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::Type *) )
  getArrayElementTypeNoTypeQual() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getArrayElementTypeNoTypeQual, Xs...); }) , (;) )
  /// If this is a pointer type, return the pointee type.
  /// If this is an array type, return the array element type.
  /// This should never be used when type qualifiers are meaningful.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::Type *) )
  getPointeeOrArrayElementType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getPointeeOrArrayElementType, Xs...); }) , (;) )
  /// If this is a pointer, ObjC object pointer, or block
  /// pointer, this returns the respective pointee.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getPointeeType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getPointeeType, Xs...); }) , (;) )
  /// Return the specified type with any "sugar" removed from the type,
  /// removing any typedefs, typeofs, etc., as well as any qualifiers.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::Type *) )
  getUnqualifiedDesugaredType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getUnqualifiedDesugaredType, Xs...); }) , (;) )
  /// More type predicates useful for type checking/promotion
  constexpr bool isPromotableIntegerType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isPromotableIntegerType, Xs...); }) , (;) )
  /// Return true if this is an integer type that is
  /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
  /// or an enum decl which has a signed representation.
  constexpr bool isSignedIntegerType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isSignedIntegerType, Xs...); }) , (;) )
  /// Return true if this is an integer type that is
  /// unsigned, according to C99 6.2.5p6 [which returns true for _Bool],
  /// or an enum decl which has an unsigned representation.
  constexpr bool isUnsignedIntegerType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isUnsignedIntegerType, Xs...); }) , (;) )
  /// Determines whether this is an integer type that is signed or an
  /// enumeration types whose underlying type is a signed integer type.
  constexpr bool isSignedIntegerOrEnumerationType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isSignedIntegerOrEnumerationType, Xs...); }) , (;) )
  /// Determines whether this is an integer type that is unsigned or an
  /// enumeration types whose underlying type is a unsigned integer type.
  constexpr bool isUnsignedIntegerOrEnumerationType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isUnsignedIntegerOrEnumerationType, Xs...); }) , (;) )
  /// Return true if this is a fixed point type according to
  /// ISO/IEC JTC1 SC22 WG14 N1169.
  constexpr bool isFixedPointType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isFixedPointType, Xs...); }) , (;) )
  /// Return true if this is a saturated fixed point type according to
  /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
  constexpr bool isSaturatedFixedPointType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isSaturatedFixedPointType, Xs...); }) , (;) )
  /// Return true if this is a saturated fixed point type according to
  /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
  constexpr bool isUnsaturatedFixedPointType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isUnsaturatedFixedPointType, Xs...); }) , (;) )
  /// Return true if this is a fixed point type that is signed according
  /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
  constexpr bool isSignedFixedPointType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isSignedFixedPointType, Xs...); }) , (;) )
  /// Return true if this is a fixed point type that is unsigned according
  /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
  constexpr bool isUnsignedFixedPointType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isUnsignedFixedPointType, Xs...); }) , (;) )
  /// Return true if this is not a variable sized type,
  /// according to the rules of C99 6.7.5p3.  It is not legal to call this on
  /// incomplete types.
  constexpr bool isConstantSizeType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isConstantSizeType, Xs...); }) , (;) )
  /// Returns true if this type can be represented by some
  /// set of type specifiers.
  constexpr bool isSpecifierType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isSpecifierType, Xs...); }) , (;) )
  /// Determine the linkage of this type.
  constexpr enum clang::Linkage getLinkage() const IFMETA_ELSE( ({    return (enum clang::Linkage)__reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getLinkage, Xs...); }) , (;) )
  /// Determine the visibility of this type.
  constexpr enum clang::Visibility getVisibility() const IFMETA_ELSE( ({    return (enum clang::Visibility)__reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getVisibility, Xs...); }) , (;) )
  /// Return true if the visibility was explicitly set is the code.
  constexpr bool isVisibilityExplicit() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isVisibilityExplicit, Xs...); }) , (;) )
  /// Determine the linkage and visibility of this type.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::LinkageInfo) )
  getLinkageAndVisibility() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getLinkageAndVisibility, Xs...); }) , (;) )
  /// True if the computed linkage is valid. Used for consistency
  /// checking. Should always return true.
  constexpr bool isLinkageValid() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::isLinkageValid, Xs...); }) , (;) )
  /// Determine whether the given type can have a nullability
  /// specifier applied to it, i.e., if it is any kind of pointer type.
  ///
  /// \param ResultIfUnknown The value to return if we don't yet know whether
  ///        this type can have nullability because it is dependent.
  constexpr bool canHaveNullability(bool ResultIfUnknown = true) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::canHaveNullability, Xs..., ResultIfUnknown); }) , (;) )
  /// Determines if this is an ObjC interface type that may accept type
  /// parameters.
  constexpr bool acceptsObjCTypeParams() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::acceptsObjCTypeParams, Xs...); }) , (;) )
  constexpr const char * getTypeClassName() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getTypeClassName, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getCanonicalTypeInternal() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::getCanonicalTypeInternal, Xs...); }) , (;) )
  constexpr void dump() const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::dump, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void dump(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) OS) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__Type, reflenums::clang__Type::dump1, Xs..., Y0s...); }) , (;) )
};

enum clang::BuiltinType::Kind : unsigned int {
  OCLImage1dRO,
  OCLImage1dArrayRO,
  OCLImage1dBufferRO,
  OCLImage2dRO,
  OCLImage2dArrayRO,
  OCLImage2dDepthRO,
  OCLImage2dArrayDepthRO,
  OCLImage2dMSAARO,
  OCLImage2dArrayMSAARO,
  OCLImage2dMSAADepthRO,
  OCLImage2dArrayMSAADepthRO,
  OCLImage3dRO,
  OCLImage1dWO,
  OCLImage1dArrayWO,
  OCLImage1dBufferWO,
  OCLImage2dWO,
  OCLImage2dArrayWO,
  OCLImage2dDepthWO,
  OCLImage2dArrayDepthWO,
  OCLImage2dMSAAWO,
  OCLImage2dArrayMSAAWO,
  OCLImage2dMSAADepthWO,
  OCLImage2dArrayMSAADepthWO,
  OCLImage3dWO,
  OCLImage1dRW,
  OCLImage1dArrayRW,
  OCLImage1dBufferRW,
  OCLImage2dRW,
  OCLImage2dArrayRW,
  OCLImage2dDepthRW,
  OCLImage2dArrayDepthRW,
  OCLImage2dMSAARW,
  OCLImage2dArrayMSAARW,
  OCLImage2dMSAADepthRW,
  OCLImage2dArrayMSAADepthRW,
  OCLImage3dRW,
  Void,
  Bool,
  Char_U,
  UChar,
  WChar_U,
  Char8,
  Char16,
  Char32,
  UShort,
  UInt,
  ULong,
  ULongLong,
  UInt128,
  Char_S,
  SChar,
  WChar_S,
  Short,
  Int,
  Long,
  LongLong,
  Int128,
  ShortAccum,
  Accum,
  LongAccum,
  UShortAccum,
  UAccum,
  ULongAccum,
  ShortFract,
  Fract,
  LongFract,
  UShortFract,
  UFract,
  ULongFract,
  SatShortAccum,
  SatAccum,
  SatLongAccum,
  SatUShortAccum,
  SatUAccum,
  SatULongAccum,
  SatShortFract,
  SatFract,
  SatLongFract,
  SatUShortFract,
  SatUFract,
  SatULongFract,
  Half,
  Float,
  Double,
  LongDouble,
  Float16,
  Float128,
  NullPtr,
  ObjCId,
  ObjCClass,
  ObjCSel,
  OCLSampler,
  OCLEvent,
  OCLClkEvent,
  OCLQueue,
  OCLReserveID,
  Dependent,
  Overload,
  BoundMember,
  PseudoObject,
  UnknownAny,
  BuiltinFn,
  ARCUnbridgedCast,
  OMPArraySection,
  LastKind = 103,
};

/// This class is used for builtin types like 'int'.  Builtin
/// types are always canonical and have a literal name field.
M_template_rtpack(Xs)
struct clang::BuiltinType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__BuiltinType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::BuiltinType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  using Kind = enum refldetail::clang::BuiltinType::Kind;
  constexpr enum clang::BuiltinType::Kind getKind() const IFMETA_ELSE( ({    return (enum clang::BuiltinType::Kind)__reflect_prop(reflenums::RK_clang__BuiltinType, reflenums::clang__BuiltinType::getKind, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr const char * getName(IFMETA_ELSE((const clang::PrintingPolicy::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::PrintingPolicy &)) Policy) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__BuiltinType, reflenums::clang__BuiltinType::getName, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr const char * getNameAsCString(IFMETA_ELSE((const clang::PrintingPolicy::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::PrintingPolicy &)) Policy) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__BuiltinType, reflenums::clang__BuiltinType::getNameAsCString, Xs..., Y0s...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__BuiltinType, reflenums::clang__BuiltinType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__BuiltinType, reflenums::clang__BuiltinType::desugar, Xs...); }) , (;) )
  constexpr bool isInteger() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__BuiltinType, reflenums::clang__BuiltinType::isInteger, Xs...); }) , (;) )
  constexpr bool isSignedInteger() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__BuiltinType, reflenums::clang__BuiltinType::isSignedInteger, Xs...); }) , (;) )
  constexpr bool isUnsignedInteger() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__BuiltinType, reflenums::clang__BuiltinType::isUnsignedInteger, Xs...); }) , (;) )
  constexpr bool isFloatingPoint() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__BuiltinType, reflenums::clang__BuiltinType::isFloatingPoint, Xs...); }) , (;) )
  /// Determines whether the given kind corresponds to a placeholder type.
  static constexpr bool isPlaceholderTypeKind(enum clang::BuiltinType::Kind K) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__BuiltinType, reflenums::clang__BuiltinType::isPlaceholderTypeKind, Xs..., K); }) , (;) )
  /// Determines whether this type is a placeholder type, i.e. a type
  /// which cannot appear in arbitrary positions in a fully-formed
  /// expression.
  constexpr bool isPlaceholderType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__BuiltinType, reflenums::clang__BuiltinType::isPlaceholderType, Xs...); }) , (;) )
  /// Determines whether this type is a placeholder type other than
  /// Overload.  Most placeholder types require only syntactic
  /// information about their context in order to be resolved (e.g.
  /// whether it is a call expression), which means they can (and
  /// should) be resolved in an earlier "phase" of analysis.
  /// Overload expressions sometimes pick up further information
  /// from their context, like whether the context expects a
  /// specific function-pointer type, and so frequently need
  /// special treatment.
  constexpr bool isNonOverloadPlaceholderType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__BuiltinType, reflenums::clang__BuiltinType::isNonOverloadPlaceholderType, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__BuiltinType, reflenums::clang__BuiltinType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Complex values, per C99 6.2.5p11.  This supports the C99 complex
/// types (_Complex float etc) as well as the GCC integer complex extensions.
M_template_rtpack(Xs)
struct clang::ComplexType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__ComplexType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::ComplexType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getElementType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ComplexType, reflenums::clang__ComplexType::getElementType, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ComplexType, reflenums::clang__ComplexType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ComplexType, reflenums::clang__ComplexType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::QualType)) Element) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__ComplexType, reflenums::clang__ComplexType::Profile, Xs..., Y0s..., Y1s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ComplexType, reflenums::clang__ComplexType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Sugar for parentheses used when specifying types.
M_template_rtpack(Xs)
struct clang::ParenType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__ParenType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::ParenType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getInnerType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ParenType, reflenums::clang__ParenType::getInnerType, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ParenType, reflenums::clang__ParenType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ParenType, reflenums::clang__ParenType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::QualType)) Inner) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__ParenType, reflenums::clang__ParenType::Profile, Xs..., Y0s..., Y1s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ParenType, reflenums::clang__ParenType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// PointerType - C99 6.7.5.1 - Pointer Declarators.
M_template_rtpack(Xs)
struct clang::PointerType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__PointerType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::PointerType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getPointeeType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PointerType, reflenums::clang__PointerType::getPointeeType, Xs...); }) , (;) )
  /// Returns true if address spaces of pointers overlap.
  /// OpenCL v2.0 defines conversion rules for pointers to different
  /// address spaces (OpenCLC v2.0 s6.5.5) and notion of overlapping
  /// address spaces.
  /// CL1.1 or CL1.2:
  ///   address spaces overlap iff they are they same.
  /// CL2.0 adds:
  ///   __generic overlaps with any address space except for __constant.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool isAddressSpaceOverlapping(IFMETA_ELSE((const clang::PointerType::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::PointerType &)) other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PointerType, reflenums::clang__PointerType::isAddressSpaceOverlapping, Xs..., Y0s...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PointerType, reflenums::clang__PointerType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PointerType, reflenums::clang__PointerType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::QualType)) Pointee) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__PointerType, reflenums::clang__PointerType::Profile, Xs..., Y0s..., Y1s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__PointerType, reflenums::clang__PointerType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Represents a type which was implicitly adjusted by the semantic
/// engine for arbitrary reasons.  For example, array and function types can
/// decay, and function types can have their calling conventions adjusted.
M_template_rtpack(Xs)
struct clang::AdjustedType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__AdjustedType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::AdjustedType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getOriginalType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__AdjustedType, reflenums::clang__AdjustedType::getOriginalType, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getAdjustedType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__AdjustedType, reflenums::clang__AdjustedType::getAdjustedType, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__AdjustedType, reflenums::clang__AdjustedType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__AdjustedType, reflenums::clang__AdjustedType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::QualType)) Orig, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y2s...>), (typename meta::clang::QualType)) New) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__AdjustedType, reflenums::clang__AdjustedType::Profile, Xs..., Y0s..., Y1s..., Y2s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__AdjustedType, reflenums::clang__AdjustedType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Represents a pointer type decayed from an array or function type.
M_template_rtpack(Xs)
struct clang::DecayedType::impl : impl_offset_t<clang::AdjustedType, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DecayedType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DecayedType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getDecayedType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DecayedType, reflenums::clang__DecayedType::getDecayedType, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getPointeeType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DecayedType, reflenums::clang__DecayedType::getPointeeType, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DecayedType, reflenums::clang__DecayedType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Pointer to a block type.
/// This type is to represent types syntactically represented as
/// "void (^)(int)", etc. Pointee is required to always be a function type.
M_template_rtpack(Xs)
struct clang::BlockPointerType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__BlockPointerType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::BlockPointerType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getPointeeType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__BlockPointerType, reflenums::clang__BlockPointerType::getPointeeType, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__BlockPointerType, reflenums::clang__BlockPointerType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__BlockPointerType, reflenums::clang__BlockPointerType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::QualType)) Pointee) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__BlockPointerType, reflenums::clang__BlockPointerType::Profile, Xs..., Y0s..., Y1s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__BlockPointerType, reflenums::clang__BlockPointerType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Base for LValueReferenceType and RValueReferenceType
M_template_rtpack(Xs)
struct clang::ReferenceType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__ReferenceType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::ReferenceType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr bool isSpelledAsLValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ReferenceType, reflenums::clang__ReferenceType::isSpelledAsLValue, Xs...); }) , (;) )
  constexpr bool isInnerRef() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ReferenceType, reflenums::clang__ReferenceType::isInnerRef, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getPointeeTypeAsWritten() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ReferenceType, reflenums::clang__ReferenceType::getPointeeTypeAsWritten, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getPointeeType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ReferenceType, reflenums::clang__ReferenceType::getPointeeType, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::QualType)) Referencee, bool SpelledAsLValue) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__ReferenceType, reflenums::clang__ReferenceType::Profile, Xs..., Y0s..., Y1s..., SpelledAsLValue); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ReferenceType, reflenums::clang__ReferenceType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// An lvalue reference type, per C++11 [dcl.ref].
M_template_rtpack(Xs)
struct clang::LValueReferenceType::impl : impl_offset_t<clang::ReferenceType, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__LValueReferenceType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::LValueReferenceType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__LValueReferenceType, reflenums::clang__LValueReferenceType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__LValueReferenceType, reflenums::clang__LValueReferenceType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__LValueReferenceType, reflenums::clang__LValueReferenceType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// An rvalue reference type, per C++11 [dcl.ref].
M_template_rtpack(Xs)
struct clang::RValueReferenceType::impl : impl_offset_t<clang::ReferenceType, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__RValueReferenceType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::RValueReferenceType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__RValueReferenceType, reflenums::clang__RValueReferenceType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__RValueReferenceType, reflenums::clang__RValueReferenceType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__RValueReferenceType, reflenums::clang__RValueReferenceType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// A pointer to member type per C++ 8.3.3 - Pointers to members.
///
/// This includes both pointers to data members and pointer to member functions.
M_template_rtpack(Xs)
struct clang::MemberPointerType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__MemberPointerType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::MemberPointerType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getPointeeType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__MemberPointerType, reflenums::clang__MemberPointerType::getPointeeType, Xs...); }) , (;) )
  /// Returns true if the member type (i.e. the pointee type) is a
  /// function type rather than a data-member type.
  constexpr bool isMemberFunctionPointer() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__MemberPointerType, reflenums::clang__MemberPointerType::isMemberFunctionPointer, Xs...); }) , (;) )
  /// Returns true if the member type (i.e. the pointee type) is a
  /// data type rather than a function type.
  constexpr bool isMemberDataPointer() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__MemberPointerType, reflenums::clang__MemberPointerType::isMemberDataPointer, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::Type *) )
  getClass() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__MemberPointerType, reflenums::clang__MemberPointerType::getClass, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::CXXRecordDecl *) )
  getMostRecentCXXRecordDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__MemberPointerType, reflenums::clang__MemberPointerType::getMostRecentCXXRecordDecl, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__MemberPointerType, reflenums::clang__MemberPointerType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__MemberPointerType, reflenums::clang__MemberPointerType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::QualType)) Pointee, IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y2s...> *), (const typename meta::clang::Type *)) Class) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__MemberPointerType, reflenums::clang__MemberPointerType::Profile, Xs..., Y0s..., Y1s..., Y2s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2>
  static constexpr void Profile(Y0 p0, Y1 p1, ptrwrp<Y2> p2) {
      return Profile(p0, p1, p2.get());
  }), () )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__MemberPointerType, reflenums::clang__MemberPointerType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Capture whether this is a normal array (e.g. int X[4])
/// an array with a static size (e.g. int X[static 4]), or an array
/// with a star size (e.g. int X[*]).
/// 'static' is only allowed on function parameters.
enum clang::ArrayType::ArraySizeModifier : unsigned int {
  Normal,
  Static,
  Star,
};

/// Represents an array type, per C99 6.7.5.2 - Array Declarators.
M_template_rtpack(Xs)
struct clang::ArrayType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__ArrayType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::ArrayType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  using ArraySizeModifier = enum refldetail::clang::ArrayType::ArraySizeModifier;
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getElementType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ArrayType, reflenums::clang__ArrayType::getElementType, Xs...); }) , (;) )
  constexpr enum clang::ArrayType::ArraySizeModifier getSizeModifier() const IFMETA_ELSE( ({    return (enum clang::ArrayType::ArraySizeModifier)__reflect_prop(reflenums::RK_clang__ArrayType, reflenums::clang__ArrayType::getSizeModifier, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Qualifiers) )
  getIndexTypeQualifiers() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ArrayType, reflenums::clang__ArrayType::getIndexTypeQualifiers, Xs...); }) , (;) )
  constexpr unsigned int getIndexTypeCVRQualifiers() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ArrayType, reflenums::clang__ArrayType::getIndexTypeCVRQualifiers, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ArrayType, reflenums::clang__ArrayType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Represents the canonical version of C arrays with a specified constant size.
/// For example, the canonical type for 'int A[4 + 4*100]' is a
/// ConstantArrayType where the element type is 'int' and the size is 404.
M_template_rtpack(Xs)
struct clang::ConstantArrayType::impl : impl_offset_t<clang::ArrayType, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__ConstantArrayType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::ConstantArrayType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::llvm::APInt &) )
  getSize() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ConstantArrayType, reflenums::clang__ConstantArrayType::getSize, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ConstantArrayType, reflenums::clang__ConstantArrayType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ConstantArrayType, reflenums::clang__ConstantArrayType::desugar, Xs...); }) , (;) )
  /// Determine the number of bits required to address a member of
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr unsigned int getNumAddressingBits(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Context, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::QualType)) ElementType, IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y2s...>), (const typename meta::llvm::APInt &)) NumElements) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ConstantArrayType, reflenums::clang__ConstantArrayType::getNumAddressingBits, Xs..., Y0s..., Y1s..., Y2s...); }) , (;) )
  /// Determine the maximum number of active bits that an array's size
  /// can require, which limits the maximum size of the array.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr unsigned int getMaxSizeBits(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Context) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ConstantArrayType, reflenums::clang__ConstantArrayType::getMaxSizeBits, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::QualType)) ET, IFMETA_ELSE((const llvm::APInt::template impl</*ptrorref=*/1, Y2s...>), (const typename meta::llvm::APInt &)) ArraySize, enum clang::ArrayType::ArraySizeModifier SizeMod, unsigned int TypeQuals) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__ConstantArrayType, reflenums::clang__ConstantArrayType::Profile, Xs..., Y0s..., Y1s..., Y2s..., SizeMod, TypeQuals); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ConstantArrayType, reflenums::clang__ConstantArrayType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Represents a C array with an unspecified size.  For example 'int A[]' has
/// an IncompleteArrayType where the element type is 'int' and the size is
/// unspecified.
M_template_rtpack(Xs)
struct clang::IncompleteArrayType::impl : impl_offset_t<clang::ArrayType, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__IncompleteArrayType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::IncompleteArrayType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IncompleteArrayType, reflenums::clang__IncompleteArrayType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IncompleteArrayType, reflenums::clang__IncompleteArrayType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__IncompleteArrayType, reflenums::clang__IncompleteArrayType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::QualType)) ET, enum clang::ArrayType::ArraySizeModifier SizeMod, unsigned int TypeQuals) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__IncompleteArrayType, reflenums::clang__IncompleteArrayType::Profile, Xs..., Y0s..., Y1s..., SizeMod, TypeQuals); }) , (;) )
};

/// Represents a C array with a specified size that is not an
/// integer-constant-expression.  For example, 'int s[x+foo()]'.
/// Since the size expression is an arbitrary expression, we store it as such.
///
/// Note: VariableArrayType's aren't uniqued (since the expressions aren't) and
/// should not be: two lexically equivalent variable array types could mean
/// different things, for example, these variables do not have the same type
/// dynamically:
///
/// void foo(int x) {
///   int Y[x];
///   ++x;
///   int Z[x];
/// }
M_template_rtpack(Xs)
struct clang::VariableArrayType::impl : impl_offset_t<clang::ArrayType, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__VariableArrayType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::VariableArrayType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Expr *) )
  getSizeExpr() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__VariableArrayType, reflenums::clang__VariableArrayType::getSizeExpr, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceRange) )
  getBracketsRange() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__VariableArrayType, reflenums::clang__VariableArrayType::getBracketsRange, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getLBracketLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__VariableArrayType, reflenums::clang__VariableArrayType::getLBracketLoc, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getRBracketLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__VariableArrayType, reflenums::clang__VariableArrayType::getRBracketLoc, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__VariableArrayType, reflenums::clang__VariableArrayType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__VariableArrayType, reflenums::clang__VariableArrayType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__VariableArrayType, reflenums::clang__VariableArrayType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Represents an array type in C++ whose size is a value-dependent expression.
///
/// For example:
/// \code
/// template<typename T, int Size>
/// class array {
///   T data[Size];
/// };
/// \endcode
///
/// For these types, we won't actually know what the array bound is
/// until template instantiation occurs, at which point this will
/// become either a ConstantArrayType or a VariableArrayType.
M_template_rtpack(Xs)
struct clang::DependentSizedArrayType::impl : impl_offset_t<clang::ArrayType, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DependentSizedArrayType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DependentSizedArrayType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Expr *) )
  getSizeExpr() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentSizedArrayType, reflenums::clang__DependentSizedArrayType::getSizeExpr, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceRange) )
  getBracketsRange() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentSizedArrayType, reflenums::clang__DependentSizedArrayType::getBracketsRange, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getLBracketLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentSizedArrayType, reflenums::clang__DependentSizedArrayType::getLBracketLoc, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getRBracketLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentSizedArrayType, reflenums::clang__DependentSizedArrayType::getRBracketLoc, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentSizedArrayType, reflenums::clang__DependentSizedArrayType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentSizedArrayType, reflenums::clang__DependentSizedArrayType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentSizedArrayType, reflenums::clang__DependentSizedArrayType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_c M_rtpack(Y3s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::clang::ASTContext &)) Context, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y2s...>), (typename meta::clang::QualType)) ET, enum clang::ArrayType::ArraySizeModifier SizeMod, unsigned int TypeQuals, IFMETA_ELSE((const clang::Expr::template impl</*ptrorref=*/1, Y3s...> *), (typename meta::clang::Expr *)) E) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DependentSizedArrayType, reflenums::clang__DependentSizedArrayType::Profile, Xs..., Y0s..., Y1s..., Y2s..., SizeMod, TypeQuals, Y3s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2, typename Y3>
  static constexpr void Profile(Y0 p0, Y1 p1, Y2 p2, enum clang::ArrayType::ArraySizeModifier p3, unsigned int p4, ptrwrp<Y3> p5) {
      return Profile(p0, p1, p2, p3, p4, p5.get());
  }), () )
};

/// Represents an extended address space qualifier where the input address space
/// value is dependent. Non-dependent address spaces are not represented with a
/// special Type subclass; they are stored on an ExtQuals node as part of a QualType.
///
/// For example:
/// \code
/// template<typename T, int AddrSpace>
/// class AddressSpace {
///   typedef T __attribute__((address_space(AddrSpace))) type;
/// }
/// \endcode
M_template_rtpack(Xs)
struct clang::DependentAddressSpaceType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DependentAddressSpaceType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DependentAddressSpaceType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Expr *) )
  getAddrSpaceExpr() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentAddressSpaceType, reflenums::clang__DependentAddressSpaceType::getAddrSpaceExpr, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getPointeeType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentAddressSpaceType, reflenums::clang__DependentAddressSpaceType::getPointeeType, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getAttributeLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentAddressSpaceType, reflenums::clang__DependentAddressSpaceType::getAttributeLoc, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentAddressSpaceType, reflenums::clang__DependentAddressSpaceType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentAddressSpaceType, reflenums::clang__DependentAddressSpaceType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentAddressSpaceType, reflenums::clang__DependentAddressSpaceType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_c M_rtpack(Y3s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::clang::ASTContext &)) Context, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y2s...>), (typename meta::clang::QualType)) PointeeType, IFMETA_ELSE((const clang::Expr::template impl</*ptrorref=*/1, Y3s...> *), (typename meta::clang::Expr *)) AddrSpaceExpr) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DependentAddressSpaceType, reflenums::clang__DependentAddressSpaceType::Profile, Xs..., Y0s..., Y1s..., Y2s..., Y3s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2, typename Y3>
  static constexpr void Profile(Y0 p0, Y1 p1, Y2 p2, ptrwrp<Y3> p3) {
      return Profile(p0, p1, p2, p3.get());
  }), () )
};

/// Represents an extended vector type where either the type or size is
/// dependent.
///
/// For example:
/// \code
/// template<typename T, int Size>
/// class vector {
///   typedef T __attribute__((ext_vector_type(Size))) type;
/// }
/// \endcode
M_template_rtpack(Xs)
struct clang::DependentSizedExtVectorType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DependentSizedExtVectorType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DependentSizedExtVectorType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Expr *) )
  getSizeExpr() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentSizedExtVectorType, reflenums::clang__DependentSizedExtVectorType::getSizeExpr, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getElementType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentSizedExtVectorType, reflenums::clang__DependentSizedExtVectorType::getElementType, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getAttributeLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentSizedExtVectorType, reflenums::clang__DependentSizedExtVectorType::getAttributeLoc, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentSizedExtVectorType, reflenums::clang__DependentSizedExtVectorType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentSizedExtVectorType, reflenums::clang__DependentSizedExtVectorType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentSizedExtVectorType, reflenums::clang__DependentSizedExtVectorType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_c M_rtpack(Y3s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::clang::ASTContext &)) Context, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y2s...>), (typename meta::clang::QualType)) ElementType, IFMETA_ELSE((const clang::Expr::template impl</*ptrorref=*/1, Y3s...> *), (typename meta::clang::Expr *)) SizeExpr) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DependentSizedExtVectorType, reflenums::clang__DependentSizedExtVectorType::Profile, Xs..., Y0s..., Y1s..., Y2s..., Y3s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2, typename Y3>
  static constexpr void Profile(Y0 p0, Y1 p1, Y2 p2, ptrwrp<Y3> p3) {
      return Profile(p0, p1, p2, p3.get());
  }), () )
};

enum clang::VectorType::VectorKind : unsigned int {
  /// not a target-specific vector type
  GenericVector,
  /// is AltiVec vector
  AltiVecVector,
  /// is AltiVec 'vector Pixel'
  AltiVecPixel,
  /// is AltiVec 'vector bool ...'
  AltiVecBool,
  /// is ARM Neon vector
  NeonVector,
  /// is ARM Neon polynomial vector
  NeonPolyVector,
};

/// Represents a GCC generic vector type. This type is created using
/// __attribute__((vector_size(n)), where "n" specifies the vector size in
/// bytes; or from an Altivec __vector or vector declaration.
/// Since the constructor takes the number of vector elements, the
/// client is responsible for converting the size into the number of elements.
M_template_rtpack(Xs)
struct clang::VectorType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__VectorType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::VectorType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  using VectorKind = enum refldetail::clang::VectorType::VectorKind;
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getElementType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__VectorType, reflenums::clang__VectorType::getElementType, Xs...); }) , (;) )
  constexpr unsigned int getNumElements() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__VectorType, reflenums::clang__VectorType::getNumElements, Xs...); }) , (;) )
  static constexpr bool isVectorSizeTooLarge(unsigned int NumElements) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__VectorType, reflenums::clang__VectorType::isVectorSizeTooLarge, Xs..., NumElements); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__VectorType, reflenums::clang__VectorType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__VectorType, reflenums::clang__VectorType::desugar, Xs...); }) , (;) )
  constexpr enum clang::VectorType::VectorKind getVectorKind() const IFMETA_ELSE( ({    return (enum clang::VectorType::VectorKind)__reflect_prop(reflenums::RK_clang__VectorType, reflenums::clang__VectorType::getVectorKind, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::QualType)) ElementType, unsigned int NumElements, enum clang::Type::TypeClass TypeClass, enum clang::VectorType::VectorKind VecKind) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__VectorType, reflenums::clang__VectorType::Profile, Xs..., Y0s..., Y1s..., NumElements, TypeClass, VecKind); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__VectorType, reflenums::clang__VectorType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Represents a vector type where either the type or size is dependent.
////
/// For example:
/// \code
/// template<typename T, int Size>
/// class vector {
///   typedef T __attribute__((vector_size(Size))) type;
/// }
/// \endcode
M_template_rtpack(Xs)
struct clang::DependentVectorType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DependentVectorType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DependentVectorType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Expr *) )
  getSizeExpr() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentVectorType, reflenums::clang__DependentVectorType::getSizeExpr, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getElementType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentVectorType, reflenums::clang__DependentVectorType::getElementType, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::SourceLocation) )
  getAttributeLoc() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentVectorType, reflenums::clang__DependentVectorType::getAttributeLoc, Xs...); }) , (;) )
  constexpr enum clang::VectorType::VectorKind getVectorKind() const IFMETA_ELSE( ({    return (enum clang::VectorType::VectorKind)__reflect_prop(reflenums::RK_clang__DependentVectorType, reflenums::clang__DependentVectorType::getVectorKind, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentVectorType, reflenums::clang__DependentVectorType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentVectorType, reflenums::clang__DependentVectorType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentVectorType, reflenums::clang__DependentVectorType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_c M_rtpack(Y3s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::clang::ASTContext &)) Context, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y2s...>), (typename meta::clang::QualType)) ElementType, IFMETA_ELSE((const clang::Expr::template impl</*ptrorref=*/1, Y3s...> *), (const typename meta::clang::Expr *)) SizeExpr, enum clang::VectorType::VectorKind VecKind) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DependentVectorType, reflenums::clang__DependentVectorType::Profile, Xs..., Y0s..., Y1s..., Y2s..., Y3s..., VecKind); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2, typename Y3>
  static constexpr void Profile(Y0 p0, Y1 p1, Y2 p2, ptrwrp<Y3> p3, enum clang::VectorType::VectorKind p4) {
      return Profile(p0, p1, p2, p3.get(), p4);
  }), () )
};

/// ExtVectorType - Extended vector type. This type is created using
/// __attribute__((ext_vector_type(n)), where "n" is the number of elements.
/// Unlike vector_size, ext_vector_type is only allowed on typedef's. This
/// class enables syntactic extensions, like Vector Components for accessing
/// points (as .xyzw), colors (as .rgba), and textures (modeled after OpenGL
/// Shading Language).
M_template_rtpack(Xs)
struct clang::ExtVectorType::impl : impl_offset_t<clang::VectorType, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__ExtVectorType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::ExtVectorType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  static constexpr int getPointAccessorIdx(char c) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ExtVectorType, reflenums::clang__ExtVectorType::getPointAccessorIdx, Xs..., c); }) , (;) )
  static constexpr int getNumericAccessorIdx(char c) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ExtVectorType, reflenums::clang__ExtVectorType::getNumericAccessorIdx, Xs..., c); }) , (;) )
  static constexpr int getAccessorIdx(char c, bool isNumericAccessor) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ExtVectorType, reflenums::clang__ExtVectorType::getAccessorIdx, Xs..., c, isNumericAccessor); }) , (;) )
  constexpr bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ExtVectorType, reflenums::clang__ExtVectorType::isAccessorWithinNumElements, Xs..., c, isNumericAccessor); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ExtVectorType, reflenums::clang__ExtVectorType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ExtVectorType, reflenums::clang__ExtVectorType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ExtVectorType, reflenums::clang__ExtVectorType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// FunctionType - C99 6.7.5.3 - Function Declarators.  This is the common base
/// class of FunctionNoProtoType and FunctionProtoType.
M_template_rtpack(Xs)
struct clang::FunctionType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__FunctionType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::FunctionType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  M_template_rtpack(Zs) using ExtInfo = struct refldetail::clang::FunctionType::ExtInfo::M_template impl M_targpack(Zs);
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getReturnType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType, reflenums::clang__FunctionType::getReturnType, Xs...); }) , (;) )
  constexpr bool getHasRegParm() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType, reflenums::clang__FunctionType::getHasRegParm, Xs...); }) , (;) )
  constexpr unsigned int getRegParmType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType, reflenums::clang__FunctionType::getRegParmType, Xs...); }) , (;) )
  /// Determine whether this function type includes the GNU noreturn
  /// attribute. The C++11 [[noreturn]] attribute does not affect the function
  /// type.
  constexpr bool getNoReturnAttr() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType, reflenums::clang__FunctionType::getNoReturnAttr, Xs...); }) , (;) )
  constexpr enum clang::CallingConv getCallConv() const IFMETA_ELSE( ({    return (enum clang::CallingConv)__reflect_prop(reflenums::RK_clang__FunctionType, reflenums::clang__FunctionType::getCallConv, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FunctionType::ExtInfo) )
  getExtInfo() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType, reflenums::clang__FunctionType::getExtInfo, Xs...); }) , (;) )
  constexpr bool isConst() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType, reflenums::clang__FunctionType::isConst, Xs...); }) , (;) )
  constexpr bool isVolatile() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType, reflenums::clang__FunctionType::isVolatile, Xs...); }) , (;) )
  constexpr bool isRestrict() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType, reflenums::clang__FunctionType::isRestrict, Xs...); }) , (;) )
  /// Determine the type of an expression that calls a function of
  /// this type.
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getCallResultType(IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y0s...>), (const typename meta::clang::ASTContext &)) Context) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType, reflenums::clang__FunctionType::getCallResultType, Xs..., Y0s...); }) , (;) )
  static constexpr const char * getNameForCallConv(enum clang::CallingConv CC) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType, reflenums::clang__FunctionType::getNameForCallConv, Xs..., CC); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType, reflenums::clang__FunctionType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// A class which abstracts out some details necessary for
  /// making a call.
  ///
  /// It is not actually used directly for storing this information in
  /// a FunctionType, although FunctionType does currently use the
  /// same bit-pattern.
  ///
M_template_rtpack(Xs)
struct clang::FunctionType::ExtInfo::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__FunctionType__ExtInfo;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::FunctionType::ExtInfo::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr bool getNoReturn() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType__ExtInfo, reflenums::clang__FunctionType__ExtInfo::getNoReturn, Xs...); }) , (;) )
  constexpr bool getProducesResult() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType__ExtInfo, reflenums::clang__FunctionType__ExtInfo::getProducesResult, Xs...); }) , (;) )
  constexpr bool getNoCallerSavedRegs() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType__ExtInfo, reflenums::clang__FunctionType__ExtInfo::getNoCallerSavedRegs, Xs...); }) , (;) )
  constexpr bool getNoCfCheck() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType__ExtInfo, reflenums::clang__FunctionType__ExtInfo::getNoCfCheck, Xs...); }) , (;) )
  constexpr bool getHasRegParm() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType__ExtInfo, reflenums::clang__FunctionType__ExtInfo::getHasRegParm, Xs...); }) , (;) )
  constexpr unsigned int getRegParm() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType__ExtInfo, reflenums::clang__FunctionType__ExtInfo::getRegParm, Xs...); }) , (;) )
  constexpr enum clang::CallingConv getCC() const IFMETA_ELSE( ({    return (enum clang::CallingConv)__reflect_prop(reflenums::RK_clang__FunctionType__ExtInfo, reflenums::clang__FunctionType__ExtInfo::getCC, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator==(IFMETA_ELSE((const clang::FunctionType::ExtInfo::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::FunctionType::ExtInfo)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType__ExtInfo, reflenums::clang__FunctionType__ExtInfo::operator_eq_eq, Xs..., Y0s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr bool operator!=(IFMETA_ELSE((const clang::FunctionType::ExtInfo::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::FunctionType::ExtInfo)) Other) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType__ExtInfo, reflenums::clang__FunctionType__ExtInfo::operator_not_eq, Xs..., Y0s...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FunctionType::ExtInfo) )
  withNoReturn(bool noReturn) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType__ExtInfo, reflenums::clang__FunctionType__ExtInfo::withNoReturn, Xs..., noReturn); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FunctionType::ExtInfo) )
  withProducesResult(bool producesResult) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType__ExtInfo, reflenums::clang__FunctionType__ExtInfo::withProducesResult, Xs..., producesResult); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FunctionType::ExtInfo) )
  withNoCallerSavedRegs(bool noCallerSavedRegs) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType__ExtInfo, reflenums::clang__FunctionType__ExtInfo::withNoCallerSavedRegs, Xs..., noCallerSavedRegs); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FunctionType::ExtInfo) )
  withNoCfCheck(bool noCfCheck) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType__ExtInfo, reflenums::clang__FunctionType__ExtInfo::withNoCfCheck, Xs..., noCfCheck); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FunctionType::ExtInfo) )
  withRegParm(unsigned int RegParm) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType__ExtInfo, reflenums::clang__FunctionType__ExtInfo::withRegParm, Xs..., RegParm); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FunctionType::ExtInfo) )
  withCallingConv(enum clang::CallingConv cc) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionType__ExtInfo, reflenums::clang__FunctionType__ExtInfo::withCallingConv, Xs..., cc); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__FunctionType__ExtInfo, reflenums::clang__FunctionType__ExtInfo::Profile, Xs..., Y0s...); }) , (;) )
};

/// Represents a K&R-style 'int foo()' function, which has
/// no information available about its arguments.
M_template_rtpack(Xs)
struct clang::FunctionNoProtoType::impl : impl_offset_t<clang::FunctionType, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 32 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__FunctionNoProtoType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::FunctionNoProtoType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionNoProtoType, reflenums::clang__FunctionNoProtoType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionNoProtoType, reflenums::clang__FunctionNoProtoType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::QualType)) ResultType, IFMETA_ELSE((const clang::FunctionType::ExtInfo::template impl</*ptrorref=*/0, Y2s...>), (typename meta::clang::FunctionType::ExtInfo)) Info) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__FunctionNoProtoType, reflenums::clang__FunctionNoProtoType::Profile, Xs..., Y0s..., Y1s..., Y2s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionNoProtoType, reflenums::clang__FunctionNoProtoType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Represents a prototype with parameter type info, e.g.
/// 'int foo(int)' or 'int foo(void)'.  'void' is represented as having no
/// parameters, not as having a single void parameter. Such a type can have an
/// exception specification, but this specification is not part of the canonical
/// type.
M_template_rtpack(Xs)
struct clang::FunctionProtoType::impl : impl_offset_t<clang::FunctionType, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 32 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__FunctionProtoType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::FunctionProtoType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  M_template_rtpack(Zs) using ExtParameterInfo = struct refldetail::clang::FunctionProtoType::ExtParameterInfo::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ExceptionSpecInfo = struct refldetail::clang::FunctionProtoType::ExceptionSpecInfo::M_template impl M_targpack(Zs);
  M_template_rtpack(Zs) using ExtProtoInfo = struct refldetail::clang::FunctionProtoType::ExtProtoInfo::M_template impl M_targpack(Zs);
  constexpr unsigned int getNumParams() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::getNumParams, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getParamType(unsigned int i) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::getParamType, Xs..., i); }) , (;) )
  RANGE_REFLECTION(clang::FunctionProtoType, getParamTypes,
      constexpr auto getParamTypes() const ,
      (typename meta::clang::QualType),
      (reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::getParamTypes, Xs...), () )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FunctionProtoType::ExtProtoInfo) )
  getExtProtoInfo() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::getExtProtoInfo, Xs...); }) , (;) )
  /// Get the kind of exception specification on this function.
  constexpr enum clang::ExceptionSpecificationType getExceptionSpecType() const IFMETA_ELSE( ({    return (enum clang::ExceptionSpecificationType)__reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::getExceptionSpecType, Xs...); }) , (;) )
  /// Return whether this function has any kind of exception spec.
  constexpr bool hasExceptionSpec() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::hasExceptionSpec, Xs...); }) , (;) )
  /// Return whether this function has a dynamic (throw) exception spec.
  constexpr bool hasDynamicExceptionSpec() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::hasDynamicExceptionSpec, Xs...); }) , (;) )
  /// Return whether this function has a noexcept exception spec.
  constexpr bool hasNoexceptExceptionSpec() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::hasNoexceptExceptionSpec, Xs...); }) , (;) )
  /// Return whether this function has a dependent exception spec.
  constexpr bool hasDependentExceptionSpec() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::hasDependentExceptionSpec, Xs...); }) , (;) )
  /// Return whether this function has an instantiation-dependent exception
  /// spec.
  constexpr bool hasInstantiationDependentExceptionSpec() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::hasInstantiationDependentExceptionSpec, Xs...); }) , (;) )
  constexpr unsigned int getNumExceptions() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::getNumExceptions, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getExceptionType(unsigned int i) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::getExceptionType, Xs..., i); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Expr *) )
  getNoexceptExpr() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::getNoexceptExpr, Xs...); }) , (;) )
  /// If this function type has an exception specification which hasn't
  /// been determined yet (either because it has not been evaluated or because
  /// it has not been instantiated), this is the function whose exception
  /// specification is represented by this type.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FunctionDecl *) )
  getExceptionSpecDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::getExceptionSpecDecl, Xs...); }) , (;) )
  /// If this function type has an uninstantiated exception
  /// specification, this is the function whose exception specification
  /// should be instantiated to find the exception specification for
  /// this type.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FunctionDecl *) )
  getExceptionSpecTemplate() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::getExceptionSpecTemplate, Xs...); }) , (;) )
  /// Determine whether this function type has a non-throwing exception
  /// specification.
  constexpr enum clang::CanThrowResult canThrow() const IFMETA_ELSE( ({    return (enum clang::CanThrowResult)__reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::canThrow, Xs...); }) , (;) )
  /// Determine whether this function type has a non-throwing exception
  /// specification. If this depends on template arguments, returns
  /// \c ResultIfDependent.
  constexpr bool isNothrow(bool ResultIfDependent = false) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::isNothrow, Xs..., ResultIfDependent); }) , (;) )
  constexpr bool isVariadic() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::isVariadic, Xs...); }) , (;) )
  /// Determines whether this function prototype contains a
  /// parameter pack at the end.
  ///
  /// A function template whose last parameter is a parameter pack can be
  /// called with an arbitrary number of arguments, much like a variadic
  /// function.
  constexpr bool isTemplateVariadic() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::isTemplateVariadic, Xs...); }) , (;) )
  constexpr bool hasTrailingReturn() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::hasTrailingReturn, Xs...); }) , (;) )
  constexpr unsigned int getTypeQuals() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::getTypeQuals, Xs...); }) , (;) )
  /// Retrieve the ref-qualifier associated with this function type.
  constexpr enum clang::RefQualifierKind getRefQualifier() const IFMETA_ELSE( ({    return (enum clang::RefQualifierKind)__reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::getRefQualifier, Xs...); }) , (;) )
  RANGE_REFLECTION(clang::FunctionProtoType, param_types,
      constexpr auto param_types() const ,
      (const typename meta::clang::QualType),
      (reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::param_types, Xs...), () )
  RANGE_REFLECTION(clang::FunctionProtoType, exceptions,
      constexpr auto exceptions() const ,
      (typename meta::clang::QualType),
      (reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::exceptions, Xs...), () )
  /// Is there any interesting extra information for any of the parameters
  /// of this function type?
  constexpr bool hasExtParameterInfos() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::hasExtParameterInfos, Xs...); }) , (;) )
  RANGE_REFLECTION(clang::FunctionProtoType, getExtParameterInfos,
      constexpr auto getExtParameterInfos() const ,
      (typename meta::clang::FunctionProtoType::ExtParameterInfo),
      (reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::getExtParameterInfos, Xs...), () )
  /// Return a pointer to the beginning of the array of extra parameter
  /// information, if present, or else null if none of the parameters
  /// carry it.  This is equivalent to getExtProtoInfo().ExtParameterInfos.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::FunctionProtoType::ExtParameterInfo *) )
  getExtParameterInfosOrNull() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::getExtParameterInfosOrNull, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FunctionProtoType::ExtParameterInfo) )
  getExtParameterInfo(unsigned int I) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::getExtParameterInfo, Xs..., I); }) , (;) )
  constexpr enum clang::ParameterABI getParameterABI(unsigned int I) const IFMETA_ELSE( ({    return (enum clang::ParameterABI)__reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::getParameterABI, Xs..., I); }) , (;) )
  constexpr bool isParamConsumed(unsigned int I) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::isParamConsumed, Xs..., I); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  constexpr void printExceptionSpecification(IFMETA_ELSE((const llvm::raw_ostream::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::raw_ostream &)) OS, IFMETA_ELSE((const clang::PrintingPolicy::template impl</*ptrorref=*/1, Y1s...>), (const typename meta::clang::PrintingPolicy &)) Policy) const IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::printExceptionSpecification, Xs..., Y0s..., Y1s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_c M_rtpack(Y3s) M_c M_rtpack(Y4s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::QualType)) Result, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/1, Y2s...> *), (const typename meta::clang::QualType *)) ArgTys, unsigned int NumArgs, IFMETA_ELSE((const clang::FunctionProtoType::ExtProtoInfo::template impl</*ptrorref=*/1, Y3s...>), (const typename meta::clang::FunctionProtoType::ExtProtoInfo &)) EPI, IFMETA_ELSE((const clang::ASTContext::template impl</*ptrorref=*/1, Y4s...>), (const typename meta::clang::ASTContext &)) Context, bool Canonical) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__FunctionProtoType, reflenums::clang__FunctionProtoType::Profile, Xs..., Y0s..., Y1s..., Y2s..., NumArgs, Y3s..., Y4s..., Canonical); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2, typename Y3, typename Y4>
  static constexpr void Profile(Y0 p0, Y1 p1, ptrwrp<Y2> p2, unsigned int p3, Y3 p4, Y4 p5, bool p6) {
      return Profile(p0, p1, p2.get(), p3, p4, p5, p6);
  }), () )
};

/// Interesting information about a specific parameter that can't simply
  /// be reflected in parameter's type.
  ///
  /// It makes sense to model language features this way when there's some
  /// sort of parameter-specific override (such as an attribute) that
  /// affects how the function is called.  For example, the ARC ns_consumed
  /// attribute changes whether a parameter is passed at +0 (the default)
  /// or +1 (ns_consumed).  This must be reflected in the function type,
  /// but isn't really a change to the parameter type.
  ///
  /// One serious disadvantage of modelling language features this way is
  /// that they generally do not work with language features that attempt
  /// to destructure types.  For example, template argument deduction will
  /// not be able to match a parameter declared as
  ///   T (*)(U)
  /// against an argument of type
  ///   void (*)(__attribute__((ns_consumed)) id)
  /// because the substitution of T=void, U=id into the former will
  /// not produce the latter.
M_template_rtpack(Xs)
struct clang::FunctionProtoType::ExtParameterInfo::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__FunctionProtoType__ExtParameterInfo;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::FunctionProtoType::ExtParameterInfo::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// Return the ABI treatment of this parameter.
  constexpr enum clang::ParameterABI getABI() const IFMETA_ELSE( ({    return (enum clang::ParameterABI)__reflect_prop(reflenums::RK_clang__FunctionProtoType__ExtParameterInfo, reflenums::clang__FunctionProtoType__ExtParameterInfo::getABI, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FunctionProtoType::ExtParameterInfo) )
  withABI(enum clang::ParameterABI kind) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExtParameterInfo, reflenums::clang__FunctionProtoType__ExtParameterInfo::withABI, Xs..., kind); }) , (;) )
  /// Is this parameter considered "consumed" by Objective-C ARC?
    /// Consumed parameters must have retainable object type.
  constexpr bool isConsumed() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExtParameterInfo, reflenums::clang__FunctionProtoType__ExtParameterInfo::isConsumed, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FunctionProtoType::ExtParameterInfo) )
  withIsConsumed(bool consumed) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExtParameterInfo, reflenums::clang__FunctionProtoType__ExtParameterInfo::withIsConsumed, Xs..., consumed); }) , (;) )
  constexpr bool hasPassObjectSize() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExtParameterInfo, reflenums::clang__FunctionProtoType__ExtParameterInfo::hasPassObjectSize, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FunctionProtoType::ExtParameterInfo) )
  withHasPassObjectSize() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExtParameterInfo, reflenums::clang__FunctionProtoType__ExtParameterInfo::withHasPassObjectSize, Xs...); }) , (;) )
  constexpr bool isNoEscape() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExtParameterInfo, reflenums::clang__FunctionProtoType__ExtParameterInfo::isNoEscape, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::FunctionProtoType::ExtParameterInfo) )
  withIsNoEscape(bool NoEscape) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExtParameterInfo, reflenums::clang__FunctionProtoType__ExtParameterInfo::withIsNoEscape, Xs..., NoEscape); }) , (;) )
  constexpr unsigned char getOpaqueValue() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExtParameterInfo, reflenums::clang__FunctionProtoType__ExtParameterInfo::getOpaqueValue, Xs...); }) , (;) )
  static constexpr IFMETA_ELSE( (auto), (typename meta::clang::FunctionProtoType::ExtParameterInfo) )
  getFromOpaqueValue(unsigned char data) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExtParameterInfo, reflenums::clang__FunctionProtoType__ExtParameterInfo::getFromOpaqueValue, Xs..., data); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr bool operator==(IFMETA_ELSE((const clang::FunctionProtoType::ExtParameterInfo::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::FunctionProtoType::ExtParameterInfo)) lhs, IFMETA_ELSE((const clang::FunctionProtoType::ExtParameterInfo::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::FunctionProtoType::ExtParameterInfo)) rhs) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExtParameterInfo, reflenums::clang__FunctionProtoType__ExtParameterInfo::operator_eq_eq, Xs..., Y0s..., Y1s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  friend constexpr bool operator!=(IFMETA_ELSE((const clang::FunctionProtoType::ExtParameterInfo::template impl</*ptrorref=*/0, Y0s...>), (typename meta::clang::FunctionProtoType::ExtParameterInfo)) lhs, IFMETA_ELSE((const clang::FunctionProtoType::ExtParameterInfo::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::FunctionProtoType::ExtParameterInfo)) rhs) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExtParameterInfo, reflenums::clang__FunctionProtoType__ExtParameterInfo::operator_not_eq, Xs..., Y0s..., Y1s...); }) , (;) )
};

M_template_rtpack(Xs)
struct clang::FunctionProtoType::ExceptionSpecInfo::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__FunctionProtoType__ExceptionSpecInfo;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::FunctionProtoType::ExceptionSpecInfo::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// The kind of exception specification this is.
  enum clang::ExceptionSpecificationType Type
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExceptionSpecInfo, reflenums::clang__FunctionProtoType__ExceptionSpecInfo::Type, Xs...);), (;) )
  /// Noexcept expression, if this is a computed noexcept specification.
  M_REFLTYPED_FIELD(NoexceptExpr, (typename meta::clang::Expr *), __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExceptionSpecInfo, reflenums::clang__FunctionProtoType__ExceptionSpecInfo::NoexceptExpr, Xs...))
  /// The function whose exception specification this is, for
    /// EST_Unevaluated and EST_Uninstantiated.
  M_REFLTYPED_FIELD(SourceDecl, (typename meta::clang::FunctionDecl *), __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExceptionSpecInfo, reflenums::clang__FunctionProtoType__ExceptionSpecInfo::SourceDecl, Xs...))
  /// The function template whose exception specification this is instantiated
    /// from, for EST_Uninstantiated.
  M_REFLTYPED_FIELD(SourceTemplate, (typename meta::clang::FunctionDecl *), __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExceptionSpecInfo, reflenums::clang__FunctionProtoType__ExceptionSpecInfo::SourceTemplate, Xs...))
};

/// Extra information about a function prototype.
M_template_rtpack(Xs)
struct clang::FunctionProtoType::ExtProtoInfo::impl {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__FunctionProtoType__ExtProtoInfo;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::FunctionProtoType::ExtProtoInfo::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  M_REFLTYPED_FIELD(ExtInfo, (typename meta::clang::FunctionType::ExtInfo), __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExtProtoInfo, reflenums::clang__FunctionProtoType__ExtProtoInfo::ExtInfo, Xs...))
  bool Variadic
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExtProtoInfo, reflenums::clang__FunctionProtoType__ExtProtoInfo::Variadic, Xs...);), (;) )
  bool HasTrailingReturn
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExtProtoInfo, reflenums::clang__FunctionProtoType__ExtProtoInfo::HasTrailingReturn, Xs...);), (;) )
  unsigned char TypeQuals
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExtProtoInfo, reflenums::clang__FunctionProtoType__ExtProtoInfo::TypeQuals, Xs...);), (;) )
  enum clang::RefQualifierKind RefQualifier
      IFMETA_ELSE( (= __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExtProtoInfo, reflenums::clang__FunctionProtoType__ExtProtoInfo::RefQualifier, Xs...);), (;) )
  M_REFLTYPED_FIELD(ExceptionSpec, (typename meta::clang::FunctionProtoType::ExceptionSpecInfo), __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExtProtoInfo, reflenums::clang__FunctionProtoType__ExtProtoInfo::ExceptionSpec, Xs...))
  M_REFLTYPED_FIELD(ExtParameterInfos, (const typename meta::clang::FunctionProtoType::ExtParameterInfo *), __reflect_prop(reflenums::RK_clang__FunctionProtoType__ExtProtoInfo, reflenums::clang__FunctionProtoType__ExtProtoInfo::ExtParameterInfos, Xs...))
};

/// Represents the dependent type named by a dependently-scoped
/// typename using declaration, e.g.
///   using typename Base<T>::foo;
///
/// Template instantiation turns these into the underlying type.
M_template_rtpack(Xs)
struct clang::UnresolvedUsingType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__UnresolvedUsingType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::UnresolvedUsingType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::UnresolvedUsingTypenameDecl *) )
  getDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__UnresolvedUsingType, reflenums::clang__UnresolvedUsingType::getDecl, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__UnresolvedUsingType, reflenums::clang__UnresolvedUsingType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__UnresolvedUsingType, reflenums::clang__UnresolvedUsingType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__UnresolvedUsingType, reflenums::clang__UnresolvedUsingType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::UnresolvedUsingTypenameDecl::template impl</*ptrorref=*/1, Y1s...> *), (typename meta::clang::UnresolvedUsingTypenameDecl *)) D) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__UnresolvedUsingType, reflenums::clang__UnresolvedUsingType::Profile, Xs..., Y0s..., Y1s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1>
  static constexpr void Profile(Y0 p0, ptrwrp<Y1> p1) {
      return Profile(p0, p1.get());
  }), () )
};

M_template_rtpack(Xs)
struct clang::TypedefType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__TypedefType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::TypedefType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TypedefNameDecl *) )
  getDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TypedefType, reflenums::clang__TypedefType::getDecl, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TypedefType, reflenums::clang__TypedefType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TypedefType, reflenums::clang__TypedefType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TypedefType, reflenums::clang__TypedefType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Represents a `typeof` (or __typeof__) expression (a GCC extension).
M_template_rtpack(Xs)
struct clang::TypeOfExprType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__TypeOfExprType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::TypeOfExprType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Expr *) )
  getUnderlyingExpr() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TypeOfExprType, reflenums::clang__TypeOfExprType::getUnderlyingExpr, Xs...); }) , (;) )
  /// Remove a single level of sugar.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TypeOfExprType, reflenums::clang__TypeOfExprType::desugar, Xs...); }) , (;) )
  /// Returns whether this type directly provides sugar.
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TypeOfExprType, reflenums::clang__TypeOfExprType::isSugared, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TypeOfExprType, reflenums::clang__TypeOfExprType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Represents `typeof(type)`, a GCC extension.
M_template_rtpack(Xs)
struct clang::TypeOfType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__TypeOfType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::TypeOfType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getUnderlyingType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TypeOfType, reflenums::clang__TypeOfType::getUnderlyingType, Xs...); }) , (;) )
  /// Remove a single level of sugar.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TypeOfType, reflenums::clang__TypeOfType::desugar, Xs...); }) , (;) )
  /// Returns whether this type directly provides sugar.
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TypeOfType, reflenums::clang__TypeOfType::isSugared, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TypeOfType, reflenums::clang__TypeOfType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Represents the type `decltype(expr)` (C++11).
M_template_rtpack(Xs)
struct clang::DecltypeType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DecltypeType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DecltypeType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Expr *) )
  getUnderlyingExpr() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DecltypeType, reflenums::clang__DecltypeType::getUnderlyingExpr, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getUnderlyingType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DecltypeType, reflenums::clang__DecltypeType::getUnderlyingType, Xs...); }) , (;) )
  /// Remove a single level of sugar.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DecltypeType, reflenums::clang__DecltypeType::desugar, Xs...); }) , (;) )
  /// Returns whether this type directly provides sugar.
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DecltypeType, reflenums::clang__DecltypeType::isSugared, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DecltypeType, reflenums::clang__DecltypeType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// \brief Representation of reflected types.
///
/// This represents the set of types formed using the typename specifier
/// on a non-dependent expression.
///
///   struct S;
///   void f() {
///     typename($S) foo ;
///   }
///
/// As with decltype types, we preserve the underlying expression.
///
/// \todo Consider merging this implementation with DecltypeType and maybe
/// TypeofType. They all appear to have the same internal structure.
M_template_rtpack(Xs)
struct clang::ReflectedType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__ReflectedType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::ReflectedType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// \brief Returns the reflection of a type.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::Expr *) )
  getTypeReflection() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ReflectedType, reflenums::clang__ReflectedType::getTypeReflection, Xs...); }) , (;) )
  /// \brief Returns the underlying type; the one reflected.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getUnderlyingType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ReflectedType, reflenums::clang__ReflectedType::getUnderlyingType, Xs...); }) , (;) )
  /// \brief Returns whether this type provides sugar.
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ReflectedType, reflenums::clang__ReflectedType::isSugared, Xs...); }) , (;) )
  /// \brief Removes one level of sugar.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ReflectedType, reflenums::clang__ReflectedType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ReflectedType, reflenums::clang__ReflectedType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

enum clang::UnaryTransformType::UTTKind : unsigned int {
  EnumUnderlyingType,
};

/// A unary type transform, which is a type constructed from another.
M_template_rtpack(Xs)
struct clang::UnaryTransformType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__UnaryTransformType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::UnaryTransformType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  using UTTKind = enum refldetail::clang::UnaryTransformType::UTTKind;
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__UnaryTransformType, reflenums::clang__UnaryTransformType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__UnaryTransformType, reflenums::clang__UnaryTransformType::desugar, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getUnderlyingType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__UnaryTransformType, reflenums::clang__UnaryTransformType::getUnderlyingType, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getBaseType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__UnaryTransformType, reflenums::clang__UnaryTransformType::getBaseType, Xs...); }) , (;) )
  constexpr enum clang::UnaryTransformType::UTTKind getUTTKind() const IFMETA_ELSE( ({    return (enum clang::UnaryTransformType::UTTKind)__reflect_prop(reflenums::RK_clang__UnaryTransformType, reflenums::clang__UnaryTransformType::getUTTKind, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__UnaryTransformType, reflenums::clang__UnaryTransformType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

M_template_rtpack(Xs)
struct clang::TagType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__TagType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::TagType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TagDecl *) )
  getDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TagType, reflenums::clang__TagType::getDecl, Xs...); }) , (;) )
  /// Determines whether this type is in the process of being defined.
  constexpr bool isBeingDefined() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TagType, reflenums::clang__TagType::isBeingDefined, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TagType, reflenums::clang__TagType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// A helper class that allows the use of isa/cast/dyncast
/// to detect TagType objects of structs/unions/classes.
M_template_rtpack(Xs)
struct clang::RecordType::impl : impl_offset_t<clang::TagType, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__RecordType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::RecordType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::RecordDecl *) )
  getDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__RecordType, reflenums::clang__RecordType::getDecl, Xs...); }) , (;) )
  /// Recursively check all fields in the record for const-ness. If any field
  /// is declared const, return true. Otherwise, return false.
  constexpr bool hasConstFields() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__RecordType, reflenums::clang__RecordType::hasConstFields, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__RecordType, reflenums::clang__RecordType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__RecordType, reflenums::clang__RecordType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__RecordType, reflenums::clang__RecordType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// A helper class that allows the use of isa/cast/dyncast
/// to detect TagType objects of enums.
M_template_rtpack(Xs)
struct clang::EnumType::impl : impl_offset_t<clang::TagType, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__EnumType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::EnumType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::EnumDecl *) )
  getDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__EnumType, reflenums::clang__EnumType::getDecl, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__EnumType, reflenums::clang__EnumType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__EnumType, reflenums::clang__EnumType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__EnumType, reflenums::clang__EnumType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

enum clang::AttributedType::Kind : unsigned int {
  attr_address_space,
  attr_regparm,
  attr_vector_size,
  attr_neon_vector_type,
  attr_neon_polyvector_type,
  FirstExprOperandKind = 0,
  LastExprOperandKind = 4,
  attr_objc_gc,
  attr_objc_ownership,
  attr_pcs,
  attr_pcs_vfp,
  FirstEnumOperandKind = 5,
  LastEnumOperandKind = 8,
  attr_noreturn,
  attr_nocf_check,
  attr_cdecl,
  attr_fastcall,
  attr_stdcall,
  attr_thiscall,
  attr_regcall,
  attr_pascal,
  attr_swiftcall,
  attr_vectorcall,
  attr_inteloclbicc,
  attr_ms_abi,
  attr_sysv_abi,
  attr_preserve_most,
  attr_preserve_all,
  attr_ptr32,
  attr_ptr64,
  attr_sptr,
  attr_uptr,
  attr_nonnull,
  attr_ns_returns_retained,
  attr_nullable,
  attr_null_unspecified,
  attr_objc_kindof,
  attr_objc_inert_unsafe_unretained,
  attr_lifetimebound,
};

/// An attributed type is a type to which a type attribute has been applied.
///
/// The "modified type" is the fully-sugared type to which the attributed
/// type was applied; generally it is not canonically equivalent to the
/// attributed type. The "equivalent type" is the minimally-desugared type
/// which the type is canonically equivalent to.
///
/// For example, in the following attributed type:
///     int32_t __attribute__((vector_size(16)))
///   - the modified type is the TypedefType for int32_t
///   - the equivalent type is VectorType(16, int32_t)
///   - the canonical type is VectorType(16, int)
M_template_rtpack(Xs)
struct clang::AttributedType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__AttributedType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::AttributedType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  using Kind = enum refldetail::clang::AttributedType::Kind;
  constexpr enum clang::AttributedType::Kind getAttrKind() const IFMETA_ELSE( ({    return (enum clang::AttributedType::Kind)__reflect_prop(reflenums::RK_clang__AttributedType, reflenums::clang__AttributedType::getAttrKind, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getModifiedType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__AttributedType, reflenums::clang__AttributedType::getModifiedType, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getEquivalentType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__AttributedType, reflenums::clang__AttributedType::getEquivalentType, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__AttributedType, reflenums::clang__AttributedType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__AttributedType, reflenums::clang__AttributedType::desugar, Xs...); }) , (;) )
  /// Does this attribute behave like a type qualifier?
  ///
  /// A type qualifier adjusts a type to provide specialized rules for
  /// a specific object, like the standard const and volatile qualifiers.
  /// This includes attributes controlling things like nullability,
  /// address spaces, and ARC ownership.  The value of the object is still
  /// largely described by the modified type.
  ///
  /// In contrast, many type attributes "rewrite" their modified type to
  /// produce a fundamentally different type, not necessarily related in any
  /// formalizable way to the original type.  For example, calling convention
  /// and vector attributes are not simple type qualifiers.
  ///
  /// Type qualifiers are often, but not always, reflected in the canonical
  /// type.
  constexpr bool isQualifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__AttributedType, reflenums::clang__AttributedType::isQualifier, Xs...); }) , (;) )
  constexpr bool isMSTypeSpec() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__AttributedType, reflenums::clang__AttributedType::isMSTypeSpec, Xs...); }) , (;) )
  constexpr bool isCallingConv() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__AttributedType, reflenums::clang__AttributedType::isCallingConv, Xs...); }) , (;) )
  /// Retrieve the attribute kind corresponding to the given
  /// nullability kind.
  static constexpr enum clang::AttributedType::Kind getNullabilityAttrKind(enum clang::NullabilityKind kind) IFMETA_ELSE( ({    return (enum clang::AttributedType::Kind)__reflect_prop(reflenums::RK_clang__AttributedType, reflenums::clang__AttributedType::getNullabilityAttrKind, Xs..., kind); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, enum clang::AttributedType::Kind attrKind, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::QualType)) modified, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y2s...>), (typename meta::clang::QualType)) equivalent) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__AttributedType, reflenums::clang__AttributedType::Profile, Xs..., Y0s..., attrKind, Y1s..., Y2s...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__AttributedType, reflenums::clang__AttributedType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

M_template_rtpack(Xs)
struct clang::TemplateTypeParmType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__TemplateTypeParmType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::TemplateTypeParmType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr unsigned int getDepth() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateTypeParmType, reflenums::clang__TemplateTypeParmType::getDepth, Xs...); }) , (;) )
  constexpr unsigned int getIndex() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateTypeParmType, reflenums::clang__TemplateTypeParmType::getIndex, Xs...); }) , (;) )
  constexpr bool isParameterPack() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateTypeParmType, reflenums::clang__TemplateTypeParmType::isParameterPack, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TemplateTypeParmDecl *) )
  getDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateTypeParmType, reflenums::clang__TemplateTypeParmType::getDecl, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::IdentifierInfo *) )
  getIdentifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateTypeParmType, reflenums::clang__TemplateTypeParmType::getIdentifier, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateTypeParmType, reflenums::clang__TemplateTypeParmType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateTypeParmType, reflenums::clang__TemplateTypeParmType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, unsigned int Depth, unsigned int Index, bool ParameterPack, IFMETA_ELSE((const clang::TemplateTypeParmDecl::template impl</*ptrorref=*/1, Y1s...> *), (typename meta::clang::TemplateTypeParmDecl *)) TTPDecl) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__TemplateTypeParmType, reflenums::clang__TemplateTypeParmType::Profile, Xs..., Y0s..., Depth, Index, ParameterPack, Y1s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1>
  static constexpr void Profile(Y0 p0, unsigned int p1, unsigned int p2, bool p3, ptrwrp<Y1> p4) {
      return Profile(p0, p1, p2, p3, p4.get());
  }), () )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateTypeParmType, reflenums::clang__TemplateTypeParmType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Represents the result of substituting a type for a template
/// type parameter.
///
/// Within an instantiated template, all template type parameters have
/// been replaced with these.  They are used solely to record that a
/// type was originally written as a template type parameter;
/// therefore they are never canonical.
M_template_rtpack(Xs)
struct clang::SubstTemplateTypeParmType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__SubstTemplateTypeParmType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::SubstTemplateTypeParmType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// Gets the template parameter that was substituted for.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::TemplateTypeParmType *) )
  getReplacedParameter() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SubstTemplateTypeParmType, reflenums::clang__SubstTemplateTypeParmType::getReplacedParameter, Xs...); }) , (;) )
  /// Gets the type that was substituted for the template
  /// parameter.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getReplacementType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SubstTemplateTypeParmType, reflenums::clang__SubstTemplateTypeParmType::getReplacementType, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SubstTemplateTypeParmType, reflenums::clang__SubstTemplateTypeParmType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SubstTemplateTypeParmType, reflenums::clang__SubstTemplateTypeParmType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::TemplateTypeParmType::template impl</*ptrorref=*/1, Y1s...> *), (const typename meta::clang::TemplateTypeParmType *)) Replaced, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y2s...>), (typename meta::clang::QualType)) Replacement) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__SubstTemplateTypeParmType, reflenums::clang__SubstTemplateTypeParmType::Profile, Xs..., Y0s..., Y1s..., Y2s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2>
  static constexpr void Profile(Y0 p0, ptrwrp<Y1> p1, Y2 p2) {
      return Profile(p0, p1.get(), p2);
  }), () )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SubstTemplateTypeParmType, reflenums::clang__SubstTemplateTypeParmType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Represents the result of substituting a set of types for a template
/// type parameter pack.
///
/// When a pack expansion in the source code contains multiple parameter packs
/// and those parameter packs correspond to different levels of template
/// parameter lists, this type node is used to represent a template type
/// parameter pack from an outer level, which has already had its argument pack
/// substituted but that still lives within a pack expansion that itself
/// could not be instantiated. When actually performing a substitution into
/// that pack expansion (e.g., when all template parameters have corresponding
/// arguments), this type will be replaced with the \c SubstTemplateTypeParmType
/// at the current pack substitution index.
M_template_rtpack(Xs)
struct clang::SubstTemplateTypeParmPackType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__SubstTemplateTypeParmPackType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::SubstTemplateTypeParmPackType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::IdentifierInfo *) )
  getIdentifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SubstTemplateTypeParmPackType, reflenums::clang__SubstTemplateTypeParmPackType::getIdentifier, Xs...); }) , (;) )
  /// Gets the template parameter that was substituted for.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::TemplateTypeParmType *) )
  getReplacedParameter() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SubstTemplateTypeParmPackType, reflenums::clang__SubstTemplateTypeParmPackType::getReplacedParameter, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SubstTemplateTypeParmPackType, reflenums::clang__SubstTemplateTypeParmPackType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SubstTemplateTypeParmPackType, reflenums::clang__SubstTemplateTypeParmPackType::desugar, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TemplateArgument) )
  getArgumentPack() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SubstTemplateTypeParmPackType, reflenums::clang__SubstTemplateTypeParmPackType::getArgumentPack, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::TemplateTypeParmType::template impl</*ptrorref=*/1, Y1s...> *), (const typename meta::clang::TemplateTypeParmType *)) Replaced, IFMETA_ELSE((const clang::TemplateArgument::template impl</*ptrorref=*/1, Y2s...>), (const typename meta::clang::TemplateArgument &)) ArgPack) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__SubstTemplateTypeParmPackType, reflenums::clang__SubstTemplateTypeParmPackType::Profile, Xs..., Y0s..., Y1s..., Y2s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2>
  static constexpr void Profile(Y0 p0, ptrwrp<Y1> p1, Y2 p2) {
      return Profile(p0, p1.get(), p2);
  }), () )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__SubstTemplateTypeParmPackType, reflenums::clang__SubstTemplateTypeParmPackType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Common base class for placeholders for types that get replaced by
/// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced
/// class template types, and (eventually) constrained type names from the C++
/// Concepts TS.
///
/// These types are usually a placeholder for a deduced type. However, before
/// the initializer is attached, or (usually) if the initializer is
/// type-dependent, there is no deduced type and the type is canonical. In
/// the latter case, it is also a dependent type.
M_template_rtpack(Xs)
struct clang::DeducedType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DeducedType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DeducedType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeducedType, reflenums::clang__DeducedType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeducedType, reflenums::clang__DeducedType::desugar, Xs...); }) , (;) )
  /// Get the type deduced for this placeholder type, or null if it's
  /// either not been deduced or was deduced to a dependent type.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getDeducedType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeducedType, reflenums::clang__DeducedType::getDeducedType, Xs...); }) , (;) )
  constexpr bool isDeduced() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeducedType, reflenums::clang__DeducedType::isDeduced, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeducedType, reflenums::clang__DeducedType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Represents a C++11 auto or C++14 decltype(auto) type.
M_template_rtpack(Xs)
struct clang::AutoType::impl : impl_offset_t<clang::DeducedType, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__AutoType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::AutoType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr bool isDecltypeAuto() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__AutoType, reflenums::clang__AutoType::isDecltypeAuto, Xs...); }) , (;) )
  constexpr enum clang::AutoTypeKeyword getKeyword() const IFMETA_ELSE( ({    return (enum clang::AutoTypeKeyword)__reflect_prop(reflenums::RK_clang__AutoType, reflenums::clang__AutoType::getKeyword, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::QualType)) Deduced, enum clang::AutoTypeKeyword Keyword, bool IsDependent) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__AutoType, reflenums::clang__AutoType::Profile, Xs..., Y0s..., Y1s..., Keyword, IsDependent); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__AutoType, reflenums::clang__AutoType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Represents a C++17 deduced template specialization type.
M_template_rtpack(Xs)
struct clang::DeducedTemplateSpecializationType::impl : impl_offset_t<clang::DeducedType, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DeducedTemplateSpecializationType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DeducedTemplateSpecializationType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// Retrieve the name of the template that we are deducing.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TemplateName) )
  getTemplateName() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeducedTemplateSpecializationType, reflenums::clang__DeducedTemplateSpecializationType::getTemplateName, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, IFMETA_ELSE((const clang::TemplateName::template impl</*ptrorref=*/0, Y1s...>), (typename meta::clang::TemplateName)) Template, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y2s...>), (typename meta::clang::QualType)) Deduced, bool IsDependent) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DeducedTemplateSpecializationType, reflenums::clang__DeducedTemplateSpecializationType::Profile, Xs..., Y0s..., Y1s..., Y2s..., IsDependent); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DeducedTemplateSpecializationType, reflenums::clang__DeducedTemplateSpecializationType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Represents a type template specialization; the template
/// must be a class template, a type alias template, or a template
/// template parameter.  A template which cannot be resolved to one of
/// these, e.g. because it is written with a dependent scope
/// specifier, is instead represented as a
/// @c DependentTemplateSpecializationType.
///
/// A non-dependent template specialization type is always "sugar",
/// typically for a \c RecordType.  For example, a class template
/// specialization type of \c vector<int> will refer to a tag type for
/// the instantiation \c std::vector<int, std::allocator<int>>
///
/// Template specializations are dependent if either the template or
/// any of the template arguments are dependent, in which case the
/// type may also be canonical.
///
/// Instances of this type are allocated with a trailing array of
/// TemplateArguments, followed by a QualType representing the
/// non-canonical aliased type when the template is a type alias
/// template.
M_template_rtpack(Xs)
struct clang::TemplateSpecializationType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__TemplateSpecializationType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::TemplateSpecializationType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// True if this template specialization type matches a current
  /// instantiation in the context in which it is found.
  constexpr bool isCurrentInstantiation() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateSpecializationType, reflenums::clang__TemplateSpecializationType::isCurrentInstantiation, Xs...); }) , (;) )
  /// Determine if this template specialization type is for a type alias
  /// template that has been substituted.
  ///
  /// Nearly every template specialization type whose template is an alias
  /// template will be substituted. However, this is not the case when
  /// the specialization contains a pack expansion but the template alias
  /// does not have a corresponding parameter pack, e.g.,
  ///
  /// \code
  /// template<typename T, typename U, typename V> struct S;
  /// template<typename T, typename U> using A = S<T, int, U>;
  /// template<typename... Ts> struct X {
  ///   typedef A<Ts...> type; // not a type alias
  /// };
  /// \endcode
  constexpr bool isTypeAlias() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateSpecializationType, reflenums::clang__TemplateSpecializationType::isTypeAlias, Xs...); }) , (;) )
  /// Get the aliased type, if this is a specialization of a type alias
  /// template.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getAliasedType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateSpecializationType, reflenums::clang__TemplateSpecializationType::getAliasedType, Xs...); }) , (;) )
  /// Retrieve the name of the template that we are specializing.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TemplateName) )
  getTemplateName() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateSpecializationType, reflenums::clang__TemplateSpecializationType::getTemplateName, Xs...); }) , (;) )
  /// Retrieve the template arguments.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::TemplateArgument *) )
  getArgs() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateSpecializationType, reflenums::clang__TemplateSpecializationType::getArgs, Xs...); }) , (;) )
  /// Retrieve the number of template arguments.
  constexpr unsigned int getNumArgs() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateSpecializationType, reflenums::clang__TemplateSpecializationType::getNumArgs, Xs...); }) , (;) )
  /// Retrieve a specific template argument as a type.
  /// \pre \c isArgType(Arg)
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::TemplateArgument &) )
  getArg(unsigned int Idx) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateSpecializationType, reflenums::clang__TemplateSpecializationType::getArg, Xs..., Idx); }) , (;) )
  RANGE_REFLECTION(clang::TemplateSpecializationType, template_arguments,
      constexpr auto template_arguments() const ,
      (typename meta::clang::TemplateArgument),
      (reflenums::RK_clang__TemplateSpecializationType, reflenums::clang__TemplateSpecializationType::template_arguments, Xs...), () )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateSpecializationType, reflenums::clang__TemplateSpecializationType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateSpecializationType, reflenums::clang__TemplateSpecializationType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TemplateSpecializationType, reflenums::clang__TemplateSpecializationType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
  RANGECLASS_SIZE_AND_GET(clang__TemplateSpecializationType, const typename meta::clang::TemplateArgument);
};

/// The injected class name of a C++ class template or class
/// template partial specialization.  Used to record that a type was
/// spelled with a bare identifier rather than as a template-id; the
/// equivalent for non-templated classes is just RecordType.
///
/// Injected class name types are always dependent.  Template
/// instantiation turns these into RecordTypes.
///
/// Injected class name types are always canonical.  This works
/// because it is impossible to compare an injected class name type
/// with the corresponding non-injected template type, for the same
/// reason that it is impossible to directly compare template
/// parameters from different dependent contexts: injected class name
/// types can only occur within the scope of a particular templated
/// declaration, and within that scope every template specialization
/// will canonicalize to the injected class name (when appropriate
/// according to the rules of the language).
M_template_rtpack(Xs)
struct clang::InjectedClassNameType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__InjectedClassNameType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::InjectedClassNameType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getInjectedSpecializationType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__InjectedClassNameType, reflenums::clang__InjectedClassNameType::getInjectedSpecializationType, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::TemplateSpecializationType *) )
  getInjectedTST() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__InjectedClassNameType, reflenums::clang__InjectedClassNameType::getInjectedTST, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TemplateName) )
  getTemplateName() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__InjectedClassNameType, reflenums::clang__InjectedClassNameType::getTemplateName, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::CXXRecordDecl *) )
  getDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__InjectedClassNameType, reflenums::clang__InjectedClassNameType::getDecl, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__InjectedClassNameType, reflenums::clang__InjectedClassNameType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__InjectedClassNameType, reflenums::clang__InjectedClassNameType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__InjectedClassNameType, reflenums::clang__InjectedClassNameType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// The kind of a tag type.
enum clang::TagTypeKind : unsigned int {
  /// The "struct" keyword.
  TTK_Struct,
  /// The "__interface" keyword.
  TTK_Interface,
  /// The "union" keyword.
  TTK_Union,
  /// The "class" keyword.
  TTK_Class,
  /// The "enum" keyword.
  TTK_Enum,
};

/// The elaboration keyword that precedes a qualified type name or
/// introduces an elaborated-type-specifier.
enum clang::ElaboratedTypeKeyword : unsigned int {
  /// The "struct" keyword introduces the elaborated-type-specifier.
  ETK_Struct,
  /// The "__interface" keyword introduces the elaborated-type-specifier.
  ETK_Interface,
  /// The "union" keyword introduces the elaborated-type-specifier.
  ETK_Union,
  /// The "class" keyword introduces the elaborated-type-specifier.
  ETK_Class,
  /// The "enum" keyword introduces the elaborated-type-specifier.
  ETK_Enum,
  /// The "typename" keyword precedes the qualified type name, e.g.,
  /// \c typename T::type.
  ETK_Typename,
  /// No keyword precedes the qualified type name.
  ETK_None,
};

/// A helper class for Type nodes having an ElaboratedTypeKeyword.
/// The keyword in stored in the free bits of the base class.
/// Also provides a few static helpers for converting and printing
/// elaborated type keyword and tag type kind enumerations.
M_template_rtpack(Xs)
struct clang::TypeWithKeyword::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__TypeWithKeyword;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::TypeWithKeyword::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr enum clang::ElaboratedTypeKeyword getKeyword() const IFMETA_ELSE( ({    return (enum clang::ElaboratedTypeKeyword)__reflect_prop(reflenums::RK_clang__TypeWithKeyword, reflenums::clang__TypeWithKeyword::getKeyword, Xs...); }) , (;) )
  /// Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
  static constexpr enum clang::ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned int TypeSpec) IFMETA_ELSE( ({    return (enum clang::ElaboratedTypeKeyword)__reflect_prop(reflenums::RK_clang__TypeWithKeyword, reflenums::clang__TypeWithKeyword::getKeywordForTypeSpec, Xs..., TypeSpec); }) , (;) )
  /// Converts a type specifier (DeclSpec::TST) into a tag type kind.
  /// It is an error to provide a type specifier which *isn't* a tag kind here.
  static constexpr enum clang::TagTypeKind getTagTypeKindForTypeSpec(unsigned int TypeSpec) IFMETA_ELSE( ({    return (enum clang::TagTypeKind)__reflect_prop(reflenums::RK_clang__TypeWithKeyword, reflenums::clang__TypeWithKeyword::getTagTypeKindForTypeSpec, Xs..., TypeSpec); }) , (;) )
  /// Converts a TagTypeKind into an elaborated type keyword.
  static constexpr enum clang::ElaboratedTypeKeyword getKeywordForTagTypeKind(enum clang::TagTypeKind Tag) IFMETA_ELSE( ({    return (enum clang::ElaboratedTypeKeyword)__reflect_prop(reflenums::RK_clang__TypeWithKeyword, reflenums::clang__TypeWithKeyword::getKeywordForTagTypeKind, Xs..., Tag); }) , (;) )
  /// Converts an elaborated type keyword into a TagTypeKind.
  /// It is an error to provide an elaborated type keyword
  /// which *isn't* a tag kind here.
  static constexpr enum clang::TagTypeKind getTagTypeKindForKeyword(enum clang::ElaboratedTypeKeyword Keyword) IFMETA_ELSE( ({    return (enum clang::TagTypeKind)__reflect_prop(reflenums::RK_clang__TypeWithKeyword, reflenums::clang__TypeWithKeyword::getTagTypeKindForKeyword, Xs..., Keyword); }) , (;) )
  static constexpr bool KeywordIsTagTypeKind(enum clang::ElaboratedTypeKeyword Keyword) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TypeWithKeyword, reflenums::clang__TypeWithKeyword::KeywordIsTagTypeKind, Xs..., Keyword); }) , (;) )
  static constexpr const char * getKeywordName(enum clang::ElaboratedTypeKeyword Keyword) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TypeWithKeyword, reflenums::clang__TypeWithKeyword::getKeywordName, Xs..., Keyword); }) , (;) )
  static constexpr const char * getTagTypeKindName(enum clang::TagTypeKind Kind) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TypeWithKeyword, reflenums::clang__TypeWithKeyword::getTagTypeKindName, Xs..., Kind); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__TypeWithKeyword, reflenums::clang__TypeWithKeyword::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Represents a type that was referred to using an elaborated type
/// keyword, e.g., struct S, or via a qualified name, e.g., N::M::type,
/// or both.
///
/// This type is used to keep track of a type name as written in the
/// source code, including tag keywords and any nested-name-specifiers.
/// The type itself is always "sugar", used to express what was written
/// in the source code but containing no additional semantic information.
M_template_rtpack(Xs)
struct clang::ElaboratedType::impl : impl_offset_t<clang::TypeWithKeyword, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__ElaboratedType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::ElaboratedType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// Retrieve the qualification on this type.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::NestedNameSpecifier *) )
  getQualifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ElaboratedType, reflenums::clang__ElaboratedType::getQualifier, Xs...); }) , (;) )
  /// Retrieve the type named by the qualified-id.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  getNamedType() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ElaboratedType, reflenums::clang__ElaboratedType::getNamedType, Xs...); }) , (;) )
  /// Remove a single level of sugar.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ElaboratedType, reflenums::clang__ElaboratedType::desugar, Xs...); }) , (;) )
  /// Returns whether this type directly provides sugar.
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ElaboratedType, reflenums::clang__ElaboratedType::isSugared, Xs...); }) , (;) )
  /// Return the (re)declaration of this type owned by this occurrence of this
  /// type, or nullptr if none.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::TagDecl *) )
  getOwnedTagDecl() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ElaboratedType, reflenums::clang__ElaboratedType::getOwnedTagDecl, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_c M_rtpack(Y3s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, enum clang::ElaboratedTypeKeyword Keyword, IFMETA_ELSE((const clang::NestedNameSpecifier::template impl</*ptrorref=*/1, Y1s...> *), (typename meta::clang::NestedNameSpecifier *)) NNS, IFMETA_ELSE((const clang::QualType::template impl</*ptrorref=*/0, Y2s...>), (typename meta::clang::QualType)) NamedType, IFMETA_ELSE((const clang::TagDecl::template impl</*ptrorref=*/1, Y3s...> *), (typename meta::clang::TagDecl *)) OwnedTagDecl) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__ElaboratedType, reflenums::clang__ElaboratedType::Profile, Xs..., Y0s..., Keyword, Y1s..., Y2s..., Y3s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2, typename Y3>
  static constexpr void Profile(Y0 p0, enum clang::ElaboratedTypeKeyword p1, ptrwrp<Y1> p2, Y2 p3, ptrwrp<Y3> p4) {
      return Profile(p0, p1, p2.get(), p3, p4.get());
  }), () )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__ElaboratedType, reflenums::clang__ElaboratedType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Represents a qualified type name for which the type name is
/// dependent.
///
/// DependentNameType represents a class of dependent types that involve a
/// possibly dependent nested-name-specifier (e.g., "T::") followed by a
/// name of a type. The DependentNameType may start with a "typename" (for a
/// typename-specifier), "class", "struct", "union", or "enum" (for a
/// dependent elaborated-type-specifier), or nothing (in contexts where we
/// know that we must be referring to a type, e.g., in a base class specifier).
/// Typically the nested-name-specifier is dependent, but in MSVC compatibility
/// mode, this type is used with non-dependent names to delay name lookup until
/// instantiation.
M_template_rtpack(Xs)
struct clang::DependentNameType::impl : impl_offset_t<clang::TypeWithKeyword, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DependentNameType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DependentNameType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  /// Retrieve the qualification on this type.
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::NestedNameSpecifier *) )
  getQualifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentNameType, reflenums::clang__DependentNameType::getQualifier, Xs...); }) , (;) )
  /// Retrieve the type named by the typename specifier as an identifier.
  ///
  /// This routine will return a non-NULL identifier pointer when the
  /// form of the original typename was terminated by an identifier,
  /// e.g., "typename T::type".
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::IdentifierInfo *) )
  getIdentifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentNameType, reflenums::clang__DependentNameType::getIdentifier, Xs...); }) , (;) )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentNameType, reflenums::clang__DependentNameType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentNameType, reflenums::clang__DependentNameType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_c M_rtpack(Y1s) M_c M_rtpack(Y2s) M_tend
  static constexpr void Profile(IFMETA_ELSE((const llvm::FoldingSetNodeID::template impl</*ptrorref=*/1, Y0s...>), (typename meta::llvm::FoldingSetNodeID &)) ID, enum clang::ElaboratedTypeKeyword Keyword, IFMETA_ELSE((const clang::NestedNameSpecifier::template impl</*ptrorref=*/1, Y1s...> *), (typename meta::clang::NestedNameSpecifier *)) NNS, IFMETA_ELSE((const clang::IdentifierInfo::template impl</*ptrorref=*/1, Y2s...> *), (const typename meta::clang::IdentifierInfo *)) Name) IFMETA_ELSE( ({    __reflect_prop(reflenums::RK_clang__DependentNameType, reflenums::clang__DependentNameType::Profile, Xs..., Y0s..., Keyword, Y1s..., Y2s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0, typename Y1, typename Y2>
  static constexpr void Profile(Y0 p0, enum clang::ElaboratedTypeKeyword p1, ptrwrp<Y1> p2, ptrwrp<Y2> p3) {
      return Profile(p0, p1, p2.get(), p3.get());
  }), () )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentNameType, reflenums::clang__DependentNameType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
};

/// Represents a template specialization type whose template cannot be
/// resolved, e.g.
///   A<T>::template B<T>
M_template_rtpack(Xs)
struct clang::DependentTemplateSpecializationType::impl : impl_offset_t<clang::TypeWithKeyword, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__DependentTemplateSpecializationType;
  constexpr explicit operator const char *() const IFMETA_ELSE( ({
    return __concatenate("cppx::meta::refldetail::clang::DependentTemplateSpecializationType::impl<",
                         concat_ints_w_commas<Xs...>::value, ">()");
  }) , ( {return "";} ) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::NestedNameSpecifier *) )
  getQualifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentTemplateSpecializationType, reflenums::clang__DependentTemplateSpecializationType::getQualifier, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::IdentifierInfo *) )
  getIdentifier() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentTemplateSpecializationType, reflenums::clang__DependentTemplateSpecializationType::getIdentifier, Xs...); }) , (;) )
  /// Retrieve the template arguments.
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::TemplateArgument *) )
  getArgs() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentTemplateSpecializationType, reflenums::clang__DependentTemplateSpecializationType::getArgs, Xs...); }) , (;) )
  /// Retrieve the number of template arguments.
  constexpr unsigned int getNumArgs() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentTemplateSpecializationType, reflenums::clang__DependentTemplateSpecializationType::getNumArgs, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (const typename meta::clang::TemplateArgument &) )
  getArg(unsigned int Idx) const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentTemplateSpecializationType, reflenums::clang__DependentTemplateSpecializationType::getArg, Xs..., Idx); }) , (;) )
  RANGE_REFLECTION(clang::DependentTemplateSpecializationType, template_arguments,
      constexpr auto template_arguments() const ,
      (typename meta::clang::TemplateArgument),
      (reflenums::RK_clang__DependentTemplateSpecializationType, reflenums::clang__DependentTemplateSpecializationType::template_arguments, Xs...), () )
  constexpr bool isSugared() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentTemplateSpecializationType, reflenums::clang__DependentTemplateSpecializationType::isSugared, Xs...); }) , (;) )
  constexpr IFMETA_ELSE( (auto), (typename meta::clang::QualType) )
  desugar() const IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentTemplateSpecializationType, reflenums::clang__DependentTemplateSpecializationType::desugar, Xs...); }) , (;) )
  M_template M_tbeg M_rtpack(Y0s) M_tend
  static constexpr bool classof(IFMETA_ELSE((const clang::Type::template impl</*ptrorref=*/1, Y0s...> *), (const typename meta::clang::Type *)) T) IFMETA_ELSE( ({    return __reflect_prop(reflenums::RK_clang__DependentTemplateSpecializationType, reflenums::clang__DependentTemplateSpecializationType::classof, Xs..., Y0s...); }) , (;) )
  IFMETA_ELSE( (template<typename Y0>
  static constexpr bool classof(ptrwrp<Y0> p0) {
      return classof(p0.get());
  }), () )
  RANGECLASS_SIZE_AND_GET(clang__DependentTemplateSpecializationType, const typename meta::clang::TemplateArgument);
};

/// Represents a pack expansion of types.
///
/// Pack expansions are part of C++11 variadic templates. A pack
/// expansion contains a pattern, which itself contains one or more
/// "unexpanded" parameter packs. When instantiated, a pack expansion
/// produces a series of types, each instantiated from the pattern of
/// the expansion, where the Ith instantiation of the pattern uses the
/// Ith arguments bound to each of the unexpanded parameter packs. The
/// pack expansion is considered to "expand" these unexpanded
/// parameter packs.
///
/// \code
/// template<typename ...Types> struct tuple;
///
/// template<typename ...Types>
/// struct tuple_of_references {
///   typedef tuple<Types&...> type;
/// };
/// \endcode
///
/// Here, the pack expansion \c Types&... is represented via a
/// PackExpansionType whose pattern is Types&.
M_template_rtpack(Xs)
struct clang::PackExpansionType::impl : impl_offset_t<clang::Type, 0 M_c M_pack(Xs)>, impl_offset_t<llvm::FoldingSetBase::Node, 24 M_c M_pack(Xs)> {
  static constexpr reflenums::ReflectionObjKind ReflObjKind = reflenums::ReflectionObjKind::RK_clang__PackExpansionType;
  constexpr explicit operator