self-review: move token spellings to definition

Author: inbelic

clang/include/clang/Lex/HLSLRootSignatureTokenKinds.def

@@ -14,16 +14,16 @@
 //===----------------------------------------------------------------------===//
 
 #ifndef TOK
-#define TOK(X)
+#define TOK(X, SPELLING)
 #endif
 #ifndef PUNCTUATOR
-#define PUNCTUATOR(X,Y) TOK(pu_ ## X)
+#define PUNCTUATOR(X,Y) TOK(pu_ ## X, Y)
 #endif
 #ifndef KEYWORD
-#define KEYWORD(X) TOK(kw_ ## X)
+#define KEYWORD(X) TOK(kw_ ## X, #X)
 #endif
 #ifndef ENUM
-#define ENUM(NAME, LIT) TOK(en_ ## NAME)
+#define ENUM(NAME, LIT) TOK(en_ ## NAME, LIT)
 #endif
 
 // Defines the various types of enum
@@ -49,15 +49,15 @@
 #endif
 
 // General Tokens:
-TOK(invalid)
-TOK(end_of_stream)
-TOK(int_literal)
+TOK(invalid, "invalid identifier")
+TOK(end_of_stream, "end of stream")
+TOK(int_literal, "integer literal")
 
 // Register Tokens:
-TOK(bReg)
-TOK(tReg)
-TOK(uReg)
-TOK(sReg)
+TOK(bReg, "b register")
+TOK(tReg, "t register")
+TOK(uReg, "u register")
+TOK(sReg, "s register")
 
 // Punctuators:
 PUNCTUATOR(l_paren, '(')

clang/include/clang/Lex/LexHLSLRootSignature.h

@@ -24,7 +24,7 @@ namespace hlsl {
 
 struct RootSignatureToken {
   enum Kind {
-#define TOK(X) X,
+#define TOK(X, SPELLING) X,
 #include "clang/Lex/HLSLRootSignatureTokenKinds.def"
   };
 

clang/lib/Parse/ParseHLSLRootSignature.cpp

@@ -17,38 +17,9 @@ static std::string FormatTokenKinds(ArrayRef<TokenKind> Kinds) {
     if (!First)
       Out << ", ";
     switch (Kind) {
-    case TokenKind::invalid:
-      Out << "invalid identifier";
-      break;
-    case TokenKind::end_of_stream:
-      Out << "end of stream";
-      break;
-    case TokenKind::int_literal:
-      Out << "integer literal";
-      break;
-    case TokenKind::bReg:
-      Out << "b register";
-      break;
-    case TokenKind::tReg:
-      Out << "t register";
-      break;
-    case TokenKind::uReg:
-      Out << "u register";
-      break;
-    case TokenKind::sReg:
-      Out << "s register";
-      break;
-#define PUNCTUATOR(X, Y)                                                       \
-  case TokenKind::pu_##X:                                                      \
-    Out << #Y;                                                                 \
-    break;
-#define KEYWORD(NAME)                                                          \
-  case TokenKind::kw_##NAME:                                                   \
-    Out << #NAME;                                                              \
-    break;
-#define ENUM(NAME, LIT)                                                        \
-  case TokenKind::en_##NAME:                                                   \
-    Out << LIT;                                                                \
+#define TOK(X, SPELLING)                                                       \
+  case TokenKind::X:                                                           \
+    Out << SPELLING;                                                           \
     break;
 #include "clang/Lex/HLSLRootSignatureTokenKinds.def"
     }

clang/unittests/Lex/LexHLSLRootSignatureTest.cpp

@@ -113,7 +113,7 @@ TEST_F(LexHLSLRootSignatureTest, ValidLexAllTokensTest) {
 
   SmallVector<hlsl::RootSignatureToken> Tokens;
   SmallVector<hlsl::TokenKind> Expected = {
-#define TOK(NAME) hlsl::TokenKind::NAME,
+#define TOK(NAME, SPELLING) hlsl::TokenKind::NAME,
 #include "clang/Lex/HLSLRootSignatureTokenKinds.def"
   };