clang-format: [Java] support Java modifiers

[het]

Summary

Before

public final<X> Foo foo() {
}

public abstract<X> Foo foo();

After

public final <X> Foo foo() {
}

public abstract <X> Foo foo();

[djasper]

Looks good. Submitted as r222527.

lib/Format/FormatToken.h

struct AdditionalKeywords {
   AdditionalKeywords(IdentifierTable &IdentTable) {
     kw_in = &IdentTable.get("in");
     kw_NS_ENUM = &IdentTable.get("NS_ENUM");
 
     kw_finally = &IdentTable.get("finally");
     kw_function = &IdentTable.get("function");
     kw_var = &IdentTable.get("var");
 
+    kw_abstract = &IdentTable.get("abstract");
     kw_extends = &IdentTable.get("extends");
+    kw_final = &IdentTable.get("final");
     kw_implements = &IdentTable.get("implements");
     kw_interface = &IdentTable.get("interface");
     kw_synchronized = &IdentTable.get("synchronized");
     kw_throws = &IdentTable.get("throws");
 
     kw_option = &IdentTable.get("option");
     kw_optional = &IdentTable.get("optional");
     kw_repeated = &IdentTable.get("repeated");
     kw_required = &IdentTable.get("required");
     kw_returns = &IdentTable.get("returns");
   }
 
   // ObjC context sensitive keywords.
   IdentifierInfo *kw_in;
   IdentifierInfo *kw_NS_ENUM;
 
   // JavaScript keywords.
   IdentifierInfo *kw_finally;
   IdentifierInfo *kw_function;
   IdentifierInfo *kw_var;
 
   // Java keywords.
+  IdentifierInfo *kw_abstract;
   IdentifierInfo *kw_extends;
+  IdentifierInfo *kw_final;
   IdentifierInfo *kw_implements;
   IdentifierInfo *kw_interface;
   IdentifierInfo *kw_synchronized;
   IdentifierInfo *kw_throws;
 
   // Proto keywords.
   IdentifierInfo *kw_option;
   IdentifierInfo *kw_optional;

lib/Format/TokenAnnotator.cpp

if (Right.is(tok::l_paren) &&
         Left.isOneOf(Keywords.kw_returns, Keywords.kw_option))
       return true;
   } else if (Style.Language == FormatStyle::LK_JavaScript) {
     if (Left.is(Keywords.kw_var))
       return true;
   } else if (Style.Language == FormatStyle::LK_Java) {
     if (Left.is(Keywords.kw_synchronized) && Right.is(tok::l_paren))
       return Style.SpaceBeforeParens != FormatStyle::SBPO_Never;
-    if (Left.isOneOf(tok::kw_static, tok::kw_public, tok::kw_private,
-                     tok::kw_protected) &&
+    if ((Left.isOneOf(tok::kw_static, tok::kw_public, tok::kw_private,
+                      tok::kw_protected) ||
+         Left.isOneOf(Keywords.kw_final, Keywords.kw_abstract)) &&
         Right.Type == TT_TemplateOpener)
       return true;
   }
   if (Right.Tok.getIdentifierInfo() && Left.Tok.getIdentifierInfo())
     return true; // Never ever merge two identifiers.
   if (Left.Type == TT_ImplicitStringLiteral)
     return Right.WhitespaceRange.getBegin() != Right.WhitespaceRange.getEnd();
   if (Line.Type == LT_ObjCMethodDecl) {

unittests/Format/FormatTestJava.cpp

TEST_F(FormatTestJava, Generics) {
 
   verifyFormat("@Override\n"
                "public Map<String, ?> getAll() {\n}");
 
   verifyFormat("public <R> ArrayList<R> get() {\n}");
   verifyFormat("protected <R> ArrayList<R> get() {\n}");
   verifyFormat("private <R> ArrayList<R> get() {\n}");
   verifyFormat("public static <R> ArrayList<R> get() {\n}");
+  verifyFormat("public final <X> Foo foo() {\n}");
+  verifyFormat("public abstract <X> Foo foo();");
   verifyFormat("<T extends B> T getInstance(Class<T> type);");
   verifyFormat("Function<F, ? extends T> function;");
 
   verifyFormat("private Foo<X, Y>[] foos;");
   verifyFormat("Foo<X, Y>[] foos = this.foos;");
 
   verifyFormat(
       "SomeLoooooooooooooooooooooongType name =\n"