[clang-format] Support TypeScript satisfies operator

[taymonbeal]

Summary

The satisfies operator was added in TypeScript 4.9.

[MyDeveloperDay]

I would like to see an annotator test just to be sure its getting annotated correctly.

apart from that it looks pretty good, would you add this to the release notes please?

clang/unittests/Format/FormatTestJS.cpp

2186

would you take say this example and add it as an annotator test

[taymonbeal]

Add release notes and unit test in TokenAnnotatorTest.cpp

[taymonbeal]

I don't have commit access; can someone who does commit this?

[MyDeveloperDay]

1. your diff is messed up
2. you have to get an accept before anyone will commit for you.

[MyDeveloperDay]

Can you add a github issue and reference it here

clang/unittests/Format/TokenAnnotatorTest.cpp

1445 ↗

(On Diff #506153)

I'd like to personally see this become a TT_JsSatisfies

clang/lib/Format/FormatToken.h

AdditionalKeywords(IdentifierTable &IdentTable) {
     kw_function = &IdentTable.get("function");
     kw_get = &IdentTable.get("get");
     kw_import = &IdentTable.get("import");
     kw_infer = &IdentTable.get("infer");
     kw_is = &IdentTable.get("is");
     kw_let = &IdentTable.get("let");
     kw_module = &IdentTable.get("module");
     kw_readonly = &IdentTable.get("readonly");
+    kw_satisfies = &IdentTable.get("satisfies");
     kw_set = &IdentTable.get("set");
     kw_type = &IdentTable.get("type");
     kw_typeof = &IdentTable.get("typeof");
     kw_var = &IdentTable.get("var");
     kw_yield = &IdentTable.get("yield");
 
     kw_abstract = &IdentTable.get("abstract");
     kw_assert = &IdentTable.get("assert");
AdditionalKeywords(IdentifierTable &IdentTable) {
     kw_apostrophe = &IdentTable.get("\'");
 
     // Keep this at the end of the constructor to make sure everything here
     // is
     // already initialized.
     JsExtraKeywords = std::unordered_set<IdentifierInfo *>(
         {kw_as, kw_async, kw_await, kw_declare, kw_finally, kw_from,
          kw_function, kw_get, kw_import, kw_is, kw_let, kw_module, kw_override,
-         kw_readonly, kw_set, kw_type, kw_typeof, kw_var, kw_yield,
+         kw_readonly, kw_satisfies, kw_set, kw_type, kw_typeof, kw_var,
+         kw_yield,
          // Keywords from the Java section.
          kw_abstract, kw_extends, kw_implements, kw_instanceof, kw_interface});
 
     CSharpExtraKeywords = std::unordered_set<IdentifierInfo *>(
         {kw_base, kw_byte, kw_checked, kw_decimal, kw_delegate, kw_event,
          kw_fixed, kw_foreach, kw_implicit, kw_in, kw_init, kw_interface,
          kw_internal, kw_is, kw_lock, kw_null, kw_object, kw_out, kw_override,
          kw_params, kw_readonly, kw_ref, kw_string, kw_stackalloc, kw_sbyte,
struct AdditionalKeywords {
   IdentifierInfo *kw_function;
   IdentifierInfo *kw_get;
   IdentifierInfo *kw_import;
   IdentifierInfo *kw_infer;
   IdentifierInfo *kw_is;
   IdentifierInfo *kw_let;
   IdentifierInfo *kw_module;
   IdentifierInfo *kw_readonly;
+  IdentifierInfo *kw_satisfies;
   IdentifierInfo *kw_set;
   IdentifierInfo *kw_type;
   IdentifierInfo *kw_typeof;
   IdentifierInfo *kw_var;
   IdentifierInfo *kw_yield;
 
   // Java keywords.
   IdentifierInfo *kw_abstract;

clang/lib/Format/TokenAnnotator.cpp

if ((Style.isJavaScript() || Style.isCSharp()) &&
                 tok::r_brace, tok::kw_false, tok::kw_true, Keywords.kw_type,
                 Keywords.kw_get, Keywords.kw_init, Keywords.kw_set) ||
             Current.Previous->Tok.isLiteral()) {
           Current.setType(TT_NonNullAssertion);
           return;
         }
       }
       if (Current.Next &&
-          Current.Next->isOneOf(TT_BinaryOperator, Keywords.kw_as)) {
+          Current.Next->isOneOf(TT_BinaryOperator, Keywords.kw_as,
+                                Keywords.kw_satisfies)) {
         Current.setType(TT_NonNullAssertion);
         return;
       }
     }
 
     // Line.MightBeFunctionDecl can only be true after the parentheses of a
     // function declaration have been found. In this case, 'Current' is a
     // trailing token of this declaration and thus cannot be a name.
private:
   ///
   /// This is a heuristic based on whether \p Tok is an identifier following
   /// something that is likely a type.
   bool isStartOfName(const FormatToken &Tok) {
     if (Tok.isNot(tok::identifier) || !Tok.Previous)
       return false;
 
     if (Tok.Previous->isOneOf(TT_LeadingJavaAnnotation, Keywords.kw_instanceof,
-                              Keywords.kw_as)) {
+                              Keywords.kw_as, Keywords.kw_satisfies)) {
       return false;
     }
     if (Style.isJavaScript() && Tok.Previous->is(Keywords.kw_in))
       return false;
 
     // Skip "const" as it does not have an influence on whether this is a name.
     FormatToken *PreviousNotConst = Tok.getPreviousNonComment();
 
if (Current) {
       }
       if (Current->is(TT_RangeBasedForLoopColon))
         return prec::Comma;
       if ((Style.Language == FormatStyle::LK_Java || Style.isJavaScript()) &&
           Current->is(Keywords.kw_instanceof)) {
         return prec::Relational;
       }
       if (Style.isJavaScript() &&
-          Current->isOneOf(Keywords.kw_in, Keywords.kw_as)) {
+          Current->isOneOf(Keywords.kw_in, Keywords.kw_as,
+                           Keywords.kw_satisfies)) {
         return prec::Relational;
       }
       if (Current->is(TT_BinaryOperator) || Current->is(tok::comma))
         return Current->getPrecedence();
       if (Current->isOneOf(tok::period, tok::arrow) &&
           Current->isNot(TT_TrailingReturnArrow)) {
         return PrecedenceArrowAndPeriod;
       }
if ((Left.isOneOf(Keywords.kw_let, Keywords.kw_var, Keywords.kw_in,
          // (e.g. as "const x of y" in a for loop), or after a destructuring
          // operation (const [x, y] of z, const {a, b} of c).
          (Left.is(Keywords.kw_of) && Left.Previous &&
           (Left.Previous->is(tok::identifier) ||
            Left.Previous->isOneOf(tok::r_square, tok::r_brace)))) &&
         (!Left.Previous || !Left.Previous->is(tok::period))) {
       return true;
     }
-    if (Left.isOneOf(tok::kw_for, Keywords.kw_as) && Left.Previous &&
-        Left.Previous->is(tok::period) && Right.is(tok::l_paren)) {
+    if (Left.isOneOf(tok::kw_for, Keywords.kw_as, Keywords.kw_satisfies) &&
+        Left.Previous && Left.Previous->is(tok::period) &&
+        Right.is(tok::l_paren)) {
       return false;
     }
-    if (Left.is(Keywords.kw_as) &&
+    if (Left.isOneOf(Keywords.kw_as, Keywords.kw_satisfies) &&
         Right.isOneOf(tok::l_square, tok::l_brace, tok::l_paren)) {
       return true;
     }
     if (Left.is(tok::kw_default) && Left.Previous &&
         Left.Previous->is(tok::kw_export)) {
       return true;
     }
     if (Left.is(Keywords.kw_is) && Right.is(tok::l_brace))
if (Left.is(TT_TemplateCloser) &&
       // Type assertions ('<type>expr') are not followed by whitespace. Other
       // locations that should have whitespace following are identified by the
       // above set of follower tokens.
       return false;
     }
     if (Right.is(TT_NonNullAssertion))
       return false;
     if (Left.is(TT_NonNullAssertion) &&
-        Right.isOneOf(Keywords.kw_as, Keywords.kw_in)) {
-      return true; // "x! as string", "x! in y"
+        Right.isOneOf(Keywords.kw_as, Keywords.kw_satisfies, Keywords.kw_in)) {
+      return true; // "x! as string", "x! satisfies string", "x! in y"
     }
   } else if (Style.Language == FormatStyle::LK_Java) {
     if (Left.is(tok::r_square) && Right.is(tok::l_brace))
       return true;
     if (Left.is(Keywords.kw_synchronized) && Right.is(tok::l_paren)) {
       return Style.SpaceBeforeParensOptions.AfterControlStatements ||
              spaceRequiredBeforeParens(Right);
     }
if (Right.is(Keywords.kw_is)) {
       // });
       if (!Next || !Next->is(tok::colon))
         return false;
     }
     if (Left.is(Keywords.kw_in))
       return Style.BreakBeforeBinaryOperators == FormatStyle::BOS_None;
     if (Right.is(Keywords.kw_in))
       return Style.BreakBeforeBinaryOperators != FormatStyle::BOS_None;
-    if (Right.is(Keywords.kw_as))
-      return false; // must not break before as in 'x as type' casts
+    if (Right.isOneOf(Keywords.kw_as, Keywords.kw_satisfies))
+      return false; // must not break before as or satisfies in 'x as type'
+                    // casts
     if (Right.isOneOf(Keywords.kw_extends, Keywords.kw_infer)) {
       // extends and infer can appear as keywords in conditional types:
       //   https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#conditional-types
       // do not break before them, as the expressions are subject to ASI.
       return false;
     }
-    if (Left.is(Keywords.kw_as))
+    if (Left.isOneOf(Keywords.kw_as, Keywords.kw_satisfies))
       return true;
     if (Left.is(TT_NonNullAssertion))
       return true;
     if (Left.is(Keywords.kw_declare) &&
         Right.isOneOf(Keywords.kw_module, tok::kw_namespace,
                       Keywords.kw_function, tok::kw_class, tok::kw_enum,
                       Keywords.kw_interface, Keywords.kw_type, Keywords.kw_var,
                       Keywords.kw_let, tok::kw_const)) {

clang/lib/Format/UnwrappedLineParser.cpp

case tok::r_brace:
           // braced list (where all blocks inside are by default braced lists),
           // or when we explicitly detect blocks (for example while parsing
           // lambdas).
 
           // If we already marked the opening brace as braced list, the closing
           // must also be part of it.
           ProbablyBracedList = LBraceStack.back()->is(TT_BracedListLBrace);
 
-          ProbablyBracedList = ProbablyBracedList ||
+          ProbablyBracedList =
+              ProbablyBracedList ||
                                (Style.isJavaScript() &&
-                                NextTok->isOneOf(Keywords.kw_of, Keywords.kw_in,
-                                                 Keywords.kw_as));
+               NextTok->isOneOf(Keywords.kw_of, Keywords.kw_in, Keywords.kw_as,
+                                Keywords.kw_satisfies));
           ProbablyBracedList = ProbablyBracedList ||
                                (Style.isCpp() && NextTok->is(tok::l_paren));
 
           // If there is a comma, semicolon or right paren after the closing
           // brace, we assume this is a braced initializer list.
           // FIXME: Some of these do not apply to JS, e.g. "} {" can never be a
           // braced list in JS.
           ProbablyBracedList =
return FormatTok->is(tok::identifier) &&
          (!FormatTok->Tok.getIdentifierInfo() ||
           !FormatTok->isOneOf(
               Keywords.kw_in, Keywords.kw_of, Keywords.kw_as, Keywords.kw_async,
               Keywords.kw_await, Keywords.kw_yield, Keywords.kw_finally,
               Keywords.kw_function, Keywords.kw_import, Keywords.kw_is,
               Keywords.kw_let, Keywords.kw_var, tok::kw_const,
               Keywords.kw_abstract, Keywords.kw_extends, Keywords.kw_implements,
               Keywords.kw_instanceof, Keywords.kw_interface,
-              Keywords.kw_override, Keywords.kw_throws, Keywords.kw_from));
+              Keywords.kw_override, Keywords.kw_satisfies, Keywords.kw_throws,
+              Keywords.kw_from));
 }
 
 static bool mustBeJSIdentOrValue(const AdditionalKeywords &Keywords,
                                  const FormatToken *FormatTok) {
   return FormatTok->Tok.isLiteral() ||
          FormatTok->isOneOf(tok::kw_true, tok::kw_false) ||
          mustBeJSIdent(Keywords, FormatTok);
 }

clang/unittests/Format/FormatTestJS.cpp

TEST_F(FormatTestJS, CastSyntax) {
   verifyFormat("x = x as (string);");
   verifyFormat("x = x! as (string);");
   verifyFormat("x = y! in z;");
   verifyFormat("var x = something.someFunction() as\n"
                "    something;",
                getGoogleJSStyleWithColumns(40));
 }
 
+TEST_F(FormatTestJS, SatisfiesSyntax) {
+  verifyFormat("let x = foo satisfies Type;");
+  verifyFormat("let x = (a + b) satisfies\n"
+               "    LongTypeIsLong;",
+               getGoogleJSStyleWithColumns(30));
+  verifyFormat("let x = [{x: 1} satisfies Type];");
+  verifyFormat("x = x satisfies [A, B];");
+  verifyFormat("x = x satisfies {a: string};");
+  verifyFormat("x = x satisfies (string);");
+  verifyFormat("x = x! satisfies (string);");
+  verifyFormat("let x = something.someFunction() satisfies\n"
+               "    LongTypeIsLong;",
+               getGoogleJSStyleWithColumns(50));
+}
+
 TEST_F(FormatTestJS, TypeArguments) {
   verifyFormat("class X<Y> {}");
   verifyFormat("new X<Y>();");
   verifyFormat("foo<Y>(a);");
   verifyFormat("var x: X<Y>[];");
   verifyFormat("class C extends D<E> implements F<G>, H<I> {}");
   verifyFormat("function f(a: List<any> = null) {}");
   verifyFormat("function f(): List<any> {}");