review: remove api of consumeExpectedToken for multiple token kinds

- using `consumeExpectedToken` with multiple expected tokens leads to
poor handling of diagnostic messaging and would largely be used in cases
where more specific errors could be done
- instead we should limit the api to just using `consumeExpectedToken`
with only a specific token and to only be used when it is very clear
that only one specific token should follow after another

Author: Finn Plummer

clang/include/clang/Lex/LexHLSLRootSignature.h

@@ -13,6 +13,7 @@
 #ifndef LLVM_CLANG_LEX_LEXHLSLROOTSIGNATURE_H
 #define LLVM_CLANG_LEX_LEXHLSLROOTSIGNATURE_H
 
+#include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceLocation.h"
 
 #include "llvm/ADT/SmallVector.h"
@@ -43,6 +44,18 @@ struct RootSignatureToken {
 };
 using TokenKind = enum RootSignatureToken::Kind;
 
+inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
+                                           const TokenKind Kind) {
+  switch (Kind) {
+#define TOK(X, SPELLING)                                                       \
+  case TokenKind::X:                                                           \
+    DB << SPELLING;                                                            \
+    break;
+#include "clang/Lex/HLSLRootSignatureTokenKinds.def"
+  }
+  return DB;
+}
+
 class RootSignatureLexer {
 public:
   RootSignatureLexer(StringRef Signature, clang::SourceLocation SourceLoc)

clang/include/clang/Parse/ParseHLSLRootSignature.h

@@ -83,9 +83,6 @@ class RootSignatureParser {
   bool consumeExpectedToken(TokenKind Expected,
                             unsigned DiagID = diag::err_expected,
                             TokenKind Context = TokenKind::invalid);
-  bool consumeExpectedToken(ArrayRef<TokenKind> AnyExpected,
-                            unsigned DiagID = diag::err_expected,
-                            TokenKind Context = TokenKind::invalid);
 
   /// Peek if the next token is of the expected kind and if it is then consume
   /// it.

clang/lib/Parse/ParseHLSLRootSignature.cpp

@@ -15,26 +15,6 @@ using namespace llvm::hlsl::rootsig;
 namespace clang {
 namespace hlsl {
 
-static std::string FormatTokenKinds(ArrayRef<TokenKind> Kinds) {
-  std::string TokenString;
-  llvm::raw_string_ostream Out(TokenString);
-  bool First = true;
-  for (auto Kind : Kinds) {
-    if (!First)
-      Out << ", ";
-    switch (Kind) {
-#define TOK(X, SPELLING)                                                       \
-  case TokenKind::X:                                                           \
-    Out << SPELLING;                                                           \
-    break;
-#include "clang/Lex/HLSLRootSignatureTokenKinds.def"
-    }
-    First = false;
-  }
-
-  return TokenString;
-}
-
 RootSignatureParser::RootSignatureParser(SmallVector<RootElement> &Elements,
                                          RootSignatureLexer &Lexer,
                                          Preprocessor &PP)
@@ -141,24 +121,18 @@ bool RootSignatureParser::peekExpectedToken(ArrayRef<TokenKind> AnyExpected) {
 bool RootSignatureParser::consumeExpectedToken(TokenKind Expected,
                                                unsigned DiagID,
                                                TokenKind Context) {
-  return consumeExpectedToken(ArrayRef{Expected}, DiagID, Context);
-}
-
-bool RootSignatureParser::consumeExpectedToken(ArrayRef<TokenKind> AnyExpected,
-                                               unsigned DiagID,
-                                               TokenKind Context) {
-  if (tryConsumeExpectedToken(AnyExpected))
+  if (tryConsumeExpectedToken(Expected))
     return false;
 
   // Report unexpected token kind error
   DiagnosticBuilder DB = getDiags().Report(CurToken.TokLoc, DiagID);
   switch (DiagID) {
   case diag::err_expected:
-    DB << FormatTokenKinds(AnyExpected);
+    DB << Expected;
     break;
   case diag::err_expected_either:
   case diag::err_expected_after:
-    DB << FormatTokenKinds(AnyExpected) << FormatTokenKinds({Context});
+    DB << Expected << Context;
     break;
   default:
     break;