clang-format: [JS] handle pseudo-keywords.

[mprobst]

Summary

The previous change in https://reviews.llvm.org/D77311 attempted to
detect more C++ keywords. However it also precisely detected all
JavaScript keywords. That's generally correct, but many JavaScripy
keywords, e.g. get, are so-called pseudo-keywords. They can be used in
positions where a keyword would never be legal, e.g. in a dotted
expression:

x.type;  // type is a pseudo-keyword, but can be used here.
x.get;   // same for get etc.

This change introduces an additional parameter to
IsJavaScriptIdentifier, allowing clients to toggle whether they want
to allow IdentifierName tokens, i.e. pseudo-keywords.

[krasimir]

Looks good! The linter suggests a few formatting fixes.

clang/lib/Format/FormatToken.h

struct AdditionalKeywords {
   IdentifierInfo *kw_unchecked;
   IdentifierInfo *kw_unsafe;
   IdentifierInfo *kw_ushort;
   IdentifierInfo *kw_when;
   IdentifierInfo *kw_where;
 
   /// Returns \c true if \p Tok is a true JavaScript identifier, returns
   /// \c false if it is a keyword or a pseudo keyword.
-  bool IsJavaScriptIdentifier(const FormatToken &Tok) const {
+  /// If \c AcceptIdentifierName is true, returns true not only for keywords,
+  // but also for IdentifierName tokens (aka pseudo-keywords), such as
+  // ``yield``.
+  bool IsJavaScriptIdentifier(const FormatToken &Tok,
+                              bool AcceptIdentifierName = true) const {
     // Based on the list of JavaScript & TypeScript keywords here:
     // https://github.com/microsoft/TypeScript/blob/master/src/compiler/scanner.ts#L74
     switch (Tok.Tok.getKind()) {
     case tok::kw_break:
     case tok::kw_case:
     case tok::kw_catch:
     case tok::kw_class:
     case tok::kw_continue:
bool IsJavaScriptIdentifier(const FormatToken &Tok,
     case tok::kw_throw:
     case tok::kw_true:
     case tok::kw_try:
     case tok::kw_typeof:
     case tok::kw_void:
     case tok::kw_while:
       // These are JS keywords that are lexed by LLVM/clang as keywords.
       return false;
-    case tok::identifier:
+    case tok::identifier: {
       // For identifiers, make sure they are true identifiers, excluding the
       // JavaScript pseudo-keywords (not lexed by LLVM/clang as keywords).
-      return JsExtraKeywords.find(Tok.Tok.getIdentifierInfo()) ==
-             JsExtraKeywords.end();
+      bool IsPseudoKeyword =
+          JsExtraKeywords.find(Tok.Tok.getIdentifierInfo()) !=
+      return AcceptIdentifierName || !IsPseudoKeyword;
+    }
     default:
       // Other keywords are handled in the switch below, to avoid problems due
       // to duplicate case labels when using the #include trick.
       break;
     }
 
     switch (Tok.Tok.getKind()) {
       // Handle C++ keywords not included above: these are all JS identifiers.

clang/lib/Format/TokenAnnotator.cpp

if (Style.isCSharp() && CurrentToken->is(tok::question)) {
         Current.Type = TT_CSharpNullConditionalLSquare;
         return;
       }
     }
 
     if (Style.Language == FormatStyle::LK_JavaScript) {
       if (Current.is(tok::exclaim)) {
         if (Current.Previous &&
-            (Keywords.IsJavaScriptIdentifier(*Current.Previous) ||
-             Current.Previous->isOneOf(tok::kw_namespace, tok::r_paren,
-                                       tok::r_square, tok::r_brace) ||
+            (Keywords.IsJavaScriptIdentifier(
+                 *Current.Previous, /* AcceptIdentifierName= */ true) ||
+             Current.Previous->isOneOf(
+                 tok::kw_namespace, tok::r_paren, tok::r_square, tok::r_brace,
+                 Keywords.kw_type, Keywords.kw_get, Keywords.kw_set) ||
              Current.Previous->Tok.isLiteral())) {
           Current.Type = TT_JsNonNullAssertion;
           return;
         }
         if (Current.Next &&
             Current.Next->isOneOf(TT_BinaryOperator, Keywords.kw_as)) {
           Current.Type = TT_JsNonNullAssertion;
           return;
if (Left.is(Keywords.kw_async) && Right.is(tok::l_paren) &&
       if (Next && Next->is(TT_JsFatArrow))
         return true;
     }
     if ((Left.is(TT_TemplateString) && Left.TokenText.endswith("${")) ||
         (Right.is(TT_TemplateString) && Right.TokenText.startswith("}")))
       return false;
     // In tagged template literals ("html`bar baz`"), there is no space between
     // the tag identifier and the template string.
-    if (Keywords.IsJavaScriptIdentifier(Left) && Right.is(TT_TemplateString))
+    if (Keywords.IsJavaScriptIdentifier(Left,
+                                        /* AcceptIdentifierName= */ false) &&
+        Right.is(TT_TemplateString))
       return false;
     if (Right.is(tok::star) &&
         Left.isOneOf(Keywords.kw_function, Keywords.kw_yield))
       return false;
     if (Right.isOneOf(tok::l_brace, tok::l_square) &&
         Left.isOneOf(Keywords.kw_function, Keywords.kw_yield,
                      Keywords.kw_extends, Keywords.kw_implements))
       return true;

clang/unittests/Format/FormatTestJS.cpp

TEST_F(FormatTestJS, CppKeywords) {
   verifyFormat("reinterpret_cast!;");
   verifyFormat("static_cast!;");
   verifyFormat("template!;");
   verifyFormat("typename!;");
   verifyFormat("typeid!;");
   verifyFormat("using!;");
   verifyFormat("virtual!;");
   verifyFormat("wchar_t!;");
+
+  // Positive tests:
+  verifyFormat("x.type!;");
+  verifyFormat("x.get!;");
+  verifyFormat("x.set!;");
 }
 
 TEST_F(FormatTestJS, NullPropagatingOperator) {
   verifyFormat("let x = foo?.bar?.baz();\n");
   verifyFormat("let x = foo?.(foo);\n");
   verifyFormat("let x = foo?.['arr'];\n");
 }