[clang][NFC] Generate the {Type,ArrayType,UnaryExprOrType,Expression}Traits enumerations from TokenKinds.def...

[riccibruno]

Summary

... and use the new macros from TokenKinds.def to remove the hard-coded lists of traits.

All the information needed to generate these enumerations is already present in TokenKinds.def.
The motivation here is to be able to dump the trait spelling without hard-coding the list in yet another
place.

Note that this change the order of the enumerators in the enumerations (except that in the TypeTrait
enumeration all unary type traits are before all binary type traits, and all binary type traits are before all
n-ary type traits).

Apart from the aforementioned ordering which is relied upon, after this patch no code in clang or in the
various clang tools depend on the specific ordering of the enumerators.

No functional changes intended.

[riccibruno]

clang/include/clang/Basic/TokenKinds.def

65

It is slightly unfortunate to have to use both UNARY_EXPR_OR_TYPE_TRAIT and CXX11_UNARY_EXPR_OR_TYPE_TRAIT since users have to define both. I have no better idea unfortunately.

[riccibruno]

clang/include/clang/Basic/DiagnosticSemaKinds.td

6008

These two can merged in a further patch.

6014

Same.

[aaron.ballman]

clang/lib/Basic/ExpressionTraits.cpp

29–34

Isn't ET_Last -1?

clang/lib/Basic/TypeTraits.cpp

64

ATT_Last is also -1.

69

UETT_Last is also -1.

clang/lib/Sema/SemaExpr.cpp

3974

I think the original code was a bit more clear; would it make sense to make the diagnostic engine aware of trait kinds so that it does this dance for you? (It may be overkill given that we don't pass UnaryExprOrTypeTrait objects to the diagnostic engine THAT often, but I'm curious what you think.)

[riccibruno]

Thanks for the review Aaron! I have added some comments inline.

clang/lib/Basic/ExpressionTraits.cpp

29–34

Nope :) It's -1 plus 1 per element in the enumeration. I have added the enumerators ET_Last, ATT_Last and UETT_Last for consistency with UTT_Last, BTT_Last and TT_Last which are needed.

In this patch ET_Last, ATT_Last and UETT_Last are only used here in this assertion and could be replaced by the equivalent T < XX_Last where XX_Last is just added as the last element in the enumeration. However mixing XX_Last = XX_LastElement and XX_Last = LastElement + 1 would be very error-prone.

clang/lib/Sema/SemaExpr.cpp

3974

I don't think it is worthwhile since as you say UnaryExprOrTypeTrait objects are not frequently passed to the diagnostic engine.

Moreover I personally finds the explicit getTraitSpelling(TraitKind) clearer for two reasons:

1. Frequently a non-class enumerator is used as an index to a select in a diagnostic, relying on the implicit integer conversion. Special casing UnaryExprOrTypeTrait would be surprising.

2. (weaker) << TraitKind could mean something else than the trait's spelling; for example this could print the trait's name or some user-visible version thereof.

[aaron.ballman]

LGTM, your choice on hiding in TokenKinds.def.

clang/lib/Basic/ExpressionTraits.cpp

29–34

Oh! I see now what's going on and that's clever; I was misunderstanding the second macro usage (which makes me wonder if it would make more sense to hide the Last fields at the bottom of TokenKinds.def rather than use the current approach, but I don't insist). Thank you for the clarification.

clang/lib/Sema/SemaExpr.cpp

3974

Sold! Thank you. :-)

[riccibruno]

In D81455#2087286, @aaron.ballman wrote:

LGTM, your choice on hiding in TokenKinds.def.

Oh! I see now what's going on and that's clever; I was misunderstanding the second macro usage (which makes me wonder if it would make more sense to hide the Last fields at the bottom of TokenKinds.def rather than use the current approach, but I don't insist). Thank you for the clarification.

Ah, I admit I was grinning for a few minutes when I came up with this :) Yay for macros... I think I will leave the XX_Lasts in the enumeration since they are not really a trait but a structural feature of the enumerations. I will however add a comment next to each XX_Last explaining this trick.

Thanks for the review!

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_atomic_specifier_bad_type
     : Error<"_Atomic cannot be applied to "
             "%select{incomplete |array |function |reference |atomic |qualified "
             "|sizeless ||integer |integer }0type "
             "%1 %select{|||||||which is not trivially copyable|with less than "
             "1 byte of precision|with a non power of 2 precision}0">;
 
 // Expressions.
-def select_unary_expr_or_type_trait_kind : TextSubstitution<
-  "%select{sizeof|alignof|vec_step|__builtin_omp_required_simd_align|"
-  "__alignof}0">;
 def ext_sizeof_alignof_function_type : Extension<
-  "invalid application of '%sub{select_unary_expr_or_type_trait_kind}0' "
-  "to a function type">, InGroup<PointerArith>;
+  "invalid application of '%0' to a function type">, InGroup<PointerArith>;
 def ext_sizeof_alignof_void_type : Extension<
-  "invalid application of '%sub{select_unary_expr_or_type_trait_kind}0' "
-  "to a void type">, InGroup<PointerArith>;
+  "invalid application of '%0' to a void type">, InGroup<PointerArith>;
 def err_opencl_sizeof_alignof_type : Error<
-  "invalid application of '%sub{select_unary_expr_or_type_trait_kind}0' "
-  "to a void type">;
+  "invalid application of '%0' to a void type">;
 def err_sizeof_alignof_incomplete_or_sizeless_type : Error<
-  "invalid application of '%sub{select_unary_expr_or_type_trait_kind}0' "
-  "to %select{an incomplete|sizeless}1 type %2">;
+  "invalid application of '%0' to %select{an incomplete|sizeless}1 type %2">;
 def err_sizeof_alignof_function_type : Error<
-  "invalid application of '%sub{select_unary_expr_or_type_trait_kind}0' "
-  "to a function type">;
+  "invalid application of '%0' to a function type">;
 def err_openmp_default_simd_align_expr : Error<
   "invalid application of '__builtin_omp_required_simd_align' to an expression, only type is allowed">;
 def err_sizeof_alignof_typeof_bitfield : Error<
   "invalid application of '%select{sizeof|alignof|typeof}0' to bit-field">;
 def err_alignof_member_of_incomplete_type : Error<
   "invalid application of 'alignof' to a field of a class still being defined">;
 def err_vecstep_non_scalar_vector_type : Error<
   "'vec_step' requires built-in scalar or vector type, %0 invalid">;

clang/include/clang/Basic/ExpressionTraits.h

 //===- ExpressionTraits.h - C++ Expression Traits Support Enums -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// Defines enumerations for expression traits intrinsics.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_BASIC_EXPRESSIONTRAITS_H
 #define LLVM_CLANG_BASIC_EXPRESSIONTRAITS_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace clang {
 
-  enum ExpressionTrait {
-    ET_IsLValueExpr,
-    ET_IsRValueExpr
-  };
-}
+#define EXPRESSION_TRAIT(Spelling, Name, Key) ET_##Name,
+#include "clang/Basic/TokenKinds.def"
+  ET_Last = -1
+#define EXPRESSION_TRAIT(Spelling, Name, Key) +1
+#include "clang/Basic/TokenKinds.def"
+
+/// Return the internal name of type trait \p T. Never null.
+const char *getTraitName(ExpressionTrait T) LLVM_READONLY;
+
+/// Return the spelling of the type trait \p TT. Never null.
+const char *getTraitSpelling(ExpressionTrait T) LLVM_READONLY;
+
+} // namespace clang
 
 #endif

clang/include/clang/Basic/TokenKinds.def

 #define TYPE_TRAIT_1(I,E,K) TYPE_TRAIT(1,I,K)
 #endif
 #ifndef TYPE_TRAIT_2
 #define TYPE_TRAIT_2(I,E,K) TYPE_TRAIT(2,I,K)
 #endif
 #ifndef TYPE_TRAIT_N
 #define TYPE_TRAIT_N(I,E,K) TYPE_TRAIT(0,I,K)
 #endif
+#ifndef ARRAY_TYPE_TRAIT
+#define ARRAY_TYPE_TRAIT(I,E,K) KEYWORD(I,K)
+#endif
+#ifndef UNARY_EXPR_OR_TYPE_TRAIT
+#define UNARY_EXPR_OR_TYPE_TRAIT(I,E,K) KEYWORD(I,K)
+#endif
+#ifndef CXX11_UNARY_EXPR_OR_TYPE_TRAIT
+#define CXX11_UNARY_EXPR_OR_TYPE_TRAIT(I,E,K) CXX11_KEYWORD(I,K)
+#endif
+#ifndef EXPRESSION_TRAIT
+#define EXPRESSION_TRAIT(I,E,K) KEYWORD(I,K)
+#endif
 #ifndef ALIAS
 #define ALIAS(X,Y,Z)
 #endif
 #ifndef PPKEYWORD
 #define PPKEYWORD(X)
 #endif
 #ifndef CXX_KEYWORD_OPERATOR
 #define CXX_KEYWORD_OPERATOR(X,Y)
 #endif

 KEYWORD(int                         , KEYALL)
 KEYWORD(_ExtInt                     , KEYALL)
 KEYWORD(long                        , KEYALL)
 KEYWORD(register                    , KEYALL)
 KEYWORD(restrict                    , KEYC99)
 KEYWORD(return                      , KEYALL)
 KEYWORD(short                       , KEYALL)
 KEYWORD(signed                      , KEYALL)
-KEYWORD(sizeof                      , KEYALL)
+UNARY_EXPR_OR_TYPE_TRAIT(sizeof, SizeOf, KEYALL)
 KEYWORD(static                      , KEYALL)
 KEYWORD(struct                      , KEYALL)
 KEYWORD(switch                      , KEYALL)
 KEYWORD(typedef                     , KEYALL)
 KEYWORD(union                       , KEYALL)
 KEYWORD(unsigned                    , KEYALL)
 KEYWORD(void                        , KEYALL)
 KEYWORD(volatile                    , KEYALL)

 CXX_KEYWORD_OPERATOR(not_eq  , exclaimequal)
 CXX_KEYWORD_OPERATOR(or      , pipepipe)
 CXX_KEYWORD_OPERATOR(or_eq   , pipeequal)
 CXX_KEYWORD_OPERATOR(xor     , caret)
 CXX_KEYWORD_OPERATOR(xor_eq  , caretequal)
 
 // C++11 keywords
 CXX11_KEYWORD(alignas               , 0)
-CXX11_KEYWORD(alignof               , 0)
+// alignof and _Alignof return the required ABI alignment
+CXX11_UNARY_EXPR_OR_TYPE_TRAIT(alignof, AlignOf, 0)
 CXX11_KEYWORD(char16_t              , KEYNOMS18)
 CXX11_KEYWORD(char32_t              , KEYNOMS18)
 CXX11_KEYWORD(constexpr             , 0)
 CXX11_KEYWORD(decltype              , 0)
 CXX11_KEYWORD(noexcept              , 0)
 CXX11_KEYWORD(nullptr               , 0)
 CXX11_KEYWORD(static_assert         , KEYMSCOMPAT)
 CXX11_KEYWORD(thread_local          , 0)

 KEYWORD(_Fract                      , KEYNOCXX)
 KEYWORD(_Sat                        , KEYNOCXX)
 
 // GNU Extensions (in impl-reserved namespace)
 KEYWORD(_Decimal32                  , KEYALL)
 KEYWORD(_Decimal64                  , KEYALL)
 KEYWORD(_Decimal128                 , KEYALL)
 KEYWORD(__null                      , KEYCXX)
-KEYWORD(__alignof                   , KEYALL)
+// __alignof returns the preferred alignment of a type, the alignment
+// clang will attempt to give an object of the type if allowed by ABI.
+UNARY_EXPR_OR_TYPE_TRAIT(__alignof, PreferredAlignOf, KEYALL)
 KEYWORD(__attribute                 , KEYALL)
 KEYWORD(__builtin_choose_expr       , KEYALL)
 KEYWORD(__builtin_offsetof          , KEYALL)
 KEYWORD(__builtin_FILE              , KEYALL)
 KEYWORD(__builtin_FUNCTION          , KEYALL)
 KEYWORD(__builtin_LINE              , KEYALL)
 KEYWORD(__builtin_COLUMN            , KEYALL)
 

 TYPE_TRAIT_1(__has_unique_object_representations,
              HasUniqueObjectRepresentations, KEYCXX)
 KEYWORD(__underlying_type           , KEYCXX)
 
 // Clang-only C++ Type Traits
 TYPE_TRAIT_2(__reference_binds_to_temporary, ReferenceBindsToTemporary, KEYCXX)
 
 // Embarcadero Expression Traits
-KEYWORD(__is_lvalue_expr            , KEYCXX)
-KEYWORD(__is_rvalue_expr            , KEYCXX)
+EXPRESSION_TRAIT(__is_lvalue_expr, IsLValueExpr, KEYCXX)
+EXPRESSION_TRAIT(__is_rvalue_expr, IsRValueExpr, KEYCXX)
 
 // Embarcadero Unary Type Traits
 TYPE_TRAIT_1(__is_arithmetic, IsArithmetic, KEYCXX)
 TYPE_TRAIT_1(__is_floating_point, IsFloatingPoint, KEYCXX)
 TYPE_TRAIT_1(__is_integral, IsIntegral, KEYCXX)
 TYPE_TRAIT_1(__is_complete_type, IsCompleteType, KEYCXX)
 TYPE_TRAIT_1(__is_void, IsVoid, KEYCXX)
 TYPE_TRAIT_1(__is_array, IsArray, KEYCXX)

 TYPE_TRAIT_1(__is_const, IsConst, KEYCXX)
 TYPE_TRAIT_1(__is_volatile, IsVolatile, KEYCXX)
 TYPE_TRAIT_1(__is_signed, IsSigned, KEYCXX)
 TYPE_TRAIT_1(__is_unsigned, IsUnsigned, KEYCXX)
 
 // Embarcadero Binary Type Traits
 TYPE_TRAIT_2(__is_same, IsSame, KEYCXX)
 TYPE_TRAIT_2(__is_convertible, IsConvertible, KEYCXX)
-KEYWORD(__array_rank                , KEYCXX)
-KEYWORD(__array_extent              , KEYCXX)
+ARRAY_TYPE_TRAIT(__array_rank, ArrayRank, KEYCXX)
+ARRAY_TYPE_TRAIT(__array_extent, ArrayExtent, KEYCXX)
 // Name for GCC 6 compatibility.
 ALIAS("__is_same_as", __is_same, KEYCXX)
 
 // Apple Extension.
 KEYWORD(__private_extern__          , KEYALL)
 KEYWORD(__module_private__          , KEYALL)
 
 // Extension that will be enabled for Microsoft, Borland and PS4, but can be

 KEYWORD(__read_only                 , KEYOPENCLC | KEYOPENCLCXX)
 KEYWORD(__write_only                , KEYOPENCLC | KEYOPENCLCXX)
 KEYWORD(__read_write                , KEYOPENCLC | KEYOPENCLCXX)
 ALIAS("read_only", __read_only      , KEYOPENCLC | KEYOPENCLCXX)
 ALIAS("write_only", __write_only    , KEYOPENCLC | KEYOPENCLCXX)
 ALIAS("read_write", __read_write    , KEYOPENCLC | KEYOPENCLCXX)
 // OpenCL builtins
 KEYWORD(__builtin_astype            , KEYOPENCLC | KEYOPENCLCXX)
-KEYWORD(vec_step                    , KEYOPENCLC | KEYALTIVEC | KEYZVECTOR)
+UNARY_EXPR_OR_TYPE_TRAIT(vec_step, VecStep, KEYOPENCLC | KEYALTIVEC | KEYZVECTOR)
 #define GENERIC_IMAGE_TYPE(ImgType, Id) KEYWORD(ImgType##_t, KEYOPENCLC | KEYOPENCLCXX)
 #include "clang/Basic/OpenCLImageTypes.def"
 KEYWORD(pipe                        , KEYOPENCLC | KEYOPENCLCXX)
 // C++ for OpenCL s2.3.1: addrspace_cast operator
 KEYWORD(addrspace_cast              , KEYOPENCLCXX)
 
 // OpenMP Type Traits
-KEYWORD(__builtin_omp_required_simd_align, KEYALL)
+UNARY_EXPR_OR_TYPE_TRAIT(__builtin_omp_required_simd_align, OpenMPRequiredSimdAlign, KEYALL)
 
 // Borland Extensions.
 KEYWORD(__pascal                    , KEYALL)
 
 // Altivec Extension.
 KEYWORD(__vector                    , KEYALTIVEC|KEYZVECTOR)
 KEYWORD(__pixel                     , KEYALTIVEC)
 KEYWORD(__bool                      , KEYALTIVEC|KEYZVECTOR)

 
 #undef PRAGMA_ANNOTATION
 #undef ANNOTATION
 #undef TESTING_KEYWORD
 #undef OBJC_AT_KEYWORD
 #undef CXX_KEYWORD_OPERATOR
 #undef PPKEYWORD
 #undef ALIAS
+#undef EXPRESSION_TRAIT
+#undef CXX11_UNARY_EXPR_OR_TYPE_TRAIT
+#undef UNARY_EXPR_OR_TYPE_TRAIT
+#undef ARRAY_TYPE_TRAIT
 #undef TYPE_TRAIT_N
 #undef TYPE_TRAIT_2
 #undef TYPE_TRAIT_1
 #undef TYPE_TRAIT
 #undef CONCEPTS_KEYWORD
 #undef CXX20_KEYWORD
 #undef CXX11_KEYWORD
 #undef KEYWORD
 #undef PUNCTUATOR
 #undef TOK

clang/include/clang/Basic/TypeTraits.h

 //===--- TypeTraits.h - C++ Type Traits Support Enumerations ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// Defines enumerations for the type traits support.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_BASIC_TYPETRAITS_H
 #define LLVM_CLANG_BASIC_TYPETRAITS_H
 
-namespace clang {
+#include "llvm/Support/Compiler.h"
 
-  /// Names for traits that operate specifically on types.
-  enum TypeTrait {
-    UTT_HasNothrowAssign,
-    UTT_HasNothrowMoveAssign,
-    UTT_HasNothrowCopy,
-    UTT_HasNothrowConstructor,
-    UTT_HasTrivialAssign,
-    UTT_HasTrivialMoveAssign,
-    UTT_HasTrivialCopy,
-    UTT_HasTrivialDefaultConstructor,
-    UTT_HasTrivialMoveConstructor,
-    UTT_HasTrivialDestructor,
-    UTT_HasVirtualDestructor,
-    UTT_IsAbstract,
-    UTT_IsAggregate,
-    UTT_IsArithmetic,
-    UTT_IsArray,
-    UTT_IsClass,
-    UTT_IsCompleteType,
-    UTT_IsCompound,
-    UTT_IsConst,
-    UTT_IsDestructible,
-    UTT_IsEmpty,
-    UTT_IsEnum,
-    UTT_IsFinal,
-    UTT_IsFloatingPoint,
-    UTT_IsFunction,
-    UTT_IsFundamental,
-    UTT_IsIntegral,
-    UTT_IsInterfaceClass,
-    UTT_IsLiteral,
-    UTT_IsLvalueReference,
-    UTT_IsMemberFunctionPointer,
-    UTT_IsMemberObjectPointer,
-    UTT_IsMemberPointer,
-    UTT_IsNothrowDestructible,
-    UTT_IsObject,
-    UTT_IsPOD,
-    UTT_IsPointer,
-    UTT_IsPolymorphic,
-    UTT_IsReference,
-    UTT_IsRvalueReference,
-    UTT_IsScalar,
-    UTT_IsSealed,
-    UTT_IsSigned,
-    UTT_IsStandardLayout,
-    UTT_IsTrivial,
-    UTT_IsTriviallyCopyable,
-    UTT_IsTriviallyDestructible,
-    UTT_IsUnion,
-    UTT_IsUnsigned,
-    UTT_IsVoid,
-    UTT_IsVolatile,
-    UTT_HasUniqueObjectRepresentations,
-    UTT_Last = UTT_HasUniqueObjectRepresentations,
-    BTT_IsBaseOf,
-    BTT_IsConvertible,
-    BTT_IsConvertibleTo,
-    BTT_IsSame,
-    BTT_TypeCompatible,
-    BTT_IsAssignable,
-    BTT_IsNothrowAssignable,
-    BTT_IsTriviallyAssignable,
-    BTT_ReferenceBindsToTemporary,
-    BTT_Last = BTT_ReferenceBindsToTemporary,
-    TT_IsConstructible,
-    TT_IsNothrowConstructible,
-    TT_IsTriviallyConstructible
-  };
+namespace clang {
+#define TYPE_TRAIT_1(Spelling, Name, Key) UTT_##Name,
+#include "clang/Basic/TokenKinds.def"
+  UTT_Last = -1
+#define TYPE_TRAIT_1(Spelling, Name, Key) +1
+#include "clang/Basic/TokenKinds.def"
+  ,
+#define TYPE_TRAIT_2(Spelling, Name, Key) BTT_##Name,
+#include "clang/Basic/TokenKinds.def"
+  BTT_Last = UTT_Last
+#define TYPE_TRAIT_2(Spelling, Name, Key) +1
+#include "clang/Basic/TokenKinds.def"
+  ,
+#define TYPE_TRAIT_N(Spelling, Name, Key) TT_##Name,
+#include "clang/Basic/TokenKinds.def"
+  TT_Last = BTT_Last
+#define TYPE_TRAIT_N(Spelling, Name, Key) +1
+#include "clang/Basic/TokenKinds.def"
 
-  /// Names for the array type traits.
-  enum ArrayTypeTrait {
-    ATT_ArrayRank,
-    ATT_ArrayExtent
-  };
+#define ARRAY_TYPE_TRAIT(Spelling, Name, Key) ATT_##Name,
+#include "clang/Basic/TokenKinds.def"
+  ATT_Last = -1
+#define ARRAY_TYPE_TRAIT(Spelling, Name, Key) +1
+#include "clang/Basic/TokenKinds.def"
 
-  /// Names for the "expression or type" traits.
-  enum UnaryExprOrTypeTrait {
-    UETT_SizeOf,
-    /// Used for C's _Alignof and C++'s alignof.
-    /// _Alignof and alignof return the required ABI alignment.
-    UETT_AlignOf,
-    UETT_VecStep,
-    UETT_OpenMPRequiredSimdAlign,
-    /// Used for GCC's __alignof.
-    /// __alignof returns the preferred alignment of a type, the alignment
-    /// clang will attempt to give an object of the type if allowed by ABI.
-    UETT_PreferredAlignOf,
-  };
-}
+#define UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key) UETT_##Name,
+#define CXX11_UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key) UETT_##Name,
+#include "clang/Basic/TokenKinds.def"
+  UETT_Last = -1
+#define UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key) +1
+#define CXX11_UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key) +1
+#include "clang/Basic/TokenKinds.def"
+
+/// Return the internal name of type trait \p T. Never null.
+const char *getTraitName(TypeTrait T) LLVM_READONLY;
+const char *getTraitName(ArrayTypeTrait T) LLVM_READONLY;
+const char *getTraitName(UnaryExprOrTypeTrait T) LLVM_READONLY;
+
+/// Return the spelling of the type trait \p TT. Never null.
+const char *getTraitSpelling(TypeTrait T) LLVM_READONLY;
+const char *getTraitSpelling(ArrayTypeTrait T) LLVM_READONLY;
+const char *getTraitSpelling(UnaryExprOrTypeTrait T) LLVM_READONLY;
+} // namespace clang
 
 #endif

clang/lib/AST/JSONNodeDumper.cpp

 }
 
 void JSONNodeDumper::VisitCallExpr(const CallExpr *CE) {
   attributeOnlyIfTrue("adl", CE->usesADL());
 }
 
 void JSONNodeDumper::VisitUnaryExprOrTypeTraitExpr(
     const UnaryExprOrTypeTraitExpr *TTE) {
-  switch (TTE->getKind()) {
-  case UETT_SizeOf: JOS.attribute("name", "sizeof"); break;
-  case UETT_AlignOf: JOS.attribute("name", "alignof"); break;
-  case UETT_VecStep:  JOS.attribute("name", "vec_step"); break;
-  case UETT_PreferredAlignOf:  JOS.attribute("name", "__alignof"); break;
-  case UETT_OpenMPRequiredSimdAlign:
-    JOS.attribute("name", "__builtin_omp_required_simd_align"); break;
-  }
+  JOS.attribute("name", getTraitSpelling(TTE->getKind()));
   if (TTE->isArgumentType())
     JOS.attribute("argType", createQualType(TTE->getArgumentType()));
 }
 
 void JSONNodeDumper::VisitSizeOfPackExpr(const SizeOfPackExpr *SOPE) {
   VisitNamedDecl(SOPE->getPack());
 }
 

clang/lib/AST/StmtPrinter.cpp

if (PrintedSomething)
       OS << ".";
     else
       PrintedSomething = true;
     OS << Id->getName();
   }
   OS << ")";
 }
 
-void StmtPrinter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *Node){
-  switch(Node->getKind()) {
-  case UETT_SizeOf:
-    OS << "sizeof";
-    break;
-  case UETT_AlignOf:
+void StmtPrinter::VisitUnaryExprOrTypeTraitExpr(
+    UnaryExprOrTypeTraitExpr *Node) {
+  const char *Spelling = getTraitSpelling(Node->getKind());
+  if (Node->getKind() == UETT_AlignOf) {
     if (Policy.Alignof)
-      OS << "alignof";
+      Spelling = "alignof";
     else if (Policy.UnderscoreAlignof)
-      OS << "_Alignof";
+      Spelling = "_Alignof";
     else
-      OS << "__alignof";
-    break;
-  case UETT_PreferredAlignOf:
-    OS << "__alignof";
-    break;
-  case UETT_VecStep:
-    OS << "vec_step";
-    break;
-  case UETT_OpenMPRequiredSimdAlign:
-    OS << "__builtin_omp_required_simd_align";
-    break;
+      Spelling = "__alignof";
   }
+
+  OS << Spelling;
+
   if (Node->isArgumentType()) {
     OS << '(';
     Node->getArgumentType().print(OS, Policy);
     OS << ')';
   } else {
     OS << " ";
     PrintExpr(Node->getArgumentExpr());
   }
if (NestedNameSpecifier *Qualifier = Node->getQualifier())
     Qualifier->print(OS, Policy);
   if (Node->hasTemplateKeyword())
     OS << "template ";
   OS << Node->getMemberNameInfo();
   if (Node->hasExplicitTemplateArgs())
     printTemplateArgumentList(OS, Node->template_arguments(), Policy);
 }
 
-static const char *getTypeTraitName(TypeTrait TT) {
-  switch (TT) {
-#define TYPE_TRAIT_1(Spelling, Name, Key) \
-case clang::UTT_##Name: return #Spelling;
-#define TYPE_TRAIT_2(Spelling, Name, Key) \
-case clang::BTT_##Name: return #Spelling;
-#define TYPE_TRAIT_N(Spelling, Name, Key) \
-  case clang::TT_##Name: return #Spelling;
-#include "clang/Basic/TokenKinds.def"
-  }
-  llvm_unreachable("Type trait not covered by switch");
-}
-
-static const char *getTypeTraitName(ArrayTypeTrait ATT) {
-  switch (ATT) {
-  case ATT_ArrayRank:        return "__array_rank";
-  case ATT_ArrayExtent:      return "__array_extent";
-  }
-  llvm_unreachable("Array type trait not covered by switch");
-}
-
-static const char *getExpressionTraitName(ExpressionTrait ET) {
-  switch (ET) {
-  case ET_IsLValueExpr:      return "__is_lvalue_expr";
-  case ET_IsRValueExpr:      return "__is_rvalue_expr";
-  }
-  llvm_unreachable("Expression type trait not covered by switch");
-}
-
 void StmtPrinter::VisitTypeTraitExpr(TypeTraitExpr *E) {
-  OS << getTypeTraitName(E->getTrait()) << "(";
+  OS << getTraitSpelling(E->getTrait()) << "(";
   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
     if (I > 0)
       OS << ", ";
     E->getArg(I)->getType().print(OS, Policy);
   }
   OS << ")";
 }
 
 void StmtPrinter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
-  OS << getTypeTraitName(E->getTrait()) << '(';
+  OS << getTraitSpelling(E->getTrait()) << '(';
   E->getQueriedType().print(OS, Policy);
   OS << ')';
 }
 
 void StmtPrinter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
-  OS << getExpressionTraitName(E->getTrait()) << '(';
+  OS << getTraitSpelling(E->getTrait()) << '(';
   PrintExpr(E->getQueriedExpression());
   OS << ')';
 }
 
 void StmtPrinter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
   OS << "noexcept(";
   PrintExpr(E->getOperand());
   OS << ")";

clang/lib/AST/TextNodeDumper.cpp

 #include "clang/AST/TextNodeDumper.h"
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclOpenMP.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/LocInfoType.h"
 #include "clang/Basic/Module.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Specifiers.h"
+#include "clang/Basic/TypeTraits.h"
 
 using namespace clang;
 
 static void dumpPreviousDeclImpl(raw_ostream &OS, ...) {}
 
 template <typename T>
 static void dumpPreviousDeclImpl(raw_ostream &OS, const Mergeable<T> *D) {
   const T *First = D->getFirstDecl();
void TextNodeDumper::VisitUnaryOperator(const UnaryOperator *Node) {
   OS << " " << (Node->isPostfix() ? "postfix" : "prefix") << " '"
      << UnaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
   if (!Node->canOverflow())
     OS << " cannot overflow";
 }
 
 void TextNodeDumper::VisitUnaryExprOrTypeTraitExpr(
     const UnaryExprOrTypeTraitExpr *Node) {
-  switch (Node->getKind()) {
-  case UETT_SizeOf:
-    OS << " sizeof";
-    break;
-  case UETT_AlignOf:
-    OS << " alignof";
-    break;
-  case UETT_VecStep:
-    OS << " vec_step";
-    break;
-  case UETT_OpenMPRequiredSimdAlign:
-    OS << " __builtin_omp_required_simd_align";
-    break;
-  case UETT_PreferredAlignOf:
-    OS << " __alignof";
-    break;
-  }
+  OS << " " << getTraitSpelling(Node->getKind());
+
   if (Node->isArgumentType())
     dumpType(Node->getArgumentType());
 }
 
 void TextNodeDumper::VisitMemberExpr(const MemberExpr *Node) {
   OS << " " << (Node->isArrow() ? "->" : ".") << *Node->getMemberDecl();
   dumpPointer(Node->getMemberDecl());
   switch (Node->isNonOdrUse()) {

clang/lib/ASTMatchers/Dynamic/Marshallers.h

public:
 
   static llvm::Optional<std::string> getBestGuess(const VariantValue &Value);
 };
 
 template <> struct ArgTypeTraits<UnaryExprOrTypeTrait> {
 private:
   static Optional<UnaryExprOrTypeTrait>
   getUnaryOrTypeTraitKind(llvm::StringRef ClauseKind) {
-    // FIXME: Type traits should probably be in a `.def` to make less error
-    // prone.
     return llvm::StringSwitch<Optional<UnaryExprOrTypeTrait>>(ClauseKind)
-        .Case("UETT_SizeOf", UETT_SizeOf)
-        .Case("UETT_AlignOf", UETT_AlignOf)
-        .Case("UETT_VecStep", UETT_VecStep)
-        .Case("UETT_OpenMPRequiredSimdAlign", UETT_OpenMPRequiredSimdAlign)
-        .Case("UETT_PreferredAlignOf", UETT_PreferredAlignOf)
+#define UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key)                          \
+  .Case("UETT_" #Name, UETT_##Name)
+#define CXX11_UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key)                    \
+  .Case("UETT_" #Name, UETT_##Name)
+#include "clang/Basic/TokenKinds.def"
         .Default(llvm::None);
   }
 
 public:
   static bool is(const VariantValue &Value) {
     return Value.isString() && getUnaryOrTypeTraitKind(Value.getString());
   }
 

clang/lib/ASTMatchers/Dynamic/Marshallers.cpp

return ::getBestGuess(Value.getString(), llvm::makeArrayRef(Allowed),
                           "OMPC_");
   return llvm::None;
 }
 
 llvm::Optional<std::string>
 clang::ast_matchers::dynamic::internal::ArgTypeTraits<
     clang::UnaryExprOrTypeTrait>::getBestGuess(const VariantValue &Value) {
   static constexpr llvm::StringRef Allowed[] = {
-      "UETT_SizeOf",           "UETT_AlignOf",
-      "UETT_VecStep",          "UETT_OpenMPRequiredSimdAlign",
-      "UETT_PreferredAlignOf",
+#define UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key) "UETT_" #Name,
+#define CXX11_UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key) "UETT_" #Name,
+#include "clang/Basic/TokenKinds.def"
   };
   if (Value.isString())
     return ::getBestGuess(Value.getString(), llvm::makeArrayRef(Allowed),
                           "UETT_");
   return llvm::None;
 }

clang/lib/Basic/CMakeLists.txt

add_clang_library(clangBasic
   Attributes.cpp
   Builtins.cpp
   CharInfo.cpp
   CodeGenOptions.cpp
   Cuda.cpp
   Diagnostic.cpp
   DiagnosticIDs.cpp
   DiagnosticOptions.cpp
+  ExpressionTraits.cpp
   FileManager.cpp
   FileSystemStatCache.cpp
   FixedPoint.cpp
   IdentifierTable.cpp
   LangOptions.cpp
   LangStandards.cpp
   Module.cpp
   ObjCRuntime.cpp
add_clang_library(clangBasic
   Targets/SPIR.cpp
   Targets/Sparc.cpp
   Targets/SystemZ.cpp
   Targets/TCE.cpp
   Targets/WebAssembly.cpp
   Targets/X86.cpp
   Targets/XCore.cpp
   TokenKinds.cpp
+  TypeTraits.cpp
   Version.cpp
   Warnings.cpp
   XRayInstr.cpp
   XRayLists.cpp
   ${version_inc}
   )
 

clang/lib/Basic/ExpressionTraits.cpp

+//===--- ExpressionTraits.cpp - Expression Traits Support -----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file implements the expression traits support functions.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Basic/ExpressionTraits.h"
+#include "llvm/Support/ErrorHandling.h"
+#include <cassert>
+using namespace clang;
+
+static constexpr const char *ExpressionTraitNames[] = {
+#define EXPRESSION_TRAIT(Spelling, Name, Key) #Name,
+#include "clang/Basic/TokenKinds.def"
+};
+
+static constexpr const char *ExpressionTraitSpellings[] = {
+#define EXPRESSION_TRAIT(Spelling, Name, Key) #Spelling,
+#include "clang/Basic/TokenKinds.def"
+};
+
+const char *clang::getTraitName(ExpressionTrait T) {
+  assert(T <= ET_Last && "invalid enum value!");
+  return ExpressionTraitNames[T];
+}
+
+const char *clang::getTraitSpelling(ExpressionTrait T) {
+  assert(T <= ET_Last && "invalid enum value!");
+  return ExpressionTraitSpellings[T];
+}

clang/lib/Basic/TypeTraits.cpp

+//===--- TypeTraits.cpp - Type Traits Support -----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file implements the type traits support functions.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Basic/TypeTraits.h"
+#include "llvm/Support/ErrorHandling.h"
+#include <cassert>
+using namespace clang;
+
+static constexpr const char *TypeTraitNames[] = {
+#define TYPE_TRAIT_1(Spelling, Name, Key) #Name,
+#include "clang/Basic/TokenKinds.def"
+#define TYPE_TRAIT_2(Spelling, Name, Key) #Name,
+#include "clang/Basic/TokenKinds.def"
+#define TYPE_TRAIT_N(Spelling, Name, Key) #Name,
+#include "clang/Basic/TokenKinds.def"
+};
+
+static constexpr const char *TypeTraitSpellings[] = {
+#define TYPE_TRAIT_1(Spelling, Name, Key) #Spelling,
+#include "clang/Basic/TokenKinds.def"
+#define TYPE_TRAIT_2(Spelling, Name, Key) #Spelling,
+#include "clang/Basic/TokenKinds.def"
+#define TYPE_TRAIT_N(Spelling, Name, Key) #Spelling,
+#include "clang/Basic/TokenKinds.def"
+};
+
+static constexpr const char *ArrayTypeTraitNames[] = {
+#define ARRAY_TYPE_TRAIT(Spelling, Name, Key) #Name,
+#include "clang/Basic/TokenKinds.def"
+};
+
+static constexpr const char *ArrayTypeTraitSpellings[] = {
+#define ARRAY_TYPE_TRAIT(Spelling, Name, Key) #Spelling,
+#include "clang/Basic/TokenKinds.def"
+};
+
+static constexpr const char *UnaryExprOrTypeTraitNames[] = {
+#define UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key) #Name,
+#define CXX11_UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key) #Name,
+#include "clang/Basic/TokenKinds.def"
+};
+
+static constexpr const char *UnaryExprOrTypeTraitSpellings[] = {
+#define UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key) #Spelling,
+#define CXX11_UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key) #Spelling,
+#include "clang/Basic/TokenKinds.def"
+};
+
+const char *clang::getTraitName(TypeTrait T) {
+  assert(T <= TT_Last && "invalid enum value!");
+  return TypeTraitNames[T];
+}
+
+const char *clang::getTraitName(ArrayTypeTrait T) {
+  assert(T <= ATT_Last && "invalid enum value!");
+  return ArrayTypeTraitNames[T];
+}
+
+const char *clang::getTraitName(UnaryExprOrTypeTrait T) {
+  assert(T <= UETT_Last && "invalid enum value!");
+  return UnaryExprOrTypeTraitNames[T];
+}
+
+const char *clang::getTraitSpelling(TypeTrait T) {
+  assert(T <= TT_Last && "invalid enum value!");
+  return TypeTraitSpellings[T];
+}
+
+const char *clang::getTraitSpelling(ArrayTypeTrait T) {
+  assert(T <= ATT_Last && "invalid enum value!");
+  return ArrayTypeTraitSpellings[T];
+}
+
+const char *clang::getTraitSpelling(UnaryExprOrTypeTrait T) {
+  assert(T <= UETT_Last && "invalid enum value!");
+  return UnaryExprOrTypeTraitSpellings[T];
+}

clang/lib/Sema/SemaExpr.cpp

if (S.LangOpts.CPlusPlus)
     return true;
 
   // C99 6.5.3.4p1:
   if (T->isFunctionType() &&
       (TraitKind == UETT_SizeOf || TraitKind == UETT_AlignOf ||
        TraitKind == UETT_PreferredAlignOf)) {
     // sizeof(function)/alignof(function) is allowed as an extension.
     S.Diag(Loc, diag::ext_sizeof_alignof_function_type)
-      << TraitKind << ArgRange;
+        << getTraitSpelling(TraitKind) << ArgRange;
     return false;
   }
 
   // Allow sizeof(void)/alignof(void) as an extension, unless in OpenCL where
   // this is an error (OpenCL v1.1 s6.3.k)
   if (T->isVoidType()) {
     unsigned DiagID = S.LangOpts.OpenCL ? diag::err_opencl_sizeof_alignof_type
                                         : diag::ext_sizeof_alignof_void_type;
-    S.Diag(Loc, DiagID) << TraitKind << ArgRange;
+    S.Diag(Loc, DiagID) << getTraitSpelling(TraitKind) << ArgRange;
     return false;
   }
 
   return true;
 }
 
 static bool CheckObjCTraitOperandConstraints(Sema &S, QualType T,
                                              SourceLocation Loc,
bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E,
 
   // 'alignof' applied to an expression only requires the base element type of
   // the expression to be complete. 'sizeof' requires the expression's type to
   // be complete (and will attempt to complete it if it's an array of unknown
   // bound).
   if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf) {
     if (RequireCompleteSizedType(
             E->getExprLoc(), Context.getBaseElementType(E->getType()),
-            diag::err_sizeof_alignof_incomplete_or_sizeless_type, ExprKind,
-            E->getSourceRange()))
+            diag::err_sizeof_alignof_incomplete_or_sizeless_type,
+            getTraitSpelling(ExprKind), E->getSourceRange()))
       return true;
   } else {
     if (RequireCompleteSizedExprType(
-            E, diag::err_sizeof_alignof_incomplete_or_sizeless_type, ExprKind,
-            E->getSourceRange()))
+            E, diag::err_sizeof_alignof_incomplete_or_sizeless_type,
+            getTraitSpelling(ExprKind), E->getSourceRange()))
       return true;
   }
 
   // Completing the expression's type may have changed it.
   ExprTy = E->getType();
   assert(!ExprTy->isReferenceType());
 
   if (ExprTy->isFunctionType()) {
     Diag(E->getExprLoc(), diag::err_sizeof_alignof_function_type)
-      << ExprKind << E->getSourceRange();
+        << getTraitSpelling(ExprKind) << E->getSourceRange();
     return true;
   }
 
   // The operand for sizeof and alignof is in an unevaluated expression context,
   // so side effects could result in unintended consequences.
   if (IsUnevaluatedOperand && !inTemplateInstantiation() &&
       E->HasSideEffects(Context, false))
     Diag(E->getExprLoc(), diag::warn_side_effects_unevaluated_context);
bool Sema::CheckUnaryExprOrTypeTraitOperand(QualType ExprType,
 
   // Whitelist some types as extensions
   if (!CheckExtensionTraitOperandType(*this, ExprType, OpLoc, ExprRange,
                                       ExprKind))
     return false;
 
   if (RequireCompleteSizedType(
           OpLoc, ExprType, diag::err_sizeof_alignof_incomplete_or_sizeless_type,
-          ExprKind, ExprRange))
+          getTraitSpelling(ExprKind), ExprRange))
     return true;
 
   if (ExprType->isFunctionType()) {
     Diag(OpLoc, diag::err_sizeof_alignof_function_type)
-      << ExprKind << ExprRange;
+        << getTraitSpelling(ExprKind) << ExprRange;
     return true;
   }
 
   if (CheckObjCTraitOperandConstraints(*this, ExprType, OpLoc, ExprRange,
                                        ExprKind))
     return true;
 
   return false;