From cfc44048b3b541c2f65ab8f4ce3207626b9218b5 Mon Sep 17 00:00:00 2001 From: Erik Silkensen <94125+esilkensen@users.noreply.github.com> Date: Sun, 19 Jan 2020 22:54:21 -0700 Subject: [PATCH] Issue #3238: Java 8 Grammar: annotations on arrays and varargs --- .../whitespace/NoWhitespaceAfterCheck.java | 24 +- .../tools/checkstyle/grammar/java.g | 23 +- .../grammar/java8/AnnotationTest.java | 9 + ...utNoWhitespaceAfterArrayDeclarations3.java | 3 + .../grammar/InputRegressionJava8Class1.java | 5 + .../grammar/InputRegressionJava8Class1Ast.txt | 902 ++++++++++-------- .../grammar/java8/InputAnnotations12.java | 16 + .../java8/InputAnnotationsOnArray.java | 24 + 8 files changed, 604 insertions(+), 402 deletions(-) create mode 100644 src/test/resources/com/puppycrawl/tools/checkstyle/grammar/java8/InputAnnotations12.java diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/checks/whitespace/NoWhitespaceAfterCheck.java b/src/main/java/com/puppycrawl/tools/checkstyle/checks/whitespace/NoWhitespaceAfterCheck.java index d03c25e74c95..9eabf21d6174 100644 --- a/src/main/java/com/puppycrawl/tools/checkstyle/checks/whitespace/NoWhitespaceAfterCheck.java +++ b/src/main/java/com/puppycrawl/tools/checkstyle/checks/whitespace/NoWhitespaceAfterCheck.java @@ -170,8 +170,7 @@ public void setAllowLineBreaks(boolean allowLineBreaks) { public void visitToken(DetailAST ast) { final DetailAST whitespaceFollowedAst = getWhitespaceFollowedNode(ast); - if (whitespaceFollowedAst.getNextSibling() == null - || whitespaceFollowedAst.getNextSibling().getType() != TokenTypes.ANNOTATIONS) { + if (shouldCheckWhitespaceAfter(whitespaceFollowedAst)) { final int whitespaceColumnNo = getPositionAfter(whitespaceFollowedAst); final int whitespaceLineNo = whitespaceFollowedAst.getLineNo(); @@ -206,6 +205,27 @@ private static DetailAST getWhitespaceFollowedNode(DetailAST ast) { return whitespaceFollowedAst; } + /** + * Returns whether whitespace after a visited node should be checked. For example, whitespace + * is not allowed between a type and an array declarator (returns true), except when there is + * an annotation in between the type and array declarator (returns false). + * @param ast the visited node + * @return true if whitespace after ast should be checked + */ + private static boolean shouldCheckWhitespaceAfter(DetailAST ast) { + boolean checkWhitespace = true; + if (ast.getNextSibling() != null) { + final DetailAST sibling = ast.getNextSibling(); + if (sibling.getType() == TokenTypes.ANNOTATIONS) { + checkWhitespace = false; + } + else if (sibling.getType() == TokenTypes.ARRAY_DECLARATOR) { + checkWhitespace = sibling.getFirstChild().getType() != TokenTypes.ANNOTATIONS; + } + } + return checkWhitespace; + } + /** * Gets position after token (place of possible redundant whitespace). * @param ast Node representing token. diff --git a/src/main/resources/com/puppycrawl/tools/checkstyle/grammar/java.g b/src/main/resources/com/puppycrawl/tools/checkstyle/grammar/java.g index 7a5692099819..48f0aea9a0fd 100644 --- a/src/main/resources/com/puppycrawl/tools/checkstyle/grammar/java.g +++ b/src/main/resources/com/puppycrawl/tools/checkstyle/grammar/java.g @@ -257,6 +257,14 @@ typeSpec[boolean addImagNode] | builtInTypeSpec[addImagNode] ; +// A type specification for a variable length parameter is a type name with +// possible brackets afterwards that can end with annotations. +variableLengthParameterTypeSpec + : (classOrInterfaceType[false] | builtInType) + ({LA(1) == AT}? annotations | ) + (lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK ({LA(1) == AT}? annotations | ))* + ; + // A class type specification is a class type with either: // - possible brackets afterwards // (which would make it an array type). @@ -387,8 +395,8 @@ builtInTypeSpec[boolean addImagNode] // A type name. which is either a (possibly qualified and parameterized) // class name or a primitive (builtin) type type - : classOrInterfaceType[false] - | builtInType + : ({LA(1) == AT}? annotations | ) + (classOrInterfaceType[false] | builtInType) ; /** A declaration is the creation of a reference or primitive-type variable @@ -893,9 +901,11 @@ variableDeclarator![AST mods, AST t] {#variableDeclarator = #(#[VARIABLE_DEF,"VARIABLE_DEF"], mods, #(#[TYPE,"TYPE"],d), id, v);} ; -declaratorBrackets[AST typ] - : {#declaratorBrackets=typ;} - (lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK)* +declaratorBrackets![AST typ] + : ({LA(1) == AT}? an:annotations | ) lb:LBRACK {#lb.setType(ARRAY_DECLARATOR);} rb:RBRACK + db:declaratorBrackets[#(lb, typ, an, rb)] + {#declaratorBrackets = #db;} + | {#declaratorBrackets = typ;} ; varInitializer @@ -969,7 +979,7 @@ parameterDeclarationList ; variableLengthParameterDeclaration! - : pm:parameterModifier t:typeSpec[false] td:ELLIPSIS IDENT + : pm:parameterModifier t:variableLengthParameterTypeSpec td:ELLIPSIS IDENT pd:declaratorBrackets[#t] {#variableLengthParameterDeclaration = #(#[PARAMETER_DEF,"PARAMETER_DEF"], pm, #([TYPE,"TYPE"],pd), td, IDENT);} @@ -1592,6 +1602,7 @@ newArrayDeclarator warnWhenFollowAmbig = false; } : + ({LA(1) == AT}? annotations | ) lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} (expression)? RBRACK diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/grammar/java8/AnnotationTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/grammar/java8/AnnotationTest.java index 1a9952f2d5be..4b98d27f6864 100644 --- a/src/test/java/com/puppycrawl/tools/checkstyle/grammar/java8/AnnotationTest.java +++ b/src/test/java/com/puppycrawl/tools/checkstyle/grammar/java8/AnnotationTest.java @@ -132,4 +132,13 @@ public void testAnnotationInTypeParameters() verify(checkConfig, getPath("InputAnnotations11.java"), expected); } + @Test + public void testAnnotationOnVarargs() + throws Exception { + final DefaultConfiguration checkConfig = + createModuleConfig(MemberNameCheck.class); + final String[] expected = CommonUtil.EMPTY_STRING_ARRAY; + verify(checkConfig, getPath("InputAnnotations12.java"), expected); + } + } diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/checks/whitespace/nowhitespaceafter/InputNoWhitespaceAfterArrayDeclarations3.java b/src/test/resources/com/puppycrawl/tools/checkstyle/checks/whitespace/nowhitespaceafter/InputNoWhitespaceAfterArrayDeclarations3.java index 51b841061b23..ec377c1e5817 100644 --- a/src/test/resources/com/puppycrawl/tools/checkstyle/checks/whitespace/nowhitespaceafter/InputNoWhitespaceAfterArrayDeclarations3.java +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/checks/whitespace/nowhitespaceafter/InputNoWhitespaceAfterArrayDeclarations3.java @@ -9,6 +9,9 @@ public void testWithAnnotationInMiddle1(final char @AnnotationAfterTest [] a) {} public void testWithAnnotationInMiddle2(final char@AnnotationAfterTest [] a) {}//Correct public void testWithAnnotationInMiddle3(final char @AnnotationAfterTest[] a) {}//Correct public void testWithAnnotationInMiddle4(final char@AnnotationAfterTest[]a) {}//Correct + public @AnnotationAfterTest String @AnnotationAfterTest [] testWithAnnotationInMiddle5() { + return new @AnnotationAfterTest String @AnnotationAfterTest [3];//Correct + } @Target(ElementType.TYPE_USE) @interface AnnotationAfterTest { diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/InputRegressionJava8Class1.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/InputRegressionJava8Class1.java index f73a0cffeb7c..90ddb9b25f31 100644 --- a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/InputRegressionJava8Class1.java +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/InputRegressionJava8Class1.java @@ -25,6 +25,8 @@ public static void m2(T @Nullable [] array) {} public void m3() throws NullPointerException, @Nullable ArrayIndexOutOfBoundsException {} public void m4(InputRegressionJava8Class1 this) {} public void m5(@Nullable InputRegressionJava8Class1 this) {} + public void m6(@Nullable String @Nullable ... vararg) {} + public String m7() @Nullable [] @Nullable [] { return null; } { List vlist = new ArrayList(); @@ -44,6 +46,9 @@ public void instructions() { Map.@Nullable Entry e; String str = (@Nullable String) ""; (new Inner3()).<@Nullable String>m(); + Object arr = new @Nullable String @Nullable [3]; + for (String a @Nullable [] : m7()) {} + Object arr2 = new @Nullable int[3]; // method reference IntBinaryOperator ibo = Math::max; diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/InputRegressionJava8Class1Ast.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/InputRegressionJava8Class1Ast.txt index b9a60b7ff653..c7ef9fe1d00d 100644 --- a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/InputRegressionJava8Class1Ast.txt +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/InputRegressionJava8Class1Ast.txt @@ -292,412 +292,526 @@ CLASS_DEF -> CLASS_DEF [17:0] | |--RPAREN -> ) [27:60] | `--SLIST -> { [27:62] | `--RCURLY -> } [27:63] - |--INSTANCE_INIT -> INSTANCE_INIT [29:4] - | `--SLIST -> { [29:4] - | |--VARIABLE_DEF -> VARIABLE_DEF [30:8] - | | |--MODIFIERS -> MODIFIERS [30:8] - | | |--TYPE -> TYPE [30:8] - | | | |--IDENT -> List [30:8] - | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [30:12] - | | | |--GENERIC_START -> < [30:12] - | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [30:13] - | | | | `--IDENT -> String [30:13] - | | | `--GENERIC_END -> > [30:19] - | | |--IDENT -> vlist [30:21] - | | `--ASSIGN -> = [30:27] - | | `--EXPR -> EXPR [30:29] - | | `--LITERAL_NEW -> new [30:29] - | | |--IDENT -> ArrayList [30:33] - | | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [30:42] - | | | |--GENERIC_START -> < [30:42] - | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [30:43] - | | | | `--IDENT -> String [30:43] - | | | `--GENERIC_END -> > [30:49] - | | |--LPAREN -> ( [30:50] - | | |--ELIST -> ELIST [30:51] - | | `--RPAREN -> ) [30:51] - | |--SEMI -> ; [30:52] - | `--RCURLY -> } [31:4] - |--METHOD_DEF -> METHOD_DEF [33:4] - | |--MODIFIERS -> MODIFIERS [33:4] - | | `--LITERAL_PUBLIC -> public [33:4] - | |--TYPE -> TYPE [33:11] - | | `--LITERAL_VOID -> void [33:11] - | |--IDENT -> instructions [33:16] - | |--LPAREN -> ( [33:28] - | |--PARAMETERS -> PARAMETERS [33:29] - | |--RPAREN -> ) [33:29] - | `--SLIST -> { [33:31] - | |--VARIABLE_DEF -> VARIABLE_DEF [35:8] - | | |--MODIFIERS -> MODIFIERS [35:8] - | | |--TYPE -> TYPE [35:8] - | | | `--LITERAL_BOOLEAN -> boolean [35:8] - | | |--IDENT -> b [35:16] - | | `--ASSIGN -> = [35:18] - | | `--EXPR -> EXPR [35:34] - | | `--GT -> > [35:34] - | | |--METHOD_CALL -> ( [35:31] - | | | |--DOT -> . [35:24] - | | | | |--IDENT -> Math [35:20] - | | | | `--IDENT -> random [35:25] - | | | |--ELIST -> ELIST [35:32] - | | | `--RPAREN -> ) [35:32] - | | `--NUM_INT -> 0 [35:36] - | |--SEMI -> ; [35:37] + |--METHOD_DEF -> METHOD_DEF [28:4] + | |--MODIFIERS -> MODIFIERS [28:4] + | | `--LITERAL_PUBLIC -> public [28:4] + | |--TYPE -> TYPE [28:11] + | | `--LITERAL_VOID -> void [28:11] + | |--IDENT -> m6 [28:16] + | |--LPAREN -> ( [28:18] + | |--PARAMETERS -> PARAMETERS [28:19] + | | `--PARAMETER_DEF -> PARAMETER_DEF [28:19] + | | |--MODIFIERS -> MODIFIERS [28:19] + | | | `--ANNOTATION -> ANNOTATION [28:19] + | | | |--AT -> @ [28:19] + | | | `--IDENT -> Nullable [28:20] + | | |--TYPE -> TYPE [28:29] + | | | |--IDENT -> String [28:29] + | | | `--ANNOTATIONS -> ANNOTATIONS [28:36] + | | | `--ANNOTATION -> ANNOTATION [28:36] + | | | |--AT -> @ [28:36] + | | | `--IDENT -> Nullable [28:37] + | | |--ELLIPSIS -> ... [28:46] + | | `--IDENT -> vararg [28:50] + | |--RPAREN -> ) [28:56] + | `--SLIST -> { [28:58] + | `--RCURLY -> } [28:59] + |--METHOD_DEF -> METHOD_DEF [29:4] + | |--MODIFIERS -> MODIFIERS [29:4] + | | `--LITERAL_PUBLIC -> public [29:4] + | |--TYPE -> TYPE [29:46] + | | `--ARRAY_DECLARATOR -> [ [29:46] + | | |--ARRAY_DECLARATOR -> [ [29:33] + | | | |--IDENT -> String [29:11] + | | | |--ANNOTATIONS -> ANNOTATIONS [29:23] + | | | | `--ANNOTATION -> ANNOTATION [29:23] + | | | | |--AT -> @ [29:23] + | | | | `--IDENT -> Nullable [29:24] + | | | `--RBRACK -> ] [29:34] + | | |--ANNOTATIONS -> ANNOTATIONS [29:36] + | | | `--ANNOTATION -> ANNOTATION [29:36] + | | | |--AT -> @ [29:36] + | | | `--IDENT -> Nullable [29:37] + | | `--RBRACK -> ] [29:47] + | |--IDENT -> m7 [29:18] + | |--LPAREN -> ( [29:20] + | |--PARAMETERS -> PARAMETERS [29:21] + | |--RPAREN -> ) [29:21] + | `--SLIST -> { [29:49] + | |--LITERAL_RETURN -> return [29:51] + | | |--EXPR -> EXPR [29:58] + | | | `--LITERAL_NULL -> null [29:58] + | | `--SEMI -> ; [29:62] + | `--RCURLY -> } [29:64] + |--INSTANCE_INIT -> INSTANCE_INIT [31:4] + | `--SLIST -> { [31:4] + | |--VARIABLE_DEF -> VARIABLE_DEF [32:8] + | | |--MODIFIERS -> MODIFIERS [32:8] + | | |--TYPE -> TYPE [32:8] + | | | |--IDENT -> List [32:8] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [32:12] + | | | |--GENERIC_START -> < [32:12] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [32:13] + | | | | `--IDENT -> String [32:13] + | | | `--GENERIC_END -> > [32:19] + | | |--IDENT -> vlist [32:21] + | | `--ASSIGN -> = [32:27] + | | `--EXPR -> EXPR [32:29] + | | `--LITERAL_NEW -> new [32:29] + | | |--IDENT -> ArrayList [32:33] + | | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [32:42] + | | | |--GENERIC_START -> < [32:42] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [32:43] + | | | | `--IDENT -> String [32:43] + | | | `--GENERIC_END -> > [32:49] + | | |--LPAREN -> ( [32:50] + | | |--ELIST -> ELIST [32:51] + | | `--RPAREN -> ) [32:51] + | |--SEMI -> ; [32:52] + | `--RCURLY -> } [33:4] + |--METHOD_DEF -> METHOD_DEF [35:4] + | |--MODIFIERS -> MODIFIERS [35:4] + | | `--LITERAL_PUBLIC -> public [35:4] + | |--TYPE -> TYPE [35:11] + | | `--LITERAL_VOID -> void [35:11] + | |--IDENT -> instructions [35:16] + | |--LPAREN -> ( [35:28] + | |--PARAMETERS -> PARAMETERS [35:29] + | |--RPAREN -> ) [35:29] + | `--SLIST -> { [35:31] | |--VARIABLE_DEF -> VARIABLE_DEF [37:8] | | |--MODIFIERS -> MODIFIERS [37:8] | | |--TYPE -> TYPE [37:8] - | | | `--LITERAL_INT -> int [37:8] - | | `--IDENT -> vint [37:12] - | |--SEMI -> ; [37:16] - | |--VARIABLE_DEF -> VARIABLE_DEF [38:8] - | | |--MODIFIERS -> MODIFIERS [38:8] - | | |--TYPE -> TYPE [38:8] - | | | `--IDENT -> Object [38:8] - | | |--IDENT -> o [38:15] - | | `--ASSIGN -> = [38:17] - | | `--EXPR -> EXPR [38:19] - | | `--LITERAL_NULL -> null [38:19] - | |--SEMI -> ; [38:23] + | | | `--LITERAL_BOOLEAN -> boolean [37:8] + | | |--IDENT -> b [37:16] + | | `--ASSIGN -> = [37:18] + | | `--EXPR -> EXPR [37:34] + | | `--GT -> > [37:34] + | | |--METHOD_CALL -> ( [37:31] + | | | |--DOT -> . [37:24] + | | | | |--IDENT -> Math [37:20] + | | | | `--IDENT -> random [37:25] + | | | |--ELIST -> ELIST [37:32] + | | | `--RPAREN -> ) [37:32] + | | `--NUM_INT -> 0 [37:36] + | |--SEMI -> ; [37:37] | |--VARIABLE_DEF -> VARIABLE_DEF [39:8] | | |--MODIFIERS -> MODIFIERS [39:8] | | |--TYPE -> TYPE [39:8] - | | | |--IDENT -> List [39:8] - | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [39:12] - | | | |--GENERIC_START -> < [39:12] - | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [39:13] - | | | | `--IDENT -> String [39:13] - | | | `--GENERIC_END -> > [39:19] - | | `--IDENT -> vlist [39:21] - | |--SEMI -> ; [39:26] - | |--EXPR -> EXPR [40:14] - | | `--ASSIGN -> = [40:14] - | | |--IDENT -> vlist [40:8] - | | `--LITERAL_NEW -> new [40:16] - | | |--IDENT -> ArrayList [40:20] - | | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [40:29] - | | | |--GENERIC_START -> < [40:29] - | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [40:30] - | | | | `--IDENT -> String [40:30] - | | | `--GENERIC_END -> > [40:36] - | | |--LPAREN -> ( [40:37] - | | |--ELIST -> ELIST [40:38] - | | `--RPAREN -> ) [40:38] - | |--SEMI -> ; [40:39] + | | | `--LITERAL_INT -> int [39:8] + | | `--IDENT -> vint [39:12] + | |--SEMI -> ; [39:16] + | |--VARIABLE_DEF -> VARIABLE_DEF [40:8] + | | |--MODIFIERS -> MODIFIERS [40:8] + | | |--TYPE -> TYPE [40:8] + | | | `--IDENT -> Object [40:8] + | | |--IDENT -> o [40:15] + | | `--ASSIGN -> = [40:17] + | | `--EXPR -> EXPR [40:19] + | | `--LITERAL_NULL -> null [40:19] + | |--SEMI -> ; [40:23] | |--VARIABLE_DEF -> VARIABLE_DEF [41:8] | | |--MODIFIERS -> MODIFIERS [41:8] | | |--TYPE -> TYPE [41:8] - | | | |--IDENT -> Supplier [41:8] - | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [41:16] - | | | |--GENERIC_START -> < [41:16] - | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [41:17] - | | | | `--WILDCARD_TYPE -> ? [41:17] - | | | `--GENERIC_END -> > [41:18] - | | `--IDENT -> s [41:20] - | |--SEMI -> ; [41:21] - | |--VARIABLE_DEF -> VARIABLE_DEF [44:11] - | | |--MODIFIERS -> MODIFIERS [44:11] - | | |--TYPE -> TYPE [44:11] - | | | `--DOT -> . [44:11] - | | | |--IDENT -> Map [44:8] - | | | |--ANNOTATIONS -> ANNOTATIONS [44:12] - | | | | `--ANNOTATION -> ANNOTATION [44:12] - | | | | |--AT -> @ [44:12] - | | | | `--IDENT -> Nullable [44:13] - | | | `--IDENT -> Entry [44:22] - | | `--IDENT -> e [44:28] - | |--SEMI -> ; [44:29] - | |--VARIABLE_DEF -> VARIABLE_DEF [45:8] - | | |--MODIFIERS -> MODIFIERS [45:8] - | | |--TYPE -> TYPE [45:8] - | | | `--IDENT -> String [45:8] - | | |--IDENT -> str [45:15] - | | `--ASSIGN -> = [45:19] - | | `--EXPR -> EXPR [45:21] - | | `--TYPECAST -> ( [45:21] - | | |--TYPE -> TYPE [45:22] - | | | |--ANNOTATIONS -> ANNOTATIONS [45:22] - | | | | `--ANNOTATION -> ANNOTATION [45:22] - | | | | |--AT -> @ [45:22] - | | | | `--IDENT -> Nullable [45:23] - | | | `--IDENT -> String [45:32] - | | |--RPAREN -> ) [45:38] - | | `--STRING_LITERAL -> "" [45:40] - | |--SEMI -> ; [45:42] - | |--EXPR -> EXPR [46:42] - | | `--METHOD_CALL -> ( [46:42] - | | |--DOT -> . [46:22] - | | | |--LPAREN -> ( [46:8] - | | | |--LITERAL_NEW -> new [46:9] - | | | | |--IDENT -> Inner3 [46:13] - | | | | |--LPAREN -> ( [46:19] - | | | | |--ELIST -> ELIST [46:20] - | | | | `--RPAREN -> ) [46:20] - | | | |--RPAREN -> ) [46:21] - | | | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [46:23] - | | | | |--GENERIC_START -> < [46:23] - | | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [46:24] - | | | | | |--ANNOTATIONS -> ANNOTATIONS [46:24] - | | | | | | `--ANNOTATION -> ANNOTATION [46:24] - | | | | | | |--AT -> @ [46:24] - | | | | | | `--IDENT -> Nullable [46:25] - | | | | | `--IDENT -> String [46:34] - | | | | `--GENERIC_END -> > [46:40] - | | | `--IDENT -> m [46:41] - | | |--ELIST -> ELIST [46:43] - | | `--RPAREN -> ) [46:43] - | |--SEMI -> ; [46:44] + | | | |--IDENT -> List [41:8] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [41:12] + | | | |--GENERIC_START -> < [41:12] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [41:13] + | | | | `--IDENT -> String [41:13] + | | | `--GENERIC_END -> > [41:19] + | | `--IDENT -> vlist [41:21] + | |--SEMI -> ; [41:26] + | |--EXPR -> EXPR [42:14] + | | `--ASSIGN -> = [42:14] + | | |--IDENT -> vlist [42:8] + | | `--LITERAL_NEW -> new [42:16] + | | |--IDENT -> ArrayList [42:20] + | | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [42:29] + | | | |--GENERIC_START -> < [42:29] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [42:30] + | | | | `--IDENT -> String [42:30] + | | | `--GENERIC_END -> > [42:36] + | | |--LPAREN -> ( [42:37] + | | |--ELIST -> ELIST [42:38] + | | `--RPAREN -> ) [42:38] + | |--SEMI -> ; [42:39] + | |--VARIABLE_DEF -> VARIABLE_DEF [43:8] + | | |--MODIFIERS -> MODIFIERS [43:8] + | | |--TYPE -> TYPE [43:8] + | | | |--IDENT -> Supplier [43:8] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [43:16] + | | | |--GENERIC_START -> < [43:16] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [43:17] + | | | | `--WILDCARD_TYPE -> ? [43:17] + | | | `--GENERIC_END -> > [43:18] + | | `--IDENT -> s [43:20] + | |--SEMI -> ; [43:21] + | |--VARIABLE_DEF -> VARIABLE_DEF [46:11] + | | |--MODIFIERS -> MODIFIERS [46:11] + | | |--TYPE -> TYPE [46:11] + | | | `--DOT -> . [46:11] + | | | |--IDENT -> Map [46:8] + | | | |--ANNOTATIONS -> ANNOTATIONS [46:12] + | | | | `--ANNOTATION -> ANNOTATION [46:12] + | | | | |--AT -> @ [46:12] + | | | | `--IDENT -> Nullable [46:13] + | | | `--IDENT -> Entry [46:22] + | | `--IDENT -> e [46:28] + | |--SEMI -> ; [46:29] + | |--VARIABLE_DEF -> VARIABLE_DEF [47:8] + | | |--MODIFIERS -> MODIFIERS [47:8] + | | |--TYPE -> TYPE [47:8] + | | | `--IDENT -> String [47:8] + | | |--IDENT -> str [47:15] + | | `--ASSIGN -> = [47:19] + | | `--EXPR -> EXPR [47:21] + | | `--TYPECAST -> ( [47:21] + | | |--TYPE -> TYPE [47:22] + | | | |--ANNOTATIONS -> ANNOTATIONS [47:22] + | | | | `--ANNOTATION -> ANNOTATION [47:22] + | | | | |--AT -> @ [47:22] + | | | | `--IDENT -> Nullable [47:23] + | | | `--IDENT -> String [47:32] + | | |--RPAREN -> ) [47:38] + | | `--STRING_LITERAL -> "" [47:40] + | |--SEMI -> ; [47:42] + | |--EXPR -> EXPR [48:42] + | | `--METHOD_CALL -> ( [48:42] + | | |--DOT -> . [48:22] + | | | |--LPAREN -> ( [48:8] + | | | |--LITERAL_NEW -> new [48:9] + | | | | |--IDENT -> Inner3 [48:13] + | | | | |--LPAREN -> ( [48:19] + | | | | |--ELIST -> ELIST [48:20] + | | | | `--RPAREN -> ) [48:20] + | | | |--RPAREN -> ) [48:21] + | | | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [48:23] + | | | | |--GENERIC_START -> < [48:23] + | | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [48:24] + | | | | | |--ANNOTATIONS -> ANNOTATIONS [48:24] + | | | | | | `--ANNOTATION -> ANNOTATION [48:24] + | | | | | | |--AT -> @ [48:24] + | | | | | | `--IDENT -> Nullable [48:25] + | | | | | `--IDENT -> String [48:34] + | | | | `--GENERIC_END -> > [48:40] + | | | `--IDENT -> m [48:41] + | | |--ELIST -> ELIST [48:43] + | | `--RPAREN -> ) [48:43] + | |--SEMI -> ; [48:44] | |--VARIABLE_DEF -> VARIABLE_DEF [49:8] | | |--MODIFIERS -> MODIFIERS [49:8] | | |--TYPE -> TYPE [49:8] - | | | `--IDENT -> IntBinaryOperator [49:8] - | | |--IDENT -> ibo [49:26] - | | `--ASSIGN -> = [49:30] - | | `--EXPR -> EXPR [49:36] - | | `--METHOD_REF -> :: [49:36] - | | |--IDENT -> Math [49:32] - | | `--IDENT -> max [49:38] - | |--SEMI -> ; [49:41] - | |--EXPR -> EXPR [50:10] - | | `--ASSIGN -> = [50:10] - | | |--IDENT -> s [50:8] - | | `--METHOD_REF -> :: [50:38] - | | |--IDENT -> InputRegressionJava8Class1 [50:12] - | | `--LITERAL_NEW -> new [50:40] - | |--SEMI -> ; [50:43] - | |--EXPR -> EXPR [51:10] - | | `--ASSIGN -> = [51:10] - | | |--IDENT -> s [51:8] - | | `--METHOD_REF -> :: [51:33] - | | |--DOT -> . [51:18] - | | | |--IDENT -> Inner1 [51:12] - | | | |--IDENT -> Inner2 [51:19] - | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [51:25] - | | | |--GENERIC_START -> < [51:25] - | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [51:26] - | | | | `--IDENT -> String [51:26] - | | | `--GENERIC_END -> > [51:32] - | | `--LITERAL_NEW -> new [51:35] - | |--SEMI -> ; [51:38] + | | | `--IDENT -> Object [49:8] + | | |--IDENT -> arr [49:15] + | | `--ASSIGN -> = [49:19] + | | `--EXPR -> EXPR [49:21] + | | `--LITERAL_NEW -> new [49:21] + | | |--ANNOTATIONS -> ANNOTATIONS [49:25] + | | | `--ANNOTATION -> ANNOTATION [49:25] + | | | |--AT -> @ [49:25] + | | | `--IDENT -> Nullable [49:26] + | | |--IDENT -> String [49:35] + | | `--ARRAY_DECLARATOR -> [ [49:52] + | | |--ANNOTATIONS -> ANNOTATIONS [49:42] + | | | `--ANNOTATION -> ANNOTATION [49:42] + | | | |--AT -> @ [49:42] + | | | `--IDENT -> Nullable [49:43] + | | |--EXPR -> EXPR [49:53] + | | | `--NUM_INT -> 3 [49:53] + | | `--RBRACK -> ] [49:54] + | |--SEMI -> ; [49:55] + | |--LITERAL_FOR -> for [50:8] + | | |--LPAREN -> ( [50:12] + | | |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [50:32] + | | | |--VARIABLE_DEF -> VARIABLE_DEF [50:32] + | | | | |--MODIFIERS -> MODIFIERS [50:32] + | | | | |--TYPE -> TYPE [50:32] + | | | | | `--ARRAY_DECLARATOR -> [ [50:32] + | | | | | |--IDENT -> String [50:13] + | | | | | |--ANNOTATIONS -> ANNOTATIONS [50:22] + | | | | | | `--ANNOTATION -> ANNOTATION [50:22] + | | | | | | |--AT -> @ [50:22] + | | | | | | `--IDENT -> Nullable [50:23] + | | | | | `--RBRACK -> ] [50:33] + | | | | `--IDENT -> a [50:20] + | | | |--COLON -> : [50:35] + | | | `--EXPR -> EXPR [50:39] + | | | `--METHOD_CALL -> ( [50:39] + | | | |--IDENT -> m7 [50:37] + | | | |--ELIST -> ELIST [50:40] + | | | `--RPAREN -> ) [50:40] + | | |--RPAREN -> ) [50:41] + | | `--SLIST -> { [50:43] + | | `--RCURLY -> } [50:44] + | |--VARIABLE_DEF -> VARIABLE_DEF [51:8] + | | |--MODIFIERS -> MODIFIERS [51:8] + | | |--TYPE -> TYPE [51:8] + | | | `--IDENT -> Object [51:8] + | | |--IDENT -> arr2 [51:15] + | | `--ASSIGN -> = [51:20] + | | `--EXPR -> EXPR [51:22] + | | `--LITERAL_NEW -> new [51:22] + | | |--ANNOTATIONS -> ANNOTATIONS [51:26] + | | | `--ANNOTATION -> ANNOTATION [51:26] + | | | |--AT -> @ [51:26] + | | | `--IDENT -> Nullable [51:27] + | | |--LITERAL_INT -> int [51:36] + | | `--ARRAY_DECLARATOR -> [ [51:39] + | | |--EXPR -> EXPR [51:40] + | | | `--NUM_INT -> 3 [51:40] + | | `--RBRACK -> ] [51:41] + | |--SEMI -> ; [51:42] | |--VARIABLE_DEF -> VARIABLE_DEF [54:8] | | |--MODIFIERS -> MODIFIERS [54:8] | | |--TYPE -> TYPE [54:8] - | | | `--IDENT -> Runnable [54:8] - | | |--IDENT -> r1 [54:17] - | | `--ASSIGN -> = [54:20] - | | `--LAMBDA -> -> [54:25] - | | |--LPAREN -> ( [54:22] - | | |--PARAMETERS -> PARAMETERS [54:23] - | | |--RPAREN -> ) [54:23] - | | `--EXPR -> EXPR [54:29] - | | `--METHOD_CALL -> ( [54:29] - | | |--IDENT -> m [54:28] - | | |--ELIST -> ELIST [54:30] - | | `--RPAREN -> ) [54:30] - | |--SEMI -> ; [54:31] - | |--VARIABLE_DEF -> VARIABLE_DEF [55:8] - | | |--MODIFIERS -> MODIFIERS [55:8] - | | |--TYPE -> TYPE [55:8] - | | | `--IDENT -> Runnable [55:8] - | | |--IDENT -> r2 [55:17] - | | `--ASSIGN -> = [55:20] - | | `--LAMBDA -> -> [55:25] - | | |--LPAREN -> ( [55:22] - | | |--PARAMETERS -> PARAMETERS [55:23] - | | |--RPAREN -> ) [55:23] - | | `--SLIST -> { [55:28] - | | |--EXPR -> EXPR [55:31] - | | | `--METHOD_CALL -> ( [55:31] - | | | |--IDENT -> m [55:30] - | | | |--ELIST -> ELIST [55:32] - | | | `--RPAREN -> ) [55:32] - | | |--SEMI -> ; [55:33] - | | `--RCURLY -> } [55:35] - | |--SEMI -> ; [55:37] - | |--EXPR -> EXPR [56:24] - | | `--METHOD_CALL -> ( [56:24] - | | |--DOT -> . [56:19] - | | | |--IDENT -> Collections [56:8] - | | | `--IDENT -> sort [56:20] - | | |--ELIST -> ELIST [56:25] - | | | |--EXPR -> EXPR [56:25] - | | | | `--IDENT -> vlist [56:25] - | | | |--COMMA -> , [56:30] - | | | `--LAMBDA -> -> [56:40] - | | | |--LPAREN -> ( [56:32] - | | | |--PARAMETERS -> PARAMETERS [56:33] - | | | | |--PARAMETER_DEF -> PARAMETER_DEF [56:33] - | | | | | |--MODIFIERS -> MODIFIERS [56:33] - | | | | | |--TYPE -> TYPE [56:33] - | | | | | `--IDENT -> l [56:33] - | | | | |--COMMA -> , [56:34] - | | | | `--PARAMETER_DEF -> PARAMETER_DEF [56:37] - | | | | |--MODIFIERS -> MODIFIERS [56:37] - | | | | |--TYPE -> TYPE [56:37] - | | | | `--IDENT -> r [56:37] - | | | |--RPAREN -> ) [56:38] - | | | `--EXPR -> EXPR [56:50] - | | | `--QUESTION -> ? [56:50] - | | | |--EQUAL -> == [56:45] - | | | | |--IDENT -> l [56:43] - | | | | `--IDENT -> r [56:48] - | | | |--NUM_INT -> 0 [56:52] - | | | |--COLON -> : [56:54] - | | | `--NUM_INT -> 1 [56:56] - | | `--RPAREN -> ) [56:57] - | |--SEMI -> ; [56:58] - | |--VARIABLE_DEF -> VARIABLE_DEF [57:8] - | | |--MODIFIERS -> MODIFIERS [57:8] - | | |--TYPE -> TYPE [57:8] - | | | |--IDENT -> Predicate [57:8] - | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [57:17] - | | | |--GENERIC_START -> < [57:17] - | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [57:18] - | | | | `--WILDCARD_TYPE -> ? [57:18] - | | | `--GENERIC_END -> > [57:19] - | | |--IDENT -> t [57:21] - | | `--ASSIGN -> = [57:23] - | | `--EXPR -> EXPR [57:29] - | | `--QUESTION -> ? [57:29] - | | |--LPAREN -> ( [57:25] - | | |--IDENT -> b [57:26] - | | |--RPAREN -> ) [57:27] - | | |--LITERAL_NULL -> null [57:31] - | | |--COLON -> : [57:36] - | | `--LAMBDA -> -> [57:45] - | | |--IDENT -> object [57:38] - | | `--EXPR -> EXPR [57:56] - | | `--METHOD_CALL -> ( [57:56] - | | |--DOT -> . [57:49] - | | | |--IDENT -> o [57:48] - | | | `--IDENT -> equals [57:50] - | | |--ELIST -> ELIST [57:57] - | | | `--EXPR -> EXPR [57:57] - | | | `--IDENT -> object [57:57] - | | `--RPAREN -> ) [57:63] - | |--SEMI -> ; [57:64] - | |--VARIABLE_DEF -> VARIABLE_DEF [58:8] - | | |--MODIFIERS -> MODIFIERS [58:8] - | | |--TYPE -> TYPE [58:8] - | | | `--IDENT -> Double [58:8] - | | |--IDENT -> mPi [58:15] - | | `--ASSIGN -> = [58:19] - | | `--EXPR -> EXPR [58:25] - | | `--DOT -> . [58:25] - | | |--IDENT -> Math [58:21] - | | `--IDENT -> PI [58:26] - | |--SEMI -> ; [58:28] - | `--RCURLY -> } [59:4] - |--VARIABLE_DEF -> VARIABLE_DEF [61:4] - | |--MODIFIERS -> MODIFIERS [61:4] - | | |--LITERAL_STATIC -> static [61:4] - | | `--FINAL -> final [61:11] - | |--TYPE -> TYPE [61:17] - | | |--IDENT -> Comparator [61:17] - | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [61:27] - | | |--GENERIC_START -> < [61:27] - | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [61:28] - | | | `--WILDCARD_TYPE -> ? [61:28] - | | `--GENERIC_END -> > [61:29] - | |--IDENT -> f [61:31] - | |--ASSIGN -> = [61:33] - | | `--EXPR -> EXPR [61:35] - | | `--TYPECAST -> ( [61:35] - | | |--TYPE -> TYPE [61:36] - | | | |--IDENT -> Comparator [61:36] - | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [61:46] - | | | |--GENERIC_START -> < [61:46] - | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [61:47] - | | | | `--WILDCARD_TYPE -> ? [61:47] - | | | `--GENERIC_END -> > [61:48] - | | |--RPAREN -> ) [61:49] - | | `--LAMBDA -> -> [61:74] - | | |--LPAREN -> ( [61:51] - | | |--PARAMETERS -> PARAMETERS [61:52] - | | | |--PARAMETER_DEF -> PARAMETER_DEF [61:52] - | | | | |--MODIFIERS -> MODIFIERS [61:52] - | | | | |--TYPE -> TYPE [61:52] - | | | | `--IDENT -> dateTime1 [61:52] - | | | |--COMMA -> , [61:61] - | | | `--PARAMETER_DEF -> PARAMETER_DEF [61:63] - | | | |--MODIFIERS -> MODIFIERS [61:63] - | | | |--TYPE -> TYPE [61:63] - | | | `--IDENT -> dateTime2 [61:63] - | | |--RPAREN -> ) [61:72] - | | `--SLIST -> { [61:77] - | | |--LITERAL_RETURN -> return [61:79] - | | | |--EXPR -> EXPR [61:86] - | | | | `--NUM_INT -> 0 [61:86] - | | | `--SEMI -> ; [61:87] - | | `--RCURLY -> } [61:89] - | `--SEMI -> ; [61:90] - |--CLASS_DEF -> CLASS_DEF [63:4] - | |--MODIFIERS -> MODIFIERS [63:4] - | | `--LITERAL_PRIVATE -> private [63:4] - | |--LITERAL_CLASS -> class [63:12] - | |--IDENT -> Inner [63:18] - | `--OBJBLOCK -> OBJBLOCK [63:24] - | |--LCURLY -> { [63:24] - | |--CTOR_DEF -> CTOR_DEF [64:8] - | | |--MODIFIERS -> MODIFIERS [64:8] - | | | `--LITERAL_PUBLIC -> public [64:8] - | | |--IDENT -> Inner [64:15] - | | |--LPAREN -> ( [64:20] - | | |--PARAMETERS -> PARAMETERS [64:21] - | | | `--PARAMETER_DEF -> PARAMETER_DEF [64:21] - | | | |--MODIFIERS -> MODIFIERS [64:21] - | | | |--TYPE -> TYPE [64:21] - | | | | `--IDENT -> InputRegressionJava8Class1 [64:21] - | | | `--DOT -> . [64:74] - | | | |--IDENT -> InputRegressionJava8Class1 [64:48] - | | | `--LITERAL_THIS -> this [64:75] - | | |--RPAREN -> ) [64:79] - | | `--SLIST -> { [64:81] - | | `--RCURLY -> } [64:82] - | `--RCURLY -> } [65:4] - `--RCURLY -> } [66:0] -SEMI -> ; [67:0] -CLASS_DEF -> CLASS_DEF [68:0] -|--MODIFIERS -> MODIFIERS [68:0] -|--LITERAL_CLASS -> class [68:0] -|--IDENT -> InputRegressionJava8TypeParam [68:6] -|--TYPE_PARAMETERS -> TYPE_PARAMETERS [68:36] -| |--GENERIC_START -> < [68:36] -| |--TYPE_PARAMETER -> TYPE_PARAMETER [68:37] -| | |--ANNOTATIONS -> ANNOTATIONS [68:37] -| | | `--ANNOTATION -> ANNOTATION [68:37] -| | | |--AT -> @ [68:37] -| | | `--IDENT -> Nullable [68:38] -| | `--IDENT -> T [68:47] -| `--GENERIC_END -> > [68:48] -`--OBJBLOCK -> OBJBLOCK [68:50] - |--LCURLY -> { [68:50] - `--RCURLY -> } [69:0] -ANNOTATION_DEF -> ANNOTATION_DEF [70:0] -|--MODIFIERS -> MODIFIERS [70:0] -| |--ANNOTATION -> ANNOTATION [70:0] -| | |--AT -> @ [70:0] -| | |--IDENT -> Retention [70:1] -| | |--LPAREN -> ( [70:10] -| | |--EXPR -> EXPR [70:26] -| | | `--DOT -> . [70:26] -| | | |--IDENT -> RetentionPolicy [70:11] -| | | `--IDENT -> CLASS [70:27] -| | `--RPAREN -> ) [70:32] -| `--ANNOTATION -> ANNOTATION [71:0] -| |--AT -> @ [71:0] -| |--IDENT -> Target [71:1] -| |--LPAREN -> ( [71:7] -| |--ANNOTATION_ARRAY_INIT -> { [71:8] -| | |--EXPR -> EXPR [71:21] -| | | `--DOT -> . [71:21] -| | | |--IDENT -> ElementType [71:10] -| | | `--IDENT -> TYPE_USE [71:22] -| | `--RCURLY -> } [71:31] -| `--RPAREN -> ) [71:32] -|--AT -> @ [72:0] -|--LITERAL_INTERFACE -> interface [72:1] -|--IDENT -> Nullable [72:11] -`--OBJBLOCK -> OBJBLOCK [72:20] - |--LCURLY -> { [72:20] - `--RCURLY -> } [73:0] + | | | `--IDENT -> IntBinaryOperator [54:8] + | | |--IDENT -> ibo [54:26] + | | `--ASSIGN -> = [54:30] + | | `--EXPR -> EXPR [54:36] + | | `--METHOD_REF -> :: [54:36] + | | |--IDENT -> Math [54:32] + | | `--IDENT -> max [54:38] + | |--SEMI -> ; [54:41] + | |--EXPR -> EXPR [55:10] + | | `--ASSIGN -> = [55:10] + | | |--IDENT -> s [55:8] + | | `--METHOD_REF -> :: [55:38] + | | |--IDENT -> InputRegressionJava8Class1 [55:12] + | | `--LITERAL_NEW -> new [55:40] + | |--SEMI -> ; [55:43] + | |--EXPR -> EXPR [56:10] + | | `--ASSIGN -> = [56:10] + | | |--IDENT -> s [56:8] + | | `--METHOD_REF -> :: [56:33] + | | |--DOT -> . [56:18] + | | | |--IDENT -> Inner1 [56:12] + | | | |--IDENT -> Inner2 [56:19] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [56:25] + | | | |--GENERIC_START -> < [56:25] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [56:26] + | | | | `--IDENT -> String [56:26] + | | | `--GENERIC_END -> > [56:32] + | | `--LITERAL_NEW -> new [56:35] + | |--SEMI -> ; [56:38] + | |--VARIABLE_DEF -> VARIABLE_DEF [59:8] + | | |--MODIFIERS -> MODIFIERS [59:8] + | | |--TYPE -> TYPE [59:8] + | | | `--IDENT -> Runnable [59:8] + | | |--IDENT -> r1 [59:17] + | | `--ASSIGN -> = [59:20] + | | `--LAMBDA -> -> [59:25] + | | |--LPAREN -> ( [59:22] + | | |--PARAMETERS -> PARAMETERS [59:23] + | | |--RPAREN -> ) [59:23] + | | `--EXPR -> EXPR [59:29] + | | `--METHOD_CALL -> ( [59:29] + | | |--IDENT -> m [59:28] + | | |--ELIST -> ELIST [59:30] + | | `--RPAREN -> ) [59:30] + | |--SEMI -> ; [59:31] + | |--VARIABLE_DEF -> VARIABLE_DEF [60:8] + | | |--MODIFIERS -> MODIFIERS [60:8] + | | |--TYPE -> TYPE [60:8] + | | | `--IDENT -> Runnable [60:8] + | | |--IDENT -> r2 [60:17] + | | `--ASSIGN -> = [60:20] + | | `--LAMBDA -> -> [60:25] + | | |--LPAREN -> ( [60:22] + | | |--PARAMETERS -> PARAMETERS [60:23] + | | |--RPAREN -> ) [60:23] + | | `--SLIST -> { [60:28] + | | |--EXPR -> EXPR [60:31] + | | | `--METHOD_CALL -> ( [60:31] + | | | |--IDENT -> m [60:30] + | | | |--ELIST -> ELIST [60:32] + | | | `--RPAREN -> ) [60:32] + | | |--SEMI -> ; [60:33] + | | `--RCURLY -> } [60:35] + | |--SEMI -> ; [60:37] + | |--EXPR -> EXPR [61:24] + | | `--METHOD_CALL -> ( [61:24] + | | |--DOT -> . [61:19] + | | | |--IDENT -> Collections [61:8] + | | | `--IDENT -> sort [61:20] + | | |--ELIST -> ELIST [61:25] + | | | |--EXPR -> EXPR [61:25] + | | | | `--IDENT -> vlist [61:25] + | | | |--COMMA -> , [61:30] + | | | `--LAMBDA -> -> [61:40] + | | | |--LPAREN -> ( [61:32] + | | | |--PARAMETERS -> PARAMETERS [61:33] + | | | | |--PARAMETER_DEF -> PARAMETER_DEF [61:33] + | | | | | |--MODIFIERS -> MODIFIERS [61:33] + | | | | | |--TYPE -> TYPE [61:33] + | | | | | `--IDENT -> l [61:33] + | | | | |--COMMA -> , [61:34] + | | | | `--PARAMETER_DEF -> PARAMETER_DEF [61:37] + | | | | |--MODIFIERS -> MODIFIERS [61:37] + | | | | |--TYPE -> TYPE [61:37] + | | | | `--IDENT -> r [61:37] + | | | |--RPAREN -> ) [61:38] + | | | `--EXPR -> EXPR [61:50] + | | | `--QUESTION -> ? [61:50] + | | | |--EQUAL -> == [61:45] + | | | | |--IDENT -> l [61:43] + | | | | `--IDENT -> r [61:48] + | | | |--NUM_INT -> 0 [61:52] + | | | |--COLON -> : [61:54] + | | | `--NUM_INT -> 1 [61:56] + | | `--RPAREN -> ) [61:57] + | |--SEMI -> ; [61:58] + | |--VARIABLE_DEF -> VARIABLE_DEF [62:8] + | | |--MODIFIERS -> MODIFIERS [62:8] + | | |--TYPE -> TYPE [62:8] + | | | |--IDENT -> Predicate [62:8] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [62:17] + | | | |--GENERIC_START -> < [62:17] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [62:18] + | | | | `--WILDCARD_TYPE -> ? [62:18] + | | | `--GENERIC_END -> > [62:19] + | | |--IDENT -> t [62:21] + | | `--ASSIGN -> = [62:23] + | | `--EXPR -> EXPR [62:29] + | | `--QUESTION -> ? [62:29] + | | |--LPAREN -> ( [62:25] + | | |--IDENT -> b [62:26] + | | |--RPAREN -> ) [62:27] + | | |--LITERAL_NULL -> null [62:31] + | | |--COLON -> : [62:36] + | | `--LAMBDA -> -> [62:45] + | | |--IDENT -> object [62:38] + | | `--EXPR -> EXPR [62:56] + | | `--METHOD_CALL -> ( [62:56] + | | |--DOT -> . [62:49] + | | | |--IDENT -> o [62:48] + | | | `--IDENT -> equals [62:50] + | | |--ELIST -> ELIST [62:57] + | | | `--EXPR -> EXPR [62:57] + | | | `--IDENT -> object [62:57] + | | `--RPAREN -> ) [62:63] + | |--SEMI -> ; [62:64] + | |--VARIABLE_DEF -> VARIABLE_DEF [63:8] + | | |--MODIFIERS -> MODIFIERS [63:8] + | | |--TYPE -> TYPE [63:8] + | | | `--IDENT -> Double [63:8] + | | |--IDENT -> mPi [63:15] + | | `--ASSIGN -> = [63:19] + | | `--EXPR -> EXPR [63:25] + | | `--DOT -> . [63:25] + | | |--IDENT -> Math [63:21] + | | `--IDENT -> PI [63:26] + | |--SEMI -> ; [63:28] + | `--RCURLY -> } [64:4] + |--VARIABLE_DEF -> VARIABLE_DEF [66:4] + | |--MODIFIERS -> MODIFIERS [66:4] + | | |--LITERAL_STATIC -> static [66:4] + | | `--FINAL -> final [66:11] + | |--TYPE -> TYPE [66:17] + | | |--IDENT -> Comparator [66:17] + | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [66:27] + | | |--GENERIC_START -> < [66:27] + | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [66:28] + | | | `--WILDCARD_TYPE -> ? [66:28] + | | `--GENERIC_END -> > [66:29] + | |--IDENT -> f [66:31] + | |--ASSIGN -> = [66:33] + | | `--EXPR -> EXPR [66:35] + | | `--TYPECAST -> ( [66:35] + | | |--TYPE -> TYPE [66:36] + | | | |--IDENT -> Comparator [66:36] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [66:46] + | | | |--GENERIC_START -> < [66:46] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [66:47] + | | | | `--WILDCARD_TYPE -> ? [66:47] + | | | `--GENERIC_END -> > [66:48] + | | |--RPAREN -> ) [66:49] + | | `--LAMBDA -> -> [66:74] + | | |--LPAREN -> ( [66:51] + | | |--PARAMETERS -> PARAMETERS [66:52] + | | | |--PARAMETER_DEF -> PARAMETER_DEF [66:52] + | | | | |--MODIFIERS -> MODIFIERS [66:52] + | | | | |--TYPE -> TYPE [66:52] + | | | | `--IDENT -> dateTime1 [66:52] + | | | |--COMMA -> , [66:61] + | | | `--PARAMETER_DEF -> PARAMETER_DEF [66:63] + | | | |--MODIFIERS -> MODIFIERS [66:63] + | | | |--TYPE -> TYPE [66:63] + | | | `--IDENT -> dateTime2 [66:63] + | | |--RPAREN -> ) [66:72] + | | `--SLIST -> { [66:77] + | | |--LITERAL_RETURN -> return [66:79] + | | | |--EXPR -> EXPR [66:86] + | | | | `--NUM_INT -> 0 [66:86] + | | | `--SEMI -> ; [66:87] + | | `--RCURLY -> } [66:89] + | `--SEMI -> ; [66:90] + |--CLASS_DEF -> CLASS_DEF [68:4] + | |--MODIFIERS -> MODIFIERS [68:4] + | | `--LITERAL_PRIVATE -> private [68:4] + | |--LITERAL_CLASS -> class [68:12] + | |--IDENT -> Inner [68:18] + | `--OBJBLOCK -> OBJBLOCK [68:24] + | |--LCURLY -> { [68:24] + | |--CTOR_DEF -> CTOR_DEF [69:8] + | | |--MODIFIERS -> MODIFIERS [69:8] + | | | `--LITERAL_PUBLIC -> public [69:8] + | | |--IDENT -> Inner [69:15] + | | |--LPAREN -> ( [69:20] + | | |--PARAMETERS -> PARAMETERS [69:21] + | | | `--PARAMETER_DEF -> PARAMETER_DEF [69:21] + | | | |--MODIFIERS -> MODIFIERS [69:21] + | | | |--TYPE -> TYPE [69:21] + | | | | `--IDENT -> InputRegressionJava8Class1 [69:21] + | | | `--DOT -> . [69:74] + | | | |--IDENT -> InputRegressionJava8Class1 [69:48] + | | | `--LITERAL_THIS -> this [69:75] + | | |--RPAREN -> ) [69:79] + | | `--SLIST -> { [69:81] + | | `--RCURLY -> } [69:82] + | `--RCURLY -> } [70:4] + `--RCURLY -> } [71:0] +SEMI -> ; [72:0] +CLASS_DEF -> CLASS_DEF [73:0] +|--MODIFIERS -> MODIFIERS [73:0] +|--LITERAL_CLASS -> class [73:0] +|--IDENT -> InputRegressionJava8TypeParam [73:6] +|--TYPE_PARAMETERS -> TYPE_PARAMETERS [73:36] +| |--GENERIC_START -> < [73:36] +| |--TYPE_PARAMETER -> TYPE_PARAMETER [73:37] +| | |--ANNOTATIONS -> ANNOTATIONS [73:37] +| | | `--ANNOTATION -> ANNOTATION [73:37] +| | | |--AT -> @ [73:37] +| | | `--IDENT -> Nullable [73:38] +| | `--IDENT -> T [73:47] +| `--GENERIC_END -> > [73:48] +`--OBJBLOCK -> OBJBLOCK [73:50] + |--LCURLY -> { [73:50] + `--RCURLY -> } [74:0] +ANNOTATION_DEF -> ANNOTATION_DEF [75:0] +|--MODIFIERS -> MODIFIERS [75:0] +| |--ANNOTATION -> ANNOTATION [75:0] +| | |--AT -> @ [75:0] +| | |--IDENT -> Retention [75:1] +| | |--LPAREN -> ( [75:10] +| | |--EXPR -> EXPR [75:26] +| | | `--DOT -> . [75:26] +| | | |--IDENT -> RetentionPolicy [75:11] +| | | `--IDENT -> CLASS [75:27] +| | `--RPAREN -> ) [75:32] +| `--ANNOTATION -> ANNOTATION [76:0] +| |--AT -> @ [76:0] +| |--IDENT -> Target [76:1] +| |--LPAREN -> ( [76:7] +| |--ANNOTATION_ARRAY_INIT -> { [76:8] +| | |--EXPR -> EXPR [76:21] +| | | `--DOT -> . [76:21] +| | | |--IDENT -> ElementType [76:10] +| | | `--IDENT -> TYPE_USE [76:22] +| | `--RCURLY -> } [76:31] +| `--RPAREN -> ) [76:32] +|--AT -> @ [77:0] +|--LITERAL_INTERFACE -> interface [77:1] +|--IDENT -> Nullable [77:11] +`--OBJBLOCK -> OBJBLOCK [77:20] + |--LCURLY -> { [77:20] + `--RCURLY -> } [78:0] diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/java8/InputAnnotations12.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/java8/InputAnnotations12.java new file mode 100644 index 000000000000..fe4e83956112 --- /dev/null +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/java8/InputAnnotations12.java @@ -0,0 +1,16 @@ +package com.puppycrawl.tools.checkstyle.grammar.java8; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Target; + + +public class InputAnnotations12 { + public void m1(@MyAnnotation1 String @MyAnnotation1 ... vararg) {} + public void m2(@MyAnnotation1 int @MyAnnotation1 ... vararg) {} + public void m3(@MyAnnotation1 String @MyAnnotation1 [] @MyAnnotation1 [] ... vararg) {} + public void m4(@MyAnnotation1 int[] @MyAnnotation1 ... vararg) {} + public void m5(@MyAnnotation1 String[][] @MyAnnotation1 [] @MyAnnotation1 [] ... vararg) {} + + @Target(ElementType.TYPE_USE) + @interface MyAnnotation1 {} +} diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/java8/InputAnnotationsOnArray.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/java8/InputAnnotationsOnArray.java index 49c2590a3777..ff6e8bad4f8e 100644 --- a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/java8/InputAnnotationsOnArray.java +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/java8/InputAnnotationsOnArray.java @@ -9,6 +9,9 @@ public final class InputAnnotationsOnArray { + private String array1 @Nullable []; + private @Nullable int array2 @Nullable [] @Nullable []; + private InputAnnotationsOnArray() { } @@ -27,6 +30,27 @@ public static T[][] checkNotNullContents2(T @Nullable [] @Nullable [] array) return array; } + + public static T @Nullable [] checkNotNullContents3(T array @Nullable []) { + if (array == null) { + throw new NullPointerException(); + } + + return array; + } + + public T checkNotNullContents4(T @Nullable [] array) @Nullable [] { + if (array == null) { + throw new NullPointerException(); + } + String tmp1 @Nullable []; + @Nullable Object[] tmp2 = new @Nullable Integer[3]; + @Nullable int[] tmp3 = new @Nullable int[3]; + @Nullable Object tmp4 = new @Nullable String @Nullable [3] @Nullable [2]; + @Nullable Object tmp5 = new @Nullable int @Nullable [3] @Nullable [2]; + + return array; + } } @Retention(RetentionPolicy.CLASS)