clang-format: [JS] exclaim preceding regex literals.

[mprobst]

Summary

Regex detection would incorrectly classify a trailing ! operator
(nullability cast) followed by a / as the start of a regular
expression literal. This fixes code such as:

var foo = x()! / 10;

Which would previously parse a regexp all the way to the end of the
source file (or next /).

[djasper]

Looks good.

lib/Format/FormatTokenLexer.cpp

 bool FormatTokenLexer::canPrecedeRegexLiteral(FormatToken *Prev) {
   if (!Prev)
     return true;
 
   // Regex literals can only follow after prefix unary operators, not after
   // postfix unary operators. If the '++' is followed by a non-operand
   // introducing token, the slash here is the operand and not the start of a
   // regex.
-  if (Prev->isOneOf(tok::plusplus, tok::minusminus))
+  // `!` is an unary prefix operator, but also a post-fix operator that casts
+  // away nullability, so the same check applies.
+  if (Prev->isOneOf(tok::plusplus, tok::minusminus, tok::exclaim))
     return (Tokens.size() < 3 || precedesOperand(Tokens[Tokens.size() - 3]));
 
   // The previous token must introduce an operand location where regex
   // literals can occur.
   if (!precedesOperand(Prev))
     return false;
 
   return true;

unittests/Format/FormatTestJS.cpp

TEST_F(FormatTestJS, RegexLiteralClassification) {
   // Regex literals.
   verifyFormat("var regex = /abc/;");
   verifyFormat("f(/abc/);");
   verifyFormat("f(abc, /abc/);");
   verifyFormat("some_map[/abc/];");
   verifyFormat("var x = a ? /abc/ : /abc/;");
   verifyFormat("for (var i = 0; /abc/.test(s[i]); i++) {\n}");
   verifyFormat("var x = !/abc/.test(y);");
+  verifyFormat("var x = foo()! / 10;");
   verifyFormat("var x = a && /abc/.test(y);");
   verifyFormat("var x = a || /abc/.test(y);");
   verifyFormat("var x = a + /abc/.search(y);");
   verifyFormat("/abc/.search(y);");
   verifyFormat("var regexs = {/abc/, /abc/};");
   verifyFormat("return /abc/;");
 
   // Not regex literals.