1
2 package io.earcam.instrumental.module.jpms.parser;
3 import org.antlr.v4.runtime.atn.*;
4 import org.antlr.v4.runtime.dfa.DFA;
5 import org.antlr.v4.runtime.*;
6 import org.antlr.v4.runtime.misc.*;
7 import org.antlr.v4.runtime.tree.*;
8 import java.util.List;
9 import java.util.Iterator;
10 import java.util.ArrayList;
11
12 @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
13 class Java9Parser extends Parser {
14 static { RuntimeMetaData.checkVersion("4.7.1", RuntimeMetaData.VERSION); }
15
16 protected static final DFA[] _decisionToDFA;
17 protected static final PredictionContextCache _sharedContextCache =
18 new PredictionContextCache();
19 public static final int
20 T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9,
21 T__9=10, ABSTRACT=11, ASSERT=12, BOOLEAN=13, BREAK=14, BYTE=15, CASE=16,
22 CATCH=17, CHAR=18, CLASS=19, CONST=20, CONTINUE=21, DEFAULT=22, DO=23,
23 DOUBLE=24, ELSE=25, ENUM=26, EXTENDS=27, FINAL=28, FINALLY=29, FLOAT=30,
24 FOR=31, IF=32, GOTO=33, IMPLEMENTS=34, IMPORT=35, INSTANCEOF=36, INT=37,
25 INTERFACE=38, LONG=39, NATIVE=40, NEW=41, PACKAGE=42, PRIVATE=43, PROTECTED=44,
26 PUBLIC=45, RETURN=46, SHORT=47, STATIC=48, STRICTFP=49, SUPER=50, SWITCH=51,
27 SYNCHRONIZED=52, THIS=53, THROW=54, THROWS=55, TRANSIENT=56, TRY=57, VOID=58,
28 VOLATILE=59, WHILE=60, UNDER_SCORE=61, IntegerLiteral=62, FloatingPointLiteral=63,
29 BooleanLiteral=64, CharacterLiteral=65, StringLiteral=66, NullLiteral=67,
30 LPAREN=68, RPAREN=69, LBRACE=70, RBRACE=71, LBRACK=72, RBRACK=73, SEMI=74,
31 COMMA=75, DOT=76, ELLIPSIS=77, AT=78, COLONCOLON=79, ASSIGN=80, GT=81,
32 LT=82, BANG=83, TILDE=84, QUESTION=85, COLON=86, ARROW=87, EQUAL=88, LE=89,
33 GE=90, NOTEQUAL=91, AND=92, OR=93, INC=94, DEC=95, ADD=96, SUB=97, MUL=98,
34 DIV=99, BITAND=100, BITOR=101, CARET=102, MOD=103, ADD_ASSIGN=104, SUB_ASSIGN=105,
35 MUL_ASSIGN=106, DIV_ASSIGN=107, AND_ASSIGN=108, OR_ASSIGN=109, XOR_ASSIGN=110,
36 MOD_ASSIGN=111, LSHIFT_ASSIGN=112, RSHIFT_ASSIGN=113, URSHIFT_ASSIGN=114,
37 Identifier=115, WS=116, COMMENT=117, LINE_COMMENT=118;
38 public static final int
39 RULE_literal = 0, RULE_primitiveType = 1, RULE_numericType = 2, RULE_integralType = 3,
40 RULE_floatingPointType = 4, RULE_referenceType = 5, RULE_classOrInterfaceType = 6,
41 RULE_classType = 7, RULE_classType_lf_classOrInterfaceType = 8, RULE_classType_lfno_classOrInterfaceType = 9,
42 RULE_interfaceType = 10, RULE_interfaceType_lf_classOrInterfaceType = 11,
43 RULE_interfaceType_lfno_classOrInterfaceType = 12, RULE_typeVariable = 13,
44 RULE_arrayType = 14, RULE_dims = 15, RULE_typeParameter = 16, RULE_typeParameterModifier = 17,
45 RULE_typeBound = 18, RULE_additionalBound = 19, RULE_typeArguments = 20,
46 RULE_typeArgumentList = 21, RULE_typeArgument = 22, RULE_wildcard = 23,
47 RULE_wildcardBounds = 24, RULE_moduleName = 25, RULE_packageName = 26,
48 RULE_typeName = 27, RULE_packageOrTypeName = 28, RULE_expressionName = 29,
49 RULE_methodName = 30, RULE_ambiguousName = 31, RULE_compilationUnit = 32,
50 RULE_ordinaryCompilation = 33, RULE_modularCompilation = 34, RULE_packageDeclaration = 35,
51 RULE_packageModifier = 36, RULE_importDeclaration = 37, RULE_singleTypeImportDeclaration = 38,
52 RULE_typeImportOnDemandDeclaration = 39, RULE_singleStaticImportDeclaration = 40,
53 RULE_staticImportOnDemandDeclaration = 41, RULE_typeDeclaration = 42,
54 RULE_moduleDeclaration = 43, RULE_moduleDirective = 44, RULE_requiresDirective = 45,
55 RULE_exportsDirective = 46, RULE_opensDirective = 47, RULE_usesDirective = 48,
56 RULE_providesDirective = 49, RULE_requiresModifier = 50, RULE_classDeclaration = 51,
57 RULE_normalClassDeclaration = 52, RULE_classModifier = 53, RULE_typeParameters = 54,
58 RULE_typeParameterList = 55, RULE_superclass = 56, RULE_superinterfaces = 57,
59 RULE_interfaceTypeList = 58, RULE_classBody = 59, RULE_classBodyDeclaration = 60,
60 RULE_classMemberDeclaration = 61, RULE_fieldDeclaration = 62, RULE_fieldModifier = 63,
61 RULE_variableDeclaratorList = 64, RULE_variableDeclarator = 65, RULE_variableDeclaratorId = 66,
62 RULE_variableInitializer = 67, RULE_unannType = 68, RULE_unannPrimitiveType = 69,
63 RULE_unannReferenceType = 70, RULE_unannClassOrInterfaceType = 71, RULE_unannClassType = 72,
64 RULE_unannClassType_lf_unannClassOrInterfaceType = 73, RULE_unannClassType_lfno_unannClassOrInterfaceType = 74,
65 RULE_unannInterfaceType = 75, RULE_unannInterfaceType_lf_unannClassOrInterfaceType = 76,
66 RULE_unannInterfaceType_lfno_unannClassOrInterfaceType = 77, RULE_unannTypeVariable = 78,
67 RULE_unannArrayType = 79, RULE_methodDeclaration = 80, RULE_methodModifier = 81,
68 RULE_methodHeader = 82, RULE_result = 83, RULE_methodDeclarator = 84,
69 RULE_formalParameterList = 85, RULE_formalParameters = 86, RULE_formalParameter = 87,
70 RULE_variableModifier = 88, RULE_lastFormalParameter = 89, RULE_receiverParameter = 90,
71 RULE_throws_ = 91, RULE_exceptionTypeList = 92, RULE_exceptionType = 93,
72 RULE_methodBody = 94, RULE_instanceInitializer = 95, RULE_staticInitializer = 96,
73 RULE_constructorDeclaration = 97, RULE_constructorModifier = 98, RULE_constructorDeclarator = 99,
74 RULE_simpleTypeName = 100, RULE_constructorBody = 101, RULE_explicitConstructorInvocation = 102,
75 RULE_enumDeclaration = 103, RULE_enumBody = 104, RULE_enumConstantList = 105,
76 RULE_enumConstant = 106, RULE_enumConstantModifier = 107, RULE_enumBodyDeclarations = 108,
77 RULE_interfaceDeclaration = 109, RULE_normalInterfaceDeclaration = 110,
78 RULE_interfaceModifier = 111, RULE_extendsInterfaces = 112, RULE_interfaceBody = 113,
79 RULE_interfaceMemberDeclaration = 114, RULE_constantDeclaration = 115,
80 RULE_constantModifier = 116, RULE_interfaceMethodDeclaration = 117, RULE_interfaceMethodModifier = 118,
81 RULE_annotationTypeDeclaration = 119, RULE_annotationTypeBody = 120, RULE_annotationTypeMemberDeclaration = 121,
82 RULE_annotationTypeElementDeclaration = 122, RULE_annotationTypeElementModifier = 123,
83 RULE_defaultValue = 124, RULE_annotation = 125, RULE_normalAnnotation = 126,
84 RULE_elementValuePairList = 127, RULE_elementValuePair = 128, RULE_elementValue = 129,
85 RULE_elementValueArrayInitializer = 130, RULE_elementValueList = 131,
86 RULE_markerAnnotation = 132, RULE_singleElementAnnotation = 133, RULE_arrayInitializer = 134,
87 RULE_variableInitializerList = 135, RULE_block = 136, RULE_blockStatements = 137,
88 RULE_blockStatement = 138, RULE_localVariableDeclarationStatement = 139,
89 RULE_localVariableDeclaration = 140, RULE_statement = 141, RULE_statementNoShortIf = 142,
90 RULE_statementWithoutTrailingSubstatement = 143, RULE_emptyStatement = 144,
91 RULE_labeledStatement = 145, RULE_labeledStatementNoShortIf = 146, RULE_expressionStatement = 147,
92 RULE_statementExpression = 148, RULE_ifThenStatement = 149, RULE_ifThenElseStatement = 150,
93 RULE_ifThenElseStatementNoShortIf = 151, RULE_assertStatement = 152, RULE_switchStatement = 153,
94 RULE_switchBlock = 154, RULE_switchBlockStatementGroup = 155, RULE_switchLabels = 156,
95 RULE_switchLabel = 157, RULE_enumConstantName = 158, RULE_whileStatement = 159,
96 RULE_whileStatementNoShortIf = 160, RULE_doStatement = 161, RULE_forStatement = 162,
97 RULE_forStatementNoShortIf = 163, RULE_basicForStatement = 164, RULE_basicForStatementNoShortIf = 165,
98 RULE_forInit = 166, RULE_forUpdate = 167, RULE_statementExpressionList = 168,
99 RULE_enhancedForStatement = 169, RULE_enhancedForStatementNoShortIf = 170,
100 RULE_breakStatement = 171, RULE_continueStatement = 172, RULE_returnStatement = 173,
101 RULE_throwStatement = 174, RULE_synchronizedStatement = 175, RULE_tryStatement = 176,
102 RULE_catches = 177, RULE_catchClause = 178, RULE_catchFormalParameter = 179,
103 RULE_catchType = 180, RULE_finally_ = 181, RULE_tryWithResourcesStatement = 182,
104 RULE_resourceSpecification = 183, RULE_resourceList = 184, RULE_resource = 185,
105 RULE_variableAccess = 186, RULE_primary = 187, RULE_primaryNoNewArray = 188,
106 RULE_primaryNoNewArray_lf_arrayAccess = 189, RULE_primaryNoNewArray_lfno_arrayAccess = 190,
107 RULE_primaryNoNewArray_lf_primary = 191, RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary = 192,
108 RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary = 193, RULE_primaryNoNewArray_lfno_primary = 194,
109 RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary = 195,
110 RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary = 196,
111 RULE_classLiteral = 197, RULE_classInstanceCreationExpression = 198, RULE_classInstanceCreationExpression_lf_primary = 199,
112 RULE_classInstanceCreationExpression_lfno_primary = 200, RULE_typeArgumentsOrDiamond = 201,
113 RULE_fieldAccess = 202, RULE_fieldAccess_lf_primary = 203, RULE_fieldAccess_lfno_primary = 204,
114 RULE_arrayAccess = 205, RULE_arrayAccess_lf_primary = 206, RULE_arrayAccess_lfno_primary = 207,
115 RULE_methodInvocation = 208, RULE_methodInvocation_lf_primary = 209, RULE_methodInvocation_lfno_primary = 210,
116 RULE_argumentList = 211, RULE_methodReference = 212, RULE_methodReference_lf_primary = 213,
117 RULE_methodReference_lfno_primary = 214, RULE_arrayCreationExpression = 215,
118 RULE_dimExprs = 216, RULE_dimExpr = 217, RULE_constantExpression = 218,
119 RULE_expression = 219, RULE_lambdaExpression = 220, RULE_lambdaParameters = 221,
120 RULE_inferredFormalParameterList = 222, RULE_lambdaBody = 223, RULE_assignmentExpression = 224,
121 RULE_assignment = 225, RULE_leftHandSide = 226, RULE_assignmentOperator = 227,
122 RULE_conditionalExpression = 228, RULE_conditionalOrExpression = 229,
123 RULE_conditionalAndExpression = 230, RULE_inclusiveOrExpression = 231,
124 RULE_exclusiveOrExpression = 232, RULE_andExpression = 233, RULE_equalityExpression = 234,
125 RULE_relationalExpression = 235, RULE_shiftExpression = 236, RULE_additiveExpression = 237,
126 RULE_multiplicativeExpression = 238, RULE_unaryExpression = 239, RULE_preIncrementExpression = 240,
127 RULE_preDecrementExpression = 241, RULE_unaryExpressionNotPlusMinus = 242,
128 RULE_postfixExpression = 243, RULE_postIncrementExpression = 244, RULE_postIncrementExpression_lf_postfixExpression = 245,
129 RULE_postDecrementExpression = 246, RULE_postDecrementExpression_lf_postfixExpression = 247,
130 RULE_castExpression = 248, RULE_identifier = 249;
131 public static final String[] ruleNames = {
132 "literal", "primitiveType", "numericType", "integralType", "floatingPointType",
133 "referenceType", "classOrInterfaceType", "classType", "classType_lf_classOrInterfaceType",
134 "classType_lfno_classOrInterfaceType", "interfaceType", "interfaceType_lf_classOrInterfaceType",
135 "interfaceType_lfno_classOrInterfaceType", "typeVariable", "arrayType",
136 "dims", "typeParameter", "typeParameterModifier", "typeBound", "additionalBound",
137 "typeArguments", "typeArgumentList", "typeArgument", "wildcard", "wildcardBounds",
138 "moduleName", "packageName", "typeName", "packageOrTypeName", "expressionName",
139 "methodName", "ambiguousName", "compilationUnit", "ordinaryCompilation",
140 "modularCompilation", "packageDeclaration", "packageModifier", "importDeclaration",
141 "singleTypeImportDeclaration", "typeImportOnDemandDeclaration", "singleStaticImportDeclaration",
142 "staticImportOnDemandDeclaration", "typeDeclaration", "moduleDeclaration",
143 "moduleDirective", "requiresDirective", "exportsDirective", "opensDirective",
144 "usesDirective", "providesDirective", "requiresModifier", "classDeclaration",
145 "normalClassDeclaration", "classModifier", "typeParameters", "typeParameterList",
146 "superclass", "superinterfaces", "interfaceTypeList", "classBody", "classBodyDeclaration",
147 "classMemberDeclaration", "fieldDeclaration", "fieldModifier", "variableDeclaratorList",
148 "variableDeclarator", "variableDeclaratorId", "variableInitializer", "unannType",
149 "unannPrimitiveType", "unannReferenceType", "unannClassOrInterfaceType",
150 "unannClassType", "unannClassType_lf_unannClassOrInterfaceType", "unannClassType_lfno_unannClassOrInterfaceType",
151 "unannInterfaceType", "unannInterfaceType_lf_unannClassOrInterfaceType",
152 "unannInterfaceType_lfno_unannClassOrInterfaceType", "unannTypeVariable",
153 "unannArrayType", "methodDeclaration", "methodModifier", "methodHeader",
154 "result", "methodDeclarator", "formalParameterList", "formalParameters",
155 "formalParameter", "variableModifier", "lastFormalParameter", "receiverParameter",
156 "throws_", "exceptionTypeList", "exceptionType", "methodBody", "instanceInitializer",
157 "staticInitializer", "constructorDeclaration", "constructorModifier",
158 "constructorDeclarator", "simpleTypeName", "constructorBody", "explicitConstructorInvocation",
159 "enumDeclaration", "enumBody", "enumConstantList", "enumConstant", "enumConstantModifier",
160 "enumBodyDeclarations", "interfaceDeclaration", "normalInterfaceDeclaration",
161 "interfaceModifier", "extendsInterfaces", "interfaceBody", "interfaceMemberDeclaration",
162 "constantDeclaration", "constantModifier", "interfaceMethodDeclaration",
163 "interfaceMethodModifier", "annotationTypeDeclaration", "annotationTypeBody",
164 "annotationTypeMemberDeclaration", "annotationTypeElementDeclaration",
165 "annotationTypeElementModifier", "defaultValue", "annotation", "normalAnnotation",
166 "elementValuePairList", "elementValuePair", "elementValue", "elementValueArrayInitializer",
167 "elementValueList", "markerAnnotation", "singleElementAnnotation", "arrayInitializer",
168 "variableInitializerList", "block", "blockStatements", "blockStatement",
169 "localVariableDeclarationStatement", "localVariableDeclaration", "statement",
170 "statementNoShortIf", "statementWithoutTrailingSubstatement", "emptyStatement",
171 "labeledStatement", "labeledStatementNoShortIf", "expressionStatement",
172 "statementExpression", "ifThenStatement", "ifThenElseStatement", "ifThenElseStatementNoShortIf",
173 "assertStatement", "switchStatement", "switchBlock", "switchBlockStatementGroup",
174 "switchLabels", "switchLabel", "enumConstantName", "whileStatement", "whileStatementNoShortIf",
175 "doStatement", "forStatement", "forStatementNoShortIf", "basicForStatement",
176 "basicForStatementNoShortIf", "forInit", "forUpdate", "statementExpressionList",
177 "enhancedForStatement", "enhancedForStatementNoShortIf", "breakStatement",
178 "continueStatement", "returnStatement", "throwStatement", "synchronizedStatement",
179 "tryStatement", "catches", "catchClause", "catchFormalParameter", "catchType",
180 "finally_", "tryWithResourcesStatement", "resourceSpecification", "resourceList",
181 "resource", "variableAccess", "primary", "primaryNoNewArray", "primaryNoNewArray_lf_arrayAccess",
182 "primaryNoNewArray_lfno_arrayAccess", "primaryNoNewArray_lf_primary",
183 "primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary", "primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary",
184 "primaryNoNewArray_lfno_primary", "primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary",
185 "primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary", "classLiteral",
186 "classInstanceCreationExpression", "classInstanceCreationExpression_lf_primary",
187 "classInstanceCreationExpression_lfno_primary", "typeArgumentsOrDiamond",
188 "fieldAccess", "fieldAccess_lf_primary", "fieldAccess_lfno_primary", "arrayAccess",
189 "arrayAccess_lf_primary", "arrayAccess_lfno_primary", "methodInvocation",
190 "methodInvocation_lf_primary", "methodInvocation_lfno_primary", "argumentList",
191 "methodReference", "methodReference_lf_primary", "methodReference_lfno_primary",
192 "arrayCreationExpression", "dimExprs", "dimExpr", "constantExpression",
193 "expression", "lambdaExpression", "lambdaParameters", "inferredFormalParameterList",
194 "lambdaBody", "assignmentExpression", "assignment", "leftHandSide", "assignmentOperator",
195 "conditionalExpression", "conditionalOrExpression", "conditionalAndExpression",
196 "inclusiveOrExpression", "exclusiveOrExpression", "andExpression", "equalityExpression",
197 "relationalExpression", "shiftExpression", "additiveExpression", "multiplicativeExpression",
198 "unaryExpression", "preIncrementExpression", "preDecrementExpression",
199 "unaryExpressionNotPlusMinus", "postfixExpression", "postIncrementExpression",
200 "postIncrementExpression_lf_postfixExpression", "postDecrementExpression",
201 "postDecrementExpression_lf_postfixExpression", "castExpression", "identifier"
202 };
203
204 private static final String[] _LITERAL_NAMES = {
205 null, "'open'", "'module'", "'requires'", "'exports'", "'to'", "'opens'",
206 "'uses'", "'provides'", "'with'", "'transitive'", "'abstract'", "'assert'",
207 "'boolean'", "'break'", "'byte'", "'case'", "'catch'", "'char'", "'class'",
208 "'const'", "'continue'", "'default'", "'do'", "'double'", "'else'", "'enum'",
209 "'extends'", "'final'", "'finally'", "'float'", "'for'", "'if'", "'goto'",
210 "'implements'", "'import'", "'instanceof'", "'int'", "'interface'", "'long'",
211 "'native'", "'new'", "'package'", "'private'", "'protected'", "'public'",
212 "'return'", "'short'", "'static'", "'strictfp'", "'super'", "'switch'",
213 "'synchronized'", "'this'", "'throw'", "'throws'", "'transient'", "'try'",
214 "'void'", "'volatile'", "'while'", "'_'", null, null, null, null, null,
215 "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", "';'", "','", "'.'",
216 "'...'", "'@'", "'::'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'",
217 "'->'", "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'",
218 "'+'", "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'+='", "'-='",
219 "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", "'>>>='"
220 };
221 private static final String[] _SYMBOLIC_NAMES = {
222 null, null, null, null, null, null, null, null, null, null, null, "ABSTRACT",
223 "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", "CHAR", "CLASS",
224 "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", "ENUM", "EXTENDS",
225 "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", "IMPORT",
226 "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE",
227 "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP",
228 "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT",
229 "TRY", "VOID", "VOLATILE", "WHILE", "UNDER_SCORE", "IntegerLiteral", "FloatingPointLiteral",
230 "BooleanLiteral", "CharacterLiteral", "StringLiteral", "NullLiteral",
231 "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA",
232 "DOT", "ELLIPSIS", "AT", "COLONCOLON", "ASSIGN", "GT", "LT", "BANG", "TILDE",
233 "QUESTION", "COLON", "ARROW", "EQUAL", "LE", "GE", "NOTEQUAL", "AND",
234 "OR", "INC", "DEC", "ADD", "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET",
235 "MOD", "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN",
236 "OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN",
237 "URSHIFT_ASSIGN", "Identifier", "WS", "COMMENT", "LINE_COMMENT"
238 };
239 public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
240
241
242
243
244 @Deprecated
245 public static final String[] tokenNames;
246 static {
247 tokenNames = new String[_SYMBOLIC_NAMES.length];
248 for (int i = 0; i < tokenNames.length; i++) {
249 tokenNames[i] = VOCABULARY.getLiteralName(i);
250 if (tokenNames[i] == null) {
251 tokenNames[i] = VOCABULARY.getSymbolicName(i);
252 }
253
254 if (tokenNames[i] == null) {
255 tokenNames[i] = "<INVALID>";
256 }
257 }
258 }
259
260 @Override
261 @Deprecated
262 public String[] getTokenNames() {
263 return tokenNames;
264 }
265
266 @Override
267
268 public Vocabulary getVocabulary() {
269 return VOCABULARY;
270 }
271
272 @Override
273 public String getGrammarFileName() { return "Java9.g4"; }
274
275 @Override
276 public String[] getRuleNames() { return ruleNames; }
277
278 @Override
279 public String getSerializedATN() { return _serializedATN; }
280
281 @Override
282 public ATN getATN() { return _ATN; }
283
284 public Java9Parser(TokenStream input) {
285 super(input);
286 _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
287 }
288 public static class LiteralContext extends ParserRuleContext {
289 public TerminalNode IntegerLiteral() { return getToken(Java9Parser.IntegerLiteral, 0); }
290 public TerminalNode FloatingPointLiteral() { return getToken(Java9Parser.FloatingPointLiteral, 0); }
291 public TerminalNode BooleanLiteral() { return getToken(Java9Parser.BooleanLiteral, 0); }
292 public TerminalNode CharacterLiteral() { return getToken(Java9Parser.CharacterLiteral, 0); }
293 public TerminalNode StringLiteral() { return getToken(Java9Parser.StringLiteral, 0); }
294 public TerminalNode NullLiteral() { return getToken(Java9Parser.NullLiteral, 0); }
295 public LiteralContext(ParserRuleContext parent, int invokingState) {
296 super(parent, invokingState);
297 }
298 @Override public int getRuleIndex() { return RULE_literal; }
299 @Override
300 public void enterRule(ParseTreeListener listener) {
301 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLiteral(this);
302 }
303 @Override
304 public void exitRule(ParseTreeListener listener) {
305 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLiteral(this);
306 }
307 }
308
309 public final LiteralContext literal() throws RecognitionException {
310 LiteralContext _localctx = new LiteralContext(_ctx, getState());
311 enterRule(_localctx, 0, RULE_literal);
312 int _la;
313 try {
314 enterOuterAlt(_localctx, 1);
315 {
316 setState(500);
317 _la = _input.LA(1);
318 if ( !(((((_la - 62)) & ~0x3f) == 0 && ((1L << (_la - 62)) & ((1L << (IntegerLiteral - 62)) | (1L << (FloatingPointLiteral - 62)) | (1L << (BooleanLiteral - 62)) | (1L << (CharacterLiteral - 62)) | (1L << (StringLiteral - 62)) | (1L << (NullLiteral - 62)))) != 0)) ) {
319 _errHandler.recoverInline(this);
320 }
321 else {
322 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
323 _errHandler.reportMatch(this);
324 consume();
325 }
326 }
327 }
328 catch (RecognitionException re) {
329 _localctx.exception = re;
330 _errHandler.reportError(this, re);
331 _errHandler.recover(this, re);
332 }
333 finally {
334 exitRule();
335 }
336 return _localctx;
337 }
338
339 public static class PrimitiveTypeContext extends ParserRuleContext {
340 public NumericTypeContext numericType() {
341 return getRuleContext(NumericTypeContext.class,0);
342 }
343 public List<AnnotationContext> annotation() {
344 return getRuleContexts(AnnotationContext.class);
345 }
346 public AnnotationContext annotation(int i) {
347 return getRuleContext(AnnotationContext.class,i);
348 }
349 public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) {
350 super(parent, invokingState);
351 }
352 @Override public int getRuleIndex() { return RULE_primitiveType; }
353 @Override
354 public void enterRule(ParseTreeListener listener) {
355 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimitiveType(this);
356 }
357 @Override
358 public void exitRule(ParseTreeListener listener) {
359 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimitiveType(this);
360 }
361 }
362
363 public final PrimitiveTypeContext primitiveType() throws RecognitionException {
364 PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState());
365 enterRule(_localctx, 2, RULE_primitiveType);
366 int _la;
367 try {
368 setState(516);
369 _errHandler.sync(this);
370 switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
371 case 1:
372 enterOuterAlt(_localctx, 1);
373 {
374 setState(505);
375 _errHandler.sync(this);
376 _la = _input.LA(1);
377 while (_la==AT) {
378 {
379 {
380 setState(502);
381 annotation();
382 }
383 }
384 setState(507);
385 _errHandler.sync(this);
386 _la = _input.LA(1);
387 }
388 setState(508);
389 numericType();
390 }
391 break;
392 case 2:
393 enterOuterAlt(_localctx, 2);
394 {
395 setState(512);
396 _errHandler.sync(this);
397 _la = _input.LA(1);
398 while (_la==AT) {
399 {
400 {
401 setState(509);
402 annotation();
403 }
404 }
405 setState(514);
406 _errHandler.sync(this);
407 _la = _input.LA(1);
408 }
409 setState(515);
410 match(BOOLEAN);
411 }
412 break;
413 }
414 }
415 catch (RecognitionException re) {
416 _localctx.exception = re;
417 _errHandler.reportError(this, re);
418 _errHandler.recover(this, re);
419 }
420 finally {
421 exitRule();
422 }
423 return _localctx;
424 }
425
426 public static class NumericTypeContext extends ParserRuleContext {
427 public IntegralTypeContext integralType() {
428 return getRuleContext(IntegralTypeContext.class,0);
429 }
430 public FloatingPointTypeContext floatingPointType() {
431 return getRuleContext(FloatingPointTypeContext.class,0);
432 }
433 public NumericTypeContext(ParserRuleContext parent, int invokingState) {
434 super(parent, invokingState);
435 }
436 @Override public int getRuleIndex() { return RULE_numericType; }
437 @Override
438 public void enterRule(ParseTreeListener listener) {
439 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterNumericType(this);
440 }
441 @Override
442 public void exitRule(ParseTreeListener listener) {
443 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitNumericType(this);
444 }
445 }
446
447 public final NumericTypeContext numericType() throws RecognitionException {
448 NumericTypeContext _localctx = new NumericTypeContext(_ctx, getState());
449 enterRule(_localctx, 4, RULE_numericType);
450 try {
451 setState(520);
452 _errHandler.sync(this);
453 switch (_input.LA(1)) {
454 case BYTE:
455 case CHAR:
456 case INT:
457 case LONG:
458 case SHORT:
459 enterOuterAlt(_localctx, 1);
460 {
461 setState(518);
462 integralType();
463 }
464 break;
465 case DOUBLE:
466 case FLOAT:
467 enterOuterAlt(_localctx, 2);
468 {
469 setState(519);
470 floatingPointType();
471 }
472 break;
473 default:
474 throw new NoViableAltException(this);
475 }
476 }
477 catch (RecognitionException re) {
478 _localctx.exception = re;
479 _errHandler.reportError(this, re);
480 _errHandler.recover(this, re);
481 }
482 finally {
483 exitRule();
484 }
485 return _localctx;
486 }
487
488 public static class IntegralTypeContext extends ParserRuleContext {
489 public IntegralTypeContext(ParserRuleContext parent, int invokingState) {
490 super(parent, invokingState);
491 }
492 @Override public int getRuleIndex() { return RULE_integralType; }
493 @Override
494 public void enterRule(ParseTreeListener listener) {
495 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterIntegralType(this);
496 }
497 @Override
498 public void exitRule(ParseTreeListener listener) {
499 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitIntegralType(this);
500 }
501 }
502
503 public final IntegralTypeContext integralType() throws RecognitionException {
504 IntegralTypeContext _localctx = new IntegralTypeContext(_ctx, getState());
505 enterRule(_localctx, 6, RULE_integralType);
506 int _la;
507 try {
508 enterOuterAlt(_localctx, 1);
509 {
510 setState(522);
511 _la = _input.LA(1);
512 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BYTE) | (1L << CHAR) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0)) ) {
513 _errHandler.recoverInline(this);
514 }
515 else {
516 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
517 _errHandler.reportMatch(this);
518 consume();
519 }
520 }
521 }
522 catch (RecognitionException re) {
523 _localctx.exception = re;
524 _errHandler.reportError(this, re);
525 _errHandler.recover(this, re);
526 }
527 finally {
528 exitRule();
529 }
530 return _localctx;
531 }
532
533 public static class FloatingPointTypeContext extends ParserRuleContext {
534 public FloatingPointTypeContext(ParserRuleContext parent, int invokingState) {
535 super(parent, invokingState);
536 }
537 @Override public int getRuleIndex() { return RULE_floatingPointType; }
538 @Override
539 public void enterRule(ParseTreeListener listener) {
540 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFloatingPointType(this);
541 }
542 @Override
543 public void exitRule(ParseTreeListener listener) {
544 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFloatingPointType(this);
545 }
546 }
547
548 public final FloatingPointTypeContext floatingPointType() throws RecognitionException {
549 FloatingPointTypeContext _localctx = new FloatingPointTypeContext(_ctx, getState());
550 enterRule(_localctx, 8, RULE_floatingPointType);
551 int _la;
552 try {
553 enterOuterAlt(_localctx, 1);
554 {
555 setState(524);
556 _la = _input.LA(1);
557 if ( !(_la==DOUBLE || _la==FLOAT) ) {
558 _errHandler.recoverInline(this);
559 }
560 else {
561 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
562 _errHandler.reportMatch(this);
563 consume();
564 }
565 }
566 }
567 catch (RecognitionException re) {
568 _localctx.exception = re;
569 _errHandler.reportError(this, re);
570 _errHandler.recover(this, re);
571 }
572 finally {
573 exitRule();
574 }
575 return _localctx;
576 }
577
578 public static class ReferenceTypeContext extends ParserRuleContext {
579 public ClassOrInterfaceTypeContext classOrInterfaceType() {
580 return getRuleContext(ClassOrInterfaceTypeContext.class,0);
581 }
582 public TypeVariableContext typeVariable() {
583 return getRuleContext(TypeVariableContext.class,0);
584 }
585 public ArrayTypeContext arrayType() {
586 return getRuleContext(ArrayTypeContext.class,0);
587 }
588 public ReferenceTypeContext(ParserRuleContext parent, int invokingState) {
589 super(parent, invokingState);
590 }
591 @Override public int getRuleIndex() { return RULE_referenceType; }
592 @Override
593 public void enterRule(ParseTreeListener listener) {
594 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterReferenceType(this);
595 }
596 @Override
597 public void exitRule(ParseTreeListener listener) {
598 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitReferenceType(this);
599 }
600 }
601
602 public final ReferenceTypeContext referenceType() throws RecognitionException {
603 ReferenceTypeContext _localctx = new ReferenceTypeContext(_ctx, getState());
604 enterRule(_localctx, 10, RULE_referenceType);
605 try {
606 setState(529);
607 _errHandler.sync(this);
608 switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
609 case 1:
610 enterOuterAlt(_localctx, 1);
611 {
612 setState(526);
613 classOrInterfaceType();
614 }
615 break;
616 case 2:
617 enterOuterAlt(_localctx, 2);
618 {
619 setState(527);
620 typeVariable();
621 }
622 break;
623 case 3:
624 enterOuterAlt(_localctx, 3);
625 {
626 setState(528);
627 arrayType();
628 }
629 break;
630 }
631 }
632 catch (RecognitionException re) {
633 _localctx.exception = re;
634 _errHandler.reportError(this, re);
635 _errHandler.recover(this, re);
636 }
637 finally {
638 exitRule();
639 }
640 return _localctx;
641 }
642
643 public static class ClassOrInterfaceTypeContext extends ParserRuleContext {
644 public ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() {
645 return getRuleContext(ClassType_lfno_classOrInterfaceTypeContext.class,0);
646 }
647 public InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_classOrInterfaceType() {
648 return getRuleContext(InterfaceType_lfno_classOrInterfaceTypeContext.class,0);
649 }
650 public List<ClassType_lf_classOrInterfaceTypeContext> classType_lf_classOrInterfaceType() {
651 return getRuleContexts(ClassType_lf_classOrInterfaceTypeContext.class);
652 }
653 public ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType(int i) {
654 return getRuleContext(ClassType_lf_classOrInterfaceTypeContext.class,i);
655 }
656 public List<InterfaceType_lf_classOrInterfaceTypeContext> interfaceType_lf_classOrInterfaceType() {
657 return getRuleContexts(InterfaceType_lf_classOrInterfaceTypeContext.class);
658 }
659 public InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_classOrInterfaceType(int i) {
660 return getRuleContext(InterfaceType_lf_classOrInterfaceTypeContext.class,i);
661 }
662 public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
663 super(parent, invokingState);
664 }
665 @Override public int getRuleIndex() { return RULE_classOrInterfaceType; }
666 @Override
667 public void enterRule(ParseTreeListener listener) {
668 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassOrInterfaceType(this);
669 }
670 @Override
671 public void exitRule(ParseTreeListener listener) {
672 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassOrInterfaceType(this);
673 }
674 }
675
676 public final ClassOrInterfaceTypeContext classOrInterfaceType() throws RecognitionException {
677 ClassOrInterfaceTypeContext _localctx = new ClassOrInterfaceTypeContext(_ctx, getState());
678 enterRule(_localctx, 12, RULE_classOrInterfaceType);
679 try {
680 int _alt;
681 enterOuterAlt(_localctx, 1);
682 {
683 setState(533);
684 _errHandler.sync(this);
685 switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
686 case 1:
687 {
688 setState(531);
689 classType_lfno_classOrInterfaceType();
690 }
691 break;
692 case 2:
693 {
694 setState(532);
695 interfaceType_lfno_classOrInterfaceType();
696 }
697 break;
698 }
699 setState(539);
700 _errHandler.sync(this);
701 _alt = getInterpreter().adaptivePredict(_input,7,_ctx);
702 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
703 if ( _alt==1 ) {
704 {
705 setState(537);
706 _errHandler.sync(this);
707 switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
708 case 1:
709 {
710 setState(535);
711 classType_lf_classOrInterfaceType();
712 }
713 break;
714 case 2:
715 {
716 setState(536);
717 interfaceType_lf_classOrInterfaceType();
718 }
719 break;
720 }
721 }
722 }
723 setState(541);
724 _errHandler.sync(this);
725 _alt = getInterpreter().adaptivePredict(_input,7,_ctx);
726 }
727 }
728 }
729 catch (RecognitionException re) {
730 _localctx.exception = re;
731 _errHandler.reportError(this, re);
732 _errHandler.recover(this, re);
733 }
734 finally {
735 exitRule();
736 }
737 return _localctx;
738 }
739
740 public static class ClassTypeContext extends ParserRuleContext {
741 public IdentifierContext identifier() {
742 return getRuleContext(IdentifierContext.class,0);
743 }
744 public List<AnnotationContext> annotation() {
745 return getRuleContexts(AnnotationContext.class);
746 }
747 public AnnotationContext annotation(int i) {
748 return getRuleContext(AnnotationContext.class,i);
749 }
750 public TypeArgumentsContext typeArguments() {
751 return getRuleContext(TypeArgumentsContext.class,0);
752 }
753 public ClassOrInterfaceTypeContext classOrInterfaceType() {
754 return getRuleContext(ClassOrInterfaceTypeContext.class,0);
755 }
756 public ClassTypeContext(ParserRuleContext parent, int invokingState) {
757 super(parent, invokingState);
758 }
759 @Override public int getRuleIndex() { return RULE_classType; }
760 @Override
761 public void enterRule(ParseTreeListener listener) {
762 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassType(this);
763 }
764 @Override
765 public void exitRule(ParseTreeListener listener) {
766 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassType(this);
767 }
768 }
769
770 public final ClassTypeContext classType() throws RecognitionException {
771 ClassTypeContext _localctx = new ClassTypeContext(_ctx, getState());
772 enterRule(_localctx, 14, RULE_classType);
773 int _la;
774 try {
775 setState(564);
776 _errHandler.sync(this);
777 switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
778 case 1:
779 enterOuterAlt(_localctx, 1);
780 {
781 setState(545);
782 _errHandler.sync(this);
783 _la = _input.LA(1);
784 while (_la==AT) {
785 {
786 {
787 setState(542);
788 annotation();
789 }
790 }
791 setState(547);
792 _errHandler.sync(this);
793 _la = _input.LA(1);
794 }
795 setState(548);
796 identifier();
797 setState(550);
798 _errHandler.sync(this);
799 _la = _input.LA(1);
800 if (_la==LT) {
801 {
802 setState(549);
803 typeArguments();
804 }
805 }
806
807 }
808 break;
809 case 2:
810 enterOuterAlt(_localctx, 2);
811 {
812 setState(552);
813 classOrInterfaceType();
814 setState(553);
815 match(DOT);
816 setState(557);
817 _errHandler.sync(this);
818 _la = _input.LA(1);
819 while (_la==AT) {
820 {
821 {
822 setState(554);
823 annotation();
824 }
825 }
826 setState(559);
827 _errHandler.sync(this);
828 _la = _input.LA(1);
829 }
830 setState(560);
831 identifier();
832 setState(562);
833 _errHandler.sync(this);
834 _la = _input.LA(1);
835 if (_la==LT) {
836 {
837 setState(561);
838 typeArguments();
839 }
840 }
841
842 }
843 break;
844 }
845 }
846 catch (RecognitionException re) {
847 _localctx.exception = re;
848 _errHandler.reportError(this, re);
849 _errHandler.recover(this, re);
850 }
851 finally {
852 exitRule();
853 }
854 return _localctx;
855 }
856
857 public static class ClassType_lf_classOrInterfaceTypeContext extends ParserRuleContext {
858 public IdentifierContext identifier() {
859 return getRuleContext(IdentifierContext.class,0);
860 }
861 public List<AnnotationContext> annotation() {
862 return getRuleContexts(AnnotationContext.class);
863 }
864 public AnnotationContext annotation(int i) {
865 return getRuleContext(AnnotationContext.class,i);
866 }
867 public TypeArgumentsContext typeArguments() {
868 return getRuleContext(TypeArgumentsContext.class,0);
869 }
870 public ClassType_lf_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
871 super(parent, invokingState);
872 }
873 @Override public int getRuleIndex() { return RULE_classType_lf_classOrInterfaceType; }
874 @Override
875 public void enterRule(ParseTreeListener listener) {
876 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassType_lf_classOrInterfaceType(this);
877 }
878 @Override
879 public void exitRule(ParseTreeListener listener) {
880 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassType_lf_classOrInterfaceType(this);
881 }
882 }
883
884 public final ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType() throws RecognitionException {
885 ClassType_lf_classOrInterfaceTypeContext _localctx = new ClassType_lf_classOrInterfaceTypeContext(_ctx, getState());
886 enterRule(_localctx, 16, RULE_classType_lf_classOrInterfaceType);
887 int _la;
888 try {
889 enterOuterAlt(_localctx, 1);
890 {
891 setState(566);
892 match(DOT);
893 setState(570);
894 _errHandler.sync(this);
895 _la = _input.LA(1);
896 while (_la==AT) {
897 {
898 {
899 setState(567);
900 annotation();
901 }
902 }
903 setState(572);
904 _errHandler.sync(this);
905 _la = _input.LA(1);
906 }
907 setState(573);
908 identifier();
909 setState(575);
910 _errHandler.sync(this);
911 switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
912 case 1:
913 {
914 setState(574);
915 typeArguments();
916 }
917 break;
918 }
919 }
920 }
921 catch (RecognitionException re) {
922 _localctx.exception = re;
923 _errHandler.reportError(this, re);
924 _errHandler.recover(this, re);
925 }
926 finally {
927 exitRule();
928 }
929 return _localctx;
930 }
931
932 public static class ClassType_lfno_classOrInterfaceTypeContext extends ParserRuleContext {
933 public IdentifierContext identifier() {
934 return getRuleContext(IdentifierContext.class,0);
935 }
936 public List<AnnotationContext> annotation() {
937 return getRuleContexts(AnnotationContext.class);
938 }
939 public AnnotationContext annotation(int i) {
940 return getRuleContext(AnnotationContext.class,i);
941 }
942 public TypeArgumentsContext typeArguments() {
943 return getRuleContext(TypeArgumentsContext.class,0);
944 }
945 public ClassType_lfno_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
946 super(parent, invokingState);
947 }
948 @Override public int getRuleIndex() { return RULE_classType_lfno_classOrInterfaceType; }
949 @Override
950 public void enterRule(ParseTreeListener listener) {
951 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassType_lfno_classOrInterfaceType(this);
952 }
953 @Override
954 public void exitRule(ParseTreeListener listener) {
955 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassType_lfno_classOrInterfaceType(this);
956 }
957 }
958
959 public final ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() throws RecognitionException {
960 ClassType_lfno_classOrInterfaceTypeContext _localctx = new ClassType_lfno_classOrInterfaceTypeContext(_ctx, getState());
961 enterRule(_localctx, 18, RULE_classType_lfno_classOrInterfaceType);
962 int _la;
963 try {
964 enterOuterAlt(_localctx, 1);
965 {
966 setState(580);
967 _errHandler.sync(this);
968 _la = _input.LA(1);
969 while (_la==AT) {
970 {
971 {
972 setState(577);
973 annotation();
974 }
975 }
976 setState(582);
977 _errHandler.sync(this);
978 _la = _input.LA(1);
979 }
980 setState(583);
981 identifier();
982 setState(585);
983 _errHandler.sync(this);
984 switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
985 case 1:
986 {
987 setState(584);
988 typeArguments();
989 }
990 break;
991 }
992 }
993 }
994 catch (RecognitionException re) {
995 _localctx.exception = re;
996 _errHandler.reportError(this, re);
997 _errHandler.recover(this, re);
998 }
999 finally {
1000 exitRule();
1001 }
1002 return _localctx;
1003 }
1004
1005 public static class InterfaceTypeContext extends ParserRuleContext {
1006 public ClassTypeContext classType() {
1007 return getRuleContext(ClassTypeContext.class,0);
1008 }
1009 public InterfaceTypeContext(ParserRuleContext parent, int invokingState) {
1010 super(parent, invokingState);
1011 }
1012 @Override public int getRuleIndex() { return RULE_interfaceType; }
1013 @Override
1014 public void enterRule(ParseTreeListener listener) {
1015 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceType(this);
1016 }
1017 @Override
1018 public void exitRule(ParseTreeListener listener) {
1019 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceType(this);
1020 }
1021 }
1022
1023 public final InterfaceTypeContext interfaceType() throws RecognitionException {
1024 InterfaceTypeContext _localctx = new InterfaceTypeContext(_ctx, getState());
1025 enterRule(_localctx, 20, RULE_interfaceType);
1026 try {
1027 enterOuterAlt(_localctx, 1);
1028 {
1029 setState(587);
1030 classType();
1031 }
1032 }
1033 catch (RecognitionException re) {
1034 _localctx.exception = re;
1035 _errHandler.reportError(this, re);
1036 _errHandler.recover(this, re);
1037 }
1038 finally {
1039 exitRule();
1040 }
1041 return _localctx;
1042 }
1043
1044 public static class InterfaceType_lf_classOrInterfaceTypeContext extends ParserRuleContext {
1045 public ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType() {
1046 return getRuleContext(ClassType_lf_classOrInterfaceTypeContext.class,0);
1047 }
1048 public InterfaceType_lf_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
1049 super(parent, invokingState);
1050 }
1051 @Override public int getRuleIndex() { return RULE_interfaceType_lf_classOrInterfaceType; }
1052 @Override
1053 public void enterRule(ParseTreeListener listener) {
1054 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceType_lf_classOrInterfaceType(this);
1055 }
1056 @Override
1057 public void exitRule(ParseTreeListener listener) {
1058 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceType_lf_classOrInterfaceType(this);
1059 }
1060 }
1061
1062 public final InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_classOrInterfaceType() throws RecognitionException {
1063 InterfaceType_lf_classOrInterfaceTypeContext _localctx = new InterfaceType_lf_classOrInterfaceTypeContext(_ctx, getState());
1064 enterRule(_localctx, 22, RULE_interfaceType_lf_classOrInterfaceType);
1065 try {
1066 enterOuterAlt(_localctx, 1);
1067 {
1068 setState(589);
1069 classType_lf_classOrInterfaceType();
1070 }
1071 }
1072 catch (RecognitionException re) {
1073 _localctx.exception = re;
1074 _errHandler.reportError(this, re);
1075 _errHandler.recover(this, re);
1076 }
1077 finally {
1078 exitRule();
1079 }
1080 return _localctx;
1081 }
1082
1083 public static class InterfaceType_lfno_classOrInterfaceTypeContext extends ParserRuleContext {
1084 public ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() {
1085 return getRuleContext(ClassType_lfno_classOrInterfaceTypeContext.class,0);
1086 }
1087 public InterfaceType_lfno_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
1088 super(parent, invokingState);
1089 }
1090 @Override public int getRuleIndex() { return RULE_interfaceType_lfno_classOrInterfaceType; }
1091 @Override
1092 public void enterRule(ParseTreeListener listener) {
1093 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceType_lfno_classOrInterfaceType(this);
1094 }
1095 @Override
1096 public void exitRule(ParseTreeListener listener) {
1097 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceType_lfno_classOrInterfaceType(this);
1098 }
1099 }
1100
1101 public final InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_classOrInterfaceType() throws RecognitionException {
1102 InterfaceType_lfno_classOrInterfaceTypeContext _localctx = new InterfaceType_lfno_classOrInterfaceTypeContext(_ctx, getState());
1103 enterRule(_localctx, 24, RULE_interfaceType_lfno_classOrInterfaceType);
1104 try {
1105 enterOuterAlt(_localctx, 1);
1106 {
1107 setState(591);
1108 classType_lfno_classOrInterfaceType();
1109 }
1110 }
1111 catch (RecognitionException re) {
1112 _localctx.exception = re;
1113 _errHandler.reportError(this, re);
1114 _errHandler.recover(this, re);
1115 }
1116 finally {
1117 exitRule();
1118 }
1119 return _localctx;
1120 }
1121
1122 public static class TypeVariableContext extends ParserRuleContext {
1123 public IdentifierContext identifier() {
1124 return getRuleContext(IdentifierContext.class,0);
1125 }
1126 public List<AnnotationContext> annotation() {
1127 return getRuleContexts(AnnotationContext.class);
1128 }
1129 public AnnotationContext annotation(int i) {
1130 return getRuleContext(AnnotationContext.class,i);
1131 }
1132 public TypeVariableContext(ParserRuleContext parent, int invokingState) {
1133 super(parent, invokingState);
1134 }
1135 @Override public int getRuleIndex() { return RULE_typeVariable; }
1136 @Override
1137 public void enterRule(ParseTreeListener listener) {
1138 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeVariable(this);
1139 }
1140 @Override
1141 public void exitRule(ParseTreeListener listener) {
1142 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeVariable(this);
1143 }
1144 }
1145
1146 public final TypeVariableContext typeVariable() throws RecognitionException {
1147 TypeVariableContext _localctx = new TypeVariableContext(_ctx, getState());
1148 enterRule(_localctx, 26, RULE_typeVariable);
1149 int _la;
1150 try {
1151 enterOuterAlt(_localctx, 1);
1152 {
1153 setState(596);
1154 _errHandler.sync(this);
1155 _la = _input.LA(1);
1156 while (_la==AT) {
1157 {
1158 {
1159 setState(593);
1160 annotation();
1161 }
1162 }
1163 setState(598);
1164 _errHandler.sync(this);
1165 _la = _input.LA(1);
1166 }
1167 setState(599);
1168 identifier();
1169 }
1170 }
1171 catch (RecognitionException re) {
1172 _localctx.exception = re;
1173 _errHandler.reportError(this, re);
1174 _errHandler.recover(this, re);
1175 }
1176 finally {
1177 exitRule();
1178 }
1179 return _localctx;
1180 }
1181
1182 public static class ArrayTypeContext extends ParserRuleContext {
1183 public PrimitiveTypeContext primitiveType() {
1184 return getRuleContext(PrimitiveTypeContext.class,0);
1185 }
1186 public DimsContext dims() {
1187 return getRuleContext(DimsContext.class,0);
1188 }
1189 public ClassOrInterfaceTypeContext classOrInterfaceType() {
1190 return getRuleContext(ClassOrInterfaceTypeContext.class,0);
1191 }
1192 public TypeVariableContext typeVariable() {
1193 return getRuleContext(TypeVariableContext.class,0);
1194 }
1195 public ArrayTypeContext(ParserRuleContext parent, int invokingState) {
1196 super(parent, invokingState);
1197 }
1198 @Override public int getRuleIndex() { return RULE_arrayType; }
1199 @Override
1200 public void enterRule(ParseTreeListener listener) {
1201 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterArrayType(this);
1202 }
1203 @Override
1204 public void exitRule(ParseTreeListener listener) {
1205 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitArrayType(this);
1206 }
1207 }
1208
1209 public final ArrayTypeContext arrayType() throws RecognitionException {
1210 ArrayTypeContext _localctx = new ArrayTypeContext(_ctx, getState());
1211 enterRule(_localctx, 28, RULE_arrayType);
1212 try {
1213 setState(610);
1214 _errHandler.sync(this);
1215 switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
1216 case 1:
1217 enterOuterAlt(_localctx, 1);
1218 {
1219 setState(601);
1220 primitiveType();
1221 setState(602);
1222 dims();
1223 }
1224 break;
1225 case 2:
1226 enterOuterAlt(_localctx, 2);
1227 {
1228 setState(604);
1229 classOrInterfaceType();
1230 setState(605);
1231 dims();
1232 }
1233 break;
1234 case 3:
1235 enterOuterAlt(_localctx, 3);
1236 {
1237 setState(607);
1238 typeVariable();
1239 setState(608);
1240 dims();
1241 }
1242 break;
1243 }
1244 }
1245 catch (RecognitionException re) {
1246 _localctx.exception = re;
1247 _errHandler.reportError(this, re);
1248 _errHandler.recover(this, re);
1249 }
1250 finally {
1251 exitRule();
1252 }
1253 return _localctx;
1254 }
1255
1256 public static class DimsContext extends ParserRuleContext {
1257 public List<AnnotationContext> annotation() {
1258 return getRuleContexts(AnnotationContext.class);
1259 }
1260 public AnnotationContext annotation(int i) {
1261 return getRuleContext(AnnotationContext.class,i);
1262 }
1263 public DimsContext(ParserRuleContext parent, int invokingState) {
1264 super(parent, invokingState);
1265 }
1266 @Override public int getRuleIndex() { return RULE_dims; }
1267 @Override
1268 public void enterRule(ParseTreeListener listener) {
1269 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterDims(this);
1270 }
1271 @Override
1272 public void exitRule(ParseTreeListener listener) {
1273 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitDims(this);
1274 }
1275 }
1276
1277 public final DimsContext dims() throws RecognitionException {
1278 DimsContext _localctx = new DimsContext(_ctx, getState());
1279 enterRule(_localctx, 30, RULE_dims);
1280 int _la;
1281 try {
1282 int _alt;
1283 enterOuterAlt(_localctx, 1);
1284 {
1285 setState(615);
1286 _errHandler.sync(this);
1287 _la = _input.LA(1);
1288 while (_la==AT) {
1289 {
1290 {
1291 setState(612);
1292 annotation();
1293 }
1294 }
1295 setState(617);
1296 _errHandler.sync(this);
1297 _la = _input.LA(1);
1298 }
1299 setState(618);
1300 match(LBRACK);
1301 setState(619);
1302 match(RBRACK);
1303 setState(630);
1304 _errHandler.sync(this);
1305 _alt = getInterpreter().adaptivePredict(_input,21,_ctx);
1306 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1307 if ( _alt==1 ) {
1308 {
1309 {
1310 setState(623);
1311 _errHandler.sync(this);
1312 _la = _input.LA(1);
1313 while (_la==AT) {
1314 {
1315 {
1316 setState(620);
1317 annotation();
1318 }
1319 }
1320 setState(625);
1321 _errHandler.sync(this);
1322 _la = _input.LA(1);
1323 }
1324 setState(626);
1325 match(LBRACK);
1326 setState(627);
1327 match(RBRACK);
1328 }
1329 }
1330 }
1331 setState(632);
1332 _errHandler.sync(this);
1333 _alt = getInterpreter().adaptivePredict(_input,21,_ctx);
1334 }
1335 }
1336 }
1337 catch (RecognitionException re) {
1338 _localctx.exception = re;
1339 _errHandler.reportError(this, re);
1340 _errHandler.recover(this, re);
1341 }
1342 finally {
1343 exitRule();
1344 }
1345 return _localctx;
1346 }
1347
1348 public static class TypeParameterContext extends ParserRuleContext {
1349 public IdentifierContext identifier() {
1350 return getRuleContext(IdentifierContext.class,0);
1351 }
1352 public List<TypeParameterModifierContext> typeParameterModifier() {
1353 return getRuleContexts(TypeParameterModifierContext.class);
1354 }
1355 public TypeParameterModifierContext typeParameterModifier(int i) {
1356 return getRuleContext(TypeParameterModifierContext.class,i);
1357 }
1358 public TypeBoundContext typeBound() {
1359 return getRuleContext(TypeBoundContext.class,0);
1360 }
1361 public TypeParameterContext(ParserRuleContext parent, int invokingState) {
1362 super(parent, invokingState);
1363 }
1364 @Override public int getRuleIndex() { return RULE_typeParameter; }
1365 @Override
1366 public void enterRule(ParseTreeListener listener) {
1367 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeParameter(this);
1368 }
1369 @Override
1370 public void exitRule(ParseTreeListener listener) {
1371 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeParameter(this);
1372 }
1373 }
1374
1375 public final TypeParameterContext typeParameter() throws RecognitionException {
1376 TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState());
1377 enterRule(_localctx, 32, RULE_typeParameter);
1378 int _la;
1379 try {
1380 enterOuterAlt(_localctx, 1);
1381 {
1382 setState(636);
1383 _errHandler.sync(this);
1384 _la = _input.LA(1);
1385 while (_la==AT) {
1386 {
1387 {
1388 setState(633);
1389 typeParameterModifier();
1390 }
1391 }
1392 setState(638);
1393 _errHandler.sync(this);
1394 _la = _input.LA(1);
1395 }
1396 setState(639);
1397 identifier();
1398 setState(641);
1399 _errHandler.sync(this);
1400 _la = _input.LA(1);
1401 if (_la==EXTENDS) {
1402 {
1403 setState(640);
1404 typeBound();
1405 }
1406 }
1407
1408 }
1409 }
1410 catch (RecognitionException re) {
1411 _localctx.exception = re;
1412 _errHandler.reportError(this, re);
1413 _errHandler.recover(this, re);
1414 }
1415 finally {
1416 exitRule();
1417 }
1418 return _localctx;
1419 }
1420
1421 public static class TypeParameterModifierContext extends ParserRuleContext {
1422 public AnnotationContext annotation() {
1423 return getRuleContext(AnnotationContext.class,0);
1424 }
1425 public TypeParameterModifierContext(ParserRuleContext parent, int invokingState) {
1426 super(parent, invokingState);
1427 }
1428 @Override public int getRuleIndex() { return RULE_typeParameterModifier; }
1429 @Override
1430 public void enterRule(ParseTreeListener listener) {
1431 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeParameterModifier(this);
1432 }
1433 @Override
1434 public void exitRule(ParseTreeListener listener) {
1435 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeParameterModifier(this);
1436 }
1437 }
1438
1439 public final TypeParameterModifierContext typeParameterModifier() throws RecognitionException {
1440 TypeParameterModifierContext _localctx = new TypeParameterModifierContext(_ctx, getState());
1441 enterRule(_localctx, 34, RULE_typeParameterModifier);
1442 try {
1443 enterOuterAlt(_localctx, 1);
1444 {
1445 setState(643);
1446 annotation();
1447 }
1448 }
1449 catch (RecognitionException re) {
1450 _localctx.exception = re;
1451 _errHandler.reportError(this, re);
1452 _errHandler.recover(this, re);
1453 }
1454 finally {
1455 exitRule();
1456 }
1457 return _localctx;
1458 }
1459
1460 public static class TypeBoundContext extends ParserRuleContext {
1461 public TypeVariableContext typeVariable() {
1462 return getRuleContext(TypeVariableContext.class,0);
1463 }
1464 public ClassOrInterfaceTypeContext classOrInterfaceType() {
1465 return getRuleContext(ClassOrInterfaceTypeContext.class,0);
1466 }
1467 public List<AdditionalBoundContext> additionalBound() {
1468 return getRuleContexts(AdditionalBoundContext.class);
1469 }
1470 public AdditionalBoundContext additionalBound(int i) {
1471 return getRuleContext(AdditionalBoundContext.class,i);
1472 }
1473 public TypeBoundContext(ParserRuleContext parent, int invokingState) {
1474 super(parent, invokingState);
1475 }
1476 @Override public int getRuleIndex() { return RULE_typeBound; }
1477 @Override
1478 public void enterRule(ParseTreeListener listener) {
1479 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeBound(this);
1480 }
1481 @Override
1482 public void exitRule(ParseTreeListener listener) {
1483 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeBound(this);
1484 }
1485 }
1486
1487 public final TypeBoundContext typeBound() throws RecognitionException {
1488 TypeBoundContext _localctx = new TypeBoundContext(_ctx, getState());
1489 enterRule(_localctx, 36, RULE_typeBound);
1490 int _la;
1491 try {
1492 setState(655);
1493 _errHandler.sync(this);
1494 switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
1495 case 1:
1496 enterOuterAlt(_localctx, 1);
1497 {
1498 setState(645);
1499 match(EXTENDS);
1500 setState(646);
1501 typeVariable();
1502 }
1503 break;
1504 case 2:
1505 enterOuterAlt(_localctx, 2);
1506 {
1507 setState(647);
1508 match(EXTENDS);
1509 setState(648);
1510 classOrInterfaceType();
1511 setState(652);
1512 _errHandler.sync(this);
1513 _la = _input.LA(1);
1514 while (_la==BITAND) {
1515 {
1516 {
1517 setState(649);
1518 additionalBound();
1519 }
1520 }
1521 setState(654);
1522 _errHandler.sync(this);
1523 _la = _input.LA(1);
1524 }
1525 }
1526 break;
1527 }
1528 }
1529 catch (RecognitionException re) {
1530 _localctx.exception = re;
1531 _errHandler.reportError(this, re);
1532 _errHandler.recover(this, re);
1533 }
1534 finally {
1535 exitRule();
1536 }
1537 return _localctx;
1538 }
1539
1540 public static class AdditionalBoundContext extends ParserRuleContext {
1541 public InterfaceTypeContext interfaceType() {
1542 return getRuleContext(InterfaceTypeContext.class,0);
1543 }
1544 public AdditionalBoundContext(ParserRuleContext parent, int invokingState) {
1545 super(parent, invokingState);
1546 }
1547 @Override public int getRuleIndex() { return RULE_additionalBound; }
1548 @Override
1549 public void enterRule(ParseTreeListener listener) {
1550 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAdditionalBound(this);
1551 }
1552 @Override
1553 public void exitRule(ParseTreeListener listener) {
1554 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAdditionalBound(this);
1555 }
1556 }
1557
1558 public final AdditionalBoundContext additionalBound() throws RecognitionException {
1559 AdditionalBoundContext _localctx = new AdditionalBoundContext(_ctx, getState());
1560 enterRule(_localctx, 38, RULE_additionalBound);
1561 try {
1562 enterOuterAlt(_localctx, 1);
1563 {
1564 setState(657);
1565 match(BITAND);
1566 setState(658);
1567 interfaceType();
1568 }
1569 }
1570 catch (RecognitionException re) {
1571 _localctx.exception = re;
1572 _errHandler.reportError(this, re);
1573 _errHandler.recover(this, re);
1574 }
1575 finally {
1576 exitRule();
1577 }
1578 return _localctx;
1579 }
1580
1581 public static class TypeArgumentsContext extends ParserRuleContext {
1582 public TypeArgumentListContext typeArgumentList() {
1583 return getRuleContext(TypeArgumentListContext.class,0);
1584 }
1585 public TypeArgumentsContext(ParserRuleContext parent, int invokingState) {
1586 super(parent, invokingState);
1587 }
1588 @Override public int getRuleIndex() { return RULE_typeArguments; }
1589 @Override
1590 public void enterRule(ParseTreeListener listener) {
1591 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeArguments(this);
1592 }
1593 @Override
1594 public void exitRule(ParseTreeListener listener) {
1595 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeArguments(this);
1596 }
1597 }
1598
1599 public final TypeArgumentsContext typeArguments() throws RecognitionException {
1600 TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState());
1601 enterRule(_localctx, 40, RULE_typeArguments);
1602 try {
1603 enterOuterAlt(_localctx, 1);
1604 {
1605 setState(660);
1606 match(LT);
1607 setState(661);
1608 typeArgumentList();
1609 setState(662);
1610 match(GT);
1611 }
1612 }
1613 catch (RecognitionException re) {
1614 _localctx.exception = re;
1615 _errHandler.reportError(this, re);
1616 _errHandler.recover(this, re);
1617 }
1618 finally {
1619 exitRule();
1620 }
1621 return _localctx;
1622 }
1623
1624 public static class TypeArgumentListContext extends ParserRuleContext {
1625 public List<TypeArgumentContext> typeArgument() {
1626 return getRuleContexts(TypeArgumentContext.class);
1627 }
1628 public TypeArgumentContext typeArgument(int i) {
1629 return getRuleContext(TypeArgumentContext.class,i);
1630 }
1631 public TypeArgumentListContext(ParserRuleContext parent, int invokingState) {
1632 super(parent, invokingState);
1633 }
1634 @Override public int getRuleIndex() { return RULE_typeArgumentList; }
1635 @Override
1636 public void enterRule(ParseTreeListener listener) {
1637 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeArgumentList(this);
1638 }
1639 @Override
1640 public void exitRule(ParseTreeListener listener) {
1641 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeArgumentList(this);
1642 }
1643 }
1644
1645 public final TypeArgumentListContext typeArgumentList() throws RecognitionException {
1646 TypeArgumentListContext _localctx = new TypeArgumentListContext(_ctx, getState());
1647 enterRule(_localctx, 42, RULE_typeArgumentList);
1648 int _la;
1649 try {
1650 enterOuterAlt(_localctx, 1);
1651 {
1652 setState(664);
1653 typeArgument();
1654 setState(669);
1655 _errHandler.sync(this);
1656 _la = _input.LA(1);
1657 while (_la==COMMA) {
1658 {
1659 {
1660 setState(665);
1661 match(COMMA);
1662 setState(666);
1663 typeArgument();
1664 }
1665 }
1666 setState(671);
1667 _errHandler.sync(this);
1668 _la = _input.LA(1);
1669 }
1670 }
1671 }
1672 catch (RecognitionException re) {
1673 _localctx.exception = re;
1674 _errHandler.reportError(this, re);
1675 _errHandler.recover(this, re);
1676 }
1677 finally {
1678 exitRule();
1679 }
1680 return _localctx;
1681 }
1682
1683 public static class TypeArgumentContext extends ParserRuleContext {
1684 public ReferenceTypeContext referenceType() {
1685 return getRuleContext(ReferenceTypeContext.class,0);
1686 }
1687 public WildcardContext wildcard() {
1688 return getRuleContext(WildcardContext.class,0);
1689 }
1690 public TypeArgumentContext(ParserRuleContext parent, int invokingState) {
1691 super(parent, invokingState);
1692 }
1693 @Override public int getRuleIndex() { return RULE_typeArgument; }
1694 @Override
1695 public void enterRule(ParseTreeListener listener) {
1696 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeArgument(this);
1697 }
1698 @Override
1699 public void exitRule(ParseTreeListener listener) {
1700 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeArgument(this);
1701 }
1702 }
1703
1704 public final TypeArgumentContext typeArgument() throws RecognitionException {
1705 TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState());
1706 enterRule(_localctx, 44, RULE_typeArgument);
1707 try {
1708 setState(674);
1709 _errHandler.sync(this);
1710 switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
1711 case 1:
1712 enterOuterAlt(_localctx, 1);
1713 {
1714 setState(672);
1715 referenceType();
1716 }
1717 break;
1718 case 2:
1719 enterOuterAlt(_localctx, 2);
1720 {
1721 setState(673);
1722 wildcard();
1723 }
1724 break;
1725 }
1726 }
1727 catch (RecognitionException re) {
1728 _localctx.exception = re;
1729 _errHandler.reportError(this, re);
1730 _errHandler.recover(this, re);
1731 }
1732 finally {
1733 exitRule();
1734 }
1735 return _localctx;
1736 }
1737
1738 public static class WildcardContext extends ParserRuleContext {
1739 public List<AnnotationContext> annotation() {
1740 return getRuleContexts(AnnotationContext.class);
1741 }
1742 public AnnotationContext annotation(int i) {
1743 return getRuleContext(AnnotationContext.class,i);
1744 }
1745 public WildcardBoundsContext wildcardBounds() {
1746 return getRuleContext(WildcardBoundsContext.class,0);
1747 }
1748 public WildcardContext(ParserRuleContext parent, int invokingState) {
1749 super(parent, invokingState);
1750 }
1751 @Override public int getRuleIndex() { return RULE_wildcard; }
1752 @Override
1753 public void enterRule(ParseTreeListener listener) {
1754 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterWildcard(this);
1755 }
1756 @Override
1757 public void exitRule(ParseTreeListener listener) {
1758 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitWildcard(this);
1759 }
1760 }
1761
1762 public final WildcardContext wildcard() throws RecognitionException {
1763 WildcardContext _localctx = new WildcardContext(_ctx, getState());
1764 enterRule(_localctx, 46, RULE_wildcard);
1765 int _la;
1766 try {
1767 enterOuterAlt(_localctx, 1);
1768 {
1769 setState(679);
1770 _errHandler.sync(this);
1771 _la = _input.LA(1);
1772 while (_la==AT) {
1773 {
1774 {
1775 setState(676);
1776 annotation();
1777 }
1778 }
1779 setState(681);
1780 _errHandler.sync(this);
1781 _la = _input.LA(1);
1782 }
1783 setState(682);
1784 match(QUESTION);
1785 setState(684);
1786 _errHandler.sync(this);
1787 _la = _input.LA(1);
1788 if (_la==EXTENDS || _la==SUPER) {
1789 {
1790 setState(683);
1791 wildcardBounds();
1792 }
1793 }
1794
1795 }
1796 }
1797 catch (RecognitionException re) {
1798 _localctx.exception = re;
1799 _errHandler.reportError(this, re);
1800 _errHandler.recover(this, re);
1801 }
1802 finally {
1803 exitRule();
1804 }
1805 return _localctx;
1806 }
1807
1808 public static class WildcardBoundsContext extends ParserRuleContext {
1809 public ReferenceTypeContext referenceType() {
1810 return getRuleContext(ReferenceTypeContext.class,0);
1811 }
1812 public WildcardBoundsContext(ParserRuleContext parent, int invokingState) {
1813 super(parent, invokingState);
1814 }
1815 @Override public int getRuleIndex() { return RULE_wildcardBounds; }
1816 @Override
1817 public void enterRule(ParseTreeListener listener) {
1818 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterWildcardBounds(this);
1819 }
1820 @Override
1821 public void exitRule(ParseTreeListener listener) {
1822 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitWildcardBounds(this);
1823 }
1824 }
1825
1826 public final WildcardBoundsContext wildcardBounds() throws RecognitionException {
1827 WildcardBoundsContext _localctx = new WildcardBoundsContext(_ctx, getState());
1828 enterRule(_localctx, 48, RULE_wildcardBounds);
1829 try {
1830 setState(690);
1831 _errHandler.sync(this);
1832 switch (_input.LA(1)) {
1833 case EXTENDS:
1834 enterOuterAlt(_localctx, 1);
1835 {
1836 setState(686);
1837 match(EXTENDS);
1838 setState(687);
1839 referenceType();
1840 }
1841 break;
1842 case SUPER:
1843 enterOuterAlt(_localctx, 2);
1844 {
1845 setState(688);
1846 match(SUPER);
1847 setState(689);
1848 referenceType();
1849 }
1850 break;
1851 default:
1852 throw new NoViableAltException(this);
1853 }
1854 }
1855 catch (RecognitionException re) {
1856 _localctx.exception = re;
1857 _errHandler.reportError(this, re);
1858 _errHandler.recover(this, re);
1859 }
1860 finally {
1861 exitRule();
1862 }
1863 return _localctx;
1864 }
1865
1866 public static class ModuleNameContext extends ParserRuleContext {
1867 public IdentifierContext identifier() {
1868 return getRuleContext(IdentifierContext.class,0);
1869 }
1870 public ModuleNameContext moduleName() {
1871 return getRuleContext(ModuleNameContext.class,0);
1872 }
1873 public ModuleNameContext(ParserRuleContext parent, int invokingState) {
1874 super(parent, invokingState);
1875 }
1876 @Override public int getRuleIndex() { return RULE_moduleName; }
1877 @Override
1878 public void enterRule(ParseTreeListener listener) {
1879 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterModuleName(this);
1880 }
1881 @Override
1882 public void exitRule(ParseTreeListener listener) {
1883 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitModuleName(this);
1884 }
1885 }
1886
1887 public final ModuleNameContext moduleName() throws RecognitionException {
1888 return moduleName(0);
1889 }
1890
1891 private ModuleNameContext moduleName(int _p) throws RecognitionException {
1892 ParserRuleContext _parentctx = _ctx;
1893 int _parentState = getState();
1894 ModuleNameContext _localctx = new ModuleNameContext(_ctx, _parentState);
1895 ModuleNameContext _prevctx = _localctx;
1896 int _startState = 50;
1897 enterRecursionRule(_localctx, 50, RULE_moduleName, _p);
1898 try {
1899 int _alt;
1900 enterOuterAlt(_localctx, 1);
1901 {
1902 {
1903 setState(693);
1904 identifier();
1905 }
1906 _ctx.stop = _input.LT(-1);
1907 setState(700);
1908 _errHandler.sync(this);
1909 _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
1910 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1911 if ( _alt==1 ) {
1912 if ( _parseListeners!=null ) triggerExitRuleEvent();
1913 _prevctx = _localctx;
1914 {
1915 {
1916 _localctx = new ModuleNameContext(_parentctx, _parentState);
1917 pushNewRecursionContext(_localctx, _startState, RULE_moduleName);
1918 setState(695);
1919 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
1920 setState(696);
1921 match(DOT);
1922 setState(697);
1923 identifier();
1924 }
1925 }
1926 }
1927 setState(702);
1928 _errHandler.sync(this);
1929 _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
1930 }
1931 }
1932 }
1933 catch (RecognitionException re) {
1934 _localctx.exception = re;
1935 _errHandler.reportError(this, re);
1936 _errHandler.recover(this, re);
1937 }
1938 finally {
1939 unrollRecursionContexts(_parentctx);
1940 }
1941 return _localctx;
1942 }
1943
1944 public static class PackageNameContext extends ParserRuleContext {
1945 public IdentifierContext identifier() {
1946 return getRuleContext(IdentifierContext.class,0);
1947 }
1948 public PackageNameContext packageName() {
1949 return getRuleContext(PackageNameContext.class,0);
1950 }
1951 public PackageNameContext(ParserRuleContext parent, int invokingState) {
1952 super(parent, invokingState);
1953 }
1954 @Override public int getRuleIndex() { return RULE_packageName; }
1955 @Override
1956 public void enterRule(ParseTreeListener listener) {
1957 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPackageName(this);
1958 }
1959 @Override
1960 public void exitRule(ParseTreeListener listener) {
1961 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPackageName(this);
1962 }
1963 }
1964
1965 public final PackageNameContext packageName() throws RecognitionException {
1966 return packageName(0);
1967 }
1968
1969 private PackageNameContext packageName(int _p) throws RecognitionException {
1970 ParserRuleContext _parentctx = _ctx;
1971 int _parentState = getState();
1972 PackageNameContext _localctx = new PackageNameContext(_ctx, _parentState);
1973 PackageNameContext _prevctx = _localctx;
1974 int _startState = 52;
1975 enterRecursionRule(_localctx, 52, RULE_packageName, _p);
1976 try {
1977 int _alt;
1978 enterOuterAlt(_localctx, 1);
1979 {
1980 {
1981 setState(704);
1982 identifier();
1983 }
1984 _ctx.stop = _input.LT(-1);
1985 setState(711);
1986 _errHandler.sync(this);
1987 _alt = getInterpreter().adaptivePredict(_input,32,_ctx);
1988 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1989 if ( _alt==1 ) {
1990 if ( _parseListeners!=null ) triggerExitRuleEvent();
1991 _prevctx = _localctx;
1992 {
1993 {
1994 _localctx = new PackageNameContext(_parentctx, _parentState);
1995 pushNewRecursionContext(_localctx, _startState, RULE_packageName);
1996 setState(706);
1997 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
1998 setState(707);
1999 match(DOT);
2000 setState(708);
2001 identifier();
2002 }
2003 }
2004 }
2005 setState(713);
2006 _errHandler.sync(this);
2007 _alt = getInterpreter().adaptivePredict(_input,32,_ctx);
2008 }
2009 }
2010 }
2011 catch (RecognitionException re) {
2012 _localctx.exception = re;
2013 _errHandler.reportError(this, re);
2014 _errHandler.recover(this, re);
2015 }
2016 finally {
2017 unrollRecursionContexts(_parentctx);
2018 }
2019 return _localctx;
2020 }
2021
2022 public static class TypeNameContext extends ParserRuleContext {
2023 public IdentifierContext identifier() {
2024 return getRuleContext(IdentifierContext.class,0);
2025 }
2026 public PackageOrTypeNameContext packageOrTypeName() {
2027 return getRuleContext(PackageOrTypeNameContext.class,0);
2028 }
2029 public TypeNameContext(ParserRuleContext parent, int invokingState) {
2030 super(parent, invokingState);
2031 }
2032 @Override public int getRuleIndex() { return RULE_typeName; }
2033 @Override
2034 public void enterRule(ParseTreeListener listener) {
2035 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeName(this);
2036 }
2037 @Override
2038 public void exitRule(ParseTreeListener listener) {
2039 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeName(this);
2040 }
2041 }
2042
2043 public final TypeNameContext typeName() throws RecognitionException {
2044 TypeNameContext _localctx = new TypeNameContext(_ctx, getState());
2045 enterRule(_localctx, 54, RULE_typeName);
2046 try {
2047 setState(719);
2048 _errHandler.sync(this);
2049 switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
2050 case 1:
2051 enterOuterAlt(_localctx, 1);
2052 {
2053 setState(714);
2054 identifier();
2055 }
2056 break;
2057 case 2:
2058 enterOuterAlt(_localctx, 2);
2059 {
2060 setState(715);
2061 packageOrTypeName(0);
2062 setState(716);
2063 match(DOT);
2064 setState(717);
2065 identifier();
2066 }
2067 break;
2068 }
2069 }
2070 catch (RecognitionException re) {
2071 _localctx.exception = re;
2072 _errHandler.reportError(this, re);
2073 _errHandler.recover(this, re);
2074 }
2075 finally {
2076 exitRule();
2077 }
2078 return _localctx;
2079 }
2080
2081 public static class PackageOrTypeNameContext extends ParserRuleContext {
2082 public IdentifierContext identifier() {
2083 return getRuleContext(IdentifierContext.class,0);
2084 }
2085 public PackageOrTypeNameContext packageOrTypeName() {
2086 return getRuleContext(PackageOrTypeNameContext.class,0);
2087 }
2088 public PackageOrTypeNameContext(ParserRuleContext parent, int invokingState) {
2089 super(parent, invokingState);
2090 }
2091 @Override public int getRuleIndex() { return RULE_packageOrTypeName; }
2092 @Override
2093 public void enterRule(ParseTreeListener listener) {
2094 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPackageOrTypeName(this);
2095 }
2096 @Override
2097 public void exitRule(ParseTreeListener listener) {
2098 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPackageOrTypeName(this);
2099 }
2100 }
2101
2102 public final PackageOrTypeNameContext packageOrTypeName() throws RecognitionException {
2103 return packageOrTypeName(0);
2104 }
2105
2106 private PackageOrTypeNameContext packageOrTypeName(int _p) throws RecognitionException {
2107 ParserRuleContext _parentctx = _ctx;
2108 int _parentState = getState();
2109 PackageOrTypeNameContext _localctx = new PackageOrTypeNameContext(_ctx, _parentState);
2110 PackageOrTypeNameContext _prevctx = _localctx;
2111 int _startState = 56;
2112 enterRecursionRule(_localctx, 56, RULE_packageOrTypeName, _p);
2113 try {
2114 int _alt;
2115 enterOuterAlt(_localctx, 1);
2116 {
2117 {
2118 setState(722);
2119 identifier();
2120 }
2121 _ctx.stop = _input.LT(-1);
2122 setState(729);
2123 _errHandler.sync(this);
2124 _alt = getInterpreter().adaptivePredict(_input,34,_ctx);
2125 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
2126 if ( _alt==1 ) {
2127 if ( _parseListeners!=null ) triggerExitRuleEvent();
2128 _prevctx = _localctx;
2129 {
2130 {
2131 _localctx = new PackageOrTypeNameContext(_parentctx, _parentState);
2132 pushNewRecursionContext(_localctx, _startState, RULE_packageOrTypeName);
2133 setState(724);
2134 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
2135 setState(725);
2136 match(DOT);
2137 setState(726);
2138 identifier();
2139 }
2140 }
2141 }
2142 setState(731);
2143 _errHandler.sync(this);
2144 _alt = getInterpreter().adaptivePredict(_input,34,_ctx);
2145 }
2146 }
2147 }
2148 catch (RecognitionException re) {
2149 _localctx.exception = re;
2150 _errHandler.reportError(this, re);
2151 _errHandler.recover(this, re);
2152 }
2153 finally {
2154 unrollRecursionContexts(_parentctx);
2155 }
2156 return _localctx;
2157 }
2158
2159 public static class ExpressionNameContext extends ParserRuleContext {
2160 public IdentifierContext identifier() {
2161 return getRuleContext(IdentifierContext.class,0);
2162 }
2163 public AmbiguousNameContext ambiguousName() {
2164 return getRuleContext(AmbiguousNameContext.class,0);
2165 }
2166 public ExpressionNameContext(ParserRuleContext parent, int invokingState) {
2167 super(parent, invokingState);
2168 }
2169 @Override public int getRuleIndex() { return RULE_expressionName; }
2170 @Override
2171 public void enterRule(ParseTreeListener listener) {
2172 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExpressionName(this);
2173 }
2174 @Override
2175 public void exitRule(ParseTreeListener listener) {
2176 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExpressionName(this);
2177 }
2178 }
2179
2180 public final ExpressionNameContext expressionName() throws RecognitionException {
2181 ExpressionNameContext _localctx = new ExpressionNameContext(_ctx, getState());
2182 enterRule(_localctx, 58, RULE_expressionName);
2183 try {
2184 setState(737);
2185 _errHandler.sync(this);
2186 switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
2187 case 1:
2188 enterOuterAlt(_localctx, 1);
2189 {
2190 setState(732);
2191 identifier();
2192 }
2193 break;
2194 case 2:
2195 enterOuterAlt(_localctx, 2);
2196 {
2197 setState(733);
2198 ambiguousName(0);
2199 setState(734);
2200 match(DOT);
2201 setState(735);
2202 identifier();
2203 }
2204 break;
2205 }
2206 }
2207 catch (RecognitionException re) {
2208 _localctx.exception = re;
2209 _errHandler.reportError(this, re);
2210 _errHandler.recover(this, re);
2211 }
2212 finally {
2213 exitRule();
2214 }
2215 return _localctx;
2216 }
2217
2218 public static class MethodNameContext extends ParserRuleContext {
2219 public IdentifierContext identifier() {
2220 return getRuleContext(IdentifierContext.class,0);
2221 }
2222 public MethodNameContext(ParserRuleContext parent, int invokingState) {
2223 super(parent, invokingState);
2224 }
2225 @Override public int getRuleIndex() { return RULE_methodName; }
2226 @Override
2227 public void enterRule(ParseTreeListener listener) {
2228 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodName(this);
2229 }
2230 @Override
2231 public void exitRule(ParseTreeListener listener) {
2232 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodName(this);
2233 }
2234 }
2235
2236 public final MethodNameContext methodName() throws RecognitionException {
2237 MethodNameContext _localctx = new MethodNameContext(_ctx, getState());
2238 enterRule(_localctx, 60, RULE_methodName);
2239 try {
2240 enterOuterAlt(_localctx, 1);
2241 {
2242 setState(739);
2243 identifier();
2244 }
2245 }
2246 catch (RecognitionException re) {
2247 _localctx.exception = re;
2248 _errHandler.reportError(this, re);
2249 _errHandler.recover(this, re);
2250 }
2251 finally {
2252 exitRule();
2253 }
2254 return _localctx;
2255 }
2256
2257 public static class AmbiguousNameContext extends ParserRuleContext {
2258 public IdentifierContext identifier() {
2259 return getRuleContext(IdentifierContext.class,0);
2260 }
2261 public AmbiguousNameContext ambiguousName() {
2262 return getRuleContext(AmbiguousNameContext.class,0);
2263 }
2264 public AmbiguousNameContext(ParserRuleContext parent, int invokingState) {
2265 super(parent, invokingState);
2266 }
2267 @Override public int getRuleIndex() { return RULE_ambiguousName; }
2268 @Override
2269 public void enterRule(ParseTreeListener listener) {
2270 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAmbiguousName(this);
2271 }
2272 @Override
2273 public void exitRule(ParseTreeListener listener) {
2274 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAmbiguousName(this);
2275 }
2276 }
2277
2278 public final AmbiguousNameContext ambiguousName() throws RecognitionException {
2279 return ambiguousName(0);
2280 }
2281
2282 private AmbiguousNameContext ambiguousName(int _p) throws RecognitionException {
2283 ParserRuleContext _parentctx = _ctx;
2284 int _parentState = getState();
2285 AmbiguousNameContext _localctx = new AmbiguousNameContext(_ctx, _parentState);
2286 AmbiguousNameContext _prevctx = _localctx;
2287 int _startState = 62;
2288 enterRecursionRule(_localctx, 62, RULE_ambiguousName, _p);
2289 try {
2290 int _alt;
2291 enterOuterAlt(_localctx, 1);
2292 {
2293 {
2294 setState(742);
2295 identifier();
2296 }
2297 _ctx.stop = _input.LT(-1);
2298 setState(749);
2299 _errHandler.sync(this);
2300 _alt = getInterpreter().adaptivePredict(_input,36,_ctx);
2301 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
2302 if ( _alt==1 ) {
2303 if ( _parseListeners!=null ) triggerExitRuleEvent();
2304 _prevctx = _localctx;
2305 {
2306 {
2307 _localctx = new AmbiguousNameContext(_parentctx, _parentState);
2308 pushNewRecursionContext(_localctx, _startState, RULE_ambiguousName);
2309 setState(744);
2310 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
2311 setState(745);
2312 match(DOT);
2313 setState(746);
2314 identifier();
2315 }
2316 }
2317 }
2318 setState(751);
2319 _errHandler.sync(this);
2320 _alt = getInterpreter().adaptivePredict(_input,36,_ctx);
2321 }
2322 }
2323 }
2324 catch (RecognitionException re) {
2325 _localctx.exception = re;
2326 _errHandler.reportError(this, re);
2327 _errHandler.recover(this, re);
2328 }
2329 finally {
2330 unrollRecursionContexts(_parentctx);
2331 }
2332 return _localctx;
2333 }
2334
2335 public static class CompilationUnitContext extends ParserRuleContext {
2336 public OrdinaryCompilationContext ordinaryCompilation() {
2337 return getRuleContext(OrdinaryCompilationContext.class,0);
2338 }
2339 public ModularCompilationContext modularCompilation() {
2340 return getRuleContext(ModularCompilationContext.class,0);
2341 }
2342 public CompilationUnitContext(ParserRuleContext parent, int invokingState) {
2343 super(parent, invokingState);
2344 }
2345 @Override public int getRuleIndex() { return RULE_compilationUnit; }
2346 @Override
2347 public void enterRule(ParseTreeListener listener) {
2348 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterCompilationUnit(this);
2349 }
2350 @Override
2351 public void exitRule(ParseTreeListener listener) {
2352 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitCompilationUnit(this);
2353 }
2354 }
2355
2356 public final CompilationUnitContext compilationUnit() throws RecognitionException {
2357 CompilationUnitContext _localctx = new CompilationUnitContext(_ctx, getState());
2358 enterRule(_localctx, 64, RULE_compilationUnit);
2359 try {
2360 setState(754);
2361 _errHandler.sync(this);
2362 switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
2363 case 1:
2364 enterOuterAlt(_localctx, 1);
2365 {
2366 setState(752);
2367 ordinaryCompilation();
2368 }
2369 break;
2370 case 2:
2371 enterOuterAlt(_localctx, 2);
2372 {
2373 setState(753);
2374 modularCompilation();
2375 }
2376 break;
2377 }
2378 }
2379 catch (RecognitionException re) {
2380 _localctx.exception = re;
2381 _errHandler.reportError(this, re);
2382 _errHandler.recover(this, re);
2383 }
2384 finally {
2385 exitRule();
2386 }
2387 return _localctx;
2388 }
2389
2390 public static class OrdinaryCompilationContext extends ParserRuleContext {
2391 public TerminalNode EOF() { return getToken(Java9Parser.EOF, 0); }
2392 public PackageDeclarationContext packageDeclaration() {
2393 return getRuleContext(PackageDeclarationContext.class,0);
2394 }
2395 public List<ImportDeclarationContext> importDeclaration() {
2396 return getRuleContexts(ImportDeclarationContext.class);
2397 }
2398 public ImportDeclarationContext importDeclaration(int i) {
2399 return getRuleContext(ImportDeclarationContext.class,i);
2400 }
2401 public List<TypeDeclarationContext> typeDeclaration() {
2402 return getRuleContexts(TypeDeclarationContext.class);
2403 }
2404 public TypeDeclarationContext typeDeclaration(int i) {
2405 return getRuleContext(TypeDeclarationContext.class,i);
2406 }
2407 public OrdinaryCompilationContext(ParserRuleContext parent, int invokingState) {
2408 super(parent, invokingState);
2409 }
2410 @Override public int getRuleIndex() { return RULE_ordinaryCompilation; }
2411 @Override
2412 public void enterRule(ParseTreeListener listener) {
2413 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterOrdinaryCompilation(this);
2414 }
2415 @Override
2416 public void exitRule(ParseTreeListener listener) {
2417 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitOrdinaryCompilation(this);
2418 }
2419 }
2420
2421 public final OrdinaryCompilationContext ordinaryCompilation() throws RecognitionException {
2422 OrdinaryCompilationContext _localctx = new OrdinaryCompilationContext(_ctx, getState());
2423 enterRule(_localctx, 66, RULE_ordinaryCompilation);
2424 int _la;
2425 try {
2426 enterOuterAlt(_localctx, 1);
2427 {
2428 setState(757);
2429 _errHandler.sync(this);
2430 switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
2431 case 1:
2432 {
2433 setState(756);
2434 packageDeclaration();
2435 }
2436 break;
2437 }
2438 setState(762);
2439 _errHandler.sync(this);
2440 _la = _input.LA(1);
2441 while (_la==IMPORT) {
2442 {
2443 {
2444 setState(759);
2445 importDeclaration();
2446 }
2447 }
2448 setState(764);
2449 _errHandler.sync(this);
2450 _la = _input.LA(1);
2451 }
2452 setState(768);
2453 _errHandler.sync(this);
2454 _la = _input.LA(1);
2455 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << CLASS) | (1L << ENUM) | (1L << FINAL) | (1L << INTERFACE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==SEMI || _la==AT) {
2456 {
2457 {
2458 setState(765);
2459 typeDeclaration();
2460 }
2461 }
2462 setState(770);
2463 _errHandler.sync(this);
2464 _la = _input.LA(1);
2465 }
2466 setState(771);
2467 match(EOF);
2468 }
2469 }
2470 catch (RecognitionException re) {
2471 _localctx.exception = re;
2472 _errHandler.reportError(this, re);
2473 _errHandler.recover(this, re);
2474 }
2475 finally {
2476 exitRule();
2477 }
2478 return _localctx;
2479 }
2480
2481 public static class ModularCompilationContext extends ParserRuleContext {
2482 public ModuleDeclarationContext moduleDeclaration() {
2483 return getRuleContext(ModuleDeclarationContext.class,0);
2484 }
2485 public List<ImportDeclarationContext> importDeclaration() {
2486 return getRuleContexts(ImportDeclarationContext.class);
2487 }
2488 public ImportDeclarationContext importDeclaration(int i) {
2489 return getRuleContext(ImportDeclarationContext.class,i);
2490 }
2491 public ModularCompilationContext(ParserRuleContext parent, int invokingState) {
2492 super(parent, invokingState);
2493 }
2494 @Override public int getRuleIndex() { return RULE_modularCompilation; }
2495 @Override
2496 public void enterRule(ParseTreeListener listener) {
2497 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterModularCompilation(this);
2498 }
2499 @Override
2500 public void exitRule(ParseTreeListener listener) {
2501 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitModularCompilation(this);
2502 }
2503 }
2504
2505 public final ModularCompilationContext modularCompilation() throws RecognitionException {
2506 ModularCompilationContext _localctx = new ModularCompilationContext(_ctx, getState());
2507 enterRule(_localctx, 68, RULE_modularCompilation);
2508 int _la;
2509 try {
2510 enterOuterAlt(_localctx, 1);
2511 {
2512 setState(776);
2513 _errHandler.sync(this);
2514 _la = _input.LA(1);
2515 while (_la==IMPORT) {
2516 {
2517 {
2518 setState(773);
2519 importDeclaration();
2520 }
2521 }
2522 setState(778);
2523 _errHandler.sync(this);
2524 _la = _input.LA(1);
2525 }
2526 setState(779);
2527 moduleDeclaration();
2528 }
2529 }
2530 catch (RecognitionException re) {
2531 _localctx.exception = re;
2532 _errHandler.reportError(this, re);
2533 _errHandler.recover(this, re);
2534 }
2535 finally {
2536 exitRule();
2537 }
2538 return _localctx;
2539 }
2540
2541 public static class PackageDeclarationContext extends ParserRuleContext {
2542 public PackageNameContext packageName() {
2543 return getRuleContext(PackageNameContext.class,0);
2544 }
2545 public List<PackageModifierContext> packageModifier() {
2546 return getRuleContexts(PackageModifierContext.class);
2547 }
2548 public PackageModifierContext packageModifier(int i) {
2549 return getRuleContext(PackageModifierContext.class,i);
2550 }
2551 public PackageDeclarationContext(ParserRuleContext parent, int invokingState) {
2552 super(parent, invokingState);
2553 }
2554 @Override public int getRuleIndex() { return RULE_packageDeclaration; }
2555 @Override
2556 public void enterRule(ParseTreeListener listener) {
2557 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPackageDeclaration(this);
2558 }
2559 @Override
2560 public void exitRule(ParseTreeListener listener) {
2561 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPackageDeclaration(this);
2562 }
2563 }
2564
2565 public final PackageDeclarationContext packageDeclaration() throws RecognitionException {
2566 PackageDeclarationContext _localctx = new PackageDeclarationContext(_ctx, getState());
2567 enterRule(_localctx, 70, RULE_packageDeclaration);
2568 int _la;
2569 try {
2570 enterOuterAlt(_localctx, 1);
2571 {
2572 setState(784);
2573 _errHandler.sync(this);
2574 _la = _input.LA(1);
2575 while (_la==AT) {
2576 {
2577 {
2578 setState(781);
2579 packageModifier();
2580 }
2581 }
2582 setState(786);
2583 _errHandler.sync(this);
2584 _la = _input.LA(1);
2585 }
2586 setState(787);
2587 match(PACKAGE);
2588 setState(788);
2589 packageName(0);
2590 setState(789);
2591 match(SEMI);
2592 }
2593 }
2594 catch (RecognitionException re) {
2595 _localctx.exception = re;
2596 _errHandler.reportError(this, re);
2597 _errHandler.recover(this, re);
2598 }
2599 finally {
2600 exitRule();
2601 }
2602 return _localctx;
2603 }
2604
2605 public static class PackageModifierContext extends ParserRuleContext {
2606 public AnnotationContext annotation() {
2607 return getRuleContext(AnnotationContext.class,0);
2608 }
2609 public PackageModifierContext(ParserRuleContext parent, int invokingState) {
2610 super(parent, invokingState);
2611 }
2612 @Override public int getRuleIndex() { return RULE_packageModifier; }
2613 @Override
2614 public void enterRule(ParseTreeListener listener) {
2615 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPackageModifier(this);
2616 }
2617 @Override
2618 public void exitRule(ParseTreeListener listener) {
2619 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPackageModifier(this);
2620 }
2621 }
2622
2623 public final PackageModifierContext packageModifier() throws RecognitionException {
2624 PackageModifierContext _localctx = new PackageModifierContext(_ctx, getState());
2625 enterRule(_localctx, 72, RULE_packageModifier);
2626 try {
2627 enterOuterAlt(_localctx, 1);
2628 {
2629 setState(791);
2630 annotation();
2631 }
2632 }
2633 catch (RecognitionException re) {
2634 _localctx.exception = re;
2635 _errHandler.reportError(this, re);
2636 _errHandler.recover(this, re);
2637 }
2638 finally {
2639 exitRule();
2640 }
2641 return _localctx;
2642 }
2643
2644 public static class ImportDeclarationContext extends ParserRuleContext {
2645 public SingleTypeImportDeclarationContext singleTypeImportDeclaration() {
2646 return getRuleContext(SingleTypeImportDeclarationContext.class,0);
2647 }
2648 public TypeImportOnDemandDeclarationContext typeImportOnDemandDeclaration() {
2649 return getRuleContext(TypeImportOnDemandDeclarationContext.class,0);
2650 }
2651 public SingleStaticImportDeclarationContext singleStaticImportDeclaration() {
2652 return getRuleContext(SingleStaticImportDeclarationContext.class,0);
2653 }
2654 public StaticImportOnDemandDeclarationContext staticImportOnDemandDeclaration() {
2655 return getRuleContext(StaticImportOnDemandDeclarationContext.class,0);
2656 }
2657 public ImportDeclarationContext(ParserRuleContext parent, int invokingState) {
2658 super(parent, invokingState);
2659 }
2660 @Override public int getRuleIndex() { return RULE_importDeclaration; }
2661 @Override
2662 public void enterRule(ParseTreeListener listener) {
2663 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterImportDeclaration(this);
2664 }
2665 @Override
2666 public void exitRule(ParseTreeListener listener) {
2667 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitImportDeclaration(this);
2668 }
2669 }
2670
2671 public final ImportDeclarationContext importDeclaration() throws RecognitionException {
2672 ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState());
2673 enterRule(_localctx, 74, RULE_importDeclaration);
2674 try {
2675 setState(797);
2676 _errHandler.sync(this);
2677 switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
2678 case 1:
2679 enterOuterAlt(_localctx, 1);
2680 {
2681 setState(793);
2682 singleTypeImportDeclaration();
2683 }
2684 break;
2685 case 2:
2686 enterOuterAlt(_localctx, 2);
2687 {
2688 setState(794);
2689 typeImportOnDemandDeclaration();
2690 }
2691 break;
2692 case 3:
2693 enterOuterAlt(_localctx, 3);
2694 {
2695 setState(795);
2696 singleStaticImportDeclaration();
2697 }
2698 break;
2699 case 4:
2700 enterOuterAlt(_localctx, 4);
2701 {
2702 setState(796);
2703 staticImportOnDemandDeclaration();
2704 }
2705 break;
2706 }
2707 }
2708 catch (RecognitionException re) {
2709 _localctx.exception = re;
2710 _errHandler.reportError(this, re);
2711 _errHandler.recover(this, re);
2712 }
2713 finally {
2714 exitRule();
2715 }
2716 return _localctx;
2717 }
2718
2719 public static class SingleTypeImportDeclarationContext extends ParserRuleContext {
2720 public TypeNameContext typeName() {
2721 return getRuleContext(TypeNameContext.class,0);
2722 }
2723 public SingleTypeImportDeclarationContext(ParserRuleContext parent, int invokingState) {
2724 super(parent, invokingState);
2725 }
2726 @Override public int getRuleIndex() { return RULE_singleTypeImportDeclaration; }
2727 @Override
2728 public void enterRule(ParseTreeListener listener) {
2729 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSingleTypeImportDeclaration(this);
2730 }
2731 @Override
2732 public void exitRule(ParseTreeListener listener) {
2733 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSingleTypeImportDeclaration(this);
2734 }
2735 }
2736
2737 public final SingleTypeImportDeclarationContext singleTypeImportDeclaration() throws RecognitionException {
2738 SingleTypeImportDeclarationContext _localctx = new SingleTypeImportDeclarationContext(_ctx, getState());
2739 enterRule(_localctx, 76, RULE_singleTypeImportDeclaration);
2740 try {
2741 enterOuterAlt(_localctx, 1);
2742 {
2743 setState(799);
2744 match(IMPORT);
2745 setState(800);
2746 typeName();
2747 setState(801);
2748 match(SEMI);
2749 }
2750 }
2751 catch (RecognitionException re) {
2752 _localctx.exception = re;
2753 _errHandler.reportError(this, re);
2754 _errHandler.recover(this, re);
2755 }
2756 finally {
2757 exitRule();
2758 }
2759 return _localctx;
2760 }
2761
2762 public static class TypeImportOnDemandDeclarationContext extends ParserRuleContext {
2763 public PackageOrTypeNameContext packageOrTypeName() {
2764 return getRuleContext(PackageOrTypeNameContext.class,0);
2765 }
2766 public TypeImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) {
2767 super(parent, invokingState);
2768 }
2769 @Override public int getRuleIndex() { return RULE_typeImportOnDemandDeclaration; }
2770 @Override
2771 public void enterRule(ParseTreeListener listener) {
2772 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeImportOnDemandDeclaration(this);
2773 }
2774 @Override
2775 public void exitRule(ParseTreeListener listener) {
2776 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeImportOnDemandDeclaration(this);
2777 }
2778 }
2779
2780 public final TypeImportOnDemandDeclarationContext typeImportOnDemandDeclaration() throws RecognitionException {
2781 TypeImportOnDemandDeclarationContext _localctx = new TypeImportOnDemandDeclarationContext(_ctx, getState());
2782 enterRule(_localctx, 78, RULE_typeImportOnDemandDeclaration);
2783 try {
2784 enterOuterAlt(_localctx, 1);
2785 {
2786 setState(803);
2787 match(IMPORT);
2788 setState(804);
2789 packageOrTypeName(0);
2790 setState(805);
2791 match(DOT);
2792 setState(806);
2793 match(MUL);
2794 setState(807);
2795 match(SEMI);
2796 }
2797 }
2798 catch (RecognitionException re) {
2799 _localctx.exception = re;
2800 _errHandler.reportError(this, re);
2801 _errHandler.recover(this, re);
2802 }
2803 finally {
2804 exitRule();
2805 }
2806 return _localctx;
2807 }
2808
2809 public static class SingleStaticImportDeclarationContext extends ParserRuleContext {
2810 public TypeNameContext typeName() {
2811 return getRuleContext(TypeNameContext.class,0);
2812 }
2813 public IdentifierContext identifier() {
2814 return getRuleContext(IdentifierContext.class,0);
2815 }
2816 public SingleStaticImportDeclarationContext(ParserRuleContext parent, int invokingState) {
2817 super(parent, invokingState);
2818 }
2819 @Override public int getRuleIndex() { return RULE_singleStaticImportDeclaration; }
2820 @Override
2821 public void enterRule(ParseTreeListener listener) {
2822 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSingleStaticImportDeclaration(this);
2823 }
2824 @Override
2825 public void exitRule(ParseTreeListener listener) {
2826 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSingleStaticImportDeclaration(this);
2827 }
2828 }
2829
2830 public final SingleStaticImportDeclarationContext singleStaticImportDeclaration() throws RecognitionException {
2831 SingleStaticImportDeclarationContext _localctx = new SingleStaticImportDeclarationContext(_ctx, getState());
2832 enterRule(_localctx, 80, RULE_singleStaticImportDeclaration);
2833 try {
2834 enterOuterAlt(_localctx, 1);
2835 {
2836 setState(809);
2837 match(IMPORT);
2838 setState(810);
2839 match(STATIC);
2840 setState(811);
2841 typeName();
2842 setState(812);
2843 match(DOT);
2844 setState(813);
2845 identifier();
2846 setState(814);
2847 match(SEMI);
2848 }
2849 }
2850 catch (RecognitionException re) {
2851 _localctx.exception = re;
2852 _errHandler.reportError(this, re);
2853 _errHandler.recover(this, re);
2854 }
2855 finally {
2856 exitRule();
2857 }
2858 return _localctx;
2859 }
2860
2861 public static class StaticImportOnDemandDeclarationContext extends ParserRuleContext {
2862 public TypeNameContext typeName() {
2863 return getRuleContext(TypeNameContext.class,0);
2864 }
2865 public StaticImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) {
2866 super(parent, invokingState);
2867 }
2868 @Override public int getRuleIndex() { return RULE_staticImportOnDemandDeclaration; }
2869 @Override
2870 public void enterRule(ParseTreeListener listener) {
2871 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterStaticImportOnDemandDeclaration(this);
2872 }
2873 @Override
2874 public void exitRule(ParseTreeListener listener) {
2875 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitStaticImportOnDemandDeclaration(this);
2876 }
2877 }
2878
2879 public final StaticImportOnDemandDeclarationContext staticImportOnDemandDeclaration() throws RecognitionException {
2880 StaticImportOnDemandDeclarationContext _localctx = new StaticImportOnDemandDeclarationContext(_ctx, getState());
2881 enterRule(_localctx, 82, RULE_staticImportOnDemandDeclaration);
2882 try {
2883 enterOuterAlt(_localctx, 1);
2884 {
2885 setState(816);
2886 match(IMPORT);
2887 setState(817);
2888 match(STATIC);
2889 setState(818);
2890 typeName();
2891 setState(819);
2892 match(DOT);
2893 setState(820);
2894 match(MUL);
2895 setState(821);
2896 match(SEMI);
2897 }
2898 }
2899 catch (RecognitionException re) {
2900 _localctx.exception = re;
2901 _errHandler.reportError(this, re);
2902 _errHandler.recover(this, re);
2903 }
2904 finally {
2905 exitRule();
2906 }
2907 return _localctx;
2908 }
2909
2910 public static class TypeDeclarationContext extends ParserRuleContext {
2911 public ClassDeclarationContext classDeclaration() {
2912 return getRuleContext(ClassDeclarationContext.class,0);
2913 }
2914 public InterfaceDeclarationContext interfaceDeclaration() {
2915 return getRuleContext(InterfaceDeclarationContext.class,0);
2916 }
2917 public TypeDeclarationContext(ParserRuleContext parent, int invokingState) {
2918 super(parent, invokingState);
2919 }
2920 @Override public int getRuleIndex() { return RULE_typeDeclaration; }
2921 @Override
2922 public void enterRule(ParseTreeListener listener) {
2923 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeDeclaration(this);
2924 }
2925 @Override
2926 public void exitRule(ParseTreeListener listener) {
2927 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeDeclaration(this);
2928 }
2929 }
2930
2931 public final TypeDeclarationContext typeDeclaration() throws RecognitionException {
2932 TypeDeclarationContext _localctx = new TypeDeclarationContext(_ctx, getState());
2933 enterRule(_localctx, 84, RULE_typeDeclaration);
2934 try {
2935 setState(826);
2936 _errHandler.sync(this);
2937 switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
2938 case 1:
2939 enterOuterAlt(_localctx, 1);
2940 {
2941 setState(823);
2942 classDeclaration();
2943 }
2944 break;
2945 case 2:
2946 enterOuterAlt(_localctx, 2);
2947 {
2948 setState(824);
2949 interfaceDeclaration();
2950 }
2951 break;
2952 case 3:
2953 enterOuterAlt(_localctx, 3);
2954 {
2955 setState(825);
2956 match(SEMI);
2957 }
2958 break;
2959 }
2960 }
2961 catch (RecognitionException re) {
2962 _localctx.exception = re;
2963 _errHandler.reportError(this, re);
2964 _errHandler.recover(this, re);
2965 }
2966 finally {
2967 exitRule();
2968 }
2969 return _localctx;
2970 }
2971
2972 public static class ModuleDeclarationContext extends ParserRuleContext {
2973 public ModuleNameContext moduleName() {
2974 return getRuleContext(ModuleNameContext.class,0);
2975 }
2976 public List<AnnotationContext> annotation() {
2977 return getRuleContexts(AnnotationContext.class);
2978 }
2979 public AnnotationContext annotation(int i) {
2980 return getRuleContext(AnnotationContext.class,i);
2981 }
2982 public List<ModuleDirectiveContext> moduleDirective() {
2983 return getRuleContexts(ModuleDirectiveContext.class);
2984 }
2985 public ModuleDirectiveContext moduleDirective(int i) {
2986 return getRuleContext(ModuleDirectiveContext.class,i);
2987 }
2988 public ModuleDeclarationContext(ParserRuleContext parent, int invokingState) {
2989 super(parent, invokingState);
2990 }
2991 @Override public int getRuleIndex() { return RULE_moduleDeclaration; }
2992 @Override
2993 public void enterRule(ParseTreeListener listener) {
2994 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterModuleDeclaration(this);
2995 }
2996 @Override
2997 public void exitRule(ParseTreeListener listener) {
2998 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitModuleDeclaration(this);
2999 }
3000 }
3001
3002 public final ModuleDeclarationContext moduleDeclaration() throws RecognitionException {
3003 ModuleDeclarationContext _localctx = new ModuleDeclarationContext(_ctx, getState());
3004 enterRule(_localctx, 86, RULE_moduleDeclaration);
3005 int _la;
3006 try {
3007 enterOuterAlt(_localctx, 1);
3008 {
3009 setState(831);
3010 _errHandler.sync(this);
3011 _la = _input.LA(1);
3012 while (_la==AT) {
3013 {
3014 {
3015 setState(828);
3016 annotation();
3017 }
3018 }
3019 setState(833);
3020 _errHandler.sync(this);
3021 _la = _input.LA(1);
3022 }
3023 setState(835);
3024 _errHandler.sync(this);
3025 _la = _input.LA(1);
3026 if (_la==T__0) {
3027 {
3028 setState(834);
3029 match(T__0);
3030 }
3031 }
3032
3033 setState(837);
3034 match(T__1);
3035 setState(838);
3036 moduleName(0);
3037 setState(839);
3038 match(LBRACE);
3039 setState(843);
3040 _errHandler.sync(this);
3041 _la = _input.LA(1);
3042 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__5) | (1L << T__6) | (1L << T__7))) != 0)) {
3043 {
3044 {
3045 setState(840);
3046 moduleDirective();
3047 }
3048 }
3049 setState(845);
3050 _errHandler.sync(this);
3051 _la = _input.LA(1);
3052 }
3053 setState(846);
3054 match(RBRACE);
3055 }
3056 }
3057 catch (RecognitionException re) {
3058 _localctx.exception = re;
3059 _errHandler.reportError(this, re);
3060 _errHandler.recover(this, re);
3061 }
3062 finally {
3063 exitRule();
3064 }
3065 return _localctx;
3066 }
3067
3068 public static class ModuleDirectiveContext extends ParserRuleContext {
3069 public RequiresDirectiveContext requiresDirective() {
3070 return getRuleContext(RequiresDirectiveContext.class,0);
3071 }
3072 public ExportsDirectiveContext exportsDirective() {
3073 return getRuleContext(ExportsDirectiveContext.class,0);
3074 }
3075 public OpensDirectiveContext opensDirective() {
3076 return getRuleContext(OpensDirectiveContext.class,0);
3077 }
3078 public UsesDirectiveContext usesDirective() {
3079 return getRuleContext(UsesDirectiveContext.class,0);
3080 }
3081 public ProvidesDirectiveContext providesDirective() {
3082 return getRuleContext(ProvidesDirectiveContext.class,0);
3083 }
3084 public ModuleDirectiveContext(ParserRuleContext parent, int invokingState) {
3085 super(parent, invokingState);
3086 }
3087 @Override public int getRuleIndex() { return RULE_moduleDirective; }
3088 @Override
3089 public void enterRule(ParseTreeListener listener) {
3090 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterModuleDirective(this);
3091 }
3092 @Override
3093 public void exitRule(ParseTreeListener listener) {
3094 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitModuleDirective(this);
3095 }
3096 }
3097
3098 public final ModuleDirectiveContext moduleDirective() throws RecognitionException {
3099 ModuleDirectiveContext _localctx = new ModuleDirectiveContext(_ctx, getState());
3100 enterRule(_localctx, 88, RULE_moduleDirective);
3101 try {
3102 setState(853);
3103 _errHandler.sync(this);
3104 switch (_input.LA(1)) {
3105 case T__2:
3106 enterOuterAlt(_localctx, 1);
3107 {
3108 setState(848);
3109 requiresDirective();
3110 }
3111 break;
3112 case T__3:
3113 enterOuterAlt(_localctx, 2);
3114 {
3115 setState(849);
3116 exportsDirective();
3117 }
3118 break;
3119 case T__5:
3120 enterOuterAlt(_localctx, 3);
3121 {
3122 setState(850);
3123 opensDirective();
3124 }
3125 break;
3126 case T__6:
3127 enterOuterAlt(_localctx, 4);
3128 {
3129 setState(851);
3130 usesDirective();
3131 }
3132 break;
3133 case T__7:
3134 enterOuterAlt(_localctx, 5);
3135 {
3136 setState(852);
3137 providesDirective();
3138 }
3139 break;
3140 default:
3141 throw new NoViableAltException(this);
3142 }
3143 }
3144 catch (RecognitionException re) {
3145 _localctx.exception = re;
3146 _errHandler.reportError(this, re);
3147 _errHandler.recover(this, re);
3148 }
3149 finally {
3150 exitRule();
3151 }
3152 return _localctx;
3153 }
3154
3155 public static class RequiresDirectiveContext extends ParserRuleContext {
3156 public ModuleNameContext moduleName() {
3157 return getRuleContext(ModuleNameContext.class,0);
3158 }
3159 public List<RequiresModifierContext> requiresModifier() {
3160 return getRuleContexts(RequiresModifierContext.class);
3161 }
3162 public RequiresModifierContext requiresModifier(int i) {
3163 return getRuleContext(RequiresModifierContext.class,i);
3164 }
3165 public RequiresDirectiveContext(ParserRuleContext parent, int invokingState) {
3166 super(parent, invokingState);
3167 }
3168 @Override public int getRuleIndex() { return RULE_requiresDirective; }
3169 @Override
3170 public void enterRule(ParseTreeListener listener) {
3171 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterRequiresDirective(this);
3172 }
3173 @Override
3174 public void exitRule(ParseTreeListener listener) {
3175 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitRequiresDirective(this);
3176 }
3177 }
3178
3179 public final RequiresDirectiveContext requiresDirective() throws RecognitionException {
3180 RequiresDirectiveContext _localctx = new RequiresDirectiveContext(_ctx, getState());
3181 enterRule(_localctx, 90, RULE_requiresDirective);
3182 int _la;
3183 try {
3184 enterOuterAlt(_localctx, 1);
3185 {
3186 setState(855);
3187 match(T__2);
3188 setState(859);
3189 _errHandler.sync(this);
3190 _la = _input.LA(1);
3191 while (_la==T__9 || _la==STATIC) {
3192 {
3193 {
3194 setState(856);
3195 requiresModifier();
3196 }
3197 }
3198 setState(861);
3199 _errHandler.sync(this);
3200 _la = _input.LA(1);
3201 }
3202 setState(862);
3203 moduleName(0);
3204 setState(863);
3205 match(SEMI);
3206 }
3207 }
3208 catch (RecognitionException re) {
3209 _localctx.exception = re;
3210 _errHandler.reportError(this, re);
3211 _errHandler.recover(this, re);
3212 }
3213 finally {
3214 exitRule();
3215 }
3216 return _localctx;
3217 }
3218
3219 public static class ExportsDirectiveContext extends ParserRuleContext {
3220 public PackageNameContext packageName() {
3221 return getRuleContext(PackageNameContext.class,0);
3222 }
3223 public List<ModuleNameContext> moduleName() {
3224 return getRuleContexts(ModuleNameContext.class);
3225 }
3226 public ModuleNameContext moduleName(int i) {
3227 return getRuleContext(ModuleNameContext.class,i);
3228 }
3229 public ExportsDirectiveContext(ParserRuleContext parent, int invokingState) {
3230 super(parent, invokingState);
3231 }
3232 @Override public int getRuleIndex() { return RULE_exportsDirective; }
3233 @Override
3234 public void enterRule(ParseTreeListener listener) {
3235 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExportsDirective(this);
3236 }
3237 @Override
3238 public void exitRule(ParseTreeListener listener) {
3239 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExportsDirective(this);
3240 }
3241 }
3242
3243 public final ExportsDirectiveContext exportsDirective() throws RecognitionException {
3244 ExportsDirectiveContext _localctx = new ExportsDirectiveContext(_ctx, getState());
3245 enterRule(_localctx, 92, RULE_exportsDirective);
3246 int _la;
3247 try {
3248 enterOuterAlt(_localctx, 1);
3249 {
3250 setState(865);
3251 match(T__3);
3252 setState(866);
3253 packageName(0);
3254 setState(876);
3255 _errHandler.sync(this);
3256 _la = _input.LA(1);
3257 if (_la==T__4) {
3258 {
3259 setState(867);
3260 match(T__4);
3261 setState(868);
3262 moduleName(0);
3263 setState(873);
3264 _errHandler.sync(this);
3265 _la = _input.LA(1);
3266 while (_la==COMMA) {
3267 {
3268 {
3269 setState(869);
3270 match(COMMA);
3271 setState(870);
3272 moduleName(0);
3273 }
3274 }
3275 setState(875);
3276 _errHandler.sync(this);
3277 _la = _input.LA(1);
3278 }
3279 }
3280 }
3281
3282 setState(878);
3283 match(SEMI);
3284 }
3285 }
3286 catch (RecognitionException re) {
3287 _localctx.exception = re;
3288 _errHandler.reportError(this, re);
3289 _errHandler.recover(this, re);
3290 }
3291 finally {
3292 exitRule();
3293 }
3294 return _localctx;
3295 }
3296
3297 public static class OpensDirectiveContext extends ParserRuleContext {
3298 public PackageNameContext packageName() {
3299 return getRuleContext(PackageNameContext.class,0);
3300 }
3301 public List<ModuleNameContext> moduleName() {
3302 return getRuleContexts(ModuleNameContext.class);
3303 }
3304 public ModuleNameContext moduleName(int i) {
3305 return getRuleContext(ModuleNameContext.class,i);
3306 }
3307 public OpensDirectiveContext(ParserRuleContext parent, int invokingState) {
3308 super(parent, invokingState);
3309 }
3310 @Override public int getRuleIndex() { return RULE_opensDirective; }
3311 @Override
3312 public void enterRule(ParseTreeListener listener) {
3313 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterOpensDirective(this);
3314 }
3315 @Override
3316 public void exitRule(ParseTreeListener listener) {
3317 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitOpensDirective(this);
3318 }
3319 }
3320
3321 public final OpensDirectiveContext opensDirective() throws RecognitionException {
3322 OpensDirectiveContext _localctx = new OpensDirectiveContext(_ctx, getState());
3323 enterRule(_localctx, 94, RULE_opensDirective);
3324 int _la;
3325 try {
3326 enterOuterAlt(_localctx, 1);
3327 {
3328 setState(880);
3329 match(T__5);
3330 setState(881);
3331 packageName(0);
3332 setState(891);
3333 _errHandler.sync(this);
3334 _la = _input.LA(1);
3335 if (_la==T__4) {
3336 {
3337 setState(882);
3338 match(T__4);
3339 setState(883);
3340 moduleName(0);
3341 setState(888);
3342 _errHandler.sync(this);
3343 _la = _input.LA(1);
3344 while (_la==COMMA) {
3345 {
3346 {
3347 setState(884);
3348 match(COMMA);
3349 setState(885);
3350 moduleName(0);
3351 }
3352 }
3353 setState(890);
3354 _errHandler.sync(this);
3355 _la = _input.LA(1);
3356 }
3357 }
3358 }
3359
3360 setState(893);
3361 match(SEMI);
3362 }
3363 }
3364 catch (RecognitionException re) {
3365 _localctx.exception = re;
3366 _errHandler.reportError(this, re);
3367 _errHandler.recover(this, re);
3368 }
3369 finally {
3370 exitRule();
3371 }
3372 return _localctx;
3373 }
3374
3375 public static class UsesDirectiveContext extends ParserRuleContext {
3376 public TypeNameContext typeName() {
3377 return getRuleContext(TypeNameContext.class,0);
3378 }
3379 public UsesDirectiveContext(ParserRuleContext parent, int invokingState) {
3380 super(parent, invokingState);
3381 }
3382 @Override public int getRuleIndex() { return RULE_usesDirective; }
3383 @Override
3384 public void enterRule(ParseTreeListener listener) {
3385 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUsesDirective(this);
3386 }
3387 @Override
3388 public void exitRule(ParseTreeListener listener) {
3389 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUsesDirective(this);
3390 }
3391 }
3392
3393 public final UsesDirectiveContext usesDirective() throws RecognitionException {
3394 UsesDirectiveContext _localctx = new UsesDirectiveContext(_ctx, getState());
3395 enterRule(_localctx, 96, RULE_usesDirective);
3396 try {
3397 enterOuterAlt(_localctx, 1);
3398 {
3399 setState(895);
3400 match(T__6);
3401 setState(896);
3402 typeName();
3403 setState(897);
3404 match(SEMI);
3405 }
3406 }
3407 catch (RecognitionException re) {
3408 _localctx.exception = re;
3409 _errHandler.reportError(this, re);
3410 _errHandler.recover(this, re);
3411 }
3412 finally {
3413 exitRule();
3414 }
3415 return _localctx;
3416 }
3417
3418 public static class ProvidesDirectiveContext extends ParserRuleContext {
3419 public List<TypeNameContext> typeName() {
3420 return getRuleContexts(TypeNameContext.class);
3421 }
3422 public TypeNameContext typeName(int i) {
3423 return getRuleContext(TypeNameContext.class,i);
3424 }
3425 public ProvidesDirectiveContext(ParserRuleContext parent, int invokingState) {
3426 super(parent, invokingState);
3427 }
3428 @Override public int getRuleIndex() { return RULE_providesDirective; }
3429 @Override
3430 public void enterRule(ParseTreeListener listener) {
3431 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterProvidesDirective(this);
3432 }
3433 @Override
3434 public void exitRule(ParseTreeListener listener) {
3435 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitProvidesDirective(this);
3436 }
3437 }
3438
3439 public final ProvidesDirectiveContext providesDirective() throws RecognitionException {
3440 ProvidesDirectiveContext _localctx = new ProvidesDirectiveContext(_ctx, getState());
3441 enterRule(_localctx, 98, RULE_providesDirective);
3442 int _la;
3443 try {
3444 enterOuterAlt(_localctx, 1);
3445 {
3446 setState(899);
3447 match(T__7);
3448 setState(900);
3449 typeName();
3450 setState(901);
3451 match(T__8);
3452 setState(902);
3453 typeName();
3454 setState(907);
3455 _errHandler.sync(this);
3456 _la = _input.LA(1);
3457 while (_la==COMMA) {
3458 {
3459 {
3460 setState(903);
3461 match(COMMA);
3462 setState(904);
3463 typeName();
3464 }
3465 }
3466 setState(909);
3467 _errHandler.sync(this);
3468 _la = _input.LA(1);
3469 }
3470 setState(910);
3471 match(SEMI);
3472 }
3473 }
3474 catch (RecognitionException re) {
3475 _localctx.exception = re;
3476 _errHandler.reportError(this, re);
3477 _errHandler.recover(this, re);
3478 }
3479 finally {
3480 exitRule();
3481 }
3482 return _localctx;
3483 }
3484
3485 public static class RequiresModifierContext extends ParserRuleContext {
3486 public RequiresModifierContext(ParserRuleContext parent, int invokingState) {
3487 super(parent, invokingState);
3488 }
3489 @Override public int getRuleIndex() { return RULE_requiresModifier; }
3490 @Override
3491 public void enterRule(ParseTreeListener listener) {
3492 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterRequiresModifier(this);
3493 }
3494 @Override
3495 public void exitRule(ParseTreeListener listener) {
3496 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitRequiresModifier(this);
3497 }
3498 }
3499
3500 public final RequiresModifierContext requiresModifier() throws RecognitionException {
3501 RequiresModifierContext _localctx = new RequiresModifierContext(_ctx, getState());
3502 enterRule(_localctx, 100, RULE_requiresModifier);
3503 int _la;
3504 try {
3505 enterOuterAlt(_localctx, 1);
3506 {
3507 setState(912);
3508 _la = _input.LA(1);
3509 if ( !(_la==T__9 || _la==STATIC) ) {
3510 _errHandler.recoverInline(this);
3511 }
3512 else {
3513 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
3514 _errHandler.reportMatch(this);
3515 consume();
3516 }
3517 }
3518 }
3519 catch (RecognitionException re) {
3520 _localctx.exception = re;
3521 _errHandler.reportError(this, re);
3522 _errHandler.recover(this, re);
3523 }
3524 finally {
3525 exitRule();
3526 }
3527 return _localctx;
3528 }
3529
3530 public static class ClassDeclarationContext extends ParserRuleContext {
3531 public NormalClassDeclarationContext normalClassDeclaration() {
3532 return getRuleContext(NormalClassDeclarationContext.class,0);
3533 }
3534 public EnumDeclarationContext enumDeclaration() {
3535 return getRuleContext(EnumDeclarationContext.class,0);
3536 }
3537 public ClassDeclarationContext(ParserRuleContext parent, int invokingState) {
3538 super(parent, invokingState);
3539 }
3540 @Override public int getRuleIndex() { return RULE_classDeclaration; }
3541 @Override
3542 public void enterRule(ParseTreeListener listener) {
3543 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassDeclaration(this);
3544 }
3545 @Override
3546 public void exitRule(ParseTreeListener listener) {
3547 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassDeclaration(this);
3548 }
3549 }
3550
3551 public final ClassDeclarationContext classDeclaration() throws RecognitionException {
3552 ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState());
3553 enterRule(_localctx, 102, RULE_classDeclaration);
3554 try {
3555 setState(916);
3556 _errHandler.sync(this);
3557 switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
3558 case 1:
3559 enterOuterAlt(_localctx, 1);
3560 {
3561 setState(914);
3562 normalClassDeclaration();
3563 }
3564 break;
3565 case 2:
3566 enterOuterAlt(_localctx, 2);
3567 {
3568 setState(915);
3569 enumDeclaration();
3570 }
3571 break;
3572 }
3573 }
3574 catch (RecognitionException re) {
3575 _localctx.exception = re;
3576 _errHandler.reportError(this, re);
3577 _errHandler.recover(this, re);
3578 }
3579 finally {
3580 exitRule();
3581 }
3582 return _localctx;
3583 }
3584
3585 public static class NormalClassDeclarationContext extends ParserRuleContext {
3586 public IdentifierContext identifier() {
3587 return getRuleContext(IdentifierContext.class,0);
3588 }
3589 public ClassBodyContext classBody() {
3590 return getRuleContext(ClassBodyContext.class,0);
3591 }
3592 public List<ClassModifierContext> classModifier() {
3593 return getRuleContexts(ClassModifierContext.class);
3594 }
3595 public ClassModifierContext classModifier(int i) {
3596 return getRuleContext(ClassModifierContext.class,i);
3597 }
3598 public TypeParametersContext typeParameters() {
3599 return getRuleContext(TypeParametersContext.class,0);
3600 }
3601 public SuperclassContext superclass() {
3602 return getRuleContext(SuperclassContext.class,0);
3603 }
3604 public SuperinterfacesContext superinterfaces() {
3605 return getRuleContext(SuperinterfacesContext.class,0);
3606 }
3607 public NormalClassDeclarationContext(ParserRuleContext parent, int invokingState) {
3608 super(parent, invokingState);
3609 }
3610 @Override public int getRuleIndex() { return RULE_normalClassDeclaration; }
3611 @Override
3612 public void enterRule(ParseTreeListener listener) {
3613 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterNormalClassDeclaration(this);
3614 }
3615 @Override
3616 public void exitRule(ParseTreeListener listener) {
3617 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitNormalClassDeclaration(this);
3618 }
3619 }
3620
3621 public final NormalClassDeclarationContext normalClassDeclaration() throws RecognitionException {
3622 NormalClassDeclarationContext _localctx = new NormalClassDeclarationContext(_ctx, getState());
3623 enterRule(_localctx, 104, RULE_normalClassDeclaration);
3624 int _la;
3625 try {
3626 enterOuterAlt(_localctx, 1);
3627 {
3628 setState(921);
3629 _errHandler.sync(this);
3630 _la = _input.LA(1);
3631 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
3632 {
3633 {
3634 setState(918);
3635 classModifier();
3636 }
3637 }
3638 setState(923);
3639 _errHandler.sync(this);
3640 _la = _input.LA(1);
3641 }
3642 setState(924);
3643 match(CLASS);
3644 setState(925);
3645 identifier();
3646 setState(927);
3647 _errHandler.sync(this);
3648 _la = _input.LA(1);
3649 if (_la==LT) {
3650 {
3651 setState(926);
3652 typeParameters();
3653 }
3654 }
3655
3656 setState(930);
3657 _errHandler.sync(this);
3658 _la = _input.LA(1);
3659 if (_la==EXTENDS) {
3660 {
3661 setState(929);
3662 superclass();
3663 }
3664 }
3665
3666 setState(933);
3667 _errHandler.sync(this);
3668 _la = _input.LA(1);
3669 if (_la==IMPLEMENTS) {
3670 {
3671 setState(932);
3672 superinterfaces();
3673 }
3674 }
3675
3676 setState(935);
3677 classBody();
3678 }
3679 }
3680 catch (RecognitionException re) {
3681 _localctx.exception = re;
3682 _errHandler.reportError(this, re);
3683 _errHandler.recover(this, re);
3684 }
3685 finally {
3686 exitRule();
3687 }
3688 return _localctx;
3689 }
3690
3691 public static class ClassModifierContext extends ParserRuleContext {
3692 public AnnotationContext annotation() {
3693 return getRuleContext(AnnotationContext.class,0);
3694 }
3695 public ClassModifierContext(ParserRuleContext parent, int invokingState) {
3696 super(parent, invokingState);
3697 }
3698 @Override public int getRuleIndex() { return RULE_classModifier; }
3699 @Override
3700 public void enterRule(ParseTreeListener listener) {
3701 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassModifier(this);
3702 }
3703 @Override
3704 public void exitRule(ParseTreeListener listener) {
3705 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassModifier(this);
3706 }
3707 }
3708
3709 public final ClassModifierContext classModifier() throws RecognitionException {
3710 ClassModifierContext _localctx = new ClassModifierContext(_ctx, getState());
3711 enterRule(_localctx, 106, RULE_classModifier);
3712 try {
3713 setState(945);
3714 _errHandler.sync(this);
3715 switch (_input.LA(1)) {
3716 case AT:
3717 enterOuterAlt(_localctx, 1);
3718 {
3719 setState(937);
3720 annotation();
3721 }
3722 break;
3723 case PUBLIC:
3724 enterOuterAlt(_localctx, 2);
3725 {
3726 setState(938);
3727 match(PUBLIC);
3728 }
3729 break;
3730 case PROTECTED:
3731 enterOuterAlt(_localctx, 3);
3732 {
3733 setState(939);
3734 match(PROTECTED);
3735 }
3736 break;
3737 case PRIVATE:
3738 enterOuterAlt(_localctx, 4);
3739 {
3740 setState(940);
3741 match(PRIVATE);
3742 }
3743 break;
3744 case ABSTRACT:
3745 enterOuterAlt(_localctx, 5);
3746 {
3747 setState(941);
3748 match(ABSTRACT);
3749 }
3750 break;
3751 case STATIC:
3752 enterOuterAlt(_localctx, 6);
3753 {
3754 setState(942);
3755 match(STATIC);
3756 }
3757 break;
3758 case FINAL:
3759 enterOuterAlt(_localctx, 7);
3760 {
3761 setState(943);
3762 match(FINAL);
3763 }
3764 break;
3765 case STRICTFP:
3766 enterOuterAlt(_localctx, 8);
3767 {
3768 setState(944);
3769 match(STRICTFP);
3770 }
3771 break;
3772 default:
3773 throw new NoViableAltException(this);
3774 }
3775 }
3776 catch (RecognitionException re) {
3777 _localctx.exception = re;
3778 _errHandler.reportError(this, re);
3779 _errHandler.recover(this, re);
3780 }
3781 finally {
3782 exitRule();
3783 }
3784 return _localctx;
3785 }
3786
3787 public static class TypeParametersContext extends ParserRuleContext {
3788 public TypeParameterListContext typeParameterList() {
3789 return getRuleContext(TypeParameterListContext.class,0);
3790 }
3791 public TypeParametersContext(ParserRuleContext parent, int invokingState) {
3792 super(parent, invokingState);
3793 }
3794 @Override public int getRuleIndex() { return RULE_typeParameters; }
3795 @Override
3796 public void enterRule(ParseTreeListener listener) {
3797 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeParameters(this);
3798 }
3799 @Override
3800 public void exitRule(ParseTreeListener listener) {
3801 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeParameters(this);
3802 }
3803 }
3804
3805 public final TypeParametersContext typeParameters() throws RecognitionException {
3806 TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState());
3807 enterRule(_localctx, 108, RULE_typeParameters);
3808 try {
3809 enterOuterAlt(_localctx, 1);
3810 {
3811 setState(947);
3812 match(LT);
3813 setState(948);
3814 typeParameterList();
3815 setState(949);
3816 match(GT);
3817 }
3818 }
3819 catch (RecognitionException re) {
3820 _localctx.exception = re;
3821 _errHandler.reportError(this, re);
3822 _errHandler.recover(this, re);
3823 }
3824 finally {
3825 exitRule();
3826 }
3827 return _localctx;
3828 }
3829
3830 public static class TypeParameterListContext extends ParserRuleContext {
3831 public List<TypeParameterContext> typeParameter() {
3832 return getRuleContexts(TypeParameterContext.class);
3833 }
3834 public TypeParameterContext typeParameter(int i) {
3835 return getRuleContext(TypeParameterContext.class,i);
3836 }
3837 public TypeParameterListContext(ParserRuleContext parent, int invokingState) {
3838 super(parent, invokingState);
3839 }
3840 @Override public int getRuleIndex() { return RULE_typeParameterList; }
3841 @Override
3842 public void enterRule(ParseTreeListener listener) {
3843 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeParameterList(this);
3844 }
3845 @Override
3846 public void exitRule(ParseTreeListener listener) {
3847 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeParameterList(this);
3848 }
3849 }
3850
3851 public final TypeParameterListContext typeParameterList() throws RecognitionException {
3852 TypeParameterListContext _localctx = new TypeParameterListContext(_ctx, getState());
3853 enterRule(_localctx, 110, RULE_typeParameterList);
3854 int _la;
3855 try {
3856 enterOuterAlt(_localctx, 1);
3857 {
3858 setState(951);
3859 typeParameter();
3860 setState(956);
3861 _errHandler.sync(this);
3862 _la = _input.LA(1);
3863 while (_la==COMMA) {
3864 {
3865 {
3866 setState(952);
3867 match(COMMA);
3868 setState(953);
3869 typeParameter();
3870 }
3871 }
3872 setState(958);
3873 _errHandler.sync(this);
3874 _la = _input.LA(1);
3875 }
3876 }
3877 }
3878 catch (RecognitionException re) {
3879 _localctx.exception = re;
3880 _errHandler.reportError(this, re);
3881 _errHandler.recover(this, re);
3882 }
3883 finally {
3884 exitRule();
3885 }
3886 return _localctx;
3887 }
3888
3889 public static class SuperclassContext extends ParserRuleContext {
3890 public ClassTypeContext classType() {
3891 return getRuleContext(ClassTypeContext.class,0);
3892 }
3893 public SuperclassContext(ParserRuleContext parent, int invokingState) {
3894 super(parent, invokingState);
3895 }
3896 @Override public int getRuleIndex() { return RULE_superclass; }
3897 @Override
3898 public void enterRule(ParseTreeListener listener) {
3899 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSuperclass(this);
3900 }
3901 @Override
3902 public void exitRule(ParseTreeListener listener) {
3903 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSuperclass(this);
3904 }
3905 }
3906
3907 public final SuperclassContext superclass() throws RecognitionException {
3908 SuperclassContext _localctx = new SuperclassContext(_ctx, getState());
3909 enterRule(_localctx, 112, RULE_superclass);
3910 try {
3911 enterOuterAlt(_localctx, 1);
3912 {
3913 setState(959);
3914 match(EXTENDS);
3915 setState(960);
3916 classType();
3917 }
3918 }
3919 catch (RecognitionException re) {
3920 _localctx.exception = re;
3921 _errHandler.reportError(this, re);
3922 _errHandler.recover(this, re);
3923 }
3924 finally {
3925 exitRule();
3926 }
3927 return _localctx;
3928 }
3929
3930 public static class SuperinterfacesContext extends ParserRuleContext {
3931 public InterfaceTypeListContext interfaceTypeList() {
3932 return getRuleContext(InterfaceTypeListContext.class,0);
3933 }
3934 public SuperinterfacesContext(ParserRuleContext parent, int invokingState) {
3935 super(parent, invokingState);
3936 }
3937 @Override public int getRuleIndex() { return RULE_superinterfaces; }
3938 @Override
3939 public void enterRule(ParseTreeListener listener) {
3940 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSuperinterfaces(this);
3941 }
3942 @Override
3943 public void exitRule(ParseTreeListener listener) {
3944 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSuperinterfaces(this);
3945 }
3946 }
3947
3948 public final SuperinterfacesContext superinterfaces() throws RecognitionException {
3949 SuperinterfacesContext _localctx = new SuperinterfacesContext(_ctx, getState());
3950 enterRule(_localctx, 114, RULE_superinterfaces);
3951 try {
3952 enterOuterAlt(_localctx, 1);
3953 {
3954 setState(962);
3955 match(IMPLEMENTS);
3956 setState(963);
3957 interfaceTypeList();
3958 }
3959 }
3960 catch (RecognitionException re) {
3961 _localctx.exception = re;
3962 _errHandler.reportError(this, re);
3963 _errHandler.recover(this, re);
3964 }
3965 finally {
3966 exitRule();
3967 }
3968 return _localctx;
3969 }
3970
3971 public static class InterfaceTypeListContext extends ParserRuleContext {
3972 public List<InterfaceTypeContext> interfaceType() {
3973 return getRuleContexts(InterfaceTypeContext.class);
3974 }
3975 public InterfaceTypeContext interfaceType(int i) {
3976 return getRuleContext(InterfaceTypeContext.class,i);
3977 }
3978 public InterfaceTypeListContext(ParserRuleContext parent, int invokingState) {
3979 super(parent, invokingState);
3980 }
3981 @Override public int getRuleIndex() { return RULE_interfaceTypeList; }
3982 @Override
3983 public void enterRule(ParseTreeListener listener) {
3984 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceTypeList(this);
3985 }
3986 @Override
3987 public void exitRule(ParseTreeListener listener) {
3988 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceTypeList(this);
3989 }
3990 }
3991
3992 public final InterfaceTypeListContext interfaceTypeList() throws RecognitionException {
3993 InterfaceTypeListContext _localctx = new InterfaceTypeListContext(_ctx, getState());
3994 enterRule(_localctx, 116, RULE_interfaceTypeList);
3995 int _la;
3996 try {
3997 enterOuterAlt(_localctx, 1);
3998 {
3999 setState(965);
4000 interfaceType();
4001 setState(970);
4002 _errHandler.sync(this);
4003 _la = _input.LA(1);
4004 while (_la==COMMA) {
4005 {
4006 {
4007 setState(966);
4008 match(COMMA);
4009 setState(967);
4010 interfaceType();
4011 }
4012 }
4013 setState(972);
4014 _errHandler.sync(this);
4015 _la = _input.LA(1);
4016 }
4017 }
4018 }
4019 catch (RecognitionException re) {
4020 _localctx.exception = re;
4021 _errHandler.reportError(this, re);
4022 _errHandler.recover(this, re);
4023 }
4024 finally {
4025 exitRule();
4026 }
4027 return _localctx;
4028 }
4029
4030 public static class ClassBodyContext extends ParserRuleContext {
4031 public List<ClassBodyDeclarationContext> classBodyDeclaration() {
4032 return getRuleContexts(ClassBodyDeclarationContext.class);
4033 }
4034 public ClassBodyDeclarationContext classBodyDeclaration(int i) {
4035 return getRuleContext(ClassBodyDeclarationContext.class,i);
4036 }
4037 public ClassBodyContext(ParserRuleContext parent, int invokingState) {
4038 super(parent, invokingState);
4039 }
4040 @Override public int getRuleIndex() { return RULE_classBody; }
4041 @Override
4042 public void enterRule(ParseTreeListener listener) {
4043 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassBody(this);
4044 }
4045 @Override
4046 public void exitRule(ParseTreeListener listener) {
4047 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassBody(this);
4048 }
4049 }
4050
4051 public final ClassBodyContext classBody() throws RecognitionException {
4052 ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState());
4053 enterRule(_localctx, 118, RULE_classBody);
4054 int _la;
4055 try {
4056 enterOuterAlt(_localctx, 1);
4057 {
4058 setState(973);
4059 match(LBRACE);
4060 setState(977);
4061 _errHandler.sync(this);
4062 _la = _input.LA(1);
4063 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOID) | (1L << VOLATILE))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (LBRACE - 70)) | (1L << (SEMI - 70)) | (1L << (AT - 70)) | (1L << (LT - 70)) | (1L << (Identifier - 70)))) != 0)) {
4064 {
4065 {
4066 setState(974);
4067 classBodyDeclaration();
4068 }
4069 }
4070 setState(979);
4071 _errHandler.sync(this);
4072 _la = _input.LA(1);
4073 }
4074 setState(980);
4075 match(RBRACE);
4076 }
4077 }
4078 catch (RecognitionException re) {
4079 _localctx.exception = re;
4080 _errHandler.reportError(this, re);
4081 _errHandler.recover(this, re);
4082 }
4083 finally {
4084 exitRule();
4085 }
4086 return _localctx;
4087 }
4088
4089 public static class ClassBodyDeclarationContext extends ParserRuleContext {
4090 public ClassMemberDeclarationContext classMemberDeclaration() {
4091 return getRuleContext(ClassMemberDeclarationContext.class,0);
4092 }
4093 public InstanceInitializerContext instanceInitializer() {
4094 return getRuleContext(InstanceInitializerContext.class,0);
4095 }
4096 public StaticInitializerContext staticInitializer() {
4097 return getRuleContext(StaticInitializerContext.class,0);
4098 }
4099 public ConstructorDeclarationContext constructorDeclaration() {
4100 return getRuleContext(ConstructorDeclarationContext.class,0);
4101 }
4102 public ClassBodyDeclarationContext(ParserRuleContext parent, int invokingState) {
4103 super(parent, invokingState);
4104 }
4105 @Override public int getRuleIndex() { return RULE_classBodyDeclaration; }
4106 @Override
4107 public void enterRule(ParseTreeListener listener) {
4108 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassBodyDeclaration(this);
4109 }
4110 @Override
4111 public void exitRule(ParseTreeListener listener) {
4112 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassBodyDeclaration(this);
4113 }
4114 }
4115
4116 public final ClassBodyDeclarationContext classBodyDeclaration() throws RecognitionException {
4117 ClassBodyDeclarationContext _localctx = new ClassBodyDeclarationContext(_ctx, getState());
4118 enterRule(_localctx, 120, RULE_classBodyDeclaration);
4119 try {
4120 setState(986);
4121 _errHandler.sync(this);
4122 switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
4123 case 1:
4124 enterOuterAlt(_localctx, 1);
4125 {
4126 setState(982);
4127 classMemberDeclaration();
4128 }
4129 break;
4130 case 2:
4131 enterOuterAlt(_localctx, 2);
4132 {
4133 setState(983);
4134 instanceInitializer();
4135 }
4136 break;
4137 case 3:
4138 enterOuterAlt(_localctx, 3);
4139 {
4140 setState(984);
4141 staticInitializer();
4142 }
4143 break;
4144 case 4:
4145 enterOuterAlt(_localctx, 4);
4146 {
4147 setState(985);
4148 constructorDeclaration();
4149 }
4150 break;
4151 }
4152 }
4153 catch (RecognitionException re) {
4154 _localctx.exception = re;
4155 _errHandler.reportError(this, re);
4156 _errHandler.recover(this, re);
4157 }
4158 finally {
4159 exitRule();
4160 }
4161 return _localctx;
4162 }
4163
4164 public static class ClassMemberDeclarationContext extends ParserRuleContext {
4165 public FieldDeclarationContext fieldDeclaration() {
4166 return getRuleContext(FieldDeclarationContext.class,0);
4167 }
4168 public MethodDeclarationContext methodDeclaration() {
4169 return getRuleContext(MethodDeclarationContext.class,0);
4170 }
4171 public ClassDeclarationContext classDeclaration() {
4172 return getRuleContext(ClassDeclarationContext.class,0);
4173 }
4174 public InterfaceDeclarationContext interfaceDeclaration() {
4175 return getRuleContext(InterfaceDeclarationContext.class,0);
4176 }
4177 public ClassMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
4178 super(parent, invokingState);
4179 }
4180 @Override public int getRuleIndex() { return RULE_classMemberDeclaration; }
4181 @Override
4182 public void enterRule(ParseTreeListener listener) {
4183 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassMemberDeclaration(this);
4184 }
4185 @Override
4186 public void exitRule(ParseTreeListener listener) {
4187 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassMemberDeclaration(this);
4188 }
4189 }
4190
4191 public final ClassMemberDeclarationContext classMemberDeclaration() throws RecognitionException {
4192 ClassMemberDeclarationContext _localctx = new ClassMemberDeclarationContext(_ctx, getState());
4193 enterRule(_localctx, 122, RULE_classMemberDeclaration);
4194 try {
4195 setState(993);
4196 _errHandler.sync(this);
4197 switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
4198 case 1:
4199 enterOuterAlt(_localctx, 1);
4200 {
4201 setState(988);
4202 fieldDeclaration();
4203 }
4204 break;
4205 case 2:
4206 enterOuterAlt(_localctx, 2);
4207 {
4208 setState(989);
4209 methodDeclaration();
4210 }
4211 break;
4212 case 3:
4213 enterOuterAlt(_localctx, 3);
4214 {
4215 setState(990);
4216 classDeclaration();
4217 }
4218 break;
4219 case 4:
4220 enterOuterAlt(_localctx, 4);
4221 {
4222 setState(991);
4223 interfaceDeclaration();
4224 }
4225 break;
4226 case 5:
4227 enterOuterAlt(_localctx, 5);
4228 {
4229 setState(992);
4230 match(SEMI);
4231 }
4232 break;
4233 }
4234 }
4235 catch (RecognitionException re) {
4236 _localctx.exception = re;
4237 _errHandler.reportError(this, re);
4238 _errHandler.recover(this, re);
4239 }
4240 finally {
4241 exitRule();
4242 }
4243 return _localctx;
4244 }
4245
4246 public static class FieldDeclarationContext extends ParserRuleContext {
4247 public UnannTypeContext unannType() {
4248 return getRuleContext(UnannTypeContext.class,0);
4249 }
4250 public VariableDeclaratorListContext variableDeclaratorList() {
4251 return getRuleContext(VariableDeclaratorListContext.class,0);
4252 }
4253 public List<FieldModifierContext> fieldModifier() {
4254 return getRuleContexts(FieldModifierContext.class);
4255 }
4256 public FieldModifierContext fieldModifier(int i) {
4257 return getRuleContext(FieldModifierContext.class,i);
4258 }
4259 public FieldDeclarationContext(ParserRuleContext parent, int invokingState) {
4260 super(parent, invokingState);
4261 }
4262 @Override public int getRuleIndex() { return RULE_fieldDeclaration; }
4263 @Override
4264 public void enterRule(ParseTreeListener listener) {
4265 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFieldDeclaration(this);
4266 }
4267 @Override
4268 public void exitRule(ParseTreeListener listener) {
4269 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFieldDeclaration(this);
4270 }
4271 }
4272
4273 public final FieldDeclarationContext fieldDeclaration() throws RecognitionException {
4274 FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState());
4275 enterRule(_localctx, 124, RULE_fieldDeclaration);
4276 int _la;
4277 try {
4278 enterOuterAlt(_localctx, 1);
4279 {
4280 setState(998);
4281 _errHandler.sync(this);
4282 _la = _input.LA(1);
4283 while (((((_la - 28)) & ~0x3f) == 0 && ((1L << (_la - 28)) & ((1L << (FINAL - 28)) | (1L << (PRIVATE - 28)) | (1L << (PROTECTED - 28)) | (1L << (PUBLIC - 28)) | (1L << (STATIC - 28)) | (1L << (TRANSIENT - 28)) | (1L << (VOLATILE - 28)) | (1L << (AT - 28)))) != 0)) {
4284 {
4285 {
4286 setState(995);
4287 fieldModifier();
4288 }
4289 }
4290 setState(1000);
4291 _errHandler.sync(this);
4292 _la = _input.LA(1);
4293 }
4294 setState(1001);
4295 unannType();
4296 setState(1002);
4297 variableDeclaratorList();
4298 setState(1003);
4299 match(SEMI);
4300 }
4301 }
4302 catch (RecognitionException re) {
4303 _localctx.exception = re;
4304 _errHandler.reportError(this, re);
4305 _errHandler.recover(this, re);
4306 }
4307 finally {
4308 exitRule();
4309 }
4310 return _localctx;
4311 }
4312
4313 public static class FieldModifierContext extends ParserRuleContext {
4314 public AnnotationContext annotation() {
4315 return getRuleContext(AnnotationContext.class,0);
4316 }
4317 public FieldModifierContext(ParserRuleContext parent, int invokingState) {
4318 super(parent, invokingState);
4319 }
4320 @Override public int getRuleIndex() { return RULE_fieldModifier; }
4321 @Override
4322 public void enterRule(ParseTreeListener listener) {
4323 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFieldModifier(this);
4324 }
4325 @Override
4326 public void exitRule(ParseTreeListener listener) {
4327 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFieldModifier(this);
4328 }
4329 }
4330
4331 public final FieldModifierContext fieldModifier() throws RecognitionException {
4332 FieldModifierContext _localctx = new FieldModifierContext(_ctx, getState());
4333 enterRule(_localctx, 126, RULE_fieldModifier);
4334 try {
4335 setState(1013);
4336 _errHandler.sync(this);
4337 switch (_input.LA(1)) {
4338 case AT:
4339 enterOuterAlt(_localctx, 1);
4340 {
4341 setState(1005);
4342 annotation();
4343 }
4344 break;
4345 case PUBLIC:
4346 enterOuterAlt(_localctx, 2);
4347 {
4348 setState(1006);
4349 match(PUBLIC);
4350 }
4351 break;
4352 case PROTECTED:
4353 enterOuterAlt(_localctx, 3);
4354 {
4355 setState(1007);
4356 match(PROTECTED);
4357 }
4358 break;
4359 case PRIVATE:
4360 enterOuterAlt(_localctx, 4);
4361 {
4362 setState(1008);
4363 match(PRIVATE);
4364 }
4365 break;
4366 case STATIC:
4367 enterOuterAlt(_localctx, 5);
4368 {
4369 setState(1009);
4370 match(STATIC);
4371 }
4372 break;
4373 case FINAL:
4374 enterOuterAlt(_localctx, 6);
4375 {
4376 setState(1010);
4377 match(FINAL);
4378 }
4379 break;
4380 case TRANSIENT:
4381 enterOuterAlt(_localctx, 7);
4382 {
4383 setState(1011);
4384 match(TRANSIENT);
4385 }
4386 break;
4387 case VOLATILE:
4388 enterOuterAlt(_localctx, 8);
4389 {
4390 setState(1012);
4391 match(VOLATILE);
4392 }
4393 break;
4394 default:
4395 throw new NoViableAltException(this);
4396 }
4397 }
4398 catch (RecognitionException re) {
4399 _localctx.exception = re;
4400 _errHandler.reportError(this, re);
4401 _errHandler.recover(this, re);
4402 }
4403 finally {
4404 exitRule();
4405 }
4406 return _localctx;
4407 }
4408
4409 public static class VariableDeclaratorListContext extends ParserRuleContext {
4410 public List<VariableDeclaratorContext> variableDeclarator() {
4411 return getRuleContexts(VariableDeclaratorContext.class);
4412 }
4413 public VariableDeclaratorContext variableDeclarator(int i) {
4414 return getRuleContext(VariableDeclaratorContext.class,i);
4415 }
4416 public VariableDeclaratorListContext(ParserRuleContext parent, int invokingState) {
4417 super(parent, invokingState);
4418 }
4419 @Override public int getRuleIndex() { return RULE_variableDeclaratorList; }
4420 @Override
4421 public void enterRule(ParseTreeListener listener) {
4422 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterVariableDeclaratorList(this);
4423 }
4424 @Override
4425 public void exitRule(ParseTreeListener listener) {
4426 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitVariableDeclaratorList(this);
4427 }
4428 }
4429
4430 public final VariableDeclaratorListContext variableDeclaratorList() throws RecognitionException {
4431 VariableDeclaratorListContext _localctx = new VariableDeclaratorListContext(_ctx, getState());
4432 enterRule(_localctx, 128, RULE_variableDeclaratorList);
4433 int _la;
4434 try {
4435 enterOuterAlt(_localctx, 1);
4436 {
4437 setState(1015);
4438 variableDeclarator();
4439 setState(1020);
4440 _errHandler.sync(this);
4441 _la = _input.LA(1);
4442 while (_la==COMMA) {
4443 {
4444 {
4445 setState(1016);
4446 match(COMMA);
4447 setState(1017);
4448 variableDeclarator();
4449 }
4450 }
4451 setState(1022);
4452 _errHandler.sync(this);
4453 _la = _input.LA(1);
4454 }
4455 }
4456 }
4457 catch (RecognitionException re) {
4458 _localctx.exception = re;
4459 _errHandler.reportError(this, re);
4460 _errHandler.recover(this, re);
4461 }
4462 finally {
4463 exitRule();
4464 }
4465 return _localctx;
4466 }
4467
4468 public static class VariableDeclaratorContext extends ParserRuleContext {
4469 public VariableDeclaratorIdContext variableDeclaratorId() {
4470 return getRuleContext(VariableDeclaratorIdContext.class,0);
4471 }
4472 public VariableInitializerContext variableInitializer() {
4473 return getRuleContext(VariableInitializerContext.class,0);
4474 }
4475 public VariableDeclaratorContext(ParserRuleContext parent, int invokingState) {
4476 super(parent, invokingState);
4477 }
4478 @Override public int getRuleIndex() { return RULE_variableDeclarator; }
4479 @Override
4480 public void enterRule(ParseTreeListener listener) {
4481 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterVariableDeclarator(this);
4482 }
4483 @Override
4484 public void exitRule(ParseTreeListener listener) {
4485 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitVariableDeclarator(this);
4486 }
4487 }
4488
4489 public final VariableDeclaratorContext variableDeclarator() throws RecognitionException {
4490 VariableDeclaratorContext _localctx = new VariableDeclaratorContext(_ctx, getState());
4491 enterRule(_localctx, 130, RULE_variableDeclarator);
4492 int _la;
4493 try {
4494 enterOuterAlt(_localctx, 1);
4495 {
4496 setState(1023);
4497 variableDeclaratorId();
4498 setState(1026);
4499 _errHandler.sync(this);
4500 _la = _input.LA(1);
4501 if (_la==ASSIGN) {
4502 {
4503 setState(1024);
4504 match(ASSIGN);
4505 setState(1025);
4506 variableInitializer();
4507 }
4508 }
4509
4510 }
4511 }
4512 catch (RecognitionException re) {
4513 _localctx.exception = re;
4514 _errHandler.reportError(this, re);
4515 _errHandler.recover(this, re);
4516 }
4517 finally {
4518 exitRule();
4519 }
4520 return _localctx;
4521 }
4522
4523 public static class VariableDeclaratorIdContext extends ParserRuleContext {
4524 public IdentifierContext identifier() {
4525 return getRuleContext(IdentifierContext.class,0);
4526 }
4527 public DimsContext dims() {
4528 return getRuleContext(DimsContext.class,0);
4529 }
4530 public VariableDeclaratorIdContext(ParserRuleContext parent, int invokingState) {
4531 super(parent, invokingState);
4532 }
4533 @Override public int getRuleIndex() { return RULE_variableDeclaratorId; }
4534 @Override
4535 public void enterRule(ParseTreeListener listener) {
4536 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterVariableDeclaratorId(this);
4537 }
4538 @Override
4539 public void exitRule(ParseTreeListener listener) {
4540 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitVariableDeclaratorId(this);
4541 }
4542 }
4543
4544 public final VariableDeclaratorIdContext variableDeclaratorId() throws RecognitionException {
4545 VariableDeclaratorIdContext _localctx = new VariableDeclaratorIdContext(_ctx, getState());
4546 enterRule(_localctx, 132, RULE_variableDeclaratorId);
4547 int _la;
4548 try {
4549 enterOuterAlt(_localctx, 1);
4550 {
4551 setState(1028);
4552 identifier();
4553 setState(1030);
4554 _errHandler.sync(this);
4555 _la = _input.LA(1);
4556 if (_la==LBRACK || _la==AT) {
4557 {
4558 setState(1029);
4559 dims();
4560 }
4561 }
4562
4563 }
4564 }
4565 catch (RecognitionException re) {
4566 _localctx.exception = re;
4567 _errHandler.reportError(this, re);
4568 _errHandler.recover(this, re);
4569 }
4570 finally {
4571 exitRule();
4572 }
4573 return _localctx;
4574 }
4575
4576 public static class VariableInitializerContext extends ParserRuleContext {
4577 public ExpressionContext expression() {
4578 return getRuleContext(ExpressionContext.class,0);
4579 }
4580 public ArrayInitializerContext arrayInitializer() {
4581 return getRuleContext(ArrayInitializerContext.class,0);
4582 }
4583 public VariableInitializerContext(ParserRuleContext parent, int invokingState) {
4584 super(parent, invokingState);
4585 }
4586 @Override public int getRuleIndex() { return RULE_variableInitializer; }
4587 @Override
4588 public void enterRule(ParseTreeListener listener) {
4589 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterVariableInitializer(this);
4590 }
4591 @Override
4592 public void exitRule(ParseTreeListener listener) {
4593 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitVariableInitializer(this);
4594 }
4595 }
4596
4597 public final VariableInitializerContext variableInitializer() throws RecognitionException {
4598 VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState());
4599 enterRule(_localctx, 134, RULE_variableInitializer);
4600 try {
4601 setState(1034);
4602 _errHandler.sync(this);
4603 switch (_input.LA(1)) {
4604 case T__0:
4605 case T__1:
4606 case T__2:
4607 case T__3:
4608 case T__4:
4609 case T__5:
4610 case T__6:
4611 case T__7:
4612 case T__8:
4613 case BOOLEAN:
4614 case BYTE:
4615 case CHAR:
4616 case DOUBLE:
4617 case FLOAT:
4618 case INT:
4619 case LONG:
4620 case NEW:
4621 case SHORT:
4622 case SUPER:
4623 case THIS:
4624 case VOID:
4625 case IntegerLiteral:
4626 case FloatingPointLiteral:
4627 case BooleanLiteral:
4628 case CharacterLiteral:
4629 case StringLiteral:
4630 case NullLiteral:
4631 case LPAREN:
4632 case AT:
4633 case BANG:
4634 case TILDE:
4635 case INC:
4636 case DEC:
4637 case ADD:
4638 case SUB:
4639 case Identifier:
4640 enterOuterAlt(_localctx, 1);
4641 {
4642 setState(1032);
4643 expression();
4644 }
4645 break;
4646 case LBRACE:
4647 enterOuterAlt(_localctx, 2);
4648 {
4649 setState(1033);
4650 arrayInitializer();
4651 }
4652 break;
4653 default:
4654 throw new NoViableAltException(this);
4655 }
4656 }
4657 catch (RecognitionException re) {
4658 _localctx.exception = re;
4659 _errHandler.reportError(this, re);
4660 _errHandler.recover(this, re);
4661 }
4662 finally {
4663 exitRule();
4664 }
4665 return _localctx;
4666 }
4667
4668 public static class UnannTypeContext extends ParserRuleContext {
4669 public UnannPrimitiveTypeContext unannPrimitiveType() {
4670 return getRuleContext(UnannPrimitiveTypeContext.class,0);
4671 }
4672 public UnannReferenceTypeContext unannReferenceType() {
4673 return getRuleContext(UnannReferenceTypeContext.class,0);
4674 }
4675 public UnannTypeContext(ParserRuleContext parent, int invokingState) {
4676 super(parent, invokingState);
4677 }
4678 @Override public int getRuleIndex() { return RULE_unannType; }
4679 @Override
4680 public void enterRule(ParseTreeListener listener) {
4681 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannType(this);
4682 }
4683 @Override
4684 public void exitRule(ParseTreeListener listener) {
4685 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannType(this);
4686 }
4687 }
4688
4689 public final UnannTypeContext unannType() throws RecognitionException {
4690 UnannTypeContext _localctx = new UnannTypeContext(_ctx, getState());
4691 enterRule(_localctx, 136, RULE_unannType);
4692 try {
4693 setState(1038);
4694 _errHandler.sync(this);
4695 switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
4696 case 1:
4697 enterOuterAlt(_localctx, 1);
4698 {
4699 setState(1036);
4700 unannPrimitiveType();
4701 }
4702 break;
4703 case 2:
4704 enterOuterAlt(_localctx, 2);
4705 {
4706 setState(1037);
4707 unannReferenceType();
4708 }
4709 break;
4710 }
4711 }
4712 catch (RecognitionException re) {
4713 _localctx.exception = re;
4714 _errHandler.reportError(this, re);
4715 _errHandler.recover(this, re);
4716 }
4717 finally {
4718 exitRule();
4719 }
4720 return _localctx;
4721 }
4722
4723 public static class UnannPrimitiveTypeContext extends ParserRuleContext {
4724 public NumericTypeContext numericType() {
4725 return getRuleContext(NumericTypeContext.class,0);
4726 }
4727 public UnannPrimitiveTypeContext(ParserRuleContext parent, int invokingState) {
4728 super(parent, invokingState);
4729 }
4730 @Override public int getRuleIndex() { return RULE_unannPrimitiveType; }
4731 @Override
4732 public void enterRule(ParseTreeListener listener) {
4733 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannPrimitiveType(this);
4734 }
4735 @Override
4736 public void exitRule(ParseTreeListener listener) {
4737 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannPrimitiveType(this);
4738 }
4739 }
4740
4741 public final UnannPrimitiveTypeContext unannPrimitiveType() throws RecognitionException {
4742 UnannPrimitiveTypeContext _localctx = new UnannPrimitiveTypeContext(_ctx, getState());
4743 enterRule(_localctx, 138, RULE_unannPrimitiveType);
4744 try {
4745 setState(1042);
4746 _errHandler.sync(this);
4747 switch (_input.LA(1)) {
4748 case BYTE:
4749 case CHAR:
4750 case DOUBLE:
4751 case FLOAT:
4752 case INT:
4753 case LONG:
4754 case SHORT:
4755 enterOuterAlt(_localctx, 1);
4756 {
4757 setState(1040);
4758 numericType();
4759 }
4760 break;
4761 case BOOLEAN:
4762 enterOuterAlt(_localctx, 2);
4763 {
4764 setState(1041);
4765 match(BOOLEAN);
4766 }
4767 break;
4768 default:
4769 throw new NoViableAltException(this);
4770 }
4771 }
4772 catch (RecognitionException re) {
4773 _localctx.exception = re;
4774 _errHandler.reportError(this, re);
4775 _errHandler.recover(this, re);
4776 }
4777 finally {
4778 exitRule();
4779 }
4780 return _localctx;
4781 }
4782
4783 public static class UnannReferenceTypeContext extends ParserRuleContext {
4784 public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() {
4785 return getRuleContext(UnannClassOrInterfaceTypeContext.class,0);
4786 }
4787 public UnannTypeVariableContext unannTypeVariable() {
4788 return getRuleContext(UnannTypeVariableContext.class,0);
4789 }
4790 public UnannArrayTypeContext unannArrayType() {
4791 return getRuleContext(UnannArrayTypeContext.class,0);
4792 }
4793 public UnannReferenceTypeContext(ParserRuleContext parent, int invokingState) {
4794 super(parent, invokingState);
4795 }
4796 @Override public int getRuleIndex() { return RULE_unannReferenceType; }
4797 @Override
4798 public void enterRule(ParseTreeListener listener) {
4799 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannReferenceType(this);
4800 }
4801 @Override
4802 public void exitRule(ParseTreeListener listener) {
4803 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannReferenceType(this);
4804 }
4805 }
4806
4807 public final UnannReferenceTypeContext unannReferenceType() throws RecognitionException {
4808 UnannReferenceTypeContext _localctx = new UnannReferenceTypeContext(_ctx, getState());
4809 enterRule(_localctx, 140, RULE_unannReferenceType);
4810 try {
4811 setState(1047);
4812 _errHandler.sync(this);
4813 switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) {
4814 case 1:
4815 enterOuterAlt(_localctx, 1);
4816 {
4817 setState(1044);
4818 unannClassOrInterfaceType();
4819 }
4820 break;
4821 case 2:
4822 enterOuterAlt(_localctx, 2);
4823 {
4824 setState(1045);
4825 unannTypeVariable();
4826 }
4827 break;
4828 case 3:
4829 enterOuterAlt(_localctx, 3);
4830 {
4831 setState(1046);
4832 unannArrayType();
4833 }
4834 break;
4835 }
4836 }
4837 catch (RecognitionException re) {
4838 _localctx.exception = re;
4839 _errHandler.reportError(this, re);
4840 _errHandler.recover(this, re);
4841 }
4842 finally {
4843 exitRule();
4844 }
4845 return _localctx;
4846 }
4847
4848 public static class UnannClassOrInterfaceTypeContext extends ParserRuleContext {
4849 public UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() {
4850 return getRuleContext(UnannClassType_lfno_unannClassOrInterfaceTypeContext.class,0);
4851 }
4852 public UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext unannInterfaceType_lfno_unannClassOrInterfaceType() {
4853 return getRuleContext(UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext.class,0);
4854 }
4855 public List<UnannClassType_lf_unannClassOrInterfaceTypeContext> unannClassType_lf_unannClassOrInterfaceType() {
4856 return getRuleContexts(UnannClassType_lf_unannClassOrInterfaceTypeContext.class);
4857 }
4858 public UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType(int i) {
4859 return getRuleContext(UnannClassType_lf_unannClassOrInterfaceTypeContext.class,i);
4860 }
4861 public List<UnannInterfaceType_lf_unannClassOrInterfaceTypeContext> unannInterfaceType_lf_unannClassOrInterfaceType() {
4862 return getRuleContexts(UnannInterfaceType_lf_unannClassOrInterfaceTypeContext.class);
4863 }
4864 public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext unannInterfaceType_lf_unannClassOrInterfaceType(int i) {
4865 return getRuleContext(UnannInterfaceType_lf_unannClassOrInterfaceTypeContext.class,i);
4866 }
4867 public UnannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
4868 super(parent, invokingState);
4869 }
4870 @Override public int getRuleIndex() { return RULE_unannClassOrInterfaceType; }
4871 @Override
4872 public void enterRule(ParseTreeListener listener) {
4873 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannClassOrInterfaceType(this);
4874 }
4875 @Override
4876 public void exitRule(ParseTreeListener listener) {
4877 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannClassOrInterfaceType(this);
4878 }
4879 }
4880
4881 public final UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() throws RecognitionException {
4882 UnannClassOrInterfaceTypeContext _localctx = new UnannClassOrInterfaceTypeContext(_ctx, getState());
4883 enterRule(_localctx, 142, RULE_unannClassOrInterfaceType);
4884 try {
4885 int _alt;
4886 enterOuterAlt(_localctx, 1);
4887 {
4888 setState(1051);
4889 _errHandler.sync(this);
4890 switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
4891 case 1:
4892 {
4893 setState(1049);
4894 unannClassType_lfno_unannClassOrInterfaceType();
4895 }
4896 break;
4897 case 2:
4898 {
4899 setState(1050);
4900 unannInterfaceType_lfno_unannClassOrInterfaceType();
4901 }
4902 break;
4903 }
4904 setState(1057);
4905 _errHandler.sync(this);
4906 _alt = getInterpreter().adaptivePredict(_input,77,_ctx);
4907 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
4908 if ( _alt==1 ) {
4909 {
4910 setState(1055);
4911 _errHandler.sync(this);
4912 switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) {
4913 case 1:
4914 {
4915 setState(1053);
4916 unannClassType_lf_unannClassOrInterfaceType();
4917 }
4918 break;
4919 case 2:
4920 {
4921 setState(1054);
4922 unannInterfaceType_lf_unannClassOrInterfaceType();
4923 }
4924 break;
4925 }
4926 }
4927 }
4928 setState(1059);
4929 _errHandler.sync(this);
4930 _alt = getInterpreter().adaptivePredict(_input,77,_ctx);
4931 }
4932 }
4933 }
4934 catch (RecognitionException re) {
4935 _localctx.exception = re;
4936 _errHandler.reportError(this, re);
4937 _errHandler.recover(this, re);
4938 }
4939 finally {
4940 exitRule();
4941 }
4942 return _localctx;
4943 }
4944
4945 public static class UnannClassTypeContext extends ParserRuleContext {
4946 public IdentifierContext identifier() {
4947 return getRuleContext(IdentifierContext.class,0);
4948 }
4949 public TypeArgumentsContext typeArguments() {
4950 return getRuleContext(TypeArgumentsContext.class,0);
4951 }
4952 public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() {
4953 return getRuleContext(UnannClassOrInterfaceTypeContext.class,0);
4954 }
4955 public List<AnnotationContext> annotation() {
4956 return getRuleContexts(AnnotationContext.class);
4957 }
4958 public AnnotationContext annotation(int i) {
4959 return getRuleContext(AnnotationContext.class,i);
4960 }
4961 public UnannClassTypeContext(ParserRuleContext parent, int invokingState) {
4962 super(parent, invokingState);
4963 }
4964 @Override public int getRuleIndex() { return RULE_unannClassType; }
4965 @Override
4966 public void enterRule(ParseTreeListener listener) {
4967 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannClassType(this);
4968 }
4969 @Override
4970 public void exitRule(ParseTreeListener listener) {
4971 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannClassType(this);
4972 }
4973 }
4974
4975 public final UnannClassTypeContext unannClassType() throws RecognitionException {
4976 UnannClassTypeContext _localctx = new UnannClassTypeContext(_ctx, getState());
4977 enterRule(_localctx, 144, RULE_unannClassType);
4978 int _la;
4979 try {
4980 setState(1076);
4981 _errHandler.sync(this);
4982 switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) {
4983 case 1:
4984 enterOuterAlt(_localctx, 1);
4985 {
4986 setState(1060);
4987 identifier();
4988 setState(1062);
4989 _errHandler.sync(this);
4990 _la = _input.LA(1);
4991 if (_la==LT) {
4992 {
4993 setState(1061);
4994 typeArguments();
4995 }
4996 }
4997
4998 }
4999 break;
5000 case 2:
5001 enterOuterAlt(_localctx, 2);
5002 {
5003 setState(1064);
5004 unannClassOrInterfaceType();
5005 setState(1065);
5006 match(DOT);
5007 setState(1069);
5008 _errHandler.sync(this);
5009 _la = _input.LA(1);
5010 while (_la==AT) {
5011 {
5012 {
5013 setState(1066);
5014 annotation();
5015 }
5016 }
5017 setState(1071);
5018 _errHandler.sync(this);
5019 _la = _input.LA(1);
5020 }
5021 setState(1072);
5022 identifier();
5023 setState(1074);
5024 _errHandler.sync(this);
5025 _la = _input.LA(1);
5026 if (_la==LT) {
5027 {
5028 setState(1073);
5029 typeArguments();
5030 }
5031 }
5032
5033 }
5034 break;
5035 }
5036 }
5037 catch (RecognitionException re) {
5038 _localctx.exception = re;
5039 _errHandler.reportError(this, re);
5040 _errHandler.recover(this, re);
5041 }
5042 finally {
5043 exitRule();
5044 }
5045 return _localctx;
5046 }
5047
5048 public static class UnannClassType_lf_unannClassOrInterfaceTypeContext extends ParserRuleContext {
5049 public IdentifierContext identifier() {
5050 return getRuleContext(IdentifierContext.class,0);
5051 }
5052 public List<AnnotationContext> annotation() {
5053 return getRuleContexts(AnnotationContext.class);
5054 }
5055 public AnnotationContext annotation(int i) {
5056 return getRuleContext(AnnotationContext.class,i);
5057 }
5058 public TypeArgumentsContext typeArguments() {
5059 return getRuleContext(TypeArgumentsContext.class,0);
5060 }
5061 public UnannClassType_lf_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
5062 super(parent, invokingState);
5063 }
5064 @Override public int getRuleIndex() { return RULE_unannClassType_lf_unannClassOrInterfaceType; }
5065 @Override
5066 public void enterRule(ParseTreeListener listener) {
5067 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannClassType_lf_unannClassOrInterfaceType(this);
5068 }
5069 @Override
5070 public void exitRule(ParseTreeListener listener) {
5071 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannClassType_lf_unannClassOrInterfaceType(this);
5072 }
5073 }
5074
5075 public final UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType() throws RecognitionException {
5076 UnannClassType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lf_unannClassOrInterfaceTypeContext(_ctx, getState());
5077 enterRule(_localctx, 146, RULE_unannClassType_lf_unannClassOrInterfaceType);
5078 int _la;
5079 try {
5080 enterOuterAlt(_localctx, 1);
5081 {
5082 setState(1078);
5083 match(DOT);
5084 setState(1082);
5085 _errHandler.sync(this);
5086 _la = _input.LA(1);
5087 while (_la==AT) {
5088 {
5089 {
5090 setState(1079);
5091 annotation();
5092 }
5093 }
5094 setState(1084);
5095 _errHandler.sync(this);
5096 _la = _input.LA(1);
5097 }
5098 setState(1085);
5099 identifier();
5100 setState(1087);
5101 _errHandler.sync(this);
5102 _la = _input.LA(1);
5103 if (_la==LT) {
5104 {
5105 setState(1086);
5106 typeArguments();
5107 }
5108 }
5109
5110 }
5111 }
5112 catch (RecognitionException re) {
5113 _localctx.exception = re;
5114 _errHandler.reportError(this, re);
5115 _errHandler.recover(this, re);
5116 }
5117 finally {
5118 exitRule();
5119 }
5120 return _localctx;
5121 }
5122
5123 public static class UnannClassType_lfno_unannClassOrInterfaceTypeContext extends ParserRuleContext {
5124 public IdentifierContext identifier() {
5125 return getRuleContext(IdentifierContext.class,0);
5126 }
5127 public TypeArgumentsContext typeArguments() {
5128 return getRuleContext(TypeArgumentsContext.class,0);
5129 }
5130 public UnannClassType_lfno_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
5131 super(parent, invokingState);
5132 }
5133 @Override public int getRuleIndex() { return RULE_unannClassType_lfno_unannClassOrInterfaceType; }
5134 @Override
5135 public void enterRule(ParseTreeListener listener) {
5136 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannClassType_lfno_unannClassOrInterfaceType(this);
5137 }
5138 @Override
5139 public void exitRule(ParseTreeListener listener) {
5140 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannClassType_lfno_unannClassOrInterfaceType(this);
5141 }
5142 }
5143
5144 public final UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() throws RecognitionException {
5145 UnannClassType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lfno_unannClassOrInterfaceTypeContext(_ctx, getState());
5146 enterRule(_localctx, 148, RULE_unannClassType_lfno_unannClassOrInterfaceType);
5147 int _la;
5148 try {
5149 enterOuterAlt(_localctx, 1);
5150 {
5151 setState(1089);
5152 identifier();
5153 setState(1091);
5154 _errHandler.sync(this);
5155 _la = _input.LA(1);
5156 if (_la==LT) {
5157 {
5158 setState(1090);
5159 typeArguments();
5160 }
5161 }
5162
5163 }
5164 }
5165 catch (RecognitionException re) {
5166 _localctx.exception = re;
5167 _errHandler.reportError(this, re);
5168 _errHandler.recover(this, re);
5169 }
5170 finally {
5171 exitRule();
5172 }
5173 return _localctx;
5174 }
5175
5176 public static class UnannInterfaceTypeContext extends ParserRuleContext {
5177 public UnannClassTypeContext unannClassType() {
5178 return getRuleContext(UnannClassTypeContext.class,0);
5179 }
5180 public UnannInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
5181 super(parent, invokingState);
5182 }
5183 @Override public int getRuleIndex() { return RULE_unannInterfaceType; }
5184 @Override
5185 public void enterRule(ParseTreeListener listener) {
5186 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannInterfaceType(this);
5187 }
5188 @Override
5189 public void exitRule(ParseTreeListener listener) {
5190 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannInterfaceType(this);
5191 }
5192 }
5193
5194 public final UnannInterfaceTypeContext unannInterfaceType() throws RecognitionException {
5195 UnannInterfaceTypeContext _localctx = new UnannInterfaceTypeContext(_ctx, getState());
5196 enterRule(_localctx, 150, RULE_unannInterfaceType);
5197 try {
5198 enterOuterAlt(_localctx, 1);
5199 {
5200 setState(1093);
5201 unannClassType();
5202 }
5203 }
5204 catch (RecognitionException re) {
5205 _localctx.exception = re;
5206 _errHandler.reportError(this, re);
5207 _errHandler.recover(this, re);
5208 }
5209 finally {
5210 exitRule();
5211 }
5212 return _localctx;
5213 }
5214
5215 public static class UnannInterfaceType_lf_unannClassOrInterfaceTypeContext extends ParserRuleContext {
5216 public UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType() {
5217 return getRuleContext(UnannClassType_lf_unannClassOrInterfaceTypeContext.class,0);
5218 }
5219 public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
5220 super(parent, invokingState);
5221 }
5222 @Override public int getRuleIndex() { return RULE_unannInterfaceType_lf_unannClassOrInterfaceType; }
5223 @Override
5224 public void enterRule(ParseTreeListener listener) {
5225 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannInterfaceType_lf_unannClassOrInterfaceType(this);
5226 }
5227 @Override
5228 public void exitRule(ParseTreeListener listener) {
5229 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannInterfaceType_lf_unannClassOrInterfaceType(this);
5230 }
5231 }
5232
5233 public final UnannInterfaceType_lf_unannClassOrInterfaceTypeContext unannInterfaceType_lf_unannClassOrInterfaceType() throws RecognitionException {
5234 UnannInterfaceType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lf_unannClassOrInterfaceTypeContext(_ctx, getState());
5235 enterRule(_localctx, 152, RULE_unannInterfaceType_lf_unannClassOrInterfaceType);
5236 try {
5237 enterOuterAlt(_localctx, 1);
5238 {
5239 setState(1095);
5240 unannClassType_lf_unannClassOrInterfaceType();
5241 }
5242 }
5243 catch (RecognitionException re) {
5244 _localctx.exception = re;
5245 _errHandler.reportError(this, re);
5246 _errHandler.recover(this, re);
5247 }
5248 finally {
5249 exitRule();
5250 }
5251 return _localctx;
5252 }
5253
5254 public static class UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext extends ParserRuleContext {
5255 public UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() {
5256 return getRuleContext(UnannClassType_lfno_unannClassOrInterfaceTypeContext.class,0);
5257 }
5258 public UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
5259 super(parent, invokingState);
5260 }
5261 @Override public int getRuleIndex() { return RULE_unannInterfaceType_lfno_unannClassOrInterfaceType; }
5262 @Override
5263 public void enterRule(ParseTreeListener listener) {
5264 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannInterfaceType_lfno_unannClassOrInterfaceType(this);
5265 }
5266 @Override
5267 public void exitRule(ParseTreeListener listener) {
5268 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannInterfaceType_lfno_unannClassOrInterfaceType(this);
5269 }
5270 }
5271
5272 public final UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext unannInterfaceType_lfno_unannClassOrInterfaceType() throws RecognitionException {
5273 UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(_ctx, getState());
5274 enterRule(_localctx, 154, RULE_unannInterfaceType_lfno_unannClassOrInterfaceType);
5275 try {
5276 enterOuterAlt(_localctx, 1);
5277 {
5278 setState(1097);
5279 unannClassType_lfno_unannClassOrInterfaceType();
5280 }
5281 }
5282 catch (RecognitionException re) {
5283 _localctx.exception = re;
5284 _errHandler.reportError(this, re);
5285 _errHandler.recover(this, re);
5286 }
5287 finally {
5288 exitRule();
5289 }
5290 return _localctx;
5291 }
5292
5293 public static class UnannTypeVariableContext extends ParserRuleContext {
5294 public IdentifierContext identifier() {
5295 return getRuleContext(IdentifierContext.class,0);
5296 }
5297 public UnannTypeVariableContext(ParserRuleContext parent, int invokingState) {
5298 super(parent, invokingState);
5299 }
5300 @Override public int getRuleIndex() { return RULE_unannTypeVariable; }
5301 @Override
5302 public void enterRule(ParseTreeListener listener) {
5303 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannTypeVariable(this);
5304 }
5305 @Override
5306 public void exitRule(ParseTreeListener listener) {
5307 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannTypeVariable(this);
5308 }
5309 }
5310
5311 public final UnannTypeVariableContext unannTypeVariable() throws RecognitionException {
5312 UnannTypeVariableContext _localctx = new UnannTypeVariableContext(_ctx, getState());
5313 enterRule(_localctx, 156, RULE_unannTypeVariable);
5314 try {
5315 enterOuterAlt(_localctx, 1);
5316 {
5317 setState(1099);
5318 identifier();
5319 }
5320 }
5321 catch (RecognitionException re) {
5322 _localctx.exception = re;
5323 _errHandler.reportError(this, re);
5324 _errHandler.recover(this, re);
5325 }
5326 finally {
5327 exitRule();
5328 }
5329 return _localctx;
5330 }
5331
5332 public static class UnannArrayTypeContext extends ParserRuleContext {
5333 public UnannPrimitiveTypeContext unannPrimitiveType() {
5334 return getRuleContext(UnannPrimitiveTypeContext.class,0);
5335 }
5336 public DimsContext dims() {
5337 return getRuleContext(DimsContext.class,0);
5338 }
5339 public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() {
5340 return getRuleContext(UnannClassOrInterfaceTypeContext.class,0);
5341 }
5342 public UnannTypeVariableContext unannTypeVariable() {
5343 return getRuleContext(UnannTypeVariableContext.class,0);
5344 }
5345 public UnannArrayTypeContext(ParserRuleContext parent, int invokingState) {
5346 super(parent, invokingState);
5347 }
5348 @Override public int getRuleIndex() { return RULE_unannArrayType; }
5349 @Override
5350 public void enterRule(ParseTreeListener listener) {
5351 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannArrayType(this);
5352 }
5353 @Override
5354 public void exitRule(ParseTreeListener listener) {
5355 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannArrayType(this);
5356 }
5357 }
5358
5359 public final UnannArrayTypeContext unannArrayType() throws RecognitionException {
5360 UnannArrayTypeContext _localctx = new UnannArrayTypeContext(_ctx, getState());
5361 enterRule(_localctx, 158, RULE_unannArrayType);
5362 try {
5363 setState(1110);
5364 _errHandler.sync(this);
5365 switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
5366 case 1:
5367 enterOuterAlt(_localctx, 1);
5368 {
5369 setState(1101);
5370 unannPrimitiveType();
5371 setState(1102);
5372 dims();
5373 }
5374 break;
5375 case 2:
5376 enterOuterAlt(_localctx, 2);
5377 {
5378 setState(1104);
5379 unannClassOrInterfaceType();
5380 setState(1105);
5381 dims();
5382 }
5383 break;
5384 case 3:
5385 enterOuterAlt(_localctx, 3);
5386 {
5387 setState(1107);
5388 unannTypeVariable();
5389 setState(1108);
5390 dims();
5391 }
5392 break;
5393 }
5394 }
5395 catch (RecognitionException re) {
5396 _localctx.exception = re;
5397 _errHandler.reportError(this, re);
5398 _errHandler.recover(this, re);
5399 }
5400 finally {
5401 exitRule();
5402 }
5403 return _localctx;
5404 }
5405
5406 public static class MethodDeclarationContext extends ParserRuleContext {
5407 public MethodHeaderContext methodHeader() {
5408 return getRuleContext(MethodHeaderContext.class,0);
5409 }
5410 public MethodBodyContext methodBody() {
5411 return getRuleContext(MethodBodyContext.class,0);
5412 }
5413 public List<MethodModifierContext> methodModifier() {
5414 return getRuleContexts(MethodModifierContext.class);
5415 }
5416 public MethodModifierContext methodModifier(int i) {
5417 return getRuleContext(MethodModifierContext.class,i);
5418 }
5419 public MethodDeclarationContext(ParserRuleContext parent, int invokingState) {
5420 super(parent, invokingState);
5421 }
5422 @Override public int getRuleIndex() { return RULE_methodDeclaration; }
5423 @Override
5424 public void enterRule(ParseTreeListener listener) {
5425 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodDeclaration(this);
5426 }
5427 @Override
5428 public void exitRule(ParseTreeListener listener) {
5429 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodDeclaration(this);
5430 }
5431 }
5432
5433 public final MethodDeclarationContext methodDeclaration() throws RecognitionException {
5434 MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState());
5435 enterRule(_localctx, 160, RULE_methodDeclaration);
5436 int _la;
5437 try {
5438 enterOuterAlt(_localctx, 1);
5439 {
5440 setState(1115);
5441 _errHandler.sync(this);
5442 _la = _input.LA(1);
5443 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED))) != 0) || _la==AT) {
5444 {
5445 {
5446 setState(1112);
5447 methodModifier();
5448 }
5449 }
5450 setState(1117);
5451 _errHandler.sync(this);
5452 _la = _input.LA(1);
5453 }
5454 setState(1118);
5455 methodHeader();
5456 setState(1119);
5457 methodBody();
5458 }
5459 }
5460 catch (RecognitionException re) {
5461 _localctx.exception = re;
5462 _errHandler.reportError(this, re);
5463 _errHandler.recover(this, re);
5464 }
5465 finally {
5466 exitRule();
5467 }
5468 return _localctx;
5469 }
5470
5471 public static class MethodModifierContext extends ParserRuleContext {
5472 public AnnotationContext annotation() {
5473 return getRuleContext(AnnotationContext.class,0);
5474 }
5475 public MethodModifierContext(ParserRuleContext parent, int invokingState) {
5476 super(parent, invokingState);
5477 }
5478 @Override public int getRuleIndex() { return RULE_methodModifier; }
5479 @Override
5480 public void enterRule(ParseTreeListener listener) {
5481 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodModifier(this);
5482 }
5483 @Override
5484 public void exitRule(ParseTreeListener listener) {
5485 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodModifier(this);
5486 }
5487 }
5488
5489 public final MethodModifierContext methodModifier() throws RecognitionException {
5490 MethodModifierContext _localctx = new MethodModifierContext(_ctx, getState());
5491 enterRule(_localctx, 162, RULE_methodModifier);
5492 try {
5493 setState(1131);
5494 _errHandler.sync(this);
5495 switch (_input.LA(1)) {
5496 case AT:
5497 enterOuterAlt(_localctx, 1);
5498 {
5499 setState(1121);
5500 annotation();
5501 }
5502 break;
5503 case PUBLIC:
5504 enterOuterAlt(_localctx, 2);
5505 {
5506 setState(1122);
5507 match(PUBLIC);
5508 }
5509 break;
5510 case PROTECTED:
5511 enterOuterAlt(_localctx, 3);
5512 {
5513 setState(1123);
5514 match(PROTECTED);
5515 }
5516 break;
5517 case PRIVATE:
5518 enterOuterAlt(_localctx, 4);
5519 {
5520 setState(1124);
5521 match(PRIVATE);
5522 }
5523 break;
5524 case ABSTRACT:
5525 enterOuterAlt(_localctx, 5);
5526 {
5527 setState(1125);
5528 match(ABSTRACT);
5529 }
5530 break;
5531 case STATIC:
5532 enterOuterAlt(_localctx, 6);
5533 {
5534 setState(1126);
5535 match(STATIC);
5536 }
5537 break;
5538 case FINAL:
5539 enterOuterAlt(_localctx, 7);
5540 {
5541 setState(1127);
5542 match(FINAL);
5543 }
5544 break;
5545 case SYNCHRONIZED:
5546 enterOuterAlt(_localctx, 8);
5547 {
5548 setState(1128);
5549 match(SYNCHRONIZED);
5550 }
5551 break;
5552 case NATIVE:
5553 enterOuterAlt(_localctx, 9);
5554 {
5555 setState(1129);
5556 match(NATIVE);
5557 }
5558 break;
5559 case STRICTFP:
5560 enterOuterAlt(_localctx, 10);
5561 {
5562 setState(1130);
5563 match(STRICTFP);
5564 }
5565 break;
5566 default:
5567 throw new NoViableAltException(this);
5568 }
5569 }
5570 catch (RecognitionException re) {
5571 _localctx.exception = re;
5572 _errHandler.reportError(this, re);
5573 _errHandler.recover(this, re);
5574 }
5575 finally {
5576 exitRule();
5577 }
5578 return _localctx;
5579 }
5580
5581 public static class MethodHeaderContext extends ParserRuleContext {
5582 public ResultContext result() {
5583 return getRuleContext(ResultContext.class,0);
5584 }
5585 public MethodDeclaratorContext methodDeclarator() {
5586 return getRuleContext(MethodDeclaratorContext.class,0);
5587 }
5588 public Throws_Context throws_() {
5589 return getRuleContext(Throws_Context.class,0);
5590 }
5591 public TypeParametersContext typeParameters() {
5592 return getRuleContext(TypeParametersContext.class,0);
5593 }
5594 public List<AnnotationContext> annotation() {
5595 return getRuleContexts(AnnotationContext.class);
5596 }
5597 public AnnotationContext annotation(int i) {
5598 return getRuleContext(AnnotationContext.class,i);
5599 }
5600 public MethodHeaderContext(ParserRuleContext parent, int invokingState) {
5601 super(parent, invokingState);
5602 }
5603 @Override public int getRuleIndex() { return RULE_methodHeader; }
5604 @Override
5605 public void enterRule(ParseTreeListener listener) {
5606 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodHeader(this);
5607 }
5608 @Override
5609 public void exitRule(ParseTreeListener listener) {
5610 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodHeader(this);
5611 }
5612 }
5613
5614 public final MethodHeaderContext methodHeader() throws RecognitionException {
5615 MethodHeaderContext _localctx = new MethodHeaderContext(_ctx, getState());
5616 enterRule(_localctx, 164, RULE_methodHeader);
5617 int _la;
5618 try {
5619 setState(1150);
5620 _errHandler.sync(this);
5621 switch (_input.LA(1)) {
5622 case T__0:
5623 case T__1:
5624 case T__2:
5625 case T__3:
5626 case T__4:
5627 case T__5:
5628 case T__6:
5629 case T__7:
5630 case T__8:
5631 case BOOLEAN:
5632 case BYTE:
5633 case CHAR:
5634 case DOUBLE:
5635 case FLOAT:
5636 case INT:
5637 case LONG:
5638 case SHORT:
5639 case VOID:
5640 case Identifier:
5641 enterOuterAlt(_localctx, 1);
5642 {
5643 setState(1133);
5644 result();
5645 setState(1134);
5646 methodDeclarator();
5647 setState(1136);
5648 _errHandler.sync(this);
5649 _la = _input.LA(1);
5650 if (_la==THROWS) {
5651 {
5652 setState(1135);
5653 throws_();
5654 }
5655 }
5656
5657 }
5658 break;
5659 case LT:
5660 enterOuterAlt(_localctx, 2);
5661 {
5662 setState(1138);
5663 typeParameters();
5664 setState(1142);
5665 _errHandler.sync(this);
5666 _la = _input.LA(1);
5667 while (_la==AT) {
5668 {
5669 {
5670 setState(1139);
5671 annotation();
5672 }
5673 }
5674 setState(1144);
5675 _errHandler.sync(this);
5676 _la = _input.LA(1);
5677 }
5678 setState(1145);
5679 result();
5680 setState(1146);
5681 methodDeclarator();
5682 setState(1148);
5683 _errHandler.sync(this);
5684 _la = _input.LA(1);
5685 if (_la==THROWS) {
5686 {
5687 setState(1147);
5688 throws_();
5689 }
5690 }
5691
5692 }
5693 break;
5694 default:
5695 throw new NoViableAltException(this);
5696 }
5697 }
5698 catch (RecognitionException re) {
5699 _localctx.exception = re;
5700 _errHandler.reportError(this, re);
5701 _errHandler.recover(this, re);
5702 }
5703 finally {
5704 exitRule();
5705 }
5706 return _localctx;
5707 }
5708
5709 public static class ResultContext extends ParserRuleContext {
5710 public UnannTypeContext unannType() {
5711 return getRuleContext(UnannTypeContext.class,0);
5712 }
5713 public ResultContext(ParserRuleContext parent, int invokingState) {
5714 super(parent, invokingState);
5715 }
5716 @Override public int getRuleIndex() { return RULE_result; }
5717 @Override
5718 public void enterRule(ParseTreeListener listener) {
5719 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterResult(this);
5720 }
5721 @Override
5722 public void exitRule(ParseTreeListener listener) {
5723 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitResult(this);
5724 }
5725 }
5726
5727 public final ResultContext result() throws RecognitionException {
5728 ResultContext _localctx = new ResultContext(_ctx, getState());
5729 enterRule(_localctx, 166, RULE_result);
5730 try {
5731 setState(1154);
5732 _errHandler.sync(this);
5733 switch (_input.LA(1)) {
5734 case T__0:
5735 case T__1:
5736 case T__2:
5737 case T__3:
5738 case T__4:
5739 case T__5:
5740 case T__6:
5741 case T__7:
5742 case T__8:
5743 case BOOLEAN:
5744 case BYTE:
5745 case CHAR:
5746 case DOUBLE:
5747 case FLOAT:
5748 case INT:
5749 case LONG:
5750 case SHORT:
5751 case Identifier:
5752 enterOuterAlt(_localctx, 1);
5753 {
5754 setState(1152);
5755 unannType();
5756 }
5757 break;
5758 case VOID:
5759 enterOuterAlt(_localctx, 2);
5760 {
5761 setState(1153);
5762 match(VOID);
5763 }
5764 break;
5765 default:
5766 throw new NoViableAltException(this);
5767 }
5768 }
5769 catch (RecognitionException re) {
5770 _localctx.exception = re;
5771 _errHandler.reportError(this, re);
5772 _errHandler.recover(this, re);
5773 }
5774 finally {
5775 exitRule();
5776 }
5777 return _localctx;
5778 }
5779
5780 public static class MethodDeclaratorContext extends ParserRuleContext {
5781 public IdentifierContext identifier() {
5782 return getRuleContext(IdentifierContext.class,0);
5783 }
5784 public FormalParameterListContext formalParameterList() {
5785 return getRuleContext(FormalParameterListContext.class,0);
5786 }
5787 public DimsContext dims() {
5788 return getRuleContext(DimsContext.class,0);
5789 }
5790 public MethodDeclaratorContext(ParserRuleContext parent, int invokingState) {
5791 super(parent, invokingState);
5792 }
5793 @Override public int getRuleIndex() { return RULE_methodDeclarator; }
5794 @Override
5795 public void enterRule(ParseTreeListener listener) {
5796 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodDeclarator(this);
5797 }
5798 @Override
5799 public void exitRule(ParseTreeListener listener) {
5800 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodDeclarator(this);
5801 }
5802 }
5803
5804 public final MethodDeclaratorContext methodDeclarator() throws RecognitionException {
5805 MethodDeclaratorContext _localctx = new MethodDeclaratorContext(_ctx, getState());
5806 enterRule(_localctx, 168, RULE_methodDeclarator);
5807 int _la;
5808 try {
5809 enterOuterAlt(_localctx, 1);
5810 {
5811 setState(1156);
5812 identifier();
5813 setState(1157);
5814 match(LPAREN);
5815 setState(1159);
5816 _errHandler.sync(this);
5817 _la = _input.LA(1);
5818 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la==AT || _la==Identifier) {
5819 {
5820 setState(1158);
5821 formalParameterList();
5822 }
5823 }
5824
5825 setState(1161);
5826 match(RPAREN);
5827 setState(1163);
5828 _errHandler.sync(this);
5829 _la = _input.LA(1);
5830 if (_la==LBRACK || _la==AT) {
5831 {
5832 setState(1162);
5833 dims();
5834 }
5835 }
5836
5837 }
5838 }
5839 catch (RecognitionException re) {
5840 _localctx.exception = re;
5841 _errHandler.reportError(this, re);
5842 _errHandler.recover(this, re);
5843 }
5844 finally {
5845 exitRule();
5846 }
5847 return _localctx;
5848 }
5849
5850 public static class FormalParameterListContext extends ParserRuleContext {
5851 public FormalParametersContext formalParameters() {
5852 return getRuleContext(FormalParametersContext.class,0);
5853 }
5854 public LastFormalParameterContext lastFormalParameter() {
5855 return getRuleContext(LastFormalParameterContext.class,0);
5856 }
5857 public ReceiverParameterContext receiverParameter() {
5858 return getRuleContext(ReceiverParameterContext.class,0);
5859 }
5860 public FormalParameterListContext(ParserRuleContext parent, int invokingState) {
5861 super(parent, invokingState);
5862 }
5863 @Override public int getRuleIndex() { return RULE_formalParameterList; }
5864 @Override
5865 public void enterRule(ParseTreeListener listener) {
5866 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFormalParameterList(this);
5867 }
5868 @Override
5869 public void exitRule(ParseTreeListener listener) {
5870 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFormalParameterList(this);
5871 }
5872 }
5873
5874 public final FormalParameterListContext formalParameterList() throws RecognitionException {
5875 FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState());
5876 enterRule(_localctx, 170, RULE_formalParameterList);
5877 try {
5878 setState(1171);
5879 _errHandler.sync(this);
5880 switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
5881 case 1:
5882 enterOuterAlt(_localctx, 1);
5883 {
5884 setState(1165);
5885 formalParameters();
5886 setState(1166);
5887 match(COMMA);
5888 setState(1167);
5889 lastFormalParameter();
5890 }
5891 break;
5892 case 2:
5893 enterOuterAlt(_localctx, 2);
5894 {
5895 setState(1169);
5896 lastFormalParameter();
5897 }
5898 break;
5899 case 3:
5900 enterOuterAlt(_localctx, 3);
5901 {
5902 setState(1170);
5903 receiverParameter();
5904 }
5905 break;
5906 }
5907 }
5908 catch (RecognitionException re) {
5909 _localctx.exception = re;
5910 _errHandler.reportError(this, re);
5911 _errHandler.recover(this, re);
5912 }
5913 finally {
5914 exitRule();
5915 }
5916 return _localctx;
5917 }
5918
5919 public static class FormalParametersContext extends ParserRuleContext {
5920 public List<FormalParameterContext> formalParameter() {
5921 return getRuleContexts(FormalParameterContext.class);
5922 }
5923 public FormalParameterContext formalParameter(int i) {
5924 return getRuleContext(FormalParameterContext.class,i);
5925 }
5926 public ReceiverParameterContext receiverParameter() {
5927 return getRuleContext(ReceiverParameterContext.class,0);
5928 }
5929 public FormalParametersContext(ParserRuleContext parent, int invokingState) {
5930 super(parent, invokingState);
5931 }
5932 @Override public int getRuleIndex() { return RULE_formalParameters; }
5933 @Override
5934 public void enterRule(ParseTreeListener listener) {
5935 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFormalParameters(this);
5936 }
5937 @Override
5938 public void exitRule(ParseTreeListener listener) {
5939 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFormalParameters(this);
5940 }
5941 }
5942
5943 public final FormalParametersContext formalParameters() throws RecognitionException {
5944 FormalParametersContext _localctx = new FormalParametersContext(_ctx, getState());
5945 enterRule(_localctx, 172, RULE_formalParameters);
5946 try {
5947 int _alt;
5948 setState(1189);
5949 _errHandler.sync(this);
5950 switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
5951 case 1:
5952 enterOuterAlt(_localctx, 1);
5953 {
5954 setState(1173);
5955 formalParameter();
5956 setState(1178);
5957 _errHandler.sync(this);
5958 _alt = getInterpreter().adaptivePredict(_input,96,_ctx);
5959 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5960 if ( _alt==1 ) {
5961 {
5962 {
5963 setState(1174);
5964 match(COMMA);
5965 setState(1175);
5966 formalParameter();
5967 }
5968 }
5969 }
5970 setState(1180);
5971 _errHandler.sync(this);
5972 _alt = getInterpreter().adaptivePredict(_input,96,_ctx);
5973 }
5974 }
5975 break;
5976 case 2:
5977 enterOuterAlt(_localctx, 2);
5978 {
5979 setState(1181);
5980 receiverParameter();
5981 setState(1186);
5982 _errHandler.sync(this);
5983 _alt = getInterpreter().adaptivePredict(_input,97,_ctx);
5984 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5985 if ( _alt==1 ) {
5986 {
5987 {
5988 setState(1182);
5989 match(COMMA);
5990 setState(1183);
5991 formalParameter();
5992 }
5993 }
5994 }
5995 setState(1188);
5996 _errHandler.sync(this);
5997 _alt = getInterpreter().adaptivePredict(_input,97,_ctx);
5998 }
5999 }
6000 break;
6001 }
6002 }
6003 catch (RecognitionException re) {
6004 _localctx.exception = re;
6005 _errHandler.reportError(this, re);
6006 _errHandler.recover(this, re);
6007 }
6008 finally {
6009 exitRule();
6010 }
6011 return _localctx;
6012 }
6013
6014 public static class FormalParameterContext extends ParserRuleContext {
6015 public UnannTypeContext unannType() {
6016 return getRuleContext(UnannTypeContext.class,0);
6017 }
6018 public VariableDeclaratorIdContext variableDeclaratorId() {
6019 return getRuleContext(VariableDeclaratorIdContext.class,0);
6020 }
6021 public List<VariableModifierContext> variableModifier() {
6022 return getRuleContexts(VariableModifierContext.class);
6023 }
6024 public VariableModifierContext variableModifier(int i) {
6025 return getRuleContext(VariableModifierContext.class,i);
6026 }
6027 public FormalParameterContext(ParserRuleContext parent, int invokingState) {
6028 super(parent, invokingState);
6029 }
6030 @Override public int getRuleIndex() { return RULE_formalParameter; }
6031 @Override
6032 public void enterRule(ParseTreeListener listener) {
6033 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFormalParameter(this);
6034 }
6035 @Override
6036 public void exitRule(ParseTreeListener listener) {
6037 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFormalParameter(this);
6038 }
6039 }
6040
6041 public final FormalParameterContext formalParameter() throws RecognitionException {
6042 FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState());
6043 enterRule(_localctx, 174, RULE_formalParameter);
6044 int _la;
6045 try {
6046 enterOuterAlt(_localctx, 1);
6047 {
6048 setState(1194);
6049 _errHandler.sync(this);
6050 _la = _input.LA(1);
6051 while (_la==FINAL || _la==AT) {
6052 {
6053 {
6054 setState(1191);
6055 variableModifier();
6056 }
6057 }
6058 setState(1196);
6059 _errHandler.sync(this);
6060 _la = _input.LA(1);
6061 }
6062 setState(1197);
6063 unannType();
6064 setState(1198);
6065 variableDeclaratorId();
6066 }
6067 }
6068 catch (RecognitionException re) {
6069 _localctx.exception = re;
6070 _errHandler.reportError(this, re);
6071 _errHandler.recover(this, re);
6072 }
6073 finally {
6074 exitRule();
6075 }
6076 return _localctx;
6077 }
6078
6079 public static class VariableModifierContext extends ParserRuleContext {
6080 public AnnotationContext annotation() {
6081 return getRuleContext(AnnotationContext.class,0);
6082 }
6083 public VariableModifierContext(ParserRuleContext parent, int invokingState) {
6084 super(parent, invokingState);
6085 }
6086 @Override public int getRuleIndex() { return RULE_variableModifier; }
6087 @Override
6088 public void enterRule(ParseTreeListener listener) {
6089 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterVariableModifier(this);
6090 }
6091 @Override
6092 public void exitRule(ParseTreeListener listener) {
6093 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitVariableModifier(this);
6094 }
6095 }
6096
6097 public final VariableModifierContext variableModifier() throws RecognitionException {
6098 VariableModifierContext _localctx = new VariableModifierContext(_ctx, getState());
6099 enterRule(_localctx, 176, RULE_variableModifier);
6100 try {
6101 setState(1202);
6102 _errHandler.sync(this);
6103 switch (_input.LA(1)) {
6104 case AT:
6105 enterOuterAlt(_localctx, 1);
6106 {
6107 setState(1200);
6108 annotation();
6109 }
6110 break;
6111 case FINAL:
6112 enterOuterAlt(_localctx, 2);
6113 {
6114 setState(1201);
6115 match(FINAL);
6116 }
6117 break;
6118 default:
6119 throw new NoViableAltException(this);
6120 }
6121 }
6122 catch (RecognitionException re) {
6123 _localctx.exception = re;
6124 _errHandler.reportError(this, re);
6125 _errHandler.recover(this, re);
6126 }
6127 finally {
6128 exitRule();
6129 }
6130 return _localctx;
6131 }
6132
6133 public static class LastFormalParameterContext extends ParserRuleContext {
6134 public UnannTypeContext unannType() {
6135 return getRuleContext(UnannTypeContext.class,0);
6136 }
6137 public VariableDeclaratorIdContext variableDeclaratorId() {
6138 return getRuleContext(VariableDeclaratorIdContext.class,0);
6139 }
6140 public List<VariableModifierContext> variableModifier() {
6141 return getRuleContexts(VariableModifierContext.class);
6142 }
6143 public VariableModifierContext variableModifier(int i) {
6144 return getRuleContext(VariableModifierContext.class,i);
6145 }
6146 public List<AnnotationContext> annotation() {
6147 return getRuleContexts(AnnotationContext.class);
6148 }
6149 public AnnotationContext annotation(int i) {
6150 return getRuleContext(AnnotationContext.class,i);
6151 }
6152 public FormalParameterContext formalParameter() {
6153 return getRuleContext(FormalParameterContext.class,0);
6154 }
6155 public LastFormalParameterContext(ParserRuleContext parent, int invokingState) {
6156 super(parent, invokingState);
6157 }
6158 @Override public int getRuleIndex() { return RULE_lastFormalParameter; }
6159 @Override
6160 public void enterRule(ParseTreeListener listener) {
6161 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLastFormalParameter(this);
6162 }
6163 @Override
6164 public void exitRule(ParseTreeListener listener) {
6165 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLastFormalParameter(this);
6166 }
6167 }
6168
6169 public final LastFormalParameterContext lastFormalParameter() throws RecognitionException {
6170 LastFormalParameterContext _localctx = new LastFormalParameterContext(_ctx, getState());
6171 enterRule(_localctx, 178, RULE_lastFormalParameter);
6172 int _la;
6173 try {
6174 setState(1221);
6175 _errHandler.sync(this);
6176 switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) {
6177 case 1:
6178 enterOuterAlt(_localctx, 1);
6179 {
6180 setState(1207);
6181 _errHandler.sync(this);
6182 _la = _input.LA(1);
6183 while (_la==FINAL || _la==AT) {
6184 {
6185 {
6186 setState(1204);
6187 variableModifier();
6188 }
6189 }
6190 setState(1209);
6191 _errHandler.sync(this);
6192 _la = _input.LA(1);
6193 }
6194 setState(1210);
6195 unannType();
6196 setState(1214);
6197 _errHandler.sync(this);
6198 _la = _input.LA(1);
6199 while (_la==AT) {
6200 {
6201 {
6202 setState(1211);
6203 annotation();
6204 }
6205 }
6206 setState(1216);
6207 _errHandler.sync(this);
6208 _la = _input.LA(1);
6209 }
6210 setState(1217);
6211 match(ELLIPSIS);
6212 setState(1218);
6213 variableDeclaratorId();
6214 }
6215 break;
6216 case 2:
6217 enterOuterAlt(_localctx, 2);
6218 {
6219 setState(1220);
6220 formalParameter();
6221 }
6222 break;
6223 }
6224 }
6225 catch (RecognitionException re) {
6226 _localctx.exception = re;
6227 _errHandler.reportError(this, re);
6228 _errHandler.recover(this, re);
6229 }
6230 finally {
6231 exitRule();
6232 }
6233 return _localctx;
6234 }
6235
6236 public static class ReceiverParameterContext extends ParserRuleContext {
6237 public UnannTypeContext unannType() {
6238 return getRuleContext(UnannTypeContext.class,0);
6239 }
6240 public List<AnnotationContext> annotation() {
6241 return getRuleContexts(AnnotationContext.class);
6242 }
6243 public AnnotationContext annotation(int i) {
6244 return getRuleContext(AnnotationContext.class,i);
6245 }
6246 public IdentifierContext identifier() {
6247 return getRuleContext(IdentifierContext.class,0);
6248 }
6249 public ReceiverParameterContext(ParserRuleContext parent, int invokingState) {
6250 super(parent, invokingState);
6251 }
6252 @Override public int getRuleIndex() { return RULE_receiverParameter; }
6253 @Override
6254 public void enterRule(ParseTreeListener listener) {
6255 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterReceiverParameter(this);
6256 }
6257 @Override
6258 public void exitRule(ParseTreeListener listener) {
6259 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitReceiverParameter(this);
6260 }
6261 }
6262
6263 public final ReceiverParameterContext receiverParameter() throws RecognitionException {
6264 ReceiverParameterContext _localctx = new ReceiverParameterContext(_ctx, getState());
6265 enterRule(_localctx, 180, RULE_receiverParameter);
6266 int _la;
6267 try {
6268 enterOuterAlt(_localctx, 1);
6269 {
6270 setState(1226);
6271 _errHandler.sync(this);
6272 _la = _input.LA(1);
6273 while (_la==AT) {
6274 {
6275 {
6276 setState(1223);
6277 annotation();
6278 }
6279 }
6280 setState(1228);
6281 _errHandler.sync(this);
6282 _la = _input.LA(1);
6283 }
6284 setState(1229);
6285 unannType();
6286 setState(1233);
6287 _errHandler.sync(this);
6288 _la = _input.LA(1);
6289 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8))) != 0) || _la==Identifier) {
6290 {
6291 setState(1230);
6292 identifier();
6293 setState(1231);
6294 match(DOT);
6295 }
6296 }
6297
6298 setState(1235);
6299 match(THIS);
6300 }
6301 }
6302 catch (RecognitionException re) {
6303 _localctx.exception = re;
6304 _errHandler.reportError(this, re);
6305 _errHandler.recover(this, re);
6306 }
6307 finally {
6308 exitRule();
6309 }
6310 return _localctx;
6311 }
6312
6313 public static class Throws_Context extends ParserRuleContext {
6314 public ExceptionTypeListContext exceptionTypeList() {
6315 return getRuleContext(ExceptionTypeListContext.class,0);
6316 }
6317 public Throws_Context(ParserRuleContext parent, int invokingState) {
6318 super(parent, invokingState);
6319 }
6320 @Override public int getRuleIndex() { return RULE_throws_; }
6321 @Override
6322 public void enterRule(ParseTreeListener listener) {
6323 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterThrows_(this);
6324 }
6325 @Override
6326 public void exitRule(ParseTreeListener listener) {
6327 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitThrows_(this);
6328 }
6329 }
6330
6331 public final Throws_Context throws_() throws RecognitionException {
6332 Throws_Context _localctx = new Throws_Context(_ctx, getState());
6333 enterRule(_localctx, 182, RULE_throws_);
6334 try {
6335 enterOuterAlt(_localctx, 1);
6336 {
6337 setState(1237);
6338 match(THROWS);
6339 setState(1238);
6340 exceptionTypeList();
6341 }
6342 }
6343 catch (RecognitionException re) {
6344 _localctx.exception = re;
6345 _errHandler.reportError(this, re);
6346 _errHandler.recover(this, re);
6347 }
6348 finally {
6349 exitRule();
6350 }
6351 return _localctx;
6352 }
6353
6354 public static class ExceptionTypeListContext extends ParserRuleContext {
6355 public List<ExceptionTypeContext> exceptionType() {
6356 return getRuleContexts(ExceptionTypeContext.class);
6357 }
6358 public ExceptionTypeContext exceptionType(int i) {
6359 return getRuleContext(ExceptionTypeContext.class,i);
6360 }
6361 public ExceptionTypeListContext(ParserRuleContext parent, int invokingState) {
6362 super(parent, invokingState);
6363 }
6364 @Override public int getRuleIndex() { return RULE_exceptionTypeList; }
6365 @Override
6366 public void enterRule(ParseTreeListener listener) {
6367 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExceptionTypeList(this);
6368 }
6369 @Override
6370 public void exitRule(ParseTreeListener listener) {
6371 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExceptionTypeList(this);
6372 }
6373 }
6374
6375 public final ExceptionTypeListContext exceptionTypeList() throws RecognitionException {
6376 ExceptionTypeListContext _localctx = new ExceptionTypeListContext(_ctx, getState());
6377 enterRule(_localctx, 184, RULE_exceptionTypeList);
6378 int _la;
6379 try {
6380 enterOuterAlt(_localctx, 1);
6381 {
6382 setState(1240);
6383 exceptionType();
6384 setState(1245);
6385 _errHandler.sync(this);
6386 _la = _input.LA(1);
6387 while (_la==COMMA) {
6388 {
6389 {
6390 setState(1241);
6391 match(COMMA);
6392 setState(1242);
6393 exceptionType();
6394 }
6395 }
6396 setState(1247);
6397 _errHandler.sync(this);
6398 _la = _input.LA(1);
6399 }
6400 }
6401 }
6402 catch (RecognitionException re) {
6403 _localctx.exception = re;
6404 _errHandler.reportError(this, re);
6405 _errHandler.recover(this, re);
6406 }
6407 finally {
6408 exitRule();
6409 }
6410 return _localctx;
6411 }
6412
6413 public static class ExceptionTypeContext extends ParserRuleContext {
6414 public ClassTypeContext classType() {
6415 return getRuleContext(ClassTypeContext.class,0);
6416 }
6417 public TypeVariableContext typeVariable() {
6418 return getRuleContext(TypeVariableContext.class,0);
6419 }
6420 public ExceptionTypeContext(ParserRuleContext parent, int invokingState) {
6421 super(parent, invokingState);
6422 }
6423 @Override public int getRuleIndex() { return RULE_exceptionType; }
6424 @Override
6425 public void enterRule(ParseTreeListener listener) {
6426 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExceptionType(this);
6427 }
6428 @Override
6429 public void exitRule(ParseTreeListener listener) {
6430 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExceptionType(this);
6431 }
6432 }
6433
6434 public final ExceptionTypeContext exceptionType() throws RecognitionException {
6435 ExceptionTypeContext _localctx = new ExceptionTypeContext(_ctx, getState());
6436 enterRule(_localctx, 186, RULE_exceptionType);
6437 try {
6438 setState(1250);
6439 _errHandler.sync(this);
6440 switch ( getInterpreter().adaptivePredict(_input,107,_ctx) ) {
6441 case 1:
6442 enterOuterAlt(_localctx, 1);
6443 {
6444 setState(1248);
6445 classType();
6446 }
6447 break;
6448 case 2:
6449 enterOuterAlt(_localctx, 2);
6450 {
6451 setState(1249);
6452 typeVariable();
6453 }
6454 break;
6455 }
6456 }
6457 catch (RecognitionException re) {
6458 _localctx.exception = re;
6459 _errHandler.reportError(this, re);
6460 _errHandler.recover(this, re);
6461 }
6462 finally {
6463 exitRule();
6464 }
6465 return _localctx;
6466 }
6467
6468 public static class MethodBodyContext extends ParserRuleContext {
6469 public BlockContext block() {
6470 return getRuleContext(BlockContext.class,0);
6471 }
6472 public MethodBodyContext(ParserRuleContext parent, int invokingState) {
6473 super(parent, invokingState);
6474 }
6475 @Override public int getRuleIndex() { return RULE_methodBody; }
6476 @Override
6477 public void enterRule(ParseTreeListener listener) {
6478 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodBody(this);
6479 }
6480 @Override
6481 public void exitRule(ParseTreeListener listener) {
6482 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodBody(this);
6483 }
6484 }
6485
6486 public final MethodBodyContext methodBody() throws RecognitionException {
6487 MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState());
6488 enterRule(_localctx, 188, RULE_methodBody);
6489 try {
6490 setState(1254);
6491 _errHandler.sync(this);
6492 switch (_input.LA(1)) {
6493 case LBRACE:
6494 enterOuterAlt(_localctx, 1);
6495 {
6496 setState(1252);
6497 block();
6498 }
6499 break;
6500 case SEMI:
6501 enterOuterAlt(_localctx, 2);
6502 {
6503 setState(1253);
6504 match(SEMI);
6505 }
6506 break;
6507 default:
6508 throw new NoViableAltException(this);
6509 }
6510 }
6511 catch (RecognitionException re) {
6512 _localctx.exception = re;
6513 _errHandler.reportError(this, re);
6514 _errHandler.recover(this, re);
6515 }
6516 finally {
6517 exitRule();
6518 }
6519 return _localctx;
6520 }
6521
6522 public static class InstanceInitializerContext extends ParserRuleContext {
6523 public BlockContext block() {
6524 return getRuleContext(BlockContext.class,0);
6525 }
6526 public InstanceInitializerContext(ParserRuleContext parent, int invokingState) {
6527 super(parent, invokingState);
6528 }
6529 @Override public int getRuleIndex() { return RULE_instanceInitializer; }
6530 @Override
6531 public void enterRule(ParseTreeListener listener) {
6532 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInstanceInitializer(this);
6533 }
6534 @Override
6535 public void exitRule(ParseTreeListener listener) {
6536 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInstanceInitializer(this);
6537 }
6538 }
6539
6540 public final InstanceInitializerContext instanceInitializer() throws RecognitionException {
6541 InstanceInitializerContext _localctx = new InstanceInitializerContext(_ctx, getState());
6542 enterRule(_localctx, 190, RULE_instanceInitializer);
6543 try {
6544 enterOuterAlt(_localctx, 1);
6545 {
6546 setState(1256);
6547 block();
6548 }
6549 }
6550 catch (RecognitionException re) {
6551 _localctx.exception = re;
6552 _errHandler.reportError(this, re);
6553 _errHandler.recover(this, re);
6554 }
6555 finally {
6556 exitRule();
6557 }
6558 return _localctx;
6559 }
6560
6561 public static class StaticInitializerContext extends ParserRuleContext {
6562 public BlockContext block() {
6563 return getRuleContext(BlockContext.class,0);
6564 }
6565 public StaticInitializerContext(ParserRuleContext parent, int invokingState) {
6566 super(parent, invokingState);
6567 }
6568 @Override public int getRuleIndex() { return RULE_staticInitializer; }
6569 @Override
6570 public void enterRule(ParseTreeListener listener) {
6571 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterStaticInitializer(this);
6572 }
6573 @Override
6574 public void exitRule(ParseTreeListener listener) {
6575 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitStaticInitializer(this);
6576 }
6577 }
6578
6579 public final StaticInitializerContext staticInitializer() throws RecognitionException {
6580 StaticInitializerContext _localctx = new StaticInitializerContext(_ctx, getState());
6581 enterRule(_localctx, 192, RULE_staticInitializer);
6582 try {
6583 enterOuterAlt(_localctx, 1);
6584 {
6585 setState(1258);
6586 match(STATIC);
6587 setState(1259);
6588 block();
6589 }
6590 }
6591 catch (RecognitionException re) {
6592 _localctx.exception = re;
6593 _errHandler.reportError(this, re);
6594 _errHandler.recover(this, re);
6595 }
6596 finally {
6597 exitRule();
6598 }
6599 return _localctx;
6600 }
6601
6602 public static class ConstructorDeclarationContext extends ParserRuleContext {
6603 public ConstructorDeclaratorContext constructorDeclarator() {
6604 return getRuleContext(ConstructorDeclaratorContext.class,0);
6605 }
6606 public ConstructorBodyContext constructorBody() {
6607 return getRuleContext(ConstructorBodyContext.class,0);
6608 }
6609 public List<ConstructorModifierContext> constructorModifier() {
6610 return getRuleContexts(ConstructorModifierContext.class);
6611 }
6612 public ConstructorModifierContext constructorModifier(int i) {
6613 return getRuleContext(ConstructorModifierContext.class,i);
6614 }
6615 public Throws_Context throws_() {
6616 return getRuleContext(Throws_Context.class,0);
6617 }
6618 public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) {
6619 super(parent, invokingState);
6620 }
6621 @Override public int getRuleIndex() { return RULE_constructorDeclaration; }
6622 @Override
6623 public void enterRule(ParseTreeListener listener) {
6624 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstructorDeclaration(this);
6625 }
6626 @Override
6627 public void exitRule(ParseTreeListener listener) {
6628 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstructorDeclaration(this);
6629 }
6630 }
6631
6632 public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException {
6633 ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState());
6634 enterRule(_localctx, 194, RULE_constructorDeclaration);
6635 int _la;
6636 try {
6637 enterOuterAlt(_localctx, 1);
6638 {
6639 setState(1264);
6640 _errHandler.sync(this);
6641 _la = _input.LA(1);
6642 while (((((_la - 43)) & ~0x3f) == 0 && ((1L << (_la - 43)) & ((1L << (PRIVATE - 43)) | (1L << (PROTECTED - 43)) | (1L << (PUBLIC - 43)) | (1L << (AT - 43)))) != 0)) {
6643 {
6644 {
6645 setState(1261);
6646 constructorModifier();
6647 }
6648 }
6649 setState(1266);
6650 _errHandler.sync(this);
6651 _la = _input.LA(1);
6652 }
6653 setState(1267);
6654 constructorDeclarator();
6655 setState(1269);
6656 _errHandler.sync(this);
6657 _la = _input.LA(1);
6658 if (_la==THROWS) {
6659 {
6660 setState(1268);
6661 throws_();
6662 }
6663 }
6664
6665 setState(1271);
6666 constructorBody();
6667 }
6668 }
6669 catch (RecognitionException re) {
6670 _localctx.exception = re;
6671 _errHandler.reportError(this, re);
6672 _errHandler.recover(this, re);
6673 }
6674 finally {
6675 exitRule();
6676 }
6677 return _localctx;
6678 }
6679
6680 public static class ConstructorModifierContext extends ParserRuleContext {
6681 public AnnotationContext annotation() {
6682 return getRuleContext(AnnotationContext.class,0);
6683 }
6684 public ConstructorModifierContext(ParserRuleContext parent, int invokingState) {
6685 super(parent, invokingState);
6686 }
6687 @Override public int getRuleIndex() { return RULE_constructorModifier; }
6688 @Override
6689 public void enterRule(ParseTreeListener listener) {
6690 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstructorModifier(this);
6691 }
6692 @Override
6693 public void exitRule(ParseTreeListener listener) {
6694 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstructorModifier(this);
6695 }
6696 }
6697
6698 public final ConstructorModifierContext constructorModifier() throws RecognitionException {
6699 ConstructorModifierContext _localctx = new ConstructorModifierContext(_ctx, getState());
6700 enterRule(_localctx, 196, RULE_constructorModifier);
6701 try {
6702 setState(1277);
6703 _errHandler.sync(this);
6704 switch (_input.LA(1)) {
6705 case AT:
6706 enterOuterAlt(_localctx, 1);
6707 {
6708 setState(1273);
6709 annotation();
6710 }
6711 break;
6712 case PUBLIC:
6713 enterOuterAlt(_localctx, 2);
6714 {
6715 setState(1274);
6716 match(PUBLIC);
6717 }
6718 break;
6719 case PROTECTED:
6720 enterOuterAlt(_localctx, 3);
6721 {
6722 setState(1275);
6723 match(PROTECTED);
6724 }
6725 break;
6726 case PRIVATE:
6727 enterOuterAlt(_localctx, 4);
6728 {
6729 setState(1276);
6730 match(PRIVATE);
6731 }
6732 break;
6733 default:
6734 throw new NoViableAltException(this);
6735 }
6736 }
6737 catch (RecognitionException re) {
6738 _localctx.exception = re;
6739 _errHandler.reportError(this, re);
6740 _errHandler.recover(this, re);
6741 }
6742 finally {
6743 exitRule();
6744 }
6745 return _localctx;
6746 }
6747
6748 public static class ConstructorDeclaratorContext extends ParserRuleContext {
6749 public SimpleTypeNameContext simpleTypeName() {
6750 return getRuleContext(SimpleTypeNameContext.class,0);
6751 }
6752 public TypeParametersContext typeParameters() {
6753 return getRuleContext(TypeParametersContext.class,0);
6754 }
6755 public FormalParameterListContext formalParameterList() {
6756 return getRuleContext(FormalParameterListContext.class,0);
6757 }
6758 public ConstructorDeclaratorContext(ParserRuleContext parent, int invokingState) {
6759 super(parent, invokingState);
6760 }
6761 @Override public int getRuleIndex() { return RULE_constructorDeclarator; }
6762 @Override
6763 public void enterRule(ParseTreeListener listener) {
6764 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstructorDeclarator(this);
6765 }
6766 @Override
6767 public void exitRule(ParseTreeListener listener) {
6768 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstructorDeclarator(this);
6769 }
6770 }
6771
6772 public final ConstructorDeclaratorContext constructorDeclarator() throws RecognitionException {
6773 ConstructorDeclaratorContext _localctx = new ConstructorDeclaratorContext(_ctx, getState());
6774 enterRule(_localctx, 198, RULE_constructorDeclarator);
6775 int _la;
6776 try {
6777 enterOuterAlt(_localctx, 1);
6778 {
6779 setState(1280);
6780 _errHandler.sync(this);
6781 _la = _input.LA(1);
6782 if (_la==LT) {
6783 {
6784 setState(1279);
6785 typeParameters();
6786 }
6787 }
6788
6789 setState(1282);
6790 simpleTypeName();
6791 setState(1283);
6792 match(LPAREN);
6793 setState(1285);
6794 _errHandler.sync(this);
6795 _la = _input.LA(1);
6796 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la==AT || _la==Identifier) {
6797 {
6798 setState(1284);
6799 formalParameterList();
6800 }
6801 }
6802
6803 setState(1287);
6804 match(RPAREN);
6805 }
6806 }
6807 catch (RecognitionException re) {
6808 _localctx.exception = re;
6809 _errHandler.reportError(this, re);
6810 _errHandler.recover(this, re);
6811 }
6812 finally {
6813 exitRule();
6814 }
6815 return _localctx;
6816 }
6817
6818 public static class SimpleTypeNameContext extends ParserRuleContext {
6819 public IdentifierContext identifier() {
6820 return getRuleContext(IdentifierContext.class,0);
6821 }
6822 public SimpleTypeNameContext(ParserRuleContext parent, int invokingState) {
6823 super(parent, invokingState);
6824 }
6825 @Override public int getRuleIndex() { return RULE_simpleTypeName; }
6826 @Override
6827 public void enterRule(ParseTreeListener listener) {
6828 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSimpleTypeName(this);
6829 }
6830 @Override
6831 public void exitRule(ParseTreeListener listener) {
6832 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSimpleTypeName(this);
6833 }
6834 }
6835
6836 public final SimpleTypeNameContext simpleTypeName() throws RecognitionException {
6837 SimpleTypeNameContext _localctx = new SimpleTypeNameContext(_ctx, getState());
6838 enterRule(_localctx, 200, RULE_simpleTypeName);
6839 try {
6840 enterOuterAlt(_localctx, 1);
6841 {
6842 setState(1289);
6843 identifier();
6844 }
6845 }
6846 catch (RecognitionException re) {
6847 _localctx.exception = re;
6848 _errHandler.reportError(this, re);
6849 _errHandler.recover(this, re);
6850 }
6851 finally {
6852 exitRule();
6853 }
6854 return _localctx;
6855 }
6856
6857 public static class ConstructorBodyContext extends ParserRuleContext {
6858 public ExplicitConstructorInvocationContext explicitConstructorInvocation() {
6859 return getRuleContext(ExplicitConstructorInvocationContext.class,0);
6860 }
6861 public BlockStatementsContext blockStatements() {
6862 return getRuleContext(BlockStatementsContext.class,0);
6863 }
6864 public ConstructorBodyContext(ParserRuleContext parent, int invokingState) {
6865 super(parent, invokingState);
6866 }
6867 @Override public int getRuleIndex() { return RULE_constructorBody; }
6868 @Override
6869 public void enterRule(ParseTreeListener listener) {
6870 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstructorBody(this);
6871 }
6872 @Override
6873 public void exitRule(ParseTreeListener listener) {
6874 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstructorBody(this);
6875 }
6876 }
6877
6878 public final ConstructorBodyContext constructorBody() throws RecognitionException {
6879 ConstructorBodyContext _localctx = new ConstructorBodyContext(_ctx, getState());
6880 enterRule(_localctx, 202, RULE_constructorBody);
6881 int _la;
6882 try {
6883 enterOuterAlt(_localctx, 1);
6884 {
6885 setState(1291);
6886 match(LBRACE);
6887 setState(1293);
6888 _errHandler.sync(this);
6889 switch ( getInterpreter().adaptivePredict(_input,114,_ctx) ) {
6890 case 1:
6891 {
6892 setState(1292);
6893 explicitConstructorInvocation();
6894 }
6895 break;
6896 }
6897 setState(1296);
6898 _errHandler.sync(this);
6899 _la = _input.LA(1);
6900 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER) | (1L << SWITCH) | (1L << SYNCHRONIZED) | (1L << THIS) | (1L << THROW) | (1L << TRY) | (1L << VOID) | (1L << WHILE) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (LBRACE - 64)) | (1L << (SEMI - 64)) | (1L << (AT - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (Identifier - 64)))) != 0)) {
6901 {
6902 setState(1295);
6903 blockStatements();
6904 }
6905 }
6906
6907 setState(1298);
6908 match(RBRACE);
6909 }
6910 }
6911 catch (RecognitionException re) {
6912 _localctx.exception = re;
6913 _errHandler.reportError(this, re);
6914 _errHandler.recover(this, re);
6915 }
6916 finally {
6917 exitRule();
6918 }
6919 return _localctx;
6920 }
6921
6922 public static class ExplicitConstructorInvocationContext extends ParserRuleContext {
6923 public TypeArgumentsContext typeArguments() {
6924 return getRuleContext(TypeArgumentsContext.class,0);
6925 }
6926 public ArgumentListContext argumentList() {
6927 return getRuleContext(ArgumentListContext.class,0);
6928 }
6929 public ExpressionNameContext expressionName() {
6930 return getRuleContext(ExpressionNameContext.class,0);
6931 }
6932 public PrimaryContext primary() {
6933 return getRuleContext(PrimaryContext.class,0);
6934 }
6935 public ExplicitConstructorInvocationContext(ParserRuleContext parent, int invokingState) {
6936 super(parent, invokingState);
6937 }
6938 @Override public int getRuleIndex() { return RULE_explicitConstructorInvocation; }
6939 @Override
6940 public void enterRule(ParseTreeListener listener) {
6941 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExplicitConstructorInvocation(this);
6942 }
6943 @Override
6944 public void exitRule(ParseTreeListener listener) {
6945 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExplicitConstructorInvocation(this);
6946 }
6947 }
6948
6949 public final ExplicitConstructorInvocationContext explicitConstructorInvocation() throws RecognitionException {
6950 ExplicitConstructorInvocationContext _localctx = new ExplicitConstructorInvocationContext(_ctx, getState());
6951 enterRule(_localctx, 204, RULE_explicitConstructorInvocation);
6952 int _la;
6953 try {
6954 setState(1346);
6955 _errHandler.sync(this);
6956 switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
6957 case 1:
6958 enterOuterAlt(_localctx, 1);
6959 {
6960 setState(1301);
6961 _errHandler.sync(this);
6962 _la = _input.LA(1);
6963 if (_la==LT) {
6964 {
6965 setState(1300);
6966 typeArguments();
6967 }
6968 }
6969
6970 setState(1303);
6971 match(THIS);
6972 setState(1304);
6973 match(LPAREN);
6974 setState(1306);
6975 _errHandler.sync(this);
6976 _la = _input.LA(1);
6977 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) {
6978 {
6979 setState(1305);
6980 argumentList();
6981 }
6982 }
6983
6984 setState(1308);
6985 match(RPAREN);
6986 setState(1309);
6987 match(SEMI);
6988 }
6989 break;
6990 case 2:
6991 enterOuterAlt(_localctx, 2);
6992 {
6993 setState(1311);
6994 _errHandler.sync(this);
6995 _la = _input.LA(1);
6996 if (_la==LT) {
6997 {
6998 setState(1310);
6999 typeArguments();
7000 }
7001 }
7002
7003 setState(1313);
7004 match(SUPER);
7005 setState(1314);
7006 match(LPAREN);
7007 setState(1316);
7008 _errHandler.sync(this);
7009 _la = _input.LA(1);
7010 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) {
7011 {
7012 setState(1315);
7013 argumentList();
7014 }
7015 }
7016
7017 setState(1318);
7018 match(RPAREN);
7019 setState(1319);
7020 match(SEMI);
7021 }
7022 break;
7023 case 3:
7024 enterOuterAlt(_localctx, 3);
7025 {
7026 setState(1320);
7027 expressionName();
7028 setState(1321);
7029 match(DOT);
7030 setState(1323);
7031 _errHandler.sync(this);
7032 _la = _input.LA(1);
7033 if (_la==LT) {
7034 {
7035 setState(1322);
7036 typeArguments();
7037 }
7038 }
7039
7040 setState(1325);
7041 match(SUPER);
7042 setState(1326);
7043 match(LPAREN);
7044 setState(1328);
7045 _errHandler.sync(this);
7046 _la = _input.LA(1);
7047 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) {
7048 {
7049 setState(1327);
7050 argumentList();
7051 }
7052 }
7053
7054 setState(1330);
7055 match(RPAREN);
7056 setState(1331);
7057 match(SEMI);
7058 }
7059 break;
7060 case 4:
7061 enterOuterAlt(_localctx, 4);
7062 {
7063 setState(1333);
7064 primary();
7065 setState(1334);
7066 match(DOT);
7067 setState(1336);
7068 _errHandler.sync(this);
7069 _la = _input.LA(1);
7070 if (_la==LT) {
7071 {
7072 setState(1335);
7073 typeArguments();
7074 }
7075 }
7076
7077 setState(1338);
7078 match(SUPER);
7079 setState(1339);
7080 match(LPAREN);
7081 setState(1341);
7082 _errHandler.sync(this);
7083 _la = _input.LA(1);
7084 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) {
7085 {
7086 setState(1340);
7087 argumentList();
7088 }
7089 }
7090
7091 setState(1343);
7092 match(RPAREN);
7093 setState(1344);
7094 match(SEMI);
7095 }
7096 break;
7097 }
7098 }
7099 catch (RecognitionException re) {
7100 _localctx.exception = re;
7101 _errHandler.reportError(this, re);
7102 _errHandler.recover(this, re);
7103 }
7104 finally {
7105 exitRule();
7106 }
7107 return _localctx;
7108 }
7109
7110 public static class EnumDeclarationContext extends ParserRuleContext {
7111 public IdentifierContext identifier() {
7112 return getRuleContext(IdentifierContext.class,0);
7113 }
7114 public EnumBodyContext enumBody() {
7115 return getRuleContext(EnumBodyContext.class,0);
7116 }
7117 public List<ClassModifierContext> classModifier() {
7118 return getRuleContexts(ClassModifierContext.class);
7119 }
7120 public ClassModifierContext classModifier(int i) {
7121 return getRuleContext(ClassModifierContext.class,i);
7122 }
7123 public SuperinterfacesContext superinterfaces() {
7124 return getRuleContext(SuperinterfacesContext.class,0);
7125 }
7126 public EnumDeclarationContext(ParserRuleContext parent, int invokingState) {
7127 super(parent, invokingState);
7128 }
7129 @Override public int getRuleIndex() { return RULE_enumDeclaration; }
7130 @Override
7131 public void enterRule(ParseTreeListener listener) {
7132 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumDeclaration(this);
7133 }
7134 @Override
7135 public void exitRule(ParseTreeListener listener) {
7136 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumDeclaration(this);
7137 }
7138 }
7139
7140 public final EnumDeclarationContext enumDeclaration() throws RecognitionException {
7141 EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState());
7142 enterRule(_localctx, 206, RULE_enumDeclaration);
7143 int _la;
7144 try {
7145 enterOuterAlt(_localctx, 1);
7146 {
7147 setState(1351);
7148 _errHandler.sync(this);
7149 _la = _input.LA(1);
7150 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
7151 {
7152 {
7153 setState(1348);
7154 classModifier();
7155 }
7156 }
7157 setState(1353);
7158 _errHandler.sync(this);
7159 _la = _input.LA(1);
7160 }
7161 setState(1354);
7162 match(ENUM);
7163 setState(1355);
7164 identifier();
7165 setState(1357);
7166 _errHandler.sync(this);
7167 _la = _input.LA(1);
7168 if (_la==IMPLEMENTS) {
7169 {
7170 setState(1356);
7171 superinterfaces();
7172 }
7173 }
7174
7175 setState(1359);
7176 enumBody();
7177 }
7178 }
7179 catch (RecognitionException re) {
7180 _localctx.exception = re;
7181 _errHandler.reportError(this, re);
7182 _errHandler.recover(this, re);
7183 }
7184 finally {
7185 exitRule();
7186 }
7187 return _localctx;
7188 }
7189
7190 public static class EnumBodyContext extends ParserRuleContext {
7191 public EnumConstantListContext enumConstantList() {
7192 return getRuleContext(EnumConstantListContext.class,0);
7193 }
7194 public EnumBodyDeclarationsContext enumBodyDeclarations() {
7195 return getRuleContext(EnumBodyDeclarationsContext.class,0);
7196 }
7197 public EnumBodyContext(ParserRuleContext parent, int invokingState) {
7198 super(parent, invokingState);
7199 }
7200 @Override public int getRuleIndex() { return RULE_enumBody; }
7201 @Override
7202 public void enterRule(ParseTreeListener listener) {
7203 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumBody(this);
7204 }
7205 @Override
7206 public void exitRule(ParseTreeListener listener) {
7207 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumBody(this);
7208 }
7209 }
7210
7211 public final EnumBodyContext enumBody() throws RecognitionException {
7212 EnumBodyContext _localctx = new EnumBodyContext(_ctx, getState());
7213 enterRule(_localctx, 208, RULE_enumBody);
7214 int _la;
7215 try {
7216 enterOuterAlt(_localctx, 1);
7217 {
7218 setState(1361);
7219 match(LBRACE);
7220 setState(1363);
7221 _errHandler.sync(this);
7222 _la = _input.LA(1);
7223 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8))) != 0) || _la==AT || _la==Identifier) {
7224 {
7225 setState(1362);
7226 enumConstantList();
7227 }
7228 }
7229
7230 setState(1366);
7231 _errHandler.sync(this);
7232 _la = _input.LA(1);
7233 if (_la==COMMA) {
7234 {
7235 setState(1365);
7236 match(COMMA);
7237 }
7238 }
7239
7240 setState(1369);
7241 _errHandler.sync(this);
7242 _la = _input.LA(1);
7243 if (_la==SEMI) {
7244 {
7245 setState(1368);
7246 enumBodyDeclarations();
7247 }
7248 }
7249
7250 setState(1371);
7251 match(RBRACE);
7252 }
7253 }
7254 catch (RecognitionException re) {
7255 _localctx.exception = re;
7256 _errHandler.reportError(this, re);
7257 _errHandler.recover(this, re);
7258 }
7259 finally {
7260 exitRule();
7261 }
7262 return _localctx;
7263 }
7264
7265 public static class EnumConstantListContext extends ParserRuleContext {
7266 public List<EnumConstantContext> enumConstant() {
7267 return getRuleContexts(EnumConstantContext.class);
7268 }
7269 public EnumConstantContext enumConstant(int i) {
7270 return getRuleContext(EnumConstantContext.class,i);
7271 }
7272 public EnumConstantListContext(ParserRuleContext parent, int invokingState) {
7273 super(parent, invokingState);
7274 }
7275 @Override public int getRuleIndex() { return RULE_enumConstantList; }
7276 @Override
7277 public void enterRule(ParseTreeListener listener) {
7278 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumConstantList(this);
7279 }
7280 @Override
7281 public void exitRule(ParseTreeListener listener) {
7282 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumConstantList(this);
7283 }
7284 }
7285
7286 public final EnumConstantListContext enumConstantList() throws RecognitionException {
7287 EnumConstantListContext _localctx = new EnumConstantListContext(_ctx, getState());
7288 enterRule(_localctx, 210, RULE_enumConstantList);
7289 try {
7290 int _alt;
7291 enterOuterAlt(_localctx, 1);
7292 {
7293 setState(1373);
7294 enumConstant();
7295 setState(1378);
7296 _errHandler.sync(this);
7297 _alt = getInterpreter().adaptivePredict(_input,130,_ctx);
7298 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
7299 if ( _alt==1 ) {
7300 {
7301 {
7302 setState(1374);
7303 match(COMMA);
7304 setState(1375);
7305 enumConstant();
7306 }
7307 }
7308 }
7309 setState(1380);
7310 _errHandler.sync(this);
7311 _alt = getInterpreter().adaptivePredict(_input,130,_ctx);
7312 }
7313 }
7314 }
7315 catch (RecognitionException re) {
7316 _localctx.exception = re;
7317 _errHandler.reportError(this, re);
7318 _errHandler.recover(this, re);
7319 }
7320 finally {
7321 exitRule();
7322 }
7323 return _localctx;
7324 }
7325
7326 public static class EnumConstantContext extends ParserRuleContext {
7327 public IdentifierContext identifier() {
7328 return getRuleContext(IdentifierContext.class,0);
7329 }
7330 public List<EnumConstantModifierContext> enumConstantModifier() {
7331 return getRuleContexts(EnumConstantModifierContext.class);
7332 }
7333 public EnumConstantModifierContext enumConstantModifier(int i) {
7334 return getRuleContext(EnumConstantModifierContext.class,i);
7335 }
7336 public ClassBodyContext classBody() {
7337 return getRuleContext(ClassBodyContext.class,0);
7338 }
7339 public ArgumentListContext argumentList() {
7340 return getRuleContext(ArgumentListContext.class,0);
7341 }
7342 public EnumConstantContext(ParserRuleContext parent, int invokingState) {
7343 super(parent, invokingState);
7344 }
7345 @Override public int getRuleIndex() { return RULE_enumConstant; }
7346 @Override
7347 public void enterRule(ParseTreeListener listener) {
7348 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumConstant(this);
7349 }
7350 @Override
7351 public void exitRule(ParseTreeListener listener) {
7352 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumConstant(this);
7353 }
7354 }
7355
7356 public final EnumConstantContext enumConstant() throws RecognitionException {
7357 EnumConstantContext _localctx = new EnumConstantContext(_ctx, getState());
7358 enterRule(_localctx, 212, RULE_enumConstant);
7359 int _la;
7360 try {
7361 enterOuterAlt(_localctx, 1);
7362 {
7363 setState(1384);
7364 _errHandler.sync(this);
7365 _la = _input.LA(1);
7366 while (_la==AT) {
7367 {
7368 {
7369 setState(1381);
7370 enumConstantModifier();
7371 }
7372 }
7373 setState(1386);
7374 _errHandler.sync(this);
7375 _la = _input.LA(1);
7376 }
7377 setState(1387);
7378 identifier();
7379 setState(1393);
7380 _errHandler.sync(this);
7381 _la = _input.LA(1);
7382 if (_la==LPAREN) {
7383 {
7384 setState(1388);
7385 match(LPAREN);
7386 setState(1390);
7387 _errHandler.sync(this);
7388 _la = _input.LA(1);
7389 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) {
7390 {
7391 setState(1389);
7392 argumentList();
7393 }
7394 }
7395
7396 setState(1392);
7397 match(RPAREN);
7398 }
7399 }
7400
7401 setState(1396);
7402 _errHandler.sync(this);
7403 _la = _input.LA(1);
7404 if (_la==LBRACE) {
7405 {
7406 setState(1395);
7407 classBody();
7408 }
7409 }
7410
7411 }
7412 }
7413 catch (RecognitionException re) {
7414 _localctx.exception = re;
7415 _errHandler.reportError(this, re);
7416 _errHandler.recover(this, re);
7417 }
7418 finally {
7419 exitRule();
7420 }
7421 return _localctx;
7422 }
7423
7424 public static class EnumConstantModifierContext extends ParserRuleContext {
7425 public AnnotationContext annotation() {
7426 return getRuleContext(AnnotationContext.class,0);
7427 }
7428 public EnumConstantModifierContext(ParserRuleContext parent, int invokingState) {
7429 super(parent, invokingState);
7430 }
7431 @Override public int getRuleIndex() { return RULE_enumConstantModifier; }
7432 @Override
7433 public void enterRule(ParseTreeListener listener) {
7434 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumConstantModifier(this);
7435 }
7436 @Override
7437 public void exitRule(ParseTreeListener listener) {
7438 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumConstantModifier(this);
7439 }
7440 }
7441
7442 public final EnumConstantModifierContext enumConstantModifier() throws RecognitionException {
7443 EnumConstantModifierContext _localctx = new EnumConstantModifierContext(_ctx, getState());
7444 enterRule(_localctx, 214, RULE_enumConstantModifier);
7445 try {
7446 enterOuterAlt(_localctx, 1);
7447 {
7448 setState(1398);
7449 annotation();
7450 }
7451 }
7452 catch (RecognitionException re) {
7453 _localctx.exception = re;
7454 _errHandler.reportError(this, re);
7455 _errHandler.recover(this, re);
7456 }
7457 finally {
7458 exitRule();
7459 }
7460 return _localctx;
7461 }
7462
7463 public static class EnumBodyDeclarationsContext extends ParserRuleContext {
7464 public List<ClassBodyDeclarationContext> classBodyDeclaration() {
7465 return getRuleContexts(ClassBodyDeclarationContext.class);
7466 }
7467 public ClassBodyDeclarationContext classBodyDeclaration(int i) {
7468 return getRuleContext(ClassBodyDeclarationContext.class,i);
7469 }
7470 public EnumBodyDeclarationsContext(ParserRuleContext parent, int invokingState) {
7471 super(parent, invokingState);
7472 }
7473 @Override public int getRuleIndex() { return RULE_enumBodyDeclarations; }
7474 @Override
7475 public void enterRule(ParseTreeListener listener) {
7476 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumBodyDeclarations(this);
7477 }
7478 @Override
7479 public void exitRule(ParseTreeListener listener) {
7480 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumBodyDeclarations(this);
7481 }
7482 }
7483
7484 public final EnumBodyDeclarationsContext enumBodyDeclarations() throws RecognitionException {
7485 EnumBodyDeclarationsContext _localctx = new EnumBodyDeclarationsContext(_ctx, getState());
7486 enterRule(_localctx, 216, RULE_enumBodyDeclarations);
7487 int _la;
7488 try {
7489 enterOuterAlt(_localctx, 1);
7490 {
7491 setState(1400);
7492 match(SEMI);
7493 setState(1404);
7494 _errHandler.sync(this);
7495 _la = _input.LA(1);
7496 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOID) | (1L << VOLATILE))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (LBRACE - 70)) | (1L << (SEMI - 70)) | (1L << (AT - 70)) | (1L << (LT - 70)) | (1L << (Identifier - 70)))) != 0)) {
7497 {
7498 {
7499 setState(1401);
7500 classBodyDeclaration();
7501 }
7502 }
7503 setState(1406);
7504 _errHandler.sync(this);
7505 _la = _input.LA(1);
7506 }
7507 }
7508 }
7509 catch (RecognitionException re) {
7510 _localctx.exception = re;
7511 _errHandler.reportError(this, re);
7512 _errHandler.recover(this, re);
7513 }
7514 finally {
7515 exitRule();
7516 }
7517 return _localctx;
7518 }
7519
7520 public static class InterfaceDeclarationContext extends ParserRuleContext {
7521 public NormalInterfaceDeclarationContext normalInterfaceDeclaration() {
7522 return getRuleContext(NormalInterfaceDeclarationContext.class,0);
7523 }
7524 public AnnotationTypeDeclarationContext annotationTypeDeclaration() {
7525 return getRuleContext(AnnotationTypeDeclarationContext.class,0);
7526 }
7527 public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
7528 super(parent, invokingState);
7529 }
7530 @Override public int getRuleIndex() { return RULE_interfaceDeclaration; }
7531 @Override
7532 public void enterRule(ParseTreeListener listener) {
7533 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceDeclaration(this);
7534 }
7535 @Override
7536 public void exitRule(ParseTreeListener listener) {
7537 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceDeclaration(this);
7538 }
7539 }
7540
7541 public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException {
7542 InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState());
7543 enterRule(_localctx, 218, RULE_interfaceDeclaration);
7544 try {
7545 setState(1409);
7546 _errHandler.sync(this);
7547 switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
7548 case 1:
7549 enterOuterAlt(_localctx, 1);
7550 {
7551 setState(1407);
7552 normalInterfaceDeclaration();
7553 }
7554 break;
7555 case 2:
7556 enterOuterAlt(_localctx, 2);
7557 {
7558 setState(1408);
7559 annotationTypeDeclaration();
7560 }
7561 break;
7562 }
7563 }
7564 catch (RecognitionException re) {
7565 _localctx.exception = re;
7566 _errHandler.reportError(this, re);
7567 _errHandler.recover(this, re);
7568 }
7569 finally {
7570 exitRule();
7571 }
7572 return _localctx;
7573 }
7574
7575 public static class NormalInterfaceDeclarationContext extends ParserRuleContext {
7576 public IdentifierContext identifier() {
7577 return getRuleContext(IdentifierContext.class,0);
7578 }
7579 public InterfaceBodyContext interfaceBody() {
7580 return getRuleContext(InterfaceBodyContext.class,0);
7581 }
7582 public List<InterfaceModifierContext> interfaceModifier() {
7583 return getRuleContexts(InterfaceModifierContext.class);
7584 }
7585 public InterfaceModifierContext interfaceModifier(int i) {
7586 return getRuleContext(InterfaceModifierContext.class,i);
7587 }
7588 public TypeParametersContext typeParameters() {
7589 return getRuleContext(TypeParametersContext.class,0);
7590 }
7591 public ExtendsInterfacesContext extendsInterfaces() {
7592 return getRuleContext(ExtendsInterfacesContext.class,0);
7593 }
7594 public NormalInterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
7595 super(parent, invokingState);
7596 }
7597 @Override public int getRuleIndex() { return RULE_normalInterfaceDeclaration; }
7598 @Override
7599 public void enterRule(ParseTreeListener listener) {
7600 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterNormalInterfaceDeclaration(this);
7601 }
7602 @Override
7603 public void exitRule(ParseTreeListener listener) {
7604 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitNormalInterfaceDeclaration(this);
7605 }
7606 }
7607
7608 public final NormalInterfaceDeclarationContext normalInterfaceDeclaration() throws RecognitionException {
7609 NormalInterfaceDeclarationContext _localctx = new NormalInterfaceDeclarationContext(_ctx, getState());
7610 enterRule(_localctx, 220, RULE_normalInterfaceDeclaration);
7611 int _la;
7612 try {
7613 enterOuterAlt(_localctx, 1);
7614 {
7615 setState(1414);
7616 _errHandler.sync(this);
7617 _la = _input.LA(1);
7618 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
7619 {
7620 {
7621 setState(1411);
7622 interfaceModifier();
7623 }
7624 }
7625 setState(1416);
7626 _errHandler.sync(this);
7627 _la = _input.LA(1);
7628 }
7629 setState(1417);
7630 match(INTERFACE);
7631 setState(1418);
7632 identifier();
7633 setState(1420);
7634 _errHandler.sync(this);
7635 _la = _input.LA(1);
7636 if (_la==LT) {
7637 {
7638 setState(1419);
7639 typeParameters();
7640 }
7641 }
7642
7643 setState(1423);
7644 _errHandler.sync(this);
7645 _la = _input.LA(1);
7646 if (_la==EXTENDS) {
7647 {
7648 setState(1422);
7649 extendsInterfaces();
7650 }
7651 }
7652
7653 setState(1425);
7654 interfaceBody();
7655 }
7656 }
7657 catch (RecognitionException re) {
7658 _localctx.exception = re;
7659 _errHandler.reportError(this, re);
7660 _errHandler.recover(this, re);
7661 }
7662 finally {
7663 exitRule();
7664 }
7665 return _localctx;
7666 }
7667
7668 public static class InterfaceModifierContext extends ParserRuleContext {
7669 public AnnotationContext annotation() {
7670 return getRuleContext(AnnotationContext.class,0);
7671 }
7672 public InterfaceModifierContext(ParserRuleContext parent, int invokingState) {
7673 super(parent, invokingState);
7674 }
7675 @Override public int getRuleIndex() { return RULE_interfaceModifier; }
7676 @Override
7677 public void enterRule(ParseTreeListener listener) {
7678 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceModifier(this);
7679 }
7680 @Override
7681 public void exitRule(ParseTreeListener listener) {
7682 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceModifier(this);
7683 }
7684 }
7685
7686 public final InterfaceModifierContext interfaceModifier() throws RecognitionException {
7687 InterfaceModifierContext _localctx = new InterfaceModifierContext(_ctx, getState());
7688 enterRule(_localctx, 222, RULE_interfaceModifier);
7689 try {
7690 setState(1434);
7691 _errHandler.sync(this);
7692 switch (_input.LA(1)) {
7693 case AT:
7694 enterOuterAlt(_localctx, 1);
7695 {
7696 setState(1427);
7697 annotation();
7698 }
7699 break;
7700 case PUBLIC:
7701 enterOuterAlt(_localctx, 2);
7702 {
7703 setState(1428);
7704 match(PUBLIC);
7705 }
7706 break;
7707 case PROTECTED:
7708 enterOuterAlt(_localctx, 3);
7709 {
7710 setState(1429);
7711 match(PROTECTED);
7712 }
7713 break;
7714 case PRIVATE:
7715 enterOuterAlt(_localctx, 4);
7716 {
7717 setState(1430);
7718 match(PRIVATE);
7719 }
7720 break;
7721 case ABSTRACT:
7722 enterOuterAlt(_localctx, 5);
7723 {
7724 setState(1431);
7725 match(ABSTRACT);
7726 }
7727 break;
7728 case STATIC:
7729 enterOuterAlt(_localctx, 6);
7730 {
7731 setState(1432);
7732 match(STATIC);
7733 }
7734 break;
7735 case STRICTFP:
7736 enterOuterAlt(_localctx, 7);
7737 {
7738 setState(1433);
7739 match(STRICTFP);
7740 }
7741 break;
7742 default:
7743 throw new NoViableAltException(this);
7744 }
7745 }
7746 catch (RecognitionException re) {
7747 _localctx.exception = re;
7748 _errHandler.reportError(this, re);
7749 _errHandler.recover(this, re);
7750 }
7751 finally {
7752 exitRule();
7753 }
7754 return _localctx;
7755 }
7756
7757 public static class ExtendsInterfacesContext extends ParserRuleContext {
7758 public InterfaceTypeListContext interfaceTypeList() {
7759 return getRuleContext(InterfaceTypeListContext.class,0);
7760 }
7761 public ExtendsInterfacesContext(ParserRuleContext parent, int invokingState) {
7762 super(parent, invokingState);
7763 }
7764 @Override public int getRuleIndex() { return RULE_extendsInterfaces; }
7765 @Override
7766 public void enterRule(ParseTreeListener listener) {
7767 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExtendsInterfaces(this);
7768 }
7769 @Override
7770 public void exitRule(ParseTreeListener listener) {
7771 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExtendsInterfaces(this);
7772 }
7773 }
7774
7775 public final ExtendsInterfacesContext extendsInterfaces() throws RecognitionException {
7776 ExtendsInterfacesContext _localctx = new ExtendsInterfacesContext(_ctx, getState());
7777 enterRule(_localctx, 224, RULE_extendsInterfaces);
7778 try {
7779 enterOuterAlt(_localctx, 1);
7780 {
7781 setState(1436);
7782 match(EXTENDS);
7783 setState(1437);
7784 interfaceTypeList();
7785 }
7786 }
7787 catch (RecognitionException re) {
7788 _localctx.exception = re;
7789 _errHandler.reportError(this, re);
7790 _errHandler.recover(this, re);
7791 }
7792 finally {
7793 exitRule();
7794 }
7795 return _localctx;
7796 }
7797
7798 public static class InterfaceBodyContext extends ParserRuleContext {
7799 public List<InterfaceMemberDeclarationContext> interfaceMemberDeclaration() {
7800 return getRuleContexts(InterfaceMemberDeclarationContext.class);
7801 }
7802 public InterfaceMemberDeclarationContext interfaceMemberDeclaration(int i) {
7803 return getRuleContext(InterfaceMemberDeclarationContext.class,i);
7804 }
7805 public InterfaceBodyContext(ParserRuleContext parent, int invokingState) {
7806 super(parent, invokingState);
7807 }
7808 @Override public int getRuleIndex() { return RULE_interfaceBody; }
7809 @Override
7810 public void enterRule(ParseTreeListener listener) {
7811 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceBody(this);
7812 }
7813 @Override
7814 public void exitRule(ParseTreeListener listener) {
7815 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceBody(this);
7816 }
7817 }
7818
7819 public final InterfaceBodyContext interfaceBody() throws RecognitionException {
7820 InterfaceBodyContext _localctx = new InterfaceBodyContext(_ctx, getState());
7821 enterRule(_localctx, 226, RULE_interfaceBody);
7822 int _la;
7823 try {
7824 enterOuterAlt(_localctx, 1);
7825 {
7826 setState(1439);
7827 match(LBRACE);
7828 setState(1443);
7829 _errHandler.sync(this);
7830 _la = _input.LA(1);
7831 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DEFAULT) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << VOID))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (SEMI - 74)) | (1L << (AT - 74)) | (1L << (LT - 74)) | (1L << (Identifier - 74)))) != 0)) {
7832 {
7833 {
7834 setState(1440);
7835 interfaceMemberDeclaration();
7836 }
7837 }
7838 setState(1445);
7839 _errHandler.sync(this);
7840 _la = _input.LA(1);
7841 }
7842 setState(1446);
7843 match(RBRACE);
7844 }
7845 }
7846 catch (RecognitionException re) {
7847 _localctx.exception = re;
7848 _errHandler.reportError(this, re);
7849 _errHandler.recover(this, re);
7850 }
7851 finally {
7852 exitRule();
7853 }
7854 return _localctx;
7855 }
7856
7857 public static class InterfaceMemberDeclarationContext extends ParserRuleContext {
7858 public ConstantDeclarationContext constantDeclaration() {
7859 return getRuleContext(ConstantDeclarationContext.class,0);
7860 }
7861 public InterfaceMethodDeclarationContext interfaceMethodDeclaration() {
7862 return getRuleContext(InterfaceMethodDeclarationContext.class,0);
7863 }
7864 public ClassDeclarationContext classDeclaration() {
7865 return getRuleContext(ClassDeclarationContext.class,0);
7866 }
7867 public InterfaceDeclarationContext interfaceDeclaration() {
7868 return getRuleContext(InterfaceDeclarationContext.class,0);
7869 }
7870 public InterfaceMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
7871 super(parent, invokingState);
7872 }
7873 @Override public int getRuleIndex() { return RULE_interfaceMemberDeclaration; }
7874 @Override
7875 public void enterRule(ParseTreeListener listener) {
7876 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceMemberDeclaration(this);
7877 }
7878 @Override
7879 public void exitRule(ParseTreeListener listener) {
7880 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceMemberDeclaration(this);
7881 }
7882 }
7883
7884 public final InterfaceMemberDeclarationContext interfaceMemberDeclaration() throws RecognitionException {
7885 InterfaceMemberDeclarationContext _localctx = new InterfaceMemberDeclarationContext(_ctx, getState());
7886 enterRule(_localctx, 228, RULE_interfaceMemberDeclaration);
7887 try {
7888 setState(1453);
7889 _errHandler.sync(this);
7890 switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
7891 case 1:
7892 enterOuterAlt(_localctx, 1);
7893 {
7894 setState(1448);
7895 constantDeclaration();
7896 }
7897 break;
7898 case 2:
7899 enterOuterAlt(_localctx, 2);
7900 {
7901 setState(1449);
7902 interfaceMethodDeclaration();
7903 }
7904 break;
7905 case 3:
7906 enterOuterAlt(_localctx, 3);
7907 {
7908 setState(1450);
7909 classDeclaration();
7910 }
7911 break;
7912 case 4:
7913 enterOuterAlt(_localctx, 4);
7914 {
7915 setState(1451);
7916 interfaceDeclaration();
7917 }
7918 break;
7919 case 5:
7920 enterOuterAlt(_localctx, 5);
7921 {
7922 setState(1452);
7923 match(SEMI);
7924 }
7925 break;
7926 }
7927 }
7928 catch (RecognitionException re) {
7929 _localctx.exception = re;
7930 _errHandler.reportError(this, re);
7931 _errHandler.recover(this, re);
7932 }
7933 finally {
7934 exitRule();
7935 }
7936 return _localctx;
7937 }
7938
7939 public static class ConstantDeclarationContext extends ParserRuleContext {
7940 public UnannTypeContext unannType() {
7941 return getRuleContext(UnannTypeContext.class,0);
7942 }
7943 public VariableDeclaratorListContext variableDeclaratorList() {
7944 return getRuleContext(VariableDeclaratorListContext.class,0);
7945 }
7946 public List<ConstantModifierContext> constantModifier() {
7947 return getRuleContexts(ConstantModifierContext.class);
7948 }
7949 public ConstantModifierContext constantModifier(int i) {
7950 return getRuleContext(ConstantModifierContext.class,i);
7951 }
7952 public ConstantDeclarationContext(ParserRuleContext parent, int invokingState) {
7953 super(parent, invokingState);
7954 }
7955 @Override public int getRuleIndex() { return RULE_constantDeclaration; }
7956 @Override
7957 public void enterRule(ParseTreeListener listener) {
7958 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstantDeclaration(this);
7959 }
7960 @Override
7961 public void exitRule(ParseTreeListener listener) {
7962 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstantDeclaration(this);
7963 }
7964 }
7965
7966 public final ConstantDeclarationContext constantDeclaration() throws RecognitionException {
7967 ConstantDeclarationContext _localctx = new ConstantDeclarationContext(_ctx, getState());
7968 enterRule(_localctx, 230, RULE_constantDeclaration);
7969 int _la;
7970 try {
7971 enterOuterAlt(_localctx, 1);
7972 {
7973 setState(1458);
7974 _errHandler.sync(this);
7975 _la = _input.LA(1);
7976 while (((((_la - 28)) & ~0x3f) == 0 && ((1L << (_la - 28)) & ((1L << (FINAL - 28)) | (1L << (PUBLIC - 28)) | (1L << (STATIC - 28)) | (1L << (AT - 28)))) != 0)) {
7977 {
7978 {
7979 setState(1455);
7980 constantModifier();
7981 }
7982 }
7983 setState(1460);
7984 _errHandler.sync(this);
7985 _la = _input.LA(1);
7986 }
7987 setState(1461);
7988 unannType();
7989 setState(1462);
7990 variableDeclaratorList();
7991 setState(1463);
7992 match(SEMI);
7993 }
7994 }
7995 catch (RecognitionException re) {
7996 _localctx.exception = re;
7997 _errHandler.reportError(this, re);
7998 _errHandler.recover(this, re);
7999 }
8000 finally {
8001 exitRule();
8002 }
8003 return _localctx;
8004 }
8005
8006 public static class ConstantModifierContext extends ParserRuleContext {
8007 public AnnotationContext annotation() {
8008 return getRuleContext(AnnotationContext.class,0);
8009 }
8010 public ConstantModifierContext(ParserRuleContext parent, int invokingState) {
8011 super(parent, invokingState);
8012 }
8013 @Override public int getRuleIndex() { return RULE_constantModifier; }
8014 @Override
8015 public void enterRule(ParseTreeListener listener) {
8016 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstantModifier(this);
8017 }
8018 @Override
8019 public void exitRule(ParseTreeListener listener) {
8020 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstantModifier(this);
8021 }
8022 }
8023
8024 public final ConstantModifierContext constantModifier() throws RecognitionException {
8025 ConstantModifierContext _localctx = new ConstantModifierContext(_ctx, getState());
8026 enterRule(_localctx, 232, RULE_constantModifier);
8027 try {
8028 setState(1469);
8029 _errHandler.sync(this);
8030 switch (_input.LA(1)) {
8031 case AT:
8032 enterOuterAlt(_localctx, 1);
8033 {
8034 setState(1465);
8035 annotation();
8036 }
8037 break;
8038 case PUBLIC:
8039 enterOuterAlt(_localctx, 2);
8040 {
8041 setState(1466);
8042 match(PUBLIC);
8043 }
8044 break;
8045 case STATIC:
8046 enterOuterAlt(_localctx, 3);
8047 {
8048 setState(1467);
8049 match(STATIC);
8050 }
8051 break;
8052 case FINAL:
8053 enterOuterAlt(_localctx, 4);
8054 {
8055 setState(1468);
8056 match(FINAL);
8057 }
8058 break;
8059 default:
8060 throw new NoViableAltException(this);
8061 }
8062 }
8063 catch (RecognitionException re) {
8064 _localctx.exception = re;
8065 _errHandler.reportError(this, re);
8066 _errHandler.recover(this, re);
8067 }
8068 finally {
8069 exitRule();
8070 }
8071 return _localctx;
8072 }
8073
8074 public static class InterfaceMethodDeclarationContext extends ParserRuleContext {
8075 public MethodHeaderContext methodHeader() {
8076 return getRuleContext(MethodHeaderContext.class,0);
8077 }
8078 public MethodBodyContext methodBody() {
8079 return getRuleContext(MethodBodyContext.class,0);
8080 }
8081 public List<InterfaceMethodModifierContext> interfaceMethodModifier() {
8082 return getRuleContexts(InterfaceMethodModifierContext.class);
8083 }
8084 public InterfaceMethodModifierContext interfaceMethodModifier(int i) {
8085 return getRuleContext(InterfaceMethodModifierContext.class,i);
8086 }
8087 public InterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) {
8088 super(parent, invokingState);
8089 }
8090 @Override public int getRuleIndex() { return RULE_interfaceMethodDeclaration; }
8091 @Override
8092 public void enterRule(ParseTreeListener listener) {
8093 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceMethodDeclaration(this);
8094 }
8095 @Override
8096 public void exitRule(ParseTreeListener listener) {
8097 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceMethodDeclaration(this);
8098 }
8099 }
8100
8101 public final InterfaceMethodDeclarationContext interfaceMethodDeclaration() throws RecognitionException {
8102 InterfaceMethodDeclarationContext _localctx = new InterfaceMethodDeclarationContext(_ctx, getState());
8103 enterRule(_localctx, 234, RULE_interfaceMethodDeclaration);
8104 int _la;
8105 try {
8106 enterOuterAlt(_localctx, 1);
8107 {
8108 setState(1474);
8109 _errHandler.sync(this);
8110 _la = _input.LA(1);
8111 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << DEFAULT) | (1L << PRIVATE) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
8112 {
8113 {
8114 setState(1471);
8115 interfaceMethodModifier();
8116 }
8117 }
8118 setState(1476);
8119 _errHandler.sync(this);
8120 _la = _input.LA(1);
8121 }
8122 setState(1477);
8123 methodHeader();
8124 setState(1478);
8125 methodBody();
8126 }
8127 }
8128 catch (RecognitionException re) {
8129 _localctx.exception = re;
8130 _errHandler.reportError(this, re);
8131 _errHandler.recover(this, re);
8132 }
8133 finally {
8134 exitRule();
8135 }
8136 return _localctx;
8137 }
8138
8139 public static class InterfaceMethodModifierContext extends ParserRuleContext {
8140 public AnnotationContext annotation() {
8141 return getRuleContext(AnnotationContext.class,0);
8142 }
8143 public InterfaceMethodModifierContext(ParserRuleContext parent, int invokingState) {
8144 super(parent, invokingState);
8145 }
8146 @Override public int getRuleIndex() { return RULE_interfaceMethodModifier; }
8147 @Override
8148 public void enterRule(ParseTreeListener listener) {
8149 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceMethodModifier(this);
8150 }
8151 @Override
8152 public void exitRule(ParseTreeListener listener) {
8153 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceMethodModifier(this);
8154 }
8155 }
8156
8157 public final InterfaceMethodModifierContext interfaceMethodModifier() throws RecognitionException {
8158 InterfaceMethodModifierContext _localctx = new InterfaceMethodModifierContext(_ctx, getState());
8159 enterRule(_localctx, 236, RULE_interfaceMethodModifier);
8160 try {
8161 setState(1487);
8162 _errHandler.sync(this);
8163 switch (_input.LA(1)) {
8164 case AT:
8165 enterOuterAlt(_localctx, 1);
8166 {
8167 setState(1480);
8168 annotation();
8169 }
8170 break;
8171 case PUBLIC:
8172 enterOuterAlt(_localctx, 2);
8173 {
8174 setState(1481);
8175 match(PUBLIC);
8176 }
8177 break;
8178 case PRIVATE:
8179 enterOuterAlt(_localctx, 3);
8180 {
8181 setState(1482);
8182 match(PRIVATE);
8183 }
8184 break;
8185 case ABSTRACT:
8186 enterOuterAlt(_localctx, 4);
8187 {
8188 setState(1483);
8189 match(ABSTRACT);
8190 }
8191 break;
8192 case DEFAULT:
8193 enterOuterAlt(_localctx, 5);
8194 {
8195 setState(1484);
8196 match(DEFAULT);
8197 }
8198 break;
8199 case STATIC:
8200 enterOuterAlt(_localctx, 6);
8201 {
8202 setState(1485);
8203 match(STATIC);
8204 }
8205 break;
8206 case STRICTFP:
8207 enterOuterAlt(_localctx, 7);
8208 {
8209 setState(1486);
8210 match(STRICTFP);
8211 }
8212 break;
8213 default:
8214 throw new NoViableAltException(this);
8215 }
8216 }
8217 catch (RecognitionException re) {
8218 _localctx.exception = re;
8219 _errHandler.reportError(this, re);
8220 _errHandler.recover(this, re);
8221 }
8222 finally {
8223 exitRule();
8224 }
8225 return _localctx;
8226 }
8227
8228 public static class AnnotationTypeDeclarationContext extends ParserRuleContext {
8229 public IdentifierContext identifier() {
8230 return getRuleContext(IdentifierContext.class,0);
8231 }
8232 public AnnotationTypeBodyContext annotationTypeBody() {
8233 return getRuleContext(AnnotationTypeBodyContext.class,0);
8234 }
8235 public List<InterfaceModifierContext> interfaceModifier() {
8236 return getRuleContexts(InterfaceModifierContext.class);
8237 }
8238 public InterfaceModifierContext interfaceModifier(int i) {
8239 return getRuleContext(InterfaceModifierContext.class,i);
8240 }
8241 public AnnotationTypeDeclarationContext(ParserRuleContext parent, int invokingState) {
8242 super(parent, invokingState);
8243 }
8244 @Override public int getRuleIndex() { return RULE_annotationTypeDeclaration; }
8245 @Override
8246 public void enterRule(ParseTreeListener listener) {
8247 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAnnotationTypeDeclaration(this);
8248 }
8249 @Override
8250 public void exitRule(ParseTreeListener listener) {
8251 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAnnotationTypeDeclaration(this);
8252 }
8253 }
8254
8255 public final AnnotationTypeDeclarationContext annotationTypeDeclaration() throws RecognitionException {
8256 AnnotationTypeDeclarationContext _localctx = new AnnotationTypeDeclarationContext(_ctx, getState());
8257 enterRule(_localctx, 238, RULE_annotationTypeDeclaration);
8258 try {
8259 int _alt;
8260 enterOuterAlt(_localctx, 1);
8261 {
8262 setState(1492);
8263 _errHandler.sync(this);
8264 _alt = getInterpreter().adaptivePredict(_input,147,_ctx);
8265 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
8266 if ( _alt==1 ) {
8267 {
8268 {
8269 setState(1489);
8270 interfaceModifier();
8271 }
8272 }
8273 }
8274 setState(1494);
8275 _errHandler.sync(this);
8276 _alt = getInterpreter().adaptivePredict(_input,147,_ctx);
8277 }
8278 setState(1495);
8279 match(AT);
8280 setState(1496);
8281 match(INTERFACE);
8282 setState(1497);
8283 identifier();
8284 setState(1498);
8285 annotationTypeBody();
8286 }
8287 }
8288 catch (RecognitionException re) {
8289 _localctx.exception = re;
8290 _errHandler.reportError(this, re);
8291 _errHandler.recover(this, re);
8292 }
8293 finally {