[Format/ObjC] Fix [foo bar]->baz formatting as lambda arrow

[benhamilton]

Summary

Currently, UnwrappedLineParser thinks an arrow token after
an ObjC method expression is a C++ lambda arrow, so it formats:

[foo bar]->baz

as:

[foo bar] -> baz

Because UnwrappedLineParser runs before TokenAnnotator, it can't
know if the arrow token is after an ObjC method expression or not.

This diff makes TokenAnnotator remove the TT_LambdaArrow on
the arrow token if it follows an ObjC method expression.

Test Plan: New test added. Ran test with:

% ninja FormatTests && ./tools/clang/unittests/Format/FormatTests
Confirmed test failed before diff and passed after diff.

[benhamilton]

Tidy up code.

lib/Format/TokenAnnotator.cpp

while (CurrentToken) {
               canBeObjCSelectorComponent(*CurrentToken->Previous))
             CurrentToken->Previous->Type = TT_SelectorName;
           // determineStarAmpUsage() thinks that '*' '[' is allocating an
           // array of pointers, but if '[' starts a selector then '*' is a
           // binary operator.
           if (Parent && Parent->is(TT_PointerOrReference))
             Parent->Type = TT_BinaryOperator;
         }
+        // An arrow after an ObjC method expression is not a lambda arrow.
+        if (CurrentToken->Type == TT_ObjCMethodExpr && CurrentToken->Next &&
+            CurrentToken->Next->is(TT_LambdaArrow))
+          CurrentToken->Next->Type = TT_Unknown;
         Left->MatchingParen = CurrentToken;
         CurrentToken->MatchingParen = Left;
         // FirstObjCSelectorName is set when a colon is found. This does
         // not work, however, when the method has no parameters.
         // Here, we set FirstObjCSelectorName when the end of the method call is
         // reached, in case it was not set already.
         if (!Contexts.back().FirstObjCSelectorName) {
             FormatToken* Previous = CurrentToken->getPreviousNonComment();

lib/Format/UnwrappedLineParser.cpp

while (FormatTok->isNot(tok::l_brace)) {
     case tok::identifier:
     case tok::numeric_constant:
     case tok::coloncolon:
     case tok::kw_mutable:
     case tok::kw_noexcept:
       nextToken();
       break;
     case tok::arrow:
+      // This might or might not actually be a lambda arrow (this could be an
+      // ObjC method invocation followed by a dereferencing arrow). We might
+      // reset this back to TT_Unknown in TokenAnnotator.
       FormatTok->Type = TT_LambdaArrow;
       nextToken();
       break;
     default:
       return true;
     }
   }
   LSquare.Type = TT_LambdaLSquare;

unittests/Format/FormatTestObjC.cpp

verifyFormat("@implementation Foo\n"
                "- (void)foo:(id)bar\n"
                "{\n"
                "}\n"
                "@end\n");
 }
 
 TEST_F(FormatTestObjC, FormatObjCMethodExpr) {
   verifyFormat("[foo bar:baz];");
+  verifyFormat("[foo bar]->baz;");
   verifyFormat("return [foo bar:baz];");
   verifyFormat("return (a)[foo bar:baz];");
   verifyFormat("f([foo bar:baz]);");
   verifyFormat("f(2, [foo bar:baz]);");
   verifyFormat("f(2, a ? b : c);");
   verifyFormat("[[self initWithInt:4] bar:[baz quux:arrrr]];");
 
   // Unary operators.