@ant-yasa/uast-parser-java-js 0.1.19-beta.2 → 0.1.19-beta.30
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/package.json +73 -0
- package/dist/src/frontend/java/ASTBuilder.d.ts +171 -0
- package/dist/src/frontend/java/ASTBuilder.js +2369 -0
- package/dist/src/frontend/java/ASTBuilder.js.map +1 -0
- package/dist/src/frontend/java/ErrorListener.d.ts +9 -0
- package/dist/src/frontend/java/ErrorListener.js +24 -0
- package/dist/src/frontend/java/ErrorListener.js.map +1 -0
- package/dist/src/frontend/java/antlr/JavaLexer.d.ts +154 -0
- package/dist/src/frontend/java/antlr/JavaLexer.js +812 -0
- package/dist/src/frontend/java/antlr/JavaLexer.js.map +1 -0
- package/dist/src/frontend/java/antlr/JavaListener.d.ts +1393 -0
- package/dist/src/frontend/java/antlr/JavaListener.js +4 -0
- package/dist/src/frontend/java/antlr/JavaListener.js.map +1 -0
- package/dist/src/frontend/java/antlr/JavaParser.d.ts +2065 -0
- package/dist/src/frontend/java/antlr/JavaParser.js +15279 -0
- package/dist/src/frontend/java/antlr/JavaParser.js.map +1 -0
- package/dist/src/frontend/java/antlr/JavaVisitor.d.ts +892 -0
- package/dist/src/frontend/java/antlr/JavaVisitor.js +4 -0
- package/dist/src/frontend/java/antlr/JavaVisitor.js.map +1 -0
- package/dist/src/frontend/java/parser.d.ts +20 -0
- package/dist/src/frontend/java/parser.js +93 -0
- package/dist/src/frontend/java/parser.js.map +1 -0
- package/dist/src/frontend/java/testBuilder.d.ts +146 -0
- package/dist/src/frontend/java/testBuilder.js +464 -0
- package/dist/src/frontend/java/testBuilder.js.map +1 -0
- package/dist/src/frontend/java/types.d.ts +29 -0
- package/dist/src/frontend/java/types.js +3 -0
- package/dist/src/frontend/java/types.js.map +1 -0
- package/dist/src/frontend/javascript/parser.d.ts +8 -0
- package/dist/src/frontend/javascript/parser.js +1121 -0
- package/dist/src/frontend/javascript/parser.js.map +1 -0
- package/dist/src/index.d.ts +14 -0
- package/dist/src/index.js +76 -0
- package/dist/src/index.js.map +1 -0
- package/package.json +1 -1
|
@@ -0,0 +1,2065 @@
|
|
|
1
|
+
import { ATN } from "antlr4ts/atn/ATN";
|
|
2
|
+
import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
|
|
3
|
+
import { Parser } from "antlr4ts/Parser";
|
|
4
|
+
import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
|
|
5
|
+
import { RuleContext } from "antlr4ts/RuleContext";
|
|
6
|
+
import { TerminalNode } from "antlr4ts/tree/TerminalNode";
|
|
7
|
+
import { Token } from "antlr4ts/Token";
|
|
8
|
+
import { TokenStream } from "antlr4ts/TokenStream";
|
|
9
|
+
import { Vocabulary } from "antlr4ts/Vocabulary";
|
|
10
|
+
import { JavaListener } from "./JavaListener";
|
|
11
|
+
import { JavaVisitor } from "./JavaVisitor";
|
|
12
|
+
export declare class JavaParser extends Parser {
|
|
13
|
+
static readonly ABSTRACT = 1;
|
|
14
|
+
static readonly ASSERT = 2;
|
|
15
|
+
static readonly BOOLEAN = 3;
|
|
16
|
+
static readonly BREAK = 4;
|
|
17
|
+
static readonly BYTE = 5;
|
|
18
|
+
static readonly CASE = 6;
|
|
19
|
+
static readonly CATCH = 7;
|
|
20
|
+
static readonly CHAR = 8;
|
|
21
|
+
static readonly CLASS = 9;
|
|
22
|
+
static readonly CONST = 10;
|
|
23
|
+
static readonly CONTINUE = 11;
|
|
24
|
+
static readonly DEFAULT = 12;
|
|
25
|
+
static readonly DO = 13;
|
|
26
|
+
static readonly DOUBLE = 14;
|
|
27
|
+
static readonly ELSE = 15;
|
|
28
|
+
static readonly ENUM = 16;
|
|
29
|
+
static readonly EXTENDS = 17;
|
|
30
|
+
static readonly FINAL = 18;
|
|
31
|
+
static readonly FINALLY = 19;
|
|
32
|
+
static readonly FLOAT = 20;
|
|
33
|
+
static readonly FOR = 21;
|
|
34
|
+
static readonly IF = 22;
|
|
35
|
+
static readonly GOTO = 23;
|
|
36
|
+
static readonly IMPLEMENTS = 24;
|
|
37
|
+
static readonly IMPORT = 25;
|
|
38
|
+
static readonly INSTANCEOF = 26;
|
|
39
|
+
static readonly INT = 27;
|
|
40
|
+
static readonly INTERFACE = 28;
|
|
41
|
+
static readonly LONG = 29;
|
|
42
|
+
static readonly NATIVE = 30;
|
|
43
|
+
static readonly NEW = 31;
|
|
44
|
+
static readonly PACKAGE = 32;
|
|
45
|
+
static readonly PRIVATE = 33;
|
|
46
|
+
static readonly PROTECTED = 34;
|
|
47
|
+
static readonly PUBLIC = 35;
|
|
48
|
+
static readonly RETURN = 36;
|
|
49
|
+
static readonly SHORT = 37;
|
|
50
|
+
static readonly STATIC = 38;
|
|
51
|
+
static readonly STRICTFP = 39;
|
|
52
|
+
static readonly SUPER = 40;
|
|
53
|
+
static readonly SWITCH = 41;
|
|
54
|
+
static readonly SYNCHRONIZED = 42;
|
|
55
|
+
static readonly THIS = 43;
|
|
56
|
+
static readonly THROW = 44;
|
|
57
|
+
static readonly THROWS = 45;
|
|
58
|
+
static readonly TRANSIENT = 46;
|
|
59
|
+
static readonly TRY = 47;
|
|
60
|
+
static readonly VOID = 48;
|
|
61
|
+
static readonly VOLATILE = 49;
|
|
62
|
+
static readonly WHILE = 50;
|
|
63
|
+
static readonly MODULE = 51;
|
|
64
|
+
static readonly OPEN = 52;
|
|
65
|
+
static readonly REQUIRES = 53;
|
|
66
|
+
static readonly EXPORTS = 54;
|
|
67
|
+
static readonly OPENS = 55;
|
|
68
|
+
static readonly TO = 56;
|
|
69
|
+
static readonly USES = 57;
|
|
70
|
+
static readonly PROVIDES = 58;
|
|
71
|
+
static readonly WITH = 59;
|
|
72
|
+
static readonly TRANSITIVE = 60;
|
|
73
|
+
static readonly VAR = 61;
|
|
74
|
+
static readonly YIELD = 62;
|
|
75
|
+
static readonly RECORD = 63;
|
|
76
|
+
static readonly SEALED = 64;
|
|
77
|
+
static readonly PERMITS = 65;
|
|
78
|
+
static readonly NON_SEALED = 66;
|
|
79
|
+
static readonly DECIMAL_LITERAL = 67;
|
|
80
|
+
static readonly HEX_LITERAL = 68;
|
|
81
|
+
static readonly OCT_LITERAL = 69;
|
|
82
|
+
static readonly BINARY_LITERAL = 70;
|
|
83
|
+
static readonly FLOAT_LITERAL = 71;
|
|
84
|
+
static readonly HEX_FLOAT_LITERAL = 72;
|
|
85
|
+
static readonly BOOL_LITERAL = 73;
|
|
86
|
+
static readonly CHAR_LITERAL = 74;
|
|
87
|
+
static readonly STRING_LITERAL = 75;
|
|
88
|
+
static readonly TEXT_BLOCK = 76;
|
|
89
|
+
static readonly NULL_LITERAL = 77;
|
|
90
|
+
static readonly LPAREN = 78;
|
|
91
|
+
static readonly RPAREN = 79;
|
|
92
|
+
static readonly LBRACE = 80;
|
|
93
|
+
static readonly RBRACE = 81;
|
|
94
|
+
static readonly LBRACK = 82;
|
|
95
|
+
static readonly RBRACK = 83;
|
|
96
|
+
static readonly SEMI = 84;
|
|
97
|
+
static readonly COMMA = 85;
|
|
98
|
+
static readonly DOT = 86;
|
|
99
|
+
static readonly ASSIGN = 87;
|
|
100
|
+
static readonly GT = 88;
|
|
101
|
+
static readonly LT = 89;
|
|
102
|
+
static readonly BANG = 90;
|
|
103
|
+
static readonly TILDE = 91;
|
|
104
|
+
static readonly QUESTION = 92;
|
|
105
|
+
static readonly COLON = 93;
|
|
106
|
+
static readonly EQUAL = 94;
|
|
107
|
+
static readonly LE = 95;
|
|
108
|
+
static readonly GE = 96;
|
|
109
|
+
static readonly NOTEQUAL = 97;
|
|
110
|
+
static readonly AND = 98;
|
|
111
|
+
static readonly OR = 99;
|
|
112
|
+
static readonly INC = 100;
|
|
113
|
+
static readonly DEC = 101;
|
|
114
|
+
static readonly ADD = 102;
|
|
115
|
+
static readonly SUB = 103;
|
|
116
|
+
static readonly MUL = 104;
|
|
117
|
+
static readonly DIV = 105;
|
|
118
|
+
static readonly BITAND = 106;
|
|
119
|
+
static readonly BITOR = 107;
|
|
120
|
+
static readonly CARET = 108;
|
|
121
|
+
static readonly MOD = 109;
|
|
122
|
+
static readonly ADD_ASSIGN = 110;
|
|
123
|
+
static readonly SUB_ASSIGN = 111;
|
|
124
|
+
static readonly MUL_ASSIGN = 112;
|
|
125
|
+
static readonly DIV_ASSIGN = 113;
|
|
126
|
+
static readonly AND_ASSIGN = 114;
|
|
127
|
+
static readonly OR_ASSIGN = 115;
|
|
128
|
+
static readonly XOR_ASSIGN = 116;
|
|
129
|
+
static readonly MOD_ASSIGN = 117;
|
|
130
|
+
static readonly LSHIFT_ASSIGN = 118;
|
|
131
|
+
static readonly RSHIFT_ASSIGN = 119;
|
|
132
|
+
static readonly URSHIFT_ASSIGN = 120;
|
|
133
|
+
static readonly ARROW = 121;
|
|
134
|
+
static readonly COLONCOLON = 122;
|
|
135
|
+
static readonly AT = 123;
|
|
136
|
+
static readonly ELLIPSIS = 124;
|
|
137
|
+
static readonly WS = 125;
|
|
138
|
+
static readonly COMMENT = 126;
|
|
139
|
+
static readonly LINE_COMMENT = 127;
|
|
140
|
+
static readonly IDENTIFIER = 128;
|
|
141
|
+
static readonly RULE_compilationUnit = 0;
|
|
142
|
+
static readonly RULE_packageDeclaration = 1;
|
|
143
|
+
static readonly RULE_importDeclaration = 2;
|
|
144
|
+
static readonly RULE_typeDeclaration = 3;
|
|
145
|
+
static readonly RULE_modifier = 4;
|
|
146
|
+
static readonly RULE_classOrInterfaceModifier = 5;
|
|
147
|
+
static readonly RULE_variableModifier = 6;
|
|
148
|
+
static readonly RULE_classDeclaration = 7;
|
|
149
|
+
static readonly RULE_typeParameters = 8;
|
|
150
|
+
static readonly RULE_typeParameter = 9;
|
|
151
|
+
static readonly RULE_typeBound = 10;
|
|
152
|
+
static readonly RULE_enumDeclaration = 11;
|
|
153
|
+
static readonly RULE_enumConstants = 12;
|
|
154
|
+
static readonly RULE_enumConstant = 13;
|
|
155
|
+
static readonly RULE_enumBodyDeclarations = 14;
|
|
156
|
+
static readonly RULE_interfaceDeclaration = 15;
|
|
157
|
+
static readonly RULE_classBody = 16;
|
|
158
|
+
static readonly RULE_interfaceBody = 17;
|
|
159
|
+
static readonly RULE_classBodyDeclaration = 18;
|
|
160
|
+
static readonly RULE_memberDeclaration = 19;
|
|
161
|
+
static readonly RULE_methodDeclaration = 20;
|
|
162
|
+
static readonly RULE_methodBody = 21;
|
|
163
|
+
static readonly RULE_typeTypeOrVoid = 22;
|
|
164
|
+
static readonly RULE_genericMethodDeclaration = 23;
|
|
165
|
+
static readonly RULE_genericConstructorDeclaration = 24;
|
|
166
|
+
static readonly RULE_constructorDeclaration = 25;
|
|
167
|
+
static readonly RULE_compactConstructorDeclaration = 26;
|
|
168
|
+
static readonly RULE_fieldDeclaration = 27;
|
|
169
|
+
static readonly RULE_interfaceBodyDeclaration = 28;
|
|
170
|
+
static readonly RULE_interfaceMemberDeclaration = 29;
|
|
171
|
+
static readonly RULE_constDeclaration = 30;
|
|
172
|
+
static readonly RULE_constantDeclarator = 31;
|
|
173
|
+
static readonly RULE_interfaceMethodDeclaration = 32;
|
|
174
|
+
static readonly RULE_interfaceMethodModifier = 33;
|
|
175
|
+
static readonly RULE_genericInterfaceMethodDeclaration = 34;
|
|
176
|
+
static readonly RULE_interfaceCommonBodyDeclaration = 35;
|
|
177
|
+
static readonly RULE_variableDeclarators = 36;
|
|
178
|
+
static readonly RULE_variableDeclarator = 37;
|
|
179
|
+
static readonly RULE_variableDeclaratorId = 38;
|
|
180
|
+
static readonly RULE_variableInitializer = 39;
|
|
181
|
+
static readonly RULE_arrayInitializer = 40;
|
|
182
|
+
static readonly RULE_classOrInterfaceType = 41;
|
|
183
|
+
static readonly RULE_typeArgument = 42;
|
|
184
|
+
static readonly RULE_qualifiedNameList = 43;
|
|
185
|
+
static readonly RULE_formalParameters = 44;
|
|
186
|
+
static readonly RULE_receiverParameter = 45;
|
|
187
|
+
static readonly RULE_formalParameterList = 46;
|
|
188
|
+
static readonly RULE_formalParameter = 47;
|
|
189
|
+
static readonly RULE_lastFormalParameter = 48;
|
|
190
|
+
static readonly RULE_lambdaLVTIList = 49;
|
|
191
|
+
static readonly RULE_lambdaLVTIParameter = 50;
|
|
192
|
+
static readonly RULE_qualifiedName = 51;
|
|
193
|
+
static readonly RULE_literal = 52;
|
|
194
|
+
static readonly RULE_integerLiteral = 53;
|
|
195
|
+
static readonly RULE_floatLiteral = 54;
|
|
196
|
+
static readonly RULE_altAnnotationQualifiedName = 55;
|
|
197
|
+
static readonly RULE_annotation = 56;
|
|
198
|
+
static readonly RULE_elementValuePairs = 57;
|
|
199
|
+
static readonly RULE_elementValuePair = 58;
|
|
200
|
+
static readonly RULE_elementValue = 59;
|
|
201
|
+
static readonly RULE_elementValueArrayInitializer = 60;
|
|
202
|
+
static readonly RULE_annotationTypeDeclaration = 61;
|
|
203
|
+
static readonly RULE_annotationTypeBody = 62;
|
|
204
|
+
static readonly RULE_annotationTypeElementDeclaration = 63;
|
|
205
|
+
static readonly RULE_annotationTypeElementRest = 64;
|
|
206
|
+
static readonly RULE_annotationMethodOrConstantRest = 65;
|
|
207
|
+
static readonly RULE_annotationMethodRest = 66;
|
|
208
|
+
static readonly RULE_annotationConstantRest = 67;
|
|
209
|
+
static readonly RULE_defaultValue = 68;
|
|
210
|
+
static readonly RULE_moduleDeclaration = 69;
|
|
211
|
+
static readonly RULE_moduleBody = 70;
|
|
212
|
+
static readonly RULE_moduleDirective = 71;
|
|
213
|
+
static readonly RULE_requiresModifier = 72;
|
|
214
|
+
static readonly RULE_recordDeclaration = 73;
|
|
215
|
+
static readonly RULE_recordHeader = 74;
|
|
216
|
+
static readonly RULE_recordComponentList = 75;
|
|
217
|
+
static readonly RULE_recordComponent = 76;
|
|
218
|
+
static readonly RULE_recordBody = 77;
|
|
219
|
+
static readonly RULE_block = 78;
|
|
220
|
+
static readonly RULE_blockStatement = 79;
|
|
221
|
+
static readonly RULE_localVariableDeclaration = 80;
|
|
222
|
+
static readonly RULE_identifier = 81;
|
|
223
|
+
static readonly RULE_typeIdentifier = 82;
|
|
224
|
+
static readonly RULE_localTypeDeclaration = 83;
|
|
225
|
+
static readonly RULE_statement = 84;
|
|
226
|
+
static readonly RULE_catchClause = 85;
|
|
227
|
+
static readonly RULE_catchType = 86;
|
|
228
|
+
static readonly RULE_finallyBlock = 87;
|
|
229
|
+
static readonly RULE_resourceSpecification = 88;
|
|
230
|
+
static readonly RULE_resources = 89;
|
|
231
|
+
static readonly RULE_resource = 90;
|
|
232
|
+
static readonly RULE_switchBlockStatementGroup = 91;
|
|
233
|
+
static readonly RULE_switchLabel = 92;
|
|
234
|
+
static readonly RULE_forControl = 93;
|
|
235
|
+
static readonly RULE_forInit = 94;
|
|
236
|
+
static readonly RULE_enhancedForControl = 95;
|
|
237
|
+
static readonly RULE_parExpression = 96;
|
|
238
|
+
static readonly RULE_expressionList = 97;
|
|
239
|
+
static readonly RULE_methodCall = 98;
|
|
240
|
+
static readonly RULE_expression = 99;
|
|
241
|
+
static readonly RULE_pattern = 100;
|
|
242
|
+
static readonly RULE_lambdaExpression = 101;
|
|
243
|
+
static readonly RULE_lambdaParameters = 102;
|
|
244
|
+
static readonly RULE_lambdaBody = 103;
|
|
245
|
+
static readonly RULE_primary = 104;
|
|
246
|
+
static readonly RULE_switchExpression = 105;
|
|
247
|
+
static readonly RULE_switchLabeledRule = 106;
|
|
248
|
+
static readonly RULE_guardedPattern = 107;
|
|
249
|
+
static readonly RULE_switchRuleOutcome = 108;
|
|
250
|
+
static readonly RULE_classType = 109;
|
|
251
|
+
static readonly RULE_creator = 110;
|
|
252
|
+
static readonly RULE_createdName = 111;
|
|
253
|
+
static readonly RULE_innerCreator = 112;
|
|
254
|
+
static readonly RULE_arrayCreatorRest = 113;
|
|
255
|
+
static readonly RULE_classCreatorRest = 114;
|
|
256
|
+
static readonly RULE_explicitGenericInvocation = 115;
|
|
257
|
+
static readonly RULE_typeArgumentsOrDiamond = 116;
|
|
258
|
+
static readonly RULE_nonWildcardTypeArgumentsOrDiamond = 117;
|
|
259
|
+
static readonly RULE_nonWildcardTypeArguments = 118;
|
|
260
|
+
static readonly RULE_typeList = 119;
|
|
261
|
+
static readonly RULE_typeType = 120;
|
|
262
|
+
static readonly RULE_primitiveType = 121;
|
|
263
|
+
static readonly RULE_typeArguments = 122;
|
|
264
|
+
static readonly RULE_superSuffix = 123;
|
|
265
|
+
static readonly RULE_explicitGenericInvocationSuffix = 124;
|
|
266
|
+
static readonly RULE_arguments = 125;
|
|
267
|
+
static readonly ruleNames: string[];
|
|
268
|
+
private static readonly _LITERAL_NAMES;
|
|
269
|
+
private static readonly _SYMBOLIC_NAMES;
|
|
270
|
+
static readonly VOCABULARY: Vocabulary;
|
|
271
|
+
get vocabulary(): Vocabulary;
|
|
272
|
+
get grammarFileName(): string;
|
|
273
|
+
get ruleNames(): string[];
|
|
274
|
+
get serializedATN(): string;
|
|
275
|
+
protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException;
|
|
276
|
+
constructor(input: TokenStream);
|
|
277
|
+
compilationUnit(): CompilationUnitContext;
|
|
278
|
+
packageDeclaration(): PackageDeclarationContext;
|
|
279
|
+
importDeclaration(): ImportDeclarationContext;
|
|
280
|
+
typeDeclaration(): TypeDeclarationContext;
|
|
281
|
+
modifier(): ModifierContext;
|
|
282
|
+
classOrInterfaceModifier(): ClassOrInterfaceModifierContext;
|
|
283
|
+
variableModifier(): VariableModifierContext;
|
|
284
|
+
classDeclaration(): ClassDeclarationContext;
|
|
285
|
+
typeParameters(): TypeParametersContext;
|
|
286
|
+
typeParameter(): TypeParameterContext;
|
|
287
|
+
typeBound(): TypeBoundContext;
|
|
288
|
+
enumDeclaration(): EnumDeclarationContext;
|
|
289
|
+
enumConstants(): EnumConstantsContext;
|
|
290
|
+
enumConstant(): EnumConstantContext;
|
|
291
|
+
enumBodyDeclarations(): EnumBodyDeclarationsContext;
|
|
292
|
+
interfaceDeclaration(): InterfaceDeclarationContext;
|
|
293
|
+
classBody(): ClassBodyContext;
|
|
294
|
+
interfaceBody(): InterfaceBodyContext;
|
|
295
|
+
classBodyDeclaration(): ClassBodyDeclarationContext;
|
|
296
|
+
memberDeclaration(): MemberDeclarationContext;
|
|
297
|
+
methodDeclaration(): MethodDeclarationContext;
|
|
298
|
+
methodBody(): MethodBodyContext;
|
|
299
|
+
typeTypeOrVoid(): TypeTypeOrVoidContext;
|
|
300
|
+
genericMethodDeclaration(): GenericMethodDeclarationContext;
|
|
301
|
+
genericConstructorDeclaration(): GenericConstructorDeclarationContext;
|
|
302
|
+
constructorDeclaration(): ConstructorDeclarationContext;
|
|
303
|
+
compactConstructorDeclaration(): CompactConstructorDeclarationContext;
|
|
304
|
+
fieldDeclaration(): FieldDeclarationContext;
|
|
305
|
+
interfaceBodyDeclaration(): InterfaceBodyDeclarationContext;
|
|
306
|
+
interfaceMemberDeclaration(): InterfaceMemberDeclarationContext;
|
|
307
|
+
constDeclaration(): ConstDeclarationContext;
|
|
308
|
+
constantDeclarator(): ConstantDeclaratorContext;
|
|
309
|
+
interfaceMethodDeclaration(): InterfaceMethodDeclarationContext;
|
|
310
|
+
interfaceMethodModifier(): InterfaceMethodModifierContext;
|
|
311
|
+
genericInterfaceMethodDeclaration(): GenericInterfaceMethodDeclarationContext;
|
|
312
|
+
interfaceCommonBodyDeclaration(): InterfaceCommonBodyDeclarationContext;
|
|
313
|
+
variableDeclarators(): VariableDeclaratorsContext;
|
|
314
|
+
variableDeclarator(): VariableDeclaratorContext;
|
|
315
|
+
variableDeclaratorId(): VariableDeclaratorIdContext;
|
|
316
|
+
variableInitializer(): VariableInitializerContext;
|
|
317
|
+
arrayInitializer(): ArrayInitializerContext;
|
|
318
|
+
classOrInterfaceType(): ClassOrInterfaceTypeContext;
|
|
319
|
+
typeArgument(): TypeArgumentContext;
|
|
320
|
+
qualifiedNameList(): QualifiedNameListContext;
|
|
321
|
+
formalParameters(): FormalParametersContext;
|
|
322
|
+
receiverParameter(): ReceiverParameterContext;
|
|
323
|
+
formalParameterList(): FormalParameterListContext;
|
|
324
|
+
formalParameter(): FormalParameterContext;
|
|
325
|
+
lastFormalParameter(): LastFormalParameterContext;
|
|
326
|
+
lambdaLVTIList(): LambdaLVTIListContext;
|
|
327
|
+
lambdaLVTIParameter(): LambdaLVTIParameterContext;
|
|
328
|
+
qualifiedName(): QualifiedNameContext;
|
|
329
|
+
literal(): LiteralContext;
|
|
330
|
+
integerLiteral(): IntegerLiteralContext;
|
|
331
|
+
floatLiteral(): FloatLiteralContext;
|
|
332
|
+
altAnnotationQualifiedName(): AltAnnotationQualifiedNameContext;
|
|
333
|
+
annotation(): AnnotationContext;
|
|
334
|
+
elementValuePairs(): ElementValuePairsContext;
|
|
335
|
+
elementValuePair(): ElementValuePairContext;
|
|
336
|
+
elementValue(): ElementValueContext;
|
|
337
|
+
elementValueArrayInitializer(): ElementValueArrayInitializerContext;
|
|
338
|
+
annotationTypeDeclaration(): AnnotationTypeDeclarationContext;
|
|
339
|
+
annotationTypeBody(): AnnotationTypeBodyContext;
|
|
340
|
+
annotationTypeElementDeclaration(): AnnotationTypeElementDeclarationContext;
|
|
341
|
+
annotationTypeElementRest(): AnnotationTypeElementRestContext;
|
|
342
|
+
annotationMethodOrConstantRest(): AnnotationMethodOrConstantRestContext;
|
|
343
|
+
annotationMethodRest(): AnnotationMethodRestContext;
|
|
344
|
+
annotationConstantRest(): AnnotationConstantRestContext;
|
|
345
|
+
defaultValue(): DefaultValueContext;
|
|
346
|
+
moduleDeclaration(): ModuleDeclarationContext;
|
|
347
|
+
moduleBody(): ModuleBodyContext;
|
|
348
|
+
moduleDirective(): ModuleDirectiveContext;
|
|
349
|
+
requiresModifier(): RequiresModifierContext;
|
|
350
|
+
recordDeclaration(): RecordDeclarationContext;
|
|
351
|
+
recordHeader(): RecordHeaderContext;
|
|
352
|
+
recordComponentList(): RecordComponentListContext;
|
|
353
|
+
recordComponent(): RecordComponentContext;
|
|
354
|
+
recordBody(): RecordBodyContext;
|
|
355
|
+
block(): BlockContext;
|
|
356
|
+
blockStatement(): BlockStatementContext;
|
|
357
|
+
localVariableDeclaration(): LocalVariableDeclarationContext;
|
|
358
|
+
identifier(): IdentifierContext;
|
|
359
|
+
typeIdentifier(): TypeIdentifierContext;
|
|
360
|
+
localTypeDeclaration(): LocalTypeDeclarationContext;
|
|
361
|
+
statement(): StatementContext;
|
|
362
|
+
catchClause(): CatchClauseContext;
|
|
363
|
+
catchType(): CatchTypeContext;
|
|
364
|
+
finallyBlock(): FinallyBlockContext;
|
|
365
|
+
resourceSpecification(): ResourceSpecificationContext;
|
|
366
|
+
resources(): ResourcesContext;
|
|
367
|
+
resource(): ResourceContext;
|
|
368
|
+
switchBlockStatementGroup(): SwitchBlockStatementGroupContext;
|
|
369
|
+
switchLabel(): SwitchLabelContext;
|
|
370
|
+
forControl(): ForControlContext;
|
|
371
|
+
forInit(): ForInitContext;
|
|
372
|
+
enhancedForControl(): EnhancedForControlContext;
|
|
373
|
+
parExpression(): ParExpressionContext;
|
|
374
|
+
expressionList(): ExpressionListContext;
|
|
375
|
+
methodCall(): MethodCallContext;
|
|
376
|
+
expression(): ExpressionContext;
|
|
377
|
+
expression(_p: number): ExpressionContext;
|
|
378
|
+
pattern(): PatternContext;
|
|
379
|
+
lambdaExpression(): LambdaExpressionContext;
|
|
380
|
+
lambdaParameters(): LambdaParametersContext;
|
|
381
|
+
lambdaBody(): LambdaBodyContext;
|
|
382
|
+
primary(): PrimaryContext;
|
|
383
|
+
switchExpression(): SwitchExpressionContext;
|
|
384
|
+
switchLabeledRule(): SwitchLabeledRuleContext;
|
|
385
|
+
guardedPattern(): GuardedPatternContext;
|
|
386
|
+
guardedPattern(_p: number): GuardedPatternContext;
|
|
387
|
+
switchRuleOutcome(): SwitchRuleOutcomeContext;
|
|
388
|
+
classType(): ClassTypeContext;
|
|
389
|
+
creator(): CreatorContext;
|
|
390
|
+
createdName(): CreatedNameContext;
|
|
391
|
+
innerCreator(): InnerCreatorContext;
|
|
392
|
+
arrayCreatorRest(): ArrayCreatorRestContext;
|
|
393
|
+
classCreatorRest(): ClassCreatorRestContext;
|
|
394
|
+
explicitGenericInvocation(): ExplicitGenericInvocationContext;
|
|
395
|
+
typeArgumentsOrDiamond(): TypeArgumentsOrDiamondContext;
|
|
396
|
+
nonWildcardTypeArgumentsOrDiamond(): NonWildcardTypeArgumentsOrDiamondContext;
|
|
397
|
+
nonWildcardTypeArguments(): NonWildcardTypeArgumentsContext;
|
|
398
|
+
typeList(): TypeListContext;
|
|
399
|
+
typeType(): TypeTypeContext;
|
|
400
|
+
primitiveType(): PrimitiveTypeContext;
|
|
401
|
+
typeArguments(): TypeArgumentsContext;
|
|
402
|
+
superSuffix(): SuperSuffixContext;
|
|
403
|
+
explicitGenericInvocationSuffix(): ExplicitGenericInvocationSuffixContext;
|
|
404
|
+
arguments(): ArgumentsContext;
|
|
405
|
+
sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean;
|
|
406
|
+
private expression_sempred;
|
|
407
|
+
private guardedPattern_sempred;
|
|
408
|
+
private static readonly _serializedATNSegments;
|
|
409
|
+
private static readonly _serializedATNSegment0;
|
|
410
|
+
private static readonly _serializedATNSegment1;
|
|
411
|
+
private static readonly _serializedATNSegment2;
|
|
412
|
+
private static readonly _serializedATNSegment3;
|
|
413
|
+
static readonly _serializedATN: string;
|
|
414
|
+
static __ATN: ATN;
|
|
415
|
+
static get _ATN(): ATN;
|
|
416
|
+
}
|
|
417
|
+
export declare class CompilationUnitContext extends ParserRuleContext {
|
|
418
|
+
packageDeclaration(): PackageDeclarationContext | undefined;
|
|
419
|
+
importDeclaration(): ImportDeclarationContext[];
|
|
420
|
+
importDeclaration(i: number): ImportDeclarationContext;
|
|
421
|
+
SEMI(): TerminalNode[];
|
|
422
|
+
SEMI(i: number): TerminalNode;
|
|
423
|
+
typeDeclaration(): TypeDeclarationContext[];
|
|
424
|
+
typeDeclaration(i: number): TypeDeclarationContext;
|
|
425
|
+
moduleDeclaration(): ModuleDeclarationContext | undefined;
|
|
426
|
+
EOF(): TerminalNode | undefined;
|
|
427
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
428
|
+
get ruleIndex(): number;
|
|
429
|
+
enterRule(listener: JavaListener): void;
|
|
430
|
+
exitRule(listener: JavaListener): void;
|
|
431
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
432
|
+
}
|
|
433
|
+
export declare class PackageDeclarationContext extends ParserRuleContext {
|
|
434
|
+
PACKAGE(): TerminalNode;
|
|
435
|
+
qualifiedName(): QualifiedNameContext;
|
|
436
|
+
SEMI(): TerminalNode;
|
|
437
|
+
annotation(): AnnotationContext[];
|
|
438
|
+
annotation(i: number): AnnotationContext;
|
|
439
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
440
|
+
get ruleIndex(): number;
|
|
441
|
+
enterRule(listener: JavaListener): void;
|
|
442
|
+
exitRule(listener: JavaListener): void;
|
|
443
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
444
|
+
}
|
|
445
|
+
export declare class ImportDeclarationContext extends ParserRuleContext {
|
|
446
|
+
IMPORT(): TerminalNode | undefined;
|
|
447
|
+
qualifiedName(): QualifiedNameContext | undefined;
|
|
448
|
+
SEMI(): TerminalNode;
|
|
449
|
+
STATIC(): TerminalNode | undefined;
|
|
450
|
+
DOT(): TerminalNode | undefined;
|
|
451
|
+
MUL(): TerminalNode | undefined;
|
|
452
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
453
|
+
get ruleIndex(): number;
|
|
454
|
+
enterRule(listener: JavaListener): void;
|
|
455
|
+
exitRule(listener: JavaListener): void;
|
|
456
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
457
|
+
}
|
|
458
|
+
export declare class TypeDeclarationContext extends ParserRuleContext {
|
|
459
|
+
classDeclaration(): ClassDeclarationContext | undefined;
|
|
460
|
+
enumDeclaration(): EnumDeclarationContext | undefined;
|
|
461
|
+
interfaceDeclaration(): InterfaceDeclarationContext | undefined;
|
|
462
|
+
annotationTypeDeclaration(): AnnotationTypeDeclarationContext | undefined;
|
|
463
|
+
recordDeclaration(): RecordDeclarationContext | undefined;
|
|
464
|
+
classOrInterfaceModifier(): ClassOrInterfaceModifierContext[];
|
|
465
|
+
classOrInterfaceModifier(i: number): ClassOrInterfaceModifierContext;
|
|
466
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
467
|
+
get ruleIndex(): number;
|
|
468
|
+
enterRule(listener: JavaListener): void;
|
|
469
|
+
exitRule(listener: JavaListener): void;
|
|
470
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
471
|
+
}
|
|
472
|
+
export declare class ModifierContext extends ParserRuleContext {
|
|
473
|
+
classOrInterfaceModifier(): ClassOrInterfaceModifierContext | undefined;
|
|
474
|
+
NATIVE(): TerminalNode | undefined;
|
|
475
|
+
SYNCHRONIZED(): TerminalNode | undefined;
|
|
476
|
+
TRANSIENT(): TerminalNode | undefined;
|
|
477
|
+
VOLATILE(): TerminalNode | undefined;
|
|
478
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
479
|
+
get ruleIndex(): number;
|
|
480
|
+
enterRule(listener: JavaListener): void;
|
|
481
|
+
exitRule(listener: JavaListener): void;
|
|
482
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
483
|
+
}
|
|
484
|
+
export declare class ClassOrInterfaceModifierContext extends ParserRuleContext {
|
|
485
|
+
annotation(): AnnotationContext | undefined;
|
|
486
|
+
PUBLIC(): TerminalNode | undefined;
|
|
487
|
+
PROTECTED(): TerminalNode | undefined;
|
|
488
|
+
PRIVATE(): TerminalNode | undefined;
|
|
489
|
+
STATIC(): TerminalNode | undefined;
|
|
490
|
+
ABSTRACT(): TerminalNode | undefined;
|
|
491
|
+
FINAL(): TerminalNode | undefined;
|
|
492
|
+
STRICTFP(): TerminalNode | undefined;
|
|
493
|
+
SEALED(): TerminalNode | undefined;
|
|
494
|
+
NON_SEALED(): TerminalNode | undefined;
|
|
495
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
496
|
+
get ruleIndex(): number;
|
|
497
|
+
enterRule(listener: JavaListener): void;
|
|
498
|
+
exitRule(listener: JavaListener): void;
|
|
499
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
500
|
+
}
|
|
501
|
+
export declare class VariableModifierContext extends ParserRuleContext {
|
|
502
|
+
FINAL(): TerminalNode | undefined;
|
|
503
|
+
annotation(): AnnotationContext | undefined;
|
|
504
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
505
|
+
get ruleIndex(): number;
|
|
506
|
+
enterRule(listener: JavaListener): void;
|
|
507
|
+
exitRule(listener: JavaListener): void;
|
|
508
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
509
|
+
}
|
|
510
|
+
export declare class ClassDeclarationContext extends ParserRuleContext {
|
|
511
|
+
CLASS(): TerminalNode;
|
|
512
|
+
identifier(): IdentifierContext;
|
|
513
|
+
classBody(): ClassBodyContext;
|
|
514
|
+
typeParameters(): TypeParametersContext | undefined;
|
|
515
|
+
EXTENDS(): TerminalNode | undefined;
|
|
516
|
+
typeType(): TypeTypeContext | undefined;
|
|
517
|
+
IMPLEMENTS(): TerminalNode | undefined;
|
|
518
|
+
typeList(): TypeListContext[];
|
|
519
|
+
typeList(i: number): TypeListContext;
|
|
520
|
+
PERMITS(): TerminalNode | undefined;
|
|
521
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
522
|
+
get ruleIndex(): number;
|
|
523
|
+
enterRule(listener: JavaListener): void;
|
|
524
|
+
exitRule(listener: JavaListener): void;
|
|
525
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
526
|
+
}
|
|
527
|
+
export declare class TypeParametersContext extends ParserRuleContext {
|
|
528
|
+
LT(): TerminalNode;
|
|
529
|
+
typeParameter(): TypeParameterContext[];
|
|
530
|
+
typeParameter(i: number): TypeParameterContext;
|
|
531
|
+
GT(): TerminalNode;
|
|
532
|
+
COMMA(): TerminalNode[];
|
|
533
|
+
COMMA(i: number): TerminalNode;
|
|
534
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
535
|
+
get ruleIndex(): number;
|
|
536
|
+
enterRule(listener: JavaListener): void;
|
|
537
|
+
exitRule(listener: JavaListener): void;
|
|
538
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
539
|
+
}
|
|
540
|
+
export declare class TypeParameterContext extends ParserRuleContext {
|
|
541
|
+
identifier(): IdentifierContext;
|
|
542
|
+
annotation(): AnnotationContext[];
|
|
543
|
+
annotation(i: number): AnnotationContext;
|
|
544
|
+
EXTENDS(): TerminalNode | undefined;
|
|
545
|
+
typeBound(): TypeBoundContext | undefined;
|
|
546
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
547
|
+
get ruleIndex(): number;
|
|
548
|
+
enterRule(listener: JavaListener): void;
|
|
549
|
+
exitRule(listener: JavaListener): void;
|
|
550
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
551
|
+
}
|
|
552
|
+
export declare class TypeBoundContext extends ParserRuleContext {
|
|
553
|
+
typeType(): TypeTypeContext[];
|
|
554
|
+
typeType(i: number): TypeTypeContext;
|
|
555
|
+
BITAND(): TerminalNode[];
|
|
556
|
+
BITAND(i: number): TerminalNode;
|
|
557
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
558
|
+
get ruleIndex(): number;
|
|
559
|
+
enterRule(listener: JavaListener): void;
|
|
560
|
+
exitRule(listener: JavaListener): void;
|
|
561
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
562
|
+
}
|
|
563
|
+
export declare class EnumDeclarationContext extends ParserRuleContext {
|
|
564
|
+
ENUM(): TerminalNode;
|
|
565
|
+
identifier(): IdentifierContext;
|
|
566
|
+
LBRACE(): TerminalNode;
|
|
567
|
+
RBRACE(): TerminalNode;
|
|
568
|
+
IMPLEMENTS(): TerminalNode | undefined;
|
|
569
|
+
typeList(): TypeListContext | undefined;
|
|
570
|
+
enumConstants(): EnumConstantsContext | undefined;
|
|
571
|
+
COMMA(): TerminalNode | undefined;
|
|
572
|
+
enumBodyDeclarations(): EnumBodyDeclarationsContext | undefined;
|
|
573
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
574
|
+
get ruleIndex(): number;
|
|
575
|
+
enterRule(listener: JavaListener): void;
|
|
576
|
+
exitRule(listener: JavaListener): void;
|
|
577
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
578
|
+
}
|
|
579
|
+
export declare class EnumConstantsContext extends ParserRuleContext {
|
|
580
|
+
enumConstant(): EnumConstantContext[];
|
|
581
|
+
enumConstant(i: number): EnumConstantContext;
|
|
582
|
+
COMMA(): TerminalNode[];
|
|
583
|
+
COMMA(i: number): TerminalNode;
|
|
584
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
585
|
+
get ruleIndex(): number;
|
|
586
|
+
enterRule(listener: JavaListener): void;
|
|
587
|
+
exitRule(listener: JavaListener): void;
|
|
588
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
589
|
+
}
|
|
590
|
+
export declare class EnumConstantContext extends ParserRuleContext {
|
|
591
|
+
identifier(): IdentifierContext;
|
|
592
|
+
annotation(): AnnotationContext[];
|
|
593
|
+
annotation(i: number): AnnotationContext;
|
|
594
|
+
arguments(): ArgumentsContext | undefined;
|
|
595
|
+
classBody(): ClassBodyContext | undefined;
|
|
596
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
597
|
+
get ruleIndex(): number;
|
|
598
|
+
enterRule(listener: JavaListener): void;
|
|
599
|
+
exitRule(listener: JavaListener): void;
|
|
600
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
601
|
+
}
|
|
602
|
+
export declare class EnumBodyDeclarationsContext extends ParserRuleContext {
|
|
603
|
+
SEMI(): TerminalNode;
|
|
604
|
+
classBodyDeclaration(): ClassBodyDeclarationContext[];
|
|
605
|
+
classBodyDeclaration(i: number): ClassBodyDeclarationContext;
|
|
606
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
607
|
+
get ruleIndex(): number;
|
|
608
|
+
enterRule(listener: JavaListener): void;
|
|
609
|
+
exitRule(listener: JavaListener): void;
|
|
610
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
611
|
+
}
|
|
612
|
+
export declare class InterfaceDeclarationContext extends ParserRuleContext {
|
|
613
|
+
INTERFACE(): TerminalNode;
|
|
614
|
+
identifier(): IdentifierContext;
|
|
615
|
+
interfaceBody(): InterfaceBodyContext;
|
|
616
|
+
typeParameters(): TypeParametersContext | undefined;
|
|
617
|
+
EXTENDS(): TerminalNode | undefined;
|
|
618
|
+
typeList(): TypeListContext[];
|
|
619
|
+
typeList(i: number): TypeListContext;
|
|
620
|
+
PERMITS(): TerminalNode | undefined;
|
|
621
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
622
|
+
get ruleIndex(): number;
|
|
623
|
+
enterRule(listener: JavaListener): void;
|
|
624
|
+
exitRule(listener: JavaListener): void;
|
|
625
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
626
|
+
}
|
|
627
|
+
export declare class ClassBodyContext extends ParserRuleContext {
|
|
628
|
+
LBRACE(): TerminalNode;
|
|
629
|
+
RBRACE(): TerminalNode;
|
|
630
|
+
classBodyDeclaration(): ClassBodyDeclarationContext[];
|
|
631
|
+
classBodyDeclaration(i: number): ClassBodyDeclarationContext;
|
|
632
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
633
|
+
get ruleIndex(): number;
|
|
634
|
+
enterRule(listener: JavaListener): void;
|
|
635
|
+
exitRule(listener: JavaListener): void;
|
|
636
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
637
|
+
}
|
|
638
|
+
export declare class InterfaceBodyContext extends ParserRuleContext {
|
|
639
|
+
LBRACE(): TerminalNode;
|
|
640
|
+
RBRACE(): TerminalNode;
|
|
641
|
+
interfaceBodyDeclaration(): InterfaceBodyDeclarationContext[];
|
|
642
|
+
interfaceBodyDeclaration(i: number): InterfaceBodyDeclarationContext;
|
|
643
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
644
|
+
get ruleIndex(): number;
|
|
645
|
+
enterRule(listener: JavaListener): void;
|
|
646
|
+
exitRule(listener: JavaListener): void;
|
|
647
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
648
|
+
}
|
|
649
|
+
export declare class ClassBodyDeclarationContext extends ParserRuleContext {
|
|
650
|
+
SEMI(): TerminalNode | undefined;
|
|
651
|
+
block(): BlockContext | undefined;
|
|
652
|
+
STATIC(): TerminalNode | undefined;
|
|
653
|
+
memberDeclaration(): MemberDeclarationContext | undefined;
|
|
654
|
+
modifier(): ModifierContext[];
|
|
655
|
+
modifier(i: number): ModifierContext;
|
|
656
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
657
|
+
get ruleIndex(): number;
|
|
658
|
+
enterRule(listener: JavaListener): void;
|
|
659
|
+
exitRule(listener: JavaListener): void;
|
|
660
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
661
|
+
}
|
|
662
|
+
export declare class MemberDeclarationContext extends ParserRuleContext {
|
|
663
|
+
recordDeclaration(): RecordDeclarationContext | undefined;
|
|
664
|
+
methodDeclaration(): MethodDeclarationContext | undefined;
|
|
665
|
+
genericMethodDeclaration(): GenericMethodDeclarationContext | undefined;
|
|
666
|
+
fieldDeclaration(): FieldDeclarationContext | undefined;
|
|
667
|
+
constructorDeclaration(): ConstructorDeclarationContext | undefined;
|
|
668
|
+
genericConstructorDeclaration(): GenericConstructorDeclarationContext | undefined;
|
|
669
|
+
interfaceDeclaration(): InterfaceDeclarationContext | undefined;
|
|
670
|
+
annotationTypeDeclaration(): AnnotationTypeDeclarationContext | undefined;
|
|
671
|
+
classDeclaration(): ClassDeclarationContext | undefined;
|
|
672
|
+
enumDeclaration(): EnumDeclarationContext | undefined;
|
|
673
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
674
|
+
get ruleIndex(): number;
|
|
675
|
+
enterRule(listener: JavaListener): void;
|
|
676
|
+
exitRule(listener: JavaListener): void;
|
|
677
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
678
|
+
}
|
|
679
|
+
export declare class MethodDeclarationContext extends ParserRuleContext {
|
|
680
|
+
typeTypeOrVoid(): TypeTypeOrVoidContext;
|
|
681
|
+
identifier(): IdentifierContext;
|
|
682
|
+
formalParameters(): FormalParametersContext;
|
|
683
|
+
methodBody(): MethodBodyContext;
|
|
684
|
+
LBRACK(): TerminalNode[];
|
|
685
|
+
LBRACK(i: number): TerminalNode;
|
|
686
|
+
RBRACK(): TerminalNode[];
|
|
687
|
+
RBRACK(i: number): TerminalNode;
|
|
688
|
+
THROWS(): TerminalNode | undefined;
|
|
689
|
+
qualifiedNameList(): QualifiedNameListContext | undefined;
|
|
690
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
691
|
+
get ruleIndex(): number;
|
|
692
|
+
enterRule(listener: JavaListener): void;
|
|
693
|
+
exitRule(listener: JavaListener): void;
|
|
694
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
695
|
+
}
|
|
696
|
+
export declare class MethodBodyContext extends ParserRuleContext {
|
|
697
|
+
block(): BlockContext | undefined;
|
|
698
|
+
SEMI(): TerminalNode | undefined;
|
|
699
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
700
|
+
get ruleIndex(): number;
|
|
701
|
+
enterRule(listener: JavaListener): void;
|
|
702
|
+
exitRule(listener: JavaListener): void;
|
|
703
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
704
|
+
}
|
|
705
|
+
export declare class TypeTypeOrVoidContext extends ParserRuleContext {
|
|
706
|
+
typeType(): TypeTypeContext | undefined;
|
|
707
|
+
VOID(): TerminalNode | undefined;
|
|
708
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
709
|
+
get ruleIndex(): number;
|
|
710
|
+
enterRule(listener: JavaListener): void;
|
|
711
|
+
exitRule(listener: JavaListener): void;
|
|
712
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
713
|
+
}
|
|
714
|
+
export declare class GenericMethodDeclarationContext extends ParserRuleContext {
|
|
715
|
+
typeParameters(): TypeParametersContext;
|
|
716
|
+
methodDeclaration(): MethodDeclarationContext;
|
|
717
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
718
|
+
get ruleIndex(): number;
|
|
719
|
+
enterRule(listener: JavaListener): void;
|
|
720
|
+
exitRule(listener: JavaListener): void;
|
|
721
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
722
|
+
}
|
|
723
|
+
export declare class GenericConstructorDeclarationContext extends ParserRuleContext {
|
|
724
|
+
typeParameters(): TypeParametersContext;
|
|
725
|
+
constructorDeclaration(): ConstructorDeclarationContext;
|
|
726
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
727
|
+
get ruleIndex(): number;
|
|
728
|
+
enterRule(listener: JavaListener): void;
|
|
729
|
+
exitRule(listener: JavaListener): void;
|
|
730
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
731
|
+
}
|
|
732
|
+
export declare class ConstructorDeclarationContext extends ParserRuleContext {
|
|
733
|
+
_constructorBody: BlockContext;
|
|
734
|
+
identifier(): IdentifierContext;
|
|
735
|
+
formalParameters(): FormalParametersContext;
|
|
736
|
+
block(): BlockContext;
|
|
737
|
+
THROWS(): TerminalNode | undefined;
|
|
738
|
+
qualifiedNameList(): QualifiedNameListContext | undefined;
|
|
739
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
740
|
+
get ruleIndex(): number;
|
|
741
|
+
enterRule(listener: JavaListener): void;
|
|
742
|
+
exitRule(listener: JavaListener): void;
|
|
743
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
744
|
+
}
|
|
745
|
+
export declare class CompactConstructorDeclarationContext extends ParserRuleContext {
|
|
746
|
+
_constructorBody: BlockContext;
|
|
747
|
+
identifier(): IdentifierContext;
|
|
748
|
+
block(): BlockContext;
|
|
749
|
+
modifier(): ModifierContext[];
|
|
750
|
+
modifier(i: number): ModifierContext;
|
|
751
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
752
|
+
get ruleIndex(): number;
|
|
753
|
+
enterRule(listener: JavaListener): void;
|
|
754
|
+
exitRule(listener: JavaListener): void;
|
|
755
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
756
|
+
}
|
|
757
|
+
export declare class FieldDeclarationContext extends ParserRuleContext {
|
|
758
|
+
typeType(): TypeTypeContext;
|
|
759
|
+
variableDeclarators(): VariableDeclaratorsContext;
|
|
760
|
+
SEMI(): TerminalNode;
|
|
761
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
762
|
+
get ruleIndex(): number;
|
|
763
|
+
enterRule(listener: JavaListener): void;
|
|
764
|
+
exitRule(listener: JavaListener): void;
|
|
765
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
766
|
+
}
|
|
767
|
+
export declare class InterfaceBodyDeclarationContext extends ParserRuleContext {
|
|
768
|
+
interfaceMemberDeclaration(): InterfaceMemberDeclarationContext | undefined;
|
|
769
|
+
modifier(): ModifierContext[];
|
|
770
|
+
modifier(i: number): ModifierContext;
|
|
771
|
+
SEMI(): TerminalNode | undefined;
|
|
772
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
773
|
+
get ruleIndex(): number;
|
|
774
|
+
enterRule(listener: JavaListener): void;
|
|
775
|
+
exitRule(listener: JavaListener): void;
|
|
776
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
777
|
+
}
|
|
778
|
+
export declare class InterfaceMemberDeclarationContext extends ParserRuleContext {
|
|
779
|
+
constDeclaration(): ConstDeclarationContext | undefined;
|
|
780
|
+
interfaceMethodDeclaration(): InterfaceMethodDeclarationContext | undefined;
|
|
781
|
+
genericInterfaceMethodDeclaration(): GenericInterfaceMethodDeclarationContext | undefined;
|
|
782
|
+
interfaceDeclaration(): InterfaceDeclarationContext | undefined;
|
|
783
|
+
annotationTypeDeclaration(): AnnotationTypeDeclarationContext | undefined;
|
|
784
|
+
classDeclaration(): ClassDeclarationContext | undefined;
|
|
785
|
+
enumDeclaration(): EnumDeclarationContext | undefined;
|
|
786
|
+
recordDeclaration(): RecordDeclarationContext | undefined;
|
|
787
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
788
|
+
get ruleIndex(): number;
|
|
789
|
+
enterRule(listener: JavaListener): void;
|
|
790
|
+
exitRule(listener: JavaListener): void;
|
|
791
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
792
|
+
}
|
|
793
|
+
export declare class ConstDeclarationContext extends ParserRuleContext {
|
|
794
|
+
typeType(): TypeTypeContext;
|
|
795
|
+
constantDeclarator(): ConstantDeclaratorContext[];
|
|
796
|
+
constantDeclarator(i: number): ConstantDeclaratorContext;
|
|
797
|
+
SEMI(): TerminalNode;
|
|
798
|
+
COMMA(): TerminalNode[];
|
|
799
|
+
COMMA(i: number): TerminalNode;
|
|
800
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
801
|
+
get ruleIndex(): number;
|
|
802
|
+
enterRule(listener: JavaListener): void;
|
|
803
|
+
exitRule(listener: JavaListener): void;
|
|
804
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
805
|
+
}
|
|
806
|
+
export declare class ConstantDeclaratorContext extends ParserRuleContext {
|
|
807
|
+
identifier(): IdentifierContext;
|
|
808
|
+
ASSIGN(): TerminalNode;
|
|
809
|
+
variableInitializer(): VariableInitializerContext;
|
|
810
|
+
LBRACK(): TerminalNode[];
|
|
811
|
+
LBRACK(i: number): TerminalNode;
|
|
812
|
+
RBRACK(): TerminalNode[];
|
|
813
|
+
RBRACK(i: number): TerminalNode;
|
|
814
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
815
|
+
get ruleIndex(): number;
|
|
816
|
+
enterRule(listener: JavaListener): void;
|
|
817
|
+
exitRule(listener: JavaListener): void;
|
|
818
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
819
|
+
}
|
|
820
|
+
export declare class InterfaceMethodDeclarationContext extends ParserRuleContext {
|
|
821
|
+
interfaceCommonBodyDeclaration(): InterfaceCommonBodyDeclarationContext;
|
|
822
|
+
interfaceMethodModifier(): InterfaceMethodModifierContext[];
|
|
823
|
+
interfaceMethodModifier(i: number): InterfaceMethodModifierContext;
|
|
824
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
825
|
+
get ruleIndex(): number;
|
|
826
|
+
enterRule(listener: JavaListener): void;
|
|
827
|
+
exitRule(listener: JavaListener): void;
|
|
828
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
829
|
+
}
|
|
830
|
+
export declare class InterfaceMethodModifierContext extends ParserRuleContext {
|
|
831
|
+
annotation(): AnnotationContext | undefined;
|
|
832
|
+
PUBLIC(): TerminalNode | undefined;
|
|
833
|
+
ABSTRACT(): TerminalNode | undefined;
|
|
834
|
+
DEFAULT(): TerminalNode | undefined;
|
|
835
|
+
STATIC(): TerminalNode | undefined;
|
|
836
|
+
STRICTFP(): TerminalNode | undefined;
|
|
837
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
838
|
+
get ruleIndex(): number;
|
|
839
|
+
enterRule(listener: JavaListener): void;
|
|
840
|
+
exitRule(listener: JavaListener): void;
|
|
841
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
842
|
+
}
|
|
843
|
+
export declare class GenericInterfaceMethodDeclarationContext extends ParserRuleContext {
|
|
844
|
+
typeParameters(): TypeParametersContext;
|
|
845
|
+
interfaceCommonBodyDeclaration(): InterfaceCommonBodyDeclarationContext;
|
|
846
|
+
interfaceMethodModifier(): InterfaceMethodModifierContext[];
|
|
847
|
+
interfaceMethodModifier(i: number): InterfaceMethodModifierContext;
|
|
848
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
849
|
+
get ruleIndex(): number;
|
|
850
|
+
enterRule(listener: JavaListener): void;
|
|
851
|
+
exitRule(listener: JavaListener): void;
|
|
852
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
853
|
+
}
|
|
854
|
+
export declare class InterfaceCommonBodyDeclarationContext extends ParserRuleContext {
|
|
855
|
+
typeTypeOrVoid(): TypeTypeOrVoidContext;
|
|
856
|
+
identifier(): IdentifierContext;
|
|
857
|
+
formalParameters(): FormalParametersContext;
|
|
858
|
+
methodBody(): MethodBodyContext;
|
|
859
|
+
annotation(): AnnotationContext[];
|
|
860
|
+
annotation(i: number): AnnotationContext;
|
|
861
|
+
LBRACK(): TerminalNode[];
|
|
862
|
+
LBRACK(i: number): TerminalNode;
|
|
863
|
+
RBRACK(): TerminalNode[];
|
|
864
|
+
RBRACK(i: number): TerminalNode;
|
|
865
|
+
THROWS(): TerminalNode | undefined;
|
|
866
|
+
qualifiedNameList(): QualifiedNameListContext | undefined;
|
|
867
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
868
|
+
get ruleIndex(): number;
|
|
869
|
+
enterRule(listener: JavaListener): void;
|
|
870
|
+
exitRule(listener: JavaListener): void;
|
|
871
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
872
|
+
}
|
|
873
|
+
export declare class VariableDeclaratorsContext extends ParserRuleContext {
|
|
874
|
+
variableDeclarator(): VariableDeclaratorContext[];
|
|
875
|
+
variableDeclarator(i: number): VariableDeclaratorContext;
|
|
876
|
+
COMMA(): TerminalNode[];
|
|
877
|
+
COMMA(i: number): TerminalNode;
|
|
878
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
879
|
+
get ruleIndex(): number;
|
|
880
|
+
enterRule(listener: JavaListener): void;
|
|
881
|
+
exitRule(listener: JavaListener): void;
|
|
882
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
883
|
+
}
|
|
884
|
+
export declare class VariableDeclaratorContext extends ParserRuleContext {
|
|
885
|
+
variableDeclaratorId(): VariableDeclaratorIdContext;
|
|
886
|
+
ASSIGN(): TerminalNode | undefined;
|
|
887
|
+
variableInitializer(): VariableInitializerContext | undefined;
|
|
888
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
889
|
+
get ruleIndex(): number;
|
|
890
|
+
enterRule(listener: JavaListener): void;
|
|
891
|
+
exitRule(listener: JavaListener): void;
|
|
892
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
893
|
+
}
|
|
894
|
+
export declare class VariableDeclaratorIdContext extends ParserRuleContext {
|
|
895
|
+
identifier(): IdentifierContext;
|
|
896
|
+
LBRACK(): TerminalNode[];
|
|
897
|
+
LBRACK(i: number): TerminalNode;
|
|
898
|
+
RBRACK(): TerminalNode[];
|
|
899
|
+
RBRACK(i: number): TerminalNode;
|
|
900
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
901
|
+
get ruleIndex(): number;
|
|
902
|
+
enterRule(listener: JavaListener): void;
|
|
903
|
+
exitRule(listener: JavaListener): void;
|
|
904
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
905
|
+
}
|
|
906
|
+
export declare class VariableInitializerContext extends ParserRuleContext {
|
|
907
|
+
arrayInitializer(): ArrayInitializerContext | undefined;
|
|
908
|
+
expression(): ExpressionContext | undefined;
|
|
909
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
910
|
+
get ruleIndex(): number;
|
|
911
|
+
enterRule(listener: JavaListener): void;
|
|
912
|
+
exitRule(listener: JavaListener): void;
|
|
913
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
914
|
+
}
|
|
915
|
+
export declare class ArrayInitializerContext extends ParserRuleContext {
|
|
916
|
+
LBRACE(): TerminalNode;
|
|
917
|
+
RBRACE(): TerminalNode;
|
|
918
|
+
variableInitializer(): VariableInitializerContext[];
|
|
919
|
+
variableInitializer(i: number): VariableInitializerContext;
|
|
920
|
+
COMMA(): TerminalNode[];
|
|
921
|
+
COMMA(i: number): TerminalNode;
|
|
922
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
923
|
+
get ruleIndex(): number;
|
|
924
|
+
enterRule(listener: JavaListener): void;
|
|
925
|
+
exitRule(listener: JavaListener): void;
|
|
926
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
927
|
+
}
|
|
928
|
+
export declare class ClassOrInterfaceTypeContext extends ParserRuleContext {
|
|
929
|
+
typeIdentifier(): TypeIdentifierContext;
|
|
930
|
+
identifier(): IdentifierContext[];
|
|
931
|
+
identifier(i: number): IdentifierContext;
|
|
932
|
+
DOT(): TerminalNode[];
|
|
933
|
+
DOT(i: number): TerminalNode;
|
|
934
|
+
typeArguments(): TypeArgumentsContext[];
|
|
935
|
+
typeArguments(i: number): TypeArgumentsContext;
|
|
936
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
937
|
+
get ruleIndex(): number;
|
|
938
|
+
enterRule(listener: JavaListener): void;
|
|
939
|
+
exitRule(listener: JavaListener): void;
|
|
940
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
941
|
+
}
|
|
942
|
+
export declare class TypeArgumentContext extends ParserRuleContext {
|
|
943
|
+
typeType(): TypeTypeContext | undefined;
|
|
944
|
+
QUESTION(): TerminalNode | undefined;
|
|
945
|
+
annotation(): AnnotationContext[];
|
|
946
|
+
annotation(i: number): AnnotationContext;
|
|
947
|
+
EXTENDS(): TerminalNode | undefined;
|
|
948
|
+
SUPER(): TerminalNode | undefined;
|
|
949
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
950
|
+
get ruleIndex(): number;
|
|
951
|
+
enterRule(listener: JavaListener): void;
|
|
952
|
+
exitRule(listener: JavaListener): void;
|
|
953
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
954
|
+
}
|
|
955
|
+
export declare class QualifiedNameListContext extends ParserRuleContext {
|
|
956
|
+
qualifiedName(): QualifiedNameContext[];
|
|
957
|
+
qualifiedName(i: number): QualifiedNameContext;
|
|
958
|
+
COMMA(): TerminalNode[];
|
|
959
|
+
COMMA(i: number): TerminalNode;
|
|
960
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
961
|
+
get ruleIndex(): number;
|
|
962
|
+
enterRule(listener: JavaListener): void;
|
|
963
|
+
exitRule(listener: JavaListener): void;
|
|
964
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
965
|
+
}
|
|
966
|
+
export declare class FormalParametersContext extends ParserRuleContext {
|
|
967
|
+
LPAREN(): TerminalNode;
|
|
968
|
+
RPAREN(): TerminalNode;
|
|
969
|
+
receiverParameter(): ReceiverParameterContext | undefined;
|
|
970
|
+
COMMA(): TerminalNode | undefined;
|
|
971
|
+
formalParameterList(): FormalParameterListContext | undefined;
|
|
972
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
973
|
+
get ruleIndex(): number;
|
|
974
|
+
enterRule(listener: JavaListener): void;
|
|
975
|
+
exitRule(listener: JavaListener): void;
|
|
976
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
977
|
+
}
|
|
978
|
+
export declare class ReceiverParameterContext extends ParserRuleContext {
|
|
979
|
+
typeType(): TypeTypeContext;
|
|
980
|
+
THIS(): TerminalNode;
|
|
981
|
+
identifier(): IdentifierContext[];
|
|
982
|
+
identifier(i: number): IdentifierContext;
|
|
983
|
+
DOT(): TerminalNode[];
|
|
984
|
+
DOT(i: number): TerminalNode;
|
|
985
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
986
|
+
get ruleIndex(): number;
|
|
987
|
+
enterRule(listener: JavaListener): void;
|
|
988
|
+
exitRule(listener: JavaListener): void;
|
|
989
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
990
|
+
}
|
|
991
|
+
export declare class FormalParameterListContext extends ParserRuleContext {
|
|
992
|
+
formalParameter(): FormalParameterContext[];
|
|
993
|
+
formalParameter(i: number): FormalParameterContext;
|
|
994
|
+
COMMA(): TerminalNode[];
|
|
995
|
+
COMMA(i: number): TerminalNode;
|
|
996
|
+
lastFormalParameter(): LastFormalParameterContext | undefined;
|
|
997
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
998
|
+
get ruleIndex(): number;
|
|
999
|
+
enterRule(listener: JavaListener): void;
|
|
1000
|
+
exitRule(listener: JavaListener): void;
|
|
1001
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1002
|
+
}
|
|
1003
|
+
export declare class FormalParameterContext extends ParserRuleContext {
|
|
1004
|
+
typeType(): TypeTypeContext;
|
|
1005
|
+
variableDeclaratorId(): VariableDeclaratorIdContext;
|
|
1006
|
+
variableModifier(): VariableModifierContext[];
|
|
1007
|
+
variableModifier(i: number): VariableModifierContext;
|
|
1008
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1009
|
+
get ruleIndex(): number;
|
|
1010
|
+
enterRule(listener: JavaListener): void;
|
|
1011
|
+
exitRule(listener: JavaListener): void;
|
|
1012
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1013
|
+
}
|
|
1014
|
+
export declare class LastFormalParameterContext extends ParserRuleContext {
|
|
1015
|
+
typeType(): TypeTypeContext;
|
|
1016
|
+
ELLIPSIS(): TerminalNode;
|
|
1017
|
+
variableDeclaratorId(): VariableDeclaratorIdContext;
|
|
1018
|
+
variableModifier(): VariableModifierContext[];
|
|
1019
|
+
variableModifier(i: number): VariableModifierContext;
|
|
1020
|
+
annotation(): AnnotationContext[];
|
|
1021
|
+
annotation(i: number): AnnotationContext;
|
|
1022
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1023
|
+
get ruleIndex(): number;
|
|
1024
|
+
enterRule(listener: JavaListener): void;
|
|
1025
|
+
exitRule(listener: JavaListener): void;
|
|
1026
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1027
|
+
}
|
|
1028
|
+
export declare class LambdaLVTIListContext extends ParserRuleContext {
|
|
1029
|
+
lambdaLVTIParameter(): LambdaLVTIParameterContext[];
|
|
1030
|
+
lambdaLVTIParameter(i: number): LambdaLVTIParameterContext;
|
|
1031
|
+
COMMA(): TerminalNode[];
|
|
1032
|
+
COMMA(i: number): TerminalNode;
|
|
1033
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1034
|
+
get ruleIndex(): number;
|
|
1035
|
+
enterRule(listener: JavaListener): void;
|
|
1036
|
+
exitRule(listener: JavaListener): void;
|
|
1037
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1038
|
+
}
|
|
1039
|
+
export declare class LambdaLVTIParameterContext extends ParserRuleContext {
|
|
1040
|
+
VAR(): TerminalNode;
|
|
1041
|
+
identifier(): IdentifierContext;
|
|
1042
|
+
variableModifier(): VariableModifierContext[];
|
|
1043
|
+
variableModifier(i: number): VariableModifierContext;
|
|
1044
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1045
|
+
get ruleIndex(): number;
|
|
1046
|
+
enterRule(listener: JavaListener): void;
|
|
1047
|
+
exitRule(listener: JavaListener): void;
|
|
1048
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1049
|
+
}
|
|
1050
|
+
export declare class QualifiedNameContext extends ParserRuleContext {
|
|
1051
|
+
identifier(): IdentifierContext[];
|
|
1052
|
+
identifier(i: number): IdentifierContext;
|
|
1053
|
+
DOT(): TerminalNode[];
|
|
1054
|
+
DOT(i: number): TerminalNode;
|
|
1055
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1056
|
+
get ruleIndex(): number;
|
|
1057
|
+
enterRule(listener: JavaListener): void;
|
|
1058
|
+
exitRule(listener: JavaListener): void;
|
|
1059
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1060
|
+
}
|
|
1061
|
+
export declare class LiteralContext extends ParserRuleContext {
|
|
1062
|
+
integerLiteral(): IntegerLiteralContext | undefined;
|
|
1063
|
+
floatLiteral(): FloatLiteralContext | undefined;
|
|
1064
|
+
CHAR_LITERAL(): TerminalNode | undefined;
|
|
1065
|
+
STRING_LITERAL(): TerminalNode | undefined;
|
|
1066
|
+
BOOL_LITERAL(): TerminalNode | undefined;
|
|
1067
|
+
NULL_LITERAL(): TerminalNode | undefined;
|
|
1068
|
+
TEXT_BLOCK(): TerminalNode | undefined;
|
|
1069
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1070
|
+
get ruleIndex(): number;
|
|
1071
|
+
enterRule(listener: JavaListener): void;
|
|
1072
|
+
exitRule(listener: JavaListener): void;
|
|
1073
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1074
|
+
}
|
|
1075
|
+
export declare class IntegerLiteralContext extends ParserRuleContext {
|
|
1076
|
+
DECIMAL_LITERAL(): TerminalNode | undefined;
|
|
1077
|
+
HEX_LITERAL(): TerminalNode | undefined;
|
|
1078
|
+
OCT_LITERAL(): TerminalNode | undefined;
|
|
1079
|
+
BINARY_LITERAL(): TerminalNode | undefined;
|
|
1080
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1081
|
+
get ruleIndex(): number;
|
|
1082
|
+
enterRule(listener: JavaListener): void;
|
|
1083
|
+
exitRule(listener: JavaListener): void;
|
|
1084
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1085
|
+
}
|
|
1086
|
+
export declare class FloatLiteralContext extends ParserRuleContext {
|
|
1087
|
+
FLOAT_LITERAL(): TerminalNode | undefined;
|
|
1088
|
+
HEX_FLOAT_LITERAL(): TerminalNode | undefined;
|
|
1089
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1090
|
+
get ruleIndex(): number;
|
|
1091
|
+
enterRule(listener: JavaListener): void;
|
|
1092
|
+
exitRule(listener: JavaListener): void;
|
|
1093
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1094
|
+
}
|
|
1095
|
+
export declare class AltAnnotationQualifiedNameContext extends ParserRuleContext {
|
|
1096
|
+
AT(): TerminalNode;
|
|
1097
|
+
identifier(): IdentifierContext[];
|
|
1098
|
+
identifier(i: number): IdentifierContext;
|
|
1099
|
+
DOT(): TerminalNode[];
|
|
1100
|
+
DOT(i: number): TerminalNode;
|
|
1101
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1102
|
+
get ruleIndex(): number;
|
|
1103
|
+
enterRule(listener: JavaListener): void;
|
|
1104
|
+
exitRule(listener: JavaListener): void;
|
|
1105
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1106
|
+
}
|
|
1107
|
+
export declare class AnnotationContext extends ParserRuleContext {
|
|
1108
|
+
AT(): TerminalNode | undefined;
|
|
1109
|
+
qualifiedName(): QualifiedNameContext | undefined;
|
|
1110
|
+
altAnnotationQualifiedName(): AltAnnotationQualifiedNameContext | undefined;
|
|
1111
|
+
LPAREN(): TerminalNode | undefined;
|
|
1112
|
+
RPAREN(): TerminalNode | undefined;
|
|
1113
|
+
elementValuePairs(): ElementValuePairsContext | undefined;
|
|
1114
|
+
elementValue(): ElementValueContext | undefined;
|
|
1115
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1116
|
+
get ruleIndex(): number;
|
|
1117
|
+
enterRule(listener: JavaListener): void;
|
|
1118
|
+
exitRule(listener: JavaListener): void;
|
|
1119
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1120
|
+
}
|
|
1121
|
+
export declare class ElementValuePairsContext extends ParserRuleContext {
|
|
1122
|
+
elementValuePair(): ElementValuePairContext[];
|
|
1123
|
+
elementValuePair(i: number): ElementValuePairContext;
|
|
1124
|
+
COMMA(): TerminalNode[];
|
|
1125
|
+
COMMA(i: number): TerminalNode;
|
|
1126
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1127
|
+
get ruleIndex(): number;
|
|
1128
|
+
enterRule(listener: JavaListener): void;
|
|
1129
|
+
exitRule(listener: JavaListener): void;
|
|
1130
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1131
|
+
}
|
|
1132
|
+
export declare class ElementValuePairContext extends ParserRuleContext {
|
|
1133
|
+
identifier(): IdentifierContext;
|
|
1134
|
+
ASSIGN(): TerminalNode;
|
|
1135
|
+
elementValue(): ElementValueContext;
|
|
1136
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1137
|
+
get ruleIndex(): number;
|
|
1138
|
+
enterRule(listener: JavaListener): void;
|
|
1139
|
+
exitRule(listener: JavaListener): void;
|
|
1140
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1141
|
+
}
|
|
1142
|
+
export declare class ElementValueContext extends ParserRuleContext {
|
|
1143
|
+
expression(): ExpressionContext | undefined;
|
|
1144
|
+
annotation(): AnnotationContext | undefined;
|
|
1145
|
+
elementValueArrayInitializer(): ElementValueArrayInitializerContext | undefined;
|
|
1146
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1147
|
+
get ruleIndex(): number;
|
|
1148
|
+
enterRule(listener: JavaListener): void;
|
|
1149
|
+
exitRule(listener: JavaListener): void;
|
|
1150
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1151
|
+
}
|
|
1152
|
+
export declare class ElementValueArrayInitializerContext extends ParserRuleContext {
|
|
1153
|
+
LBRACE(): TerminalNode;
|
|
1154
|
+
RBRACE(): TerminalNode;
|
|
1155
|
+
elementValue(): ElementValueContext[];
|
|
1156
|
+
elementValue(i: number): ElementValueContext;
|
|
1157
|
+
COMMA(): TerminalNode[];
|
|
1158
|
+
COMMA(i: number): TerminalNode;
|
|
1159
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1160
|
+
get ruleIndex(): number;
|
|
1161
|
+
enterRule(listener: JavaListener): void;
|
|
1162
|
+
exitRule(listener: JavaListener): void;
|
|
1163
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1164
|
+
}
|
|
1165
|
+
export declare class AnnotationTypeDeclarationContext extends ParserRuleContext {
|
|
1166
|
+
AT(): TerminalNode;
|
|
1167
|
+
INTERFACE(): TerminalNode;
|
|
1168
|
+
identifier(): IdentifierContext;
|
|
1169
|
+
annotationTypeBody(): AnnotationTypeBodyContext;
|
|
1170
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1171
|
+
get ruleIndex(): number;
|
|
1172
|
+
enterRule(listener: JavaListener): void;
|
|
1173
|
+
exitRule(listener: JavaListener): void;
|
|
1174
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1175
|
+
}
|
|
1176
|
+
export declare class AnnotationTypeBodyContext extends ParserRuleContext {
|
|
1177
|
+
LBRACE(): TerminalNode;
|
|
1178
|
+
RBRACE(): TerminalNode;
|
|
1179
|
+
annotationTypeElementDeclaration(): AnnotationTypeElementDeclarationContext[];
|
|
1180
|
+
annotationTypeElementDeclaration(i: number): AnnotationTypeElementDeclarationContext;
|
|
1181
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1182
|
+
get ruleIndex(): number;
|
|
1183
|
+
enterRule(listener: JavaListener): void;
|
|
1184
|
+
exitRule(listener: JavaListener): void;
|
|
1185
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1186
|
+
}
|
|
1187
|
+
export declare class AnnotationTypeElementDeclarationContext extends ParserRuleContext {
|
|
1188
|
+
annotationTypeElementRest(): AnnotationTypeElementRestContext | undefined;
|
|
1189
|
+
modifier(): ModifierContext[];
|
|
1190
|
+
modifier(i: number): ModifierContext;
|
|
1191
|
+
SEMI(): TerminalNode | undefined;
|
|
1192
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1193
|
+
get ruleIndex(): number;
|
|
1194
|
+
enterRule(listener: JavaListener): void;
|
|
1195
|
+
exitRule(listener: JavaListener): void;
|
|
1196
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1197
|
+
}
|
|
1198
|
+
export declare class AnnotationTypeElementRestContext extends ParserRuleContext {
|
|
1199
|
+
typeType(): TypeTypeContext | undefined;
|
|
1200
|
+
annotationMethodOrConstantRest(): AnnotationMethodOrConstantRestContext | undefined;
|
|
1201
|
+
SEMI(): TerminalNode | undefined;
|
|
1202
|
+
classDeclaration(): ClassDeclarationContext | undefined;
|
|
1203
|
+
interfaceDeclaration(): InterfaceDeclarationContext | undefined;
|
|
1204
|
+
enumDeclaration(): EnumDeclarationContext | undefined;
|
|
1205
|
+
annotationTypeDeclaration(): AnnotationTypeDeclarationContext | undefined;
|
|
1206
|
+
recordDeclaration(): RecordDeclarationContext | undefined;
|
|
1207
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1208
|
+
get ruleIndex(): number;
|
|
1209
|
+
enterRule(listener: JavaListener): void;
|
|
1210
|
+
exitRule(listener: JavaListener): void;
|
|
1211
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1212
|
+
}
|
|
1213
|
+
export declare class AnnotationMethodOrConstantRestContext extends ParserRuleContext {
|
|
1214
|
+
annotationMethodRest(): AnnotationMethodRestContext | undefined;
|
|
1215
|
+
annotationConstantRest(): AnnotationConstantRestContext | undefined;
|
|
1216
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1217
|
+
get ruleIndex(): number;
|
|
1218
|
+
enterRule(listener: JavaListener): void;
|
|
1219
|
+
exitRule(listener: JavaListener): void;
|
|
1220
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1221
|
+
}
|
|
1222
|
+
export declare class AnnotationMethodRestContext extends ParserRuleContext {
|
|
1223
|
+
identifier(): IdentifierContext;
|
|
1224
|
+
LPAREN(): TerminalNode;
|
|
1225
|
+
RPAREN(): TerminalNode;
|
|
1226
|
+
defaultValue(): DefaultValueContext | undefined;
|
|
1227
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1228
|
+
get ruleIndex(): number;
|
|
1229
|
+
enterRule(listener: JavaListener): void;
|
|
1230
|
+
exitRule(listener: JavaListener): void;
|
|
1231
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1232
|
+
}
|
|
1233
|
+
export declare class AnnotationConstantRestContext extends ParserRuleContext {
|
|
1234
|
+
variableDeclarators(): VariableDeclaratorsContext;
|
|
1235
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1236
|
+
get ruleIndex(): number;
|
|
1237
|
+
enterRule(listener: JavaListener): void;
|
|
1238
|
+
exitRule(listener: JavaListener): void;
|
|
1239
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1240
|
+
}
|
|
1241
|
+
export declare class DefaultValueContext extends ParserRuleContext {
|
|
1242
|
+
DEFAULT(): TerminalNode;
|
|
1243
|
+
elementValue(): ElementValueContext;
|
|
1244
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1245
|
+
get ruleIndex(): number;
|
|
1246
|
+
enterRule(listener: JavaListener): void;
|
|
1247
|
+
exitRule(listener: JavaListener): void;
|
|
1248
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1249
|
+
}
|
|
1250
|
+
export declare class ModuleDeclarationContext extends ParserRuleContext {
|
|
1251
|
+
MODULE(): TerminalNode;
|
|
1252
|
+
qualifiedName(): QualifiedNameContext;
|
|
1253
|
+
moduleBody(): ModuleBodyContext;
|
|
1254
|
+
OPEN(): TerminalNode | undefined;
|
|
1255
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1256
|
+
get ruleIndex(): number;
|
|
1257
|
+
enterRule(listener: JavaListener): void;
|
|
1258
|
+
exitRule(listener: JavaListener): void;
|
|
1259
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1260
|
+
}
|
|
1261
|
+
export declare class ModuleBodyContext extends ParserRuleContext {
|
|
1262
|
+
LBRACE(): TerminalNode;
|
|
1263
|
+
RBRACE(): TerminalNode;
|
|
1264
|
+
moduleDirective(): ModuleDirectiveContext[];
|
|
1265
|
+
moduleDirective(i: number): ModuleDirectiveContext;
|
|
1266
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1267
|
+
get ruleIndex(): number;
|
|
1268
|
+
enterRule(listener: JavaListener): void;
|
|
1269
|
+
exitRule(listener: JavaListener): void;
|
|
1270
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1271
|
+
}
|
|
1272
|
+
export declare class ModuleDirectiveContext extends ParserRuleContext {
|
|
1273
|
+
REQUIRES(): TerminalNode | undefined;
|
|
1274
|
+
qualifiedName(): QualifiedNameContext[];
|
|
1275
|
+
qualifiedName(i: number): QualifiedNameContext;
|
|
1276
|
+
SEMI(): TerminalNode;
|
|
1277
|
+
requiresModifier(): RequiresModifierContext[];
|
|
1278
|
+
requiresModifier(i: number): RequiresModifierContext;
|
|
1279
|
+
EXPORTS(): TerminalNode | undefined;
|
|
1280
|
+
TO(): TerminalNode | undefined;
|
|
1281
|
+
OPENS(): TerminalNode | undefined;
|
|
1282
|
+
USES(): TerminalNode | undefined;
|
|
1283
|
+
PROVIDES(): TerminalNode | undefined;
|
|
1284
|
+
WITH(): TerminalNode | undefined;
|
|
1285
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1286
|
+
get ruleIndex(): number;
|
|
1287
|
+
enterRule(listener: JavaListener): void;
|
|
1288
|
+
exitRule(listener: JavaListener): void;
|
|
1289
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1290
|
+
}
|
|
1291
|
+
export declare class RequiresModifierContext extends ParserRuleContext {
|
|
1292
|
+
TRANSITIVE(): TerminalNode | undefined;
|
|
1293
|
+
STATIC(): TerminalNode | undefined;
|
|
1294
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1295
|
+
get ruleIndex(): number;
|
|
1296
|
+
enterRule(listener: JavaListener): void;
|
|
1297
|
+
exitRule(listener: JavaListener): void;
|
|
1298
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1299
|
+
}
|
|
1300
|
+
export declare class RecordDeclarationContext extends ParserRuleContext {
|
|
1301
|
+
RECORD(): TerminalNode;
|
|
1302
|
+
identifier(): IdentifierContext;
|
|
1303
|
+
recordHeader(): RecordHeaderContext;
|
|
1304
|
+
recordBody(): RecordBodyContext;
|
|
1305
|
+
typeParameters(): TypeParametersContext | undefined;
|
|
1306
|
+
IMPLEMENTS(): TerminalNode | undefined;
|
|
1307
|
+
typeList(): TypeListContext | undefined;
|
|
1308
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1309
|
+
get ruleIndex(): number;
|
|
1310
|
+
enterRule(listener: JavaListener): void;
|
|
1311
|
+
exitRule(listener: JavaListener): void;
|
|
1312
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1313
|
+
}
|
|
1314
|
+
export declare class RecordHeaderContext extends ParserRuleContext {
|
|
1315
|
+
LPAREN(): TerminalNode;
|
|
1316
|
+
RPAREN(): TerminalNode;
|
|
1317
|
+
recordComponentList(): RecordComponentListContext | undefined;
|
|
1318
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1319
|
+
get ruleIndex(): number;
|
|
1320
|
+
enterRule(listener: JavaListener): void;
|
|
1321
|
+
exitRule(listener: JavaListener): void;
|
|
1322
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1323
|
+
}
|
|
1324
|
+
export declare class RecordComponentListContext extends ParserRuleContext {
|
|
1325
|
+
recordComponent(): RecordComponentContext[];
|
|
1326
|
+
recordComponent(i: number): RecordComponentContext;
|
|
1327
|
+
COMMA(): TerminalNode[];
|
|
1328
|
+
COMMA(i: number): TerminalNode;
|
|
1329
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1330
|
+
get ruleIndex(): number;
|
|
1331
|
+
enterRule(listener: JavaListener): void;
|
|
1332
|
+
exitRule(listener: JavaListener): void;
|
|
1333
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1334
|
+
}
|
|
1335
|
+
export declare class RecordComponentContext extends ParserRuleContext {
|
|
1336
|
+
typeType(): TypeTypeContext;
|
|
1337
|
+
identifier(): IdentifierContext;
|
|
1338
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1339
|
+
get ruleIndex(): number;
|
|
1340
|
+
enterRule(listener: JavaListener): void;
|
|
1341
|
+
exitRule(listener: JavaListener): void;
|
|
1342
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1343
|
+
}
|
|
1344
|
+
export declare class RecordBodyContext extends ParserRuleContext {
|
|
1345
|
+
LBRACE(): TerminalNode;
|
|
1346
|
+
RBRACE(): TerminalNode;
|
|
1347
|
+
classBodyDeclaration(): ClassBodyDeclarationContext[];
|
|
1348
|
+
classBodyDeclaration(i: number): ClassBodyDeclarationContext;
|
|
1349
|
+
compactConstructorDeclaration(): CompactConstructorDeclarationContext[];
|
|
1350
|
+
compactConstructorDeclaration(i: number): CompactConstructorDeclarationContext;
|
|
1351
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1352
|
+
get ruleIndex(): number;
|
|
1353
|
+
enterRule(listener: JavaListener): void;
|
|
1354
|
+
exitRule(listener: JavaListener): void;
|
|
1355
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1356
|
+
}
|
|
1357
|
+
export declare class BlockContext extends ParserRuleContext {
|
|
1358
|
+
LBRACE(): TerminalNode;
|
|
1359
|
+
RBRACE(): TerminalNode;
|
|
1360
|
+
blockStatement(): BlockStatementContext[];
|
|
1361
|
+
blockStatement(i: number): BlockStatementContext;
|
|
1362
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1363
|
+
get ruleIndex(): number;
|
|
1364
|
+
enterRule(listener: JavaListener): void;
|
|
1365
|
+
exitRule(listener: JavaListener): void;
|
|
1366
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1367
|
+
}
|
|
1368
|
+
export declare class BlockStatementContext extends ParserRuleContext {
|
|
1369
|
+
localVariableDeclaration(): LocalVariableDeclarationContext | undefined;
|
|
1370
|
+
SEMI(): TerminalNode | undefined;
|
|
1371
|
+
localTypeDeclaration(): LocalTypeDeclarationContext | undefined;
|
|
1372
|
+
statement(): StatementContext | undefined;
|
|
1373
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1374
|
+
get ruleIndex(): number;
|
|
1375
|
+
enterRule(listener: JavaListener): void;
|
|
1376
|
+
exitRule(listener: JavaListener): void;
|
|
1377
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1378
|
+
}
|
|
1379
|
+
export declare class LocalVariableDeclarationContext extends ParserRuleContext {
|
|
1380
|
+
VAR(): TerminalNode | undefined;
|
|
1381
|
+
identifier(): IdentifierContext | undefined;
|
|
1382
|
+
ASSIGN(): TerminalNode | undefined;
|
|
1383
|
+
expression(): ExpressionContext | undefined;
|
|
1384
|
+
typeType(): TypeTypeContext | undefined;
|
|
1385
|
+
variableDeclarators(): VariableDeclaratorsContext | undefined;
|
|
1386
|
+
variableModifier(): VariableModifierContext[];
|
|
1387
|
+
variableModifier(i: number): VariableModifierContext;
|
|
1388
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1389
|
+
get ruleIndex(): number;
|
|
1390
|
+
enterRule(listener: JavaListener): void;
|
|
1391
|
+
exitRule(listener: JavaListener): void;
|
|
1392
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1393
|
+
}
|
|
1394
|
+
export declare class IdentifierContext extends ParserRuleContext {
|
|
1395
|
+
IDENTIFIER(): TerminalNode | undefined;
|
|
1396
|
+
MODULE(): TerminalNode | undefined;
|
|
1397
|
+
OPEN(): TerminalNode | undefined;
|
|
1398
|
+
REQUIRES(): TerminalNode | undefined;
|
|
1399
|
+
EXPORTS(): TerminalNode | undefined;
|
|
1400
|
+
OPENS(): TerminalNode | undefined;
|
|
1401
|
+
TO(): TerminalNode | undefined;
|
|
1402
|
+
USES(): TerminalNode | undefined;
|
|
1403
|
+
PROVIDES(): TerminalNode | undefined;
|
|
1404
|
+
WITH(): TerminalNode | undefined;
|
|
1405
|
+
TRANSITIVE(): TerminalNode | undefined;
|
|
1406
|
+
YIELD(): TerminalNode | undefined;
|
|
1407
|
+
SEALED(): TerminalNode | undefined;
|
|
1408
|
+
PERMITS(): TerminalNode | undefined;
|
|
1409
|
+
RECORD(): TerminalNode | undefined;
|
|
1410
|
+
VAR(): TerminalNode | undefined;
|
|
1411
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1412
|
+
get ruleIndex(): number;
|
|
1413
|
+
enterRule(listener: JavaListener): void;
|
|
1414
|
+
exitRule(listener: JavaListener): void;
|
|
1415
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1416
|
+
}
|
|
1417
|
+
export declare class TypeIdentifierContext extends ParserRuleContext {
|
|
1418
|
+
IDENTIFIER(): TerminalNode | undefined;
|
|
1419
|
+
MODULE(): TerminalNode | undefined;
|
|
1420
|
+
OPEN(): TerminalNode | undefined;
|
|
1421
|
+
REQUIRES(): TerminalNode | undefined;
|
|
1422
|
+
EXPORTS(): TerminalNode | undefined;
|
|
1423
|
+
OPENS(): TerminalNode | undefined;
|
|
1424
|
+
TO(): TerminalNode | undefined;
|
|
1425
|
+
USES(): TerminalNode | undefined;
|
|
1426
|
+
PROVIDES(): TerminalNode | undefined;
|
|
1427
|
+
WITH(): TerminalNode | undefined;
|
|
1428
|
+
TRANSITIVE(): TerminalNode | undefined;
|
|
1429
|
+
SEALED(): TerminalNode | undefined;
|
|
1430
|
+
PERMITS(): TerminalNode | undefined;
|
|
1431
|
+
RECORD(): TerminalNode | undefined;
|
|
1432
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1433
|
+
get ruleIndex(): number;
|
|
1434
|
+
enterRule(listener: JavaListener): void;
|
|
1435
|
+
exitRule(listener: JavaListener): void;
|
|
1436
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1437
|
+
}
|
|
1438
|
+
export declare class LocalTypeDeclarationContext extends ParserRuleContext {
|
|
1439
|
+
classDeclaration(): ClassDeclarationContext | undefined;
|
|
1440
|
+
interfaceDeclaration(): InterfaceDeclarationContext | undefined;
|
|
1441
|
+
recordDeclaration(): RecordDeclarationContext | undefined;
|
|
1442
|
+
classOrInterfaceModifier(): ClassOrInterfaceModifierContext[];
|
|
1443
|
+
classOrInterfaceModifier(i: number): ClassOrInterfaceModifierContext;
|
|
1444
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1445
|
+
get ruleIndex(): number;
|
|
1446
|
+
enterRule(listener: JavaListener): void;
|
|
1447
|
+
exitRule(listener: JavaListener): void;
|
|
1448
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1449
|
+
}
|
|
1450
|
+
export declare class StatementContext extends ParserRuleContext {
|
|
1451
|
+
_blockLabel: BlockContext;
|
|
1452
|
+
_statementExpression: ExpressionContext;
|
|
1453
|
+
_identifierLabel: IdentifierContext;
|
|
1454
|
+
block(): BlockContext | undefined;
|
|
1455
|
+
ASSERT(): TerminalNode | undefined;
|
|
1456
|
+
expression(): ExpressionContext[];
|
|
1457
|
+
expression(i: number): ExpressionContext;
|
|
1458
|
+
SEMI(): TerminalNode | undefined;
|
|
1459
|
+
COLON(): TerminalNode | undefined;
|
|
1460
|
+
IF(): TerminalNode | undefined;
|
|
1461
|
+
parExpression(): ParExpressionContext | undefined;
|
|
1462
|
+
statement(): StatementContext[];
|
|
1463
|
+
statement(i: number): StatementContext;
|
|
1464
|
+
ELSE(): TerminalNode | undefined;
|
|
1465
|
+
FOR(): TerminalNode | undefined;
|
|
1466
|
+
LPAREN(): TerminalNode | undefined;
|
|
1467
|
+
forControl(): ForControlContext | undefined;
|
|
1468
|
+
RPAREN(): TerminalNode | undefined;
|
|
1469
|
+
WHILE(): TerminalNode | undefined;
|
|
1470
|
+
DO(): TerminalNode | undefined;
|
|
1471
|
+
TRY(): TerminalNode | undefined;
|
|
1472
|
+
finallyBlock(): FinallyBlockContext | undefined;
|
|
1473
|
+
catchClause(): CatchClauseContext[];
|
|
1474
|
+
catchClause(i: number): CatchClauseContext;
|
|
1475
|
+
resourceSpecification(): ResourceSpecificationContext | undefined;
|
|
1476
|
+
SWITCH(): TerminalNode | undefined;
|
|
1477
|
+
LBRACE(): TerminalNode | undefined;
|
|
1478
|
+
RBRACE(): TerminalNode | undefined;
|
|
1479
|
+
switchBlockStatementGroup(): SwitchBlockStatementGroupContext[];
|
|
1480
|
+
switchBlockStatementGroup(i: number): SwitchBlockStatementGroupContext;
|
|
1481
|
+
switchLabel(): SwitchLabelContext[];
|
|
1482
|
+
switchLabel(i: number): SwitchLabelContext;
|
|
1483
|
+
SYNCHRONIZED(): TerminalNode | undefined;
|
|
1484
|
+
RETURN(): TerminalNode | undefined;
|
|
1485
|
+
THROW(): TerminalNode | undefined;
|
|
1486
|
+
BREAK(): TerminalNode | undefined;
|
|
1487
|
+
identifier(): IdentifierContext | undefined;
|
|
1488
|
+
CONTINUE(): TerminalNode | undefined;
|
|
1489
|
+
YIELD(): TerminalNode | undefined;
|
|
1490
|
+
switchExpression(): SwitchExpressionContext | undefined;
|
|
1491
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1492
|
+
get ruleIndex(): number;
|
|
1493
|
+
enterRule(listener: JavaListener): void;
|
|
1494
|
+
exitRule(listener: JavaListener): void;
|
|
1495
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1496
|
+
}
|
|
1497
|
+
export declare class CatchClauseContext extends ParserRuleContext {
|
|
1498
|
+
CATCH(): TerminalNode;
|
|
1499
|
+
LPAREN(): TerminalNode;
|
|
1500
|
+
catchType(): CatchTypeContext;
|
|
1501
|
+
identifier(): IdentifierContext;
|
|
1502
|
+
RPAREN(): TerminalNode;
|
|
1503
|
+
block(): BlockContext;
|
|
1504
|
+
variableModifier(): VariableModifierContext[];
|
|
1505
|
+
variableModifier(i: number): VariableModifierContext;
|
|
1506
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1507
|
+
get ruleIndex(): number;
|
|
1508
|
+
enterRule(listener: JavaListener): void;
|
|
1509
|
+
exitRule(listener: JavaListener): void;
|
|
1510
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1511
|
+
}
|
|
1512
|
+
export declare class CatchTypeContext extends ParserRuleContext {
|
|
1513
|
+
qualifiedName(): QualifiedNameContext[];
|
|
1514
|
+
qualifiedName(i: number): QualifiedNameContext;
|
|
1515
|
+
BITOR(): TerminalNode[];
|
|
1516
|
+
BITOR(i: number): TerminalNode;
|
|
1517
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1518
|
+
get ruleIndex(): number;
|
|
1519
|
+
enterRule(listener: JavaListener): void;
|
|
1520
|
+
exitRule(listener: JavaListener): void;
|
|
1521
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1522
|
+
}
|
|
1523
|
+
export declare class FinallyBlockContext extends ParserRuleContext {
|
|
1524
|
+
FINALLY(): TerminalNode;
|
|
1525
|
+
block(): BlockContext;
|
|
1526
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1527
|
+
get ruleIndex(): number;
|
|
1528
|
+
enterRule(listener: JavaListener): void;
|
|
1529
|
+
exitRule(listener: JavaListener): void;
|
|
1530
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1531
|
+
}
|
|
1532
|
+
export declare class ResourceSpecificationContext extends ParserRuleContext {
|
|
1533
|
+
LPAREN(): TerminalNode;
|
|
1534
|
+
resources(): ResourcesContext;
|
|
1535
|
+
RPAREN(): TerminalNode;
|
|
1536
|
+
SEMI(): TerminalNode | undefined;
|
|
1537
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1538
|
+
get ruleIndex(): number;
|
|
1539
|
+
enterRule(listener: JavaListener): void;
|
|
1540
|
+
exitRule(listener: JavaListener): void;
|
|
1541
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1542
|
+
}
|
|
1543
|
+
export declare class ResourcesContext extends ParserRuleContext {
|
|
1544
|
+
resource(): ResourceContext[];
|
|
1545
|
+
resource(i: number): ResourceContext;
|
|
1546
|
+
SEMI(): TerminalNode[];
|
|
1547
|
+
SEMI(i: number): TerminalNode;
|
|
1548
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1549
|
+
get ruleIndex(): number;
|
|
1550
|
+
enterRule(listener: JavaListener): void;
|
|
1551
|
+
exitRule(listener: JavaListener): void;
|
|
1552
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1553
|
+
}
|
|
1554
|
+
export declare class ResourceContext extends ParserRuleContext {
|
|
1555
|
+
ASSIGN(): TerminalNode | undefined;
|
|
1556
|
+
expression(): ExpressionContext | undefined;
|
|
1557
|
+
classOrInterfaceType(): ClassOrInterfaceTypeContext | undefined;
|
|
1558
|
+
variableDeclaratorId(): VariableDeclaratorIdContext | undefined;
|
|
1559
|
+
VAR(): TerminalNode | undefined;
|
|
1560
|
+
identifier(): IdentifierContext | undefined;
|
|
1561
|
+
variableModifier(): VariableModifierContext[];
|
|
1562
|
+
variableModifier(i: number): VariableModifierContext;
|
|
1563
|
+
qualifiedName(): QualifiedNameContext | undefined;
|
|
1564
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1565
|
+
get ruleIndex(): number;
|
|
1566
|
+
enterRule(listener: JavaListener): void;
|
|
1567
|
+
exitRule(listener: JavaListener): void;
|
|
1568
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1569
|
+
}
|
|
1570
|
+
export declare class SwitchBlockStatementGroupContext extends ParserRuleContext {
|
|
1571
|
+
switchLabel(): SwitchLabelContext[];
|
|
1572
|
+
switchLabel(i: number): SwitchLabelContext;
|
|
1573
|
+
blockStatement(): BlockStatementContext[];
|
|
1574
|
+
blockStatement(i: number): BlockStatementContext;
|
|
1575
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1576
|
+
get ruleIndex(): number;
|
|
1577
|
+
enterRule(listener: JavaListener): void;
|
|
1578
|
+
exitRule(listener: JavaListener): void;
|
|
1579
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1580
|
+
}
|
|
1581
|
+
export declare class SwitchLabelContext extends ParserRuleContext {
|
|
1582
|
+
_constantExpression: ExpressionContext;
|
|
1583
|
+
_enumConstantName: Token;
|
|
1584
|
+
_varName: IdentifierContext;
|
|
1585
|
+
CASE(): TerminalNode | undefined;
|
|
1586
|
+
COLON(): TerminalNode;
|
|
1587
|
+
typeType(): TypeTypeContext | undefined;
|
|
1588
|
+
expression(): ExpressionContext | undefined;
|
|
1589
|
+
IDENTIFIER(): TerminalNode | undefined;
|
|
1590
|
+
identifier(): IdentifierContext | undefined;
|
|
1591
|
+
DEFAULT(): TerminalNode | undefined;
|
|
1592
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1593
|
+
get ruleIndex(): number;
|
|
1594
|
+
enterRule(listener: JavaListener): void;
|
|
1595
|
+
exitRule(listener: JavaListener): void;
|
|
1596
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1597
|
+
}
|
|
1598
|
+
export declare class ForControlContext extends ParserRuleContext {
|
|
1599
|
+
_forUpdate: ExpressionListContext;
|
|
1600
|
+
enhancedForControl(): EnhancedForControlContext | undefined;
|
|
1601
|
+
SEMI(): TerminalNode[];
|
|
1602
|
+
SEMI(i: number): TerminalNode;
|
|
1603
|
+
forInit(): ForInitContext | undefined;
|
|
1604
|
+
expression(): ExpressionContext | undefined;
|
|
1605
|
+
expressionList(): ExpressionListContext | undefined;
|
|
1606
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1607
|
+
get ruleIndex(): number;
|
|
1608
|
+
enterRule(listener: JavaListener): void;
|
|
1609
|
+
exitRule(listener: JavaListener): void;
|
|
1610
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1611
|
+
}
|
|
1612
|
+
export declare class ForInitContext extends ParserRuleContext {
|
|
1613
|
+
localVariableDeclaration(): LocalVariableDeclarationContext | undefined;
|
|
1614
|
+
expressionList(): ExpressionListContext | undefined;
|
|
1615
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1616
|
+
get ruleIndex(): number;
|
|
1617
|
+
enterRule(listener: JavaListener): void;
|
|
1618
|
+
exitRule(listener: JavaListener): void;
|
|
1619
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1620
|
+
}
|
|
1621
|
+
export declare class EnhancedForControlContext extends ParserRuleContext {
|
|
1622
|
+
variableDeclaratorId(): VariableDeclaratorIdContext;
|
|
1623
|
+
COLON(): TerminalNode;
|
|
1624
|
+
expression(): ExpressionContext;
|
|
1625
|
+
typeType(): TypeTypeContext | undefined;
|
|
1626
|
+
VAR(): TerminalNode | undefined;
|
|
1627
|
+
variableModifier(): VariableModifierContext[];
|
|
1628
|
+
variableModifier(i: number): VariableModifierContext;
|
|
1629
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1630
|
+
get ruleIndex(): number;
|
|
1631
|
+
enterRule(listener: JavaListener): void;
|
|
1632
|
+
exitRule(listener: JavaListener): void;
|
|
1633
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1634
|
+
}
|
|
1635
|
+
export declare class ParExpressionContext extends ParserRuleContext {
|
|
1636
|
+
LPAREN(): TerminalNode;
|
|
1637
|
+
expression(): ExpressionContext;
|
|
1638
|
+
RPAREN(): TerminalNode;
|
|
1639
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1640
|
+
get ruleIndex(): number;
|
|
1641
|
+
enterRule(listener: JavaListener): void;
|
|
1642
|
+
exitRule(listener: JavaListener): void;
|
|
1643
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1644
|
+
}
|
|
1645
|
+
export declare class ExpressionListContext extends ParserRuleContext {
|
|
1646
|
+
expression(): ExpressionContext[];
|
|
1647
|
+
expression(i: number): ExpressionContext;
|
|
1648
|
+
COMMA(): TerminalNode[];
|
|
1649
|
+
COMMA(i: number): TerminalNode;
|
|
1650
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1651
|
+
get ruleIndex(): number;
|
|
1652
|
+
enterRule(listener: JavaListener): void;
|
|
1653
|
+
exitRule(listener: JavaListener): void;
|
|
1654
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1655
|
+
}
|
|
1656
|
+
export declare class MethodCallContext extends ParserRuleContext {
|
|
1657
|
+
identifier(): IdentifierContext | undefined;
|
|
1658
|
+
LPAREN(): TerminalNode;
|
|
1659
|
+
RPAREN(): TerminalNode;
|
|
1660
|
+
expressionList(): ExpressionListContext | undefined;
|
|
1661
|
+
THIS(): TerminalNode | undefined;
|
|
1662
|
+
SUPER(): TerminalNode | undefined;
|
|
1663
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1664
|
+
get ruleIndex(): number;
|
|
1665
|
+
enterRule(listener: JavaListener): void;
|
|
1666
|
+
exitRule(listener: JavaListener): void;
|
|
1667
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1668
|
+
}
|
|
1669
|
+
export declare class ExpressionContext extends ParserRuleContext {
|
|
1670
|
+
_prefix: Token;
|
|
1671
|
+
_bop: Token;
|
|
1672
|
+
_postfix: Token;
|
|
1673
|
+
primary(): PrimaryContext | undefined;
|
|
1674
|
+
expression(): ExpressionContext[];
|
|
1675
|
+
expression(i: number): ExpressionContext;
|
|
1676
|
+
DOT(): TerminalNode | undefined;
|
|
1677
|
+
identifier(): IdentifierContext | undefined;
|
|
1678
|
+
methodCall(): MethodCallContext | undefined;
|
|
1679
|
+
THIS(): TerminalNode | undefined;
|
|
1680
|
+
NEW(): TerminalNode | undefined;
|
|
1681
|
+
innerCreator(): InnerCreatorContext | undefined;
|
|
1682
|
+
SUPER(): TerminalNode | undefined;
|
|
1683
|
+
superSuffix(): SuperSuffixContext | undefined;
|
|
1684
|
+
explicitGenericInvocation(): ExplicitGenericInvocationContext | undefined;
|
|
1685
|
+
nonWildcardTypeArguments(): NonWildcardTypeArgumentsContext | undefined;
|
|
1686
|
+
LBRACK(): TerminalNode | undefined;
|
|
1687
|
+
RBRACK(): TerminalNode | undefined;
|
|
1688
|
+
creator(): CreatorContext | undefined;
|
|
1689
|
+
LPAREN(): TerminalNode | undefined;
|
|
1690
|
+
typeType(): TypeTypeContext[];
|
|
1691
|
+
typeType(i: number): TypeTypeContext;
|
|
1692
|
+
RPAREN(): TerminalNode | undefined;
|
|
1693
|
+
annotation(): AnnotationContext[];
|
|
1694
|
+
annotation(i: number): AnnotationContext;
|
|
1695
|
+
BITAND(): TerminalNode[];
|
|
1696
|
+
BITAND(i: number): TerminalNode;
|
|
1697
|
+
INC(): TerminalNode | undefined;
|
|
1698
|
+
DEC(): TerminalNode | undefined;
|
|
1699
|
+
ADD(): TerminalNode | undefined;
|
|
1700
|
+
SUB(): TerminalNode | undefined;
|
|
1701
|
+
TILDE(): TerminalNode | undefined;
|
|
1702
|
+
BANG(): TerminalNode | undefined;
|
|
1703
|
+
MUL(): TerminalNode | undefined;
|
|
1704
|
+
DIV(): TerminalNode | undefined;
|
|
1705
|
+
MOD(): TerminalNode | undefined;
|
|
1706
|
+
LT(): TerminalNode[];
|
|
1707
|
+
LT(i: number): TerminalNode;
|
|
1708
|
+
GT(): TerminalNode[];
|
|
1709
|
+
GT(i: number): TerminalNode;
|
|
1710
|
+
LE(): TerminalNode | undefined;
|
|
1711
|
+
GE(): TerminalNode | undefined;
|
|
1712
|
+
INSTANCEOF(): TerminalNode | undefined;
|
|
1713
|
+
pattern(): PatternContext | undefined;
|
|
1714
|
+
EQUAL(): TerminalNode | undefined;
|
|
1715
|
+
NOTEQUAL(): TerminalNode | undefined;
|
|
1716
|
+
CARET(): TerminalNode | undefined;
|
|
1717
|
+
BITOR(): TerminalNode | undefined;
|
|
1718
|
+
AND(): TerminalNode | undefined;
|
|
1719
|
+
OR(): TerminalNode | undefined;
|
|
1720
|
+
COLON(): TerminalNode | undefined;
|
|
1721
|
+
QUESTION(): TerminalNode | undefined;
|
|
1722
|
+
ASSIGN(): TerminalNode | undefined;
|
|
1723
|
+
ADD_ASSIGN(): TerminalNode | undefined;
|
|
1724
|
+
SUB_ASSIGN(): TerminalNode | undefined;
|
|
1725
|
+
MUL_ASSIGN(): TerminalNode | undefined;
|
|
1726
|
+
DIV_ASSIGN(): TerminalNode | undefined;
|
|
1727
|
+
AND_ASSIGN(): TerminalNode | undefined;
|
|
1728
|
+
OR_ASSIGN(): TerminalNode | undefined;
|
|
1729
|
+
XOR_ASSIGN(): TerminalNode | undefined;
|
|
1730
|
+
RSHIFT_ASSIGN(): TerminalNode | undefined;
|
|
1731
|
+
URSHIFT_ASSIGN(): TerminalNode | undefined;
|
|
1732
|
+
LSHIFT_ASSIGN(): TerminalNode | undefined;
|
|
1733
|
+
MOD_ASSIGN(): TerminalNode | undefined;
|
|
1734
|
+
lambdaExpression(): LambdaExpressionContext | undefined;
|
|
1735
|
+
switchExpression(): SwitchExpressionContext | undefined;
|
|
1736
|
+
COLONCOLON(): TerminalNode | undefined;
|
|
1737
|
+
typeArguments(): TypeArgumentsContext | undefined;
|
|
1738
|
+
classType(): ClassTypeContext | undefined;
|
|
1739
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1740
|
+
get ruleIndex(): number;
|
|
1741
|
+
enterRule(listener: JavaListener): void;
|
|
1742
|
+
exitRule(listener: JavaListener): void;
|
|
1743
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1744
|
+
}
|
|
1745
|
+
export declare class PatternContext extends ParserRuleContext {
|
|
1746
|
+
typeType(): TypeTypeContext;
|
|
1747
|
+
identifier(): IdentifierContext;
|
|
1748
|
+
variableModifier(): VariableModifierContext[];
|
|
1749
|
+
variableModifier(i: number): VariableModifierContext;
|
|
1750
|
+
annotation(): AnnotationContext[];
|
|
1751
|
+
annotation(i: number): AnnotationContext;
|
|
1752
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1753
|
+
get ruleIndex(): number;
|
|
1754
|
+
enterRule(listener: JavaListener): void;
|
|
1755
|
+
exitRule(listener: JavaListener): void;
|
|
1756
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1757
|
+
}
|
|
1758
|
+
export declare class LambdaExpressionContext extends ParserRuleContext {
|
|
1759
|
+
lambdaParameters(): LambdaParametersContext;
|
|
1760
|
+
ARROW(): TerminalNode;
|
|
1761
|
+
lambdaBody(): LambdaBodyContext;
|
|
1762
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1763
|
+
get ruleIndex(): number;
|
|
1764
|
+
enterRule(listener: JavaListener): void;
|
|
1765
|
+
exitRule(listener: JavaListener): void;
|
|
1766
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1767
|
+
}
|
|
1768
|
+
export declare class LambdaParametersContext extends ParserRuleContext {
|
|
1769
|
+
identifier(): IdentifierContext[];
|
|
1770
|
+
identifier(i: number): IdentifierContext;
|
|
1771
|
+
LPAREN(): TerminalNode | undefined;
|
|
1772
|
+
RPAREN(): TerminalNode | undefined;
|
|
1773
|
+
formalParameterList(): FormalParameterListContext | undefined;
|
|
1774
|
+
COMMA(): TerminalNode[];
|
|
1775
|
+
COMMA(i: number): TerminalNode;
|
|
1776
|
+
lambdaLVTIList(): LambdaLVTIListContext | undefined;
|
|
1777
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1778
|
+
get ruleIndex(): number;
|
|
1779
|
+
enterRule(listener: JavaListener): void;
|
|
1780
|
+
exitRule(listener: JavaListener): void;
|
|
1781
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1782
|
+
}
|
|
1783
|
+
export declare class LambdaBodyContext extends ParserRuleContext {
|
|
1784
|
+
expression(): ExpressionContext | undefined;
|
|
1785
|
+
block(): BlockContext | undefined;
|
|
1786
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1787
|
+
get ruleIndex(): number;
|
|
1788
|
+
enterRule(listener: JavaListener): void;
|
|
1789
|
+
exitRule(listener: JavaListener): void;
|
|
1790
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1791
|
+
}
|
|
1792
|
+
export declare class PrimaryContext extends ParserRuleContext {
|
|
1793
|
+
LPAREN(): TerminalNode | undefined;
|
|
1794
|
+
expression(): ExpressionContext | undefined;
|
|
1795
|
+
RPAREN(): TerminalNode | undefined;
|
|
1796
|
+
THIS(): TerminalNode | undefined;
|
|
1797
|
+
SUPER(): TerminalNode | undefined;
|
|
1798
|
+
literal(): LiteralContext | undefined;
|
|
1799
|
+
identifier(): IdentifierContext | undefined;
|
|
1800
|
+
typeTypeOrVoid(): TypeTypeOrVoidContext | undefined;
|
|
1801
|
+
DOT(): TerminalNode | undefined;
|
|
1802
|
+
CLASS(): TerminalNode | undefined;
|
|
1803
|
+
nonWildcardTypeArguments(): NonWildcardTypeArgumentsContext | undefined;
|
|
1804
|
+
explicitGenericInvocationSuffix(): ExplicitGenericInvocationSuffixContext | undefined;
|
|
1805
|
+
arguments(): ArgumentsContext | undefined;
|
|
1806
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1807
|
+
get ruleIndex(): number;
|
|
1808
|
+
enterRule(listener: JavaListener): void;
|
|
1809
|
+
exitRule(listener: JavaListener): void;
|
|
1810
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1811
|
+
}
|
|
1812
|
+
export declare class SwitchExpressionContext extends ParserRuleContext {
|
|
1813
|
+
SWITCH(): TerminalNode;
|
|
1814
|
+
parExpression(): ParExpressionContext;
|
|
1815
|
+
LBRACE(): TerminalNode;
|
|
1816
|
+
RBRACE(): TerminalNode;
|
|
1817
|
+
switchLabeledRule(): SwitchLabeledRuleContext[];
|
|
1818
|
+
switchLabeledRule(i: number): SwitchLabeledRuleContext;
|
|
1819
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1820
|
+
get ruleIndex(): number;
|
|
1821
|
+
enterRule(listener: JavaListener): void;
|
|
1822
|
+
exitRule(listener: JavaListener): void;
|
|
1823
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1824
|
+
}
|
|
1825
|
+
export declare class SwitchLabeledRuleContext extends ParserRuleContext {
|
|
1826
|
+
CASE(): TerminalNode | undefined;
|
|
1827
|
+
switchRuleOutcome(): SwitchRuleOutcomeContext;
|
|
1828
|
+
ARROW(): TerminalNode | undefined;
|
|
1829
|
+
COLON(): TerminalNode | undefined;
|
|
1830
|
+
expressionList(): ExpressionListContext | undefined;
|
|
1831
|
+
NULL_LITERAL(): TerminalNode | undefined;
|
|
1832
|
+
guardedPattern(): GuardedPatternContext | undefined;
|
|
1833
|
+
DEFAULT(): TerminalNode | undefined;
|
|
1834
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1835
|
+
get ruleIndex(): number;
|
|
1836
|
+
enterRule(listener: JavaListener): void;
|
|
1837
|
+
exitRule(listener: JavaListener): void;
|
|
1838
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1839
|
+
}
|
|
1840
|
+
export declare class GuardedPatternContext extends ParserRuleContext {
|
|
1841
|
+
LPAREN(): TerminalNode | undefined;
|
|
1842
|
+
guardedPattern(): GuardedPatternContext | undefined;
|
|
1843
|
+
RPAREN(): TerminalNode | undefined;
|
|
1844
|
+
typeType(): TypeTypeContext | undefined;
|
|
1845
|
+
identifier(): IdentifierContext | undefined;
|
|
1846
|
+
variableModifier(): VariableModifierContext[];
|
|
1847
|
+
variableModifier(i: number): VariableModifierContext;
|
|
1848
|
+
annotation(): AnnotationContext[];
|
|
1849
|
+
annotation(i: number): AnnotationContext;
|
|
1850
|
+
AND(): TerminalNode[];
|
|
1851
|
+
AND(i: number): TerminalNode;
|
|
1852
|
+
expression(): ExpressionContext[];
|
|
1853
|
+
expression(i: number): ExpressionContext;
|
|
1854
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1855
|
+
get ruleIndex(): number;
|
|
1856
|
+
enterRule(listener: JavaListener): void;
|
|
1857
|
+
exitRule(listener: JavaListener): void;
|
|
1858
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1859
|
+
}
|
|
1860
|
+
export declare class SwitchRuleOutcomeContext extends ParserRuleContext {
|
|
1861
|
+
block(): BlockContext | undefined;
|
|
1862
|
+
blockStatement(): BlockStatementContext[];
|
|
1863
|
+
blockStatement(i: number): BlockStatementContext;
|
|
1864
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1865
|
+
get ruleIndex(): number;
|
|
1866
|
+
enterRule(listener: JavaListener): void;
|
|
1867
|
+
exitRule(listener: JavaListener): void;
|
|
1868
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1869
|
+
}
|
|
1870
|
+
export declare class ClassTypeContext extends ParserRuleContext {
|
|
1871
|
+
identifier(): IdentifierContext;
|
|
1872
|
+
classOrInterfaceType(): ClassOrInterfaceTypeContext | undefined;
|
|
1873
|
+
DOT(): TerminalNode | undefined;
|
|
1874
|
+
annotation(): AnnotationContext[];
|
|
1875
|
+
annotation(i: number): AnnotationContext;
|
|
1876
|
+
typeArguments(): TypeArgumentsContext | undefined;
|
|
1877
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1878
|
+
get ruleIndex(): number;
|
|
1879
|
+
enterRule(listener: JavaListener): void;
|
|
1880
|
+
exitRule(listener: JavaListener): void;
|
|
1881
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1882
|
+
}
|
|
1883
|
+
export declare class CreatorContext extends ParserRuleContext {
|
|
1884
|
+
nonWildcardTypeArguments(): NonWildcardTypeArgumentsContext | undefined;
|
|
1885
|
+
createdName(): CreatedNameContext;
|
|
1886
|
+
classCreatorRest(): ClassCreatorRestContext | undefined;
|
|
1887
|
+
arrayCreatorRest(): ArrayCreatorRestContext | undefined;
|
|
1888
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1889
|
+
get ruleIndex(): number;
|
|
1890
|
+
enterRule(listener: JavaListener): void;
|
|
1891
|
+
exitRule(listener: JavaListener): void;
|
|
1892
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1893
|
+
}
|
|
1894
|
+
export declare class CreatedNameContext extends ParserRuleContext {
|
|
1895
|
+
identifier(): IdentifierContext[];
|
|
1896
|
+
identifier(i: number): IdentifierContext;
|
|
1897
|
+
typeArgumentsOrDiamond(): TypeArgumentsOrDiamondContext[];
|
|
1898
|
+
typeArgumentsOrDiamond(i: number): TypeArgumentsOrDiamondContext;
|
|
1899
|
+
DOT(): TerminalNode[];
|
|
1900
|
+
DOT(i: number): TerminalNode;
|
|
1901
|
+
primitiveType(): PrimitiveTypeContext | undefined;
|
|
1902
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1903
|
+
get ruleIndex(): number;
|
|
1904
|
+
enterRule(listener: JavaListener): void;
|
|
1905
|
+
exitRule(listener: JavaListener): void;
|
|
1906
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1907
|
+
}
|
|
1908
|
+
export declare class InnerCreatorContext extends ParserRuleContext {
|
|
1909
|
+
identifier(): IdentifierContext;
|
|
1910
|
+
classCreatorRest(): ClassCreatorRestContext;
|
|
1911
|
+
nonWildcardTypeArgumentsOrDiamond(): NonWildcardTypeArgumentsOrDiamondContext | undefined;
|
|
1912
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1913
|
+
get ruleIndex(): number;
|
|
1914
|
+
enterRule(listener: JavaListener): void;
|
|
1915
|
+
exitRule(listener: JavaListener): void;
|
|
1916
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1917
|
+
}
|
|
1918
|
+
export declare class ArrayCreatorRestContext extends ParserRuleContext {
|
|
1919
|
+
LBRACK(): TerminalNode[];
|
|
1920
|
+
LBRACK(i: number): TerminalNode;
|
|
1921
|
+
RBRACK(): TerminalNode[];
|
|
1922
|
+
RBRACK(i: number): TerminalNode;
|
|
1923
|
+
arrayInitializer(): ArrayInitializerContext | undefined;
|
|
1924
|
+
expression(): ExpressionContext[];
|
|
1925
|
+
expression(i: number): ExpressionContext;
|
|
1926
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1927
|
+
get ruleIndex(): number;
|
|
1928
|
+
enterRule(listener: JavaListener): void;
|
|
1929
|
+
exitRule(listener: JavaListener): void;
|
|
1930
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1931
|
+
}
|
|
1932
|
+
export declare class ClassCreatorRestContext extends ParserRuleContext {
|
|
1933
|
+
arguments(): ArgumentsContext;
|
|
1934
|
+
classBody(): ClassBodyContext | undefined;
|
|
1935
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1936
|
+
get ruleIndex(): number;
|
|
1937
|
+
enterRule(listener: JavaListener): void;
|
|
1938
|
+
exitRule(listener: JavaListener): void;
|
|
1939
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1940
|
+
}
|
|
1941
|
+
export declare class ExplicitGenericInvocationContext extends ParserRuleContext {
|
|
1942
|
+
nonWildcardTypeArguments(): NonWildcardTypeArgumentsContext;
|
|
1943
|
+
explicitGenericInvocationSuffix(): ExplicitGenericInvocationSuffixContext;
|
|
1944
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1945
|
+
get ruleIndex(): number;
|
|
1946
|
+
enterRule(listener: JavaListener): void;
|
|
1947
|
+
exitRule(listener: JavaListener): void;
|
|
1948
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1949
|
+
}
|
|
1950
|
+
export declare class TypeArgumentsOrDiamondContext extends ParserRuleContext {
|
|
1951
|
+
LT(): TerminalNode | undefined;
|
|
1952
|
+
GT(): TerminalNode | undefined;
|
|
1953
|
+
typeArguments(): TypeArgumentsContext | undefined;
|
|
1954
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1955
|
+
get ruleIndex(): number;
|
|
1956
|
+
enterRule(listener: JavaListener): void;
|
|
1957
|
+
exitRule(listener: JavaListener): void;
|
|
1958
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1959
|
+
}
|
|
1960
|
+
export declare class NonWildcardTypeArgumentsOrDiamondContext extends ParserRuleContext {
|
|
1961
|
+
LT(): TerminalNode | undefined;
|
|
1962
|
+
GT(): TerminalNode | undefined;
|
|
1963
|
+
nonWildcardTypeArguments(): NonWildcardTypeArgumentsContext | undefined;
|
|
1964
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1965
|
+
get ruleIndex(): number;
|
|
1966
|
+
enterRule(listener: JavaListener): void;
|
|
1967
|
+
exitRule(listener: JavaListener): void;
|
|
1968
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1969
|
+
}
|
|
1970
|
+
export declare class NonWildcardTypeArgumentsContext extends ParserRuleContext {
|
|
1971
|
+
LT(): TerminalNode;
|
|
1972
|
+
typeList(): TypeListContext;
|
|
1973
|
+
GT(): TerminalNode;
|
|
1974
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1975
|
+
get ruleIndex(): number;
|
|
1976
|
+
enterRule(listener: JavaListener): void;
|
|
1977
|
+
exitRule(listener: JavaListener): void;
|
|
1978
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1979
|
+
}
|
|
1980
|
+
export declare class TypeListContext extends ParserRuleContext {
|
|
1981
|
+
typeType(): TypeTypeContext[];
|
|
1982
|
+
typeType(i: number): TypeTypeContext;
|
|
1983
|
+
COMMA(): TerminalNode[];
|
|
1984
|
+
COMMA(i: number): TerminalNode;
|
|
1985
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
1986
|
+
get ruleIndex(): number;
|
|
1987
|
+
enterRule(listener: JavaListener): void;
|
|
1988
|
+
exitRule(listener: JavaListener): void;
|
|
1989
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
1990
|
+
}
|
|
1991
|
+
export declare class TypeTypeContext extends ParserRuleContext {
|
|
1992
|
+
classOrInterfaceType(): ClassOrInterfaceTypeContext | undefined;
|
|
1993
|
+
primitiveType(): PrimitiveTypeContext | undefined;
|
|
1994
|
+
annotation(): AnnotationContext[];
|
|
1995
|
+
annotation(i: number): AnnotationContext;
|
|
1996
|
+
LBRACK(): TerminalNode[];
|
|
1997
|
+
LBRACK(i: number): TerminalNode;
|
|
1998
|
+
RBRACK(): TerminalNode[];
|
|
1999
|
+
RBRACK(i: number): TerminalNode;
|
|
2000
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
2001
|
+
get ruleIndex(): number;
|
|
2002
|
+
enterRule(listener: JavaListener): void;
|
|
2003
|
+
exitRule(listener: JavaListener): void;
|
|
2004
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
2005
|
+
}
|
|
2006
|
+
export declare class PrimitiveTypeContext extends ParserRuleContext {
|
|
2007
|
+
BOOLEAN(): TerminalNode | undefined;
|
|
2008
|
+
CHAR(): TerminalNode | undefined;
|
|
2009
|
+
BYTE(): TerminalNode | undefined;
|
|
2010
|
+
SHORT(): TerminalNode | undefined;
|
|
2011
|
+
INT(): TerminalNode | undefined;
|
|
2012
|
+
LONG(): TerminalNode | undefined;
|
|
2013
|
+
FLOAT(): TerminalNode | undefined;
|
|
2014
|
+
DOUBLE(): TerminalNode | undefined;
|
|
2015
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
2016
|
+
get ruleIndex(): number;
|
|
2017
|
+
enterRule(listener: JavaListener): void;
|
|
2018
|
+
exitRule(listener: JavaListener): void;
|
|
2019
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
2020
|
+
}
|
|
2021
|
+
export declare class TypeArgumentsContext extends ParserRuleContext {
|
|
2022
|
+
LT(): TerminalNode;
|
|
2023
|
+
typeArgument(): TypeArgumentContext[];
|
|
2024
|
+
typeArgument(i: number): TypeArgumentContext;
|
|
2025
|
+
GT(): TerminalNode;
|
|
2026
|
+
COMMA(): TerminalNode[];
|
|
2027
|
+
COMMA(i: number): TerminalNode;
|
|
2028
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
2029
|
+
get ruleIndex(): number;
|
|
2030
|
+
enterRule(listener: JavaListener): void;
|
|
2031
|
+
exitRule(listener: JavaListener): void;
|
|
2032
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
2033
|
+
}
|
|
2034
|
+
export declare class SuperSuffixContext extends ParserRuleContext {
|
|
2035
|
+
arguments(): ArgumentsContext | undefined;
|
|
2036
|
+
DOT(): TerminalNode | undefined;
|
|
2037
|
+
identifier(): IdentifierContext | undefined;
|
|
2038
|
+
typeArguments(): TypeArgumentsContext | undefined;
|
|
2039
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
2040
|
+
get ruleIndex(): number;
|
|
2041
|
+
enterRule(listener: JavaListener): void;
|
|
2042
|
+
exitRule(listener: JavaListener): void;
|
|
2043
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
2044
|
+
}
|
|
2045
|
+
export declare class ExplicitGenericInvocationSuffixContext extends ParserRuleContext {
|
|
2046
|
+
SUPER(): TerminalNode | undefined;
|
|
2047
|
+
superSuffix(): SuperSuffixContext | undefined;
|
|
2048
|
+
identifier(): IdentifierContext | undefined;
|
|
2049
|
+
arguments(): ArgumentsContext | undefined;
|
|
2050
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
2051
|
+
get ruleIndex(): number;
|
|
2052
|
+
enterRule(listener: JavaListener): void;
|
|
2053
|
+
exitRule(listener: JavaListener): void;
|
|
2054
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
2055
|
+
}
|
|
2056
|
+
export declare class ArgumentsContext extends ParserRuleContext {
|
|
2057
|
+
LPAREN(): TerminalNode;
|
|
2058
|
+
RPAREN(): TerminalNode;
|
|
2059
|
+
expressionList(): ExpressionListContext | undefined;
|
|
2060
|
+
constructor(parent: ParserRuleContext | undefined, invokingState: number);
|
|
2061
|
+
get ruleIndex(): number;
|
|
2062
|
+
enterRule(listener: JavaListener): void;
|
|
2063
|
+
exitRule(listener: JavaListener): void;
|
|
2064
|
+
accept<Result>(visitor: JavaVisitor<Result>): Result;
|
|
2065
|
+
}
|