clang-format/java: Unbreak genenrics formatting after r299952.

[thakis]

Summary

https://reviews.llvm.org/rL299952 merged '>>>' tokens into a single JavaRightLogicalShift token. This broke formatting of generics nested more than two deep, e.g. Foo<Bar<Baz>>> because the '>>>' now weren't three '>' for parseAngle().

Luckily, just deleting JavaRightLogicalShift fixes things without breaking the test added in r299952, so do that.

[bradfier]

If this doesn't break the test case for '>>>' then it looks good, although I'm not sure what has changed in the interim to allow that to work. When I made the patch in r299952 we definitely required the explicit JavaRightLogicalShift handling.

[thakis]

r314325, thanks!

lib/Format/FormatTokenLexer.cpp

if (tryMergeTokens(JSExponentiation, TT_JsExponentiation))
       return;
     if (tryMergeTokens(JSExponentiationEqual, TT_JsExponentiationEqual)) {
       Tokens.back()->Tok.setKind(tok::starequal);
       return;
     }
   }
 
   if (Style.Language == FormatStyle::LK_Java) {
-    static const tok::TokenKind JavaRightLogicalShift[] = {
-        tok::greater, tok::greater, tok::greater};
     static const tok::TokenKind JavaRightLogicalShiftAssign[] = {
         tok::greater, tok::greater, tok::greaterequal};
-    if (tryMergeTokens(JavaRightLogicalShift, TT_BinaryOperator))
-      return;
     if (tryMergeTokens(JavaRightLogicalShiftAssign, TT_BinaryOperator))
       return;
   }
 }
 
 bool FormatTokenLexer::tryMergeNSStringLiteral() {
   if (Tokens.size() < 2)
     return false;

lib/Format/TokenAnnotator.cpp

 
 private:
   bool parseAngle() {
     if (!CurrentToken || !CurrentToken->Previous)
       return false;
     if (NonTemplateLess.count(CurrentToken->Previous))
       return false;
 
-    const FormatToken &Previous = *CurrentToken->Previous;
+    const FormatToken &Previous = *CurrentToken->Previous;  // The '<'.
     if (Previous.Previous) {
       if (Previous.Previous->Tok.isLiteral())
         return false;
       if (Previous.Previous->is(tok::r_paren) && Contexts.size() > 1 &&
           (!Previous.Previous->MatchingParen ||
            !Previous.Previous->MatchingParen->is(TT_OverloadedOperatorLParen)))
         return false;
     }
if ((Left.isOneOf(tok::identifier, tok::greater, tok::r_square,
     return false;
   if (Left.is(tok::period) || Right.is(tok::period))
     return false;
   if (Right.is(tok::hash) && Left.is(tok::identifier) && Left.TokenText == "L")
     return false;
   if (Left.is(TT_TemplateCloser) && Left.MatchingParen &&
       Left.MatchingParen->Previous &&
       Left.MatchingParen->Previous->is(tok::period))
-    // A.<B>DoSomething();
+    // A.<B<C<...>>>DoSomething();
     return false;
   if (Left.is(TT_TemplateCloser) && Right.is(tok::l_square))
     return false;
   return true;
 }
 
 bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line,
                                          const FormatToken &Right) {

unittests/Format/FormatTestJava.cpp

 }
 
 TEST_F(FormatTestJava, Generics) {
   verifyFormat("Iterable<?> a;");
   verifyFormat("Iterable<?> a;");
   verifyFormat("Iterable<? extends SomeObject> a;");
 
   verifyFormat("A.<B>doSomething();");
+  verifyFormat("A.<B<C>>doSomething();");
+  verifyFormat("A.<B<C<D>>>doSomething();");
+  verifyFormat("A.<B<C<D<E>>>>doSomething();");
+
+  verifyFormat("OrderedPair<String, List<Box<Integer>>> p = null;");
 
   verifyFormat("@Override\n"
                "public Map<String, ?> getAll() {}");
 
   verifyFormat("public <R> ArrayList<R> get() {}");
   verifyFormat("protected <R> ArrayList<R> get() {}");
   verifyFormat("private <R> ArrayList<R> get() {}");
   verifyFormat("public static <R> ArrayList<R> get() {}");