[clangd] Add isKeyword function.

[hokein]

Summary

This will be used in rename for doing basic name validation.

[sammccall]

clang-tools-extra/clangd/SourceCode.cpp

638

this builds a pretty decent sized hashtable for each call, because LangOpts isn't constant.

We could consider exposing getKeywordStatus from IdentifierTable.h, then we could build a StringMap<TokenKind> (once, statically) and then call getKeywordStatus to apply the per-langopts logic.
In fact that StringMap might also be generally nice to expose in TokenKinds.h... as long as there are no conflicts.

Or we could have cache map from LangOpts to IdentifierTable, since we won't see many sets in practice.

Or maybe it doesn't matter, I suppose!

clang-tools-extra/clangd/unittests/SourceCodeTests.cpp

794

demonstrate some sensitivity to langopts?

e.g. set CPlusPlus20 to true then check co_await

[hokein]

address code comments.

clang-tools-extra/clangd/SourceCode.cpp

638

Or maybe it doesn't matter, I suppose!

this is my impression as well, there are ~120 keywords for C++, I think the number is not too big.

clang-tools-extra/clangd/SourceCode.h

struct SpelledWord {
   const syntax::Token *ExpandedToken = nullptr;
 
   // Find the unique word that contains SpelledLoc or starts/ends there.
   static llvm::Optional<SpelledWord> touching(SourceLocation SpelledLoc,
                                               const syntax::TokenBuffer &TB,
                                               const LangOptions &LangOpts);
 };
 
+/// Return true if the \p TokenName is in the list of reversed keywords of the
+/// language.
+bool isKeyword(llvm::StringRef TokenName, const LangOptions &LangOpts);
+
 /// Heuristically determine namespaces visible at a point, without parsing Code.
 /// This considers using-directives and enclosing namespace-declarations that
 /// are visible (and not obfuscated) in the file itself (not headers).
 /// Code should be truncated at the point of interest.
 ///
 /// The returned vector is always non-empty.
 /// - The first element is the namespace that encloses the point: a declaration
 ///   near the point would be within this namespace.

clang-tools-extra/clangd/SourceCode.cpp

lex(Content, LangOpts,
       [&](const syntax::Token &Tok, const SourceManager &SM) {
         if (Tok.kind() != tok::identifier || Tok.text(SM) != Identifier)
           return;
         Ranges.push_back(halfOpenToRange(SM, Tok.range(SM).toCharRange(SM)));
       });
   return Ranges;
 }
 
+bool isKeyword(llvm::StringRef NewName, const LangOptions &LangOpts) {
+  // Keywords are initialized in constructor.
+  clang::IdentifierTable KeywordsTable(LangOpts);
+  return KeywordsTable.find(NewName) != KeywordsTable.end();
+}
+
 namespace {
 struct NamespaceEvent {
   enum {
     BeginNamespace, // namespace <ns> {.     Payload is resolved <ns>.
     EndNamespace,   // } // namespace <ns>.  Payload is resolved *outer*
                     // namespace.
     UsingDirective  // using namespace <ns>. Payload is unresolved <ns>.
   } Trigger;

clang-tools-extra/clangd/unittests/SourceCodeTests.cpp

TEST(SourceCodeTests, isHeaderFile) {
   LangOpts.IsHeaderFile = true;
   EXPECT_TRUE(isHeaderFile("string", LangOpts));
   // Emulate cases where there is no "-x header" flag for a .h file, we still
   // want to treat it as a header.
   LangOpts.IsHeaderFile = false;
   EXPECT_TRUE(isHeaderFile("header.h", LangOpts));
 }
 
+TEST(SourceCodeTests, isKeywords) {
+  LangOptions LangOpts;
+  LangOpts.CPlusPlus20 = true;
+  EXPECT_TRUE(isKeyword("int", LangOpts));
+  EXPECT_TRUE(isKeyword("return", LangOpts));
+  EXPECT_TRUE(isKeyword("co_await", LangOpts));
+
+  // these are identifiers (not keywords!) with special meaning in some
+  // contexts.
+  EXPECT_FALSE(isKeyword("final", LangOpts));
+  EXPECT_FALSE(isKeyword("override", LangOpts));
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang