clang-format: [JS] wrap optional properties in type aliases.

[mprobst]

Summary

clang-format wraps object literal keys in an object literal if they are
marked as TT_SelectorNames and/or the colon is marked as
TT_DictLiteral. Previously, clang-format would accidentally work
because colons in type aliases were marked as TT_DictLiteral. r310367
fixed this to assing TT_JsTypeColon, which broke wrapping in certain
situations. However the root cause was that clang-format incorrectly
didn't skip questionmarks when detecting selector name.

This change fixes both locations to (1) assign TT_SelectorName and (2)
treat TT_JsTypeColon like TT_DictLiteral.

Previously:

type X = {
  a: string, b?: string,
};

Now:

type X = {
  a: string,
  b?: string,
};

[djasper]

Looks good.

cfe/trunk/lib/Format/TokenAnnotator.cpp

if (CurrentToken) {
           next();
           return true;
         }
         if (CurrentToken->isOneOf(tok::r_paren, tok::r_square))
           return false;
         updateParameterCount(Left, CurrentToken);
         if (CurrentToken->isOneOf(tok::colon, tok::l_brace, tok::less)) {
           FormatToken *Previous = CurrentToken->getPreviousNonComment();
+          if (Previous->is(TT_JsTypeOptionalQuestion))
+            Previous = Previous->getPreviousNonComment();
           if (((CurrentToken->is(tok::colon) &&
                 (!Contexts.back().ColonIsDictLiteral || !Style.isCpp())) ||
                Style.Language == FormatStyle::LK_Proto ||
                Style.Language == FormatStyle::LK_TextProto) &&
               (Previous->Tok.getIdentifierInfo() ||
                Previous->is(tok::string_literal)))
             Previous->Type = TT_SelectorName;
           if (CurrentToken->is(tok::colon) ||
private:
   /// \brief Gets the precedence (+1) of the given token for binary operators
   /// and other tokens that we treat like binary operators.
   int getCurrentPrecedence() {
     if (Current) {
       const FormatToken *NextNonComment = Current->getNextNonComment();
       if (Current->is(TT_ConditionalExpr))
         return prec::Conditional;
       if (NextNonComment && Current->is(TT_SelectorName) &&
-          (NextNonComment->is(TT_DictLiteral) ||
+          (NextNonComment->isOneOf(TT_DictLiteral, TT_JsTypeColon) ||
            ((Style.Language == FormatStyle::LK_Proto ||
              Style.Language == FormatStyle::LK_TextProto) &&
             NextNonComment->is(tok::less))))
         return prec::Assignment;
       if (Current->is(TT_JsComputedPropertyName))
         return prec::Assignment;
       if (Current->is(TT_LambdaArrow))
         return prec::Comma;

cfe/trunk/unittests/Format/FormatTestJS.cpp

 TEST_F(FormatTestJS, TypeAliases) {
   verifyFormat("type X = number;\n"
                "class C {}");
   verifyFormat("type X<Y> = Z<Y>;");
   verifyFormat("type X = {\n"
                "  y: number\n"
                "};\n"
                "class C {}");
+  verifyFormat("export type X = {\n"
+               "  a: string,\n"
+               "  b?: string,\n"
+               "};\n");
 }
 
 TEST_F(FormatTestJS, TypeInterfaceLineWrapping) {
   const FormatStyle &Style = getGoogleJSStyleWithColumns(20);
   verifyFormat("type LongTypeIsReallyUnreasonablyLong =\n"
                "    string;\n",
                "type LongTypeIsReallyUnreasonablyLong = string;\n",
                Style);