diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/grammars/AstRegressionTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/grammars/AstRegressionTest.java new file mode 100644 index 000000000..475c2d15b --- /dev/null +++ b/src/test/java/com/puppycrawl/tools/checkstyle/grammars/AstRegressionTest.java @@ -0,0 +1,103 @@ +//////////////////////////////////////////////////////////////////////////////// +// checkstyle: Checks Java source code for adherence to a set of rules. +// Copyright (C) 2001-2016 the original author or authors. +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +//////////////////////////////////////////////////////////////////////////////// + +package com.puppycrawl.tools.checkstyle.grammars; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.lang.reflect.Constructor; + +import org.junit.Test; + +import com.puppycrawl.tools.checkstyle.BaseCheckTestSupport; + +public class AstRegressionTest extends BaseCheckTestSupport { + @Override + protected String getPath(String filename) throws IOException { + return super.getPath("grammars" + File.separator + filename); + } + + @Override + protected String getNonCompilablePath(String filename) throws IOException { + return super.getNonCompilablePath("grammars" + File.separator + filename); + } + + @Test + public void testClassAstTree1() throws Exception { + verifyAst(getPath("InputRegressionJavaClass1Ast.txt"), + getPath("InputRegressionJavaClass1.java")); + } + + @Test + public void testClassAstTree2() throws Exception { + verifyAst(getPath("InputRegressionJavaClass2Ast.txt"), + getPath("InputRegressionJavaClass2.java")); + } + + @Test + public void testJava8ClassAstTree1() throws Exception { + verifyAst(getNonCompilablePath("InputRegressionJava8Class1Ast.txt"), + getNonCompilablePath("InputRegressionJava8Class1.java")); + } + + @Test + public void testInterfaceAstTree1() throws Exception { + verifyAst(getPath("InputRegressionJavaInterface1Ast.txt"), + getPath("InputRegressionJavaInterface1.java")); + } + + @Test + public void testInterfaceAstTree2() throws Exception { + verifyAst(getPath("InputRegressionJavaInterface2Ast.txt"), + getPath("InputRegressionJavaInterface2.java")); + } + + @Test + public void testJava8InterfaceAstTree1() throws Exception { + verifyAst(getNonCompilablePath("InputRegressionJava8Interface1Ast.txt"), + getNonCompilablePath("InputRegressionJava8Interface1.java")); + } + + @Test + public void testEnumAstTree1() throws Exception { + verifyAst(getPath("InputRegressionJavaEnum1Ast.txt"), + getPath("InputRegressionJavaEnum1.java")); + } + + @Test + public void testEnumAstTree2() throws Exception { + verifyAst(getPath("InputRegressionJavaEnum2Ast.txt"), + getPath("InputRegressionJavaEnum2.java")); + } + + @Test + public void testAnnotationAstTree1() throws Exception { + verifyAst(getPath("InputRegressionJavaAnnotation1Ast.txt"), + getPath("InputRegressionJavaAnnotation1.java")); + } + + @Test + public void testUnusedMethods() throws Exception { + final Class clss = GeneratedJavaLexer.class; + final Constructor constructor = clss.getDeclaredConstructor(InputStream.class); + + constructor.newInstance((InputStream) null); + } +} diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJava8Class1.java b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJava8Class1.java new file mode 100644 index 000000000..384a858c8 --- /dev/null +++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJava8Class1.java @@ -0,0 +1,64 @@ +//Compilable with Java8 +package com.puppycrawl.tools.checkstyle.grammars; +; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.Map; +import java.util.List; +import java.util.function.IntBinaryOperator; +import java.util.function.Predicate; +import java.util.function.Supplier; + +public class InputRegressionJava8Class1 { + static class Inner1 { static class Inner2 { public void m() {} } } + static class Inner3 { public void m() {} } + + public void m() {} + public static void sm() {} + void m1() throws @Nullable Exception {} + public static void m2(T @Nullable [] array) {} + + { + List vlist = new ArrayList(); + } + + public void instructions() { + // used to let inputs compile + boolean b = Math.random() > 0; + + int vint; + Object o = null; + List vlist; + vlist = new ArrayList(); + Supplier s; + + // annotations + Map.@Nullable Entry e; + String str = (@Nullable String) ""; + (new Inner3()).<@Nullable String>m(); + + // method reference + IntBinaryOperator ibo = Math::max; + s = InputRegressionJava8Class1::new; + s = Inner1.Inner2::new; + + // lambda + Runnable r1 = () -> m(); + Runnable r2 = () -> { m(); } ; + Collections.sort(vlist, (l, r) -> l == r ? 0 : 1); + Predicate t = (b) ? null : object -> o.equals(object); + Double mPi = Math.PI; + } + + static final Comparator f = (Comparator) (dateTime1, dateTime2) -> { return 0; }; +} +; +@Retention(RetentionPolicy.CLASS) +@Target({ ElementType.TYPE_USE }) +@interface Nullable { +} diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJava8Class1Ast.txt b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJava8Class1Ast.txt new file mode 100644 index 000000000..6b92ddbd0 --- /dev/null +++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJava8Class1Ast.txt @@ -0,0 +1,610 @@ +PACKAGE_DEF -> package [2:0] +|--ANNOTATIONS -> ANNOTATIONS [2:39] +|--DOT -> . [2:39] +| |--DOT -> . [2:28] +| | |--DOT -> . [2:22] +| | | |--DOT -> . [2:11] +| | | | |--IDENT -> com [2:8] +| | | | `--IDENT -> puppycrawl [2:12] +| | | `--IDENT -> tools [2:23] +| | `--IDENT -> checkstyle [2:29] +| `--IDENT -> grammars [2:40] +`--SEMI -> ; [2:48] +SEMI -> ; [3:0] +IMPORT -> import [4:0] +|--DOT -> . [4:27] +| |--DOT -> . [4:16] +| | |--DOT -> . [4:11] +| | | |--IDENT -> java [4:7] +| | | `--IDENT -> lang [4:12] +| | `--IDENT -> annotation [4:17] +| `--IDENT -> ElementType [4:28] +`--SEMI -> ; [4:39] +IMPORT -> import [5:0] +|--DOT -> . [5:27] +| |--DOT -> . [5:16] +| | |--DOT -> . [5:11] +| | | |--IDENT -> java [5:7] +| | | `--IDENT -> lang [5:12] +| | `--IDENT -> annotation [5:17] +| `--IDENT -> Retention [5:28] +`--SEMI -> ; [5:37] +IMPORT -> import [6:0] +|--DOT -> . [6:27] +| |--DOT -> . [6:16] +| | |--DOT -> . [6:11] +| | | |--IDENT -> java [6:7] +| | | `--IDENT -> lang [6:12] +| | `--IDENT -> annotation [6:17] +| `--IDENT -> RetentionPolicy [6:28] +`--SEMI -> ; [6:43] +IMPORT -> import [7:0] +|--DOT -> . [7:27] +| |--DOT -> . [7:16] +| | |--DOT -> . [7:11] +| | | |--IDENT -> java [7:7] +| | | `--IDENT -> lang [7:12] +| | `--IDENT -> annotation [7:17] +| `--IDENT -> Target [7:28] +`--SEMI -> ; [7:34] +IMPORT -> import [8:0] +|--DOT -> . [8:16] +| |--DOT -> . [8:11] +| | |--IDENT -> java [8:7] +| | `--IDENT -> util [8:12] +| `--IDENT -> ArrayList [8:17] +`--SEMI -> ; [8:26] +IMPORT -> import [9:0] +|--DOT -> . [9:16] +| |--DOT -> . [9:11] +| | |--IDENT -> java [9:7] +| | `--IDENT -> util [9:12] +| `--IDENT -> Collections [9:17] +`--SEMI -> ; [9:28] +IMPORT -> import [10:0] +|--DOT -> . [10:16] +| |--DOT -> . [10:11] +| | |--IDENT -> java [10:7] +| | `--IDENT -> util [10:12] +| `--IDENT -> Comparator [10:17] +`--SEMI -> ; [10:27] +IMPORT -> import [11:0] +|--DOT -> . [11:16] +| |--DOT -> . [11:11] +| | |--IDENT -> java [11:7] +| | `--IDENT -> util [11:12] +| `--IDENT -> Map [11:17] +`--SEMI -> ; [11:20] +IMPORT -> import [12:0] +|--DOT -> . [12:16] +| |--DOT -> . [12:11] +| | |--IDENT -> java [12:7] +| | `--IDENT -> util [12:12] +| `--IDENT -> List [12:17] +`--SEMI -> ; [12:21] +IMPORT -> import [13:0] +|--DOT -> . [13:25] +| |--DOT -> . [13:16] +| | |--DOT -> . [13:11] +| | | |--IDENT -> java [13:7] +| | | `--IDENT -> util [13:12] +| | `--IDENT -> function [13:17] +| `--IDENT -> IntBinaryOperator [13:26] +`--SEMI -> ; [13:43] +IMPORT -> import [14:0] +|--DOT -> . [14:25] +| |--DOT -> . [14:16] +| | |--DOT -> . [14:11] +| | | |--IDENT -> java [14:7] +| | | `--IDENT -> util [14:12] +| | `--IDENT -> function [14:17] +| `--IDENT -> Predicate [14:26] +`--SEMI -> ; [14:35] +IMPORT -> import [15:0] +|--DOT -> . [15:25] +| |--DOT -> . [15:16] +| | |--DOT -> . [15:11] +| | | |--IDENT -> java [15:7] +| | | `--IDENT -> util [15:12] +| | `--IDENT -> function [15:17] +| `--IDENT -> Supplier [15:26] +`--SEMI -> ; [15:34] +CLASS_DEF -> CLASS_DEF [17:0] +|--MODIFIERS -> MODIFIERS [17:0] +| `--LITERAL_PUBLIC -> public [17:0] +|--LITERAL_CLASS -> class [17:7] +|--IDENT -> InputRegressionJava8Class1 [17:13] +`--OBJBLOCK -> OBJBLOCK [17:40] + |--LCURLY -> { [17:40] + |--CLASS_DEF -> CLASS_DEF [18:4] + | |--MODIFIERS -> MODIFIERS [18:4] + | | `--LITERAL_STATIC -> static [18:4] + | |--LITERAL_CLASS -> class [18:11] + | |--IDENT -> Inner1 [18:17] + | `--OBJBLOCK -> OBJBLOCK [18:24] + | |--LCURLY -> { [18:24] + | |--CLASS_DEF -> CLASS_DEF [18:26] + | | |--MODIFIERS -> MODIFIERS [18:26] + | | | `--LITERAL_STATIC -> static [18:26] + | | |--LITERAL_CLASS -> class [18:33] + | | |--IDENT -> Inner2 [18:39] + | | |--TYPE_PARAMETERS -> TYPE_PARAMETERS [18:45] + | | | |--GENERIC_START -> < [18:45] + | | | |--TYPE_PARAMETER -> TYPE_PARAMETER [18:46] + | | | | `--IDENT -> V [18:46] + | | | `--GENERIC_END -> > [18:47] + | | `--OBJBLOCK -> OBJBLOCK [18:49] + | | |--LCURLY -> { [18:49] + | | |--METHOD_DEF -> METHOD_DEF [18:51] + | | | |--MODIFIERS -> MODIFIERS [18:51] + | | | | `--LITERAL_PUBLIC -> public [18:51] + | | | |--TYPE -> TYPE [18:58] + | | | | `--LITERAL_VOID -> void [18:58] + | | | |--IDENT -> m [18:63] + | | | |--LPAREN -> ( [18:64] + | | | |--PARAMETERS -> PARAMETERS [18:65] + | | | |--RPAREN -> ) [18:65] + | | | `--SLIST -> { [18:67] + | | | `--RCURLY -> } [18:68] + | | `--RCURLY -> } [18:70] + | `--RCURLY -> } [18:72] + |--CLASS_DEF -> CLASS_DEF [19:4] + | |--MODIFIERS -> MODIFIERS [19:4] + | | `--LITERAL_STATIC -> static [19:4] + | |--LITERAL_CLASS -> class [19:11] + | |--IDENT -> Inner3 [19:17] + | |--TYPE_PARAMETERS -> TYPE_PARAMETERS [19:23] + | | |--GENERIC_START -> < [19:23] + | | |--TYPE_PARAMETER -> TYPE_PARAMETER [19:24] + | | | `--IDENT -> T [19:24] + | | `--GENERIC_END -> > [19:25] + | `--OBJBLOCK -> OBJBLOCK [19:27] + | |--LCURLY -> { [19:27] + | |--METHOD_DEF -> METHOD_DEF [19:29] + | | |--MODIFIERS -> MODIFIERS [19:29] + | | | `--LITERAL_PUBLIC -> public [19:29] + | | |--TYPE -> TYPE [19:36] + | | | `--LITERAL_VOID -> void [19:36] + | | |--IDENT -> m [19:41] + | | |--LPAREN -> ( [19:42] + | | |--PARAMETERS -> PARAMETERS [19:43] + | | |--RPAREN -> ) [19:43] + | | `--SLIST -> { [19:45] + | | `--RCURLY -> } [19:46] + | `--RCURLY -> } [19:48] + |--METHOD_DEF -> METHOD_DEF [21:4] + | |--MODIFIERS -> MODIFIERS [21:4] + | | `--LITERAL_PUBLIC -> public [21:4] + | |--TYPE -> TYPE [21:11] + | | `--LITERAL_VOID -> void [21:11] + | |--IDENT -> m [21:16] + | |--LPAREN -> ( [21:17] + | |--PARAMETERS -> PARAMETERS [21:18] + | |--RPAREN -> ) [21:18] + | `--SLIST -> { [21:20] + | `--RCURLY -> } [21:21] + |--METHOD_DEF -> METHOD_DEF [22:4] + | |--MODIFIERS -> MODIFIERS [22:4] + | | |--LITERAL_PUBLIC -> public [22:4] + | | `--LITERAL_STATIC -> static [22:11] + | |--TYPE -> TYPE [22:18] + | | `--LITERAL_VOID -> void [22:18] + | |--IDENT -> sm [22:23] + | |--LPAREN -> ( [22:25] + | |--PARAMETERS -> PARAMETERS [22:26] + | |--RPAREN -> ) [22:26] + | `--SLIST -> { [22:28] + | `--RCURLY -> } [22:29] + |--METHOD_DEF -> METHOD_DEF [23:4] + | |--MODIFIERS -> MODIFIERS [23:4] + | |--TYPE -> TYPE [23:4] + | | `--LITERAL_VOID -> void [23:4] + | |--IDENT -> m1 [23:9] + | |--LPAREN -> ( [23:11] + | |--PARAMETERS -> PARAMETERS [23:12] + | |--RPAREN -> ) [23:12] + | |--LITERAL_THROWS -> throws [23:14] + | | |--ANNOTATIONS -> ANNOTATIONS [23:21] + | | | `--ANNOTATION -> ANNOTATION [23:21] + | | | |--AT -> @ [23:21] + | | | `--IDENT -> Nullable [23:22] + | | `--IDENT -> Exception [23:31] + | `--SLIST -> { [23:41] + | `--RCURLY -> } [23:42] + |--METHOD_DEF -> METHOD_DEF [24:4] + | |--MODIFIERS -> MODIFIERS [24:4] + | | |--LITERAL_PUBLIC -> public [24:4] + | | `--LITERAL_STATIC -> static [24:11] + | |--TYPE_PARAMETERS -> TYPE_PARAMETERS [24:18] + | | |--GENERIC_START -> < [24:18] + | | |--TYPE_PARAMETER -> TYPE_PARAMETER [24:19] + | | | `--IDENT -> T [24:19] + | | `--GENERIC_END -> > [24:20] + | |--TYPE -> TYPE [24:22] + | | `--LITERAL_VOID -> void [24:22] + | |--IDENT -> m2 [24:27] + | |--LPAREN -> ( [24:29] + | |--PARAMETERS -> PARAMETERS [24:42] + | | `--PARAMETER_DEF -> PARAMETER_DEF [24:42] + | | |--MODIFIERS -> MODIFIERS [24:42] + | | |--TYPE -> TYPE [24:42] + | | | `--ARRAY_DECLARATOR -> [ [24:42] + | | | |--IDENT -> T [24:30] + | | | |--ANNOTATIONS -> ANNOTATIONS [24:32] + | | | | `--ANNOTATION -> ANNOTATION [24:32] + | | | | |--AT -> @ [24:32] + | | | | `--IDENT -> Nullable [24:33] + | | | `--RBRACK -> ] [24:43] + | | `--IDENT -> array [24:45] + | |--RPAREN -> ) [24:50] + | `--SLIST -> { [24:52] + | `--RCURLY -> } [24:53] + |--INSTANCE_INIT -> INSTANCE_INIT [26:4] + | `--SLIST -> { [26:4] + | |--VARIABLE_DEF -> VARIABLE_DEF [27:8] + | | |--MODIFIERS -> MODIFIERS [27:8] + | | |--TYPE -> TYPE [27:8] + | | | |--IDENT -> List [27:8] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [27:12] + | | | |--GENERIC_START -> < [27:12] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [27:13] + | | | | `--IDENT -> String [27:13] + | | | `--GENERIC_END -> > [27:19] + | | |--IDENT -> vlist [27:21] + | | `--ASSIGN -> = [27:27] + | | `--EXPR -> EXPR [27:29] + | | `--LITERAL_NEW -> new [27:29] + | | |--IDENT -> ArrayList [27:33] + | | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [27:42] + | | | |--GENERIC_START -> < [27:42] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [27:43] + | | | | `--IDENT -> String [27:43] + | | | `--GENERIC_END -> > [27:49] + | | |--LPAREN -> ( [27:50] + | | |--ELIST -> ELIST [27:51] + | | `--RPAREN -> ) [27:51] + | |--SEMI -> ; [27:52] + | `--RCURLY -> } [28:4] + |--METHOD_DEF -> METHOD_DEF [30:4] + | |--MODIFIERS -> MODIFIERS [30:4] + | | `--LITERAL_PUBLIC -> public [30:4] + | |--TYPE -> TYPE [30:11] + | | `--LITERAL_VOID -> void [30:11] + | |--IDENT -> instructions [30:16] + | |--LPAREN -> ( [30:28] + | |--PARAMETERS -> PARAMETERS [30:29] + | |--RPAREN -> ) [30:29] + | `--SLIST -> { [30:31] + | |--VARIABLE_DEF -> VARIABLE_DEF [32:8] + | | |--MODIFIERS -> MODIFIERS [32:8] + | | |--TYPE -> TYPE [32:8] + | | | `--LITERAL_BOOLEAN -> boolean [32:8] + | | |--IDENT -> b [32:16] + | | `--ASSIGN -> = [32:18] + | | `--EXPR -> EXPR [32:34] + | | `--GT -> > [32:34] + | | |--METHOD_CALL -> ( [32:31] + | | | |--DOT -> . [32:24] + | | | | |--IDENT -> Math [32:20] + | | | | `--IDENT -> random [32:25] + | | | |--ELIST -> ELIST [32:32] + | | | `--RPAREN -> ) [32:32] + | | `--NUM_INT -> 0 [32:36] + | |--SEMI -> ; [32:37] + | |--VARIABLE_DEF -> VARIABLE_DEF [34:8] + | | |--MODIFIERS -> MODIFIERS [34:8] + | | |--TYPE -> TYPE [34:8] + | | | `--LITERAL_INT -> int [34:8] + | | `--IDENT -> vint [34:12] + | |--SEMI -> ; [34:16] + | |--VARIABLE_DEF -> VARIABLE_DEF [35:8] + | | |--MODIFIERS -> MODIFIERS [35:8] + | | |--TYPE -> TYPE [35:8] + | | | `--IDENT -> Object [35:8] + | | |--IDENT -> o [35:15] + | | `--ASSIGN -> = [35:17] + | | `--EXPR -> EXPR [35:19] + | | `--LITERAL_NULL -> null [35:19] + | |--SEMI -> ; [35:23] + | |--VARIABLE_DEF -> VARIABLE_DEF [36:8] + | | |--MODIFIERS -> MODIFIERS [36:8] + | | |--TYPE -> TYPE [36:8] + | | | |--IDENT -> List [36:8] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [36:12] + | | | |--GENERIC_START -> < [36:12] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [36:13] + | | | | `--IDENT -> String [36:13] + | | | `--GENERIC_END -> > [36:19] + | | `--IDENT -> vlist [36:21] + | |--SEMI -> ; [36:26] + | |--EXPR -> EXPR [37:14] + | | `--ASSIGN -> = [37:14] + | | |--IDENT -> vlist [37:8] + | | `--LITERAL_NEW -> new [37:16] + | | |--IDENT -> ArrayList [37:20] + | | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [37:29] + | | | |--GENERIC_START -> < [37:29] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [37:30] + | | | | `--IDENT -> String [37:30] + | | | `--GENERIC_END -> > [37:36] + | | |--LPAREN -> ( [37:37] + | | |--ELIST -> ELIST [37:38] + | | `--RPAREN -> ) [37:38] + | |--SEMI -> ; [37:39] + | |--VARIABLE_DEF -> VARIABLE_DEF [38:8] + | | |--MODIFIERS -> MODIFIERS [38:8] + | | |--TYPE -> TYPE [38:8] + | | | |--IDENT -> Supplier [38:8] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [38:16] + | | | |--GENERIC_START -> < [38:16] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [38:17] + | | | | `--WILDCARD_TYPE -> ? [38:17] + | | | `--GENERIC_END -> > [38:18] + | | `--IDENT -> s [38:20] + | |--SEMI -> ; [38:21] + | |--VARIABLE_DEF -> VARIABLE_DEF [41:11] + | | |--MODIFIERS -> MODIFIERS [41:11] + | | |--TYPE -> TYPE [41:11] + | | | `--DOT -> . [41:11] + | | | |--IDENT -> Map [41:8] + | | | |--ANNOTATIONS -> ANNOTATIONS [41:12] + | | | | `--ANNOTATION -> ANNOTATION [41:12] + | | | | |--AT -> @ [41:12] + | | | | `--IDENT -> Nullable [41:13] + | | | `--IDENT -> Entry [41:22] + | | `--IDENT -> e [41:28] + | |--SEMI -> ; [41:29] + | |--VARIABLE_DEF -> VARIABLE_DEF [42:8] + | | |--MODIFIERS -> MODIFIERS [42:8] + | | |--TYPE -> TYPE [42:8] + | | | `--IDENT -> String [42:8] + | | |--IDENT -> str [42:15] + | | `--ASSIGN -> = [42:19] + | | `--EXPR -> EXPR [42:21] + | | `--TYPECAST -> ( [42:21] + | | |--TYPE -> TYPE [42:22] + | | | |--ANNOTATIONS -> ANNOTATIONS [42:22] + | | | | `--ANNOTATION -> ANNOTATION [42:22] + | | | | |--AT -> @ [42:22] + | | | | `--IDENT -> Nullable [42:23] + | | | `--IDENT -> String [42:32] + | | |--RPAREN -> ) [42:38] + | | `--STRING_LITERAL -> "" [42:40] + | |--SEMI -> ; [42:42] + | |--EXPR -> EXPR [43:42] + | | `--METHOD_CALL -> ( [43:42] + | | |--DOT -> . [43:22] + | | | |--LPAREN -> ( [43:8] + | | | |--LITERAL_NEW -> new [43:9] + | | | | |--IDENT -> Inner3 [43:13] + | | | | |--LPAREN -> ( [43:19] + | | | | |--ELIST -> ELIST [43:20] + | | | | `--RPAREN -> ) [43:20] + | | | |--RPAREN -> ) [43:21] + | | | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [43:23] + | | | | |--GENERIC_START -> < [43:23] + | | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [43:24] + | | | | | |--ANNOTATIONS -> ANNOTATIONS [43:24] + | | | | | | `--ANNOTATION -> ANNOTATION [43:24] + | | | | | | |--AT -> @ [43:24] + | | | | | | `--IDENT -> Nullable [43:25] + | | | | | `--IDENT -> String [43:34] + | | | | `--GENERIC_END -> > [43:40] + | | | `--IDENT -> m [43:41] + | | |--ELIST -> ELIST [43:43] + | | `--RPAREN -> ) [43:43] + | |--SEMI -> ; [43:44] + | |--VARIABLE_DEF -> VARIABLE_DEF [46:8] + | | |--MODIFIERS -> MODIFIERS [46:8] + | | |--TYPE -> TYPE [46:8] + | | | `--IDENT -> IntBinaryOperator [46:8] + | | |--IDENT -> ibo [46:26] + | | `--ASSIGN -> = [46:30] + | | `--EXPR -> EXPR [46:36] + | | `--METHOD_REF -> :: [46:36] + | | |--IDENT -> Math [46:32] + | | `--IDENT -> max [46:38] + | |--SEMI -> ; [46:41] + | |--EXPR -> EXPR [47:10] + | | `--ASSIGN -> = [47:10] + | | |--IDENT -> s [47:8] + | | `--METHOD_REF -> :: [47:38] + | | |--IDENT -> InputRegressionJava8Class1 [47:12] + | | `--LITERAL_NEW -> new [47:40] + | |--SEMI -> ; [47:43] + | |--EXPR -> EXPR [48:10] + | | `--ASSIGN -> = [48:10] + | | |--IDENT -> s [48:8] + | | `--METHOD_REF -> :: [48:33] + | | |--DOT -> . [48:18] + | | | |--IDENT -> Inner1 [48:12] + | | | |--IDENT -> Inner2 [48:19] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [48:25] + | | | |--GENERIC_START -> < [48:25] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [48:26] + | | | | `--IDENT -> String [48:26] + | | | `--GENERIC_END -> > [48:32] + | | `--LITERAL_NEW -> new [48:35] + | |--SEMI -> ; [48:38] + | |--VARIABLE_DEF -> VARIABLE_DEF [51:8] + | | |--MODIFIERS -> MODIFIERS [51:8] + | | |--TYPE -> TYPE [51:8] + | | | `--IDENT -> Runnable [51:8] + | | |--IDENT -> r1 [51:17] + | | `--ASSIGN -> = [51:20] + | | `--LAMBDA -> -> [51:25] + | | |--LPAREN -> ( [51:22] + | | |--PARAMETERS -> PARAMETERS [51:23] + | | |--RPAREN -> ) [51:23] + | | `--EXPR -> EXPR [51:29] + | | `--METHOD_CALL -> ( [51:29] + | | |--IDENT -> m [51:28] + | | |--ELIST -> ELIST [51:30] + | | `--RPAREN -> ) [51:30] + | |--SEMI -> ; [51:31] + | |--VARIABLE_DEF -> VARIABLE_DEF [52:8] + | | |--MODIFIERS -> MODIFIERS [52:8] + | | |--TYPE -> TYPE [52:8] + | | | `--IDENT -> Runnable [52:8] + | | |--IDENT -> r2 [52:17] + | | `--ASSIGN -> = [52:20] + | | `--LAMBDA -> -> [52:25] + | | |--LPAREN -> ( [52:22] + | | |--PARAMETERS -> PARAMETERS [52:23] + | | |--RPAREN -> ) [52:23] + | | `--SLIST -> { [52:28] + | | |--EXPR -> EXPR [52:31] + | | | `--METHOD_CALL -> ( [52:31] + | | | |--IDENT -> m [52:30] + | | | |--ELIST -> ELIST [52:32] + | | | `--RPAREN -> ) [52:32] + | | |--SEMI -> ; [52:33] + | | `--RCURLY -> } [52:35] + | |--SEMI -> ; [52:37] + | |--EXPR -> EXPR [53:24] + | | `--METHOD_CALL -> ( [53:24] + | | |--DOT -> . [53:19] + | | | |--IDENT -> Collections [53:8] + | | | `--IDENT -> sort [53:20] + | | |--ELIST -> ELIST [53:25] + | | | |--EXPR -> EXPR [53:25] + | | | | `--IDENT -> vlist [53:25] + | | | |--COMMA -> , [53:30] + | | | `--LAMBDA -> -> [53:40] + | | | |--LPAREN -> ( [53:32] + | | | |--PARAMETERS -> PARAMETERS [53:33] + | | | | |--PARAMETER_DEF -> PARAMETER_DEF [53:33] + | | | | | |--MODIFIERS -> MODIFIERS [53:33] + | | | | | |--TYPE -> TYPE [53:33] + | | | | | `--IDENT -> l [53:33] + | | | | |--COMMA -> , [53:34] + | | | | `--PARAMETER_DEF -> PARAMETER_DEF [53:37] + | | | | |--MODIFIERS -> MODIFIERS [53:37] + | | | | |--TYPE -> TYPE [53:37] + | | | | `--IDENT -> r [53:37] + | | | |--RPAREN -> ) [53:38] + | | | `--EXPR -> EXPR [53:50] + | | | `--QUESTION -> ? [53:50] + | | | |--EQUAL -> == [53:45] + | | | | |--IDENT -> l [53:43] + | | | | `--IDENT -> r [53:48] + | | | |--NUM_INT -> 0 [53:52] + | | | |--COLON -> : [53:54] + | | | `--NUM_INT -> 1 [53:56] + | | `--RPAREN -> ) [53:57] + | |--SEMI -> ; [53:58] + | |--VARIABLE_DEF -> VARIABLE_DEF [54:8] + | | |--MODIFIERS -> MODIFIERS [54:8] + | | |--TYPE -> TYPE [54:8] + | | | |--IDENT -> Predicate [54:8] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [54:17] + | | | |--GENERIC_START -> < [54:17] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [54:18] + | | | | `--WILDCARD_TYPE -> ? [54:18] + | | | `--GENERIC_END -> > [54:19] + | | |--IDENT -> t [54:21] + | | `--ASSIGN -> = [54:23] + | | `--EXPR -> EXPR [54:29] + | | `--QUESTION -> ? [54:29] + | | |--LPAREN -> ( [54:25] + | | |--IDENT -> b [54:26] + | | |--RPAREN -> ) [54:27] + | | |--LITERAL_NULL -> null [54:31] + | | |--COLON -> : [54:36] + | | `--LAMBDA -> -> [54:45] + | | |--IDENT -> object [54:38] + | | `--EXPR -> EXPR [54:56] + | | `--METHOD_CALL -> ( [54:56] + | | |--DOT -> . [54:49] + | | | |--IDENT -> o [54:48] + | | | `--IDENT -> equals [54:50] + | | |--ELIST -> ELIST [54:57] + | | | `--EXPR -> EXPR [54:57] + | | | `--IDENT -> object [54:57] + | | `--RPAREN -> ) [54:63] + | |--SEMI -> ; [54:64] + | |--VARIABLE_DEF -> VARIABLE_DEF [55:8] + | | |--MODIFIERS -> MODIFIERS [55:8] + | | |--TYPE -> TYPE [55:8] + | | | `--IDENT -> Double [55:8] + | | |--IDENT -> mPi [55:15] + | | `--ASSIGN -> = [55:19] + | | `--EXPR -> EXPR [55:25] + | | `--DOT -> . [55:25] + | | |--IDENT -> Math [55:21] + | | `--IDENT -> PI [55:26] + | |--SEMI -> ; [55:28] + | `--RCURLY -> } [56:4] + |--VARIABLE_DEF -> VARIABLE_DEF [58:4] + | |--MODIFIERS -> MODIFIERS [58:4] + | | |--LITERAL_STATIC -> static [58:4] + | | `--FINAL -> final [58:11] + | |--TYPE -> TYPE [58:17] + | | |--IDENT -> Comparator [58:17] + | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [58:27] + | | |--GENERIC_START -> < [58:27] + | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [58:28] + | | | `--WILDCARD_TYPE -> ? [58:28] + | | `--GENERIC_END -> > [58:29] + | |--IDENT -> f [58:31] + | |--ASSIGN -> = [58:33] + | | `--EXPR -> EXPR [58:35] + | | `--TYPECAST -> ( [58:35] + | | |--TYPE -> TYPE [58:36] + | | | |--IDENT -> Comparator [58:36] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [58:46] + | | | |--GENERIC_START -> < [58:46] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [58:47] + | | | | `--WILDCARD_TYPE -> ? [58:47] + | | | `--GENERIC_END -> > [58:48] + | | |--RPAREN -> ) [58:49] + | | `--LAMBDA -> -> [58:74] + | | |--LPAREN -> ( [58:51] + | | |--PARAMETERS -> PARAMETERS [58:52] + | | | |--PARAMETER_DEF -> PARAMETER_DEF [58:52] + | | | | |--MODIFIERS -> MODIFIERS [58:52] + | | | | |--TYPE -> TYPE [58:52] + | | | | `--IDENT -> dateTime1 [58:52] + | | | |--COMMA -> , [58:61] + | | | `--PARAMETER_DEF -> PARAMETER_DEF [58:63] + | | | |--MODIFIERS -> MODIFIERS [58:63] + | | | |--TYPE -> TYPE [58:63] + | | | `--IDENT -> dateTime2 [58:63] + | | |--RPAREN -> ) [58:72] + | | `--SLIST -> { [58:77] + | | |--LITERAL_RETURN -> return [58:79] + | | | |--EXPR -> EXPR [58:86] + | | | | `--NUM_INT -> 0 [58:86] + | | | `--SEMI -> ; [58:87] + | | `--RCURLY -> } [58:89] + | `--SEMI -> ; [58:90] + `--RCURLY -> } [59:0] +SEMI -> ; [60:0] +ANNOTATION_DEF -> ANNOTATION_DEF [61:0] +|--MODIFIERS -> MODIFIERS [61:0] +| |--ANNOTATION -> ANNOTATION [61:0] +| | |--AT -> @ [61:0] +| | |--IDENT -> Retention [61:1] +| | |--LPAREN -> ( [61:10] +| | |--EXPR -> EXPR [61:26] +| | | `--DOT -> . [61:26] +| | | |--IDENT -> RetentionPolicy [61:11] +| | | `--IDENT -> CLASS [61:27] +| | `--RPAREN -> ) [61:32] +| `--ANNOTATION -> ANNOTATION [62:0] +| |--AT -> @ [62:0] +| |--IDENT -> Target [62:1] +| |--LPAREN -> ( [62:7] +| |--ANNOTATION_ARRAY_INIT -> { [62:8] +| | |--EXPR -> EXPR [62:21] +| | | `--DOT -> . [62:21] +| | | |--IDENT -> ElementType [62:10] +| | | `--IDENT -> TYPE_USE [62:22] +| | `--RCURLY -> } [62:31] +| `--RPAREN -> ) [62:32] +|--AT -> @ [63:0] +|--LITERAL_INTERFACE -> interface [63:1] +|--IDENT -> Nullable [63:11] +`--OBJBLOCK -> OBJBLOCK [63:20] + |--LCURLY -> { [63:20] + `--RCURLY -> } [64:0] diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJava8Interface1.java b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJava8Interface1.java new file mode 100644 index 000000000..fe9d27d63 --- /dev/null +++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJava8Interface1.java @@ -0,0 +1,6 @@ +//Compilable with Java8 +package com.puppycrawl.tools.checkstyle.grammars; + +public interface InputRegressionJava8Interface1 { + default void m() {} +} \ No newline at end of file diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJava8Interface1Ast.txt b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJava8Interface1Ast.txt new file mode 100644 index 000000000..b407e0bf0 --- /dev/null +++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJava8Interface1Ast.txt @@ -0,0 +1,31 @@ +PACKAGE_DEF -> package [2:0] +|--ANNOTATIONS -> ANNOTATIONS [2:39] +|--DOT -> . [2:39] +| |--DOT -> . [2:28] +| | |--DOT -> . [2:22] +| | | |--DOT -> . [2:11] +| | | | |--IDENT -> com [2:8] +| | | | `--IDENT -> puppycrawl [2:12] +| | | `--IDENT -> tools [2:23] +| | `--IDENT -> checkstyle [2:29] +| `--IDENT -> grammars [2:40] +`--SEMI -> ; [2:48] +INTERFACE_DEF -> INTERFACE_DEF [4:0] +|--MODIFIERS -> MODIFIERS [4:0] +| `--LITERAL_PUBLIC -> public [4:0] +|--LITERAL_INTERFACE -> interface [4:7] +|--IDENT -> InputRegressionJava8Interface1 [4:17] +`--OBJBLOCK -> OBJBLOCK [4:48] + |--LCURLY -> { [4:48] + |--METHOD_DEF -> METHOD_DEF [5:4] + | |--MODIFIERS -> MODIFIERS [5:4] + | | `--LITERAL_DEFAULT -> default [5:4] + | |--TYPE -> TYPE [5:12] + | | `--LITERAL_VOID -> void [5:12] + | |--IDENT -> m [5:17] + | |--LPAREN -> ( [5:18] + | |--PARAMETERS -> PARAMETERS [5:19] + | |--RPAREN -> ) [5:19] + | `--SLIST -> { [5:21] + | `--RCURLY -> } [5:22] + `--RCURLY -> } [6:0] diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionEmptyAst.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionEmptyAst.txt new file mode 100644 index 000000000..e69de29bb diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaAnnotation1.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaAnnotation1.java new file mode 100644 index 000000000..3e285ba2c --- /dev/null +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaAnnotation1.java @@ -0,0 +1,15 @@ +package com.puppycrawl.tools.checkstyle.grammars; + +@interface InputRegressionJavaAnnotation1 { + int f1 = 0; + + String[] m1(); + String[] m2() default {}; + + class SomeClass { + private SomeClass() {} + } +} +@interface ComplexAnnotation { + InputRegressionJavaAnnotation1[] value(); +} \ No newline at end of file diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaAnnotation1Ast.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaAnnotation1Ast.txt new file mode 100644 index 000000000..03216f748 --- /dev/null +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaAnnotation1Ast.txt @@ -0,0 +1,86 @@ +PACKAGE_DEF -> package [1:0] +|--ANNOTATIONS -> ANNOTATIONS [1:39] +|--DOT -> . [1:39] +| |--DOT -> . [1:28] +| | |--DOT -> . [1:22] +| | | |--DOT -> . [1:11] +| | | | |--IDENT -> com [1:8] +| | | | `--IDENT -> puppycrawl [1:12] +| | | `--IDENT -> tools [1:23] +| | `--IDENT -> checkstyle [1:29] +| `--IDENT -> grammars [1:40] +`--SEMI -> ; [1:48] +ANNOTATION_DEF -> ANNOTATION_DEF [3:0] +|--MODIFIERS -> MODIFIERS [3:0] +|--AT -> @ [3:0] +|--LITERAL_INTERFACE -> interface [3:1] +|--IDENT -> InputRegressionJavaAnnotation1 [3:11] +`--OBJBLOCK -> OBJBLOCK [3:42] + |--LCURLY -> { [3:42] + |--VARIABLE_DEF -> VARIABLE_DEF [4:4] + | |--MODIFIERS -> MODIFIERS [4:4] + | |--TYPE -> TYPE [4:4] + | | `--LITERAL_INT -> int [4:4] + | |--IDENT -> f1 [4:8] + | |--ASSIGN -> = [4:11] + | | `--EXPR -> EXPR [4:13] + | | `--NUM_INT -> 0 [4:13] + | `--SEMI -> ; [4:14] + |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [6:10] + | |--MODIFIERS -> MODIFIERS [6:10] + | |--TYPE -> TYPE [6:10] + | | `--ARRAY_DECLARATOR -> [ [6:10] + | | |--IDENT -> String [6:4] + | | `--RBRACK -> ] [6:11] + | |--IDENT -> m1 [6:13] + | |--LPAREN -> ( [6:15] + | |--RPAREN -> ) [6:16] + | `--SEMI -> ; [6:17] + |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [7:10] + | |--MODIFIERS -> MODIFIERS [7:10] + | |--TYPE -> TYPE [7:10] + | | `--ARRAY_DECLARATOR -> [ [7:10] + | | |--IDENT -> String [7:4] + | | `--RBRACK -> ] [7:11] + | |--IDENT -> m2 [7:13] + | |--LPAREN -> ( [7:15] + | |--RPAREN -> ) [7:16] + | |--LITERAL_DEFAULT -> default [7:18] + | | `--ANNOTATION_ARRAY_INIT -> { [7:26] + | | `--RCURLY -> } [7:27] + | `--SEMI -> ; [7:28] + |--CLASS_DEF -> CLASS_DEF [9:4] + | |--MODIFIERS -> MODIFIERS [9:4] + | |--LITERAL_CLASS -> class [9:4] + | |--IDENT -> SomeClass [9:10] + | `--OBJBLOCK -> OBJBLOCK [9:20] + | |--LCURLY -> { [9:20] + | |--CTOR_DEF -> CTOR_DEF [10:8] + | | |--MODIFIERS -> MODIFIERS [10:8] + | | | `--LITERAL_PRIVATE -> private [10:8] + | | |--IDENT -> SomeClass [10:16] + | | |--LPAREN -> ( [10:25] + | | |--PARAMETERS -> PARAMETERS [10:26] + | | |--RPAREN -> ) [10:26] + | | `--SLIST -> { [10:28] + | | `--RCURLY -> } [10:29] + | `--RCURLY -> } [11:4] + `--RCURLY -> } [12:0] +ANNOTATION_DEF -> ANNOTATION_DEF [13:0] +|--MODIFIERS -> MODIFIERS [13:0] +|--AT -> @ [13:0] +|--LITERAL_INTERFACE -> interface [13:1] +|--IDENT -> ComplexAnnotation [13:11] +`--OBJBLOCK -> OBJBLOCK [13:29] + |--LCURLY -> { [13:29] + |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [14:34] + | |--MODIFIERS -> MODIFIERS [14:34] + | |--TYPE -> TYPE [14:34] + | | `--ARRAY_DECLARATOR -> [ [14:34] + | | |--IDENT -> InputRegressionJavaAnnotation1 [14:4] + | | `--RBRACK -> ] [14:35] + | |--IDENT -> value [14:37] + | |--LPAREN -> ( [14:42] + | |--RPAREN -> ) [14:43] + | `--SEMI -> ; [14:44] + `--RCURLY -> } [15:0] diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaClass1.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaClass1.java new file mode 100644 index 000000000..04684c646 --- /dev/null +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaClass1.java @@ -0,0 +1,348 @@ +package com.puppycrawl.tools.checkstyle.grammars; + +import static java.lang.String.valueOf; + +import java.io.BufferedReader; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import javax.xml.*; + +public class InputRegressionJavaClass1 { + //comments + + // single line + /* multi on single line */ + /* multi + line */ + /** javadoc */ + // tab -> <- + + // fields + // modifiers + public int f1; + private int f2; + protected int f3; + int f4; + static int f5; + final int f6; + volatile int f7; + transient int f8; + Object f9; + + // constructors + static {} + public InputRegressionJavaClass1() {f6 = 0;} + public InputRegressionJavaClass1(int i) {this.f6 = i;} + public InputRegressionJavaClass1(float f) {this((int)f);} + InputRegressionJavaClass1(double a) throws Exception {f6 = 0;} + + // methods + // modifiers + native void m1(); + void m2() {} + synchronized void m4() {} + strictfp void m5() {} + + // returns + public int[] m6() {return null;} + public int m7() [] {return null;} + + // parameters + public void m10(String p1) {} + public void m11(final String p1) {} + public void m12(String[] p1) {} + public void m13(String[][] p1) {} + public void m14(String p1, String p2) {} + public void m15(String... p1) {} + public void m16(String[]... p1) {} + public void m17(int p1, String[]... p2) {} + + // throws + public void m18() throws Exception {} + public void m19() throws IOException, Exception {} + + // types + public T_$ m20() {return null;} + public <$_T> $_T m21() {return null;} + public > void m22() {} + public void m23() {}; + public void m24() {} + + // annotations + @SuppressWarnings({}) + public void m50() {} + @SuppressWarnings({"1"}) + public void m51() {} + @SuppressWarnings({"1","2"}) + public void m52() {} + @SuppressWarnings(value={"1"}) + public void m53() {} + @SuppressWarnings(value={"1",}) + public void m54() {} + @SuppressWarnings(value={"1","2"}) + public void m55() {} + @InputRegressionJavaAnnotation1(m1="1", m2="2") + public void m56() {} + @ComplexAnnotation({ + @InputRegressionJavaAnnotation1(m1 = "1"), @InputRegressionJavaAnnotation1(m1 = "1") + }) + public void m57() {} + public void m58(@Deprecated String s) {} + public void m59(final @Deprecated List l) {} + + // extra + {} + ; + + // instructions + public void instructions() throws Exception { + // used to let inputs compile + boolean b = Math.random() > 0; + + // variables and types + byte vbyte; + boolean vboolean; + char vchar; + short vshort; + int vint; + long vlong; + float vfloat; + double vdouble; + int[] varray; + int varray2[]; + boolean test1 = true; + + // types + String vstring; + List vlist; + Map vmap; + int[] test2 = {}; + List test3; + Class test4; + List test5; + List> test6; + List>> test7; + List test8; + List test9; + + // literals + vboolean = true; + vboolean = false; + vchar = ' '; + vchar = '"'; + vchar = '\0'; + vchar = '\''; + vchar = '\n'; + vchar = '\r'; + vchar = '\t'; + vchar = '\b'; + vchar = '\f'; + vchar = '\"'; + vchar = '\''; + vchar = '\\'; + vchar = '\00'; + vchar = '\013'; + vchar = '\4'; + vchar = '\40'; + vchar = '\u0000'; + vchar = '\u1234'; + vchar = '\u005C\u005C'; + vchar = '\u005c\u005c'; + vchar = '\uu005C\uuuuu005C'; + vchar = '\u005cn'; + vchar = '\u005cr'; + vchar = '\u005ct'; + vchar = '\u005cb'; + vchar = '\u005cf'; + vchar = '\u005c"'; + vchar = '\u005c''; + vchar = '\u005c\'; + vint = 0; + vint = -1; + vint = +1; + vint = 100_000; + vint = 0x00; + vint = 0x12345678; + vint = 0X9; + vint = 0x1234_5678; + vint = 0b101; + vint = 0B101; + vint = 0b1; + vint = 0b1_0; + vint = 012345670; + vint = 01234_5670; + vlong = 0L; + vlong = 1L; + vlong = 0b1L; + vlong = 1234567890l; + vlong = 1234567890L; + vlong = 0x0l; + vlong = 0xABCDEFl; + vlong = 0XABCDEFL; + vfloat = 0f; + vfloat = 0F; + vfloat = 1.1f; + vfloat = 1.10_1F; + vfloat = 0_1.1_1F; + vfloat = 1e0f; + vfloat = 1e0F; + vfloat = 1.0e0F; + vfloat = 0x2__3_34.4___AFP00_00f; + vdouble = 10.; + vdouble = .1; + vdouble = .1__1_1; + vdouble = 0.0; + vdouble = 1000.0; + vdouble = .1d; + vdouble = 1.D; + vdouble = 0_1.0d; + vdouble = 0_1.0D; + vdouble = 4e23; + vdouble = 4E23; + vdouble = 4E2_3; + vdouble = 0x0.0000000000001p-1022; + vdouble = 0x0.0000000000001P-1022; + vdouble = 0X0.0000000000001p+1022; + vdouble = 0X0.0000000000001P+1022; + vdouble = 0x.0P0; + vdouble = 0X0p+2; + vdouble = 0X0p+20F; + vdouble = 0X0p+2D; + vdouble = 0X0p+2d; + vdouble = 0x1.P-1; + vdouble = 0x.1___AFp1; + vstring = null; + vstring = ""; + vstring = "\\"; + + // assignments and operators + vint = 1 + 1; + vint = 1 - 1; + vint = 1 * 1; + vint = 1 / 1; + vint = 1 % 1; + vint = 1 & 1; + vint = 1 | 1; + vint = 1 ^ 1; + vint = ~1; + vboolean = 1 != 0; + vboolean = 1 == 0; + vboolean = 1 > 0; + vboolean = 1 >= 0; + vboolean = 1 < 0; + vboolean = 1 <= 0; + vboolean = true && true; + vboolean = true || true; + vboolean = true ? true : false; + vboolean = !true; + vboolean = f9 instanceof Object; + vint = 1 << 1; + vint = 1 >> 1; + vint = 1 >>> 1; + vint += 1; + vint -= 1; + vint *= 1; + vint /= 1; + vint %= 1; + vint &= 1; + vint |= 1; + vint ^= 1; + vint <<= 1; + vint >>= 1; + vint >>>= 1; + vint++; + vint--; + ++vint; + --vint; + String[] arrayinit = {}; + String[] arrayinit2 = {""}; + String[] arrayinit3 = {"", "",}; + + // new + varray = new int[]{}; + varray = new int[]{0}; + varray = new int[]{0, 1}; + varray = new int[5]; + vlist = new ArrayList(); + vmap = new HashMap(); + Object anonymous = new InputRegressionJavaClass1() {}; + + // stataments + ; + this.f1 = 0; + + // labels + test_label1: + + // blocks + {} + if (true) ; + if (true) {} + if (true) {} else ; + if (true) {} else {} + if (b) { for (;;) ; } + if (b) { for (;;) {} } + for (int i = 0; i < 1; i++) {} + for (int i = 0, j = 0; i < 1; i++, j += 2) {} + for (int value: new int[]{}) ; + for (String s : new String[]{}) ; + for (final String s : new String[]{}) ; + if (b) { while (true) ; } + if (b) { while (true) {} } + do {} while (false); + synchronized (f9) {} + + switch (0) { + case 1: + case 0: break; + default: break; + } + + try { + if (b) { throw new IOException(); } + if (b) { throw new ArrayIndexOutOfBoundsException(); } + throw new Exception(); + } catch (IOException | ArrayIndexOutOfBoundsException e) { + } catch (Exception e) { + } finally {} + try (BufferedReader br = new BufferedReader(new FileReader(""))) {} + try (BufferedReader br1 = new BufferedReader(new FileReader("")); + BufferedReader br2 = new BufferedReader(new FileReader(""));) {} + + // access + test4 = InputRegressionJavaClass1.class; + test4 = List[].class; + test4 = boolean[].class; + varray[0] = 0; + for (String[] s : new String[][]{{}}) ; + for (Map.Entry e : vmap.entrySet()) { } + + // others + for (;;) {break;} + test_label2: + for (;;) {break test_label2;} + if (b) { for (;;) {continue;} } + if (b) { test_label3: for (;;) {continue test_label3;} } + if (false) return; + if (false) throw new Exception(); + assert(false); + assert true : "false"; + f9 = (Object) f9; + f9.equals(((vstring = ""))); + for (int i = 0; ((i) < (6+6)); i++) ; + if ((b & b)) {} + + // ast error handling + vint = vboolean ? (vint = 1) : (vint = 0); + varray[vint] = Integer.parseInt("0"); + } + + public @interface innerAnnotation {} +} diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaClass1Ast.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaClass1Ast.txt new file mode 100644 index 000000000..35c9f97b2 --- /dev/null +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaClass1Ast.txt @@ -0,0 +1,2623 @@ +PACKAGE_DEF -> package [1:0] +|--ANNOTATIONS -> ANNOTATIONS [1:39] +|--DOT -> . [1:39] +| |--DOT -> . [1:28] +| | |--DOT -> . [1:22] +| | | |--DOT -> . [1:11] +| | | | |--IDENT -> com [1:8] +| | | | `--IDENT -> puppycrawl [1:12] +| | | `--IDENT -> tools [1:23] +| | `--IDENT -> checkstyle [1:29] +| `--IDENT -> grammars [1:40] +`--SEMI -> ; [1:48] +STATIC_IMPORT -> import [3:0] +|--LITERAL_STATIC -> static [3:7] +|--DOT -> . [3:30] +| |--DOT -> . [3:23] +| | |--DOT -> . [3:18] +| | | |--IDENT -> java [3:14] +| | | `--IDENT -> lang [3:19] +| | `--IDENT -> String [3:24] +| `--IDENT -> valueOf [3:31] +`--SEMI -> ; [3:38] +IMPORT -> import [5:0] +|--DOT -> . [5:14] +| |--DOT -> . [5:11] +| | |--IDENT -> java [5:7] +| | `--IDENT -> io [5:12] +| `--IDENT -> BufferedReader [5:15] +`--SEMI -> ; [5:29] +IMPORT -> import [6:0] +|--DOT -> . [6:14] +| |--DOT -> . [6:11] +| | |--IDENT -> java [6:7] +| | `--IDENT -> io [6:12] +| `--IDENT -> FileNotFoundException [6:15] +`--SEMI -> ; [6:36] +IMPORT -> import [7:0] +|--DOT -> . [7:14] +| |--DOT -> . [7:11] +| | |--IDENT -> java [7:7] +| | `--IDENT -> io [7:12] +| `--IDENT -> FileReader [7:15] +`--SEMI -> ; [7:25] +IMPORT -> import [8:0] +|--DOT -> . [8:14] +| |--DOT -> . [8:11] +| | |--IDENT -> java [8:7] +| | `--IDENT -> io [8:12] +| `--IDENT -> IOException [8:15] +`--SEMI -> ; [8:26] +IMPORT -> import [9:0] +|--DOT -> . [9:16] +| |--DOT -> . [9:11] +| | |--IDENT -> java [9:7] +| | `--IDENT -> util [9:12] +| `--IDENT -> ArrayList [9:17] +`--SEMI -> ; [9:26] +IMPORT -> import [10:0] +|--DOT -> . [10:16] +| |--DOT -> . [10:11] +| | |--IDENT -> java [10:7] +| | `--IDENT -> util [10:12] +| `--IDENT -> HashMap [10:17] +`--SEMI -> ; [10:24] +IMPORT -> import [11:0] +|--DOT -> . [11:16] +| |--DOT -> . [11:11] +| | |--IDENT -> java [11:7] +| | `--IDENT -> util [11:12] +| `--IDENT -> Iterator [11:17] +`--SEMI -> ; [11:25] +IMPORT -> import [12:0] +|--DOT -> . [12:16] +| |--DOT -> . [12:11] +| | |--IDENT -> java [12:7] +| | `--IDENT -> util [12:12] +| `--IDENT -> List [12:17] +`--SEMI -> ; [12:21] +IMPORT -> import [13:0] +|--DOT -> . [13:16] +| |--DOT -> . [13:11] +| | |--IDENT -> java [13:7] +| | `--IDENT -> util [13:12] +| `--IDENT -> Map [13:17] +`--SEMI -> ; [13:20] +IMPORT -> import [15:0] +|--DOT -> . [15:16] +| |--DOT -> . [15:12] +| | |--IDENT -> javax [15:7] +| | `--IDENT -> xml [15:13] +| `--STAR -> * [15:17] +`--SEMI -> ; [15:18] +CLASS_DEF -> CLASS_DEF [17:0] +|--MODIFIERS -> MODIFIERS [17:0] +| `--LITERAL_PUBLIC -> public [17:0] +|--LITERAL_CLASS -> class [17:7] +|--IDENT -> InputRegressionJavaClass1 [17:13] +`--OBJBLOCK -> OBJBLOCK [17:39] + |--LCURLY -> { [17:39] + |--VARIABLE_DEF -> VARIABLE_DEF [29:4] + | |--MODIFIERS -> MODIFIERS [29:4] + | | `--LITERAL_PUBLIC -> public [29:4] + | |--TYPE -> TYPE [29:11] + | | `--LITERAL_INT -> int [29:11] + | |--IDENT -> f1 [29:15] + | `--SEMI -> ; [29:17] + |--VARIABLE_DEF -> VARIABLE_DEF [30:4] + | |--MODIFIERS -> MODIFIERS [30:4] + | | `--LITERAL_PRIVATE -> private [30:4] + | |--TYPE -> TYPE [30:12] + | | `--LITERAL_INT -> int [30:12] + | |--IDENT -> f2 [30:16] + | `--SEMI -> ; [30:18] + |--VARIABLE_DEF -> VARIABLE_DEF [31:4] + | |--MODIFIERS -> MODIFIERS [31:4] + | | `--LITERAL_PROTECTED -> protected [31:4] + | |--TYPE -> TYPE [31:14] + | | `--LITERAL_INT -> int [31:14] + | |--IDENT -> f3 [31:18] + | `--SEMI -> ; [31:20] + |--VARIABLE_DEF -> VARIABLE_DEF [32:4] + | |--MODIFIERS -> MODIFIERS [32:4] + | |--TYPE -> TYPE [32:4] + | | `--LITERAL_INT -> int [32:4] + | |--IDENT -> f4 [32:8] + | `--SEMI -> ; [32:10] + |--VARIABLE_DEF -> VARIABLE_DEF [33:4] + | |--MODIFIERS -> MODIFIERS [33:4] + | | `--LITERAL_STATIC -> static [33:4] + | |--TYPE -> TYPE [33:11] + | | `--LITERAL_INT -> int [33:11] + | |--IDENT -> f5 [33:15] + | `--SEMI -> ; [33:17] + |--VARIABLE_DEF -> VARIABLE_DEF [34:4] + | |--MODIFIERS -> MODIFIERS [34:4] + | | `--FINAL -> final [34:4] + | |--TYPE -> TYPE [34:10] + | | `--LITERAL_INT -> int [34:10] + | |--IDENT -> f6 [34:14] + | `--SEMI -> ; [34:16] + |--VARIABLE_DEF -> VARIABLE_DEF [35:4] + | |--MODIFIERS -> MODIFIERS [35:4] + | | `--LITERAL_VOLATILE -> volatile [35:4] + | |--TYPE -> TYPE [35:13] + | | `--LITERAL_INT -> int [35:13] + | |--IDENT -> f7 [35:17] + | `--SEMI -> ; [35:19] + |--VARIABLE_DEF -> VARIABLE_DEF [36:4] + | |--MODIFIERS -> MODIFIERS [36:4] + | | `--LITERAL_TRANSIENT -> transient [36:4] + | |--TYPE -> TYPE [36:14] + | | `--LITERAL_INT -> int [36:14] + | |--IDENT -> f8 [36:18] + | `--SEMI -> ; [36:20] + |--VARIABLE_DEF -> VARIABLE_DEF [37:4] + | |--MODIFIERS -> MODIFIERS [37:4] + | |--TYPE -> TYPE [37:4] + | | `--IDENT -> Object [37:4] + | |--IDENT -> f9 [37:11] + | `--SEMI -> ; [37:13] + |--STATIC_INIT -> STATIC_INIT [40:4] + | `--SLIST -> { [40:11] + | `--RCURLY -> } [40:12] + |--CTOR_DEF -> CTOR_DEF [41:4] + | |--MODIFIERS -> MODIFIERS [41:4] + | | `--LITERAL_PUBLIC -> public [41:4] + | |--IDENT -> InputRegressionJavaClass1 [41:11] + | |--LPAREN -> ( [41:36] + | |--PARAMETERS -> PARAMETERS [41:37] + | |--RPAREN -> ) [41:37] + | `--SLIST -> { [41:39] + | |--EXPR -> EXPR [41:43] + | | `--ASSIGN -> = [41:43] + | | |--IDENT -> f6 [41:40] + | | `--NUM_INT -> 0 [41:45] + | |--SEMI -> ; [41:46] + | `--RCURLY -> } [41:47] + |--CTOR_DEF -> CTOR_DEF [42:4] + | |--MODIFIERS -> MODIFIERS [42:4] + | | `--LITERAL_PUBLIC -> public [42:4] + | |--IDENT -> InputRegressionJavaClass1 [42:11] + | |--LPAREN -> ( [42:36] + | |--PARAMETERS -> PARAMETERS [42:37] + | | `--PARAMETER_DEF -> PARAMETER_DEF [42:37] + | | |--MODIFIERS -> MODIFIERS [42:37] + | | |--TYPE -> TYPE [42:37] + | | | `--LITERAL_INT -> int [42:37] + | | `--IDENT -> i [42:41] + | |--RPAREN -> ) [42:42] + | `--SLIST -> { [42:44] + | |--EXPR -> EXPR [42:53] + | | `--ASSIGN -> = [42:53] + | | |--DOT -> . [42:49] + | | | |--LITERAL_THIS -> this [42:45] + | | | `--IDENT -> f6 [42:50] + | | `--IDENT -> i [42:55] + | |--SEMI -> ; [42:56] + | `--RCURLY -> } [42:57] + |--CTOR_DEF -> CTOR_DEF [43:4] + | |--MODIFIERS -> MODIFIERS [43:4] + | | `--LITERAL_PUBLIC -> public [43:4] + | |--IDENT -> InputRegressionJavaClass1 [43:11] + | |--LPAREN -> ( [43:36] + | |--PARAMETERS -> PARAMETERS [43:37] + | | `--PARAMETER_DEF -> PARAMETER_DEF [43:37] + | | |--MODIFIERS -> MODIFIERS [43:37] + | | |--TYPE -> TYPE [43:37] + | | | `--LITERAL_FLOAT -> float [43:37] + | | `--IDENT -> f [43:43] + | |--RPAREN -> ) [43:44] + | `--SLIST -> { [43:46] + | |--CTOR_CALL -> this [43:47] + | | |--LPAREN -> ( [43:51] + | | |--ELIST -> ELIST [43:52] + | | | `--EXPR -> EXPR [43:52] + | | | `--TYPECAST -> ( [43:52] + | | | |--TYPE -> TYPE [43:53] + | | | | `--LITERAL_INT -> int [43:53] + | | | |--RPAREN -> ) [43:56] + | | | `--IDENT -> f [43:57] + | | |--RPAREN -> ) [43:58] + | | `--SEMI -> ; [43:59] + | `--RCURLY -> } [43:60] + |--CTOR_DEF -> CTOR_DEF [44:4] + | |--MODIFIERS -> MODIFIERS [44:4] + | |--IDENT -> InputRegressionJavaClass1 [44:4] + | |--LPAREN -> ( [44:29] + | |--PARAMETERS -> PARAMETERS [44:30] + | | `--PARAMETER_DEF -> PARAMETER_DEF [44:30] + | | |--MODIFIERS -> MODIFIERS [44:30] + | | |--TYPE -> TYPE [44:30] + | | | `--LITERAL_DOUBLE -> double [44:30] + | | `--IDENT -> a [44:37] + | |--RPAREN -> ) [44:38] + | |--LITERAL_THROWS -> throws [44:40] + | | `--IDENT -> Exception [44:47] + | `--SLIST -> { [44:57] + | |--EXPR -> EXPR [44:61] + | | `--ASSIGN -> = [44:61] + | | |--IDENT -> f6 [44:58] + | | `--NUM_INT -> 0 [44:63] + | |--SEMI -> ; [44:64] + | `--RCURLY -> } [44:65] + |--METHOD_DEF -> METHOD_DEF [48:4] + | |--MODIFIERS -> MODIFIERS [48:4] + | | `--LITERAL_NATIVE -> native [48:4] + | |--TYPE -> TYPE [48:11] + | | `--LITERAL_VOID -> void [48:11] + | |--IDENT -> m1 [48:16] + | |--LPAREN -> ( [48:18] + | |--PARAMETERS -> PARAMETERS [48:19] + | |--RPAREN -> ) [48:19] + | `--SEMI -> ; [48:20] + |--METHOD_DEF -> METHOD_DEF [49:4] + | |--MODIFIERS -> MODIFIERS [49:4] + | |--TYPE -> TYPE [49:4] + | | `--LITERAL_VOID -> void [49:4] + | |--IDENT -> m2 [49:9] + | |--LPAREN -> ( [49:11] + | |--PARAMETERS -> PARAMETERS [49:12] + | |--RPAREN -> ) [49:12] + | `--SLIST -> { [49:14] + | `--RCURLY -> } [49:15] + |--METHOD_DEF -> METHOD_DEF [50:4] + | |--MODIFIERS -> MODIFIERS [50:4] + | | `--LITERAL_SYNCHRONIZED -> synchronized [50:4] + | |--TYPE -> TYPE [50:17] + | | `--LITERAL_VOID -> void [50:17] + | |--IDENT -> m4 [50:22] + | |--LPAREN -> ( [50:24] + | |--PARAMETERS -> PARAMETERS [50:25] + | |--RPAREN -> ) [50:25] + | `--SLIST -> { [50:27] + | `--RCURLY -> } [50:28] + |--METHOD_DEF -> METHOD_DEF [51:4] + | |--MODIFIERS -> MODIFIERS [51:4] + | | `--STRICTFP -> strictfp [51:4] + | |--TYPE -> TYPE [51:13] + | | `--LITERAL_VOID -> void [51:13] + | |--IDENT -> m5 [51:18] + | |--LPAREN -> ( [51:20] + | |--PARAMETERS -> PARAMETERS [51:21] + | |--RPAREN -> ) [51:21] + | `--SLIST -> { [51:23] + | `--RCURLY -> } [51:24] + |--METHOD_DEF -> METHOD_DEF [54:4] + | |--MODIFIERS -> MODIFIERS [54:4] + | | `--LITERAL_PUBLIC -> public [54:4] + | |--TYPE -> TYPE [54:14] + | | `--ARRAY_DECLARATOR -> [ [54:14] + | | |--LITERAL_INT -> int [54:11] + | | `--RBRACK -> ] [54:15] + | |--IDENT -> m6 [54:17] + | |--LPAREN -> ( [54:19] + | |--PARAMETERS -> PARAMETERS [54:20] + | |--RPAREN -> ) [54:20] + | `--SLIST -> { [54:22] + | |--LITERAL_RETURN -> return [54:23] + | | |--EXPR -> EXPR [54:30] + | | | `--LITERAL_NULL -> null [54:30] + | | `--SEMI -> ; [54:34] + | `--RCURLY -> } [54:35] + |--METHOD_DEF -> METHOD_DEF [55:4] + | |--MODIFIERS -> MODIFIERS [55:4] + | | `--LITERAL_PUBLIC -> public [55:4] + | |--TYPE -> TYPE [55:20] + | | `--ARRAY_DECLARATOR -> [ [55:20] + | | |--LITERAL_INT -> int [55:11] + | | `--RBRACK -> ] [55:21] + | |--IDENT -> m7 [55:15] + | |--LPAREN -> ( [55:17] + | |--PARAMETERS -> PARAMETERS [55:18] + | |--RPAREN -> ) [55:18] + | `--SLIST -> { [55:23] + | |--LITERAL_RETURN -> return [55:24] + | | |--EXPR -> EXPR [55:31] + | | | `--LITERAL_NULL -> null [55:31] + | | `--SEMI -> ; [55:35] + | `--RCURLY -> } [55:36] + |--METHOD_DEF -> METHOD_DEF [58:4] + | |--MODIFIERS -> MODIFIERS [58:4] + | | `--LITERAL_PUBLIC -> public [58:4] + | |--TYPE -> TYPE [58:11] + | | `--LITERAL_VOID -> void [58:11] + | |--IDENT -> m10 [58:16] + | |--LPAREN -> ( [58:19] + | |--PARAMETERS -> PARAMETERS [58:20] + | | `--PARAMETER_DEF -> PARAMETER_DEF [58:20] + | | |--MODIFIERS -> MODIFIERS [58:20] + | | |--TYPE -> TYPE [58:20] + | | | `--IDENT -> String [58:20] + | | `--IDENT -> p1 [58:27] + | |--RPAREN -> ) [58:29] + | `--SLIST -> { [58:31] + | `--RCURLY -> } [58:32] + |--METHOD_DEF -> METHOD_DEF [59:4] + | |--MODIFIERS -> MODIFIERS [59:4] + | | `--LITERAL_PUBLIC -> public [59:4] + | |--TYPE -> TYPE [59:11] + | | `--LITERAL_VOID -> void [59:11] + | |--IDENT -> m11 [59:16] + | |--LPAREN -> ( [59:19] + | |--PARAMETERS -> PARAMETERS [59:20] + | | `--PARAMETER_DEF -> PARAMETER_DEF [59:20] + | | |--MODIFIERS -> MODIFIERS [59:20] + | | | `--FINAL -> final [59:20] + | | |--TYPE -> TYPE [59:26] + | | | `--IDENT -> String [59:26] + | | `--IDENT -> p1 [59:33] + | |--RPAREN -> ) [59:35] + | `--SLIST -> { [59:37] + | `--RCURLY -> } [59:38] + |--METHOD_DEF -> METHOD_DEF [60:4] + | |--MODIFIERS -> MODIFIERS [60:4] + | | `--LITERAL_PUBLIC -> public [60:4] + | |--TYPE -> TYPE [60:11] + | | `--LITERAL_VOID -> void [60:11] + | |--IDENT -> m12 [60:16] + | |--LPAREN -> ( [60:19] + | |--PARAMETERS -> PARAMETERS [60:26] + | | `--PARAMETER_DEF -> PARAMETER_DEF [60:26] + | | |--MODIFIERS -> MODIFIERS [60:26] + | | |--TYPE -> TYPE [60:26] + | | | `--ARRAY_DECLARATOR -> [ [60:26] + | | | |--IDENT -> String [60:20] + | | | `--RBRACK -> ] [60:27] + | | `--IDENT -> p1 [60:29] + | |--RPAREN -> ) [60:31] + | `--SLIST -> { [60:33] + | `--RCURLY -> } [60:34] + |--METHOD_DEF -> METHOD_DEF [61:4] + | |--MODIFIERS -> MODIFIERS [61:4] + | | `--LITERAL_PUBLIC -> public [61:4] + | |--TYPE -> TYPE [61:11] + | | `--LITERAL_VOID -> void [61:11] + | |--IDENT -> m13 [61:16] + | |--LPAREN -> ( [61:19] + | |--PARAMETERS -> PARAMETERS [61:28] + | | `--PARAMETER_DEF -> PARAMETER_DEF [61:28] + | | |--MODIFIERS -> MODIFIERS [61:28] + | | |--TYPE -> TYPE [61:28] + | | | `--ARRAY_DECLARATOR -> [ [61:28] + | | | |--ARRAY_DECLARATOR -> [ [61:26] + | | | | |--IDENT -> String [61:20] + | | | | `--RBRACK -> ] [61:27] + | | | `--RBRACK -> ] [61:29] + | | `--IDENT -> p1 [61:31] + | |--RPAREN -> ) [61:33] + | `--SLIST -> { [61:35] + | `--RCURLY -> } [61:36] + |--METHOD_DEF -> METHOD_DEF [62:4] + | |--MODIFIERS -> MODIFIERS [62:4] + | | `--LITERAL_PUBLIC -> public [62:4] + | |--TYPE -> TYPE [62:11] + | | `--LITERAL_VOID -> void [62:11] + | |--IDENT -> m14 [62:16] + | |--LPAREN -> ( [62:19] + | |--PARAMETERS -> PARAMETERS [62:20] + | | |--PARAMETER_DEF -> PARAMETER_DEF [62:20] + | | | |--MODIFIERS -> MODIFIERS [62:20] + | | | |--TYPE -> TYPE [62:20] + | | | | `--IDENT -> String [62:20] + | | | `--IDENT -> p1 [62:27] + | | |--COMMA -> , [62:29] + | | `--PARAMETER_DEF -> PARAMETER_DEF [62:31] + | | |--MODIFIERS -> MODIFIERS [62:31] + | | |--TYPE -> TYPE [62:31] + | | | `--IDENT -> String [62:31] + | | `--IDENT -> p2 [62:38] + | |--RPAREN -> ) [62:40] + | `--SLIST -> { [62:42] + | `--RCURLY -> } [62:43] + |--METHOD_DEF -> METHOD_DEF [63:4] + | |--MODIFIERS -> MODIFIERS [63:4] + | | `--LITERAL_PUBLIC -> public [63:4] + | |--TYPE -> TYPE [63:11] + | | `--LITERAL_VOID -> void [63:11] + | |--IDENT -> m15 [63:16] + | |--LPAREN -> ( [63:19] + | |--PARAMETERS -> PARAMETERS [63:20] + | | `--PARAMETER_DEF -> PARAMETER_DEF [63:20] + | | |--MODIFIERS -> MODIFIERS [63:20] + | | |--TYPE -> TYPE [63:20] + | | | `--IDENT -> String [63:20] + | | |--ELLIPSIS -> ... [63:26] + | | `--IDENT -> p1 [63:30] + | |--RPAREN -> ) [63:32] + | `--SLIST -> { [63:34] + | `--RCURLY -> } [63:35] + |--METHOD_DEF -> METHOD_DEF [64:4] + | |--MODIFIERS -> MODIFIERS [64:4] + | | `--LITERAL_PUBLIC -> public [64:4] + | |--TYPE -> TYPE [64:11] + | | `--LITERAL_VOID -> void [64:11] + | |--IDENT -> m16 [64:16] + | |--LPAREN -> ( [64:19] + | |--PARAMETERS -> PARAMETERS [64:26] + | | `--PARAMETER_DEF -> PARAMETER_DEF [64:26] + | | |--MODIFIERS -> MODIFIERS [64:26] + | | |--TYPE -> TYPE [64:26] + | | | `--ARRAY_DECLARATOR -> [ [64:26] + | | | |--IDENT -> String [64:20] + | | | `--RBRACK -> ] [64:27] + | | |--ELLIPSIS -> ... [64:28] + | | `--IDENT -> p1 [64:32] + | |--RPAREN -> ) [64:34] + | `--SLIST -> { [64:36] + | `--RCURLY -> } [64:37] + |--METHOD_DEF -> METHOD_DEF [65:4] + | |--MODIFIERS -> MODIFIERS [65:4] + | | `--LITERAL_PUBLIC -> public [65:4] + | |--TYPE -> TYPE [65:11] + | | `--LITERAL_VOID -> void [65:11] + | |--IDENT -> m17 [65:16] + | |--LPAREN -> ( [65:19] + | |--PARAMETERS -> PARAMETERS [65:20] + | | |--PARAMETER_DEF -> PARAMETER_DEF [65:20] + | | | |--MODIFIERS -> MODIFIERS [65:20] + | | | |--TYPE -> TYPE [65:20] + | | | | `--LITERAL_INT -> int [65:20] + | | | `--IDENT -> p1 [65:24] + | | |--COMMA -> , [65:26] + | | `--PARAMETER_DEF -> PARAMETER_DEF [65:34] + | | |--MODIFIERS -> MODIFIERS [65:34] + | | |--TYPE -> TYPE [65:34] + | | | `--ARRAY_DECLARATOR -> [ [65:34] + | | | |--IDENT -> String [65:28] + | | | `--RBRACK -> ] [65:35] + | | |--ELLIPSIS -> ... [65:36] + | | `--IDENT -> p2 [65:40] + | |--RPAREN -> ) [65:42] + | `--SLIST -> { [65:44] + | `--RCURLY -> } [65:45] + |--METHOD_DEF -> METHOD_DEF [68:4] + | |--MODIFIERS -> MODIFIERS [68:4] + | | `--LITERAL_PUBLIC -> public [68:4] + | |--TYPE -> TYPE [68:11] + | | `--LITERAL_VOID -> void [68:11] + | |--IDENT -> m18 [68:16] + | |--LPAREN -> ( [68:19] + | |--PARAMETERS -> PARAMETERS [68:20] + | |--RPAREN -> ) [68:20] + | |--LITERAL_THROWS -> throws [68:22] + | | `--IDENT -> Exception [68:29] + | `--SLIST -> { [68:39] + | `--RCURLY -> } [68:40] + |--METHOD_DEF -> METHOD_DEF [69:4] + | |--MODIFIERS -> MODIFIERS [69:4] + | | `--LITERAL_PUBLIC -> public [69:4] + | |--TYPE -> TYPE [69:11] + | | `--LITERAL_VOID -> void [69:11] + | |--IDENT -> m19 [69:16] + | |--LPAREN -> ( [69:19] + | |--PARAMETERS -> PARAMETERS [69:20] + | |--RPAREN -> ) [69:20] + | |--LITERAL_THROWS -> throws [69:22] + | | |--IDENT -> IOException [69:29] + | | |--COMMA -> , [69:40] + | | `--IDENT -> Exception [69:42] + | `--SLIST -> { [69:52] + | `--RCURLY -> } [69:53] + |--METHOD_DEF -> METHOD_DEF [72:4] + | |--MODIFIERS -> MODIFIERS [72:4] + | | `--LITERAL_PUBLIC -> public [72:4] + | |--TYPE_PARAMETERS -> TYPE_PARAMETERS [72:11] + | | |--GENERIC_START -> < [72:11] + | | |--TYPE_PARAMETER -> TYPE_PARAMETER [72:12] + | | | `--IDENT -> T_$ [72:12] + | | `--GENERIC_END -> > [72:15] + | |--TYPE -> TYPE [72:17] + | | `--IDENT -> T_$ [72:17] + | |--IDENT -> m20 [72:21] + | |--LPAREN -> ( [72:24] + | |--PARAMETERS -> PARAMETERS [72:25] + | |--RPAREN -> ) [72:25] + | `--SLIST -> { [72:27] + | |--LITERAL_RETURN -> return [72:28] + | | |--EXPR -> EXPR [72:35] + | | | `--LITERAL_NULL -> null [72:35] + | | `--SEMI -> ; [72:39] + | `--RCURLY -> } [72:40] + |--METHOD_DEF -> METHOD_DEF [73:4] + | |--MODIFIERS -> MODIFIERS [73:4] + | | `--LITERAL_PUBLIC -> public [73:4] + | |--TYPE_PARAMETERS -> TYPE_PARAMETERS [73:11] + | | |--GENERIC_START -> < [73:11] + | | |--TYPE_PARAMETER -> TYPE_PARAMETER [73:12] + | | | `--IDENT -> $_T [73:12] + | | `--GENERIC_END -> > [73:15] + | |--TYPE -> TYPE [73:17] + | | `--IDENT -> $_T [73:17] + | |--IDENT -> m21 [73:21] + | |--LPAREN -> ( [73:24] + | |--PARAMETERS -> PARAMETERS [73:25] + | |--RPAREN -> ) [73:25] + | `--SLIST -> { [73:27] + | |--LITERAL_RETURN -> return [73:28] + | | |--EXPR -> EXPR [73:35] + | | | `--LITERAL_NULL -> null [73:35] + | | `--SEMI -> ; [73:39] + | `--RCURLY -> } [73:40] + |--METHOD_DEF -> METHOD_DEF [74:4] + | |--MODIFIERS -> MODIFIERS [74:4] + | | `--LITERAL_PUBLIC -> public [74:4] + | |--TYPE_PARAMETERS -> TYPE_PARAMETERS [74:11] + | | |--GENERIC_START -> < [74:11] + | | |--TYPE_PARAMETER -> TYPE_PARAMETER [74:12] + | | | |--IDENT -> T [74:12] + | | | `--TYPE_UPPER_BOUNDS -> extends [74:14] + | | | |--IDENT -> Enum [74:22] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [74:26] + | | | |--GENERIC_START -> < [74:26] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [74:27] + | | | | `--TYPE -> TYPE [74:27] + | | | | `--IDENT -> T [74:27] + | | | `--GENERIC_END -> > [74:28] + | | `--GENERIC_END -> > [74:29] + | |--TYPE -> TYPE [74:31] + | | `--LITERAL_VOID -> void [74:31] + | |--IDENT -> m22 [74:36] + | |--LPAREN -> ( [74:39] + | |--PARAMETERS -> PARAMETERS [74:40] + | |--RPAREN -> ) [74:40] + | `--SLIST -> { [74:42] + | `--RCURLY -> } [74:43] + |--METHOD_DEF -> METHOD_DEF [75:4] + | |--MODIFIERS -> MODIFIERS [75:4] + | | `--LITERAL_PUBLIC -> public [75:4] + | |--TYPE_PARAMETERS -> TYPE_PARAMETERS [75:11] + | | |--GENERIC_START -> < [75:11] + | | |--TYPE_PARAMETER -> TYPE_PARAMETER [75:12] + | | | `--IDENT -> T [75:12] + | | `--GENERIC_END -> > [75:13] + | |--TYPE -> TYPE [75:15] + | | `--LITERAL_VOID -> void [75:15] + | |--IDENT -> m23 [75:20] + | |--LPAREN -> ( [75:23] + | |--PARAMETERS -> PARAMETERS [75:24] + | |--RPAREN -> ) [75:24] + | `--SLIST -> { [75:26] + | `--RCURLY -> } [75:27] + |--SEMI -> ; [75:28] + |--METHOD_DEF -> METHOD_DEF [76:4] + | |--MODIFIERS -> MODIFIERS [76:4] + | | `--LITERAL_PUBLIC -> public [76:4] + | |--TYPE_PARAMETERS -> TYPE_PARAMETERS [76:11] + | | |--GENERIC_START -> < [76:11] + | | |--TYPE_PARAMETER -> TYPE_PARAMETER [76:12] + | | | |--IDENT -> T [76:12] + | | | `--TYPE_UPPER_BOUNDS -> extends [76:14] + | | | |--IDENT -> RuntimeException [76:22] + | | | |--TYPE_EXTENSION_AND -> & [76:39] + | | | `--DOT -> . [76:48] + | | | |--DOT -> . [76:45] + | | | | |--IDENT -> java [76:41] + | | | | `--IDENT -> io [76:46] + | | | `--IDENT -> Serializable [76:49] + | | `--GENERIC_END -> > [76:61] + | |--TYPE -> TYPE [76:63] + | | `--LITERAL_VOID -> void [76:63] + | |--IDENT -> m24 [76:68] + | |--LPAREN -> ( [76:71] + | |--PARAMETERS -> PARAMETERS [76:72] + | |--RPAREN -> ) [76:72] + | `--SLIST -> { [76:74] + | `--RCURLY -> } [76:75] + |--METHOD_DEF -> METHOD_DEF [79:4] + | |--MODIFIERS -> MODIFIERS [79:4] + | | |--ANNOTATION -> ANNOTATION [79:4] + | | | |--AT -> @ [79:4] + | | | |--IDENT -> SuppressWarnings [79:5] + | | | |--LPAREN -> ( [79:21] + | | | |--ANNOTATION_ARRAY_INIT -> { [79:22] + | | | | `--RCURLY -> } [79:23] + | | | `--RPAREN -> ) [79:24] + | | `--LITERAL_PUBLIC -> public [80:4] + | |--TYPE -> TYPE [80:11] + | | `--LITERAL_VOID -> void [80:11] + | |--IDENT -> m50 [80:16] + | |--LPAREN -> ( [80:19] + | |--PARAMETERS -> PARAMETERS [80:20] + | |--RPAREN -> ) [80:20] + | `--SLIST -> { [80:22] + | `--RCURLY -> } [80:23] + |--METHOD_DEF -> METHOD_DEF [81:4] + | |--MODIFIERS -> MODIFIERS [81:4] + | | |--ANNOTATION -> ANNOTATION [81:4] + | | | |--AT -> @ [81:4] + | | | |--IDENT -> SuppressWarnings [81:5] + | | | |--LPAREN -> ( [81:21] + | | | |--ANNOTATION_ARRAY_INIT -> { [81:22] + | | | | |--EXPR -> EXPR [81:23] + | | | | | `--STRING_LITERAL -> "1" [81:23] + | | | | `--RCURLY -> } [81:26] + | | | `--RPAREN -> ) [81:27] + | | `--LITERAL_PUBLIC -> public [82:4] + | |--TYPE -> TYPE [82:11] + | | `--LITERAL_VOID -> void [82:11] + | |--IDENT -> m51 [82:16] + | |--LPAREN -> ( [82:19] + | |--PARAMETERS -> PARAMETERS [82:20] + | |--RPAREN -> ) [82:20] + | `--SLIST -> { [82:22] + | `--RCURLY -> } [82:23] + |--METHOD_DEF -> METHOD_DEF [83:4] + | |--MODIFIERS -> MODIFIERS [83:4] + | | |--ANNOTATION -> ANNOTATION [83:4] + | | | |--AT -> @ [83:4] + | | | |--IDENT -> SuppressWarnings [83:5] + | | | |--LPAREN -> ( [83:21] + | | | |--ANNOTATION_ARRAY_INIT -> { [83:22] + | | | | |--EXPR -> EXPR [83:23] + | | | | | `--STRING_LITERAL -> "1" [83:23] + | | | | |--COMMA -> , [83:26] + | | | | |--EXPR -> EXPR [83:27] + | | | | | `--STRING_LITERAL -> "2" [83:27] + | | | | `--RCURLY -> } [83:30] + | | | `--RPAREN -> ) [83:31] + | | `--LITERAL_PUBLIC -> public [84:4] + | |--TYPE -> TYPE [84:11] + | | `--LITERAL_VOID -> void [84:11] + | |--IDENT -> m52 [84:16] + | |--LPAREN -> ( [84:19] + | |--PARAMETERS -> PARAMETERS [84:20] + | |--RPAREN -> ) [84:20] + | `--SLIST -> { [84:22] + | `--RCURLY -> } [84:23] + |--METHOD_DEF -> METHOD_DEF [85:4] + | |--MODIFIERS -> MODIFIERS [85:4] + | | |--ANNOTATION -> ANNOTATION [85:4] + | | | |--AT -> @ [85:4] + | | | |--IDENT -> SuppressWarnings [85:5] + | | | |--LPAREN -> ( [85:21] + | | | |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [85:22] + | | | | |--IDENT -> value [85:22] + | | | | |--ASSIGN -> = [85:27] + | | | | `--ANNOTATION_ARRAY_INIT -> { [85:28] + | | | | |--EXPR -> EXPR [85:29] + | | | | | `--STRING_LITERAL -> "1" [85:29] + | | | | `--RCURLY -> } [85:32] + | | | `--RPAREN -> ) [85:33] + | | `--LITERAL_PUBLIC -> public [86:4] + | |--TYPE -> TYPE [86:11] + | | `--LITERAL_VOID -> void [86:11] + | |--IDENT -> m53 [86:16] + | |--LPAREN -> ( [86:19] + | |--PARAMETERS -> PARAMETERS [86:20] + | |--RPAREN -> ) [86:20] + | `--SLIST -> { [86:22] + | `--RCURLY -> } [86:23] + |--METHOD_DEF -> METHOD_DEF [87:4] + | |--MODIFIERS -> MODIFIERS [87:4] + | | |--ANNOTATION -> ANNOTATION [87:4] + | | | |--AT -> @ [87:4] + | | | |--IDENT -> SuppressWarnings [87:5] + | | | |--LPAREN -> ( [87:21] + | | | |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [87:22] + | | | | |--IDENT -> value [87:22] + | | | | |--ASSIGN -> = [87:27] + | | | | `--ANNOTATION_ARRAY_INIT -> { [87:28] + | | | | |--EXPR -> EXPR [87:29] + | | | | | `--STRING_LITERAL -> "1" [87:29] + | | | | |--COMMA -> , [87:32] + | | | | `--RCURLY -> } [87:33] + | | | `--RPAREN -> ) [87:34] + | | `--LITERAL_PUBLIC -> public [88:4] + | |--TYPE -> TYPE [88:11] + | | `--LITERAL_VOID -> void [88:11] + | |--IDENT -> m54 [88:16] + | |--LPAREN -> ( [88:19] + | |--PARAMETERS -> PARAMETERS [88:20] + | |--RPAREN -> ) [88:20] + | `--SLIST -> { [88:22] + | `--RCURLY -> } [88:23] + |--METHOD_DEF -> METHOD_DEF [89:4] + | |--MODIFIERS -> MODIFIERS [89:4] + | | |--ANNOTATION -> ANNOTATION [89:4] + | | | |--AT -> @ [89:4] + | | | |--IDENT -> SuppressWarnings [89:5] + | | | |--LPAREN -> ( [89:21] + | | | |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [89:22] + | | | | |--IDENT -> value [89:22] + | | | | |--ASSIGN -> = [89:27] + | | | | `--ANNOTATION_ARRAY_INIT -> { [89:28] + | | | | |--EXPR -> EXPR [89:29] + | | | | | `--STRING_LITERAL -> "1" [89:29] + | | | | |--COMMA -> , [89:32] + | | | | |--EXPR -> EXPR [89:33] + | | | | | `--STRING_LITERAL -> "2" [89:33] + | | | | `--RCURLY -> } [89:36] + | | | `--RPAREN -> ) [89:37] + | | `--LITERAL_PUBLIC -> public [90:4] + | |--TYPE -> TYPE [90:11] + | | `--LITERAL_VOID -> void [90:11] + | |--IDENT -> m55 [90:16] + | |--LPAREN -> ( [90:19] + | |--PARAMETERS -> PARAMETERS [90:20] + | |--RPAREN -> ) [90:20] + | `--SLIST -> { [90:22] + | `--RCURLY -> } [90:23] + |--METHOD_DEF -> METHOD_DEF [91:4] + | |--MODIFIERS -> MODIFIERS [91:4] + | | |--ANNOTATION -> ANNOTATION [91:4] + | | | |--AT -> @ [91:4] + | | | |--IDENT -> InputRegressionJavaAnnotation1 [91:5] + | | | |--LPAREN -> ( [91:35] + | | | |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [91:36] + | | | | |--IDENT -> m1 [91:36] + | | | | |--ASSIGN -> = [91:38] + | | | | `--EXPR -> EXPR [91:39] + | | | | `--STRING_LITERAL -> "1" [91:39] + | | | |--COMMA -> , [91:42] + | | | |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [91:44] + | | | | |--IDENT -> m2 [91:44] + | | | | |--ASSIGN -> = [91:46] + | | | | `--EXPR -> EXPR [91:47] + | | | | `--STRING_LITERAL -> "2" [91:47] + | | | `--RPAREN -> ) [91:50] + | | `--LITERAL_PUBLIC -> public [92:4] + | |--TYPE -> TYPE [92:11] + | | `--LITERAL_VOID -> void [92:11] + | |--IDENT -> m56 [92:16] + | |--LPAREN -> ( [92:19] + | |--PARAMETERS -> PARAMETERS [92:20] + | |--RPAREN -> ) [92:20] + | `--SLIST -> { [92:22] + | `--RCURLY -> } [92:23] + |--METHOD_DEF -> METHOD_DEF [93:4] + | |--MODIFIERS -> MODIFIERS [93:4] + | | |--ANNOTATION -> ANNOTATION [93:4] + | | | |--AT -> @ [93:4] + | | | |--IDENT -> ComplexAnnotation [93:5] + | | | |--LPAREN -> ( [93:22] + | | | |--ANNOTATION_ARRAY_INIT -> { [93:23] + | | | | |--ANNOTATION -> ANNOTATION [94:12] + | | | | | |--AT -> @ [94:12] + | | | | | |--IDENT -> InputRegressionJavaAnnotation1 [94:13] + | | | | | |--LPAREN -> ( [94:43] + | | | | | |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [94:44] + | | | | | | |--IDENT -> m1 [94:44] + | | | | | | |--ASSIGN -> = [94:47] + | | | | | | `--EXPR -> EXPR [94:49] + | | | | | | `--STRING_LITERAL -> "1" [94:49] + | | | | | `--RPAREN -> ) [94:52] + | | | | |--COMMA -> , [94:53] + | | | | |--ANNOTATION -> ANNOTATION [94:55] + | | | | | |--AT -> @ [94:55] + | | | | | |--IDENT -> InputRegressionJavaAnnotation1 [94:56] + | | | | | |--LPAREN -> ( [94:86] + | | | | | |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [94:87] + | | | | | | |--IDENT -> m1 [94:87] + | | | | | | |--ASSIGN -> = [94:90] + | | | | | | `--EXPR -> EXPR [94:92] + | | | | | | `--STRING_LITERAL -> "1" [94:92] + | | | | | `--RPAREN -> ) [94:95] + | | | | `--RCURLY -> } [95:4] + | | | `--RPAREN -> ) [95:5] + | | `--LITERAL_PUBLIC -> public [96:4] + | |--TYPE -> TYPE [96:11] + | | `--LITERAL_VOID -> void [96:11] + | |--IDENT -> m57 [96:16] + | |--LPAREN -> ( [96:19] + | |--PARAMETERS -> PARAMETERS [96:20] + | |--RPAREN -> ) [96:20] + | `--SLIST -> { [96:22] + | `--RCURLY -> } [96:23] + |--METHOD_DEF -> METHOD_DEF [97:4] + | |--MODIFIERS -> MODIFIERS [97:4] + | | `--LITERAL_PUBLIC -> public [97:4] + | |--TYPE -> TYPE [97:11] + | | `--LITERAL_VOID -> void [97:11] + | |--IDENT -> m58 [97:16] + | |--LPAREN -> ( [97:19] + | |--PARAMETERS -> PARAMETERS [97:20] + | | `--PARAMETER_DEF -> PARAMETER_DEF [97:20] + | | |--MODIFIERS -> MODIFIERS [97:20] + | | | `--ANNOTATION -> ANNOTATION [97:20] + | | | |--AT -> @ [97:20] + | | | `--IDENT -> Deprecated [97:21] + | | |--TYPE -> TYPE [97:32] + | | | `--IDENT -> String [97:32] + | | `--IDENT -> s [97:39] + | |--RPAREN -> ) [97:40] + | `--SLIST -> { [97:42] + | `--RCURLY -> } [97:43] + |--METHOD_DEF -> METHOD_DEF [98:4] + | |--MODIFIERS -> MODIFIERS [98:4] + | | `--LITERAL_PUBLIC -> public [98:4] + | |--TYPE -> TYPE [98:11] + | | `--LITERAL_VOID -> void [98:11] + | |--IDENT -> m59 [98:16] + | |--LPAREN -> ( [98:19] + | |--PARAMETERS -> PARAMETERS [98:20] + | | `--PARAMETER_DEF -> PARAMETER_DEF [98:20] + | | |--MODIFIERS -> MODIFIERS [98:20] + | | | |--FINAL -> final [98:20] + | | | `--ANNOTATION -> ANNOTATION [98:26] + | | | |--AT -> @ [98:26] + | | | `--IDENT -> Deprecated [98:27] + | | |--TYPE -> TYPE [98:38] + | | | `--IDENT -> List [98:38] + | | `--IDENT -> l [98:43] + | |--RPAREN -> ) [98:44] + | `--SLIST -> { [98:46] + | `--RCURLY -> } [98:47] + |--INSTANCE_INIT -> INSTANCE_INIT [101:4] + | `--SLIST -> { [101:4] + | `--RCURLY -> } [101:5] + |--SEMI -> ; [102:4] + |--METHOD_DEF -> METHOD_DEF [105:4] + | |--MODIFIERS -> MODIFIERS [105:4] + | | `--LITERAL_PUBLIC -> public [105:4] + | |--TYPE -> TYPE [105:11] + | | `--LITERAL_VOID -> void [105:11] + | |--IDENT -> instructions [105:16] + | |--LPAREN -> ( [105:28] + | |--PARAMETERS -> PARAMETERS [105:29] + | |--RPAREN -> ) [105:29] + | |--LITERAL_THROWS -> throws [105:31] + | | `--IDENT -> Exception [105:38] + | `--SLIST -> { [105:48] + | |--VARIABLE_DEF -> VARIABLE_DEF [107:8] + | | |--MODIFIERS -> MODIFIERS [107:8] + | | |--TYPE -> TYPE [107:8] + | | | `--LITERAL_BOOLEAN -> boolean [107:8] + | | |--IDENT -> b [107:16] + | | `--ASSIGN -> = [107:18] + | | `--EXPR -> EXPR [107:34] + | | `--GT -> > [107:34] + | | |--METHOD_CALL -> ( [107:31] + | | | |--DOT -> . [107:24] + | | | | |--IDENT -> Math [107:20] + | | | | `--IDENT -> random [107:25] + | | | |--ELIST -> ELIST [107:32] + | | | `--RPAREN -> ) [107:32] + | | `--NUM_INT -> 0 [107:36] + | |--SEMI -> ; [107:37] + | |--VARIABLE_DEF -> VARIABLE_DEF [110:8] + | | |--MODIFIERS -> MODIFIERS [110:8] + | | |--TYPE -> TYPE [110:8] + | | | `--LITERAL_BYTE -> byte [110:8] + | | `--IDENT -> vbyte [110:13] + | |--SEMI -> ; [110:18] + | |--VARIABLE_DEF -> VARIABLE_DEF [111:8] + | | |--MODIFIERS -> MODIFIERS [111:8] + | | |--TYPE -> TYPE [111:8] + | | | `--LITERAL_BOOLEAN -> boolean [111:8] + | | `--IDENT -> vboolean [111:16] + | |--SEMI -> ; [111:24] + | |--VARIABLE_DEF -> VARIABLE_DEF [112:8] + | | |--MODIFIERS -> MODIFIERS [112:8] + | | |--TYPE -> TYPE [112:8] + | | | `--LITERAL_CHAR -> char [112:8] + | | `--IDENT -> vchar [112:13] + | |--SEMI -> ; [112:18] + | |--VARIABLE_DEF -> VARIABLE_DEF [113:8] + | | |--MODIFIERS -> MODIFIERS [113:8] + | | |--TYPE -> TYPE [113:8] + | | | `--LITERAL_SHORT -> short [113:8] + | | `--IDENT -> vshort [113:14] + | |--SEMI -> ; [113:20] + | |--VARIABLE_DEF -> VARIABLE_DEF [114:8] + | | |--MODIFIERS -> MODIFIERS [114:8] + | | |--TYPE -> TYPE [114:8] + | | | `--LITERAL_INT -> int [114:8] + | | `--IDENT -> vint [114:12] + | |--SEMI -> ; [114:16] + | |--VARIABLE_DEF -> VARIABLE_DEF [115:8] + | | |--MODIFIERS -> MODIFIERS [115:8] + | | |--TYPE -> TYPE [115:8] + | | | `--LITERAL_LONG -> long [115:8] + | | `--IDENT -> vlong [115:13] + | |--SEMI -> ; [115:18] + | |--VARIABLE_DEF -> VARIABLE_DEF [116:8] + | | |--MODIFIERS -> MODIFIERS [116:8] + | | |--TYPE -> TYPE [116:8] + | | | `--LITERAL_FLOAT -> float [116:8] + | | `--IDENT -> vfloat [116:14] + | |--SEMI -> ; [116:20] + | |--VARIABLE_DEF -> VARIABLE_DEF [117:8] + | | |--MODIFIERS -> MODIFIERS [117:8] + | | |--TYPE -> TYPE [117:8] + | | | `--LITERAL_DOUBLE -> double [117:8] + | | `--IDENT -> vdouble [117:15] + | |--SEMI -> ; [117:22] + | |--VARIABLE_DEF -> VARIABLE_DEF [118:11] + | | |--MODIFIERS -> MODIFIERS [118:11] + | | |--TYPE -> TYPE [118:11] + | | | `--ARRAY_DECLARATOR -> [ [118:11] + | | | |--LITERAL_INT -> int [118:8] + | | | `--RBRACK -> ] [118:12] + | | `--IDENT -> varray [118:14] + | |--SEMI -> ; [118:20] + | |--VARIABLE_DEF -> VARIABLE_DEF [119:19] + | | |--MODIFIERS -> MODIFIERS [119:19] + | | |--TYPE -> TYPE [119:19] + | | | `--ARRAY_DECLARATOR -> [ [119:19] + | | | |--LITERAL_INT -> int [119:8] + | | | `--RBRACK -> ] [119:20] + | | `--IDENT -> varray2 [119:12] + | |--SEMI -> ; [119:21] + | |--VARIABLE_DEF -> VARIABLE_DEF [120:8] + | | |--MODIFIERS -> MODIFIERS [120:8] + | | |--TYPE -> TYPE [120:8] + | | | `--LITERAL_BOOLEAN -> boolean [120:8] + | | |--IDENT -> test1 [120:16] + | | `--ASSIGN -> = [120:22] + | | `--EXPR -> EXPR [120:24] + | | `--LITERAL_TRUE -> true [120:24] + | |--SEMI -> ; [120:28] + | |--VARIABLE_DEF -> VARIABLE_DEF [123:8] + | | |--MODIFIERS -> MODIFIERS [123:8] + | | |--TYPE -> TYPE [123:8] + | | | `--IDENT -> String [123:8] + | | `--IDENT -> vstring [123:15] + | |--SEMI -> ; [123:22] + | |--VARIABLE_DEF -> VARIABLE_DEF [124:8] + | | |--MODIFIERS -> MODIFIERS [124:8] + | | |--TYPE -> TYPE [124:8] + | | | |--IDENT -> List [124:8] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [124:12] + | | | |--GENERIC_START -> < [124:12] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [124:13] + | | | | `--IDENT -> String [124:13] + | | | `--GENERIC_END -> > [124:19] + | | `--IDENT -> vlist [124:21] + | |--SEMI -> ; [124:26] + | |--VARIABLE_DEF -> VARIABLE_DEF [125:8] + | | |--MODIFIERS -> MODIFIERS [125:8] + | | |--TYPE -> TYPE [125:8] + | | | |--IDENT -> Map [125:8] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [125:11] + | | | |--GENERIC_START -> < [125:11] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [125:12] + | | | | `--IDENT -> String [125:12] + | | | |--COMMA -> , [125:18] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [125:26] + | | | | `--ARRAY_DECLARATOR -> [ [125:26] + | | | | |--IDENT -> String [125:20] + | | | | `--RBRACK -> ] [125:27] + | | | `--GENERIC_END -> > [125:28] + | | `--IDENT -> vmap [125:30] + | |--SEMI -> ; [125:34] + | |--VARIABLE_DEF -> VARIABLE_DEF [126:11] + | | |--MODIFIERS -> MODIFIERS [126:11] + | | |--TYPE -> TYPE [126:11] + | | | `--ARRAY_DECLARATOR -> [ [126:11] + | | | |--LITERAL_INT -> int [126:8] + | | | `--RBRACK -> ] [126:12] + | | |--IDENT -> test2 [126:14] + | | `--ASSIGN -> = [126:20] + | | `--ARRAY_INIT -> { [126:22] + | | `--RCURLY -> } [126:23] + | |--SEMI -> ; [126:24] + | |--VARIABLE_DEF -> VARIABLE_DEF [127:8] + | | |--MODIFIERS -> MODIFIERS [127:8] + | | |--TYPE -> TYPE [127:8] + | | | |--IDENT -> List [127:8] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [127:12] + | | | |--GENERIC_START -> < [127:12] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [127:17] + | | | | `--ARRAY_DECLARATOR -> [ [127:17] + | | | | |--LITERAL_CHAR -> char [127:13] + | | | | `--RBRACK -> ] [127:18] + | | | `--GENERIC_END -> > [127:19] + | | `--IDENT -> test3 [127:21] + | |--SEMI -> ; [127:26] + | |--VARIABLE_DEF -> VARIABLE_DEF [128:8] + | | |--MODIFIERS -> MODIFIERS [128:8] + | | |--TYPE -> TYPE [128:8] + | | | |--IDENT -> Class [128:8] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [128:13] + | | | |--GENERIC_START -> < [128:13] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [128:14] + | | | | `--WILDCARD_TYPE -> ? [128:14] + | | | `--GENERIC_END -> > [128:15] + | | `--IDENT -> test4 [128:17] + | |--SEMI -> ; [128:22] + | |--VARIABLE_DEF -> VARIABLE_DEF [129:8] + | | |--MODIFIERS -> MODIFIERS [129:8] + | | |--TYPE -> TYPE [129:8] + | | | |--IDENT -> List [129:8] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [129:12] + | | | |--GENERIC_START -> < [129:12] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [129:13] + | | | | |--WILDCARD_TYPE -> ? [129:13] + | | | | `--TYPE_UPPER_BOUNDS -> extends [129:15] + | | | | `--IDENT -> InputRegressionJavaClass1 [129:23] + | | | `--GENERIC_END -> > [129:48] + | | `--IDENT -> test5 [129:50] + | |--SEMI -> ; [129:55] + | |--VARIABLE_DEF -> VARIABLE_DEF [130:8] + | | |--MODIFIERS -> MODIFIERS [130:8] + | | |--TYPE -> TYPE [130:8] + | | | |--IDENT -> List [130:8] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [130:12] + | | | |--GENERIC_START -> < [130:12] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [130:13] + | | | | |--WILDCARD_TYPE -> ? [130:13] + | | | | `--TYPE_UPPER_BOUNDS -> extends [130:15] + | | | | |--IDENT -> List [130:23] + | | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [130:27] + | | | | |--GENERIC_START -> < [130:27] + | | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [130:28] + | | | | | `--IDENT -> Object [130:28] + | | | | `--GENERIC_END -> > [130:34] + | | | `--GENERIC_END -> > [130:35] + | | `--IDENT -> test6 [130:37] + | |--SEMI -> ; [130:42] + | |--VARIABLE_DEF -> VARIABLE_DEF [131:8] + | | |--MODIFIERS -> MODIFIERS [131:8] + | | |--TYPE -> TYPE [131:8] + | | | |--IDENT -> List [131:8] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [131:12] + | | | |--GENERIC_START -> < [131:12] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [131:13] + | | | | |--WILDCARD_TYPE -> ? [131:13] + | | | | `--TYPE_UPPER_BOUNDS -> extends [131:15] + | | | | |--IDENT -> List [131:23] + | | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [131:27] + | | | | |--GENERIC_START -> < [131:27] + | | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [131:28] + | | | | | |--IDENT -> List [131:28] + | | | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [131:32] + | | | | | |--GENERIC_START -> < [131:32] + | | | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [131:33] + | | | | | | `--IDENT -> Object [131:33] + | | | | | `--GENERIC_END -> > [131:39] + | | | | `--GENERIC_END -> > [131:40] + | | | `--GENERIC_END -> > [131:41] + | | `--IDENT -> test7 [131:43] + | |--SEMI -> ; [131:48] + | |--VARIABLE_DEF -> VARIABLE_DEF [132:8] + | | |--MODIFIERS -> MODIFIERS [132:8] + | | |--TYPE -> TYPE [132:8] + | | | |--IDENT -> List [132:8] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [132:12] + | | | |--GENERIC_START -> < [132:12] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [132:13] + | | | | |--WILDCARD_TYPE -> ? [132:13] + | | | | `--ARRAY_DECLARATOR -> [ [132:26] + | | | | |--TYPE_UPPER_BOUNDS -> extends [132:15] + | | | | | `--LITERAL_INT -> int [132:23] + | | | | `--RBRACK -> ] [132:27] + | | | `--GENERIC_END -> > [132:28] + | | `--IDENT -> test8 [132:30] + | |--SEMI -> ; [132:35] + | |--VARIABLE_DEF -> VARIABLE_DEF [133:8] + | | |--MODIFIERS -> MODIFIERS [133:8] + | | |--TYPE -> TYPE [133:8] + | | | |--IDENT -> List [133:8] + | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [133:12] + | | | |--GENERIC_START -> < [133:12] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [133:13] + | | | | |--WILDCARD_TYPE -> ? [133:13] + | | | | `--TYPE_LOWER_BOUNDS -> super [133:15] + | | | | `--IDENT -> InputRegressionJavaClass1 [133:21] + | | | `--GENERIC_END -> > [133:46] + | | `--IDENT -> test9 [133:48] + | |--SEMI -> ; [133:53] + | |--EXPR -> EXPR [136:17] + | | `--ASSIGN -> = [136:17] + | | |--IDENT -> vboolean [136:8] + | | `--LITERAL_TRUE -> true [136:19] + | |--SEMI -> ; [136:23] + | |--EXPR -> EXPR [137:17] + | | `--ASSIGN -> = [137:17] + | | |--IDENT -> vboolean [137:8] + | | `--LITERAL_FALSE -> false [137:19] + | |--SEMI -> ; [137:24] + | |--EXPR -> EXPR [138:14] + | | `--ASSIGN -> = [138:14] + | | |--IDENT -> vchar [138:8] + | | `--CHAR_LITERAL -> ' ' [138:16] + | |--SEMI -> ; [138:19] + | |--EXPR -> EXPR [139:14] + | | `--ASSIGN -> = [139:14] + | | |--IDENT -> vchar [139:8] + | | `--CHAR_LITERAL -> '"' [139:16] + | |--SEMI -> ; [139:19] + | |--EXPR -> EXPR [140:14] + | | `--ASSIGN -> = [140:14] + | | |--IDENT -> vchar [140:8] + | | `--CHAR_LITERAL -> '\0' [140:16] + | |--SEMI -> ; [140:20] + | |--EXPR -> EXPR [141:14] + | | `--ASSIGN -> = [141:14] + | | |--IDENT -> vchar [141:8] + | | `--CHAR_LITERAL -> '\'' [141:16] + | |--SEMI -> ; [141:20] + | |--EXPR -> EXPR [142:14] + | | `--ASSIGN -> = [142:14] + | | |--IDENT -> vchar [142:8] + | | `--CHAR_LITERAL -> '\n' [142:16] + | |--SEMI -> ; [142:20] + | |--EXPR -> EXPR [143:14] + | | `--ASSIGN -> = [143:14] + | | |--IDENT -> vchar [143:8] + | | `--CHAR_LITERAL -> '\r' [143:16] + | |--SEMI -> ; [143:20] + | |--EXPR -> EXPR [144:14] + | | `--ASSIGN -> = [144:14] + | | |--IDENT -> vchar [144:8] + | | `--CHAR_LITERAL -> '\t' [144:16] + | |--SEMI -> ; [144:20] + | |--EXPR -> EXPR [145:14] + | | `--ASSIGN -> = [145:14] + | | |--IDENT -> vchar [145:8] + | | `--CHAR_LITERAL -> '\b' [145:16] + | |--SEMI -> ; [145:20] + | |--EXPR -> EXPR [146:14] + | | `--ASSIGN -> = [146:14] + | | |--IDENT -> vchar [146:8] + | | `--CHAR_LITERAL -> '\f' [146:16] + | |--SEMI -> ; [146:20] + | |--EXPR -> EXPR [147:14] + | | `--ASSIGN -> = [147:14] + | | |--IDENT -> vchar [147:8] + | | `--CHAR_LITERAL -> '\"' [147:16] + | |--SEMI -> ; [147:20] + | |--EXPR -> EXPR [148:14] + | | `--ASSIGN -> = [148:14] + | | |--IDENT -> vchar [148:8] + | | `--CHAR_LITERAL -> '\'' [148:16] + | |--SEMI -> ; [148:20] + | |--EXPR -> EXPR [149:14] + | | `--ASSIGN -> = [149:14] + | | |--IDENT -> vchar [149:8] + | | `--CHAR_LITERAL -> '\\' [149:16] + | |--SEMI -> ; [149:20] + | |--EXPR -> EXPR [150:14] + | | `--ASSIGN -> = [150:14] + | | |--IDENT -> vchar [150:8] + | | `--CHAR_LITERAL -> '\00' [150:16] + | |--SEMI -> ; [150:21] + | |--EXPR -> EXPR [151:14] + | | `--ASSIGN -> = [151:14] + | | |--IDENT -> vchar [151:8] + | | `--CHAR_LITERAL -> '\013' [151:16] + | |--SEMI -> ; [151:22] + | |--EXPR -> EXPR [152:14] + | | `--ASSIGN -> = [152:14] + | | |--IDENT -> vchar [152:8] + | | `--CHAR_LITERAL -> '\4' [152:16] + | |--SEMI -> ; [152:20] + | |--EXPR -> EXPR [153:14] + | | `--ASSIGN -> = [153:14] + | | |--IDENT -> vchar [153:8] + | | `--CHAR_LITERAL -> '\40' [153:16] + | |--SEMI -> ; [153:21] + | |--EXPR -> EXPR [154:14] + | | `--ASSIGN -> = [154:14] + | | |--IDENT -> vchar [154:8] + | | `--CHAR_LITERAL -> '\u0000' [154:16] + | |--SEMI -> ; [154:24] + | |--EXPR -> EXPR [155:14] + | | `--ASSIGN -> = [155:14] + | | |--IDENT -> vchar [155:8] + | | `--CHAR_LITERAL -> '\u1234' [155:16] + | |--SEMI -> ; [155:24] + | |--EXPR -> EXPR [156:14] + | | `--ASSIGN -> = [156:14] + | | |--IDENT -> vchar [156:8] + | | `--CHAR_LITERAL -> '\u005C\u005C' [156:16] + | |--SEMI -> ; [156:30] + | |--EXPR -> EXPR [157:14] + | | `--ASSIGN -> = [157:14] + | | |--IDENT -> vchar [157:8] + | | `--CHAR_LITERAL -> '\u005c\u005c' [157:16] + | |--SEMI -> ; [157:30] + | |--EXPR -> EXPR [158:14] + | | `--ASSIGN -> = [158:14] + | | |--IDENT -> vchar [158:8] + | | `--CHAR_LITERAL -> '\uu005C\uuuuu005C' [158:16] + | |--SEMI -> ; [158:35] + | |--EXPR -> EXPR [159:14] + | | `--ASSIGN -> = [159:14] + | | |--IDENT -> vchar [159:8] + | | `--CHAR_LITERAL -> '\u005cn' [159:16] + | |--SEMI -> ; [159:25] + | |--EXPR -> EXPR [160:14] + | | `--ASSIGN -> = [160:14] + | | |--IDENT -> vchar [160:8] + | | `--CHAR_LITERAL -> '\u005cr' [160:16] + | |--SEMI -> ; [160:25] + | |--EXPR -> EXPR [161:14] + | | `--ASSIGN -> = [161:14] + | | |--IDENT -> vchar [161:8] + | | `--CHAR_LITERAL -> '\u005ct' [161:16] + | |--SEMI -> ; [161:25] + | |--EXPR -> EXPR [162:14] + | | `--ASSIGN -> = [162:14] + | | |--IDENT -> vchar [162:8] + | | `--CHAR_LITERAL -> '\u005cb' [162:16] + | |--SEMI -> ; [162:25] + | |--EXPR -> EXPR [163:14] + | | `--ASSIGN -> = [163:14] + | | |--IDENT -> vchar [163:8] + | | `--CHAR_LITERAL -> '\u005cf' [163:16] + | |--SEMI -> ; [163:25] + | |--EXPR -> EXPR [164:14] + | | `--ASSIGN -> = [164:14] + | | |--IDENT -> vchar [164:8] + | | `--CHAR_LITERAL -> '\u005c"' [164:16] + | |--SEMI -> ; [164:25] + | |--EXPR -> EXPR [165:14] + | | `--ASSIGN -> = [165:14] + | | |--IDENT -> vchar [165:8] + | | `--CHAR_LITERAL -> '\u005c'' [165:16] + | |--SEMI -> ; [165:25] + | |--EXPR -> EXPR [166:14] + | | `--ASSIGN -> = [166:14] + | | |--IDENT -> vchar [166:8] + | | `--CHAR_LITERAL -> '\u005c\' [166:16] + | |--SEMI -> ; [166:25] + | |--EXPR -> EXPR [167:13] + | | `--ASSIGN -> = [167:13] + | | |--IDENT -> vint [167:8] + | | `--NUM_INT -> 0 [167:15] + | |--SEMI -> ; [167:16] + | |--EXPR -> EXPR [168:13] + | | `--ASSIGN -> = [168:13] + | | |--IDENT -> vint [168:8] + | | `--UNARY_MINUS -> - [168:15] + | | `--NUM_INT -> 1 [168:16] + | |--SEMI -> ; [168:17] + | |--EXPR -> EXPR [169:13] + | | `--ASSIGN -> = [169:13] + | | |--IDENT -> vint [169:8] + | | `--UNARY_PLUS -> + [169:15] + | | `--NUM_INT -> 1 [169:16] + | |--SEMI -> ; [169:17] + | |--EXPR -> EXPR [170:13] + | | `--ASSIGN -> = [170:13] + | | |--IDENT -> vint [170:8] + | | `--NUM_INT -> 100_000 [170:15] + | |--SEMI -> ; [170:22] + | |--EXPR -> EXPR [171:13] + | | `--ASSIGN -> = [171:13] + | | |--IDENT -> vint [171:8] + | | `--NUM_INT -> 0x00 [171:15] + | |--SEMI -> ; [171:19] + | |--EXPR -> EXPR [172:13] + | | `--ASSIGN -> = [172:13] + | | |--IDENT -> vint [172:8] + | | `--NUM_INT -> 0x12345678 [172:15] + | |--SEMI -> ; [172:25] + | |--EXPR -> EXPR [173:13] + | | `--ASSIGN -> = [173:13] + | | |--IDENT -> vint [173:8] + | | `--NUM_INT -> 0X9 [173:15] + | |--SEMI -> ; [173:18] + | |--EXPR -> EXPR [174:13] + | | `--ASSIGN -> = [174:13] + | | |--IDENT -> vint [174:8] + | | `--NUM_INT -> 0x1234_5678 [174:15] + | |--SEMI -> ; [174:26] + | |--EXPR -> EXPR [175:13] + | | `--ASSIGN -> = [175:13] + | | |--IDENT -> vint [175:8] + | | `--NUM_INT -> 0b101 [175:15] + | |--SEMI -> ; [175:20] + | |--EXPR -> EXPR [176:13] + | | `--ASSIGN -> = [176:13] + | | |--IDENT -> vint [176:8] + | | `--NUM_INT -> 0B101 [176:15] + | |--SEMI -> ; [176:20] + | |--EXPR -> EXPR [177:13] + | | `--ASSIGN -> = [177:13] + | | |--IDENT -> vint [177:8] + | | `--NUM_INT -> 0b1 [177:15] + | |--SEMI -> ; [177:18] + | |--EXPR -> EXPR [178:13] + | | `--ASSIGN -> = [178:13] + | | |--IDENT -> vint [178:8] + | | `--NUM_INT -> 0b1_0 [178:15] + | |--SEMI -> ; [178:20] + | |--EXPR -> EXPR [179:13] + | | `--ASSIGN -> = [179:13] + | | |--IDENT -> vint [179:8] + | | `--NUM_INT -> 012345670 [179:15] + | |--SEMI -> ; [179:24] + | |--EXPR -> EXPR [180:13] + | | `--ASSIGN -> = [180:13] + | | |--IDENT -> vint [180:8] + | | `--NUM_INT -> 01234_5670 [180:15] + | |--SEMI -> ; [180:25] + | |--EXPR -> EXPR [181:14] + | | `--ASSIGN -> = [181:14] + | | |--IDENT -> vlong [181:8] + | | `--NUM_LONG -> 0L [181:16] + | |--SEMI -> ; [181:18] + | |--EXPR -> EXPR [182:14] + | | `--ASSIGN -> = [182:14] + | | |--IDENT -> vlong [182:8] + | | `--NUM_LONG -> 1L [182:16] + | |--SEMI -> ; [182:18] + | |--EXPR -> EXPR [183:14] + | | `--ASSIGN -> = [183:14] + | | |--IDENT -> vlong [183:8] + | | `--NUM_LONG -> 0b1L [183:16] + | |--SEMI -> ; [183:20] + | |--EXPR -> EXPR [184:14] + | | `--ASSIGN -> = [184:14] + | | |--IDENT -> vlong [184:8] + | | `--NUM_LONG -> 1234567890l [184:16] + | |--SEMI -> ; [184:27] + | |--EXPR -> EXPR [185:14] + | | `--ASSIGN -> = [185:14] + | | |--IDENT -> vlong [185:8] + | | `--NUM_LONG -> 1234567890L [185:16] + | |--SEMI -> ; [185:27] + | |--EXPR -> EXPR [186:14] + | | `--ASSIGN -> = [186:14] + | | |--IDENT -> vlong [186:8] + | | `--NUM_LONG -> 0x0l [186:16] + | |--SEMI -> ; [186:20] + | |--EXPR -> EXPR [187:14] + | | `--ASSIGN -> = [187:14] + | | |--IDENT -> vlong [187:8] + | | `--NUM_LONG -> 0xABCDEFl [187:16] + | |--SEMI -> ; [187:25] + | |--EXPR -> EXPR [188:14] + | | `--ASSIGN -> = [188:14] + | | |--IDENT -> vlong [188:8] + | | `--NUM_LONG -> 0XABCDEFL [188:16] + | |--SEMI -> ; [188:25] + | |--EXPR -> EXPR [189:15] + | | `--ASSIGN -> = [189:15] + | | |--IDENT -> vfloat [189:8] + | | `--NUM_FLOAT -> 0f [189:17] + | |--SEMI -> ; [189:19] + | |--EXPR -> EXPR [190:15] + | | `--ASSIGN -> = [190:15] + | | |--IDENT -> vfloat [190:8] + | | `--NUM_FLOAT -> 0F [190:17] + | |--SEMI -> ; [190:19] + | |--EXPR -> EXPR [191:15] + | | `--ASSIGN -> = [191:15] + | | |--IDENT -> vfloat [191:8] + | | `--NUM_FLOAT -> 1.1f [191:17] + | |--SEMI -> ; [191:21] + | |--EXPR -> EXPR [192:15] + | | `--ASSIGN -> = [192:15] + | | |--IDENT -> vfloat [192:8] + | | `--NUM_FLOAT -> 1.10_1F [192:17] + | |--SEMI -> ; [192:24] + | |--EXPR -> EXPR [193:15] + | | `--ASSIGN -> = [193:15] + | | |--IDENT -> vfloat [193:8] + | | `--NUM_FLOAT -> 0_1.1_1F [193:17] + | |--SEMI -> ; [193:25] + | |--EXPR -> EXPR [194:15] + | | `--ASSIGN -> = [194:15] + | | |--IDENT -> vfloat [194:8] + | | `--NUM_FLOAT -> 1e0f [194:17] + | |--SEMI -> ; [194:21] + | |--EXPR -> EXPR [195:15] + | | `--ASSIGN -> = [195:15] + | | |--IDENT -> vfloat [195:8] + | | `--NUM_FLOAT -> 1e0F [195:17] + | |--SEMI -> ; [195:21] + | |--EXPR -> EXPR [196:15] + | | `--ASSIGN -> = [196:15] + | | |--IDENT -> vfloat [196:8] + | | `--NUM_FLOAT -> 1.0e0F [196:17] + | |--SEMI -> ; [196:23] + | |--EXPR -> EXPR [197:15] + | | `--ASSIGN -> = [197:15] + | | |--IDENT -> vfloat [197:8] + | | `--NUM_FLOAT -> 0x2__3_34.4___AFP00_00f [197:17] + | |--SEMI -> ; [197:40] + | |--EXPR -> EXPR [198:16] + | | `--ASSIGN -> = [198:16] + | | |--IDENT -> vdouble [198:8] + | | `--NUM_FLOAT -> 10. [198:18] + | |--SEMI -> ; [198:21] + | |--EXPR -> EXPR [199:16] + | | `--ASSIGN -> = [199:16] + | | |--IDENT -> vdouble [199:8] + | | `--NUM_FLOAT -> .1 [199:18] + | |--SEMI -> ; [199:20] + | |--EXPR -> EXPR [200:16] + | | `--ASSIGN -> = [200:16] + | | |--IDENT -> vdouble [200:8] + | | `--NUM_FLOAT -> .1__1_1 [200:18] + | |--SEMI -> ; [200:25] + | |--EXPR -> EXPR [201:16] + | | `--ASSIGN -> = [201:16] + | | |--IDENT -> vdouble [201:8] + | | `--NUM_FLOAT -> 0.0 [201:18] + | |--SEMI -> ; [201:21] + | |--EXPR -> EXPR [202:16] + | | `--ASSIGN -> = [202:16] + | | |--IDENT -> vdouble [202:8] + | | `--NUM_FLOAT -> 1000.0 [202:18] + | |--SEMI -> ; [202:24] + | |--EXPR -> EXPR [203:16] + | | `--ASSIGN -> = [203:16] + | | |--IDENT -> vdouble [203:8] + | | `--NUM_DOUBLE -> .1d [203:18] + | |--SEMI -> ; [203:21] + | |--EXPR -> EXPR [204:16] + | | `--ASSIGN -> = [204:16] + | | |--IDENT -> vdouble [204:8] + | | `--NUM_DOUBLE -> 1.D [204:18] + | |--SEMI -> ; [204:21] + | |--EXPR -> EXPR [205:16] + | | `--ASSIGN -> = [205:16] + | | |--IDENT -> vdouble [205:8] + | | `--NUM_DOUBLE -> 0_1.0d [205:18] + | |--SEMI -> ; [205:24] + | |--EXPR -> EXPR [206:16] + | | `--ASSIGN -> = [206:16] + | | |--IDENT -> vdouble [206:8] + | | `--NUM_DOUBLE -> 0_1.0D [206:18] + | |--SEMI -> ; [206:24] + | |--EXPR -> EXPR [207:16] + | | `--ASSIGN -> = [207:16] + | | |--IDENT -> vdouble [207:8] + | | `--NUM_FLOAT -> 4e23 [207:18] + | |--SEMI -> ; [207:22] + | |--EXPR -> EXPR [208:16] + | | `--ASSIGN -> = [208:16] + | | |--IDENT -> vdouble [208:8] + | | `--NUM_FLOAT -> 4E23 [208:18] + | |--SEMI -> ; [208:22] + | |--EXPR -> EXPR [209:16] + | | `--ASSIGN -> = [209:16] + | | |--IDENT -> vdouble [209:8] + | | `--NUM_FLOAT -> 4E2_3 [209:18] + | |--SEMI -> ; [209:23] + | |--EXPR -> EXPR [210:16] + | | `--ASSIGN -> = [210:16] + | | |--IDENT -> vdouble [210:8] + | | `--NUM_FLOAT -> 0x0.0000000000001p-1022 [210:18] + | |--SEMI -> ; [210:41] + | |--EXPR -> EXPR [211:16] + | | `--ASSIGN -> = [211:16] + | | |--IDENT -> vdouble [211:8] + | | `--NUM_FLOAT -> 0x0.0000000000001P-1022 [211:18] + | |--SEMI -> ; [211:41] + | |--EXPR -> EXPR [212:16] + | | `--ASSIGN -> = [212:16] + | | |--IDENT -> vdouble [212:8] + | | `--NUM_FLOAT -> 0X0.0000000000001p+1022 [212:18] + | |--SEMI -> ; [212:41] + | |--EXPR -> EXPR [213:16] + | | `--ASSIGN -> = [213:16] + | | |--IDENT -> vdouble [213:8] + | | `--NUM_FLOAT -> 0X0.0000000000001P+1022 [213:18] + | |--SEMI -> ; [213:41] + | |--EXPR -> EXPR [214:16] + | | `--ASSIGN -> = [214:16] + | | |--IDENT -> vdouble [214:8] + | | `--NUM_FLOAT -> 0x.0P0 [214:18] + | |--SEMI -> ; [214:24] + | |--EXPR -> EXPR [215:16] + | | `--ASSIGN -> = [215:16] + | | |--IDENT -> vdouble [215:8] + | | `--NUM_FLOAT -> 0X0p+2 [215:18] + | |--SEMI -> ; [215:24] + | |--EXPR -> EXPR [216:16] + | | `--ASSIGN -> = [216:16] + | | |--IDENT -> vdouble [216:8] + | | `--NUM_FLOAT -> 0X0p+20F [216:18] + | |--SEMI -> ; [216:26] + | |--EXPR -> EXPR [217:16] + | | `--ASSIGN -> = [217:16] + | | |--IDENT -> vdouble [217:8] + | | `--NUM_DOUBLE -> 0X0p+2D [217:18] + | |--SEMI -> ; [217:25] + | |--EXPR -> EXPR [218:16] + | | `--ASSIGN -> = [218:16] + | | |--IDENT -> vdouble [218:8] + | | `--NUM_DOUBLE -> 0X0p+2d [218:18] + | |--SEMI -> ; [218:25] + | |--EXPR -> EXPR [219:16] + | | `--ASSIGN -> = [219:16] + | | |--IDENT -> vdouble [219:8] + | | `--NUM_FLOAT -> 0x1.P-1 [219:18] + | |--SEMI -> ; [219:25] + | |--EXPR -> EXPR [220:16] + | | `--ASSIGN -> = [220:16] + | | |--IDENT -> vdouble [220:8] + | | `--NUM_FLOAT -> 0x.1___AFp1 [220:18] + | |--SEMI -> ; [220:29] + | |--EXPR -> EXPR [221:16] + | | `--ASSIGN -> = [221:16] + | | |--IDENT -> vstring [221:8] + | | `--LITERAL_NULL -> null [221:18] + | |--SEMI -> ; [221:22] + | |--EXPR -> EXPR [222:16] + | | `--ASSIGN -> = [222:16] + | | |--IDENT -> vstring [222:8] + | | `--STRING_LITERAL -> "" [222:18] + | |--SEMI -> ; [222:20] + | |--EXPR -> EXPR [223:16] + | | `--ASSIGN -> = [223:16] + | | |--IDENT -> vstring [223:8] + | | `--STRING_LITERAL -> "\\" [223:18] + | |--SEMI -> ; [223:22] + | |--EXPR -> EXPR [226:13] + | | `--ASSIGN -> = [226:13] + | | |--IDENT -> vint [226:8] + | | `--PLUS -> + [226:17] + | | |--NUM_INT -> 1 [226:15] + | | `--NUM_INT -> 1 [226:19] + | |--SEMI -> ; [226:20] + | |--EXPR -> EXPR [227:13] + | | `--ASSIGN -> = [227:13] + | | |--IDENT -> vint [227:8] + | | `--MINUS -> - [227:17] + | | |--NUM_INT -> 1 [227:15] + | | `--NUM_INT -> 1 [227:19] + | |--SEMI -> ; [227:20] + | |--EXPR -> EXPR [228:13] + | | `--ASSIGN -> = [228:13] + | | |--IDENT -> vint [228:8] + | | `--STAR -> * [228:17] + | | |--NUM_INT -> 1 [228:15] + | | `--NUM_INT -> 1 [228:19] + | |--SEMI -> ; [228:20] + | |--EXPR -> EXPR [229:13] + | | `--ASSIGN -> = [229:13] + | | |--IDENT -> vint [229:8] + | | `--DIV -> / [229:17] + | | |--NUM_INT -> 1 [229:15] + | | `--NUM_INT -> 1 [229:19] + | |--SEMI -> ; [229:20] + | |--EXPR -> EXPR [230:13] + | | `--ASSIGN -> = [230:13] + | | |--IDENT -> vint [230:8] + | | `--MOD -> % [230:17] + | | |--NUM_INT -> 1 [230:15] + | | `--NUM_INT -> 1 [230:19] + | |--SEMI -> ; [230:20] + | |--EXPR -> EXPR [231:13] + | | `--ASSIGN -> = [231:13] + | | |--IDENT -> vint [231:8] + | | `--BAND -> & [231:17] + | | |--NUM_INT -> 1 [231:15] + | | `--NUM_INT -> 1 [231:19] + | |--SEMI -> ; [231:20] + | |--EXPR -> EXPR [232:13] + | | `--ASSIGN -> = [232:13] + | | |--IDENT -> vint [232:8] + | | `--BOR -> | [232:17] + | | |--NUM_INT -> 1 [232:15] + | | `--NUM_INT -> 1 [232:19] + | |--SEMI -> ; [232:20] + | |--EXPR -> EXPR [233:13] + | | `--ASSIGN -> = [233:13] + | | |--IDENT -> vint [233:8] + | | `--BXOR -> ^ [233:17] + | | |--NUM_INT -> 1 [233:15] + | | `--NUM_INT -> 1 [233:19] + | |--SEMI -> ; [233:20] + | |--EXPR -> EXPR [234:13] + | | `--ASSIGN -> = [234:13] + | | |--IDENT -> vint [234:8] + | | `--BNOT -> ~ [234:15] + | | `--NUM_INT -> 1 [234:16] + | |--SEMI -> ; [234:17] + | |--EXPR -> EXPR [235:17] + | | `--ASSIGN -> = [235:17] + | | |--IDENT -> vboolean [235:8] + | | `--NOT_EQUAL -> != [235:21] + | | |--NUM_INT -> 1 [235:19] + | | `--NUM_INT -> 0 [235:24] + | |--SEMI -> ; [235:25] + | |--EXPR -> EXPR [236:17] + | | `--ASSIGN -> = [236:17] + | | |--IDENT -> vboolean [236:8] + | | `--EQUAL -> == [236:21] + | | |--NUM_INT -> 1 [236:19] + | | `--NUM_INT -> 0 [236:24] + | |--SEMI -> ; [236:25] + | |--EXPR -> EXPR [237:17] + | | `--ASSIGN -> = [237:17] + | | |--IDENT -> vboolean [237:8] + | | `--GT -> > [237:21] + | | |--NUM_INT -> 1 [237:19] + | | `--NUM_INT -> 0 [237:23] + | |--SEMI -> ; [237:24] + | |--EXPR -> EXPR [238:17] + | | `--ASSIGN -> = [238:17] + | | |--IDENT -> vboolean [238:8] + | | `--GE -> >= [238:21] + | | |--NUM_INT -> 1 [238:19] + | | `--NUM_INT -> 0 [238:24] + | |--SEMI -> ; [238:25] + | |--EXPR -> EXPR [239:17] + | | `--ASSIGN -> = [239:17] + | | |--IDENT -> vboolean [239:8] + | | `--LT -> < [239:21] + | | |--NUM_INT -> 1 [239:19] + | | `--NUM_INT -> 0 [239:23] + | |--SEMI -> ; [239:24] + | |--EXPR -> EXPR [240:17] + | | `--ASSIGN -> = [240:17] + | | |--IDENT -> vboolean [240:8] + | | `--LE -> <= [240:21] + | | |--NUM_INT -> 1 [240:19] + | | `--NUM_INT -> 0 [240:24] + | |--SEMI -> ; [240:25] + | |--EXPR -> EXPR [241:17] + | | `--ASSIGN -> = [241:17] + | | |--IDENT -> vboolean [241:8] + | | `--LAND -> && [241:24] + | | |--LITERAL_TRUE -> true [241:19] + | | `--LITERAL_TRUE -> true [241:27] + | |--SEMI -> ; [241:31] + | |--EXPR -> EXPR [242:17] + | | `--ASSIGN -> = [242:17] + | | |--IDENT -> vboolean [242:8] + | | `--LOR -> || [242:24] + | | |--LITERAL_TRUE -> true [242:19] + | | `--LITERAL_TRUE -> true [242:27] + | |--SEMI -> ; [242:31] + | |--EXPR -> EXPR [243:17] + | | `--ASSIGN -> = [243:17] + | | |--IDENT -> vboolean [243:8] + | | `--QUESTION -> ? [243:24] + | | |--LITERAL_TRUE -> true [243:19] + | | |--LITERAL_TRUE -> true [243:26] + | | |--COLON -> : [243:31] + | | `--LITERAL_FALSE -> false [243:33] + | |--SEMI -> ; [243:38] + | |--EXPR -> EXPR [244:17] + | | `--ASSIGN -> = [244:17] + | | |--IDENT -> vboolean [244:8] + | | `--LNOT -> ! [244:19] + | | `--LITERAL_TRUE -> true [244:20] + | |--SEMI -> ; [244:24] + | |--EXPR -> EXPR [245:17] + | | `--ASSIGN -> = [245:17] + | | |--IDENT -> vboolean [245:8] + | | `--LITERAL_INSTANCEOF -> instanceof [245:22] + | | |--IDENT -> f9 [245:19] + | | `--TYPE -> TYPE [245:33] + | | `--IDENT -> Object [245:33] + | |--SEMI -> ; [245:39] + | |--EXPR -> EXPR [246:13] + | | `--ASSIGN -> = [246:13] + | | |--IDENT -> vint [246:8] + | | `--SL -> << [246:17] + | | |--NUM_INT -> 1 [246:15] + | | `--NUM_INT -> 1 [246:20] + | |--SEMI -> ; [246:21] + | |--EXPR -> EXPR [247:13] + | | `--ASSIGN -> = [247:13] + | | |--IDENT -> vint [247:8] + | | `--SR -> >> [247:17] + | | |--NUM_INT -> 1 [247:15] + | | `--NUM_INT -> 1 [247:20] + | |--SEMI -> ; [247:21] + | |--EXPR -> EXPR [248:13] + | | `--ASSIGN -> = [248:13] + | | |--IDENT -> vint [248:8] + | | `--BSR -> >>> [248:17] + | | |--NUM_INT -> 1 [248:15] + | | `--NUM_INT -> 1 [248:21] + | |--SEMI -> ; [248:22] + | |--EXPR -> EXPR [249:13] + | | `--PLUS_ASSIGN -> += [249:13] + | | |--IDENT -> vint [249:8] + | | `--NUM_INT -> 1 [249:16] + | |--SEMI -> ; [249:17] + | |--EXPR -> EXPR [250:13] + | | `--MINUS_ASSIGN -> -= [250:13] + | | |--IDENT -> vint [250:8] + | | `--NUM_INT -> 1 [250:16] + | |--SEMI -> ; [250:17] + | |--EXPR -> EXPR [251:13] + | | `--STAR_ASSIGN -> *= [251:13] + | | |--IDENT -> vint [251:8] + | | `--NUM_INT -> 1 [251:16] + | |--SEMI -> ; [251:17] + | |--EXPR -> EXPR [252:13] + | | `--DIV_ASSIGN -> /= [252:13] + | | |--IDENT -> vint [252:8] + | | `--NUM_INT -> 1 [252:16] + | |--SEMI -> ; [252:17] + | |--EXPR -> EXPR [253:13] + | | `--MOD_ASSIGN -> %= [253:13] + | | |--IDENT -> vint [253:8] + | | `--NUM_INT -> 1 [253:16] + | |--SEMI -> ; [253:17] + | |--EXPR -> EXPR [254:13] + | | `--BAND_ASSIGN -> &= [254:13] + | | |--IDENT -> vint [254:8] + | | `--NUM_INT -> 1 [254:16] + | |--SEMI -> ; [254:17] + | |--EXPR -> EXPR [255:13] + | | `--BOR_ASSIGN -> |= [255:13] + | | |--IDENT -> vint [255:8] + | | `--NUM_INT -> 1 [255:16] + | |--SEMI -> ; [255:17] + | |--EXPR -> EXPR [256:13] + | | `--BXOR_ASSIGN -> ^= [256:13] + | | |--IDENT -> vint [256:8] + | | `--NUM_INT -> 1 [256:16] + | |--SEMI -> ; [256:17] + | |--EXPR -> EXPR [257:13] + | | `--SL_ASSIGN -> <<= [257:13] + | | |--IDENT -> vint [257:8] + | | `--NUM_INT -> 1 [257:17] + | |--SEMI -> ; [257:18] + | |--EXPR -> EXPR [258:13] + | | `--SR_ASSIGN -> >>= [258:13] + | | |--IDENT -> vint [258:8] + | | `--NUM_INT -> 1 [258:17] + | |--SEMI -> ; [258:18] + | |--EXPR -> EXPR [259:13] + | | `--BSR_ASSIGN -> >>>= [259:13] + | | |--IDENT -> vint [259:8] + | | `--NUM_INT -> 1 [259:18] + | |--SEMI -> ; [259:19] + | |--EXPR -> EXPR [260:12] + | | `--POST_INC -> ++ [260:12] + | | `--IDENT -> vint [260:8] + | |--SEMI -> ; [260:14] + | |--EXPR -> EXPR [261:12] + | | `--POST_DEC -> -- [261:12] + | | `--IDENT -> vint [261:8] + | |--SEMI -> ; [261:14] + | |--EXPR -> EXPR [262:8] + | | `--INC -> ++ [262:8] + | | `--IDENT -> vint [262:10] + | |--SEMI -> ; [262:14] + | |--EXPR -> EXPR [263:8] + | | `--DEC -> -- [263:8] + | | `--IDENT -> vint [263:10] + | |--SEMI -> ; [263:14] + | |--VARIABLE_DEF -> VARIABLE_DEF [264:14] + | | |--MODIFIERS -> MODIFIERS [264:14] + | | |--TYPE -> TYPE [264:14] + | | | `--ARRAY_DECLARATOR -> [ [264:14] + | | | |--IDENT -> String [264:8] + | | | `--RBRACK -> ] [264:15] + | | |--IDENT -> arrayinit [264:17] + | | `--ASSIGN -> = [264:27] + | | `--ARRAY_INIT -> { [264:29] + | | `--RCURLY -> } [264:30] + | |--SEMI -> ; [264:31] + | |--VARIABLE_DEF -> VARIABLE_DEF [265:14] + | | |--MODIFIERS -> MODIFIERS [265:14] + | | |--TYPE -> TYPE [265:14] + | | | `--ARRAY_DECLARATOR -> [ [265:14] + | | | |--IDENT -> String [265:8] + | | | `--RBRACK -> ] [265:15] + | | |--IDENT -> arrayinit2 [265:17] + | | `--ASSIGN -> = [265:28] + | | `--ARRAY_INIT -> { [265:30] + | | |--EXPR -> EXPR [265:31] + | | | `--STRING_LITERAL -> "" [265:31] + | | `--RCURLY -> } [265:33] + | |--SEMI -> ; [265:34] + | |--VARIABLE_DEF -> VARIABLE_DEF [266:14] + | | |--MODIFIERS -> MODIFIERS [266:14] + | | |--TYPE -> TYPE [266:14] + | | | `--ARRAY_DECLARATOR -> [ [266:14] + | | | |--IDENT -> String [266:8] + | | | `--RBRACK -> ] [266:15] + | | |--IDENT -> arrayinit3 [266:17] + | | `--ASSIGN -> = [266:28] + | | `--ARRAY_INIT -> { [266:30] + | | |--EXPR -> EXPR [266:31] + | | | `--STRING_LITERAL -> "" [266:31] + | | |--COMMA -> , [266:33] + | | |--EXPR -> EXPR [266:35] + | | | `--STRING_LITERAL -> "" [266:35] + | | |--COMMA -> , [266:37] + | | `--RCURLY -> } [266:38] + | |--SEMI -> ; [266:39] + | |--EXPR -> EXPR [269:15] + | | `--ASSIGN -> = [269:15] + | | |--IDENT -> varray [269:8] + | | `--LITERAL_NEW -> new [269:17] + | | |--LITERAL_INT -> int [269:21] + | | |--ARRAY_DECLARATOR -> [ [269:24] + | | | `--RBRACK -> ] [269:25] + | | `--ARRAY_INIT -> { [269:26] + | | `--RCURLY -> } [269:27] + | |--SEMI -> ; [269:28] + | |--EXPR -> EXPR [270:15] + | | `--ASSIGN -> = [270:15] + | | |--IDENT -> varray [270:8] + | | `--LITERAL_NEW -> new [270:17] + | | |--LITERAL_INT -> int [270:21] + | | |--ARRAY_DECLARATOR -> [ [270:24] + | | | `--RBRACK -> ] [270:25] + | | `--ARRAY_INIT -> { [270:26] + | | |--EXPR -> EXPR [270:27] + | | | `--NUM_INT -> 0 [270:27] + | | `--RCURLY -> } [270:28] + | |--SEMI -> ; [270:29] + | |--EXPR -> EXPR [271:15] + | | `--ASSIGN -> = [271:15] + | | |--IDENT -> varray [271:8] + | | `--LITERAL_NEW -> new [271:17] + | | |--LITERAL_INT -> int [271:21] + | | |--ARRAY_DECLARATOR -> [ [271:24] + | | | `--RBRACK -> ] [271:25] + | | `--ARRAY_INIT -> { [271:26] + | | |--EXPR -> EXPR [271:27] + | | | `--NUM_INT -> 0 [271:27] + | | |--COMMA -> , [271:28] + | | |--EXPR -> EXPR [271:30] + | | | `--NUM_INT -> 1 [271:30] + | | `--RCURLY -> } [271:31] + | |--SEMI -> ; [271:32] + | |--EXPR -> EXPR [272:15] + | | `--ASSIGN -> = [272:15] + | | |--IDENT -> varray [272:8] + | | `--LITERAL_NEW -> new [272:17] + | | |--LITERAL_INT -> int [272:21] + | | `--ARRAY_DECLARATOR -> [ [272:24] + | | |--EXPR -> EXPR [272:25] + | | | `--NUM_INT -> 5 [272:25] + | | `--RBRACK -> ] [272:26] + | |--SEMI -> ; [272:27] + | |--EXPR -> EXPR [273:14] + | | `--ASSIGN -> = [273:14] + | | |--IDENT -> vlist [273:8] + | | `--LITERAL_NEW -> new [273:16] + | | |--IDENT -> ArrayList [273:20] + | | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [273:29] + | | | |--GENERIC_START -> < [273:29] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [273:30] + | | | | `--IDENT -> String [273:30] + | | | `--GENERIC_END -> > [273:36] + | | |--LPAREN -> ( [273:37] + | | |--ELIST -> ELIST [273:38] + | | `--RPAREN -> ) [273:38] + | |--SEMI -> ; [273:39] + | |--EXPR -> EXPR [274:13] + | | `--ASSIGN -> = [274:13] + | | |--IDENT -> vmap [274:8] + | | `--LITERAL_NEW -> new [274:15] + | | |--IDENT -> HashMap [274:19] + | | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [274:26] + | | | |--GENERIC_START -> < [274:26] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [274:27] + | | | | `--IDENT -> String [274:27] + | | | |--COMMA -> , [274:33] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [274:41] + | | | | `--ARRAY_DECLARATOR -> [ [274:41] + | | | | |--IDENT -> String [274:35] + | | | | `--RBRACK -> ] [274:42] + | | | `--GENERIC_END -> > [274:43] + | | |--LPAREN -> ( [274:44] + | | |--ELIST -> ELIST [274:45] + | | `--RPAREN -> ) [274:45] + | |--SEMI -> ; [274:46] + | |--VARIABLE_DEF -> VARIABLE_DEF [275:8] + | | |--MODIFIERS -> MODIFIERS [275:8] + | | |--TYPE -> TYPE [275:8] + | | | `--IDENT -> Object [275:8] + | | |--IDENT -> anonymous [275:15] + | | `--ASSIGN -> = [275:25] + | | `--EXPR -> EXPR [275:27] + | | `--LITERAL_NEW -> new [275:27] + | | |--IDENT -> InputRegressionJavaClass1 [275:31] + | | |--LPAREN -> ( [275:56] + | | |--ELIST -> ELIST [275:57] + | | |--RPAREN -> ) [275:57] + | | `--OBJBLOCK -> OBJBLOCK [275:59] + | | |--LCURLY -> { [275:59] + | | `--RCURLY -> } [275:60] + | |--SEMI -> ; [275:61] + | |--EMPTY_STAT -> ; [278:8] + | |--EXPR -> EXPR [279:16] + | | `--ASSIGN -> = [279:16] + | | |--DOT -> . [279:12] + | | | |--LITERAL_THIS -> this [279:8] + | | | `--IDENT -> f1 [279:13] + | | `--NUM_INT -> 0 [279:18] + | |--SEMI -> ; [279:19] + | |--LABELED_STAT -> : [282:19] + | | |--IDENT -> test_label1 [282:8] + | | `--SLIST -> { [285:8] + | | `--RCURLY -> } [285:9] + | |--LITERAL_IF -> if [286:8] + | | |--LPAREN -> ( [286:11] + | | |--EXPR -> EXPR [286:12] + | | | `--LITERAL_TRUE -> true [286:12] + | | |--RPAREN -> ) [286:16] + | | `--EMPTY_STAT -> ; [286:18] + | |--LITERAL_IF -> if [287:8] + | | |--LPAREN -> ( [287:11] + | | |--EXPR -> EXPR [287:12] + | | | `--LITERAL_TRUE -> true [287:12] + | | |--RPAREN -> ) [287:16] + | | `--SLIST -> { [287:18] + | | `--RCURLY -> } [287:19] + | |--LITERAL_IF -> if [288:8] + | | |--LPAREN -> ( [288:11] + | | |--EXPR -> EXPR [288:12] + | | | `--LITERAL_TRUE -> true [288:12] + | | |--RPAREN -> ) [288:16] + | | |--SLIST -> { [288:18] + | | | `--RCURLY -> } [288:19] + | | `--LITERAL_ELSE -> else [288:21] + | | `--EMPTY_STAT -> ; [288:26] + | |--LITERAL_IF -> if [289:8] + | | |--LPAREN -> ( [289:11] + | | |--EXPR -> EXPR [289:12] + | | | `--LITERAL_TRUE -> true [289:12] + | | |--RPAREN -> ) [289:16] + | | |--SLIST -> { [289:18] + | | | `--RCURLY -> } [289:19] + | | `--LITERAL_ELSE -> else [289:21] + | | `--SLIST -> { [289:26] + | | `--RCURLY -> } [289:27] + | |--LITERAL_IF -> if [290:8] + | | |--LPAREN -> ( [290:11] + | | |--EXPR -> EXPR [290:12] + | | | `--IDENT -> b [290:12] + | | |--RPAREN -> ) [290:13] + | | `--SLIST -> { [290:15] + | | |--LITERAL_FOR -> for [290:17] + | | | |--LPAREN -> ( [290:21] + | | | |--FOR_INIT -> FOR_INIT [290:22] + | | | |--SEMI -> ; [290:22] + | | | |--FOR_CONDITION -> FOR_CONDITION [290:23] + | | | |--SEMI -> ; [290:23] + | | | |--FOR_ITERATOR -> FOR_ITERATOR [290:24] + | | | |--RPAREN -> ) [290:24] + | | | `--EMPTY_STAT -> ; [290:26] + | | `--RCURLY -> } [290:28] + | |--LITERAL_IF -> if [291:8] + | | |--LPAREN -> ( [291:11] + | | |--EXPR -> EXPR [291:12] + | | | `--IDENT -> b [291:12] + | | |--RPAREN -> ) [291:13] + | | `--SLIST -> { [291:15] + | | |--LITERAL_FOR -> for [291:17] + | | | |--LPAREN -> ( [291:21] + | | | |--FOR_INIT -> FOR_INIT [291:22] + | | | |--SEMI -> ; [291:22] + | | | |--FOR_CONDITION -> FOR_CONDITION [291:23] + | | | |--SEMI -> ; [291:23] + | | | |--FOR_ITERATOR -> FOR_ITERATOR [291:24] + | | | |--RPAREN -> ) [291:24] + | | | `--SLIST -> { [291:26] + | | | `--RCURLY -> } [291:27] + | | `--RCURLY -> } [291:29] + | |--LITERAL_FOR -> for [292:8] + | | |--LPAREN -> ( [292:12] + | | |--FOR_INIT -> FOR_INIT [292:13] + | | | `--VARIABLE_DEF -> VARIABLE_DEF [292:13] + | | | |--MODIFIERS -> MODIFIERS [292:13] + | | | |--TYPE -> TYPE [292:13] + | | | | `--LITERAL_INT -> int [292:13] + | | | |--IDENT -> i [292:17] + | | | `--ASSIGN -> = [292:19] + | | | `--EXPR -> EXPR [292:21] + | | | `--NUM_INT -> 0 [292:21] + | | |--SEMI -> ; [292:22] + | | |--FOR_CONDITION -> FOR_CONDITION [292:26] + | | | `--EXPR -> EXPR [292:26] + | | | `--LT -> < [292:26] + | | | |--IDENT -> i [292:24] + | | | `--NUM_INT -> 1 [292:28] + | | |--SEMI -> ; [292:29] + | | |--FOR_ITERATOR -> FOR_ITERATOR [292:32] + | | | `--ELIST -> ELIST [292:32] + | | | `--EXPR -> EXPR [292:32] + | | | `--POST_INC -> ++ [292:32] + | | | `--IDENT -> i [292:31] + | | |--RPAREN -> ) [292:34] + | | `--SLIST -> { [292:36] + | | `--RCURLY -> } [292:37] + | |--LITERAL_FOR -> for [293:8] + | | |--LPAREN -> ( [293:12] + | | |--FOR_INIT -> FOR_INIT [293:13] + | | | |--VARIABLE_DEF -> VARIABLE_DEF [293:13] + | | | | |--MODIFIERS -> MODIFIERS [293:13] + | | | | |--TYPE -> TYPE [293:13] + | | | | | `--LITERAL_INT -> int [293:13] + | | | | |--IDENT -> i [293:17] + | | | | `--ASSIGN -> = [293:19] + | | | | `--EXPR -> EXPR [293:21] + | | | | `--NUM_INT -> 0 [293:21] + | | | |--COMMA -> , [293:22] + | | | `--VARIABLE_DEF -> VARIABLE_DEF [293:13] + | | | |--MODIFIERS -> MODIFIERS [293:13] + | | | |--TYPE -> TYPE [293:13] + | | | | `--LITERAL_INT -> int [293:13] + | | | |--IDENT -> j [293:24] + | | | `--ASSIGN -> = [293:26] + | | | `--EXPR -> EXPR [293:28] + | | | `--NUM_INT -> 0 [293:28] + | | |--SEMI -> ; [293:29] + | | |--FOR_CONDITION -> FOR_CONDITION [293:33] + | | | `--EXPR -> EXPR [293:33] + | | | `--LT -> < [293:33] + | | | |--IDENT -> i [293:31] + | | | `--NUM_INT -> 1 [293:35] + | | |--SEMI -> ; [293:36] + | | |--FOR_ITERATOR -> FOR_ITERATOR [293:39] + | | | `--ELIST -> ELIST [293:39] + | | | |--EXPR -> EXPR [293:39] + | | | | `--POST_INC -> ++ [293:39] + | | | | `--IDENT -> i [293:38] + | | | |--COMMA -> , [293:41] + | | | `--EXPR -> EXPR [293:45] + | | | `--PLUS_ASSIGN -> += [293:45] + | | | |--IDENT -> j [293:43] + | | | `--NUM_INT -> 2 [293:48] + | | |--RPAREN -> ) [293:49] + | | `--SLIST -> { [293:51] + | | `--RCURLY -> } [293:52] + | |--LITERAL_FOR -> for [294:8] + | | |--LPAREN -> ( [294:12] + | | |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [294:13] + | | | |--VARIABLE_DEF -> VARIABLE_DEF [294:13] + | | | | |--MODIFIERS -> MODIFIERS [294:13] + | | | | |--TYPE -> TYPE [294:13] + | | | | | `--LITERAL_INT -> int [294:13] + | | | | `--IDENT -> value [294:17] + | | | |--COLON -> : [294:22] + | | | `--EXPR -> EXPR [294:24] + | | | `--LITERAL_NEW -> new [294:24] + | | | |--LITERAL_INT -> int [294:28] + | | | |--ARRAY_DECLARATOR -> [ [294:31] + | | | | `--RBRACK -> ] [294:32] + | | | `--ARRAY_INIT -> { [294:33] + | | | `--RCURLY -> } [294:34] + | | |--RPAREN -> ) [294:35] + | | `--EMPTY_STAT -> ; [294:37] + | |--LITERAL_FOR -> for [295:8] + | | |--LPAREN -> ( [295:12] + | | |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [295:13] + | | | |--VARIABLE_DEF -> VARIABLE_DEF [295:13] + | | | | |--MODIFIERS -> MODIFIERS [295:13] + | | | | |--TYPE -> TYPE [295:13] + | | | | | `--IDENT -> String [295:13] + | | | | `--IDENT -> s [295:20] + | | | |--COLON -> : [295:22] + | | | `--EXPR -> EXPR [295:24] + | | | `--LITERAL_NEW -> new [295:24] + | | | |--IDENT -> String [295:28] + | | | |--ARRAY_DECLARATOR -> [ [295:34] + | | | | `--RBRACK -> ] [295:35] + | | | `--ARRAY_INIT -> { [295:36] + | | | `--RCURLY -> } [295:37] + | | |--RPAREN -> ) [295:38] + | | `--EMPTY_STAT -> ; [295:40] + | |--LITERAL_FOR -> for [296:8] + | | |--LPAREN -> ( [296:12] + | | |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [296:13] + | | | |--VARIABLE_DEF -> VARIABLE_DEF [296:13] + | | | | |--MODIFIERS -> MODIFIERS [296:13] + | | | | | `--FINAL -> final [296:13] + | | | | |--TYPE -> TYPE [296:19] + | | | | | `--IDENT -> String [296:19] + | | | | `--IDENT -> s [296:26] + | | | |--COLON -> : [296:28] + | | | `--EXPR -> EXPR [296:30] + | | | `--LITERAL_NEW -> new [296:30] + | | | |--IDENT -> String [296:34] + | | | |--ARRAY_DECLARATOR -> [ [296:40] + | | | | `--RBRACK -> ] [296:41] + | | | `--ARRAY_INIT -> { [296:42] + | | | `--RCURLY -> } [296:43] + | | |--RPAREN -> ) [296:44] + | | `--EMPTY_STAT -> ; [296:46] + | |--LITERAL_IF -> if [297:8] + | | |--LPAREN -> ( [297:11] + | | |--EXPR -> EXPR [297:12] + | | | `--IDENT -> b [297:12] + | | |--RPAREN -> ) [297:13] + | | `--SLIST -> { [297:15] + | | |--LITERAL_WHILE -> while [297:17] + | | | |--LPAREN -> ( [297:23] + | | | |--EXPR -> EXPR [297:24] + | | | | `--LITERAL_TRUE -> true [297:24] + | | | |--RPAREN -> ) [297:28] + | | | `--EMPTY_STAT -> ; [297:30] + | | `--RCURLY -> } [297:32] + | |--LITERAL_IF -> if [298:8] + | | |--LPAREN -> ( [298:11] + | | |--EXPR -> EXPR [298:12] + | | | `--IDENT -> b [298:12] + | | |--RPAREN -> ) [298:13] + | | `--SLIST -> { [298:15] + | | |--LITERAL_WHILE -> while [298:17] + | | | |--LPAREN -> ( [298:23] + | | | |--EXPR -> EXPR [298:24] + | | | | `--LITERAL_TRUE -> true [298:24] + | | | |--RPAREN -> ) [298:28] + | | | `--SLIST -> { [298:30] + | | | `--RCURLY -> } [298:31] + | | `--RCURLY -> } [298:33] + | |--LITERAL_DO -> do [299:8] + | | |--SLIST -> { [299:11] + | | | `--RCURLY -> } [299:12] + | | |--DO_WHILE -> while [299:14] + | | |--LPAREN -> ( [299:20] + | | |--EXPR -> EXPR [299:21] + | | | `--LITERAL_FALSE -> false [299:21] + | | |--RPAREN -> ) [299:26] + | | `--SEMI -> ; [299:27] + | |--LITERAL_SYNCHRONIZED -> synchronized [300:8] + | | |--LPAREN -> ( [300:21] + | | |--EXPR -> EXPR [300:22] + | | | `--IDENT -> f9 [300:22] + | | |--RPAREN -> ) [300:24] + | | `--SLIST -> { [300:26] + | | `--RCURLY -> } [300:27] + | |--LITERAL_SWITCH -> switch [302:8] + | | |--LPAREN -> ( [302:15] + | | |--EXPR -> EXPR [302:16] + | | | `--NUM_INT -> 0 [302:16] + | | |--RPAREN -> ) [302:17] + | | |--LCURLY -> { [302:19] + | | |--CASE_GROUP -> CASE_GROUP [303:12] + | | | |--LITERAL_CASE -> case [303:12] + | | | | |--EXPR -> EXPR [303:17] + | | | | | `--NUM_INT -> 1 [303:17] + | | | | `--COLON -> : [303:18] + | | | |--LITERAL_CASE -> case [304:12] + | | | | |--EXPR -> EXPR [304:17] + | | | | | `--NUM_INT -> 0 [304:17] + | | | | `--COLON -> : [304:18] + | | | `--SLIST -> SLIST [304:20] + | | | `--LITERAL_BREAK -> break [304:20] + | | | `--SEMI -> ; [304:25] + | | |--CASE_GROUP -> CASE_GROUP [305:12] + | | | |--LITERAL_DEFAULT -> default [305:12] + | | | | `--COLON -> : [305:19] + | | | `--SLIST -> SLIST [305:21] + | | | `--LITERAL_BREAK -> break [305:21] + | | | `--SEMI -> ; [305:26] + | | `--RCURLY -> } [306:8] + | |--LITERAL_TRY -> try [308:8] + | | |--SLIST -> { [308:12] + | | | |--LITERAL_IF -> if [309:12] + | | | | |--LPAREN -> ( [309:15] + | | | | |--EXPR -> EXPR [309:16] + | | | | | `--IDENT -> b [309:16] + | | | | |--RPAREN -> ) [309:17] + | | | | `--SLIST -> { [309:19] + | | | | |--LITERAL_THROW -> throw [309:21] + | | | | | |--EXPR -> EXPR [309:27] + | | | | | | `--LITERAL_NEW -> new [309:27] + | | | | | | |--IDENT -> IOException [309:31] + | | | | | | |--LPAREN -> ( [309:42] + | | | | | | |--ELIST -> ELIST [309:43] + | | | | | | `--RPAREN -> ) [309:43] + | | | | | `--SEMI -> ; [309:44] + | | | | `--RCURLY -> } [309:46] + | | | |--LITERAL_IF -> if [310:12] + | | | | |--LPAREN -> ( [310:15] + | | | | |--EXPR -> EXPR [310:16] + | | | | | `--IDENT -> b [310:16] + | | | | |--RPAREN -> ) [310:17] + | | | | `--SLIST -> { [310:19] + | | | | |--LITERAL_THROW -> throw [310:21] + | | | | | |--EXPR -> EXPR [310:27] + | | | | | | `--LITERAL_NEW -> new [310:27] + | | | | | | |--IDENT -> ArrayIndexOutOfBoundsException [310:31] + | | | | | | |--LPAREN -> ( [310:61] + | | | | | | |--ELIST -> ELIST [310:62] + | | | | | | `--RPAREN -> ) [310:62] + | | | | | `--SEMI -> ; [310:63] + | | | | `--RCURLY -> } [310:65] + | | | |--LITERAL_THROW -> throw [311:12] + | | | | |--EXPR -> EXPR [311:18] + | | | | | `--LITERAL_NEW -> new [311:18] + | | | | | |--IDENT -> Exception [311:22] + | | | | | |--LPAREN -> ( [311:31] + | | | | | |--ELIST -> ELIST [311:32] + | | | | | `--RPAREN -> ) [311:32] + | | | | `--SEMI -> ; [311:33] + | | | `--RCURLY -> } [312:8] + | | |--LITERAL_CATCH -> catch [312:10] + | | | |--LPAREN -> ( [312:16] + | | | |--PARAMETER_DEF -> PARAMETER_DEF [312:29] + | | | | |--MODIFIERS -> MODIFIERS [312:29] + | | | | |--TYPE -> TYPE [312:29] + | | | | | `--BOR -> | [312:29] + | | | | | |--IDENT -> IOException [312:17] + | | | | | `--IDENT -> ArrayIndexOutOfBoundsException [312:31] + | | | | `--IDENT -> e [312:62] + | | | |--RPAREN -> ) [312:63] + | | | `--SLIST -> { [312:65] + | | | `--RCURLY -> } [313:8] + | | |--LITERAL_CATCH -> catch [313:10] + | | | |--LPAREN -> ( [313:16] + | | | |--PARAMETER_DEF -> PARAMETER_DEF [313:17] + | | | | |--MODIFIERS -> MODIFIERS [313:17] + | | | | |--TYPE -> TYPE [313:17] + | | | | | `--IDENT -> Exception [313:17] + | | | | `--IDENT -> e [313:27] + | | | |--RPAREN -> ) [313:28] + | | | `--SLIST -> { [313:30] + | | | `--RCURLY -> } [314:8] + | | `--LITERAL_FINALLY -> finally [314:10] + | | `--SLIST -> { [314:18] + | | `--RCURLY -> } [314:19] + | |--LITERAL_TRY -> try [315:8] + | | |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [315:12] + | | | |--LPAREN -> ( [315:12] + | | | |--RESOURCES -> RESOURCES [315:13] + | | | | `--RESOURCE -> RESOURCE [315:13] + | | | | |--MODIFIERS -> MODIFIERS [315:13] + | | | | |--TYPE -> TYPE [315:13] + | | | | | `--IDENT -> BufferedReader [315:13] + | | | | |--IDENT -> br [315:28] + | | | | `--ASSIGN -> = [315:31] + | | | | `--EXPR -> EXPR [315:33] + | | | | `--LITERAL_NEW -> new [315:33] + | | | | |--IDENT -> BufferedReader [315:37] + | | | | |--LPAREN -> ( [315:51] + | | | | |--ELIST -> ELIST [315:52] + | | | | | `--EXPR -> EXPR [315:52] + | | | | | `--LITERAL_NEW -> new [315:52] + | | | | | |--IDENT -> FileReader [315:56] + | | | | | |--LPAREN -> ( [315:66] + | | | | | |--ELIST -> ELIST [315:67] + | | | | | | `--EXPR -> EXPR [315:67] + | | | | | | `--STRING_LITERAL -> "" [315:67] + | | | | | `--RPAREN -> ) [315:69] + | | | | `--RPAREN -> ) [315:70] + | | | `--RPAREN -> ) [315:71] + | | `--SLIST -> { [315:73] + | | `--RCURLY -> } [315:74] + | |--LITERAL_TRY -> try [316:8] + | | |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [316:12] + | | | |--LPAREN -> ( [316:12] + | | | |--RESOURCES -> RESOURCES [316:13] + | | | | |--RESOURCE -> RESOURCE [316:13] + | | | | | |--MODIFIERS -> MODIFIERS [316:13] + | | | | | |--TYPE -> TYPE [316:13] + | | | | | | `--IDENT -> BufferedReader [316:13] + | | | | | |--IDENT -> br1 [316:28] + | | | | | `--ASSIGN -> = [316:32] + | | | | | `--EXPR -> EXPR [316:34] + | | | | | `--LITERAL_NEW -> new [316:34] + | | | | | |--IDENT -> BufferedReader [316:38] + | | | | | |--LPAREN -> ( [316:52] + | | | | | |--ELIST -> ELIST [316:53] + | | | | | | `--EXPR -> EXPR [316:53] + | | | | | | `--LITERAL_NEW -> new [316:53] + | | | | | | |--IDENT -> FileReader [316:57] + | | | | | | |--LPAREN -> ( [316:67] + | | | | | | |--ELIST -> ELIST [316:68] + | | | | | | | `--EXPR -> EXPR [316:68] + | | | | | | | `--STRING_LITERAL -> "" [316:68] + | | | | | | `--RPAREN -> ) [316:70] + | | | | | `--RPAREN -> ) [316:71] + | | | | |--SEMI -> ; [316:72] + | | | | `--RESOURCE -> RESOURCE [317:16] + | | | | |--MODIFIERS -> MODIFIERS [317:16] + | | | | |--TYPE -> TYPE [317:16] + | | | | | `--IDENT -> BufferedReader [317:16] + | | | | |--IDENT -> br2 [317:31] + | | | | `--ASSIGN -> = [317:35] + | | | | `--EXPR -> EXPR [317:37] + | | | | `--LITERAL_NEW -> new [317:37] + | | | | |--IDENT -> BufferedReader [317:41] + | | | | |--LPAREN -> ( [317:55] + | | | | |--ELIST -> ELIST [317:56] + | | | | | `--EXPR -> EXPR [317:56] + | | | | | `--LITERAL_NEW -> new [317:56] + | | | | | |--IDENT -> FileReader [317:60] + | | | | | |--LPAREN -> ( [317:70] + | | | | | |--ELIST -> ELIST [317:71] + | | | | | | `--EXPR -> EXPR [317:71] + | | | | | | `--STRING_LITERAL -> "" [317:71] + | | | | | `--RPAREN -> ) [317:73] + | | | | `--RPAREN -> ) [317:74] + | | | |--SEMI -> ; [317:75] + | | | `--RPAREN -> ) [317:76] + | | `--SLIST -> { [317:78] + | | `--RCURLY -> } [317:79] + | |--EXPR -> EXPR [320:14] + | | `--ASSIGN -> = [320:14] + | | |--IDENT -> test4 [320:8] + | | `--DOT -> . [320:41] + | | |--IDENT -> InputRegressionJavaClass1 [320:16] + | | `--LITERAL_CLASS -> class [320:42] + | |--SEMI -> ; [320:47] + | |--EXPR -> EXPR [321:14] + | | `--ASSIGN -> = [321:14] + | | |--IDENT -> test4 [321:8] + | | `--DOT -> . [321:22] + | | |--ARRAY_DECLARATOR -> [ [321:20] + | | | |--IDENT -> List [321:16] + | | | `--RBRACK -> ] [321:21] + | | `--LITERAL_CLASS -> class [321:23] + | |--SEMI -> ; [321:28] + | |--EXPR -> EXPR [322:14] + | | `--ASSIGN -> = [322:14] + | | |--IDENT -> test4 [322:8] + | | `--DOT -> . [322:25] + | | |--ARRAY_DECLARATOR -> [ [322:23] + | | | |--LITERAL_BOOLEAN -> boolean [322:16] + | | | `--RBRACK -> ] [322:24] + | | `--LITERAL_CLASS -> class [322:26] + | |--SEMI -> ; [322:31] + | |--EXPR -> EXPR [323:18] + | | `--ASSIGN -> = [323:18] + | | |--INDEX_OP -> [ [323:14] + | | | |--IDENT -> varray [323:8] + | | | |--EXPR -> EXPR [323:15] + | | | | `--NUM_INT -> 0 [323:15] + | | | `--RBRACK -> ] [323:16] + | | `--NUM_INT -> 0 [323:20] + | |--SEMI -> ; [323:21] + | |--LITERAL_FOR -> for [324:8] + | | |--LPAREN -> ( [324:12] + | | |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [324:19] + | | | |--VARIABLE_DEF -> VARIABLE_DEF [324:19] + | | | | |--MODIFIERS -> MODIFIERS [324:19] + | | | | |--TYPE -> TYPE [324:19] + | | | | | `--ARRAY_DECLARATOR -> [ [324:19] + | | | | | |--IDENT -> String [324:13] + | | | | | `--RBRACK -> ] [324:20] + | | | | `--IDENT -> s [324:22] + | | | |--COLON -> : [324:24] + | | | `--EXPR -> EXPR [324:26] + | | | `--LITERAL_NEW -> new [324:26] + | | | |--IDENT -> String [324:30] + | | | |--ARRAY_DECLARATOR -> [ [324:38] + | | | | |--ARRAY_DECLARATOR -> [ [324:36] + | | | | | `--RBRACK -> ] [324:37] + | | | | `--RBRACK -> ] [324:39] + | | | `--ARRAY_INIT -> { [324:40] + | | | |--ARRAY_INIT -> { [324:41] + | | | | `--RCURLY -> } [324:42] + | | | `--RCURLY -> } [324:43] + | | |--RPAREN -> ) [324:44] + | | `--EMPTY_STAT -> ; [324:46] + | |--LITERAL_FOR -> for [325:8] + | | |--LPAREN -> ( [325:12] + | | |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [325:16] + | | | |--VARIABLE_DEF -> VARIABLE_DEF [325:16] + | | | | |--MODIFIERS -> MODIFIERS [325:16] + | | | | |--TYPE -> TYPE [325:16] + | | | | | `--DOT -> . [325:16] + | | | | | |--IDENT -> Map [325:13] + | | | | | |--IDENT -> Entry [325:17] + | | | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [325:22] + | | | | | |--GENERIC_START -> < [325:22] + | | | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [325:23] + | | | | | | `--IDENT -> String [325:23] + | | | | | |--COMMA -> , [325:29] + | | | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [325:37] + | | | | | | `--ARRAY_DECLARATOR -> [ [325:37] + | | | | | | |--IDENT -> String [325:31] + | | | | | | `--RBRACK -> ] [325:38] + | | | | | `--GENERIC_END -> > [325:39] + | | | | `--IDENT -> e [325:41] + | | | |--COLON -> : [325:43] + | | | `--EXPR -> EXPR [325:58] + | | | `--METHOD_CALL -> ( [325:58] + | | | |--DOT -> . [325:49] + | | | | |--IDENT -> vmap [325:45] + | | | | `--IDENT -> entrySet [325:50] + | | | |--ELIST -> ELIST [325:59] + | | | `--RPAREN -> ) [325:59] + | | |--RPAREN -> ) [325:60] + | | `--SLIST -> { [325:62] + | | `--RCURLY -> } [325:64] + | |--LITERAL_FOR -> for [328:8] + | | |--LPAREN -> ( [328:12] + | | |--FOR_INIT -> FOR_INIT [328:13] + | | |--SEMI -> ; [328:13] + | | |--FOR_CONDITION -> FOR_CONDITION [328:14] + | | |--SEMI -> ; [328:14] + | | |--FOR_ITERATOR -> FOR_ITERATOR [328:15] + | | |--RPAREN -> ) [328:15] + | | `--SLIST -> { [328:17] + | | |--LITERAL_BREAK -> break [328:18] + | | | `--SEMI -> ; [328:23] + | | `--RCURLY -> } [328:24] + | |--LABELED_STAT -> : [329:19] + | | |--IDENT -> test_label2 [329:8] + | | `--LITERAL_FOR -> for [330:8] + | | |--LPAREN -> ( [330:12] + | | |--FOR_INIT -> FOR_INIT [330:13] + | | |--SEMI -> ; [330:13] + | | |--FOR_CONDITION -> FOR_CONDITION [330:14] + | | |--SEMI -> ; [330:14] + | | |--FOR_ITERATOR -> FOR_ITERATOR [330:15] + | | |--RPAREN -> ) [330:15] + | | `--SLIST -> { [330:17] + | | |--LITERAL_BREAK -> break [330:18] + | | | |--IDENT -> test_label2 [330:24] + | | | `--SEMI -> ; [330:35] + | | `--RCURLY -> } [330:36] + | |--LITERAL_IF -> if [331:8] + | | |--LPAREN -> ( [331:11] + | | |--EXPR -> EXPR [331:12] + | | | `--IDENT -> b [331:12] + | | |--RPAREN -> ) [331:13] + | | `--SLIST -> { [331:15] + | | |--LITERAL_FOR -> for [331:17] + | | | |--LPAREN -> ( [331:21] + | | | |--FOR_INIT -> FOR_INIT [331:22] + | | | |--SEMI -> ; [331:22] + | | | |--FOR_CONDITION -> FOR_CONDITION [331:23] + | | | |--SEMI -> ; [331:23] + | | | |--FOR_ITERATOR -> FOR_ITERATOR [331:24] + | | | |--RPAREN -> ) [331:24] + | | | `--SLIST -> { [331:26] + | | | |--LITERAL_CONTINUE -> continue [331:27] + | | | | `--SEMI -> ; [331:35] + | | | `--RCURLY -> } [331:36] + | | `--RCURLY -> } [331:38] + | |--LITERAL_IF -> if [332:8] + | | |--LPAREN -> ( [332:11] + | | |--EXPR -> EXPR [332:12] + | | | `--IDENT -> b [332:12] + | | |--RPAREN -> ) [332:13] + | | `--SLIST -> { [332:15] + | | |--LABELED_STAT -> : [332:28] + | | | |--IDENT -> test_label3 [332:17] + | | | `--LITERAL_FOR -> for [332:30] + | | | |--LPAREN -> ( [332:34] + | | | |--FOR_INIT -> FOR_INIT [332:35] + | | | |--SEMI -> ; [332:35] + | | | |--FOR_CONDITION -> FOR_CONDITION [332:36] + | | | |--SEMI -> ; [332:36] + | | | |--FOR_ITERATOR -> FOR_ITERATOR [332:37] + | | | |--RPAREN -> ) [332:37] + | | | `--SLIST -> { [332:39] + | | | |--LITERAL_CONTINUE -> continue [332:40] + | | | | |--IDENT -> test_label3 [332:49] + | | | | `--SEMI -> ; [332:60] + | | | `--RCURLY -> } [332:61] + | | `--RCURLY -> } [332:63] + | |--LITERAL_IF -> if [333:8] + | | |--LPAREN -> ( [333:11] + | | |--EXPR -> EXPR [333:12] + | | | `--LITERAL_FALSE -> false [333:12] + | | |--RPAREN -> ) [333:17] + | | `--LITERAL_RETURN -> return [333:19] + | | `--SEMI -> ; [333:25] + | |--LITERAL_IF -> if [334:8] + | | |--LPAREN -> ( [334:11] + | | |--EXPR -> EXPR [334:12] + | | | `--LITERAL_FALSE -> false [334:12] + | | |--RPAREN -> ) [334:17] + | | `--LITERAL_THROW -> throw [334:19] + | | |--EXPR -> EXPR [334:25] + | | | `--LITERAL_NEW -> new [334:25] + | | | |--IDENT -> Exception [334:29] + | | | |--LPAREN -> ( [334:38] + | | | |--ELIST -> ELIST [334:39] + | | | `--RPAREN -> ) [334:39] + | | `--SEMI -> ; [334:40] + | |--LITERAL_ASSERT -> assert [335:8] + | | |--EXPR -> EXPR [335:14] + | | | |--LPAREN -> ( [335:14] + | | | |--LITERAL_FALSE -> false [335:15] + | | | `--RPAREN -> ) [335:20] + | | `--SEMI -> ; [335:21] + | |--LITERAL_ASSERT -> assert [336:8] + | | |--EXPR -> EXPR [336:15] + | | | `--LITERAL_TRUE -> true [336:15] + | | |--COLON -> : [336:20] + | | |--EXPR -> EXPR [336:22] + | | | `--STRING_LITERAL -> "false" [336:22] + | | `--SEMI -> ; [336:29] + | |--EXPR -> EXPR [337:11] + | | `--ASSIGN -> = [337:11] + | | |--IDENT -> f9 [337:8] + | | `--TYPECAST -> ( [337:13] + | | |--TYPE -> TYPE [337:14] + | | | `--IDENT -> Object [337:14] + | | |--RPAREN -> ) [337:20] + | | `--IDENT -> f9 [337:22] + | |--SEMI -> ; [337:24] + | |--EXPR -> EXPR [338:17] + | | `--METHOD_CALL -> ( [338:17] + | | |--DOT -> . [338:10] + | | | |--IDENT -> f9 [338:8] + | | | `--IDENT -> equals [338:11] + | | |--ELIST -> ELIST [338:18] + | | | `--EXPR -> EXPR [338:18] + | | | |--LPAREN -> ( [338:18] + | | | |--LPAREN -> ( [338:19] + | | | |--ASSIGN -> = [338:28] + | | | | |--IDENT -> vstring [338:20] + | | | | `--STRING_LITERAL -> "" [338:30] + | | | |--RPAREN -> ) [338:32] + | | | `--RPAREN -> ) [338:33] + | | `--RPAREN -> ) [338:34] + | |--SEMI -> ; [338:35] + | |--LITERAL_FOR -> for [339:8] + | | |--LPAREN -> ( [339:12] + | | |--FOR_INIT -> FOR_INIT [339:13] + | | | `--VARIABLE_DEF -> VARIABLE_DEF [339:13] + | | | |--MODIFIERS -> MODIFIERS [339:13] + | | | |--TYPE -> TYPE [339:13] + | | | | `--LITERAL_INT -> int [339:13] + | | | |--IDENT -> i [339:17] + | | | `--ASSIGN -> = [339:19] + | | | `--EXPR -> EXPR [339:21] + | | | `--NUM_INT -> 0 [339:21] + | | |--SEMI -> ; [339:22] + | | |--FOR_CONDITION -> FOR_CONDITION [339:24] + | | | `--EXPR -> EXPR [339:24] + | | | |--LPAREN -> ( [339:24] + | | | |--LT -> < [339:29] + | | | | |--LPAREN -> ( [339:25] + | | | | |--IDENT -> i [339:26] + | | | | |--RPAREN -> ) [339:27] + | | | | |--LPAREN -> ( [339:31] + | | | | |--PLUS -> + [339:33] + | | | | | |--NUM_INT -> 6 [339:32] + | | | | | `--NUM_INT -> 6 [339:34] + | | | | `--RPAREN -> ) [339:35] + | | | `--RPAREN -> ) [339:36] + | | |--SEMI -> ; [339:37] + | | |--FOR_ITERATOR -> FOR_ITERATOR [339:40] + | | | `--ELIST -> ELIST [339:40] + | | | `--EXPR -> EXPR [339:40] + | | | `--POST_INC -> ++ [339:40] + | | | `--IDENT -> i [339:39] + | | |--RPAREN -> ) [339:42] + | | `--EMPTY_STAT -> ; [339:44] + | |--LITERAL_IF -> if [340:8] + | | |--LPAREN -> ( [340:11] + | | |--EXPR -> EXPR [340:12] + | | | |--LPAREN -> ( [340:12] + | | | |--BAND -> & [340:15] + | | | | |--IDENT -> b [340:13] + | | | | `--IDENT -> b [340:17] + | | | `--RPAREN -> ) [340:18] + | | |--RPAREN -> ) [340:19] + | | `--SLIST -> { [340:21] + | | `--RCURLY -> } [340:22] + | |--EXPR -> EXPR [343:13] + | | `--ASSIGN -> = [343:13] + | | |--IDENT -> vint [343:8] + | | `--QUESTION -> ? [343:24] + | | |--IDENT -> vboolean [343:15] + | | |--LPAREN -> ( [343:26] + | | |--ASSIGN -> = [343:32] + | | | |--IDENT -> vint [343:27] + | | | `--NUM_INT -> 1 [343:34] + | | |--RPAREN -> ) [343:35] + | | |--COLON -> : [343:37] + | | |--LPAREN -> ( [343:39] + | | |--ASSIGN -> = [343:45] + | | | |--IDENT -> vint [343:40] + | | | `--NUM_INT -> 0 [343:47] + | | `--RPAREN -> ) [343:48] + | |--SEMI -> ; [343:49] + | |--EXPR -> EXPR [344:21] + | | `--ASSIGN -> = [344:21] + | | |--INDEX_OP -> [ [344:14] + | | | |--IDENT -> varray [344:8] + | | | |--EXPR -> EXPR [344:15] + | | | | `--IDENT -> vint [344:15] + | | | `--RBRACK -> ] [344:19] + | | `--METHOD_CALL -> ( [344:39] + | | |--DOT -> . [344:30] + | | | |--IDENT -> Integer [344:23] + | | | `--IDENT -> parseInt [344:31] + | | |--ELIST -> ELIST [344:40] + | | | `--EXPR -> EXPR [344:40] + | | | `--STRING_LITERAL -> "0" [344:40] + | | `--RPAREN -> ) [344:43] + | |--SEMI -> ; [344:44] + | `--RCURLY -> } [345:4] + |--ANNOTATION_DEF -> ANNOTATION_DEF [347:4] + | |--MODIFIERS -> MODIFIERS [347:4] + | | `--LITERAL_PUBLIC -> public [347:4] + | |--AT -> @ [347:11] + | |--LITERAL_INTERFACE -> interface [347:12] + | |--IDENT -> innerAnnotation [347:22] + | `--OBJBLOCK -> OBJBLOCK [347:38] + | |--LCURLY -> { [347:38] + | `--RCURLY -> } [347:39] + `--RCURLY -> } [348:0] diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaClass2.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaClass2.java new file mode 100644 index 000000000..591e9e699 --- /dev/null +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaClass2.java @@ -0,0 +1,41 @@ +package com.puppycrawl.tools.checkstyle.grammars; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +@SuppressWarnings("serial") +class InputRegressionJavaClass2 extends ArrayList implements List, Collection { + public InputRegressionJavaClass2() { super(); } + + @Override + public int size() { return super.size(); } + @Override() + public boolean isEmpty() { return InputRegressionJavaClass2.super.isEmpty(); } + + public class Inner1 { + public void m() { + class Inner2 { + } + }; + + public InputRegressionJavaClass2 m2() { + return InputRegressionJavaClass2.this; + } + } + + public void m() { this.new Inner1().m(); } +} +class _c1 {} +abstract class c2 {} +class c3 { public c3 m(){return null;} } +class c4 extends c3 { + class c4a {} + + public c4() { super(); } + public c3 m() { return super.m(); } +} +class c5 extends c4.c4a { + c5() { new c4().super(); } + c5(int a) { new c4().super(); } +} \ No newline at end of file diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaClass2Ast.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaClass2Ast.txt new file mode 100644 index 000000000..1bbccbda5 --- /dev/null +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaClass2Ast.txt @@ -0,0 +1,370 @@ +PACKAGE_DEF -> package [1:0] +|--ANNOTATIONS -> ANNOTATIONS [1:39] +|--DOT -> . [1:39] +| |--DOT -> . [1:28] +| | |--DOT -> . [1:22] +| | | |--DOT -> . [1:11] +| | | | |--IDENT -> com [1:8] +| | | | `--IDENT -> puppycrawl [1:12] +| | | `--IDENT -> tools [1:23] +| | `--IDENT -> checkstyle [1:29] +| `--IDENT -> grammars [1:40] +`--SEMI -> ; [1:48] +IMPORT -> import [3:0] +|--DOT -> . [3:16] +| |--DOT -> . [3:11] +| | |--IDENT -> java [3:7] +| | `--IDENT -> util [3:12] +| `--IDENT -> ArrayList [3:17] +`--SEMI -> ; [3:26] +IMPORT -> import [4:0] +|--DOT -> . [4:16] +| |--DOT -> . [4:11] +| | |--IDENT -> java [4:7] +| | `--IDENT -> util [4:12] +| `--IDENT -> Collection [4:17] +`--SEMI -> ; [4:27] +IMPORT -> import [5:0] +|--DOT -> . [5:16] +| |--DOT -> . [5:11] +| | |--IDENT -> java [5:7] +| | `--IDENT -> util [5:12] +| `--IDENT -> List [5:17] +`--SEMI -> ; [5:21] +CLASS_DEF -> CLASS_DEF [7:0] +|--MODIFIERS -> MODIFIERS [7:0] +| `--ANNOTATION -> ANNOTATION [7:0] +| |--AT -> @ [7:0] +| |--IDENT -> SuppressWarnings [7:1] +| |--LPAREN -> ( [7:17] +| |--EXPR -> EXPR [7:18] +| | `--STRING_LITERAL -> "serial" [7:18] +| `--RPAREN -> ) [7:26] +|--LITERAL_CLASS -> class [8:0] +|--IDENT -> InputRegressionJavaClass2 [8:6] +|--EXTENDS_CLAUSE -> extends [8:32] +| `--IDENT -> ArrayList [8:40] +|--IMPLEMENTS_CLAUSE -> implements [8:50] +| |--IDENT -> List [8:61] +| |--COMMA -> , [8:65] +| `--IDENT -> Collection [8:67] +`--OBJBLOCK -> OBJBLOCK [8:78] + |--LCURLY -> { [8:78] + |--CTOR_DEF -> CTOR_DEF [9:4] + | |--MODIFIERS -> MODIFIERS [9:4] + | | `--LITERAL_PUBLIC -> public [9:4] + | |--IDENT -> InputRegressionJavaClass2 [9:11] + | |--LPAREN -> ( [9:36] + | |--PARAMETERS -> PARAMETERS [9:37] + | |--RPAREN -> ) [9:37] + | `--SLIST -> { [9:39] + | |--SUPER_CTOR_CALL -> super [9:41] + | | |--LPAREN -> ( [9:46] + | | |--ELIST -> ELIST [9:47] + | | |--RPAREN -> ) [9:47] + | | `--SEMI -> ; [9:48] + | `--RCURLY -> } [9:50] + |--METHOD_DEF -> METHOD_DEF [11:4] + | |--MODIFIERS -> MODIFIERS [11:4] + | | |--ANNOTATION -> ANNOTATION [11:4] + | | | |--AT -> @ [11:4] + | | | `--IDENT -> Override [11:5] + | | `--LITERAL_PUBLIC -> public [12:4] + | |--TYPE -> TYPE [12:11] + | | `--LITERAL_INT -> int [12:11] + | |--IDENT -> size [12:15] + | |--LPAREN -> ( [12:19] + | |--PARAMETERS -> PARAMETERS [12:20] + | |--RPAREN -> ) [12:20] + | `--SLIST -> { [12:22] + | |--LITERAL_RETURN -> return [12:24] + | | |--EXPR -> EXPR [12:41] + | | | `--METHOD_CALL -> ( [12:41] + | | | |--DOT -> . [12:36] + | | | | |--LITERAL_SUPER -> super [12:31] + | | | | `--IDENT -> size [12:37] + | | | |--ELIST -> ELIST [12:42] + | | | `--RPAREN -> ) [12:42] + | | `--SEMI -> ; [12:43] + | `--RCURLY -> } [12:45] + |--METHOD_DEF -> METHOD_DEF [13:4] + | |--MODIFIERS -> MODIFIERS [13:4] + | | |--ANNOTATION -> ANNOTATION [13:4] + | | | |--AT -> @ [13:4] + | | | |--IDENT -> Override [13:5] + | | | |--LPAREN -> ( [13:13] + | | | `--RPAREN -> ) [13:14] + | | `--LITERAL_PUBLIC -> public [14:4] + | |--TYPE -> TYPE [14:11] + | | `--LITERAL_BOOLEAN -> boolean [14:11] + | |--IDENT -> isEmpty [14:19] + | |--LPAREN -> ( [14:26] + | |--PARAMETERS -> PARAMETERS [14:27] + | |--RPAREN -> ) [14:27] + | `--SLIST -> { [14:29] + | |--LITERAL_RETURN -> return [14:31] + | | |--EXPR -> EXPR [14:77] + | | | `--METHOD_CALL -> ( [14:77] + | | | |--DOT -> . [14:69] + | | | | |--DOT -> . [14:63] + | | | | | |--IDENT -> InputRegressionJavaClass2 [14:38] + | | | | | `--LITERAL_SUPER -> super [14:64] + | | | | `--IDENT -> isEmpty [14:70] + | | | |--ELIST -> ELIST [14:78] + | | | `--RPAREN -> ) [14:78] + | | `--SEMI -> ; [14:79] + | `--RCURLY -> } [14:81] + |--CLASS_DEF -> CLASS_DEF [16:4] + | |--MODIFIERS -> MODIFIERS [16:4] + | | `--LITERAL_PUBLIC -> public [16:4] + | |--LITERAL_CLASS -> class [16:11] + | |--IDENT -> Inner1 [16:17] + | `--OBJBLOCK -> OBJBLOCK [16:24] + | |--LCURLY -> { [16:24] + | |--METHOD_DEF -> METHOD_DEF [17:8] + | | |--MODIFIERS -> MODIFIERS [17:8] + | | | `--LITERAL_PUBLIC -> public [17:8] + | | |--TYPE -> TYPE [17:15] + | | | `--LITERAL_VOID -> void [17:15] + | | |--IDENT -> m [17:20] + | | |--LPAREN -> ( [17:21] + | | |--PARAMETERS -> PARAMETERS [17:22] + | | |--RPAREN -> ) [17:22] + | | `--SLIST -> { [17:24] + | | |--CLASS_DEF -> CLASS_DEF [18:12] + | | | |--MODIFIERS -> MODIFIERS [18:12] + | | | |--LITERAL_CLASS -> class [18:12] + | | | |--IDENT -> Inner2 [18:18] + | | | `--OBJBLOCK -> OBJBLOCK [18:25] + | | | |--LCURLY -> { [18:25] + | | | `--RCURLY -> } [19:12] + | | `--RCURLY -> } [20:8] + | |--SEMI -> ; [20:9] + | |--METHOD_DEF -> METHOD_DEF [22:8] + | | |--MODIFIERS -> MODIFIERS [22:8] + | | | `--LITERAL_PUBLIC -> public [22:8] + | | |--TYPE -> TYPE [22:15] + | | | `--IDENT -> InputRegressionJavaClass2 [22:15] + | | |--IDENT -> m2 [22:41] + | | |--LPAREN -> ( [22:43] + | | |--PARAMETERS -> PARAMETERS [22:44] + | | |--RPAREN -> ) [22:44] + | | `--SLIST -> { [22:46] + | | |--LITERAL_RETURN -> return [23:12] + | | | |--EXPR -> EXPR [23:44] + | | | | `--DOT -> . [23:44] + | | | | |--IDENT -> InputRegressionJavaClass2 [23:19] + | | | | `--LITERAL_THIS -> this [23:45] + | | | `--SEMI -> ; [23:49] + | | `--RCURLY -> } [24:8] + | `--RCURLY -> } [25:4] + |--METHOD_DEF -> METHOD_DEF [27:4] + | |--MODIFIERS -> MODIFIERS [27:4] + | | `--LITERAL_PUBLIC -> public [27:4] + | |--TYPE -> TYPE [27:11] + | | `--LITERAL_VOID -> void [27:11] + | |--IDENT -> m [27:16] + | |--LPAREN -> ( [27:17] + | |--PARAMETERS -> PARAMETERS [27:18] + | |--RPAREN -> ) [27:18] + | `--SLIST -> { [27:20] + | |--EXPR -> EXPR [27:41] + | | `--METHOD_CALL -> ( [27:41] + | | |--DOT -> . [27:39] + | | | |--DOT -> . [27:26] + | | | | |--LITERAL_THIS -> this [27:22] + | | | | `--LITERAL_NEW -> new [27:27] + | | | | |--IDENT -> Inner1 [27:31] + | | | | |--LPAREN -> ( [27:37] + | | | | |--ELIST -> ELIST [27:38] + | | | | `--RPAREN -> ) [27:38] + | | | `--IDENT -> m [27:40] + | | |--ELIST -> ELIST [27:42] + | | `--RPAREN -> ) [27:42] + | |--SEMI -> ; [27:43] + | `--RCURLY -> } [27:45] + `--RCURLY -> } [28:0] +CLASS_DEF -> CLASS_DEF [29:0] +|--MODIFIERS -> MODIFIERS [29:0] +|--LITERAL_CLASS -> class [29:0] +|--IDENT -> _c1 [29:6] +`--OBJBLOCK -> OBJBLOCK [29:10] + |--LCURLY -> { [29:10] + `--RCURLY -> } [29:11] +CLASS_DEF -> CLASS_DEF [30:0] +|--MODIFIERS -> MODIFIERS [30:0] +| `--ABSTRACT -> abstract [30:0] +|--LITERAL_CLASS -> class [30:9] +|--IDENT -> c2 [30:15] +`--OBJBLOCK -> OBJBLOCK [30:18] + |--LCURLY -> { [30:18] + `--RCURLY -> } [30:19] +CLASS_DEF -> CLASS_DEF [31:0] +|--MODIFIERS -> MODIFIERS [31:0] +|--LITERAL_CLASS -> class [31:0] +|--IDENT -> c3 [31:6] +|--TYPE_PARAMETERS -> TYPE_PARAMETERS [31:8] +| |--GENERIC_START -> < [31:8] +| |--TYPE_PARAMETER -> TYPE_PARAMETER [31:9] +| | `--IDENT -> A [31:9] +| `--GENERIC_END -> > [31:10] +`--OBJBLOCK -> OBJBLOCK [31:12] + |--LCURLY -> { [31:12] + |--METHOD_DEF -> METHOD_DEF [31:14] + | |--MODIFIERS -> MODIFIERS [31:14] + | | `--LITERAL_PUBLIC -> public [31:14] + | |--TYPE -> TYPE [31:21] + | | |--IDENT -> c3 [31:21] + | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:23] + | | |--GENERIC_START -> < [31:23] + | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:24] + | | | `--IDENT -> A [31:24] + | | `--GENERIC_END -> > [31:25] + | |--IDENT -> m [31:27] + | |--LPAREN -> ( [31:28] + | |--PARAMETERS -> PARAMETERS [31:29] + | |--RPAREN -> ) [31:29] + | `--SLIST -> { [31:30] + | |--LITERAL_RETURN -> return [31:31] + | | |--EXPR -> EXPR [31:38] + | | | `--LITERAL_NULL -> null [31:38] + | | `--SEMI -> ; [31:42] + | `--RCURLY -> } [31:43] + `--RCURLY -> } [31:45] +CLASS_DEF -> CLASS_DEF [32:0] +|--MODIFIERS -> MODIFIERS [32:0] +|--LITERAL_CLASS -> class [32:0] +|--IDENT -> c4 [32:6] +|--TYPE_PARAMETERS -> TYPE_PARAMETERS [32:8] +| |--GENERIC_START -> < [32:8] +| |--TYPE_PARAMETER -> TYPE_PARAMETER [32:9] +| | `--IDENT -> A [32:9] +| |--COMMA -> , [32:10] +| |--TYPE_PARAMETER -> TYPE_PARAMETER [32:11] +| | `--IDENT -> B [32:11] +| `--GENERIC_END -> > [32:12] +|--EXTENDS_CLAUSE -> extends [32:14] +| |--IDENT -> c3 [32:22] +| `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [32:24] +| |--GENERIC_START -> < [32:24] +| |--TYPE_ARGUMENT -> TYPE_ARGUMENT [32:25] +| | `--IDENT -> A [32:25] +| `--GENERIC_END -> > [32:26] +`--OBJBLOCK -> OBJBLOCK [32:28] + |--LCURLY -> { [32:28] + |--CLASS_DEF -> CLASS_DEF [33:4] + | |--MODIFIERS -> MODIFIERS [33:4] + | |--LITERAL_CLASS -> class [33:4] + | |--IDENT -> c4a [33:10] + | `--OBJBLOCK -> OBJBLOCK [33:14] + | |--LCURLY -> { [33:14] + | `--RCURLY -> } [33:15] + |--CTOR_DEF -> CTOR_DEF [35:4] + | |--MODIFIERS -> MODIFIERS [35:4] + | | `--LITERAL_PUBLIC -> public [35:4] + | |--IDENT -> c4 [35:11] + | |--LPAREN -> ( [35:13] + | |--PARAMETERS -> PARAMETERS [35:14] + | |--RPAREN -> ) [35:14] + | `--SLIST -> { [35:16] + | |--SUPER_CTOR_CALL -> super [35:26] + | | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [35:18] + | | | |--GENERIC_START -> < [35:18] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [35:19] + | | | | `--IDENT -> String [35:19] + | | | `--GENERIC_END -> > [35:25] + | | |--LPAREN -> ( [35:31] + | | |--ELIST -> ELIST [35:32] + | | |--RPAREN -> ) [35:32] + | | `--SEMI -> ; [35:33] + | `--RCURLY -> } [35:35] + |--METHOD_DEF -> METHOD_DEF [36:4] + | |--MODIFIERS -> MODIFIERS [36:4] + | | `--LITERAL_PUBLIC -> public [36:4] + | |--TYPE -> TYPE [36:11] + | | |--IDENT -> c3 [36:11] + | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [36:13] + | | |--GENERIC_START -> < [36:13] + | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [36:14] + | | | `--IDENT -> A [36:14] + | | `--GENERIC_END -> > [36:15] + | |--IDENT -> m [36:17] + | |--LPAREN -> ( [36:18] + | |--PARAMETERS -> PARAMETERS [36:19] + | |--RPAREN -> ) [36:19] + | `--SLIST -> { [36:21] + | |--LITERAL_RETURN -> return [36:23] + | | |--EXPR -> EXPR [36:40] + | | | `--METHOD_CALL -> ( [36:40] + | | | |--DOT -> . [36:35] + | | | | |--LITERAL_SUPER -> super [36:30] + | | | | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [36:36] + | | | | | |--GENERIC_START -> < [36:36] + | | | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [36:37] + | | | | | | `--IDENT -> A [36:37] + | | | | | `--GENERIC_END -> > [36:38] + | | | | `--IDENT -> m [36:39] + | | | |--ELIST -> ELIST [36:41] + | | | `--RPAREN -> ) [36:41] + | | `--SEMI -> ; [36:42] + | `--RCURLY -> } [36:44] + `--RCURLY -> } [37:0] +CLASS_DEF -> CLASS_DEF [38:0] +|--MODIFIERS -> MODIFIERS [38:0] +|--LITERAL_CLASS -> class [38:0] +|--IDENT -> c5 [38:6] +|--EXTENDS_CLAUSE -> extends [38:9] +| `--DOT -> . [38:19] +| |--IDENT -> c4 [38:17] +| `--IDENT -> c4a [38:20] +`--OBJBLOCK -> OBJBLOCK [38:24] + |--LCURLY -> { [38:24] + |--CTOR_DEF -> CTOR_DEF [39:4] + | |--MODIFIERS -> MODIFIERS [39:4] + | |--IDENT -> c5 [39:4] + | |--LPAREN -> ( [39:6] + | |--PARAMETERS -> PARAMETERS [39:7] + | |--RPAREN -> ) [39:7] + | `--SLIST -> { [39:9] + | |--SUPER_CTOR_CALL -> super [39:20] + | | |--LITERAL_NEW -> new [39:11] + | | | |--IDENT -> c4 [39:15] + | | | |--LPAREN -> ( [39:17] + | | | |--ELIST -> ELIST [39:18] + | | | `--RPAREN -> ) [39:18] + | | |--DOT -> . [39:19] + | | |--LPAREN -> ( [39:25] + | | |--ELIST -> ELIST [39:26] + | | |--RPAREN -> ) [39:26] + | | `--SEMI -> ; [39:27] + | `--RCURLY -> } [39:29] + |--CTOR_DEF -> CTOR_DEF [40:4] + | |--MODIFIERS -> MODIFIERS [40:4] + | |--IDENT -> c5 [40:4] + | |--LPAREN -> ( [40:6] + | |--PARAMETERS -> PARAMETERS [40:7] + | | `--PARAMETER_DEF -> PARAMETER_DEF [40:7] + | | |--MODIFIERS -> MODIFIERS [40:7] + | | |--TYPE -> TYPE [40:7] + | | | `--LITERAL_INT -> int [40:7] + | | `--IDENT -> a [40:11] + | |--RPAREN -> ) [40:12] + | `--SLIST -> { [40:14] + | |--SUPER_CTOR_CALL -> super [40:33] + | | |--LITERAL_NEW -> new [40:16] + | | | |--IDENT -> c4 [40:20] + | | | |--LPAREN -> ( [40:22] + | | | |--ELIST -> ELIST [40:23] + | | | `--RPAREN -> ) [40:23] + | | |--DOT -> . [40:24] + | | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [40:25] + | | | |--GENERIC_START -> < [40:25] + | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [40:26] + | | | | `--IDENT -> String [40:26] + | | | `--GENERIC_END -> > [40:32] + | | |--LPAREN -> ( [40:38] + | | |--ELIST -> ELIST [40:39] + | | |--RPAREN -> ) [40:39] + | | `--SEMI -> ; [40:40] + | `--RCURLY -> } [40:42] + `--RCURLY -> } [41:0] diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaEnum1.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaEnum1.java new file mode 100644 index 000000000..a18e3419d --- /dev/null +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaEnum1.java @@ -0,0 +1,25 @@ +package com.puppycrawl.tools.checkstyle.grammars; + +public enum InputRegressionJavaEnum1 { + E1(), E2 { + class anonymous {} + private static final int f = 1; + + @Override + public void override() {}; + public void m1() {}; + public void m2() throws Exception { throw new Exception(); }; + public native void m3() throws Exception; + + {;} + } + ; + + public void override() {} +} +enum e1 { + E1(),; +} +enum e2 { + E1();; +} \ No newline at end of file diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaEnum1Ast.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaEnum1Ast.txt new file mode 100644 index 000000000..4d32a2361 --- /dev/null +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaEnum1Ast.txt @@ -0,0 +1,165 @@ +PACKAGE_DEF -> package [1:0] +|--ANNOTATIONS -> ANNOTATIONS [1:39] +|--DOT -> . [1:39] +| |--DOT -> . [1:28] +| | |--DOT -> . [1:22] +| | | |--DOT -> . [1:11] +| | | | |--IDENT -> com [1:8] +| | | | `--IDENT -> puppycrawl [1:12] +| | | `--IDENT -> tools [1:23] +| | `--IDENT -> checkstyle [1:29] +| `--IDENT -> grammars [1:40] +`--SEMI -> ; [1:48] +ENUM_DEF -> ENUM_DEF [3:0] +|--MODIFIERS -> MODIFIERS [3:0] +| `--LITERAL_PUBLIC -> public [3:0] +|--ENUM -> enum [3:7] +|--IDENT -> InputRegressionJavaEnum1 [3:12] +`--OBJBLOCK -> OBJBLOCK [3:37] + |--LCURLY -> { [3:37] + |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [4:4] + | |--ANNOTATIONS -> ANNOTATIONS [4:4] + | |--IDENT -> E1 [4:4] + | |--LPAREN -> ( [4:6] + | |--ELIST -> ELIST [4:7] + | `--RPAREN -> ) [4:7] + |--COMMA -> , [4:8] + |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [4:10] + | |--ANNOTATIONS -> ANNOTATIONS [4:10] + | |--IDENT -> E2 [4:10] + | `--OBJBLOCK -> OBJBLOCK [4:13] + | |--LCURLY -> { [4:13] + | |--CLASS_DEF -> CLASS_DEF [5:8] + | | |--MODIFIERS -> MODIFIERS [5:8] + | | |--LITERAL_CLASS -> class [5:8] + | | |--IDENT -> anonymous [5:14] + | | `--OBJBLOCK -> OBJBLOCK [5:24] + | | |--LCURLY -> { [5:24] + | | `--RCURLY -> } [5:25] + | |--VARIABLE_DEF -> VARIABLE_DEF [6:8] + | | |--MODIFIERS -> MODIFIERS [6:8] + | | | |--LITERAL_PRIVATE -> private [6:8] + | | | |--LITERAL_STATIC -> static [6:16] + | | | `--FINAL -> final [6:23] + | | |--TYPE -> TYPE [6:29] + | | | `--LITERAL_INT -> int [6:29] + | | |--IDENT -> f [6:33] + | | |--ASSIGN -> = [6:35] + | | | `--EXPR -> EXPR [6:37] + | | | `--NUM_INT -> 1 [6:37] + | | `--SEMI -> ; [6:38] + | |--METHOD_DEF -> METHOD_DEF [8:8] + | | |--MODIFIERS -> MODIFIERS [8:8] + | | | |--ANNOTATION -> ANNOTATION [8:8] + | | | | |--AT -> @ [8:8] + | | | | `--IDENT -> Override [8:9] + | | | `--LITERAL_PUBLIC -> public [9:8] + | | |--TYPE -> TYPE [9:15] + | | | `--LITERAL_VOID -> void [9:15] + | | |--IDENT -> override [9:20] + | | |--LPAREN -> ( [9:28] + | | |--PARAMETERS -> PARAMETERS [9:29] + | | |--RPAREN -> ) [9:29] + | | `--SLIST -> { [9:31] + | | `--RCURLY -> } [9:32] + | |--SEMI -> ; [9:33] + | |--METHOD_DEF -> METHOD_DEF [10:8] + | | |--MODIFIERS -> MODIFIERS [10:8] + | | | `--LITERAL_PUBLIC -> public [10:8] + | | |--TYPE_PARAMETERS -> TYPE_PARAMETERS [10:15] + | | | |--GENERIC_START -> < [10:15] + | | | |--TYPE_PARAMETER -> TYPE_PARAMETER [10:16] + | | | | `--IDENT -> T [10:16] + | | | `--GENERIC_END -> > [10:17] + | | |--TYPE -> TYPE [10:19] + | | | `--LITERAL_VOID -> void [10:19] + | | |--IDENT -> m1 [10:24] + | | |--LPAREN -> ( [10:26] + | | |--PARAMETERS -> PARAMETERS [10:27] + | | |--RPAREN -> ) [10:27] + | | `--SLIST -> { [10:29] + | | `--RCURLY -> } [10:30] + | |--SEMI -> ; [10:31] + | |--METHOD_DEF -> METHOD_DEF [11:8] + | | |--MODIFIERS -> MODIFIERS [11:8] + | | | `--LITERAL_PUBLIC -> public [11:8] + | | |--TYPE -> TYPE [11:15] + | | | `--LITERAL_VOID -> void [11:15] + | | |--IDENT -> m2 [11:20] + | | |--LPAREN -> ( [11:22] + | | |--PARAMETERS -> PARAMETERS [11:23] + | | |--RPAREN -> ) [11:23] + | | |--LITERAL_THROWS -> throws [11:25] + | | | `--IDENT -> Exception [11:32] + | | `--SLIST -> { [11:42] + | | |--LITERAL_THROW -> throw [11:44] + | | | |--EXPR -> EXPR [11:50] + | | | | `--LITERAL_NEW -> new [11:50] + | | | | |--IDENT -> Exception [11:54] + | | | | |--LPAREN -> ( [11:63] + | | | | |--ELIST -> ELIST [11:64] + | | | | `--RPAREN -> ) [11:64] + | | | `--SEMI -> ; [11:65] + | | `--RCURLY -> } [11:67] + | |--SEMI -> ; [11:68] + | |--METHOD_DEF -> METHOD_DEF [12:8] + | | |--MODIFIERS -> MODIFIERS [12:8] + | | | |--LITERAL_PUBLIC -> public [12:8] + | | | `--LITERAL_NATIVE -> native [12:15] + | | |--TYPE -> TYPE [12:22] + | | | `--LITERAL_VOID -> void [12:22] + | | |--IDENT -> m3 [12:27] + | | |--LPAREN -> ( [12:29] + | | |--PARAMETERS -> PARAMETERS [12:30] + | | |--RPAREN -> ) [12:30] + | | |--LITERAL_THROWS -> throws [12:32] + | | | `--IDENT -> Exception [12:39] + | | `--SEMI -> ; [12:48] + | |--INSTANCE_INIT -> INSTANCE_INIT [14:8] + | | `--SLIST -> { [14:8] + | | |--EMPTY_STAT -> ; [14:9] + | | `--RCURLY -> } [14:10] + | `--RCURLY -> } [15:4] + |--SEMI -> ; [16:4] + |--METHOD_DEF -> METHOD_DEF [18:4] + | |--MODIFIERS -> MODIFIERS [18:4] + | | `--LITERAL_PUBLIC -> public [18:4] + | |--TYPE -> TYPE [18:11] + | | `--LITERAL_VOID -> void [18:11] + | |--IDENT -> override [18:16] + | |--LPAREN -> ( [18:24] + | |--PARAMETERS -> PARAMETERS [18:25] + | |--RPAREN -> ) [18:25] + | `--SLIST -> { [18:27] + | `--RCURLY -> } [18:28] + `--RCURLY -> } [19:0] +ENUM_DEF -> ENUM_DEF [20:0] +|--MODIFIERS -> MODIFIERS [20:0] +|--ENUM -> enum [20:0] +|--IDENT -> e1 [20:5] +`--OBJBLOCK -> OBJBLOCK [20:8] + |--LCURLY -> { [20:8] + |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [21:4] + | |--ANNOTATIONS -> ANNOTATIONS [21:4] + | |--IDENT -> E1 [21:4] + | |--LPAREN -> ( [21:6] + | |--ELIST -> ELIST [21:7] + | `--RPAREN -> ) [21:7] + |--COMMA -> , [21:8] + |--SEMI -> ; [21:9] + `--RCURLY -> } [22:0] +ENUM_DEF -> ENUM_DEF [23:0] +|--MODIFIERS -> MODIFIERS [23:0] +|--ENUM -> enum [23:0] +|--IDENT -> e2 [23:5] +`--OBJBLOCK -> OBJBLOCK [23:8] + |--LCURLY -> { [23:8] + |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [24:4] + | |--ANNOTATIONS -> ANNOTATIONS [24:4] + | |--IDENT -> E1 [24:4] + | |--LPAREN -> ( [24:6] + | |--ELIST -> ELIST [24:7] + | `--RPAREN -> ) [24:7] + |--SEMI -> ; [24:8] + |--SEMI -> ; [24:9] + `--RCURLY -> } [25:0] diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaEnum2.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaEnum2.java new file mode 100644 index 000000000..5ba243387 --- /dev/null +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaEnum2.java @@ -0,0 +1,4 @@ +package com.puppycrawl.tools.checkstyle.grammars; + +public enum InputRegressionJavaEnum2 { +} \ No newline at end of file diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaEnum2Ast.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaEnum2Ast.txt new file mode 100644 index 000000000..adfceb700 --- /dev/null +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaEnum2Ast.txt @@ -0,0 +1,20 @@ +PACKAGE_DEF -> package [1:0] +|--ANNOTATIONS -> ANNOTATIONS [1:39] +|--DOT -> . [1:39] +| |--DOT -> . [1:28] +| | |--DOT -> . [1:22] +| | | |--DOT -> . [1:11] +| | | | |--IDENT -> com [1:8] +| | | | `--IDENT -> puppycrawl [1:12] +| | | `--IDENT -> tools [1:23] +| | `--IDENT -> checkstyle [1:29] +| `--IDENT -> grammars [1:40] +`--SEMI -> ; [1:48] +ENUM_DEF -> ENUM_DEF [3:0] +|--MODIFIERS -> MODIFIERS [3:0] +| `--LITERAL_PUBLIC -> public [3:0] +|--ENUM -> enum [3:7] +|--IDENT -> InputRegressionJavaEnum2 [3:12] +`--OBJBLOCK -> OBJBLOCK [3:37] + |--LCURLY -> { [3:37] + `--RCURLY -> } [4:0] diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaInterface1.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaInterface1.java new file mode 100644 index 000000000..999244169 --- /dev/null +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaInterface1.java @@ -0,0 +1,8 @@ +package com.puppycrawl.tools.checkstyle.grammars; + + +import java.util.Collection; +import java.util.List; + +public interface InputRegressionJavaInterface1 extends List, Collection { +} diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaInterface1Ast.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaInterface1Ast.txt new file mode 100644 index 000000000..b71fc5a43 --- /dev/null +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaInterface1Ast.txt @@ -0,0 +1,38 @@ +PACKAGE_DEF -> package [1:0] +|--ANNOTATIONS -> ANNOTATIONS [1:39] +|--DOT -> . [1:39] +| |--DOT -> . [1:28] +| | |--DOT -> . [1:22] +| | | |--DOT -> . [1:11] +| | | | |--IDENT -> com [1:8] +| | | | `--IDENT -> puppycrawl [1:12] +| | | `--IDENT -> tools [1:23] +| | `--IDENT -> checkstyle [1:29] +| `--IDENT -> grammars [1:40] +`--SEMI -> ; [1:48] +IMPORT -> import [4:0] +|--DOT -> . [4:16] +| |--DOT -> . [4:11] +| | |--IDENT -> java [4:7] +| | `--IDENT -> util [4:12] +| `--IDENT -> Collection [4:17] +`--SEMI -> ; [4:27] +IMPORT -> import [5:0] +|--DOT -> . [5:16] +| |--DOT -> . [5:11] +| | |--IDENT -> java [5:7] +| | `--IDENT -> util [5:12] +| `--IDENT -> List [5:17] +`--SEMI -> ; [5:21] +INTERFACE_DEF -> INTERFACE_DEF [7:0] +|--MODIFIERS -> MODIFIERS [7:0] +| `--LITERAL_PUBLIC -> public [7:0] +|--LITERAL_INTERFACE -> interface [7:7] +|--IDENT -> InputRegressionJavaInterface1 [7:17] +|--EXTENDS_CLAUSE -> extends [7:47] +| |--IDENT -> List [7:55] +| |--COMMA -> , [7:59] +| `--IDENT -> Collection [7:61] +`--OBJBLOCK -> OBJBLOCK [7:72] + |--LCURLY -> { [7:72] + `--RCURLY -> } [8:0] diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaInterface2.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaInterface2.java new file mode 100644 index 000000000..545c45f52 --- /dev/null +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaInterface2.java @@ -0,0 +1,6 @@ +package com.puppycrawl.tools.checkstyle.grammars; + +public interface InputRegressionJavaInterface2 { +} +interface MyInterface { +} diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaInterface2Ast.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaInterface2Ast.txt new file mode 100644 index 000000000..e3584561c --- /dev/null +++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammars/InputRegressionJavaInterface2Ast.txt @@ -0,0 +1,32 @@ +PACKAGE_DEF -> package [1:0] +|--ANNOTATIONS -> ANNOTATIONS [1:39] +|--DOT -> . [1:39] +| |--DOT -> . [1:28] +| | |--DOT -> . [1:22] +| | | |--DOT -> . [1:11] +| | | | |--IDENT -> com [1:8] +| | | | `--IDENT -> puppycrawl [1:12] +| | | `--IDENT -> tools [1:23] +| | `--IDENT -> checkstyle [1:29] +| `--IDENT -> grammars [1:40] +`--SEMI -> ; [1:48] +INTERFACE_DEF -> INTERFACE_DEF [3:0] +|--MODIFIERS -> MODIFIERS [3:0] +| `--LITERAL_PUBLIC -> public [3:0] +|--LITERAL_INTERFACE -> interface [3:7] +|--IDENT -> InputRegressionJavaInterface2 [3:17] +`--OBJBLOCK -> OBJBLOCK [3:47] + |--LCURLY -> { [3:47] + `--RCURLY -> } [4:0] +INTERFACE_DEF -> INTERFACE_DEF [5:0] +|--MODIFIERS -> MODIFIERS [5:0] +|--LITERAL_INTERFACE -> interface [5:0] +|--IDENT -> MyInterface [5:10] +|--TYPE_PARAMETERS -> TYPE_PARAMETERS [5:21] +| |--GENERIC_START -> < [5:21] +| |--TYPE_PARAMETER -> TYPE_PARAMETER [5:22] +| | `--IDENT -> T [5:22] +| `--GENERIC_END -> > [5:23] +`--OBJBLOCK -> OBJBLOCK [5:25] + |--LCURLY -> { [5:25] + `--RCURLY -> } [6:0]