[clang-format][tests] Fix MacroExpander lexer not parsing C++ keywords

[arichardson]

Summary

While debugging a different clang-format failure, I tried to reuse the
MacroExpander lexer, but was surprised to see that it marks all C++
keywords (e.g. const, decltype) as being of type identifier. After stepping
through the ::format() code, I noticed that the difference between these
two is that the identifier table was not being initialized based on the
FormatStyle, so only basic tokens such as tok::semi, tok::plus, etc. were
being handled.

[klimek]

Nice catch, thanks! LG!

clang/unittests/Format/MacroExpanderTest.cpp

TEST_F(MacroExpanderTest, SingleExpansion) {
   std::vector<MacroAttributes> Attributes = {
       {tok::identifier, MR_ExpandedArg, 1, 0, {A}},
       {tok::plus, MR_Hidden, 0, 0, {A}},
       {tok::identifier, MR_Hidden, 0, 1, {A}},
   };
   EXPECT_ATTRIBUTES(Result, Attributes);
 }
 
+TEST_F(MacroExpanderTest, UnderstandsCppTokens) {
+  auto Macros = create({"A(T,name)=T name = 0;"});
+  auto *A = Lex.id("A");
+  auto Args = lexArgs({"const int", "x"});
+  auto Result = uneof(Macros->expand(A, Args));
+  std::vector<MacroAttributes> Attributes = {
+      {tok::kw_const, MR_ExpandedArg, 1, 0, {A}},
+      {tok::kw_int, MR_ExpandedArg, 0, 0, {A}},
+      {tok::identifier, MR_ExpandedArg, 0, 0, {A}},
+      {tok::equal, MR_Hidden, 0, 0, {A}},
+      {tok::numeric_constant, MR_Hidden, 0, 0, {A}},
+      {tok::semi, MR_Hidden, 0, 1, {A}},
+  };
+  EXPECT_ATTRIBUTES(Result, Attributes);
+}
+
 } // namespace
 } // namespace format
 } // namespace clang

clang/unittests/Format/TestLexer.h

inline std::string text(llvm::ArrayRef<FormatToken *> Tokens) {
   return std::accumulate(Tokens.begin(), Tokens.end(), std::string(),
                          [](const std::string &R, FormatToken *Tok) {
                            return (R + Tok->TokenText).str();
                          });
 }
 
 class TestLexer {
 public:
-  TestLexer() : SourceMgr("test.cpp", "") {}
+  TestLexer(FormatStyle Style = getLLVMStyle())
+      : Style(Style), SourceMgr("test.cpp", ""),
+        IdentTable(getFormattingLangOpts(Style)) {}
 
   TokenList lex(llvm::StringRef Code) {
     Buffers.push_back(
         llvm::MemoryBuffer::getMemBufferCopy(Code, "<scratch space>"));
     clang::FileID FID = SourceMgr.get().createFileID(SourceManager::Unowned,
                                                      Buffers.back().get());
     FormatTokenLexer Lex(SourceMgr.get(), FID, 0, Style, Encoding, Allocator,
                          IdentTable);
     auto Result = Lex.lex();
     return TokenList(Result.begin(), Result.end());
   }
 
   FormatToken *id(llvm::StringRef Code) {
     auto Result = uneof(lex(Code));
     assert(Result.size() == 1U && "Code must expand to 1 token.");
     return Result[0];
   }
 
-  FormatStyle Style = getLLVMStyle();
+  FormatStyle Style;
   encoding::Encoding Encoding = encoding::Encoding_UTF8;
   std::vector<std::unique_ptr<llvm::MemoryBuffer>> Buffers;
   clang::SourceManagerForFile SourceMgr;
   llvm::SpecificBumpPtrAllocator<FormatToken> Allocator;
   IdentifierTable IdentTable;
 };
 
 } // namespace format
 } // namespace clang
 
 #endif // LLVM_CLANG_UNITTESTS_FORMAT_TEST_LEXER_H